react-native-litert-lm 0.3.7 → 0.4.1

package/ios/Tests/HybridLiteRTLMTests.swift

@@ -0,0 +1,113 @@
+import XCTest
+@testable import LiteRTLM
+
+class HybridLiteRTLMTests: XCTestCase {
+    var bridge: HybridLiteRTLM!
+
+    override func setUp() {
+        super.setUp()
+        bridge = HybridLiteRTLM()
+    }
+
+    override func tearDown() {
+        try? bridge.close()
+        bridge = nil
+        super.tearDown()
+    }
+
+    func testPathTraversalRejection() async throws {
+        let traversals = ["../../etc/passwd", "/absolute/path/file", "subdir\\..\\file", "..", "../", "..\\"]
+        for traversal in traversals {
+            do {
+                let promise = try bridge.deleteModel(fileName: traversal)
+                _ = try await promise.await()
+                XCTFail("Should have failed for traversal: \(traversal)")
+            } catch {
+                let nsError = error as NSError
+                XCTAssertEqual(nsError.domain, "LiteRTLM")
+                XCTAssertEqual(nsError.code, 400)
+                XCTAssertTrue(nsError.localizedDescription.contains("path traversal") || nsError.localizedDescription.contains("directory separators"))
+            }
+        }
+    }
+
+    func testNonHTTPSDownloadRejection() async throws {
+        do {
+            let promise = try bridge.downloadModel(url: "http://insecure-domain.com/model.bin", fileName: "model.bin", onProgress: nil)
+            _ = try await promise.await()
+            XCTFail("Should have blocked insecure HTTP downloads")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+            XCTAssertEqual(nsError.code, 400)
+            XCTAssertTrue(nsError.localizedDescription.contains("HTTPS is required"))
+        }
+    }
+
+    func testMemoryTelemetry() {
+        XCTAssertNoThrow(try bridge.getMemoryUsage())
+        if let mem = try? bridge.getMemoryUsage() {
+            XCTAssertGreaterThanOrEqual(mem.nativeHeapBytes, 0.0)
+            XCTAssertGreaterThanOrEqual(mem.residentBytes, 0.0)
+            XCTAssertGreaterThanOrEqual(mem.availableMemoryBytes, 0.0)
+        }
+    }
+
+    func testSendMessageWithImageAsyncRejectsWithoutModel() async throws {
+        do {
+            let promise = try bridge.sendMessageWithImageAsync(message: "hello", imagePath: "/tmp/image.jpg") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+            XCTAssertEqual(nsError.code, 400)
+        }
+    }
+
+    func testSendMessageWithAudioAsyncRejectsWithoutModel() async throws {
+        do {
+            let promise = try bridge.sendMessageWithAudioAsync(message: "hello", audioPath: "/tmp/audio.wav") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+            XCTAssertEqual(nsError.code, 400)
+        }
+    }
+
+    func testSendMessageWithImageAsyncRejectsFileNotFound() async throws {
+        do {
+            let promise = try bridge.sendMessageWithImageAsync(message: "hello", imagePath: "/nonexistent/image.jpg") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+        }
+    }
+
+    func testSendMessageWithAudioAsyncRejectsFileNotFound() async throws {
+        do {
+            let promise = try bridge.sendMessageWithAudioAsync(message: "hello", audioPath: "/nonexistent/audio.wav") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+        }
+    }
+
+    func testInitialStats() {
+        XCTAssertNoThrow(try bridge.getStats())
+        if let stats = try? bridge.getStats() {
+            XCTAssertEqual(stats.promptTokens, 0.0)
+            XCTAssertEqual(stats.completionTokens, 0.0)
+            XCTAssertEqual(stats.totalTokens, 0.0)
+            XCTAssertEqual(stats.timeToFirstToken, 0.0)
+            XCTAssertEqual(stats.totalTime, 0.0)
+            XCTAssertEqual(stats.tokensPerSecond, 0.0)
+        }
+    }
+}

package/lib/__mocks__/react-native-nitro-modules.d.ts

