Add batch transcription in voice agent

Author: VyasGuru

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/RAG/ViewModels/RAGViewModel.swift

@@ -19,6 +19,50 @@ enum MessageRole {
     case system
 }
 
+// MARK: - RAG Message
+
+struct RAGMessage: Identifiable {
+    let id = UUID()
+    let role: MessageRole
+    let text: String
+    let thinkingContent: String?
+
+    init(role: MessageRole, text: String, thinkingContent: String? = nil) {
+        self.role = role
+        self.text = text
+        self.thinkingContent = thinkingContent
+    }
+
+    // MARK: - Think Tag Helpers
+
+    /// Extract the content inside `<think>...</think>` tags.
+    static func extractThinkingContent(from text: String) -> String? {
+        guard let startRange = text.range(of: "<think>"),
+              let endRange = text.range(of: "</think>"),
+              startRange.upperBound <= endRange.lowerBound else {
+            return nil
+        }
+        let content = String(text[startRange.upperBound..<endRange.lowerBound])
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        return content.isEmpty ? nil : content
+    }
+
+    /// Strip all `<think>...</think>` blocks and trailing incomplete `<think>` tags.
+    static func stripThinkTags(from text: String) -> String {
+        var result = text
+        while let startRange = result.range(of: "<think>"),
+              let endRange = result.range(of: "</think>"),
+              startRange.upperBound <= endRange.lowerBound {
+            result.removeSubrange(startRange.lowerBound..<endRange.upperBound)
+        }
+        if let trailingStart = result.range(of: "<think>", options: .backwards),
+           result.range(of: "</think>", range: trailingStart.upperBound..<result.endIndex) == nil {
+            result = String(result[result.startIndex..<trailingStart.lowerBound])
+        }
+        return result.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
+
 // MARK: - RAG View Model
 
 @MainActor
@@ -33,7 +77,7 @@ final class RAGViewModel {
 
     // MARK: - Query State
 
-    private(set) var messages: [(role: MessageRole, text: String)] = []
+    private(set) var messages: [RAGMessage] = []
     private(set) var isQuerying = false
     /// Settable from the view layer to surface file-picker failures in the error banner.
     var error: Error?
@@ -97,7 +141,7 @@ final class RAGViewModel {
         guard !question.isEmpty else { return }
         guard isDocumentLoaded else { return }
 
-        messages.append((role: .user, text: question))
+        messages.append(RAGMessage(role: .user, text: question))
         currentQuestion = ""
         isQuerying = true
         error = nil
@@ -117,11 +161,13 @@ final class RAGViewModel {
 
             logger.info("Querying RAG pipeline: \(question)")
             let result = try await RunAnywhere.ragQuery(question: effectiveQuestion)
-            messages.append((role: .assistant, text: result.answer))
+            let thinkingContent = RAGMessage.extractThinkingContent(from: result.answer)
+            let displayText = RAGMessage.stripThinkTags(from: result.answer)
+            messages.append(RAGMessage(role: .assistant, text: displayText, thinkingContent: thinkingContent))
             logger.info("Query complete (\(result.totalTimeMs, format: .fixed(precision: 0))ms)")
         } catch {
             self.error = error
-            messages.append((role: .assistant, text: "Error: \(error.localizedDescription)"))
+            messages.append(RAGMessage(role: .assistant, text: "Error: \(error.localizedDescription)"))
             logger.error("Query failed: \(error.localizedDescription)")
         }
     }

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/RAG/Views/DocumentRAGView.swift

@@ -384,9 +384,9 @@ extension DocumentRAGView {
             Spacer(minLength: AppSpacing.large)
                 .id("top-spacer")
 
-            ForEach(Array(viewModel.messages.enumerated()), id: \.offset) { index, message in
+            ForEach(viewModel.messages) { message in
                 RAGMessageBubble(message: message)
-                    .id(index)
+                    .id(message.id)
             }
 
             if viewModel.isQuerying {
@@ -412,8 +412,8 @@ extension DocumentRAGView {
         withAnimation(.easeInOut(duration: AppLayout.animationFast)) {
             if viewModel.isQuerying {
                 proxy.scrollTo("querying", anchor: .bottom)
-            } else if !viewModel.messages.isEmpty {
-                proxy.scrollTo(viewModel.messages.count - 1, anchor: .bottom)
+            } else if let lastMessage = viewModel.messages.last {
+                proxy.scrollTo(lastMessage.id, anchor: .bottom)
             }
         }
     }
@@ -503,31 +503,143 @@ extension DocumentRAGView {
 // MARK: - RAG Message Bubble
 
 private struct RAGMessageBubble: View {
-    let message: (role: MessageRole, text: String)
+    let message: RAGMessage
+    @State private var isThinkingExpanded = false
 
     private var isUser: Bool {
         message.role == .user
     }
 
+    private var hasThinking: Bool {
+        message.thinkingContent != nil && !(message.thinkingContent?.isEmpty ?? true)
+    }
+
     var body: some View {
         HStack(alignment: .bottom, spacing: AppSpacing.smallMedium) {
             if isUser { Spacer(minLength: AppSpacing.xxxLarge) }
 
-            Text(message.text)
-                .font(.body)
-                .foregroundColor(isUser ? .white : AppColors.textPrimary)
-                .padding(.horizontal, AppSpacing.mediumLarge)
-                .padding(.vertical, AppSpacing.smallMedium)
+            VStack(alignment: .leading, spacing: 4) {
+                if !isUser && hasThinking {
+                    thinkingSection
+                }
+
+                Text(message.text)
+                    .font(.body)
+                    .foregroundColor(isUser ? .white : AppColors.textPrimary)
+                    .padding(.horizontal, AppSpacing.mediumLarge)
+                    .padding(.vertical, AppSpacing.smallMedium)
+                    .background(
+                        isUser
+                            ? AppColors.messageBubbleUser
+                            : AppColors.messageBubbleAssistant
+                    )
+                    .cornerRadius(AppSpacing.cornerRadiusBubble)
+            }
+
+            if !isUser { Spacer(minLength: AppSpacing.xxxLarge) }
+        }
+    }
+
+    // MARK: - Thinking Section
+
+    private var thinkingSection: some View {
+        VStack(alignment: .leading, spacing: AppSpacing.small) {
+            Button {
+                withAnimation(.easeInOut(duration: AppLayout.animationFast)) {
+                    isThinkingExpanded.toggle()
+                }
+            } label: {
+                HStack(spacing: 8) {
+                    Image(systemName: "lightbulb.min")
+                        .font(AppTypography.caption)
+                        .foregroundColor(AppColors.primaryPurple)
+
+                    Text(isThinkingExpanded ? "Hide reasoning" : thinkingSummary)
+                        .font(AppTypography.caption)
+                        .foregroundColor(AppColors.primaryPurple)
+                        .lineLimit(1)
+
+                    Spacer()
+
+                    Image(systemName: isThinkingExpanded ? "chevron.up" : "chevron.right")
+                        .font(AppTypography.caption2)
+                        .foregroundColor(AppColors.primaryPurple.opacity(0.6))
+                }
+                .padding(.horizontal, AppSpacing.regular)
+                .padding(.vertical, AppSpacing.padding9)
                 .background(
-                    isUser
-                        ? AppColors.messageBubbleUser
-                        : AppColors.messageBubbleAssistant
+                    RoundedRectangle(cornerRadius: AppSpacing.mediumLarge)
+                        .fill(
+                            LinearGradient(
+                                colors: [
+                                    AppColors.primaryPurple.opacity(0.1),
+                                    AppColors.primaryPurple.opacity(0.05)
+                                ],
+                                startPoint: .topLeading,
+                                endPoint: .bottomTrailing
+                            )
+                        )
+                        .shadow(color: AppColors.primaryPurple.opacity(0.2), radius: 2, x: 0, y: 1)
+                        .overlay(
+                            RoundedRectangle(cornerRadius: AppSpacing.mediumLarge)
+                                .strokeBorder(
+                                    AppColors.primaryPurple.opacity(0.2),
+                                    lineWidth: AppSpacing.strokeThin
+                                )
+                        )
                 )
-                .cornerRadius(AppSpacing.cornerRadiusBubble)
+            }
+            .buttonStyle(PlainButtonStyle())
 
-            if !isUser { Spacer(minLength: AppSpacing.xxxLarge) }
+            if isThinkingExpanded {
+                ScrollView {
+                    Text(message.thinkingContent ?? "")
+                        .font(AppTypography.caption)
+                        .foregroundColor(AppColors.textSecondary)
+                        .frame(maxWidth: .infinity, alignment: .leading)
+                        .fixedSize(horizontal: false, vertical: true)
+                        .multilineTextAlignment(.leading)
+                }
+                .frame(maxHeight: AppSpacing.minFrameHeight)
+                .padding(AppSpacing.mediumLarge)
+                .background(
+                    RoundedRectangle(cornerRadius: AppSpacing.medium)
+                        .fill(AppColors.backgroundGray6)
+                )
+                .transition(.asymmetric(
+                    insertion: .opacity.combined(with: .slide),
+                    removal: .opacity.combined(with: .slide)
+                ))
+            }
         }
     }
+
+    private var thinkingSummary: String {
+        guard let thinking = message.thinkingContent?
+            .trimmingCharacters(in: .whitespacesAndNewlines) else {
+            return ""
+        }
+
+        let sentences = thinking.components(separatedBy: CharacterSet(charactersIn: ".!?"))
+            .filter { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
+
+        if sentences.count >= 2 {
+            let firstSentence = sentences[0].trimmingCharacters(in: .whitespacesAndNewlines)
+            if firstSentence.count > 20 {
+                return firstSentence + "..."
+            }
+        }
+
+        if thinking.count > 80 {
+            let truncated = String(thinking.prefix(80))
+            if let lastSpace = truncated.lastIndex(of: " ") {
+                return String(truncated[..<lastSpace]) + "..."
+            }
+            return truncated + "..."
+        }
+
+        return thinking
+    }
 }
 
 

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Settings/SettingsViewModel.swift

@@ -10,6 +10,7 @@ import Foundation
 import SwiftUI
 import RunAnywhere
 import Combine
+import os
 
 @MainActor
 class SettingsViewModel: ObservableObject {
@@ -45,6 +46,7 @@ class SettingsViewModel: ObservableObject {
 
     // MARK: - Private Properties
 
+    private let logger = Logger(subsystem: "com.runanywhere.RunAnywhereAI", category: "Settings")
     private var cancellables = Set<AnyCancellable>()
     private let keychainService = KeychainService.shared
     private let apiKeyStorageKey = "runanywhere_api_key"
@@ -99,32 +101,34 @@ class SettingsViewModel: ObservableObject {
     }
 
     private func subscribeToModelNotifications() {
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(handleModelLoaded(_:)),
-            name: Notification.Name("ModelLoaded"),
-            object: nil
-        )
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(handleModelUnloaded),
-            name: Notification.Name("ModelUnloaded"),
-            object: nil
-        )
-    }
-
-    @objc private func handleModelLoaded(_ notification: Notification) {
-        if let model = notification.object as? ModelInfo {
-            loadedModelSupportsThinking = model.supportsThinking
-        }
+        // Subscribe to SDK events directly so any LLM model load
+        // (from chat, voice agent, or RAG) updates the thinking mode flag.
+        RunAnywhere.events.events
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] event in
+                Task { @MainActor in
+                    self?.handleSDKEvent(event)
+                }
+            }
+            .store(in: &cancellables)
     }
 
-    @objc private func handleModelUnloaded() {
-        loadedModelSupportsThinking = false
-    }
+    private func handleSDKEvent(_ event: any SDKEvent) {
+        guard event.category == .llm else { return }
 
-    deinit {
-        NotificationCenter.default.removeObserver(self)
+        switch event.type {
+        case "llm_model_load_completed":
+            let modelId = event.properties["model_id"] ?? ""
+            if let model = ModelListViewModel.shared.availableModels.first(where: { $0.id == modelId }) {
+                loadedModelSupportsThinking = model.supportsThinking
+                logger.info("LLM loaded (\(modelId)), supportsThinking: \(model.supportsThinking)")
+            }
+        case "llm_model_unloaded":
+            loadedModelSupportsThinking = false
+            logger.info("LLM unloaded, thinking mode disabled")
+        default:
+            break
+        }
     }
 
     // MARK: - Setup

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Voice/VoiceAgentViewModel.swift

@@ -150,13 +150,15 @@ final class VoiceAgentViewModel: ObservableObject {
     var instructionText: String {
         switch sessionState {
         case .listening:
-            return "Listening... Pause to send"
+            return "Tap to send · Hold to stop"
         case .processing:
             return "Processing your message..."
         case .speaking:
             return "Speaking..."
         case .connecting:
             return "Connecting..."
+        case .connected:
+            return "Tap to speak · Hold to end"
         default:
             return "Tap to start conversation"
         }
@@ -389,6 +391,7 @@ final class VoiceAgentViewModel: ObservableObject {
         do {
             let settings = SettingsViewModel.shared
             let voiceConfig = VoiceSessionConfig(
+                continuousMode: false,
                 thinkingModeEnabled: settings.loadedModelSupportsThinking && settings.thinkingModeEnabled,
                 maxTokens: settings.maxTokens
             )
@@ -434,6 +437,14 @@ final class VoiceAgentViewModel: ObservableObject {
         logger.debug("Forced audio send")
     }
 
+    /// Resume listening on the current session (push-to-talk: user taps mic after turn completes)
+    func resumeListening() async {
+        await session?.resumeListening()
+        sessionState = .listening
+        currentStatus = "Listening..."
+        logger.debug("Resumed listening")
+    }
+
     // MARK: - Session Event Handling
 
     private func handleSessionEvent(_ event: VoiceSessionEvent) {
@@ -447,7 +458,7 @@ final class VoiceAgentViewModel: ObservableObject {
         case .speaking: sessionState = .speaking; currentStatus = "Speaking..."
         case let .turnCompleted(transcript, response, _, _):
             currentTranscript = transcript; assistantResponse = response
-            sessionState = .listening; currentStatus = "Listening..."
+            sessionState = .connected; currentStatus = "Ready"
         case .stopped: sessionState = .disconnected; currentStatus = "Ready"
         case .error(let message): logger.error("Session error: \(message)"); errorMessage = message
         }