fix: address PR #472 review comments — 31 fixes across C++ commons, Swift SDK, and iOS app

**C++ commons (`sdk/runanywhere-commons/`):**
- `tool_calling.cpp`: Add `json_value_kind_t` enum + `extract_json_array_raw` helper;
  flat-args fallback now emits numbers / booleans / null / arrays verbatim instead of
  coercing them to strings. Track the matched tool-name key so only the specific alias
  that produced `out_tool_name` is excluded from flat args (e.g. `run_shell`'s
  `command` is no longer dropped). Return `false` on `out_args_json` malloc failure
  instead of success-with-null. (QEF-1/15/16/29)
- `llamacpp_backend.cpp`: Cast `stop_window[safe_len]` to `uint8_t` before `& 0xC0`
  mask so signed-char platforms don't invoke UB on UTF-8 continuation-byte detection
  (both loops). Mirror `generate_stream`'s `partial_utf8_buffer` flush into
  `generate_from_context` so trailing multi-byte codepoints aren't silently dropped
  before the final stop_window emit. (QEF-28/31)
- `llm_component.cpp`: Special-case empty `ctx.full_text` so cancelled / no-op
  streams report `completion_tokens = 0` instead of `estimate_tokens("") = 1`.
  (QEF-26)

**Swift SDK (`sdk/runanywhere-swift/`):**
- `RunAnywhere+TextGeneration.swift`: Remove explicit
  `Unmanaged<LLMStreamCallbackContext>.release()` in the non-SUCCESS branch —
  C++ always calls `errorCallback` which consumes the retained ref via
  `takeRetainedValue()`, so the explicit release was a double-free. Drop the
  `Task.isCancelled` no-op in the C token callback (cancellation is atomic-flag
  based in `llm_component.cpp`). Approximate `thinkingTokens` proportionally by
  character ratio for both streaming and non-streaming paths instead of assigning
  the whole `outputTokens`. (QEF-4/17/27)
- `RunAnywhere+ToolCalling.swift`: Re-apply `noThinkPrefix` at the top of every
  follow-up tool-round prompt (was only preserved on the initial build), and pass
  `cleanPrompt` (not the raw `prompt`) into `buildFollowUpPrompt`. (QEF-18)
- `RunAnywhere+VoiceSession.swift`: Move `emit(.turnCompleted(...))` inside the
  `do` block so errors no longer overwrite `.error` UI state. Make
  `resumeListening()` idempotent by guarding on `audioCapture.isRecording`.
  Gate `/no_think` injection on `RunAnywhere.currentLLMModel?.supportsThinking`
  so non-thinking models don't receive a stray slash command. Only swallow
  `.playbackInterrupted`; rethrow other `AudioPlaybackError` cases so real TTS
  failures aren't hidden. (QEF-2/20/21/22)
- `RunAnywhere+VoiceAgent.swift`: Use `defer { rac_free(ptr) }` in
  `voiceAgentSynthesizeSpeech` instead of a bare `free(ptr)` — fixes both the
  native-memory leak on empty audio and the deallocator mismatch (header contract
  says use `rac_free`). (QEF-19)
- `CppBridge.swift` + `RunAnywhere.swift`: Make `CppBridge.shutdown()` and
  `RunAnywhere.reset()` `async`, and `await` each component's `destroy()`
  sequentially before `Telemetry.shutdown()` / `Events.unregister()` — removes
  the fire-and-forget `Task` that raced with synchronous teardown. (QEF-30)
- Make `ThinkingContentParser` + its `extract(from:)` public, add a canonical
  `strip(from:)` that handles multi-block + trailing-unclosed `<think>` tags so
  the app doesn't duplicate three divergent stripping implementations. (QEF-5)

**iOS example app (`examples/ios/RunAnywhereAI/`):**
- `ChatInterfaceView.swift`: Replace `@AppStorage("thinkingModeEnabled")` with
  `@ObservedObject SettingsViewModel.shared` so the badge and
  `LLMViewModel.applyThinkingModePrefix()` read/write the same `@Published`
  source. (QEF-3/7)
- `LLMViewModel.swift` + `RAGViewModel.swift`: Delegate `stripThinkTags` /
  `extractThinkingContent` to the new public SDK `ThinkingContentParser`. (QEF-5)
- `LLMViewModel+ToolCalling.swift`: Extend `updateMessageWithToolResult(...)`
  with `thinkingContent:` and wire SDK-provided thinking content through so the
  tool-call path no longer silently drops it. (QEF-24)
- `LoraExamplePrompts.swift`: Replace the lock-picking prompt with a benign
  smart-toaster review prompt that still showcases the abliterated LoRA's
  unfiltered-opinion character. (QEF-6)
