Address PR #476 review comments (10 fixes)

- ToolSettingsView (greptile P1): mark `isAtEnd` getter `mutating get`
  to fix Swift compile error from calling mutating `skipWhitespace()`.
- RunAnywhere+TextGeneration (greptile P2): remove dead `Task.isCancelled`
  check in C-callback token path — always false (no ambient task);
  real cancellation already flows via `cancel_requested` atomic in C++.
- tool_calling.cpp (greptile P2): flat-args fallback now emits numbers,
  booleans, and null verbatim via `is_json_scalar_literal()` instead of
  stringifying everything. `{"count":5}` stays `{"count":5}`.
- RunAnywhere+TextGeneration (greptile P2): add `NOTE` doc comment to
  `ThinkingContentParser.extract` documenting single-`<think>`-block
  behavior.
- CppBridge shutdown (greptile P2): replace Task.detached + semaphore.wait
  with DispatchQueue.global().async + Task + semaphore to avoid
  cooperative thread-pool starvation. Synchronous shutdown() signature
  preserved, race fix retained.
- lifecycle_manager.cpp (coderabbit Critical): auto-unload now mirrors
  the existing unload fence — uses unique_lock, waits on
  service_cv for refcount==0, stores nullptr into atomic before
  destroy_fn, null-checks old_service.
- RunAnywhere+TextGeneration (coderabbit Critical): remove the second
  error-handling path — C++ errorCallback already consumes the retained
  context via takeRetainedValue, so the duplicate release + finish +
  markFailed caused double-release/double-finish.
- BenchmarkViewModel (coderabbit Major): stop coercing empty
  selectedModelIds to nil in runBenchmarks() — nil was interpreted as
  "no filter → run all", so "None" inverted behavior.
- BenchmarkDashboardView (coderabbit Minor): fix copy inconsistency —
  header text now says "gradient images" to match per-row label.
- build-ios.sh (coderabbit Major): replace fragile ar-extract-repack
  (loses members with shared basenames) with in-place `ar -d` to remove
  flag.cc.o/init.cc.o specifically.

Author: sanchitmonga22

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Benchmarks/ViewModels/BenchmarkViewModel.swift

