react-native-litert-lm 0.2.2 → 0.3.0

package/scripts/postinstall.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * postinstall.js
+ *
+ * Downloads prebuilt LiteRT-LM iOS frameworks from this package's GitHub
+ * releases when consumers run `npm install react-native-litert-lm`.
+ *
+ * Skips download if:
+ *   - Not on macOS (iOS builds require macOS)
+ *   - Frameworks already exist
+ *   - CI environment with SKIP_IOS_FRAMEWORK_DOWNLOAD=1
+ */
+
+const { execSync } = require('child_process');
+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 SCRIPT_DIR = __dirname;
+const PACKAGE_ROOT = path.resolve(SCRIPT_DIR, '..');
+const FRAMEWORKS_DIR = path.join(PACKAGE_ROOT, 'ios', 'Frameworks');
+
+function log(msg) {
+  console.log(`[react-native-litert-lm] ${msg}`);
+}
+
+function shouldSkip() {
+  // Skip if not macOS
+  if (process.platform !== 'darwin') {
+    log('Skipping iOS framework download (not macOS).');
+    return true;
+  }
+
+  // Skip if explicitly disabled
+  if (process.env.SKIP_IOS_FRAMEWORK_DOWNLOAD === '1') {
+    log('Skipping iOS framework download (SKIP_IOS_FRAMEWORK_DOWNLOAD=1).');
+    return true;
+  }
+
+  // Skip if frameworks already exist
+  if (fs.existsSync(FRAMEWORKS_DIR) && fs.readdirSync(FRAMEWORKS_DIR).length > 0) {
+    log('iOS frameworks already present, skipping download.');
+    return true;
+  }
+
+  return false;
+}
+
+function downloadFile(url, destPath, maxRedirects = 5) {
+  return new Promise((resolve, reject) => {
+    if (maxRedirects <= 0) {
+      return reject(new Error('Too many redirects'));
+    }
+
+    const protocol = url.startsWith('https') ? https : require('http');
+
+    protocol.get(url, { headers: { 'User-Agent': 'react-native-litert-lm' } }, (res) => {
+      // Follow redirects
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return downloadFile(res.headers.location, destPath, maxRedirects - 1)
+          .then(resolve)
+          .catch(reject);
+      }
+
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
+      }
+
+      const file = fs.createWriteStream(destPath);
+      res.pipe(file);
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+      file.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+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}`);
+
+  const tmpZip = path.join(PACKAGE_ROOT, '.ios-frameworks-tmp.zip');
+
+  try {
+    await downloadFile(releaseUrl, tmpZip);
+
+    // Extract
+    fs.mkdirSync(FRAMEWORKS_DIR, { recursive: true });
+    execSync(`unzip -o -q "${tmpZip}" -d "${FRAMEWORKS_DIR}"`, { stdio: 'inherit' });
+
+    // Cleanup
+    fs.unlinkSync(tmpZip);
+
+    log('iOS frameworks installed successfully.');
+  } catch (err) {
+    // Don't fail the install — iOS frameworks are optional (Android-only users)
+    log(`Warning: 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.');
+
+    // Cleanup partial download
+    try { fs.unlinkSync(tmpZip); } catch {}
+  }
+}
+
+main();

package/scripts/stubs/cxx_bridge_stubs.cc

