react-native-nitro-mlx 0.1.1 → 0.2.1

package/lib/typescript/src/specs/LLM.nitro.d.ts

@@ -12,6 +12,20 @@ export interface GenerationStats {
     /** Total generation time in milliseconds */
     totalTime: number;
 }
+export interface LLMMessage {
+    role: string;
+    content: string;
+}
+/** Options for loading a model.
+ */
+export interface LLMLoadOptions {
+    /** Callback invoked with loading progress (0-1) */
+    onProgress?: (progress: number) => void;
+    /** Additional context to provide to the model */
+    additionalContext?: LLMMessage[];
+    /** Whether to automatically manage message history */
+    manageHistory?: boolean;
+}
 /**
  * Low-level LLM interface for text generation using MLX.
  * @internal Use the `LLM` export from `react-native-nitro-mlx` instead.
@@ -22,9 +36,9 @@ export interface LLM extends HybridObject<{
     /**
      * Load a model into memory. Downloads from HuggingFace if not already cached.
      * @param modelId - HuggingFace model ID (e.g., 'mlx-community/Qwen3-0.6B-4bit')
-     * @param onProgress - Callback invoked with loading progress (0-1)
+     * @param options - Callback invoked with loading progress (0-1)
      */
-    load(modelId: string, onProgress: (progress: number) => void): Promise<void>;
+    load(modelId: string, options?: LLMLoadOptions): Promise<void>;
     /**
      * Generate a complete response for a prompt.
      * @param prompt - The input text to generate a response for
@@ -42,11 +56,24 @@ export interface LLM extends HybridObject<{
      * Stop the current generation.
      */
     stop(): void;
+    /**
+     * Unload the current model and release memory.
+     */
+    unload(): void;
     /**
      * Get statistics from the last generation.
      * @returns Statistics including token count, speed, and timing
      */
     getLastGenerationStats(): GenerationStats;
+    /**
+     * Get the message history if management is enabled.
+     * @returns Array of messages in the history
+     */
+    getHistory(): LLMMessage[];
+    /**
+     * Clear the message history.
+     */
+    clearHistory(): void;
     /** Whether a model is currently loaded */
     readonly isLoaded: boolean;
     /** Whether text is currently being generated */

package/lib/typescript/src/specs/LLM.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LLM.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/LLM.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,eAAe,EAAE,MAAM,CAAA;IACvB,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAA;IACxB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,GAAI,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,CAAC;IACzD;;;;OAIG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE5E;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAEzC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAEzE;;OAEG;IACH,IAAI,IAAI,IAAI,CAAA;IAEZ;;;OAGG;IACH,sBAAsB,IAAI,eAAe,CAAA;IAEzC,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,gDAAgD;IAChD,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB,2BAA2B;IAC3B,KAAK,EAAE,OAAO,CAAA;IACd,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAA;CACrB"}
+{"version":3,"file":"LLM.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/LLM.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,eAAe,EAAE,MAAM,CAAA;IACvB,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAA;IACxB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;GACG;AACH,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,iDAAiD;IACjD,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAA;IAChC,sDAAsD;IACtD,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,GAAI,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,CAAC;IACzD;;;;OAIG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE9D;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAEzC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAEzE;;OAEG;IACH,IAAI,IAAI,IAAI,CAAA;IAEZ;;OAEG;IACH,MAAM,IAAI,IAAI,CAAA;IAEd;;;OAGG;IACH,sBAAsB,IAAI,eAAe,CAAA;IAEzC;;;OAGG;IACH,UAAU,IAAI,UAAU,EAAE,CAAA;IAE1B;;OAEG;IACH,YAAY,IAAI,IAAI,CAAA;IAEpB,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,gDAAgD;IAChD,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB,2BAA2B;IAC3B,KAAK,EAAE,OAAO,CAAA;IACd,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAA;CACrB"}

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

@@ -14,6 +14,10 @@ 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 `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 declarations of Swift defined types
 // Forward declaration of `HybridLLMSpec_cxx` to properly resolve imports.
@@ -25,12 +29,15 @@ namespace MLXReactNative { class HybridModelManagerSpec_cxx; }
 #include "GenerationStats.hpp"
 #include "HybridLLMSpec.hpp"
 #include "HybridModelManagerSpec.hpp"
+#include "LLMLoadOptions.hpp"
+#include "LLMMessage.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -118,6 +125,77 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
     return Func_void_double_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<std::function<void(double /* progress */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(double / * progress * /)>>`.
