react-native-nitro-mlx 0.2.2 → 0.4.0

package/lib/typescript/src/tts.d.ts

@@ -0,0 +1,13 @@
+import type { TTSLoadOptions, TTSGenerateOptions } from './specs/TTS.nitro';
+export declare const TTS: {
+    load(modelId: string, options?: TTSLoadOptions): Promise<void>;
+    generate(text: string, options?: TTSGenerateOptions): Promise<ArrayBuffer>;
+    stream(text: string, onAudioChunk: (audio: ArrayBuffer) => void, options?: TTSGenerateOptions): Promise<void>;
+    stop(): void;
+    unload(): void;
+    readonly isLoaded: boolean;
+    readonly isGenerating: boolean;
+    readonly modelId: string;
+    readonly sampleRate: number;
+};
+//# sourceMappingURL=tts.d.ts.map

package/lib/typescript/src/tts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tts.d.ts","sourceRoot":"","sources":["../../../src/tts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,cAAc,EACd,kBAAkB,EACnB,MAAM,mBAAmB,CAAA;AAW1B,eAAO,MAAM,GAAG;kBACA,MAAM,YAAY,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;mBAKtD,MAAM,YACF,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC;iBAKf,MAAM,gBACE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,YAChC,kBAAkB,GAC3B,OAAO,CAAC,IAAI,CAAC;YAIR,IAAI;cAIF,IAAI;uBAIE,OAAO;2BAIH,OAAO;sBAIZ,MAAM;yBAIH,MAAM;CAGzB,CAAA"}

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

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

@@ -2,35 +2,65 @@
 /// MLXReactNative-Swift-Cxx-Bridge.hpp
 /// 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
 ///
 
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct GenerationStats; }
 // Forward declaration of `HybridLLMSpec` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { class HybridLLMSpec; }
 // Forward declaration of `HybridModelManagerSpec` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { class HybridModelManagerSpec; }
+// Forward declaration of `HybridSTTSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridSTTSpec; }
+// Forward declaration of `HybridTTSSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridTTSSpec; }
 // Forward declaration of `LLMLoadOptions` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMLoadOptions; }
 // Forward declaration of `LLMMessage` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMMessage; }
+// Forward declaration of `STTLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct STTLoadOptions; }
+// Forward declaration of `TTSGenerateOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSGenerateOptions; }
+// Forward declaration of `TTSLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSLoadOptions; }
+// Forward declaration of `ToolDefinition` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct ToolDefinition; }
+// Forward declaration of `ToolParameter` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct ToolParameter; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridLLMSpec_cxx` to properly resolve imports.
 namespace MLXReactNative { class HybridLLMSpec_cxx; }
 // Forward declaration of `HybridModelManagerSpec_cxx` to properly resolve imports.
 namespace MLXReactNative { class HybridModelManagerSpec_cxx; }
+// Forward declaration of `HybridSTTSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridSTTSpec_cxx; }
+// Forward declaration of `HybridTTSSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridTTSSpec_cxx; }
 
 // Include C++ defined types
 #include "GenerationStats.hpp"
 #include "HybridLLMSpec.hpp"
 #include "HybridModelManagerSpec.hpp"
+#include "HybridSTTSpec.hpp"
+#include "HybridTTSSpec.hpp"
 #include "LLMLoadOptions.hpp"
 #include "LLMMessage.hpp"