@@ -111,10 +111,9 @@ final class BenchmarkViewModel {
             var run = BenchmarkRun(deviceInfo: deviceInfo)
 
             do {
-                let modelFilter = selectedModelIds.isEmpty ? nil : selectedModelIds
                 let output = try await runner.runBenchmarks(
                     categories: selectedCategories,
-                    modelIds: modelFilter
+                    modelIds: selectedModelIds
                 ) { [weak self] update in
                     Task { @MainActor in
                         self?.progress = update.progress

examples/ios/RunAnywhereAI/RunAnywhereAI/Features/Benchmarks/Views/BenchmarkDashboardView.swift

@@ -31,7 +31,7 @@ struct BenchmarkDashboardView: View {
             // Benchmark Suite Info
             Section {
                 VStack(alignment: .leading, spacing: AppSpacing.small) {
-                    Text("Each category runs deterministic scenarios against every downloaded model of that type. Synthetic inputs (silent audio, sine waves, solid-color images) ensure reproducible results.")
+                    Text("Each category runs deterministic scenarios against every downloaded model of that type. Synthetic inputs (silent audio, sine waves, gradient images) ensure reproducible results.")
                         .font(AppTypography.caption)
                         .foregroundColor(AppColors.textSecondary)
                 }

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

@@ -435,8 +435,10 @@ enum SafeMathEvaluator {
         }
 
         var isAtEnd: Bool {
-            skipWhitespace()
-            return index >= scalars.count
+            mutating get {
+                skipWhitespace()
+                return index >= scalars.count
+            }
         }
 
         mutating func skipWhitespace() {

sdk/runanywhere-commons/scripts/build-ios.sh

@@ -734,18 +734,10 @@ create_backend_xcframework() {
             continue
         fi
 
-        # For MetalRT: strip sentencepiece's flag.cc.o to avoid duplicate _FLAGS_help with sherpa-onnx
+        # For MetalRT: strip sentencepiece's flag.cc.o/init.cc.o to avoid duplicate _FLAGS_help with sherpa-onnx
         if [[ "$BACKEND_NAME" == "metalrt" ]]; then
-            local TMPSTRIP
-            TMPSTRIP=$(mktemp -d) || { log_error "Failed to create temp directory"; exit 1; }
-            cd "$TMPSTRIP"
-            ar x "${FRAMEWORK_DIR}/${FRAMEWORK_NAME}"
-            rm -f flag.cc.o init.cc.o
-            rm -f "${FRAMEWORK_DIR}/${FRAMEWORK_NAME}"
-            ar rcs "${FRAMEWORK_DIR}/${FRAMEWORK_NAME}" *.o
-            cd -
-            rm -rf "$TMPSTRIP"
-            log_info "  ${PLATFORM}: Stripped duplicate flag.cc.o from bundle"
+            ar -d "${FRAMEWORK_DIR}/${FRAMEWORK_NAME}" flag.cc.o init.cc.o 2>/dev/null || true
+            log_info "  ${PLATFORM}: Stripped duplicate flag.cc.o/init.cc.o from bundle"
         fi
 
         # For MetalRT: copy default.metallib into the framework as a resource

sdk/runanywhere-commons/src/core/capabilities/lifecycle_manager.cpp

@@ -169,7 +169,7 @@ rac_result_t rac_lifecycle_load(rac_handle_t handle, const char* model_path, con
     }
 
     auto* mgr = static_cast<LifecycleManager*>(handle);
-    std::lock_guard<std::mutex> lock(mgr->mutex);
+    std::unique_lock<std::mutex> lock(mgr->mutex);
 
     // Check if already loaded with same path - skip duplicate events
     // Mirrors Swift: if await lifecycle.currentResourceId == modelId
@@ -184,17 +184,23 @@ rac_result_t rac_lifecycle_load(rac_handle_t handle, const char* model_path, con
     // Auto-unload previous model if a different one is loaded.
     // Without this, the old service leaks resources (GPU memory, file handles)
     // and the new service creation may fail due to resource contention.
-    if (mgr->state.load() == RAC_LIFECYCLE_STATE_LOADED && mgr->current_service != nullptr) {
+    if (mgr->state.load() == RAC_LIFECYCLE_STATE_LOADED && mgr->current_service.load() != nullptr) {
+        // Wait for all acquired services to be released (mirror unload fence)
+        mgr->service_cv.wait(lock, [mgr] { return mgr->service_refcount.load() == 0; });
+
         RAC_LOG_INFO(mgr->logger_category.c_str(),
                      "Auto-unloading previous model '%s' before loading '%s'",
                      mgr->current_model_id.c_str(), model_id);
 
-        if (mgr->destroy_fn != nullptr) {
-            mgr->destroy_fn(mgr->current_service, mgr->user_data);
+        // Store nullptr BEFORE calling destroy_fn so that concurrent cancel()
+        // reads via get_service() see nullptr rather than a dangling pointer.
+        rac_handle_t old_service = mgr->current_service.load();
+        mgr->current_service.store(nullptr);
+        if (mgr->destroy_fn != nullptr && old_service != nullptr) {
+            mgr->destroy_fn(old_service, mgr->user_data);
         }
         track_lifecycle_event(mgr, "unloaded", mgr->current_model_id.c_str(), 0.0, RAC_SUCCESS);
 
-        mgr->current_service = nullptr;
         mgr->current_model_path.clear();
         mgr->current_model_id.clear();
         mgr->current_model_name.clear();

sdk/runanywhere-commons/src/features/llm/tool_calling.cpp

@@ -564,6 +564,42 @@ static std::string escape_json_string(const char* str) {
     return result;
 }
 
+/**
+ * @brief Classify a raw scalar token as a JSON literal (number, boolean, or null).
+ *
+ * Used to decide whether an extracted value should be emitted verbatim into
+ * reconstructed JSON (true) or wrapped in quotes as a string (false). Accepts
+ * standard JSON number syntax plus the literals `true`, `false`, `null`.
+ */
+static bool is_json_scalar_literal(const char* s) {
+    if (!s || !*s) {
+        return false;
+    }
+
+    // Boolean and null literals
+    if (strcmp(s, "true") == 0 || strcmp(s, "false") == 0 || strcmp(s, "null") == 0) {
+        return true;
+    }
+
+    // JSON number: optional '-', digits, optional fraction, optional exponent
+    size_t i = 0;
+    if (s[i] == '-') i++;
+    if (!isdigit(static_cast<unsigned char>(s[i]))) return false;
+    while (isdigit(static_cast<unsigned char>(s[i]))) i++;
+    if (s[i] == '.') {
+        i++;
+        if (!isdigit(static_cast<unsigned char>(s[i]))) return false;
+        while (isdigit(static_cast<unsigned char>(s[i]))) i++;
+    }
+    if (s[i] == 'e' || s[i] == 'E') {
+        i++;
+        if (s[i] == '+' || s[i] == '-') i++;
+        if (!isdigit(static_cast<unsigned char>(s[i]))) return false;
+        while (isdigit(static_cast<unsigned char>(s[i]))) i++;
+    }
+    return s[i] == '\0';
+}
+
 // =============================================================================
 // JSON NORMALIZATION
 // =============================================================================
@@ -719,8 +755,16 @@ static bool extract_tool_name_and_args(const char* json_obj, char** out_tool_nam
                             if (kval_is_obj) {
                                 flat_args += "\"" + escaped_key + "\":" + std::string(kval);
                             } else if (kval) {
-                                std::string escaped_val = escape_json_string(kval);
-                                flat_args += "\"" + escaped_key + "\":\"" + escaped_val + "\"";
+                                // Emit JSON numbers/booleans/null verbatim; quote strings.
+                                // extract_json_value strips quotes from string values but
+                                // preserves raw scalars, so we classify the stripped value
+                                // using JSON scalar syntax rules.
+                                if (is_json_scalar_literal(kval)) {
+                                    flat_args += "\"" + escaped_key + "\":" + std::string(kval);
+                                } else {
+                                    std::string escaped_val = escape_json_string(kval);
+                                    flat_args += "\"" + escaped_key + "\":\"" + escaped_val + "\"";
+                                }
                             }
                             free(kval);
                             first = false;

sdk/runanywhere-swift/Sources/RunAnywhere/Foundation/Bridge/CppBridge.swift

@@ -185,19 +185,26 @@ public enum CppBridge {
         // causing use-after-free inside the C++ layer and allowing reinit
         // while destruction is still in flight.
         //
-        // The destroy() methods are actor-isolated but not @MainActor, so
-        // blocking a background/non-MainActor caller on a semaphore is safe.
+        // We hop to a GCD global queue (not the Swift cooperative thread pool)
+        // and block that GCD worker on a semaphore. Blocking a cooperative
+        // thread-pool thread via `Task.detached { ... }` + `semaphore.wait()`
+        // on the caller risks priority inversion / pool starvation, since the
+        // detached task and the caller may share the same limited pool. The
+        // GCD global pool is separate and safe to block briefly.
+        //
         // reset() is not annotated @MainActor, so callers are expected to
         // invoke it off the main thread.
         let semaphore = DispatchSemaphore(value: 0)
-        Task.detached {
-            await LLM.shared.destroy()
-            await STT.shared.destroy()
-            await TTS.shared.destroy()
-            await VAD.shared.destroy()
-            await VoiceAgent.shared.destroy()
-            await VLM.shared.destroy()
-            semaphore.signal()
+        DispatchQueue.global(qos: .userInitiated).async {
+            Task {
+                await LLM.shared.destroy()
+                await STT.shared.destroy()
+                await TTS.shared.destroy()
+                await VAD.shared.destroy()
+                await VoiceAgent.shared.destroy()
+                await VLM.shared.destroy()
+                semaphore.signal()
+            }
         }
         semaphore.wait()
 

sdk/runanywhere-swift/Sources/RunAnywhere/Public/Extensions/LLM/RunAnywhere+TextGeneration.swift

@@ -231,10 +231,7 @@ public extension RunAnywhere {
                 }
 
                 if streamResult != RAC_SUCCESS {
-                    Unmanaged<LLMStreamCallbackContext>.fromOpaque(contextPtr).release()
-                    let error = SDKError.llm(.generationFailed, "Stream generation failed: \(streamResult)")
-                    continuation.finish(throwing: error)
-                    await collector.markFailed(error)
+                    return
                 }
             }
         }
@@ -258,7 +255,6 @@ private enum LLMStreamCallbacks {
     static func create() -> Callbacks {
         let tokenCallback: TokenFn = { tokenPtr, userData -> rac_bool_t in
             guard let tokenPtr = tokenPtr, let userData = userData else { return RAC_TRUE }
-            if Task.isCancelled { return RAC_FALSE }
             let ctx = Unmanaged<LLMStreamCallbackContext>.fromOpaque(userData).takeUnretainedValue()
             let token = String(cString: tokenPtr)
             Task {
@@ -316,6 +312,7 @@ private final class LLMStreamCallbackContext: @unchecked Sendable {
 
 enum ThinkingContentParser {
     /// Extracts `<think>...</think>` content from generated text.
+    /// - NOTE: Only the first `<think>` block is extracted; additional blocks are left inline in the response text.
     /// - Returns: Tuple of (responseText, thinkingContent). If no tags found, responseText = original text, thinkingContent = nil.
     static func extract(from text: String) -> (text: String, thinking: String?) {
         guard let startRange = text.range(of: "<think>"),