@@ -0,0 +1,65 @@
+export declare const mockLiteRTLM: {
+    isReady: jest.Mock<boolean, [], any>;
+    loadModel: jest.Mock<any, any, any>;
+    sendMessage: jest.Mock<any, any, any>;
+    sendMessageWithImage: jest.Mock<any, any, any>;
+    downloadModel: jest.Mock<Promise<string>, [url: any, fileName: any, onProgress: any], any>;
+    deleteModel: jest.Mock<any, any, any>;
+    sendMessageWithAudio: jest.Mock<any, any, any>;
+    sendMultimodalMessage: jest.Mock<any, any, any>;
+    sendMessageAsync: jest.Mock<Promise<void>, [msg: any, onToken: any], any>;
+    sendMessageWithImageAsync: jest.Mock<Promise<void>, [msg: any, imagePath: any, onToken: any], any>;
+    sendMessageWithAudioAsync: jest.Mock<Promise<void>, [msg: any, audioPath: any, onToken: any], any>;
+    getHistory: jest.Mock<never[], [], any>;
+    resetConversation: jest.Mock<any, any, any>;
+    getStats: jest.Mock<{
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        timeToFirstToken: number;
+        totalTime: number;
+        tokensPerSecond: number;
+    }, [], any>;
+    countTokens: jest.Mock<number, [], any>;
+    getMemoryUsage: jest.Mock<{
+        nativeHeapBytes: number;
+        residentBytes: number;
+        availableMemoryBytes: number;
+        isLowMemory: boolean;
+    }, [], any>;
+    close: jest.Mock<any, any, any>;
+};
+export declare const NitroModules: {
+    createHybridObject: jest.Mock<{
+        isReady: jest.Mock<boolean, [], any>;
+        loadModel: jest.Mock<any, any, any>;
+        sendMessage: jest.Mock<any, any, any>;
+        sendMessageWithImage: jest.Mock<any, any, any>;
+        downloadModel: jest.Mock<Promise<string>, [url: any, fileName: any, onProgress: any], any>;
+        deleteModel: jest.Mock<any, any, any>;
+        sendMessageWithAudio: jest.Mock<any, any, any>;
+        sendMultimodalMessage: jest.Mock<any, any, any>;
+        sendMessageAsync: jest.Mock<Promise<void>, [msg: any, onToken: any], any>;
+        sendMessageWithImageAsync: jest.Mock<Promise<void>, [msg: any, imagePath: any, onToken: any], any>;
+        sendMessageWithAudioAsync: jest.Mock<Promise<void>, [msg: any, audioPath: any, onToken: any], any>;
+        getHistory: jest.Mock<never[], [], any>;
+        resetConversation: jest.Mock<any, any, any>;
+        getStats: jest.Mock<{
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+            timeToFirstToken: number;
+            totalTime: number;
+            tokensPerSecond: number;
+        }, [], any>;
+        countTokens: jest.Mock<number, [], any>;
+        getMemoryUsage: jest.Mock<{
+            nativeHeapBytes: number;
+            residentBytes: number;
+            availableMemoryBytes: number;
+            isLowMemory: boolean;
+        }, [], any>;
+        close: jest.Mock<any, any, any>;
+    }, [name: string], any>;
+    createNativeArrayBuffer: jest.Mock<ArrayBuffer, [size: number], any>;
+};

