react-native-litert-lm 0.3.7 → 0.4.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "react-native-litert-lm",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "litertLm": {
-    "version": "0.10.2",
-    "androidMavenVersion": "0.10.2",
-    "iosGitTag": "v0.10.2"
+    "version": "0.12.0",
+    "androidMavenVersion": "0.12.0",
+    "iosGitTag": "v0.12.0"
   },
   "description": "High-performance LLM inference for React Native using LiteRT-LM. Optimized for Gemma 4 and other on-device language models.",
   "license": "MIT",
@@ -43,14 +43,14 @@
     "android/src",
     "android/build.gradle",
     "android/CMakeLists.txt",
-    "ios/*.mm",
-    "ios/*.m",
+    "ios/**/*.swift",
+    "ios/**/*.mm",
+    "ios/**/*.m",
     "cpp",
     "nitrogen/generated",
     "scripts/postinstall.js",
+    "scripts/framework-source.js",
     "scripts/download-ios-frameworks.sh",
-    "scripts/build-ios-engine.sh",
-    "scripts/stubs",
     "react-native.config.js",
     "react-native-litert-lm.podspec",
     "app.plugin.js",
@@ -64,11 +64,14 @@
     "postinstall": "node scripts/postinstall.js",
     "build": "tsc",
     "typecheck": "tsc --noEmit",
+    "test": "jest",
     "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
-    "prepack": "npm run build",
+    "prepack": "npx nitrogen && npm run build",
     "specs": "npx nitrogen",
     "clean": "rm -rf lib android/build ios/build ios/Frameworks nitrogen/generated",
     "download-frameworks": "scripts/download-ios-frameworks.sh",
+    "check-framework-release": "node scripts/check-framework-release.js",
+    "prepublishOnly": "node scripts/check-framework-release.js",
     "android": "expo run:android",
     "android:clean": "cd android && ./gradlew clean",
     "ios": "expo run:ios",
@@ -76,16 +79,24 @@
   },
   "devDependencies": {
     "@expo/config-plugins": "~55.0.0",
+    "@types/jest": "^30.0.0",
     "@types/react": "~19.2.10",
-    "react-native-nitro-modules": "^0.35.4",
+    "@types/react-test-renderer": "^19.1.0",
+    "jest": "^30.4.2",
+    "react": "^19.2.6",
+    "react-native": "^0.85.3",
+    "react-native-nitro-modules": "^0.35.9",
+    "react-test-renderer": "^19.2.6",
     "release-it": "^19.2.4",
+    "ts-jest": "^29.4.10",
+    "ts-node": "^10.9.2",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
     "expo": ">=55.0.0",
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "^0.35.4"
+    "react-native-nitro-modules": "^0.35.9"
   },
   "peerDependenciesMeta": {
     "expo": {

package/react-native-litert-lm.podspec

@@ -9,36 +9,30 @@ 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 (xcframework). Not shipped in the npm tarball;
+  # fetched on install by scripts/postinstall.js (asset/tag defined in
+  # scripts/framework-source.js). Manual/upstream fallback:
+  # 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 +53,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,39 @@
 #!/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"
+# Resolve the asset URL + output dir from the shared single source of truth
+# (scripts/framework-source.js) so this manual path can't drift from postinstall.
+RELEASE_URL="$(node -e "console.log(require('$SCRIPT_DIR/framework-source').ASSET_URL)")"
+OUTPUT_DIR="$(node -e "console.log(require('$SCRIPT_DIR/framework-source').FRAMEWORKS_DIR)")"
 
 # 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/framework-source.js

@@ -0,0 +1,46 @@
+/**
+ * framework-source.js
+ *
+ * Single source of truth for the prebuilt iOS framework artifact, shared by
+ * scripts/postinstall.js, scripts/download-ios-frameworks.sh, and
+ * scripts/check-framework-release.js, so the asset name, tag, and URL can never
+ * drift between the install path and the release-time guardrail.
+ *
+ * The artifact is Google's canonical LiteRT-LM release (NOT a per-version
+ * re-host of this package), pinned to the LiteRT-LM **engine** version
+ * (`litertLm.iosGitTag` in package.json), NOT this wrapper's npm version. So:
+ *   - patch releases of this wrapper reuse the same framework (no re-upload),
+ *   - there is no per-release asset for the maintainer to forget to upload,
+ *   - the guardrail checks the exact URL consumers fetch.
+ *
+ * Override the host/asset (e.g. to point at a private mirror) via env vars:
+ *   LITERT_FRAMEWORK_REPO   (default: google-ai-edge/LiteRT-LM)
+ *   LITERT_FRAMEWORK_ASSET  (default: CLiteRTLM.xcframework.zip)
+ */
+
+const path = require('path');
+const packageJson = require('../package.json');
+
+/** GitHub repo that hosts the framework release asset. */
+const GITHUB_REPO = process.env.LITERT_FRAMEWORK_REPO || 'google-ai-edge/LiteRT-LM';
+
+/** Release asset filename. Must match the file on the GitHub release. */
+const ASSET_NAME = process.env.LITERT_FRAMEWORK_ASSET || 'CLiteRTLM.xcframework.zip';
+
+/** Release tag the asset lives under — the LiteRT-LM engine git tag, e.g. "v0.12.0". */
+const FRAMEWORK_TAG = packageJson.litertLm.iosGitTag;
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const FRAMEWORKS_DIR = path.join(PACKAGE_ROOT, 'ios', 'Frameworks');
+
+/** Fully-resolved download URL for the framework zip. */
+const ASSET_URL = `https://github.com/${GITHUB_REPO}/releases/download/${FRAMEWORK_TAG}/${ASSET_NAME}`;
+
+module.exports = {
+  GITHUB_REPO,
+  ASSET_NAME,
+  FRAMEWORK_TAG,
+  PACKAGE_ROOT,
+  FRAMEWORKS_DIR,
+  ASSET_URL,
+};

package/scripts/postinstall.js

@@ -5,10 +5,15 @@
  * Downloads prebuilt LiteRT-LM iOS frameworks from this package's GitHub
  * releases when consumers run `npm install react-native-litert-lm`.
  *
+ * The framework is intentionally NOT shipped inside the npm tarball (it is
+ * ~40MB and irrelevant to Android-only consumers). The asset name, tag, and
+ * URL come from scripts/framework-source.js so they stay in lockstep with the
+ * release-time guardrail (scripts/check-framework-release.js).
+ *
  * Skips download if:
  *   - Not on macOS (iOS builds require macOS)
  *   - Frameworks already exist
- *   - CI environment with SKIP_IOS_FRAMEWORK_DOWNLOAD=1
+ *   - SKIP_IOS_FRAMEWORK_DOWNLOAD=1 (e.g. Android-only / CI builds)
  */
 
 const { execSync } = require('child_process');
@@ -16,14 +21,12 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 
-const PACKAGE_JSON = require('../package.json');
-const PACKAGE_VERSION = PACKAGE_JSON.version;
-const GITHUB_REPO = 'hung-yueh/react-native-litert-lm';
-const ASSET_NAME = 'LiteRTLM-ios-frameworks.zip';
+const { ASSET_URL, FRAMEWORKS_DIR, FRAMEWORK_TAG } = require('./framework-source');
 
-const SCRIPT_DIR = __dirname;
-const PACKAGE_ROOT = path.resolve(SCRIPT_DIR, '..');
-const FRAMEWORKS_DIR = path.join(PACKAGE_ROOT, 'ios', 'Frameworks');
+/** ZIP local-file-header magic ("PK\x03\x04"). Guards against truncated downloads / HTML error pages. */
+const ZIP_MAGIC = Buffer.from([0x50, 0x4b, 0x03, 0x04]);
+/** A valid framework zip is well over this; anything smaller is certainly an error page. */
+const MIN_VALID_BYTES = 1024 * 1024; // 1 MB
 
 function log(msg) {
   console.log(`[react-native-litert-lm] ${msg}`);
@@ -74,25 +77,46 @@ function downloadFile(url, destPath, maxRedirects = 5) {
       const file = fs.createWriteStream(destPath);
       res.pipe(file);
       file.on('finish', () => {
-        file.close();
-        resolve();
+        file.close(resolve);
       });
       file.on('error', reject);
     }).on('error', reject);
   });
 }
 