@@ -0,0 +1,224 @@
+/**
+ * cxx_bridge_stubs.cc
+ *
+ * Provides stub implementations for the Rust CXX bridge runtime.
+ *
+ * ARCHITECTURE NOTES:
+ * The CXX bridge generates two halves:
+ *   1. Rust .o files define C++ mangled wrappers (e.g., litert::lm::new_minijinja_template)
+ *      that call extern "C" shims (e.g., _litert$lm$cxxbridge1$new_minijinja_template)
+ *   2. Generated C++ code defines those extern "C" shims, which call the actual Rust FFI entry points
+ *
+ * Since we only have half #1 (the Rust .o), we provide stub extern "C" shims.
+ *
+ * CRITICAL: These stubs must NOT forward (via __asm__) to the C++ mangled functions
+ * in the Rust .o files. Those functions call RIGHT BACK to these extern "C" stubs,
+ * creating infinite recursion → stack overflow → SIGBUS.
+ *
+ * ALLOCATOR CONSISTENCY: All stubs use calloc/free. Since our stub creates the objects
+ * (not real Rust code), our drop/dealloc stubs using free() are perfectly consistent.
+ * If the real Rust code created the objects, there would be a mismatch, but it doesn't
+ * because these stubs intercept the calls before Rust can run.
+ */
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+// ============================================================================
+// Part 1: CXX Runtime Types
+// ============================================================================
+
+namespace rust {
+namespace cxxbridge1 {
+
+class String;
+
+class Str {
+public:
+  const char* ptr;
+  size_t len;
+  Str(const char* s);
+  Str(const String& s);
+  const char* data() const;
+  size_t size() const;
+  operator std::string() const;
+};
+
+class String {
+public:
+  struct Repr { char* ptr; size_t len; size_t cap; };
+  Repr repr_;
+  String(String&& o) noexcept;
+  String(const std::string& s);
+  ~String();
+  const char* data() const;
+  size_t size() const;
+  operator std::string() const;
+};
+
+Str::Str(const char* s) : ptr(s), len(s ? strlen(s) : 0) {}
+Str::Str(const String& s) : ptr(s.data()), len(s.size()) {}
+const char* Str::data() const { return ptr; }
+size_t Str::size() const { return len; }
+Str::operator std::string() const { return std::string(ptr, len); }
+
+String::String(String&& o) noexcept : repr_(o.repr_) { o.repr_ = {nullptr,0,0}; }
+String::String(const std::string& s) {
+  repr_.len = s.size();
+  repr_.cap = s.size() + 1;
+  repr_.ptr = static_cast<char*>(malloc(repr_.cap));
+  if (repr_.ptr) memcpy(repr_.ptr, s.c_str(), repr_.cap);
+}
+String::~String() { if (repr_.ptr) free(repr_.ptr); }
+const char* String::data() const { return repr_.ptr ? repr_.ptr : ""; }
+size_t String::size() const { return repr_.len; }
+String::operator std::string() const { return std::string(data(), size()); }
+
+template<typename T> class Vec {
+public:
+  T* data_; size_t len_; size_t cap_;
+  Vec();
+  const T* data() const;
+  size_t size() const;
+  void drop();
+};
+
+template<typename T> Vec<T>::Vec() : data_(nullptr), len_(0), cap_(0) {}
+template<typename T> const T* Vec<T>::data() const { return data_; }
+template<typename T> size_t Vec<T>::size() const { return len_; }
+template<typename T> void Vec<T>::drop() { if (data_) { free(data_); data_ = nullptr; } len_ = cap_ = 0; }
+
+template class Vec<String>;
+
+void sliceInit(void* s, const void* p, size_t l) {
+  auto* a = static_cast<const void**>(s);
+  a[0] = p; *reinterpret_cast<size_t*>(&a[1]) = l;
+}
+size_t sliceLen(const void* s) {
+  return *reinterpret_cast<const size_t*>(static_cast<const void* const*>(s)+1);
+}
+const void* slicePtr(const void* s) {
+  return static_cast<const void* const*>(s)[0];
+}
+
+}  // namespace cxxbridge1
+}  // namespace rust
+
+
+// ============================================================================
+// Part 2: extern "C" stubs
+//
+// All stubs use calloc/free for allocation. NO __asm__ forwarding to the C++
+// mangled Rust functions, which would create mutual recursion.
+// ============================================================================
+extern "C" {
+
+// --- rust_vec for JsonValue ---
+void* cxxbridge1$rust_vec$litert$lm$JsonValue$new() { return nullptr; }
+const void* cxxbridge1$rust_vec$litert$lm$JsonValue$data(const void*) { return nullptr; }
+size_t cxxbridge1$rust_vec$litert$lm$JsonValue$len(const void*) { return 0; }
+size_t cxxbridge1$rust_vec$litert$lm$JsonValue$capacity(const void*) { return 0; }
+void cxxbridge1$rust_vec$litert$lm$JsonValue$set_len(void*, size_t) {}
+void cxxbridge1$rust_vec$litert$lm$JsonValue$truncate(void*, size_t) {}
+void cxxbridge1$rust_vec$litert$lm$JsonValue$reserve_total(void*, size_t) {}
+void cxxbridge1$rust_vec$litert$lm$JsonValue$drop(void*) {}
+
+// --- Box<MinijinjaTemplate> ---
+// Allocate zeroed memory; consistent with free() in drop/dealloc.
+void* cxxbridge1$box$litert$lm$MinijinjaTemplate$alloc() {
+  return calloc(1, 64);
+}
+void cxxbridge1$box$litert$lm$MinijinjaTemplate$dealloc(void* p) {
+  if (p) free(p);
+}
+void cxxbridge1$box$litert$lm$MinijinjaTemplate$drop(void* p) {
+  if (p) free(p);
+}
+
+// --- Box<JsonValue> ---
+void* cxxbridge1$box$litert$lm$JsonValue$alloc() {
+  return calloc(1, 64);
+}
+void cxxbridge1$box$litert$lm$JsonValue$dealloc(void* p) {
+  if (p) free(p);
+}
+void cxxbridge1$box$litert$lm$JsonValue$drop(void* p) {
+  if (p) free(p);
+}
+
+// --- MinijinjaTemplate FFI shims ---
+// These are the Rust-side FFI entry points. The C++ mangled wrappers in the
+// Rust .o call INTO these. We must NOT forward back to those wrappers.
+size_t litert$lm$cxxbridge1$MinijinjaTemplate$operator$sizeof() { return 64; }
+size_t litert$lm$cxxbridge1$MinijinjaTemplate$operator$alignof() { return 8; }
+void litert$lm$cxxbridge1$MinijinjaTemplate$source(const void*, void* out) {
+  // Write an empty rust::cxxbridge1::String to out
+  if (out) memset(out, 0, 24);
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$apply(const void*, void* input, void* out) {
+  // Return an empty string result
+  if (out) memset(out, 0, 24);
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$clone_template(const void*, void* out) {
+  // Write a valid calloc'd pointer so drop() can safely free() it
+  if (out) {
+    void* cloned = calloc(1, 64);
+    memcpy(out, &cloned, sizeof(void*));
+  }
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$get_capabilities(const void*, void* out) {
+  if (out) memset(out, 0, 24);
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$get_error(const void*, void* out) {
+  if (out) memset(out, 0, 24);
+}
+
+// --- new_minijinja_template ---
+// Creates a Box<MinijinjaTemplate>. Writes a valid calloc'd pointer to `out`
+// so that later Box::drop() can free() it without issues.
+void litert$lm$cxxbridge1$new_minijinja_template(void* input, void* out) {
+  if (out) {
+    void* tmpl = calloc(1, 64);
+    memcpy(out, &tmpl, sizeof(void*));
+  }
+}
+
+// --- JsonValue FFI shims ---
+size_t litert$lm$cxxbridge1$JsonValue$operator$sizeof() { return 64; }
+size_t litert$lm$cxxbridge1$JsonValue$operator$alignof() { return 8; }
+void litert$lm$cxxbridge1$JsonValue$object_get(const void*, void*, void*) {}
+int litert$lm$cxxbridge1$JsonValue$is_null(const void*) { return 1; }
+int litert$lm$cxxbridge1$JsonValue$is_bool(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_number(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_string(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_array(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_object(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$get_bool(const void*) { return 0; }
+double litert$lm$cxxbridge1$JsonValue$get_number(const void*) { return 0.0; }
+void litert$lm$cxxbridge1$JsonValue$get_string(const void*, void*) {}
+size_t litert$lm$cxxbridge1$JsonValue$array_len(const void*) { return 0; }
+void litert$lm$cxxbridge1$JsonValue$array_get(const void*, size_t, void*) {}
+int litert$lm$cxxbridge1$JsonValue$object_has_key(const void*, void*) { return 0; }
+void litert$lm$cxxbridge1$JsonValue$object_keys(const void*, void*) {}
+
+// --- Parser/template FFI shims ---
+void litert$lm$cxxbridge1$parse_fc_expression(void*, void*) {}
+void litert$lm$cxxbridge1$parse_json_expression(void*, void*) {}
+void litert$lm$cxxbridge1$parse_python_expression(void*, void*) {}
+
+// --- Tokenizers FFI stubs ---
+void* byte_level_bpe_tokenizers_new_from_str(void*, void*, void*) { return nullptr; }
+void* tokenizers_decode(void*, void*, size_t, int) { return nullptr; }
+void* tokenizers_encode(void*, void*, size_t) { return nullptr; }
+void* tokenizers_encode_batch(void*, void**, size_t, size_t) { return nullptr; }
+void tokenizers_free(void*) {}
+void tokenizers_free_encode_results(void*, size_t) {}
+void* tokenizers_get_decode_str(void*) { return nullptr; }
+int tokenizers_get_vocab_size(void*, int) { return 0; }
+void* tokenizers_id_to_token(void*, int) { return nullptr; }
+void* tokenizers_new_from_str(void*, size_t) { return nullptr; }
+int tokenizers_token_to_id(void*, void*, size_t) { return 0; }
+
+}  // extern "C"

package/scripts/stubs/gemma_model_constraint_provider.cc

@@ -0,0 +1,46 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#include <cstdio>
+
+struct LiteRtLmGemmaModelConstraintProvider {
+    int dummy;
+};
+
+extern "C" {
+
+void* LiteRtLmGemmaModelConstraintProvider_Create(
+    const char* serialized_sp_model_proto, size_t serialized_sp_model_proto_len,
+    const int** stop_token_ids, const size_t* stop_token_lengths,
+    size_t num_stop_lists) {
+    fprintf(stderr, "\n[LiteRT-LM WARN] Gemma Constraint Provider is"
+                    " STUBBED/DISABLED.\n");
+    fprintf(stderr, "[LiteRT-LM WARN] Any requests for grammar-constrained"
+                    " decoding will be ignored or fail.\n\n");
+    // Return a dummy pointer so that engine creation doesn't fail!
+    return new LiteRtLmGemmaModelConstraintProvider{0};
+}
+
+void LiteRtLmGemmaModelConstraintProvider_Destroy(void* provider) {
+    if (provider) {
+        delete static_cast<LiteRtLmGemmaModelConstraintProvider*>(provider);
+    }
+}
+
+void* LiteRtLmGemmaModelConstraintProvider_CreateConstraintFromTools(
+    void* provider, void* tools, void* options) {
+    return nullptr;
+}
+}  // extern "C"

package/scripts/stubs/llguidance_stubs.c

@@ -0,0 +1,101 @@
+/**
+ * llguidance_stubs.c
+ *
+ * Stub implementations for the llguidance C API used by LiteRT-LM's
+ * constrained decoding subsystem (llg_constraint, llg_constraint_provider).
+ * The real implementation is a Rust library (llguidance) which is not
+ * available in the iOS Bazel build.
+ *
+ * These stubs return error/null values so that constrained decoding
+ * gracefully fails at runtime. Basic LLM inference is unaffected.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+
+/* Opaque types */
+typedef struct LlgTokenizer LlgTokenizer;
+typedef struct LlgConstraint LlgConstraint;
+typedef struct LlgConstraintInit LlgConstraintInit;
+
+/* llg_new_tokenizer: create a tokenizer handle */
+int llg_new_tokenizer(void* init, void** out_tokenizer) {
+    if (out_tokenizer) *out_tokenizer = NULL;
+    return -1; /* error */
+}
+
+/* llg_free_tokenizer: release tokenizer */
+void llg_free_tokenizer(void* tokenizer) {
+    (void)tokenizer;
+}
+
+/* llg_constraint_init_set_defaults: initialize constraint config */
+void llg_constraint_init_set_defaults(void* init, void* tokenizer) {
+    (void)init;
+    (void)tokenizer;
+}
+
+/* llg_new_constraint: create grammar constraint */
+void* llg_new_constraint(void* init, void* grammar) {
+    (void)init;
+    (void)grammar;
+    return NULL;
+}
+
+/* llg_new_constraint_json: create JSON schema constraint */
+void* llg_new_constraint_json(void* init, const char* json_schema) {
+    (void)init;
+    (void)json_schema;
+    return NULL;
+}
+
+/* llg_new_constraint_regex: create regex constraint */
+void* llg_new_constraint_regex(void* init, const char* regex) {
+    (void)init;
+    (void)regex;
+    return NULL;
+}
+
+/* llg_new_constraint_lark: create Lark grammar constraint */
+void* llg_new_constraint_lark(void* init, const char* lark_grammar) {
+    (void)init;
+    (void)lark_grammar;
+    return NULL;
+}
+
+/* llg_clone_constraint: duplicate a constraint */
+void* llg_clone_constraint(void* constraint) {
+    (void)constraint;
+    return NULL;
+}
+
+/* llg_compute_mask: compute next token mask */
+int llg_compute_mask(void* constraint, void* result) {
+    (void)constraint;
+    (void)result;
+    return -1; /* error */
+}
+
+/* llg_commit_token: commit selected token */
+int llg_commit_token(void* constraint, int32_t token) {
+    (void)constraint;
+    (void)token;
+    return -1; /* error */
+}
+
+/* llg_is_stopped: check if constraint reached accepting state */
+int llg_is_stopped(void* constraint) {
+    (void)constraint;
+    return 1; /* stopped (nothing to do) */
+}
+
+/* llg_get_error: get last error message */
+const char* llg_get_error(void* constraint) {
+    (void)constraint;
+    return "llguidance not available on iOS";
+}
+
+/* llg_free_constraint: release constraint */
+void llg_free_constraint(void* constraint) {
+    (void)constraint;
+}

package/src/hooks.ts

@@ -1,12 +1,13 @@
-import { useState, useEffect, useRef, useCallback } from "react";
-import { LiteRTLM, LLMConfig } from "./index";
+import { useState, useEffect, useRef, useCallback, useMemo } from "react";
+import { LLMConfig } from "./index";
 import { createLLM } from "./modelFactory";
+import type { LiteRTLMInstance } from "./modelFactory";
 import type { MemoryTracker, MemoryTrackerSummary } from "./memoryTracker";
 
 export interface UseModelConfig extends LLMConfig {
   autoLoad?: boolean;
   /**
-   * Enable memory tracking using native ArrayBuffers (v0.34+).
+   * Enable memory tracking using native ArrayBuffers (v0.35+).
    * When enabled, memory usage is tracked after each inference call
    * using `NitroModules.createNativeArrayBuffer()` for zero-copy storage.
    * @default false
@@ -21,14 +22,18 @@ export interface UseModelConfig extends LLMConfig {
 }
 
 export interface UseModelResult {
-  model: LiteRTLM | null;
+  model: LiteRTLMInstance | null;
   isReady: boolean;
   isGenerating: boolean;
   downloadProgress: number;
   error: string | null;
   generate: (prompt: string) => Promise<string>;
   reset: () => void;
-  deleteModel: (fileName: string) => Promise<void>;
+  /**
+   * Delete the model file. If no fileName is provided, derives it from
+   * the URL/path passed to useModel.
+   */
+  deleteModel: (fileName?: string) => Promise<void>;
   load: () => Promise<void>;
   /**
    * Memory tracker instance (available when enableMemoryTracking is true).
@@ -43,21 +48,49 @@ export interface UseModelResult {
   memorySummary: MemoryTrackerSummary | null;
 }
 
+/**
+ * Extract a filename from a URL or file path.
+ */
+function extractFileName(pathOrUrl: string): string {
+  return pathOrUrl.split("/").pop() || "model.bin";
+}
+
 export function useModel(
   pathOrUrl: string,
   config?: UseModelConfig,
 ): UseModelResult {
-  const modelRef = useRef<(LiteRTLM & { memoryTracker?: MemoryTracker }) | null>(null);
+  const modelRef = useRef<LiteRTLMInstance | null>(null);
   const [isReady, setIsReady] = useState(false);
   const [isGenerating, setIsGenerating] = useState(false);
   const [downloadProgress, setDownloadProgress] = useState(0);
   const [error, setError] = useState<string | null>(null);
   const [memorySummary, setMemorySummary] = useState<MemoryTrackerSummary | null>(null);
 
-  // Extract autoLoad (default true) and memory tracking options
+  // Destructure config into primitive values for stable dependency arrays.
+  // This prevents infinite re-render loops when consumers pass inline config
+  // objects (e.g. useModel(url, { backend: 'cpu' })) without useMemo.
   const autoLoad = config?.autoLoad ?? true;
   const enableMemoryTracking = config?.enableMemoryTracking ?? false;
   const maxMemorySnapshots = config?.maxMemorySnapshots ?? 256;
+  const backend = config?.backend;
+  const systemPrompt = config?.systemPrompt;
+  const maxTokens = config?.maxTokens;
+  const temperature = config?.temperature;
+  const topK = config?.topK;
+  const topP = config?.topP;
+
+  // Build a stable config object from the destructured primitives
+  const nativeConfig = useMemo<LLMConfig>(
+    () => ({
+      ...(backend !== undefined && { backend }),
+      ...(systemPrompt !== undefined && { systemPrompt }),
+      ...(maxTokens !== undefined && { maxTokens }),
+      ...(temperature !== undefined && { temperature }),
+      ...(topK !== undefined && { topK }),
+      ...(topP !== undefined && { topP }),
+    }),
+    [backend, systemPrompt, maxTokens, temperature, topK, topP],
+  );
 
   /**
    * Refresh memory summary from the tracker's native buffer.
@@ -74,11 +107,9 @@ export function useModel(
       enableMemoryTracking,
       maxMemorySnapshots,
     });
-    let isMounted = true;
 
     // Cleanup on unmount
     return () => {
-      isMounted = false;
       try {
         modelRef.current?.close();
       } catch (e) {
@@ -93,36 +124,24 @@ export function useModel(
     setDownloadProgress(0);
 
     try {
-      let modelPath = pathOrUrl;
-
-      // Handle URL download manually to capture progress
-      if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
-        const fileName = pathOrUrl.split("/").pop() || "model.bin";
-
-        if (modelRef.current) {
-          modelPath = await modelRef.current.downloadModel(
-            pathOrUrl,
-            fileName,
-            (progress) => {
-              setDownloadProgress(progress);
-            },
-          );
-        }
-      }
-
       if (modelRef.current) {
-        // Create a clean config object for native loadModel (excluding autoLoad)
-        const nativeConfig: LLMConfig = { ...config };
-        delete (nativeConfig as any).autoLoad;
-
-        await modelRef.current.loadModel(modelPath, nativeConfig);
+        // Delegate URL handling + download to the factory's loadModel,
+        // passing our progress setter as the callback (eliminates
+        // duplicate download logic that was previously in this hook).
+        await modelRef.current.loadModel(
+          pathOrUrl,
+          nativeConfig,
+          (progress) => {
+            setDownloadProgress(progress);
+          },
+        );
         setIsReady(true);
       }
     } catch (e: any) {
       setError(e.message || "Failed to load model");
       console.error(e);
     }
-  }, [pathOrUrl, config]);
+  }, [pathOrUrl, nativeConfig]);
 
   useEffect(() => {
     if (autoLoad) {
@@ -171,13 +190,17 @@ export function useModel(
     }
   }, []);
 
-  const deleteModel = useCallback(async (fileName: string): Promise<void> => {
-    if (modelRef.current) {
-      await modelRef.current.deleteModel(fileName);
-      setIsReady(false);
-      setDownloadProgress(0);
-    }
-  }, []);
+  const deleteModel = useCallback(
+    async (fileName?: string): Promise<void> => {
+      if (modelRef.current) {
+        const resolvedName = fileName ?? extractFileName(pathOrUrl);
+        await modelRef.current.deleteModel(resolvedName);
+        setIsReady(false);
+        setDownloadProgress(0);
+      }
+    },
+    [pathOrUrl],
+  );
 
   return {
     model: modelRef.current,