@inferrlm/react-native-mlx 0.2.0-inferrlm.2 → 0.4.0

package/ios/Sources/ThinkingStateMachine.swift

@@ -0,0 +1,206 @@
+import Foundation
+
+struct ThinkingStateMachine {
+    enum Output {
+        case token(String)
+        case thinkingStart
+        case thinkingChunk(String)
+        case thinkingEnd(String)
+    }
+
+    private enum State {
+        case idle
+        case bufferingOpenTag(String)
+        case inThinking
+        case bufferingCloseTag(String)
+    }
+
+    private var state: State = .idle
+    private var thinkingContent: String = ""
+
+    private let openTag = "<think>"
+    private let closeTag = "</think>"
+
+    mutating func process(token: String) -> [Output] {
+        var outputs: [Output] = []
+        var remaining = token
+
+        while !remaining.isEmpty {
+            switch state {
+            case .idle:
+                outputs.append(contentsOf: processIdle(&remaining))
+
+            case .bufferingOpenTag(let buffer):
+                outputs.append(contentsOf: processBufferingOpenTag(buffer: buffer, remaining: &remaining))
+
+            case .inThinking:
+                outputs.append(contentsOf: processInThinking(&remaining))
+
+            case .bufferingCloseTag(let buffer):
+                outputs.append(contentsOf: processBufferingCloseTag(buffer: buffer, remaining: &remaining))
+            }
+        }
+
+        return outputs
+    }
+
+    mutating func flush() -> [Output] {
+        var outputs: [Output] = []
+
+        switch state {
+        case .bufferingOpenTag(let buffer):
+            if !buffer.isEmpty {
+                outputs.append(.token(buffer))
+            }
+        case .bufferingCloseTag(let buffer):
+            if !buffer.isEmpty {
+                outputs.append(.thinkingChunk(buffer))
+            }
+            outputs.append(.thinkingEnd(thinkingContent + buffer))
+        case .inThinking:
+            outputs.append(.thinkingEnd(thinkingContent))
+        case .idle:
+            break
+        }
+
+        state = .idle
+        thinkingContent = ""
+        return outputs
+    }
+
+    private mutating func processIdle(_ remaining: inout String) -> [Output] {
+        var outputs: [Output] = []
+
+        if let tagRange = remaining.range(of: openTag) {
+            let before = String(remaining[..<tagRange.lowerBound])
+            if !before.isEmpty {
+                outputs.append(.token(before))
+            }
+            outputs.append(.thinkingStart)
+            state = .inThinking
+            thinkingContent = ""
+            remaining = String(remaining[tagRange.upperBound...])
+        } else if let partialMatch = findPartialMatch(remaining, target: openTag) {
+            let before = String(remaining[..<partialMatch.range.lowerBound])
+            if !before.isEmpty {
+                outputs.append(.token(before))
+            }
+            state = .bufferingOpenTag(partialMatch.matched)
+            remaining = ""
+        } else {
+            outputs.append(.token(remaining))
+            remaining = ""
+        }
+
+        return outputs
+    }
+
+    private mutating func processBufferingOpenTag(buffer: String, remaining: inout String) -> [Output] {
+        var outputs: [Output] = []
+        let combined = buffer + remaining
+
+        if let tagRange = combined.range(of: openTag) {
+            let before = String(combined[..<tagRange.lowerBound])
+            if !before.isEmpty {
+                outputs.append(.token(before))
+            }
+            outputs.append(.thinkingStart)
+            state = .inThinking
+            thinkingContent = ""
+            remaining = String(combined[tagRange.upperBound...])
+        } else if openTag.hasPrefix(combined) {
+            state = .bufferingOpenTag(combined)
+            remaining = ""
+        } else if let partialMatch = findPartialMatch(combined, target: openTag) {
+            let before = String(combined[..<partialMatch.range.lowerBound])
+            if !before.isEmpty {
+                outputs.append(.token(before))
+            }
+            state = .bufferingOpenTag(partialMatch.matched)
+            remaining = ""
+        } else {
+            outputs.append(.token(combined))
+            state = .idle
+            remaining = ""
+        }
+
+        return outputs
+    }
+
+    private mutating func processInThinking(_ remaining: inout String) -> [Output] {
+        var outputs: [Output] = []
+
+        if let tagRange = remaining.range(of: closeTag) {
+            let before = String(remaining[..<tagRange.lowerBound])
+            if !before.isEmpty {
+                thinkingContent += before
+                outputs.append(.thinkingChunk(before))
+            }
+            outputs.append(.thinkingEnd(thinkingContent))
+            state = .idle
+            thinkingContent = ""
+            remaining = String(remaining[tagRange.upperBound...])
+        } else if let partialMatch = findPartialMatch(remaining, target: closeTag) {
+            let before = String(remaining[..<partialMatch.range.lowerBound])
+            if !before.isEmpty {
+                thinkingContent += before
+                outputs.append(.thinkingChunk(before))
+            }
+            state = .bufferingCloseTag(partialMatch.matched)
+            remaining = ""
+        } else {
+            thinkingContent += remaining
+            outputs.append(.thinkingChunk(remaining))
+            remaining = ""
+        }
+
+        return outputs
+    }
+
+    private mutating func processBufferingCloseTag(buffer: String, remaining: inout String) -> [Output] {
+        var outputs: [Output] = []
+        let combined = buffer + remaining
+
+        if let tagRange = combined.range(of: closeTag) {
+            let before = String(combined[..<tagRange.lowerBound])
+            if !before.isEmpty {
+                thinkingContent += before
+                outputs.append(.thinkingChunk(before))
+            }
+            outputs.append(.thinkingEnd(thinkingContent))
+            state = .idle
+            thinkingContent = ""
+            remaining = String(combined[tagRange.upperBound...])
+        } else if closeTag.hasPrefix(combined) {
+            state = .bufferingCloseTag(combined)
+            remaining = ""
+        } else if let partialMatch = findPartialMatch(combined, target: closeTag) {
+            let before = String(combined[..<partialMatch.range.lowerBound])
+            if !before.isEmpty {
+                thinkingContent += before
+                outputs.append(.thinkingChunk(before))
+            }
+            state = .bufferingCloseTag(partialMatch.matched)
+            remaining = ""
+        } else {
+            thinkingContent += combined
+            outputs.append(.thinkingChunk(combined))
+            state = .inThinking
+            remaining = ""
+        }
+
+        return outputs
+    }
+
+    private func findPartialMatch(_ str: String, target: String) -> (range: Range<String.Index>, matched: String)? {
+        for i in stride(from: target.count - 1, through: 1, by: -1) {
+            let suffix = String(str.suffix(i))
+            let prefix = String(target.prefix(i))
+            if suffix == prefix {
+                let startIndex = str.index(str.endIndex, offsetBy: -i)
+                return (startIndex..<str.endIndex, suffix)
+            }
+        }
+        return nil
+    }
+}