+/**
+ * Verify the downloaded file is a non-trivial ZIP before we trust it.
+ * Catches GitHub HTML error pages and truncated downloads that would
+ * otherwise fail cryptically at `unzip` or, worse, link a corrupt framework.
+ */
+function assertValidZip(zipPath) {
+  const { size } = fs.statSync(zipPath);
+  if (size < MIN_VALID_BYTES) {
+    throw new Error(`downloaded asset is only ${size} bytes — expected a multi-MB framework zip (likely an error page or truncated download)`);
+  }
+
+  const header = Buffer.alloc(4);
+  const fd = fs.openSync(zipPath, 'r');
+  try {
+    fs.readSync(fd, header, 0, 4, 0);
+  } finally {
+    fs.closeSync(fd);
+  }
+  if (!header.equals(ZIP_MAGIC)) {
+    throw new Error('downloaded asset is not a valid ZIP (bad magic bytes)');
+  }
+}
+
 async function main() {
   if (shouldSkip()) return;
 
-  const releaseUrl = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/${ASSET_NAME}`;
-
-  log(`Downloading iOS frameworks from: ${releaseUrl}`);
+  log(`Downloading iOS frameworks (engine ${FRAMEWORK_TAG}) from: ${ASSET_URL}`);
 
-  const tmpZip = path.join(PACKAGE_ROOT, '.ios-frameworks-tmp.zip');
+  const tmpZip = path.join(path.dirname(FRAMEWORKS_DIR), '.ios-frameworks-tmp.zip');
 
   try {
-    await downloadFile(releaseUrl, tmpZip);
+    await downloadFile(ASSET_URL, tmpZip);
+    assertValidZip(tmpZip);
 
     // Extract
     fs.mkdirSync(FRAMEWORKS_DIR, { recursive: true });
@@ -108,11 +132,9 @@ 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.
     if (process.platform === 'darwin') {
       log('Set SKIP_IOS_FRAMEWORK_DOWNLOAD=1 to suppress this error (e.g. Android-only builds).');
       process.exit(1);

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

@@ -0,0 +1,58 @@
+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();
+  }),
+  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(),
+};
+
+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();
+  });
+});