- `ModelListViewModel.swift` + `SimplifiedModelsView.swift`: Publish
  `isLoadingModel` and `.disabled(...)` the model-selection rows while a load
  is in-flight, instead of silently discarding later taps. (QEF-8)
- `SettingsViewModel.swift`: Reset `loadedModelSupportsThinking = false` on
  registry-lookup miss so the Settings UI stops showing the previous model's
  capability flag. (QEF-9)
- `ToolSettingsView.swift`: Calculator tool returns an error dict instead of
  fabricating `"0"` when no `expression`/`input`/`expr` key is present; adds
  `isValidMathExpression(_:)` pre-validation (balanced parens, no consecutive
  operators, no trailing operator, no `..`) before `NSExpression(format:)` so
  malformed input can't raise an uncatchable Objective-C exception. (QEF-10/11)
- `VLMCameraView.swift`: Snapshot `isAutoStreamingEnabled` on scenePhase ==
  inactive/background and restore it on .active so LIVE mode survives
  foregrounding. (QEF-12)
- `VoiceAgentViewModel.swift`: Drop the manual `sessionState = .listening`
  after `resumeListening()`; handle the state transition in the session event
  handler to avoid racing with the .listening event stream. (QEF-13)
- `VoiceAssistantView.swift`: Decide the mic tap / long-press action
  synchronously before spawning `Task`, so fast state changes can't turn a
  "send now" into `resumeListening()`. (QEF-25)
- `AdaptiveLayout.swift`: Add `.accessibilityAddTraits(.isButton)`,
  `.accessibilityLabel`, `.accessibilityHint`, and `.accessibilityAction` on
  both iOS-26 and legacy `AdaptiveMicButton` branches so the gesture-driven
  button regains button semantics for VoiceOver / Switch Control. (QEF-14)
- `DemoLoRAAdapter.swift`: Set the abliterated LoRA `fileSize` to the real
  HF-confirmed `17_620_224` bytes instead of `0`. (QEF-23)

Verification: `swift build` on the Swift SDK and
`cmake --build build --target rac_commons -j 4` on the C++ commons both succeed
with zero new warnings; all 5 commons unit test binaries (PlaceholderTest,
core_tests, extraction_tests, download_orchestrator_tests, rac_simple_tokenizer_test)
pass. The chunker / rag_backend_thread_safety test failures are pre-existing and
unrelated (missing `rag_chunker.h` / `rag_backend.h` headers from separate work).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sanchitmonga22

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Chat/Models/DemoLoRAAdapter.swift

@@ -76,7 +76,7 @@ enum LoRAAdapterCatalog {
             downloadURL: URL(string: "https://huggingface.co/Void2377/qwen-lora-gguf/resolve/main/qwen2.5-0.5b-abliterated-lora-f16.gguf")!,
             filename: "qwen2.5-0.5b-abliterated-lora-f16.gguf",
             compatibleModelIds: ["qwen2.5-0.5b-base-q8_0"],
-            fileSize: 0,
+            fileSize: 17_620_224,
             defaultScale: 1.0
         ),
     ]

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Chat/Models/LoraExamplePrompts.swift

@@ -29,7 +29,7 @@ enum LoraExamplePrompts {
         ],
         "qwen2.5-0.5b-abliterated-lora-f16.gguf": [
             "What are some controversial topics people often debate about?",
-            "Explain how lock picking works in detail",
+            "Write a brutally honest product review for a fictional smart toaster",
         ],
     ]
 

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Chat/ViewModels/LLMViewModel+ToolCalling.swift

@@ -69,13 +69,16 @@ extension LLMViewModel {
             toolCallInfo = nil
         }
 
-        // Strip any residual <think> tags before displaying
-        let displayText = Self.stripThinkTags(from: result.text)
+        // Split `<think>...</think>` content from the response so the UI can render
+        // the thinking block separately and avoid silently dropping SDK-provided
+        // thinking content on the tool-calling path.
+        let (displayText, thinkingContent) = ThinkingContentParser.extract(from: result.text)
 
         // Update the message with the result
         await updateMessageWithToolResult(
             at: messageIndex,
             text: displayText,
+            thinkingContent: thinkingContent,
             toolCallInfo: toolCallInfo
         )
     }