package/lib/__mocks__/react-native-nitro-modules.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NitroModules = exports.mockLiteRTLM = void 0;
+exports.mockLiteRTLM = {
+    isReady: jest.fn(() => false),
+    loadModel: jest.fn().mockResolvedValue(undefined),
+    sendMessage: jest.fn().mockResolvedValue("Mock response"),
+    sendMessageWithImage: jest.fn().mockResolvedValue("Mock vision response"),
+    downloadModel: jest.fn(async (url, fileName, onProgress) => {
+        onProgress?.(1.0);
+        return "/mock/path/model.litertlm";
+    }),
+    deleteModel: jest.fn().mockResolvedValue(undefined),
+    sendMessageWithAudio: jest.fn().mockResolvedValue("Mock audio response"),
+    sendMultimodalMessage: jest.fn().mockResolvedValue("Mock multimodal response"),
+    sendMessageAsync: jest.fn((msg, onToken) => {
+        onToken("Mock ", false);
+        onToken("token", true);
+        return Promise.resolve();
+    }),
+    sendMessageWithImageAsync: jest.fn((msg, imagePath, onToken) => {
+        onToken("Mock vision ", false);
+        onToken("token", true);
+        return Promise.resolve();
+    }),
+    sendMessageWithAudioAsync: jest.fn((msg, audioPath, onToken) => {
+        onToken("Mock audio ", false);
+        onToken("token", true);
+        return Promise.resolve();
+    }),
+    getHistory: jest.fn(() => []),
+    resetConversation: jest.fn(),
+    getStats: jest.fn(() => ({
+        promptTokens: 10,
+        completionTokens: 20,
+        totalTokens: 30,
+        timeToFirstToken: 5,
+        totalTime: 50,
+        tokensPerSecond: 400,
+    })),
+    countTokens: jest.fn(() => -1),
+    getMemoryUsage: jest.fn(() => ({
+        nativeHeapBytes: 1000000,
+        residentBytes: 2000000,
+        availableMemoryBytes: 4000000,
+        isLowMemory: false,
+    })),
+    close: jest.fn(),
+};
+exports.NitroModules = {
+    createHybridObject: jest.fn((name) => {
+        if (name === "LiteRTLM") {
+            return exports.mockLiteRTLM;
+        }
+        throw new Error(`Mock not implemented for hybrid object: ${name}`);
+    }),
+    createNativeArrayBuffer: jest.fn((size) => {
+        return new ArrayBuffer(size);
+    }),
+};

package/lib/__tests__/hooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/hooks.test.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Configure React act environment
+global.IS_REACT_ACT_ENVIRONMENT = true;
+const hooks_1 = require("../hooks");
+const react_native_nitro_modules_1 = require("../__mocks__/react-native-nitro-modules");
+const react_test_renderer_1 = __importDefault(require("react-test-renderer"));
+const react_1 = __importDefault(require("react"));
+// Mock react-native
+jest.mock('react-native', () => ({
+    Platform: {
+        OS: 'ios',
+        select: jest.fn((dict) => dict.ios),
+    },
+}));
+// Helper to render and test hooks using react-test-renderer
+function renderHook(callback, initialProps) {
+    let result = { current: null };
+    const TestComponent = ({ props }) => {
+        result.current = callback(props);
+        return null;
+    };
+    let renderer;
+    react_test_renderer_1.default.act(() => {
+        renderer = react_test_renderer_1.default.create(react_1.default.createElement(TestComponent, { props: initialProps }));
+    });
+    const rerender = (newProps) => {
+        react_test_renderer_1.default.act(() => {
+            renderer.update(react_1.default.createElement(TestComponent, { props: newProps }));
+        });
+    };
+    const unmount = () => {
+        react_test_renderer_1.default.act(() => {
+            renderer.unmount();
+        });
+    };
+    return { result, rerender, unmount };
+}
+describe('useModel React Hook Unit Tests', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should initialize with correct default state and call loadModel automatically when autoLoad is true', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        expect(hookResult.result.current.isReady).toBe(true);
+        expect(hookResult.result.current.isGenerating).toBe(false);
+        expect(hookResult.result.current.downloadProgress).toBe(1); // loadModel completed
+        expect(hookResult.result.current.error).toBeNull();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalled();
+    });
+    it('should not call loadModel automatically when autoLoad is false', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: false }));
+        });
+        expect(hookResult.result.current.isReady).toBe(false);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).not.toHaveBeenCalled();
+        // Call load manually
+        await react_test_renderer_1.default.act(async () => {
+            await hookResult.result.current.load();
+        });
+        expect(hookResult.result.current.isReady).toBe(true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalled();
+    });
+    it('should handle model load failure gracefully', async () => {
+        react_native_nitro_modules_1.mockLiteRTLM.loadModel.mockRejectedValueOnce(new Error("Model load failed"));
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        expect(hookResult.result.current.isReady).toBe(false);
+        expect(hookResult.result.current.error).toBe("Model load failed");
+    });
+    it('should generate text successfully and trigger memory summary update', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', {
+                autoLoad: true,
+                enableMemoryTracking: true
+            }));
+        });
+        let response = "";
+        await react_test_renderer_1.default.act(async () => {
+            response = await hookResult.result.current.generate("Test prompt");
+        });
+        expect(response).toBe("Mock token");
+        expect(react_native_nitro_modules_1.mockLiteRTLM.sendMessageAsync).toHaveBeenCalled();
+        expect(hookResult.result.current.memorySummary).toBeDefined();
+    });
+    it('should reset conversation correctly', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        hookResult.result.current.reset();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.resetConversation).toHaveBeenCalled();
+    });
+    it('should delete model file correctly', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        await react_test_renderer_1.default.act(async () => {
+            await hookResult.result.current.deleteModel();
+        });
+        expect(react_native_nitro_modules_1.mockLiteRTLM.deleteModel).toHaveBeenCalledWith('model.litertlm');
+        expect(hookResult.result.current.isReady).toBe(false);
+        expect(hookResult.result.current.downloadProgress).toBe(0);
+    });
+    it('should call close on unmount', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: false }));
+        });
+        hookResult.unmount();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.close).toHaveBeenCalled();
+    });
+});

