react-native-nitro-mlx 0.1.1 → 0.2.0

package/ios/Sources/HybridLLM.swift

@@ -7,6 +7,7 @@ internal import MLXLMCommon
 class HybridLLM: HybridLLMSpec {
     private var session: ChatSession?
     private var currentTask: Task<String, Error>?
+    private var container: Any?
     private var lastStats: GenerationStats = GenerationStats(
         tokenCount: 0,
         tokensPerSecond: 0,
@@ -14,12 +15,15 @@ class HybridLLM: HybridLLMSpec {
         totalTime: 0
     )
     private var modelFactory: ModelFactory = LLMModelFactory.shared
+    private var manageHistory: Bool = false
+    private var messageHistory: [LLMMessage] = []
 
     var isLoaded: Bool { session != nil }
     var isGenerating: Bool { currentTask != nil }
     var modelId: String = ""
     var debug: Bool = false
     var systemPrompt: String = "You are a helpful assistant."
+    var additionalContext: LLMMessage = LLMMessage()
 
     private func log(_ message: String) {
         if debug {
@@ -27,21 +31,80 @@ class HybridLLM: HybridLLMSpec {
         }
     }
 
-    func load(modelId: String, onProgress: @escaping (Double) -> Void) throws -> Promise<Void> {
+    private func getMemoryUsage() -> String {
+        var taskInfo = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
+        let result: kern_return_t = withUnsafeMutablePointer(to: &taskInfo) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                task_info(mach_task_self_,
+                         task_flavor_t(MACH_TASK_BASIC_INFO),
+                         $0,
+                         &count)
+            }
+        }
+
+        if result == KERN_SUCCESS {
+            let usedMB = Float(taskInfo.resident_size) / 1024.0 / 1024.0
+            return String(format: "%.1f MB", usedMB)
+        } else {
+            return "unknown"
+        }
+    }
+
+    private func getGPUMemoryUsage() -> String {
+        let snapshot = GPU.snapshot()
+        let allocatedMB = Float(snapshot.activeMemory) / 1024.0 / 1024.0
+        let cacheMB = Float(snapshot.cacheMemory) / 1024.0 / 1024.0
+        let peakMB = Float(snapshot.peakMemory) / 1024.0 / 1024.0
+        return String(format: "Allocated: %.1f MB, Cache: %.1f MB, Peak: %.1f MB",
+                     allocatedMB, cacheMB, peakMB)
+    }
+
+    func load(modelId: String, options: LLMLoadOptions?) throws -> Promise<Void> {
         return Promise.async { [self] in
+            MLX.GPU.set(cacheLimit: 2000000)
+
+            self.currentTask?.cancel()
+            self.currentTask = nil
+            self.session = nil
+            self.container = nil
+            MLX.GPU.clearCache()
+
+            let memoryAfterCleanup = self.getMemoryUsage()
+            let gpuAfterCleanup = self.getGPUMemoryUsage()
+            log("After cleanup - Host: \(memoryAfterCleanup), GPU: \(gpuAfterCleanup)")
+
             let modelDir = await ModelDownloader.shared.getModelDirectory(modelId: modelId)
             log("Loading from directory: \(modelDir.path)")
 
             let config = ModelConfiguration(directory: modelDir)
-            let container = try await modelFactory.loadContainer(
+            let loadedContainer = try await modelFactory.loadContainer(
                 configuration: config
             ) { progress in
-                onProgress(progress.fractionCompleted)
+                options?.onProgress?(progress.fractionCompleted)
             }
 
-            self.session = ChatSession(container, instructions: self.systemPrompt)
+            let memoryAfterContainer = self.getMemoryUsage()
+            let gpuAfterContainer = self.getGPUMemoryUsage()
+            log("Model loaded - Host: \(memoryAfterContainer), GPU: \(gpuAfterContainer)")
+
+            // Convert [LLMMessage]? to [String: Any]?
+            let additionalContextDict: [String: Any]? = if let messages = options?.additionalContext {
+                ["messages": messages.map { ["role": $0.role, "content": $0.content] }]
+            } else {
+                nil
+            }
+
+            self.container = loadedContainer
+            self.session = ChatSession(loadedContainer, instructions: self.systemPrompt, additionalContext: additionalContextDict)
             self.modelId = modelId
-            log("Model loaded with system prompt: \(self.systemPrompt.prefix(50))...")
+
+            self.manageHistory = options?.manageHistory ?? false
+            self.messageHistory = options?.additionalContext ?? []
+
+            if self.manageHistory {
+                log("History management enabled with \(self.messageHistory.count) initial messages")
+            }
         }
     }
 
@@ -51,6 +114,10 @@ class HybridLLM: HybridLLMSpec {
         }
 
         return Promise.async { [self] in
+            if self.manageHistory {
+                self.messageHistory.append(LLMMessage(role: "user", content: prompt))
+            }
+
             let task = Task<String, Error> {
                 log("Generating response for: \(prompt.prefix(50))...")
                 let result = try await session.respond(to: prompt)
@@ -63,6 +130,11 @@ class HybridLLM: HybridLLMSpec {
             do {
                 let result = try await task.value
                 self.currentTask = nil
+
+                if self.manageHistory {
+                    self.messageHistory.append(LLMMessage(role: "assistant", content: result))
+                }
+
                 return result
             } catch {
                 self.currentTask = nil
@@ -77,6 +149,10 @@ class HybridLLM: HybridLLMSpec {
         }
 
         return Promise.async { [self] in
+            if self.manageHistory {
+                self.messageHistory.append(LLMMessage(role: "user", content: prompt))
+            }
+
             let task = Task<String, Error> {
                 var result = ""
                 var tokenCount = 0
@@ -116,6 +192,11 @@ class HybridLLM: HybridLLMSpec {
             do {
                 let result = try await task.value
                 self.currentTask = nil
+
+                if self.manageHistory {
+                    self.messageHistory.append(LLMMessage(role: "assistant", content: result))
+                }
+
                 return result
             } catch {
                 self.currentTask = nil
@@ -129,7 +210,36 @@ class HybridLLM: HybridLLMSpec {
         currentTask = nil
     }
 
+    func unload() throws {
+        let memoryBefore = getMemoryUsage()
+        let gpuBefore = getGPUMemoryUsage()
+        log("Before unload - Host: \(memoryBefore), GPU: \(gpuBefore)")
+
+        currentTask?.cancel()
+        currentTask = nil
+        session = nil
+        container = nil
+        messageHistory = []
+        manageHistory = false
+        modelId = ""
+
+        MLX.GPU.clearCache()
+
+        let memoryAfter = getMemoryUsage()
+        let gpuAfter = getGPUMemoryUsage()
+        log("After unload - Host: \(memoryAfter), GPU: \(gpuAfter)")
+    }
+
     func getLastGenerationStats() throws -> GenerationStats {
         return lastStats
     }
+
+    func getHistory() throws -> [LLMMessage] {
+        return messageHistory
+    }
+
+    func clearHistory() throws {
+        messageHistory = []
+        log("Message history cleared")
+    }
 }

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["LLM","ModelManager","MLXModel"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,GAAG,QAAQ,UAAO;AAC3B,SAASC,YAAY,QAAQ,mBAAgB;AAC7C,SAASC,QAAQ,QAAQ,aAAU","ignoreList":[]}
+{"version":3,"names":["LLM","ModelManager","MLXModel"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,GAAG,QAAsB,UAAO;AACzC,SAASC,YAAY,QAAQ,mBAAgB;AAC7C,SAASC,QAAQ,QAAQ,aAAU","ignoreList":[]}

package/lib/module/llm.js

@@ -35,10 +35,10 @@ export const LLM = {
   /**
    * Load a model into memory. Downloads the model 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, onProgress) {
-    return getInstance().load(modelId, onProgress);
+  load(modelId, options) {
+    return getInstance().load(modelId, options);
   },
   /**
    * Generate a complete response for a prompt. Blocks until generation is complete.
@@ -64,6 +64,13 @@ export const LLM = {
   stop() {
     getInstance().stop();
   },
+  /**
+   * Unload the current model and release memory.
+   * Call this when you're done with the model to free up memory.
+   */
+  unload() {
+    getInstance().unload();
+  },
   /**
    * Get statistics from the last generation.
    * @returns Statistics including token count, tokens/sec, TTFT, and total time
@@ -71,6 +78,19 @@ export const LLM = {
   getLastGenerationStats() {
     return getInstance().getLastGenerationStats();
   },
+  /**
+   * Get the message history if management is enabled.
+   * @returns Array of messages in the history
+   */
+  getHistory() {
+    return getInstance().getHistory();
+  },
+  /**
+   * Clear the message history.
+   */
+  clearHistory() {
+    getInstance().clearHistory();
+  },
   /** Whether a model is currently loaded and ready for generation */
   get isLoaded() {
     return getInstance().isLoaded;

package/lib/module/llm.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","instance","getInstance","createHybridObject","LLM","load","modelId","onProgress","generate","prompt","stream","onToken","stop","getLastGenerationStats","isLoaded","isGenerating","debug","value","systemPrompt"],"sourceRoot":"../../src","sources":["llm.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,IAAIC,QAAwB,GAAG,IAAI;AAEnC,SAASC,WAAWA,CAAA,EAAY;EAC9B,IAAI,CAACD,QAAQ,EAAE;IACbA,QAAQ,GAAGD,YAAY,CAACG,kBAAkB,CAAU,KAAK,CAAC;EAC5D;EACA,OAAOF,QAAQ;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMG,GAAG,GAAG;EACjB;AACF;AACA;AACA;AACA;EACEC,IAAIA,CAACC,OAAe,EAAEC,UAAsC,EAAiB;IAC3E,OAAOL,WAAW,CAAC,CAAC,CAACG,IAAI,CAACC,OAAO,EAAEC,UAAU,CAAC;EAChD,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;EACEC,QAAQA,CAACC,MAAc,EAAmB;IACxC,OAAOP,WAAW,CAAC,CAAC,CAACM,QAAQ,CAACC,MAAM,CAAC;EACvC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;EACEC,MAAMA,CAACD,MAAc,EAAEE,OAAgC,EAAmB;IACxE,OAAOT,WAAW,CAAC,CAAC,CAACQ,MAAM,CAACD,MAAM,EAAEE,OAAO,CAAC;EAC9C,CAAC;EAED;AACF;AACA;EACEC,IAAIA,CAAA,EAAS;IACXV,WAAW,CAAC,CAAC,CAACU,IAAI,CAAC,CAAC;EACtB,CAAC;EAED;AACF;AACA;AACA;EACEC,sBAAsBA,CAAA,EAAoB;IACxC,OAAOX,WAAW,CAAC,CAAC,CAACW,sBAAsB,CAAC,CAAC;EAC/C,CAAC;EAED;EACA,IAAIC,QAAQA,CAAA,EAAY;IACtB,OAAOZ,WAAW,CAAC,CAAC,CAACY,QAAQ;EAC/B,CAAC;EAED;EACA,IAAIC,YAAYA,CAAA,EAAY;IAC1B,OAAOb,WAAW,CAAC,CAAC,CAACa,YAAY;EACnC,CAAC;EAED;EACA,IAAIT,OAAOA,CAAA,EAAW;IACpB,OAAOJ,WAAW,CAAC,CAAC,CAACI,OAAO;EAC9B,CAAC;EAED;EACA,IAAIU,KAAKA,CAAA,EAAY;IACnB,OAAOd,WAAW,CAAC,CAAC,CAACc,KAAK;EAC5B,CAAC;EAED,IAAIA,KAAKA,CAACC,KAAc,EAAE;IACxBf,WAAW,CAAC,CAAC,CAACc,KAAK,GAAGC,KAAK;EAC7B,CAAC;EAED;AACF;AACA;AACA;AACA;EACE,IAAIC,YAAYA,CAAA,EAAW;IACzB,OAAOhB,WAAW,CAAC,CAAC,CAACgB,YAAY;EACnC,CAAC;EAED,IAAIA,YAAYA,CAACD,KAAa,EAAE;IAC9Bf,WAAW,CAAC,CAAC,CAACgB,YAAY,GAAGD,KAAK;EACpC;AACF,CAAC","ignoreList":[]}
+{"version":3,"names":["NitroModules","instance","getInstance","createHybridObject","LLM","load","modelId","options","generate","prompt","stream","onToken","stop","unload","getLastGenerationStats","getHistory","clearHistory","isLoaded","isGenerating","debug","value","systemPrompt"],"sourceRoot":"../../src","sources":["llm.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,IAAIC,QAAwB,GAAG,IAAI;AAOnC,SAASC,WAAWA,CAAA,EAAY;EAC9B,IAAI,CAACD,QAAQ,EAAE;IACbA,QAAQ,GAAGD,YAAY,CAACG,kBAAkB,CAAU,KAAK,CAAC;EAC5D;EACA,OAAOF,QAAQ;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMG,GAAG,GAAG;EACjB;AACF;AACA;AACA;AACA;EACEC,IAAIA,CAACC,OAAe,EAAEC,OAAuB,EAAiB;IAC5D,OAAOL,WAAW,CAAC,CAAC,CAACG,IAAI,CAACC,OAAO,EAAEC,OAAO,CAAC;EAC7C,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;EACEC,QAAQA,CAACC,MAAc,EAAmB;IACxC,OAAOP,WAAW,CAAC,CAAC,CAACM,QAAQ,CAACC,MAAM,CAAC;EACvC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;EACEC,MAAMA,CAACD,MAAc,EAAEE,OAAgC,EAAmB;IACxE,OAAOT,WAAW,CAAC,CAAC,CAACQ,MAAM,CAACD,MAAM,EAAEE,OAAO,CAAC;EAC9C,CAAC;EAED;AACF;AACA;EACEC,IAAIA,CAAA,EAAS;IACXV,WAAW,CAAC,CAAC,CAACU,IAAI,CAAC,CAAC;EACtB,CAAC;EAED;AACF;AACA;AACA;EACEC,MAAMA,CAAA,EAAS;IACbX,WAAW,CAAC,CAAC,CAACW,MAAM,CAAC,CAAC;EACxB,CAAC;EAED;AACF;AACA;AACA;EACEC,sBAAsBA,CAAA,EAAoB;IACxC,OAAOZ,WAAW,CAAC,CAAC,CAACY,sBAAsB,CAAC,CAAC;EAC/C,CAAC;EAED;AACF;AACA;AACA;EACEC,UAAUA,CAAA,EAAc;IACtB,OAAOb,WAAW,CAAC,CAAC,CAACa,UAAU,CAAC,CAAC;EACnC,CAAC;EAED;AACF;AACA;EACEC,YAAYA,CAAA,EAAS;IACnBd,WAAW,CAAC,CAAC,CAACc,YAAY,CAAC,CAAC;EAC9B,CAAC;EAED;EACA,IAAIC,QAAQA,CAAA,EAAY;IACtB,OAAOf,WAAW,CAAC,CAAC,CAACe,QAAQ;EAC/B,CAAC;EAED;EACA,IAAIC,YAAYA,CAAA,EAAY;IAC1B,OAAOhB,WAAW,CAAC,CAAC,CAACgB,YAAY;EACnC,CAAC;EAED;EACA,IAAIZ,OAAOA,CAAA,EAAW;IACpB,OAAOJ,WAAW,CAAC,CAAC,CAACI,OAAO;EAC9B,CAAC;EAED;EACA,IAAIa,KAAKA,CAAA,EAAY;IACnB,OAAOjB,WAAW,CAAC,CAAC,CAACiB,KAAK;EAC5B,CAAC;EAED,IAAIA,KAAKA,CAACC,KAAc,EAAE;IACxBlB,WAAW,CAAC,CAAC,CAACiB,KAAK,GAAGC,KAAK;EAC7B,CAAC;EAED;AACF;AACA;AACA;AACA;EACE,IAAIC,YAAYA,CAAA,EAAW;IACzB,OAAOnB,WAAW,CAAC,CAAC,CAACmB,YAAY;EACnC,CAAC;EAED,IAAIA,YAAYA,CAACD,KAAa,EAAE;IAC9BlB,WAAW,CAAC,CAAC,CAACmB,YAAY,GAAGD,KAAK;EACpC;AACF,CAAC","ignoreList":[]}

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

@@ -1,6 +1,6 @@
-export { LLM } from './llm';
+export { LLM, type Message } from './llm';
 export { ModelManager } from './modelManager';
 export { MLXModel } from './models';
-export type { GenerationStats, LLM as LLMSpec } from './specs/LLM.nitro';
+export type { GenerationStats, LLM as LLMSpec, LLMLoadOptions } from './specs/LLM.nitro';
 export type { ModelManager as ModelManagerSpec } from './specs/ModelManager.nitro';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,YAAY,EAAE,eAAe,EAAE,GAAG,IAAI,OAAO,EAAE,MAAM,mBAAmB,CAAA;AACxE,YAAY,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,4BAA4B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,EAAE,MAAM,OAAO,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,YAAY,EAAE,eAAe,EAAE,GAAG,IAAI,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACxF,YAAY,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,4BAA4B,CAAA"}

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

@@ -1,4 +1,8 @@
-import type { GenerationStats } from './specs/LLM.nitro';
+import type { GenerationStats, LLMLoadOptions } from './specs/LLM.nitro';
+export type Message = {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+};
 /**
  * LLM text generation using MLX on Apple Silicon.
  *
@@ -25,9 +29,9 @@ export declare const LLM: {
     /**
      * Load a model into memory. Downloads the model 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. Blocks until generation is complete.
      * For streaming responses, use `stream()` instead.
@@ -46,11 +50,25 @@ export declare const LLM: {
      * Stop the current generation. Safe to call even if not generating.
      */
     stop(): void;
+    /**
+     * Unload the current model and release memory.
+     * Call this when you're done with the model to free up memory.
+     */
+    unload(): void;
     /**
      * Get statistics from the last generation.
      * @returns Statistics including token count, tokens/sec, TTFT, and total time
      */
     getLastGenerationStats(): GenerationStats;
+    /**
+     * Get the message history if management is enabled.
+     * @returns Array of messages in the history
+     */
+    getHistory(): Message[];
+    /**
+     * Clear the message history.
+     */
+    clearHistory(): void;
     /** Whether a model is currently loaded and ready for generation */
     readonly isLoaded: boolean;
     /** Whether text is currently being generated */

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

@@ -1 +1 @@
-{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/llm.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,mBAAmB,CAAA;AAWxE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,GAAG;IACd;;;;OAIG;kBACW,MAAM,cAAc,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5E;;;;;OAKG;qBACc,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzC;;;;;OAKG;mBACY,MAAM,WAAW,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzE;;OAEG;YACK,IAAI;IAIZ;;;OAGG;8BACuB,eAAe;IAIzC,mEAAmE;uBACnD,OAAO;IAIvB,gDAAgD;2BAC5B,OAAO;IAI3B,oEAAoE;sBACrD,MAAM;IAIrB,sCAAsC;WACzB,OAAO;IAQpB;;;;OAIG;kBACiB,MAAM;CAO3B,CAAA"}
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/llm.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAA;AAIxF,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAA;IACrC,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AASD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,GAAG;IACd;;;;OAIG;kBACW,MAAM,WAAW,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7D;;;;;OAKG;qBACc,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzC;;;;;OAKG;mBACY,MAAM,WAAW,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzE;;OAEG;YACK,IAAI;IAIZ;;;OAGG;cACO,IAAI;IAId;;;OAGG;8BACuB,eAAe;IAIzC;;;OAGG;kBACW,OAAO,EAAE;IAIvB;;OAEG;oBACa,IAAI;IAIpB,mEAAmE;uBACnD,OAAO;IAIvB,gDAAgD;2BAC5B,OAAO;IAI3B,oEAAoE;sBACrD,MAAM;IAIrB,sCAAsC;WACzB,OAAO;IAQpB;;;;OAIG;kBACiB,MAAM;CAO3B,CAAA"}

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

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

@@ -0,0 +1,87 @@
+///
+/// LLMLoadOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `LLMMessage` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct LLMMessage; }
+
+#include <functional>
+#include <optional>
+#include "LLMMessage.hpp"
+#include <vector>
+
+namespace margelo::nitro::mlxreactnative {
+
+  /**
+   * A struct which can be represented as a JavaScript object (LLMLoadOptions).
+   */
+  struct LLMLoadOptions {
+  public:
+    std::optional<std::function<void(double /* progress */)>> onProgress     SWIFT_PRIVATE;
+    std::optional<std::vector<LLMMessage>> additionalContext     SWIFT_PRIVATE;
+    std::optional<bool> manageHistory     SWIFT_PRIVATE;
+
+  public:
+    LLMLoadOptions() = default;
+    explicit LLMLoadOptions(std::optional<std::function<void(double /* progress */)>> onProgress, std::optional<std::vector<LLMMessage>> additionalContext, std::optional<bool> manageHistory): onProgress(onProgress), additionalContext(additionalContext), manageHistory(manageHistory) {}
+  };
+
+} // namespace margelo::nitro::mlxreactnative
+
+namespace margelo::nitro {
+
+  // C++ LLMLoadOptions <> JS LLMLoadOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::mlxreactnative::LLMLoadOptions> final {
+    static inline margelo::nitro::mlxreactnative::LLMLoadOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::mlxreactnative::LLMLoadOptions(
+        JSIConverter<std::optional<std::function<void(double)>>>::fromJSI(runtime, obj.getProperty(runtime, "onProgress")),
+        JSIConverter<std::optional<std::vector<margelo::nitro::mlxreactnative::LLMMessage>>>::fromJSI(runtime, obj.getProperty(runtime, "additionalContext")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "manageHistory"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::mlxreactnative::LLMLoadOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "onProgress", JSIConverter<std::optional<std::function<void(double)>>>::toJSI(runtime, arg.onProgress));
+      obj.setProperty(runtime, "additionalContext", JSIConverter<std::optional<std::vector<margelo::nitro::mlxreactnative::LLMMessage>>>::toJSI(runtime, arg.additionalContext));
+      obj.setProperty(runtime, "manageHistory", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.manageHistory));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<std::function<void(double)>>>::canConvert(runtime, obj.getProperty(runtime, "onProgress"))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::mlxreactnative::LLMMessage>>>::canConvert(runtime, obj.getProperty(runtime, "additionalContext"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "manageHistory"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,79 @@
+///
+/// LLMMessage.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::mlxreactnative {
+
+  /**
+   * A struct which can be represented as a JavaScript object (LLMMessage).
+   */
+  struct LLMMessage {
+  public:
+    std::string role     SWIFT_PRIVATE;
+    std::string content     SWIFT_PRIVATE;
+
+  public:
+    LLMMessage() = default;
+    explicit LLMMessage(std::string role, std::string content): role(role), content(content) {}
+  };
+
+} // namespace margelo::nitro::mlxreactnative
+
+namespace margelo::nitro {
+
+  // C++ LLMMessage <> JS LLMMessage (object)
+  template <>
+  struct JSIConverter<margelo::nitro::mlxreactnative::LLMMessage> final {
+    static inline margelo::nitro::mlxreactnative::LLMMessage fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::mlxreactnative::LLMMessage(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "role")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "content"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::mlxreactnative::LLMMessage& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "role", JSIConverter<std::string>::toJSI(runtime, arg.role));
+      obj.setProperty(runtime, "content", JSIConverter<std::string>::toJSI(runtime, arg.content));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "role"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "content"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-mlx",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Nitro module package",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
@@ -89,14 +89,6 @@
       "requireCleanWorkingDir": false
     },
     "plugins": {
-      "@release-it/bumper": {
-        "out": [
-          {
-            "file": "package.json",
-            "path": "version"
-          }
-        ]
-      },
       "@release-it/conventional-changelog": {
         "preset": {
           "name": "conventionalcommits",

package/src/index.ts

@@ -1,6 +1,6 @@
-export { LLM } from './llm'
+export { LLM, type Message } from './llm'
 export { ModelManager } from './modelManager'
 export { MLXModel } from './models'
 
-export type { GenerationStats, LLM as LLMSpec } from './specs/LLM.nitro'
+export type { GenerationStats, LLM as LLMSpec, LLMLoadOptions } from './specs/LLM.nitro'
 export type { ModelManager as ModelManagerSpec } from './specs/ModelManager.nitro'

package/src/llm.ts

@@ -1,8 +1,13 @@
 import { NitroModules } from 'react-native-nitro-modules'
-import type { GenerationStats, LLM as LLMSpec } from './specs/LLM.nitro'
+import type { GenerationStats, LLMLoadOptions, LLM as LLMSpec } from './specs/LLM.nitro'
 
 let instance: LLMSpec | null = null
 
+export type Message = {
+  role: 'user' | 'assistant' | 'system'
+  content: string
+}
+
 function getInstance(): LLMSpec {
   if (!instance) {
     instance = NitroModules.createHybridObject<LLMSpec>('LLM')
@@ -36,10 +41,10 @@ export const LLM = {
   /**
    * Load a model into memory. Downloads the model 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> {
-    return getInstance().load(modelId, onProgress)
+  load(modelId: string, options: LLMLoadOptions): Promise<void> {
+    return getInstance().load(modelId, options)
   },
 
   /**
@@ -69,6 +74,14 @@ export const LLM = {
     getInstance().stop()
   },
 
+  /**
+   * Unload the current model and release memory.
+   * Call this when you're done with the model to free up memory.
+   */
+  unload(): void {
+    getInstance().unload()
+  },
+
   /**
    * Get statistics from the last generation.
    * @returns Statistics including token count, tokens/sec, TTFT, and total time
@@ -77,6 +90,21 @@ export const LLM = {
     return getInstance().getLastGenerationStats()
   },
 
+  /**
+   * Get the message history if management is enabled.
+   * @returns Array of messages in the history
+   */
+  getHistory(): Message[] {
+    return getInstance().getHistory() as Message[]
+  },
+
+  /**
+   * Clear the message history.
+   */
+  clearHistory(): void {
+    getInstance().clearHistory()
+  },
+
   /** Whether a model is currently loaded and ready for generation */
   get isLoaded(): boolean {
     return getInstance().isLoaded

package/src/specs/LLM.nitro.ts

@@ -14,6 +14,22 @@ export interface GenerationStats {
   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 +38,9 @@ export interface LLM extends HybridObject<{ ios: 'swift' }> {
   /**
    * 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.
@@ -46,12 +62,28 @@ export interface LLM extends HybridObject<{ ios: 'swift' }> {
    */
   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 */