react-native-litert-lm 0.3.7 → 0.4.0

package/react-native-litert-lm.podspec

@@ -9,36 +9,28 @@ Pod::Spec.new do |s|
   s.homepage     = package["homepage"]
   s.license      = package["license"]
   s.authors      = package["author"]
-  s.platforms    = { :ios => "15.0" }
+  s.platforms    = { :ios => "15.1" }
+  s.module_name  = "LiteRTLM"
   s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
   
-  s.swift_version = '5.0'
+  s.swift_version = '5.9'
 
   s.source_files = [
-    # Implementation (C++)
-    "cpp/**/*.{hpp,cpp,h}",
-    # Autolinking (Objective-C++)
-    "ios/**/*.{m,mm}",
-    # Nitrogen generated iOS bridge
+    # Swift, Objective-C/C++ implementation & autolinking
+    "ios/*.{swift,m,mm}",
+    # Nitrogen generated iOS bridge & shared C++ interfaces
     "nitrogen/generated/ios/**/*.{mm,swift}",
+    "nitrogen/generated/shared/c++/**/*.{hpp,cpp}",
   ]
 
-  # Exclude Android-only JNI files from iOS build
-  s.exclude_files = [
-    "cpp/cpp-adapter.cpp",
-  ]
-
-  # Prebuilt LiteRT-LM C engine (static library built from Bazel //c:engine target).
-  # Downloaded from GitHub releases by postinstall.js, or built locally via:
-  #   scripts/build-ios-engine.sh
-  s.vendored_frameworks = 'ios/Frameworks/LiteRTLM.xcframework'
+  # Prebuilt LiteRT-LM C engine (static library).
+  # Downloaded from Google's release via: scripts/download-ios-frameworks.sh
+  s.vendored_frameworks = 'ios/Frameworks/CLiteRTLM.xcframework'
 
   s.pod_target_xcconfig = {
     'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20',
-    'CLANG_CXX_LIBRARY' => 'libc++',
+    'SWIFT_VERSION' => '5.9',
     'HEADER_SEARCH_PATHS' => [
-      '"$(PODS_TARGET_SRCROOT)/cpp"',
-      '"$(PODS_TARGET_SRCROOT)/cpp/include"',
       '"$(PODS_TARGET_SRCROOT)/nitrogen/generated/shared/c++"',
       '"$(PODS_TARGET_SRCROOT)/nitrogen/generated/ios"',
     ].join(' '),
@@ -59,6 +51,10 @@ Pod::Spec.new do |s|
   s.frameworks = ['Metal', 'MetalPerformanceShaders', 'Accelerate', 'CoreML', 'CoreGraphics']
   s.libraries = ['c++']
 
+  s.test_spec 'Tests' do |test_spec|
+    test_spec.source_files = 'ios/Tests/**/*.{swift}'
+  end
+
   install_modules_dependencies(s)
 end
 

package/scripts/download-ios-frameworks.sh

@@ -1,72 +1,38 @@
 #!/bin/bash
 # download-ios-frameworks.sh
-#
-# Downloads prebuilt LiteRT-LM iOS static engine from this project's GitHub
-# releases. If the prebuilt asset is not available, falls back to building
-# from source via Bazel (see build-ios-engine.sh).
-#
-# The XCFramework contains a static library compiled from the LiteRT-LM
-# C engine (//c:engine Bazel target) for both device (arm64) and simulator
-# (sim_arm64).
-#
-# Usage:
-#   ./scripts/download-ios-frameworks.sh
+# Downloads the official prebuilt LiteRT-LM iOS framework (CLiteRTLM.xcframework)
+# directly from the google-ai-edge/LiteRT-LM releases.
 
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 OUTPUT_DIR="$PROJECT_ROOT/ios/Frameworks"
-C_API_HEADER_DIR="$PROJECT_ROOT/cpp/include"
 
 LITERT_LM_VERSION="$(node -e "console.log(require('$PROJECT_ROOT/package.json').litertLm.iosGitTag)")"
-GITHUB_RAW="https://github.com/google-ai-edge/LiteRT-LM/raw/${LITERT_LM_VERSION}"
-
-# Read version from package.json
-PACKAGE_VERSION=$(node -e "console.log(require('$PROJECT_ROOT/package.json').version)" 2>/dev/null || echo "0.0.0")
-GITHUB_REPO="hung-yueh/react-native-litert-lm"
-ASSET_NAME="LiteRTLM-ios-frameworks.zip"
+RELEASE_URL="https://github.com/google-ai-edge/LiteRT-LM/releases/download/${LITERT_LM_VERSION}/CLiteRTLM.xcframework.zip"
 
 # Skip if already present
-if [ -d "$OUTPUT_DIR" ] && [ "$(find "$OUTPUT_DIR" -name "*.xcframework" 2>/dev/null | wc -l)" -gt 0 ]; then
-  echo "[LiteRT-LM] iOS frameworks already present at ios/Frameworks/, skipping."
+if [ -d "$OUTPUT_DIR/CLiteRTLM.xcframework" ]; then
+  echo "[LiteRT-LM] iOS CLiteRTLM.xcframework already present, skipping download."
   exit 0
 fi
 
-# ---- Ensure C API header is vendored --------------------------------------
-echo "[LiteRT-LM] Vendoring C API header..."
-mkdir -p "$C_API_HEADER_DIR"
-curl -fsSL -o "$C_API_HEADER_DIR/litert_lm_engine.h" \
-  "${GITHUB_RAW}/c/engine.h" 2>/dev/null || true
-
-# ---- Try downloading prebuilt from our GitHub releases --------------------
-RELEASE_URL="https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/${ASSET_NAME}"
-
-echo "[LiteRT-LM] Attempting to download prebuilt iOS engine from:"
+echo "[LiteRT-LM] Downloading prebuilt iOS engine from Google's release:"
 echo "   ${RELEASE_URL}"
 
+mkdir -p "$OUTPUT_DIR"
 TMP_ZIP="$PROJECT_ROOT/.ios-frameworks-tmp.zip"
-if curl -fsSL -o "$TMP_ZIP" "$RELEASE_URL" 2>/dev/null; then
-  echo "[LiteRT-LM] Download successful, extracting..."
-  rm -rf "$OUTPUT_DIR"
-  mkdir -p "$OUTPUT_DIR"
+
+if curl -fsSL -o "$TMP_ZIP" "$RELEASE_URL"; then
+  echo "[LiteRT-LM] Download successful, extracting to $OUTPUT_DIR..."
+  rm -rf "$OUTPUT_DIR/CLiteRTLM.xcframework"
   unzip -o -q "$TMP_ZIP" -d "$OUTPUT_DIR"
   rm -f "$TMP_ZIP"
-  echo "[LiteRT-LM] ✅ iOS frameworks installed from prebuilt release."
+  echo "[LiteRT-LM] ✅ iOS frameworks successfully installed."
   exit 0
-fi
-
-rm -f "$TMP_ZIP"
-echo "[LiteRT-LM] Prebuilt not available for v${PACKAGE_VERSION}."
-
-# ---- Fall back to building from source ------------------------------------
-echo "[LiteRT-LM] Falling back to building from source via Bazel..."
-echo ""
-
-if [ -x "$SCRIPT_DIR/build-ios-engine.sh" ]; then
-  exec "$SCRIPT_DIR/build-ios-engine.sh"
 else
-  echo "Error: build-ios-engine.sh not found or not executable."
-  echo "Run manually: ./scripts/build-ios-engine.sh"
+  rm -f "$TMP_ZIP"
+  echo "Error: Failed to download LiteRT-LM iOS framework from ${RELEASE_URL}"
   exit 1
 fi

package/scripts/postinstall.js

@@ -108,8 +108,7 @@ async function main() {
 
     log(`Error: Could not download iOS frameworks: ${err.message}`);
     log('iOS builds will not work until frameworks are available.');
-    log('Run: ./scripts/download-ios-frameworks.sh to download manually,');
-    log('  or: ./scripts/build-ios-engine.sh to build from source.');
+    log('Run: ./scripts/download-ios-frameworks.sh to download manually.');
 
     // Fail fast on macOS so users discover the problem now, not at Xcode link time.
     // Skip SKIP_IOS_FRAMEWORK_DOWNLOAD is already checked above.

package/src/__mocks__/react-native-nitro-modules.ts

@@ -0,0 +1,48 @@
+export const 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();
+  }),
+  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(),
+};
+
+export const NitroModules = {
+  createHybridObject: jest.fn((name: string) => {
+    if (name === "LiteRTLM") {
+      return mockLiteRTLM;
+    }
+    throw new Error(`Mock not implemented for hybrid object: ${name}`);
+  }),
+  createNativeArrayBuffer: jest.fn((size: number) => {
+    return new ArrayBuffer(size);
+  }),
+};