+   */
+  using std__optional_std__function_void_double____progress______ = std::optional<std::function<void(double /* progress */)>>;
+  inline std::optional<std::function<void(double /* progress */)>> create_std__optional_std__function_void_double____progress______(const std::function<void(double /* progress */)>& value) noexcept {
+    return std::optional<std::function<void(double /* progress */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_double____progress______(const std::optional<std::function<void(double /* progress */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(double /* progress */)> get_std__optional_std__function_void_double____progress______(const std::optional<std::function<void(double /* progress */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<LLMMessage>
+  /**
+   * Specialized version of `std::vector<LLMMessage>`.
+   */
+  using std__vector_LLMMessage_ = std::vector<LLMMessage>;
+  inline std::vector<LLMMessage> create_std__vector_LLMMessage_(size_t size) noexcept {
+    std::vector<LLMMessage> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<LLMMessage>>
+  /**
+   * Specialized version of `std::optional<std::vector<LLMMessage>>`.
+   */
+  using std__optional_std__vector_LLMMessage__ = std::optional<std::vector<LLMMessage>>;
+  inline std::optional<std::vector<LLMMessage>> create_std__optional_std__vector_LLMMessage__(const std::vector<LLMMessage>& value) noexcept {
+    return std::optional<std::vector<LLMMessage>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_LLMMessage__(const std::optional<std::vector<LLMMessage>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<LLMMessage> get_std__optional_std__vector_LLMMessage__(const std::optional<std::vector<LLMMessage>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<LLMLoadOptions>
+  /**
+   * Specialized version of `std::optional<LLMLoadOptions>`.
+   */
+  using std__optional_LLMLoadOptions_ = std::optional<LLMLoadOptions>;
+  inline std::optional<LLMLoadOptions> create_std__optional_LLMLoadOptions_(const LLMLoadOptions& value) noexcept {
+    return std::optional<LLMLoadOptions>(value);
+  }
+  inline bool has_value_std__optional_LLMLoadOptions_(const std::optional<LLMLoadOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline LLMLoadOptions get_std__optional_LLMLoadOptions_(const std::optional<LLMLoadOptions>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<std::string>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::string>>`.
@@ -200,6 +278,15 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
     return Result<GenerationStats>::withError(error);
   }
   
+  // pragma MARK: Result<std::vector<LLMMessage>>
+  using Result_std__vector_LLMMessage__ = Result<std::vector<LLMMessage>>;
+  inline Result_std__vector_LLMMessage__ create_Result_std__vector_LLMMessage__(const std::vector<LLMMessage>& value) noexcept {
+    return Result<std::vector<LLMMessage>>::withValue(value);
+  }
+  inline Result_std__vector_LLMMessage__ create_Result_std__vector_LLMMessage__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<LLMMessage>>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<bool>>
   /**
    * Specialized version of `std::shared_ptr<Promise<bool>>`.

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

@@ -14,16 +14,23 @@ 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 `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; }
 
 // Include C++ defined types
 #include "GenerationStats.hpp"
 #include "HybridLLMSpec.hpp"
 #include "HybridModelManagerSpec.hpp"
+#include "LLMLoadOptions.hpp"
+#include "LLMMessage.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 

package/nitrogen/generated/ios/c++/HybridLLMSpecSwift.hpp

@@ -12,12 +12,20 @@
 // Forward declaration of `HybridLLMSpec_cxx` to properly resolve imports.
 namespace MLXReactNative { class HybridLLMSpec_cxx; }
 
+// 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 `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct GenerationStats; }
 
 #include <string>
 #include <NitroModules/Promise.hpp>
+#include "LLMLoadOptions.hpp"
+#include <optional>
 #include <functional>
+#include "LLMMessage.hpp"
+#include <vector>
 #include "GenerationStats.hpp"
 
 #include "MLXReactNative-Swift-Cxx-Umbrella.hpp"
@@ -86,8 +94,8 @@ namespace margelo::nitro::mlxreactnative {
 
   public:
     // Methods
-    inline std::shared_ptr<Promise<void>> load(const std::string& modelId, const std::function<void(double /* progress */)>& onProgress) override {
-      auto __result = _swiftPart.load(modelId, onProgress);
+    inline std::shared_ptr<Promise<void>> load(const std::string& modelId, const std::optional<LLMLoadOptions>& options) override {
+      auto __result = _swiftPart.load(modelId, options);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -116,6 +124,12 @@ namespace margelo::nitro::mlxreactnative {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void unload() override {
+      auto __result = _swiftPart.unload();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline GenerationStats getLastGenerationStats() override {
       auto __result = _swiftPart.getLastGenerationStats();
       if (__result.hasError()) [[unlikely]] {
@@ -124,6 +138,20 @@ namespace margelo::nitro::mlxreactnative {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::vector<LLMMessage> getHistory() override {
+      auto __result = _swiftPart.getHistory();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void clearHistory() override {
+      auto __result = _swiftPart.clearHistory();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
 
   private:
     MLXReactNative::HybridLLMSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridLLMSpec.swift

@@ -18,11 +18,14 @@ public protocol HybridLLMSpec_protocol: HybridObject {
   var systemPrompt: String { get set }
 
   // Methods
-  func load(modelId: String, onProgress: @escaping (_ progress: Double) -> Void) throws -> Promise<Void>
+  func load(modelId: String, options: LLMLoadOptions?) throws -> Promise<Void>
   func generate(prompt: String) throws -> Promise<String>
   func stream(prompt: String, onToken: @escaping (_ token: String) -> Void) throws -> Promise<String>
   func stop() throws -> Void
+  func unload() throws -> Void
   func getLastGenerationStats() throws -> GenerationStats
+  func getHistory() throws -> [LLMMessage]
+  func clearHistory() throws -> Void
 }
 
 public extension HybridLLMSpec_protocol {

package/nitrogen/generated/ios/swift/HybridLLMSpec_cxx.swift

@@ -159,14 +159,9 @@ open class HybridLLMSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func load(modelId: std.string, onProgress: bridge.Func_void_double) -> bridge.Result_std__shared_ptr_Promise_void___ {
+  public final func load(modelId: std.string, options: bridge.std__optional_LLMLoadOptions_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      let __result = try self.__implementation.load(modelId: String(modelId), onProgress: { () -> (Double) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_double(onProgress)
-        return { (__progress: Double) -> Void in
-          __wrappedFunction.call(__progress)
-        }
-      }())
+      let __result = try self.__implementation.load(modelId: String(modelId), options: options.value)
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
@@ -236,6 +231,17 @@ open class HybridLLMSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func unload() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.unload()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getLastGenerationStats() -> bridge.Result_GenerationStats_ {
     do {
@@ -247,4 +253,33 @@ open class HybridLLMSpec_cxx {
       return bridge.create_Result_GenerationStats_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func getHistory() -> bridge.Result_std__vector_LLMMessage__ {
+    do {
+      let __result = try self.__implementation.getHistory()
+      let __resultCpp = { () -> bridge.std__vector_LLMMessage_ in
+        var __vector = bridge.create_std__vector_LLMMessage_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_LLMMessage__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_LLMMessage__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearHistory() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.clearHistory()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/LLMLoadOptions.swift

@@ -0,0 +1,138 @@
+///
+/// LLMLoadOptions.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `LLMLoadOptions`, backed by a C++ struct.
+ */
+public typealias LLMLoadOptions = margelo.nitro.mlxreactnative.LLMLoadOptions
+
+public extension LLMLoadOptions {
+  private typealias bridge = margelo.nitro.mlxreactnative.bridge.swift
+
+  /**
+   * Create a new instance of `LLMLoadOptions`.
+   */
+  init(onProgress: ((_ progress: Double) -> Void)?, additionalContext: [LLMMessage]?, manageHistory: Bool?) {
+    self.init({ () -> bridge.std__optional_std__function_void_double____progress______ in
+      if let __unwrappedValue = onProgress {
+        return bridge.create_std__optional_std__function_void_double____progress______({ () -> bridge.Func_void_double in
+          let __closureWrapper = Func_void_double(__unwrappedValue)
+          return bridge.create_Func_void_double(__closureWrapper.toUnsafe())
+        }())
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__vector_LLMMessage__ in
+      if let __unwrappedValue = additionalContext {
+        return bridge.create_std__optional_std__vector_LLMMessage__({ () -> bridge.std__vector_LLMMessage_ in
+          var __vector = bridge.create_std__vector_LLMMessage_(__unwrappedValue.count)
+          for __item in __unwrappedValue {
+            __vector.push_back(__item)
+          }
+          return __vector
+        }())
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = manageHistory {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var onProgress: ((_ progress: Double) -> Void)? {
+    @inline(__always)
+    get {
+      return { () -> ((_ progress: Double) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_double____progress______(self.__onProgress) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_double____progress______(self.__onProgress)
+          return { () -> (Double) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_double(__unwrapped)
+            return { (__progress: Double) -> Void in
+              __wrappedFunction.call(__progress)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__onProgress = { () -> bridge.std__optional_std__function_void_double____progress______ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__function_void_double____progress______({ () -> bridge.Func_void_double in
+            let __closureWrapper = Func_void_double(__unwrappedValue)
+            return bridge.create_Func_void_double(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var additionalContext: [LLMMessage]? {
+    @inline(__always)
+    get {
+      return { () -> [LLMMessage]? in
+        if bridge.has_value_std__optional_std__vector_LLMMessage__(self.__additionalContext) {
+          let __unwrapped = bridge.get_std__optional_std__vector_LLMMessage__(self.__additionalContext)
+          return __unwrapped.map({ __item in __item })
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__additionalContext = { () -> bridge.std__optional_std__vector_LLMMessage__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__vector_LLMMessage__({ () -> bridge.std__vector_LLMMessage_ in
+            var __vector = bridge.create_std__vector_LLMMessage_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var manageHistory: Bool? {
+    @inline(__always)
+    get {
+      return { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(self.__manageHistory) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__manageHistory)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__manageHistory = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/LLMMessage.swift

@@ -0,0 +1,47 @@
+///
+/// LLMMessage.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `LLMMessage`, backed by a C++ struct.
+ */
+public typealias LLMMessage = margelo.nitro.mlxreactnative.LLMMessage
+
+public extension LLMMessage {
+  private typealias bridge = margelo.nitro.mlxreactnative.bridge.swift
+
+  /**
+   * Create a new instance of `LLMMessage`.
+   */
+  init(role: String, content: String) {
+    self.init(std.string(role), std.string(content))
+  }
+
+  var role: String {
+    @inline(__always)
+    get {
+      return String(self.__role)
+    }
+    @inline(__always)
+    set {
+      self.__role = std.string(newValue)
+    }
+  }
+  
+  var content: String {
+    @inline(__always)
+    get {
+      return String(self.__content)
+    }
+    @inline(__always)
+    set {
+      self.__content = std.string(newValue)
+    }
+  }
+}

package/nitrogen/generated/shared/c++/HybridLLMSpec.cpp

@@ -25,7 +25,10 @@ namespace margelo::nitro::mlxreactnative {
       prototype.registerHybridMethod("generate", &HybridLLMSpec::generate);
       prototype.registerHybridMethod("stream", &HybridLLMSpec::stream);
       prototype.registerHybridMethod("stop", &HybridLLMSpec::stop);
+      prototype.registerHybridMethod("unload", &HybridLLMSpec::unload);
       prototype.registerHybridMethod("getLastGenerationStats", &HybridLLMSpec::getLastGenerationStats);
+      prototype.registerHybridMethod("getHistory", &HybridLLMSpec::getHistory);
+      prototype.registerHybridMethod("clearHistory", &HybridLLMSpec::clearHistory);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridLLMSpec.hpp

@@ -13,13 +13,21 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `LLMLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct LLMLoadOptions; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct GenerationStats; }
+// Forward declaration of `LLMMessage` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct LLMMessage; }
 
 #include <string>
 #include <NitroModules/Promise.hpp>
+#include "LLMLoadOptions.hpp"
+#include <optional>
 #include <functional>
 #include "GenerationStats.hpp"
+#include "LLMMessage.hpp"
+#include <vector>
 
 namespace margelo::nitro::mlxreactnative {
 
@@ -58,11 +66,14 @@ namespace margelo::nitro::mlxreactnative {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<void>> load(const std::string& modelId, const std::function<void(double /* progress */)>& onProgress) = 0;
+      virtual std::shared_ptr<Promise<void>> load(const std::string& modelId, const std::optional<LLMLoadOptions>& options) = 0;
       virtual std::shared_ptr<Promise<std::string>> generate(const std::string& prompt) = 0;
       virtual std::shared_ptr<Promise<std::string>> stream(const std::string& prompt, const std::function<void(const std::string& /* token */)>& onToken) = 0;
       virtual void stop() = 0;
+      virtual void unload() = 0;
       virtual GenerationStats getLastGenerationStats() = 0;
+      virtual std::vector<LLMMessage> getHistory() = 0;
+      virtual void clearHistory() = 0;
 
     protected:
       // Hybrid Setup