@@ -85,6 +88,7 @@ extension LLMViewModel {
     func updateMessageWithToolResult(
         at index: Int,
         text: String,
+        thinkingContent: String?,
         toolCallInfo: ToolCallInfo?
     ) async {
         await MainActor.run {
@@ -103,7 +107,7 @@ extension LLMViewModel {
                 id: currentMessage.id,
                 role: currentMessage.role,
                 content: text,
-                thinkingContent: nil,
+                thinkingContent: thinkingContent,
                 timestamp: currentMessage.timestamp,
                 analytics: nil, // Tool calling doesn't use standard analytics
                 modelInfo: modelInfo,

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Chat/ViewModels/LLMViewModel.swift

@@ -575,18 +575,9 @@ final class LLMViewModel {
         }
     }
 
+    /// Thin pass-through to the SDK's canonical `ThinkingContentParser.strip(from:)`
+    /// so the app has a single source of truth for `<think>` tag handling.
     static func stripThinkTags(from text: String) -> String {
-        var result = text
-        // Remove complete <think>...</think> blocks 
-        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)
+        ThinkingContentParser.strip(from: text)
     }
 }

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Chat/Views/ChatInterfaceView.swift

@@ -32,7 +32,7 @@ struct ChatInterfaceView: View {
     @State private var pendingLoRAURL: URL?
     @State private var loraScale: Float = 1.0
     @ObservedObject private var toolSettingsViewModel = ToolSettingsViewModel.shared
-    @AppStorage("thinkingModeEnabled") private var thinkingModeEnabled = false
+    @ObservedObject private var settingsViewModel = SettingsViewModel.shared
     @FocusState private var isTextFieldFocused: Bool
 
     private let logger = Logger(
@@ -449,7 +449,7 @@ extension ChatInterfaceView {
 
             // Status badges (thinking mode + tool calling + LoRA)
             HStack(spacing: 8) {
-                if thinkingModeEnabled && viewModel.loadedModelSupportsThinking {
+                if settingsViewModel.thinkingModeEnabled && viewModel.loadedModelSupportsThinking {
                     thinkingModeBadge
                 }
 
@@ -465,7 +465,7 @@ extension ChatInterfaceView {
                     loraAddButton
                 }
             }
-            .padding(.top, ((thinkingModeEnabled && viewModel.loadedModelSupportsThinking) || viewModel.useToolCalling || !viewModel.loraAdapters.isEmpty || hasModelSelected) ? 8 : 0)
+            .padding(.top, ((settingsViewModel.thinkingModeEnabled && viewModel.loadedModelSupportsThinking) || viewModel.useToolCalling || !viewModel.loraAdapters.isEmpty || hasModelSelected) ? 8 : 0)
 
             HStack(spacing: AppSpacing.mediumLarge) {
                 TextField("Type a message...", text: $viewModel.currentInput, axis: .vertical)
@@ -501,7 +501,7 @@ extension ChatInterfaceView {
 
     var thinkingModeBadge: some View {
         Button {
-            thinkingModeEnabled.toggle()
+            settingsViewModel.thinkingModeEnabled.toggle()
         } label: {
             HStack(spacing: 6) {
                 Image(systemName: "lightbulb.min.fill")

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Models/ModelListViewModel.swift

@@ -129,7 +129,7 @@ class ModelListViewModel: ObservableObject {
         await loadModelsFromRegistry()
     }
 
-    private var isLoadingModel = false
+    @Published private(set) var isLoadingModel = false
 
     /// Select and load a model
     func selectModel(_ model: ModelInfo) async {

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Models/SimplifiedModelsView.swift

@@ -137,6 +137,7 @@ struct SimplifiedModelsView: View {
                     SimplifiedModelRow(
                         model: model,
                         isSelected: selectedModel?.id == model.id,
+                        isLoadingModel: viewModel.isLoadingModel,
                         onDownloadCompleted: {
                             Task {
                                 await viewModel.loadModels()
@@ -178,6 +179,7 @@ struct SimplifiedModelsView: View {
 private struct SimplifiedModelRow: View {
     let model: ModelInfo
     let isSelected: Bool
+    let isLoadingModel: Bool
     let onDownloadCompleted: () -> Void
     let onSelectModel: () -> Void
     let onModelUpdated: () -> Void
@@ -299,7 +301,7 @@ private struct SimplifiedModelRow: View {
                 .buttonStyle(.borderedProminent)
                 .tint(AppColors.primaryAccent)
                 .controlSize(.small)
-                .disabled(isSelected)
+                .disabled(isSelected || isLoadingModel)
             } else if model.localPath == nil {
                 if isDownloading {
                     ProgressView()
@@ -339,6 +341,7 @@ private struct SimplifiedModelRow: View {
                     .buttonStyle(.borderedProminent)
                     .tint(AppColors.primaryAccent)
                     .controlSize(.small)
+                    .disabled(isLoadingModel)
                 }
             }
         }

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

@@ -34,32 +34,18 @@ struct RAGMessage: Identifiable {
     }
 
     // MARK: - Think Tag Helpers
+    //
+    // Thin pass-throughs to the SDK's canonical `ThinkingContentParser` so the
+    // app has a single source of truth for `<think>` tag handling.
 
     /// 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
+        ThinkingContentParser.extract(from: text).thinking
     }
 
     /// 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)
+        ThinkingContentParser.strip(from: text)
     }
 }
 

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

@@ -122,6 +122,9 @@ class SettingsViewModel: ObservableObject {
             if let model = ModelListViewModel.shared.availableModels.first(where: { $0.id == modelId }) {
                 loadedModelSupportsThinking = model.supportsThinking
                 logger.info("LLM loaded (\(modelId)), supportsThinking: \(model.supportsThinking)")
+            } else {
+                loadedModelSupportsThinking = false
+                logger.warning("LLM loaded (\(modelId)), but it was not found in the registry")
             }
         case "llm_model_unloaded":
             loadedModelSupportsThinking = false

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

@@ -8,6 +8,61 @@
 import SwiftUI
 import RunAnywhere
 
+// MARK: - Math Expression Validation
+
+/// Strict syntactic validation for math expressions before evaluation.
+/// `NSExpression(format:)` can raise uncatchable ObjC exceptions on malformed
+/// input that passes a simple character whitelist (e.g., "2*/3", "(", "1+").
+/// This routine rejects the common unsafe patterns.
+fileprivate func isValidMathExpression(_ expr: String) -> Bool {
+    let trimmed = expr.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard !trimmed.isEmpty else { return false }
+
+    let operators: Set<Character> = ["+", "-", "*", "/"]
+    // Chars after which a unary "-" is acceptable.
+    let unaryMinusContext: Set<Character> = ["(", "+", "-", "*", "/"]
+
+    var parenDepth = 0
+    var prevNonSpace: Character? = nil
+    var prevWasDot = false
+
+    for ch in trimmed {
+        if ch == " " { continue }
+
+        if ch == "(" {
+            parenDepth += 1
+        } else if ch == ")" {
+            parenDepth -= 1
+            if parenDepth < 0 { return false }
+        }
+
+        // Consecutive decimal dots (e.g., "1..2").
+        if ch == "." {
+            if prevWasDot { return false }
+            prevWasDot = true
+        } else {
+            prevWasDot = false
+        }
+
+        // Consecutive operators (allow unary "-" after operators or "(").
+        if operators.contains(ch), let prev = prevNonSpace, operators.contains(prev) {
+            if !(ch == "-" && unaryMinusContext.contains(prev)) {
+                return false
+            }
+        }
+
+        prevNonSpace = ch
+    }
+
+    // Balanced parentheses.
+    guard parenDepth == 0 else { return false }
+
+    // No trailing operator.
+    if let last = prevNonSpace, operators.contains(last) { return false }
+
+    return true
+}
+
 // MARK: - Tool Settings View Model
 
 @MainActor
@@ -85,7 +140,7 @@ class ToolSettingsViewModel: ObservableObject {
                 ),
                 executor: { args in
                     // Extract expression from args, handling both string and number ToolValue types
-                    let expression: String = {
+                    let expression: String? = {
                         let keys = ["expression", "input", "expr"]
                         for key in keys {
                             if let val = args[key] {
@@ -98,8 +153,13 @@ class ToolSettingsViewModel: ObservableObject {
                             if let s = val.stringValue { return s }
                             if let n = val.numberValue { return "\(n)" }
                         }
-                        return "0"
+                        return nil
                     }()
+                    guard let expression, !expression.isEmpty else {
+                        return [
+                            "error": .string("Missing expression argument")
+                        ]
+                    }
                     print("Calculator received args: \(args), using expression: '\(expression)'")
                     // Clean the expression - remove any non-math characters
                     let cleanedExpression = expression
@@ -119,6 +179,15 @@ class ToolSettingsViewModel: ObservableObject {
                         ]
                     }
 
+                    // Strict pre-validation: NSExpression(format:) can throw uncatchable
+                    // ObjC exceptions on malformed input (e.g., "2*/3", "(", "1+").
+                    guard isValidMathExpression(cleanedExpression) else {
+                        return [
+                            "error": .string("Invalid expression syntax"),
+                            "expression": .string(expression)
+                        ]
+                    }
+
                     let exp = NSExpression(format: cleanedExpression)
                     if let result = exp.expressionValue(with: nil, context: nil) as? NSNumber {
                         return [