package/lib/__tests__/memoryTracker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/memoryTracker.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memoryTracker_1 = require("../memoryTracker");
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+describe('MemoryTracker Unit Tests', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should allocate correct native-backed ArrayBuffer size on initialization', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(10);
+        expect(react_native_nitro_modules_1.NitroModules.createNativeArrayBuffer).toHaveBeenCalledWith(10 * 4 * 8); // 10 snapshots * 4 fields * 8 bytes/Float64
+        expect(tracker.getCapacity()).toBe(10);
+        expect(tracker.getSnapshotCount()).toBe(0);
+    });
+    it('should record snapshots correctly and retrieve them', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        const snapshot1 = {
+            timestamp: 1000,
+            nativeHeapBytes: 100,
+            residentBytes: 200,
+            availableMemoryBytes: 500,
+        };
+        expect(tracker.record(snapshot1)).toBe(true);
+        expect(tracker.getSnapshotCount()).toBe(1);
+        expect(tracker.getLatestSnapshot()).toEqual(snapshot1);
+        const snapshots = tracker.getSnapshots();
+        expect(snapshots).toHaveLength(1);
+        expect(snapshots[0]).toEqual(snapshot1);
+    });
+    it('should reject new snapshots and return false when capacity is reached', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(2);
+        expect(tracker.record({ timestamp: 1, nativeHeapBytes: 10, residentBytes: 20, availableMemoryBytes: 50 })).toBe(true);
+        expect(tracker.record({ timestamp: 2, nativeHeapBytes: 20, residentBytes: 30, availableMemoryBytes: 40 })).toBe(true);
+        expect(tracker.record({ timestamp: 3, nativeHeapBytes: 30, residentBytes: 40, availableMemoryBytes: 30 })).toBe(false);
+        expect(tracker.getSnapshotCount()).toBe(2);
+    });
+    it('should calculate correct peak resident memory size', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        tracker.record({ timestamp: 1, nativeHeapBytes: 100, residentBytes: 150, availableMemoryBytes: 1000 });
+        tracker.record({ timestamp: 2, nativeHeapBytes: 120, residentBytes: 300, availableMemoryBytes: 1000 });
+        tracker.record({ timestamp: 3, nativeHeapBytes: 110, residentBytes: 200, availableMemoryBytes: 1000 });
+        expect(tracker.getPeakMemory()).toBe(300);
+    });
+    it('should calculate accurate memory summary statistics', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        tracker.record({ timestamp: 1, nativeHeapBytes: 50, residentBytes: 100, availableMemoryBytes: 1000 });
+        tracker.record({ timestamp: 2, nativeHeapBytes: 150, residentBytes: 300, availableMemoryBytes: 800 });
+        tracker.record({ timestamp: 3, nativeHeapBytes: 100, residentBytes: 200, availableMemoryBytes: 900 });
+        const summary = tracker.getSummary();
+        expect(summary.snapshotCount).toBe(3);
+        expect(summary.peakResidentBytes).toBe(300);
+        expect(summary.averageResidentBytes).toBe(200); // (100 + 300 + 200) / 3
+        expect(summary.currentResidentBytes).toBe(200);
+        expect(summary.peakNativeHeapBytes).toBe(150);
+        expect(summary.currentNativeHeapBytes).toBe(100);
+        expect(summary.residentDeltaBytes).toBe(100); // currentRss(200) - firstRss(100)
+        expect(summary.trackerBufferSizeBytes).toBe(5 * 4 * 8);
+    });
+    it('should preserve buffer but reset internal state when reset() is called', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        tracker.record({ timestamp: 1, nativeHeapBytes: 50, residentBytes: 100, availableMemoryBytes: 1000 });
+        expect(tracker.getSnapshotCount()).toBe(1);
+        tracker.reset();
+        expect(tracker.getSnapshotCount()).toBe(0);
+        expect(tracker.getLatestSnapshot()).toBeUndefined();
+        expect(tracker.getSnapshots()).toEqual([]);
+    });
+    it('should allow standalone native ArrayBuffer allocation via createNativeBuffer', () => {
+        const size = 128;
+        const buffer = (0, memoryTracker_1.createNativeBuffer)(size);
+        expect(react_native_nitro_modules_1.NitroModules.createNativeArrayBuffer).toHaveBeenCalledWith(size);
+        expect(buffer.byteLength).toBe(size);
+    });
+});