+#include "STTLoadOptions.hpp"
+#include "TTSGenerateOptions.hpp"
+#include "TTSLoadOptions.hpp"
+#include "ToolDefinition.hpp"
+#include "ToolParameter.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -181,6 +211,134 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::vector<ToolParameter>
+  /**
+   * Specialized version of `std::vector<ToolParameter>`.
+   */
+  using std__vector_ToolParameter_ = std::vector<ToolParameter>;
+  inline std::vector<ToolParameter> create_std__vector_ToolParameter_(size_t size) noexcept {
+    std::vector<ToolParameter> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_AnyMap___ = std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<AnyMap>>> create_std__shared_ptr_Promise_std__shared_ptr_AnyMap___() noexcept {
+    return Promise<std::shared_ptr<AnyMap>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<AnyMap>> wrap_std__shared_ptr_Promise_std__shared_ptr_AnyMap___(std::shared_ptr<Promise<std::shared_ptr<AnyMap>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<AnyMap>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<AnyMap>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<AnyMap>&)>`.
+   */
+  using Func_void_std__shared_ptr_AnyMap_ = std::function<void(const std::shared_ptr<AnyMap>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<AnyMap>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_AnyMap__Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_AnyMap__Wrapper(std::function<void(const std::shared_ptr<AnyMap>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<AnyMap>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<AnyMap> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<AnyMap>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_AnyMap_ create_Func_void_std__shared_ptr_AnyMap_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_AnyMap__Wrapper wrap_Func_void_std__shared_ptr_AnyMap_(Func_void_std__shared_ptr_AnyMap_ value) noexcept {
+    return Func_void_std__shared_ptr_AnyMap__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>& /* args */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap_ = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>& /* args */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>& / * args * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap__Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap__Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>& /* args */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>& /* args */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>> call(std::shared_ptr<AnyMap> args) const noexcept {
+      auto __result = _function->operator()(args);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>(const std::shared_ptr<AnyMap>& /* args */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  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;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap__Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap_(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap_ value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap______std__shared_ptr_AnyMap__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap_____ = std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap_____() noexcept {
+    return Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_AnyMap_____(std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap___ = std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap____Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap____Wrapper(std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<std::shared_ptr<AnyMap>>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<std::shared_ptr<AnyMap>>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  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;
+  inline Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap____Wrapper wrap_Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap___(Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap___ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_std__shared_ptr_AnyMap____Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<ToolDefinition>
+  /**
+   * Specialized version of `std::vector<ToolDefinition>`.
+   */
+  using std__vector_ToolDefinition_ = std::vector<ToolDefinition>;
+  inline std::vector<ToolDefinition> create_std__vector_ToolDefinition_(size_t size) noexcept {
+    std::vector<ToolDefinition> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<ToolDefinition>>
+  /**
+   * Specialized version of `std::optional<std::vector<ToolDefinition>>`.
+   */
+  using std__optional_std__vector_ToolDefinition__ = std::optional<std::vector<ToolDefinition>>;
+  inline std::optional<std::vector<ToolDefinition>> create_std__optional_std__vector_ToolDefinition__(const std::vector<ToolDefinition>& value) noexcept {
+    return std::optional<std::vector<ToolDefinition>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_ToolDefinition__(const std::optional<std::vector<ToolDefinition>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<ToolDefinition> get_std__optional_std__vector_ToolDefinition__(const std::optional<std::vector<ToolDefinition>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<LLMLoadOptions>
   /**
    * Specialized version of `std::optional<LLMLoadOptions>`.
@@ -230,6 +388,43 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(const std::string& /* toolName */, const std::string& /* args */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&, const std::string&)>`.
+   */
+  using Func_void_std__string_std__string = std::function<void(const std::string& /* toolName */, const std::string& /* args */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * toolName * /, const std::string& / * args * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_std__string_Wrapper(std::function<void(const std::string& /* toolName */, const std::string& /* args */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>>(std::move(func))) {}
+    inline void call(std::string toolName, std::string args) const noexcept {
+      _function->operator()(toolName, args);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string_std__string create_Func_void_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_std__string_Wrapper wrap_Func_void_std__string_std__string(Func_void_std__string_std__string value) noexcept {
+    return Func_void_std__string_std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const std::string& / * toolName * /, const std::string& / * args * /)>>`.
+   */
+  using std__optional_std__function_void_const_std__string_____toolName_____const_std__string_____args______ = std::optional<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>>;
+  inline std::optional<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>> create_std__optional_std__function_void_const_std__string_____toolName_____const_std__string_____args______(const std::function<void(const std::string& /* toolName */, const std::string& /* args */)>& value) noexcept {
+    return std::optional<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_std__string_____toolName_____const_std__string_____args______(const std::optional<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const std::string& /* toolName */, const std::string& /* args */)> get_std__optional_std__function_void_const_std__string_____toolName_____const_std__string_____args______(const std::optional<std::function<void(const std::string& /* toolName */, const std::string& /* args */)>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridLLMSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridLLMSpec>`.
@@ -395,5 +590,147 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
   inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::withError(error);
   }
+  
+  // pragma MARK: std::optional<STTLoadOptions>
+  /**
+   * Specialized version of `std::optional<STTLoadOptions>`.
+   */
+  using std__optional_STTLoadOptions_ = std::optional<STTLoadOptions>;
+  inline std::optional<STTLoadOptions> create_std__optional_STTLoadOptions_(const STTLoadOptions& value) noexcept {
+    return std::optional<STTLoadOptions>(value);
+  }
+  inline bool has_value_std__optional_STTLoadOptions_(const std::optional<STTLoadOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline STTLoadOptions get_std__optional_STTLoadOptions_(const std::optional<STTLoadOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridSTTSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridSTTSpec>`.
+   */
+  using std__shared_ptr_HybridSTTSpec_ = std::shared_ptr<HybridSTTSpec>;
+  std::shared_ptr<HybridSTTSpec> create_std__shared_ptr_HybridSTTSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridSTTSpec_(std__shared_ptr_HybridSTTSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridSTTSpec>
+  using std__weak_ptr_HybridSTTSpec_ = std::weak_ptr<HybridSTTSpec>;
+  inline std__weak_ptr_HybridSTTSpec_ weakify_std__shared_ptr_HybridSTTSpec_(const std::shared_ptr<HybridSTTSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<TTSLoadOptions>
+  /**
+   * Specialized version of `std::optional<TTSLoadOptions>`.
+   */
+  using std__optional_TTSLoadOptions_ = std::optional<TTSLoadOptions>;
+  inline std::optional<TTSLoadOptions> create_std__optional_TTSLoadOptions_(const TTSLoadOptions& value) noexcept {
+    return std::optional<TTSLoadOptions>(value);
+  }
+  inline bool has_value_std__optional_TTSLoadOptions_(const std::optional<TTSLoadOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TTSLoadOptions get_std__optional_TTSLoadOptions_(const std::optional<TTSLoadOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ = std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___() noexcept {
+    return Promise<std::shared_ptr<ArrayBuffer>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<ArrayBuffer>> wrap_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___(std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<ArrayBuffer>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<ArrayBuffer>&)>`.
+   */
+  using Func_void_std__shared_ptr_ArrayBuffer_ = std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<ArrayBuffer>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_ArrayBuffer__Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>>(std::move(func))) {}
+    inline void call(ArrayBufferHolder result) const noexcept {
+      _function->operator()(result.getArrayBuffer());
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_ArrayBuffer__Wrapper wrap_Func_void_std__shared_ptr_ArrayBuffer_(Func_void_std__shared_ptr_ArrayBuffer_ value) noexcept {
+    return Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<TTSGenerateOptions>
+  /**
+   * Specialized version of `std::optional<TTSGenerateOptions>`.
+   */
+  using std__optional_TTSGenerateOptions_ = std::optional<TTSGenerateOptions>;
+  inline std::optional<TTSGenerateOptions> create_std__optional_TTSGenerateOptions_(const TTSGenerateOptions& value) noexcept {
+    return std::optional<TTSGenerateOptions>(value);
+  }
+  inline bool has_value_std__optional_TTSGenerateOptions_(const std::optional<TTSGenerateOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TTSGenerateOptions get_std__optional_TTSGenerateOptions_(const std::optional<TTSGenerateOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridTTSSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridTTSSpec>`.
+   */
+  using std__shared_ptr_HybridTTSSpec_ = std::shared_ptr<HybridTTSSpec>;
+  std::shared_ptr<HybridTTSSpec> create_std__shared_ptr_HybridTTSSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridTTSSpec_(std__shared_ptr_HybridTTSSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridTTSSpec>
+  using std__weak_ptr_HybridTTSSpec_ = std::weak_ptr<HybridTTSSpec>;
+  inline std__weak_ptr_HybridTTSSpec_ weakify_std__shared_ptr_HybridTTSSpec_(const std::shared_ptr<HybridTTSSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>
+  using Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ = Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>;
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::mlxreactnative::bridge::swift

package/nitrogen/generated/ios/MLXReactNative-Swift-Cxx-Umbrella.hpp

@@ -2,7 +2,7 @@
 /// MLXReactNative-Swift-Cxx-Umbrella.hpp
 /// 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
 ///
 
 #pragma once
@@ -14,17 +14,40 @@ namespace margelo::nitro::mlxreactnative { struct GenerationStats; }
 namespace margelo::nitro::mlxreactnative { class HybridLLMSpec; }
 // Forward declaration of `HybridModelManagerSpec` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { class HybridModelManagerSpec; }
+// Forward declaration of `HybridSTTSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridSTTSpec; }
+// Forward declaration of `HybridTTSSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridTTSSpec; }
 // Forward declaration of `LLMLoadOptions` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMLoadOptions; }
 // Forward declaration of `LLMMessage` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMMessage; }
+// Forward declaration of `STTLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct STTLoadOptions; }
+// Forward declaration of `TTSGenerateOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSGenerateOptions; }
+// Forward declaration of `TTSLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSLoadOptions; }
+// Forward declaration of `ToolDefinition` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct ToolDefinition; }
+// Forward declaration of `ToolParameter` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct ToolParameter; }
 
 // Include C++ defined types
 #include "GenerationStats.hpp"
 #include "HybridLLMSpec.hpp"
 #include "HybridModelManagerSpec.hpp"
+#include "HybridSTTSpec.hpp"
+#include "HybridTTSSpec.hpp"
 #include "LLMLoadOptions.hpp"
 #include "LLMMessage.hpp"
+#include "STTLoadOptions.hpp"
+#include "TTSGenerateOptions.hpp"
+#include "TTSLoadOptions.hpp"
+#include "ToolDefinition.hpp"
+#include "ToolParameter.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -48,6 +71,10 @@ namespace margelo::nitro::mlxreactnative { struct LLMMessage; }
 namespace MLXReactNative { class HybridLLMSpec_cxx; }
 // Forward declaration of `HybridModelManagerSpec_cxx` to properly resolve imports.
 namespace MLXReactNative { class HybridModelManagerSpec_cxx; }
+// Forward declaration of `HybridSTTSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridSTTSpec_cxx; }
+// Forward declaration of `HybridTTSSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridTTSSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("MLXReactNative-Swift.h")

package/nitrogen/generated/ios/MLXReactNativeAutolinking.mm

@@ -2,7 +2,7 @@
 /// MLXReactNativeAutolinking.mm
 /// 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
 ///
 
 #import <Foundation/Foundation.h>
@@ -12,6 +12,8 @@
 
 #include "HybridLLMSpecSwift.hpp"
 #include "HybridModelManagerSpecSwift.hpp"
+#include "HybridTTSSpecSwift.hpp"
+#include "HybridSTTSpecSwift.hpp"
 
 @interface MLXReactNativeAutolinking : NSObject
 @end
@@ -36,6 +38,20 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "TTS",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridTTSSpec> hybridObject = MLXReactNative::MLXReactNativeAutolinking::createTTS();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "STT",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridSTTSpec> hybridObject = MLXReactNative::MLXReactNativeAutolinking::createSTT();
+      return hybridObject;
+    }
+  );
 }
 
 @end