package/src/__tests__/hooks.test.ts

@@ -0,0 +1,153 @@
+// Configure React act environment
+(global as any).IS_REACT_ACT_ENVIRONMENT = true;
+
+import { useModel } from '../hooks';
+import { mockLiteRTLM } from '../__mocks__/react-native-nitro-modules';
+import TestRenderer from 'react-test-renderer';
+import React from '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<P, R>(callback: (props: P) => R, initialProps?: P) {
+  let result = { current: null as unknown as R };
+  
+  const TestComponent = ({ props }: { props: P }) => {
+    result.current = callback(props);
+    return null;
+  };
+
+  let renderer: TestRenderer.ReactTestRenderer;
+  TestRenderer.act(() => {
+    renderer = TestRenderer.create(React.createElement(TestComponent, { props: initialProps as P }));
+  });
+
+  const rerender = (newProps: P) => {
+    TestRenderer.act(() => {
+      renderer.update(React.createElement(TestComponent, { props: newProps }));
+    });
+  };
+
+  const unmount = () => {
+    TestRenderer.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: any;
+    
+    await TestRenderer.act(async () => {
+      hookResult = renderHook(() => 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(mockLiteRTLM.loadModel).toHaveBeenCalled();
+  });
+
+  it('should not call loadModel automatically when autoLoad is false', async () => {
+    let hookResult: any;
+    
+    await TestRenderer.act(async () => {
+      hookResult = renderHook(() => useModel('https://example.com/model.litertlm', { autoLoad: false }));
+    });
+
+    expect(hookResult.result.current.isReady).toBe(false);
+    expect(mockLiteRTLM.loadModel).not.toHaveBeenCalled();
+
+    // Call load manually
+    await TestRenderer.act(async () => {
+      await hookResult.result.current.load();
+    });
+
+    expect(hookResult.result.current.isReady).toBe(true);
+    expect(mockLiteRTLM.loadModel).toHaveBeenCalled();
+  });
+
+  it('should handle model load failure gracefully', async () => {
+    mockLiteRTLM.loadModel.mockRejectedValueOnce(new Error("Model load failed"));
+    let hookResult: any;
+
+    await TestRenderer.act(async () => {
+      hookResult = renderHook(() => 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: any;
+    
+    await TestRenderer.act(async () => {
+      hookResult = renderHook(() => useModel('https://example.com/model.litertlm', { 
+        autoLoad: true,
+        enableMemoryTracking: true 
+      }));
+    });
+
+    let response = "";
+    await TestRenderer.act(async () => {
+      response = await hookResult.result.current.generate("Test prompt");
+    });
+
+    expect(response).toBe("Mock token");
+    expect(mockLiteRTLM.sendMessageAsync).toHaveBeenCalled();
+    expect(hookResult.result.current.memorySummary).toBeDefined();
+  });
+
+  it('should reset conversation correctly', async () => {
+    let hookResult: any;
+    
+    await TestRenderer.act(async () => {
+      hookResult = renderHook(() => useModel('https://example.com/model.litertlm', { autoLoad: true }));
+    });
+
+    hookResult.result.current.reset();
+    expect(mockLiteRTLM.resetConversation).toHaveBeenCalled();
+  });
+
+  it('should delete model file correctly', async () => {
+    let hookResult: any;
+    
+    await TestRenderer.act(async () => {
+      hookResult = renderHook(() => useModel('https://example.com/model.litertlm', { autoLoad: true }));
+    });
+
+    await TestRenderer.act(async () => {
+      await hookResult.result.current.deleteModel();
+    });
+
+    expect(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: any;
+    
+    await TestRenderer.act(async () => {
+      hookResult = renderHook(() => useModel('https://example.com/model.litertlm', { autoLoad: false }));
+    });
+
+    hookResult.unmount();
+    expect(mockLiteRTLM.close).toHaveBeenCalled();
+  });
+});

package/src/__tests__/memoryTracker.test.ts

@@ -0,0 +1,87 @@
+import { createMemoryTracker, createNativeBuffer } from '../memoryTracker';
+import { NitroModules } from 'react-native-nitro-modules';
+
+describe('MemoryTracker Unit Tests', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should allocate correct native-backed ArrayBuffer size on initialization', () => {
+    const tracker = createMemoryTracker(10);
+    expect(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 = 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 = 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 = 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 = 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 = 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 = createNativeBuffer(size);
+    expect(NitroModules.createNativeArrayBuffer).toHaveBeenCalledWith(size);
+    expect(buffer.byteLength).toBe(size);
+  });
+});

package/src/__tests__/modelFactory.test.ts

@@ -0,0 +1,68 @@
+import { createLLM } from '../modelFactory';
+import { mockLiteRTLM } from '../__mocks__/react-native-nitro-modules';
+
+describe('modelFactory Security & Proxy Unit Tests', () => {
+  let llm: ReturnType<typeof createLLM>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    llm = 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(mockLiteRTLM.downloadModel).toHaveBeenCalledWith(
+      'https://example.com/model.litertlm?token=123',
+      'model.litertlm',
+      expect.any(Function)
+    );
+    expect(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(mockLiteRTLM.sendMessage).toHaveBeenCalledWith("Test prompt");
+    expect(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(mockLiteRTLM.resetConversation).toHaveBeenCalled();
+    expect(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(mockLiteRTLM.sendMessageAsync).toHaveBeenCalled();
+    expect(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 = createLLM({ enableMemoryTracking: false });
+    expect(untrackedLLM.memoryTracker).toBeUndefined();
+  });
+});

package/src/hooks.ts

@@ -174,7 +174,7 @@ export function useModel(
                   resolve(fullResponse);
                 }
               },
-            );
+            ).catch(reject);
           } catch (e: any) {
             reject(e);
           }

package/src/index.ts

@@ -20,13 +20,6 @@ export type {
   MemoryUsage,
 } from "./specs/LiteRTLM.nitro";
 
-// Re-export template utilities
-export type { ChatMessage } from "./templates";
-export {
-  applyGemmaTemplate,
-  applyPhiTemplate,
-  applyLlamaTemplate,
-} from "./templates";
 
 // Re-export memory tracking utilities (uses NitroModules.createNativeArrayBuffer v0.35+)
 export type {