package/nitrogen/generated/ios/MLXReactNative+autolinking.rb

@@ -2,7 +2,7 @@
 # MLXReactNative+autolinking.rb
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2025 Marc Rousavy @ Margelo
+# Copyright © 2026 Marc Rousavy @ Margelo
 #
 
 # This is a Ruby script that adds all files generated by Nitrogen

package/nitrogen/generated/ios/MLXReactNative-Swift-Cxx-Bridge.cpp

@@ -2,7 +2,7 @@
 /// MLXReactNative-Swift-Cxx-Bridge.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "MLXReactNative-Swift-Cxx-Bridge.hpp"
@@ -10,6 +10,8 @@
 // Include C++ implementation defined types
 #include "HybridLLMSpecSwift.hpp"
 #include "HybridModelManagerSpecSwift.hpp"
+#include "HybridSTTSpecSwift.hpp"
+#include "HybridTTSSpecSwift.hpp"
 #include "MLXReactNative-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
 
@@ -39,6 +41,31 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const std::shared_ptr<AnyMap>& /* result */)>
+  Func_void_std__shared_ptr_AnyMap_ create_Func_void_std__shared_ptr_AnyMap_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = MLXReactNative::Func_void_std__shared_ptr_AnyMap_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<AnyMap>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>& /* args */)>
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap_ create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = MLXReactNative::Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<AnyMap>& args) mutable -> std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>> {
+      auto __result = swiftClosure.call(args);
+      return __result;
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& /* result */)>
+  Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap___ create_Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap___(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = MLXReactNative::Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap___::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::string& /* result */)>
   Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = MLXReactNative::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
@@ -47,6 +74,14 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const std::string& /* toolName */, const std::string& /* args */)>
+  Func_void_std__string_std__string create_Func_void_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = MLXReactNative::Func_void_std__string_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& toolName, const std::string& args) mutable -> void {
+      swiftClosure.call(toolName, args);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridLLMSpec>
   std::shared_ptr<HybridLLMSpec> create_std__shared_ptr_HybridLLMSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     MLXReactNative::HybridLLMSpec_cxx swiftPart = MLXReactNative::HybridLLMSpec_cxx::fromUnsafe(swiftUnsafePointer);
@@ -94,5 +129,45 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
     MLXReactNative::HybridModelManagerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
+  
+  // pragma MARK: std::shared_ptr<HybridSTTSpec>
+  std::shared_ptr<HybridSTTSpec> create_std__shared_ptr_HybridSTTSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    MLXReactNative::HybridSTTSpec_cxx swiftPart = MLXReactNative::HybridSTTSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::mlxreactnative::HybridSTTSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridSTTSpec_(std__shared_ptr_HybridSTTSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::mlxreactnative::HybridSTTSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::mlxreactnative::HybridSTTSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridSTTSpec\" is not implemented in Swift!");
+    }
+    #endif
+    MLXReactNative::HybridSTTSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
+  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = MLXReactNative::Func_void_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<ArrayBuffer>& result) mutable -> void {
+      swiftClosure.call(ArrayBufferHolder(result));
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridTTSSpec>
+  std::shared_ptr<HybridTTSSpec> create_std__shared_ptr_HybridTTSSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    MLXReactNative::HybridTTSSpec_cxx swiftPart = MLXReactNative::HybridTTSSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::mlxreactnative::HybridTTSSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridTTSSpec_(std__shared_ptr_HybridTTSSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::mlxreactnative::HybridTTSSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::mlxreactnative::HybridTTSSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridTTSSpec\" is not implemented in Swift!");
+    }
+    #endif
+    MLXReactNative::HybridTTSSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
 
 } // namespace margelo::nitro::mlxreactnative::bridge::swift