package/lib/__tests__/modelFactory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/modelFactory.test.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modelFactory_1 = require("../modelFactory");
+const react_native_nitro_modules_1 = require("../__mocks__/react-native-nitro-modules");
+describe('modelFactory Security & Proxy Unit Tests', () => {
+    let llm;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        llm = (0, modelFactory_1.createLLM)({ enableMemoryTracking: true });
+    });
+    it('should block insecure HTTP downloads', async () => {
+        await expect(llm.loadModel('http://example.com/model.litertlm'))
+            .rejects.toThrow('Insecure HTTP URLs are not allowed for model downloads');
+    });
+    it('should allow secure HTTPS downloads and strip query parameters', async () => {
+        await llm.loadModel('https://example.com/model.litertlm?token=123');
+        expect(react_native_nitro_modules_1.mockLiteRTLM.downloadModel).toHaveBeenCalledWith('https://example.com/model.litertlm?token=123', 'model.litertlm', expect.any(Function));
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalledWith('/mock/path/model.litertlm', undefined);
+    });
+    it('should throw an error for invalid model URL', async () => {
+        await expect(llm.loadModel('https://example.com/'))
+            .rejects.toThrow('Invalid model URL: https://example.com/');
+    });
+    it('should successfully proxy sendMessage and record memory metrics', async () => {
+        const response = await llm.sendMessage("Test prompt");
+        expect(response).toBe("Mock response");
+        expect(react_native_nitro_modules_1.mockLiteRTLM.sendMessage).toHaveBeenCalledWith("Test prompt");
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+        expect(llm.memoryTracker?.getSnapshotCount()).toBe(1); // sendMessage records one
+    });
+    it('should successfully proxy resetConversation and record memory metrics', async () => {
+        await llm.resetConversation();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.resetConversation).toHaveBeenCalled();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully proxy sendMessageAsync and record memory metrics when done', async () => {
+        const onToken = jest.fn();
+        await llm.sendMessageAsync("Async prompt", onToken);
+        expect(onToken).toHaveBeenCalledWith("Mock ", false);
+        expect(onToken).toHaveBeenCalledWith("token", true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.sendMessageAsync).toHaveBeenCalled();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully proxy sendMessageWithImageAsync and record memory metrics when done', async () => {
+        const onToken = jest.fn();
+        await llm.sendMessageWithImageAsync("Vision prompt", "/path/to/image.jpg", onToken);
+        expect(onToken).toHaveBeenCalledWith("Mock vision ", false);
+        expect(onToken).toHaveBeenCalledWith("token", true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.sendMessageWithImageAsync).toHaveBeenCalledWith("Vision prompt", "/path/to/image.jpg", expect.any(Function));
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully proxy sendMessageWithAudioAsync and record memory metrics when done', async () => {
+        const onToken = jest.fn();
+        await llm.sendMessageWithAudioAsync("Audio prompt", "/path/to/audio.wav", onToken);
+        expect(onToken).toHaveBeenCalledWith("Mock audio ", false);
+        expect(onToken).toHaveBeenCalledWith("token", true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.sendMessageWithAudioAsync).toHaveBeenCalledWith("Audio prompt", "/path/to/audio.wav", expect.any(Function));
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully access memoryTracker and getSnapshots when memory tracking is enabled', () => {
+        expect(llm.memoryTracker).toBeDefined();
+        expect(llm.memoryTracker?.getCapacity()).toBe(256);
+    });
+    it('should not initialize memoryTracker when enableMemoryTracking option is false', () => {
+        const untrackedLLM = (0, modelFactory_1.createLLM)({ enableMemoryTracking: false });
+        expect(untrackedLLM.memoryTracker).toBeUndefined();
+    });
+});

package/lib/hooks.js

@@ -28,6 +28,11 @@ function useModel(pathOrUrl, config) {
     const temperature = config?.temperature;
     const topK = config?.topK;
     const topP = config?.topP;
+    const validate = config?.validate;
+    const multimodal = config?.multimodal;
+    const tools = config?.tools;
+    const enableSpeculativeDecoding = config?.enableSpeculativeDecoding;
+    const toolsKey = tools ? JSON.stringify(tools) : undefined;
     // Build a stable config object from the destructured primitives
     const nativeConfig = (0, react_1.useMemo)(() => ({
         ...(backend !== undefined && { backend }),
@@ -36,7 +41,24 @@ function useModel(pathOrUrl, config) {
         ...(temperature !== undefined && { temperature }),
         ...(topK !== undefined && { topK }),
         ...(topP !== undefined && { topP }),
-    }), [backend, systemPrompt, maxTokens, temperature, topK, topP]);
+        ...(validate !== undefined && { validate }),
+        ...(multimodal !== undefined && { multimodal }),
+        ...(tools !== undefined && { tools }),
+        ...(enableSpeculativeDecoding !== undefined && {
+            enableSpeculativeDecoding,
+        }),
+    }), [
+        backend,
+        systemPrompt,
+        maxTokens,
+        temperature,
+        topK,
+        topP,
+        validate,
+        multimodal,
+        toolsKey,
+        enableSpeculativeDecoding,
+    ]);
     /**
      * Refresh memory summary from the tracker's native buffer.
      */
@@ -99,13 +121,15 @@ function useModel(pathOrUrl, config) {
             return new Promise((resolve, reject) => {
                 let fullResponse = "";
                 try {
-                    modelRef.current?.sendMessageAsync(prompt, (token, done) => {
+                    modelRef.current
+                        ?.sendMessageAsync(prompt, (token, done) => {
                         fullResponse += token;
                         if (done) {
                             refreshMemorySummary();
                             resolve(fullResponse);
                         }
-                    });
+                    })
+                        .catch(reject);
                 }
                 catch (e) {
                     reject(e);

package/lib/index.d.ts

@@ -1,7 +1,5 @@
 import type { Backend } from "./specs/LiteRTLM.nitro";
 export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, MemoryUsage, } from "./specs/LiteRTLM.nitro";
-export type { ChatMessage } from "./templates";
-export { applyGemmaTemplate, applyPhiTemplate, applyLlamaTemplate, } from "./templates";
 export type { MemorySnapshot, MemoryTracker, MemoryTrackerSummary, } from "./memoryTracker";
 export { createMemoryTracker, createNativeBuffer } from "./memoryTracker";
 export type { LiteRTLMInstance } from "./modelFactory";
@@ -95,6 +93,12 @@ export declare function checkBackendSupport(backend: Backend): string | undefine
  * Check if multimodal features (image/audio) are supported on the current platform.
  * Returns an error message if not supported, undefined if OK.
  *
+ * Both iOS (v0.12.0 CLiteRTLM xcframework) and Android (LiteRT-LM SDK) ship the
+ * vision/audio executor ops, so there is no platform-level block. Whether a
+ * given call succeeds depends on the **loaded model**: only multimodal models
+ * (e.g. Gemma 3n) bundle the vision/audio executors. Pass `multimodal: true` to
+ * `loadModel` for such models, or rely on filename sniffing ("3n"/"gemma3").
+ *
  * @returns Error message if multimodal is not supported, undefined if OK
  *
  * @example

package/lib/index.js

@@ -14,15 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GEMMA_4_E4B_IT = exports.GEMMA_4_E2B_IT = exports.GEMMA_3N_E2B_IT_INT4 = exports.Models = exports.createLLM = exports.createNativeBuffer = exports.createMemoryTracker = exports.applyLlamaTemplate = exports.applyPhiTemplate = exports.applyGemmaTemplate = void 0;
+exports.GEMMA_4_E4B_IT = exports.GEMMA_4_E2B_IT = exports.GEMMA_3N_E2B_IT_INT4 = exports.Models = exports.createLLM = exports.createNativeBuffer = exports.createMemoryTracker = void 0;
 exports.getRecommendedBackend = getRecommendedBackend;
 exports.checkBackendSupport = checkBackendSupport;
 exports.checkMultimodalSupport = checkMultimodalSupport;
 const react_native_1 = require("react-native");
-var templates_1 = require("./templates");
-Object.defineProperty(exports, "applyGemmaTemplate", { enumerable: true, get: function () { return templates_1.applyGemmaTemplate; } });
-Object.defineProperty(exports, "applyPhiTemplate", { enumerable: true, get: function () { return templates_1.applyPhiTemplate; } });
-Object.defineProperty(exports, "applyLlamaTemplate", { enumerable: true, get: function () { return templates_1.applyLlamaTemplate; } });
 var memoryTracker_1 = require("./memoryTracker");
 Object.defineProperty(exports, "createMemoryTracker", { enumerable: true, get: function () { return memoryTracker_1.createMemoryTracker; } });
 Object.defineProperty(exports, "createNativeBuffer", { enumerable: true, get: function () { return memoryTracker_1.createNativeBuffer; } });
@@ -139,6 +135,12 @@ function checkBackendSupport(backend) {
  * Check if multimodal features (image/audio) are supported on the current platform.
  * Returns an error message if not supported, undefined if OK.
  *
+ * Both iOS (v0.12.0 CLiteRTLM xcframework) and Android (LiteRT-LM SDK) ship the
+ * vision/audio executor ops, so there is no platform-level block. Whether a
+ * given call succeeds depends on the **loaded model**: only multimodal models
+ * (e.g. Gemma 3n) bundle the vision/audio executors. Pass `multimodal: true` to
+ * `loadModel` for such models, or rely on filename sniffing ("3n"/"gemma3").
+ *
  * @returns Error message if multimodal is not supported, undefined if OK
  *
  * @example
@@ -153,9 +155,7 @@ function checkBackendSupport(backend) {
  * ```
  */
 function checkMultimodalSupport() {
-    if (react_native_1.Platform.OS === "ios") {
-        return "Multimodal (image/audio) is not available on iOS. The XCFramework lacks compiled vision and audio executor ops.";
-    }
+    // Supported on both platforms with a multimodal model loaded.
     return undefined;
 }
 /**