react-native-nobodywho 1.0.1 → 2.0.0

package/generated/cpp/nobodywho.hpp

@@ -211,6 +211,10 @@ protected:
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);
   jsi::Value
+  cpp_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+      jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+      size_t count);
+  jsi::Value
   cpp_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rusttoolcallback(
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);
@@ -573,6 +577,10 @@ protected:
   cpp_uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json(
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);
+  jsi::Value
+  cpp_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress(
+      jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+      size_t count);
   jsi::Value cpp_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call(
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);

package/generated/ts/nobodywho-ffi.ts

@@ -77,9 +77,10 @@ interface NativeModuleInterface {
     ubrn_uniffi_nobodywho_uniffi_fn_free_samplerconfig(handle: bigint, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_nobodywho_uniffi_fn_constructor_samplerconfig_from_json(jsonStr: Uint8Array, uniffi_out_err: UniffiRustCallStatus): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_method_samplerconfig_to_json(ptr: bigint, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(vtable: UniffiVTableCallbackInterfaceRustDownloadProgressCallback): void;
     ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rusttoolcallback(vtable: UniffiVTableCallbackInterfaceRustToolCallback): void;
     ubrn_uniffi_nobodywho_uniffi_fn_func_cosine_similarity(a: Uint8Array, b: Uint8Array, uniffi_out_err: UniffiRustCallStatus): number;
-    ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(modelPath: Uint8Array, useGpu: number, projectionModelPath: Uint8Array): bigint;
+    ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(modelPath: Uint8Array, useGpu: number, projectionModelPath: Uint8Array, onDownloadProgress: Uint8Array): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_default(uniffi_out_err: UniffiRustCallStatus): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_dry(uniffi_out_err: UniffiRustCallStatus): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_grammar(grammar: Uint8Array, uniffi_out_err: UniffiRustCallStatus): bigint;
@@ -189,6 +190,7 @@ interface NativeModuleInterface {
     ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new_async(): number;
     ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerbuilder_new(): number;
     ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json(): number;
+    ubrn_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress(): number;
     ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call(): number;
     ubrn_ffi_nobodywho_uniffi_uniffi_contract_version(): number;
     ubrn_uniffi_internal_fn_method_rustchat_ffi__bless_pointer(pointer: bigint, uniffi_out_err: UniffiRustCallStatus): UniffiGcObject;
@@ -278,8 +280,15 @@ export type UniffiForeignFutureResultVoid = {
   callStatus: UniffiRustCallStatus;
 };
 export type UniffiForeignFutureCompleteVoid = (callbackData: bigint, result: UniffiForeignFutureResultVoid) => void;
+type UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0 = (uniffiHandle: bigint, downloaded: bigint, total: bigint) => UniffiResult<void>
+;
 type UniffiCallbackInterfaceRustToolCallbackMethod0 = (uniffiHandle: bigint, argumentsJson: Uint8Array) => Uint8Array
 ;
+export type UniffiVTableCallbackInterfaceRustDownloadProgressCallback = {
+  uniffiFree: UniffiCallbackInterfaceFree;
+  uniffiClone: UniffiCallbackInterfaceClone;
+  onDownloadProgress: UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0;
+};
 export type UniffiVTableCallbackInterfaceRustToolCallback = {
   uniffiFree: UniffiCallbackInterfaceFree;
   uniffiClone: UniffiCallbackInterfaceClone;

package/generated/ts/nobodywho.ts

@@ -32,6 +32,7 @@ import nativeModule, {
   type UniffiForeignFutureCompleteRustBuffer,
   type UniffiForeignFutureResultVoid,
   type UniffiForeignFutureCompleteVoid,
+  type UniffiVTableCallbackInterfaceRustDownloadProgressCallback,
   type UniffiVTableCallbackInterfaceRustToolCallback,
 } from "./nobodywho-ffi";
 import {
@@ -104,13 +105,13 @@ export function cosineSimilarity(a: Array</*f32*/number>, b: Array</*f32*/number
  * uniffi-bindgen-react-native generates invalid JS (`async static` instead
  * of `static async`) for async constructors.
  */
-export async function loadModel(modelPath: string, useGpu: boolean, projectionModelPath: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustModelInterface> /*throws*/ {
+export async function loadModel(modelPath: string, useGpu: boolean, projectionModelPath: string | undefined, onDownloadProgress: RustDownloadProgressCallback | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustModelInterface> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
         return await uniffiRustCallAsync(
             /*rustCaller:*/ uniffiCaller,
             /*rustFutureFunc:*/ () => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(FfiConverterString.lower(modelPath),FfiConverterBool.lower(useGpu),FfiConverterOptionalString.lower(projectionModelPath)
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(FfiConverterString.lower(modelPath),FfiConverterBool.lower(useGpu),FfiConverterOptionalString.lower(projectionModelPath),FfiConverterOptionalTypeRustDownloadProgressCallback.lower(onDownloadProgress)
                 );
             },
             /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_u64,
@@ -234,6 +235,69 @@ export function samplerPresetTopP(topP: /*f32*/number): SamplerConfigInterface {
 
 
 
+/**
+ * Callback interface for download progress reporting. Implement this in your
+ * language to receive `(downloadedBytes, totalBytes)` events while a remote
+ * model is being downloaded. Throttled to ~10 Hz with a guaranteed final emit
+ * on completion. Not invoked for cached/local files.
+ */
+export interface RustDownloadProgressCallback {
+    
+    onDownloadProgress(downloaded: /*u64*/bigint, total: /*u64*/bigint) : void;
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceRustDownloadProgressCallback: { vtable: UniffiVTableCallbackInterfaceRustDownloadProgressCallback; register: () => void; } = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        onDownloadProgress: (
+            uniffiHandle: bigint,
+            downloaded: bigint,
+            total: bigint,) => {
+            const uniffiMakeCall = 
+            ()
+            : void => {
+                const jsCallback = FfiConverterTypeRustDownloadProgressCallback.lift(uniffiHandle);
+                return jsCallback.onDownloadProgress(
+                    FfiConverterUInt64.lift(downloaded), 
+                    FfiConverterUInt64.lift(total)
+                )
+            };
+            const uniffiResult = UniffiResult.ready<void>();
+            const uniffiHandleSuccess = (obj: any) => {};
+            const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+                UniffiResult.writeError(uniffiResult, code, errBuf);
+            };
+            uniffiTraitInterfaceCall(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*lowerString:*/ FfiConverterString.lower
+            )
+            return uniffiResult;
+        },
+        uniffiFree: (uniffiHandle: UniffiHandle): void => {
+            // RustDownloadProgressCallback: this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeRustDownloadProgressCallback.drop(uniffiHandle);
+        },
+        uniffiClone: (uniffiHandle: UniffiHandle): UniffiHandle => {
+            return FfiConverterTypeRustDownloadProgressCallback.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+            uniffiCallbackInterfaceRustDownloadProgressCallback.vtable
+        );
+    },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeRustDownloadProgressCallback = new FfiConverterCallback<RustDownloadProgressCallback>();
+
+
+
 /**
  * Callback interface for tool functions.
  * Implement this in your language to provide the tool's logic.
@@ -555,38 +619,39 @@ const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
 
 // Enum: Message
 export enum Message_Tags {
-    Message = "Message",
-    ToolCalls = "ToolCalls",
-    ToolResp = "ToolResp"
+    User = "User",
+    Assistant = "Assistant",
+    System = "System",
+    Tool = "Tool"
 }
 export const Message = (() => {
     
 
-    type Message__interface = {
-        tag: Message_Tags.Message;
-        inner: Readonly<{role: Role; content: string; assets: Array<Asset>}>
+    type User__interface = {
+        tag: Message_Tags.User;
+        inner: Readonly<{content: string; assets: Array<Asset>}>
     };
 
     
-    class Message_ extends UniffiEnum implements Message__interface {
+    class User_ extends UniffiEnum implements User__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
         readonly [uniffiTypeNameSymbol] = "Message";
-        readonly tag = Message_Tags.Message;
-        readonly inner: Readonly<{role: Role; content: string; assets: Array<Asset>}>;
-        constructor(inner: { role: Role, content: string, assets: Array<Asset> }) {
-            super("Message", "Message");
+        readonly tag = Message_Tags.User;
+        readonly inner: Readonly<{content: string; assets: Array<Asset>}>;
+        constructor(inner: { content: string, assets: Array<Asset> }) {
+            super("Message", "User");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { role: Role, content: string, assets: Array<Asset> }): Message_ {
-            return new Message_(inner);
+        static new(inner: { content: string, assets: Array<Asset> }): User_ {
+            return new User_(inner);
         }
 
-        static instanceOf(obj: any): obj is Message_ {
-            return obj.tag === Message_Tags.Message;
+        static instanceOf(obj: any): obj is User_ {
+            return obj.tag === Message_Tags.User;
         }
         
 
@@ -595,31 +660,31 @@ export const Message = (() => {
     }
     
 
-    type ToolCalls__interface = {
-        tag: Message_Tags.ToolCalls;
-        inner: Readonly<{role: Role; content: string; toolCalls: Array<ToolCall>}>
+    type Assistant__interface = {
+        tag: Message_Tags.Assistant;
+        inner: Readonly<{content: string; toolCalls: Array<ToolCall> | undefined}>
     };
 
     
-    class ToolCalls_ extends UniffiEnum implements ToolCalls__interface {
+    class Assistant_ extends UniffiEnum implements Assistant__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
         readonly [uniffiTypeNameSymbol] = "Message";
-        readonly tag = Message_Tags.ToolCalls;
-        readonly inner: Readonly<{role: Role; content: string; toolCalls: Array<ToolCall>}>;
-        constructor(inner: { role: Role, content: string, toolCalls: Array<ToolCall> }) {
-            super("Message", "ToolCalls");
+        readonly tag = Message_Tags.Assistant;
+        readonly inner: Readonly<{content: string; toolCalls: Array<ToolCall> | undefined}>;
+        constructor(inner: { content: string, toolCalls: Array<ToolCall> | undefined }) {
+            super("Message", "Assistant");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { role: Role, content: string, toolCalls: Array<ToolCall> }): ToolCalls_ {
-            return new ToolCalls_(inner);
+        static new(inner: { content: string, toolCalls: Array<ToolCall> | undefined }): Assistant_ {
+            return new Assistant_(inner);
         }
 
-        static instanceOf(obj: any): obj is ToolCalls_ {
-            return obj.tag === Message_Tags.ToolCalls;
+        static instanceOf(obj: any): obj is Assistant_ {
+            return obj.tag === Message_Tags.Assistant;
         }
         
 
@@ -628,31 +693,64 @@ export const Message = (() => {
     }
     
 
-    type ToolResp__interface = {
-        tag: Message_Tags.ToolResp;
-        inner: Readonly<{role: Role; name: string; content: string}>
+    type System__interface = {
+        tag: Message_Tags.System;
+        inner: Readonly<{content: string}>
     };
 
     
-    class ToolResp_ extends UniffiEnum implements ToolResp__interface {
+    class System_ extends UniffiEnum implements System__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
         readonly [uniffiTypeNameSymbol] = "Message";
-        readonly tag = Message_Tags.ToolResp;
-        readonly inner: Readonly<{role: Role; name: string; content: string}>;
-        constructor(inner: { role: Role, name: string, content: string }) {
-            super("Message", "ToolResp");
+        readonly tag = Message_Tags.System;
+        readonly inner: Readonly<{content: string}>;
+        constructor(inner: { content: string }) {
+            super("Message", "System");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { role: Role, name: string, content: string }): ToolResp_ {
-            return new ToolResp_(inner);
+        static new(inner: { content: string }): System_ {
+            return new System_(inner);
         }
 
-        static instanceOf(obj: any): obj is ToolResp_ {
-            return obj.tag === Message_Tags.ToolResp;
+        static instanceOf(obj: any): obj is System_ {
+            return obj.tag === Message_Tags.System;
+        }
+        
+
+        
+
+    }
+    
+
+    type Tool__interface = {
+        tag: Message_Tags.Tool;
+        inner: Readonly<{name: string; content: string}>
+    };
+
+    
+    class Tool_ extends UniffiEnum implements Tool__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "Message";
+        readonly tag = Message_Tags.Tool;
+        readonly inner: Readonly<{name: string; content: string}>;
+        constructor(inner: { name: string, content: string }) {
+            super("Message", "Tool");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { name: string, content: string }): Tool_ {
+            return new Tool_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Tool_ {
+            return obj.tag === Message_Tags.Tool;
         }
         
 
@@ -666,9 +764,10 @@ export const Message = (() => {
 
     return Object.freeze({
         instanceOf,
-  Message: Message_, 
-  ToolCalls: ToolCalls_, 
-  ToolResp: ToolResp_
+  User: User_, 
+  Assistant: Assistant_, 
+  System: System_, 
+  Tool: Tool_
     });
 
 })();
@@ -686,34 +785,38 @@ const FfiConverterTypeMessage = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         read(from: RustBuffer): TypeName {
             switch (ordinalConverter.read(from)) {
-                case 1: return new Message.Message({role: FfiConverterTypeRole.read(from), content: FfiConverterString.read(from), assets: FfiConverterArrayTypeAsset.read(from) });
-                case 2: return new Message.ToolCalls({role: FfiConverterTypeRole.read(from), content: FfiConverterString.read(from), toolCalls: FfiConverterArrayTypeToolCall.read(from) });
-                case 3: return new Message.ToolResp({role: FfiConverterTypeRole.read(from), name: FfiConverterString.read(from), content: FfiConverterString.read(from) });
+                case 1: return new Message.User({content: FfiConverterString.read(from), assets: FfiConverterArrayTypeAsset.read(from) });
+                case 2: return new Message.Assistant({content: FfiConverterString.read(from), toolCalls: FfiConverterOptionalArrayTypeToolCall.read(from) });
+                case 3: return new Message.System({content: FfiConverterString.read(from) });
+                case 4: return new Message.Tool({name: FfiConverterString.read(from), content: FfiConverterString.read(from) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value: TypeName, into: RustBuffer): void {
             switch (value.tag) {
-                case Message_Tags.Message: {
+                case Message_Tags.User: {
                     ordinalConverter.write(1, into);
                     const inner = value.inner;
-                    FfiConverterTypeRole.write(inner.role, into);
                     FfiConverterString.write(inner.content, into);
                     FfiConverterArrayTypeAsset.write(inner.assets, into);
                     return;
                 }
-                case Message_Tags.ToolCalls: {
+                case Message_Tags.Assistant: {
                     ordinalConverter.write(2, into);
                     const inner = value.inner;
-                    FfiConverterTypeRole.write(inner.role, into);
                     FfiConverterString.write(inner.content, into);
-                    FfiConverterArrayTypeToolCall.write(inner.toolCalls, into);
+                    FfiConverterOptionalArrayTypeToolCall.write(inner.toolCalls, into);
                     return;
                 }
-                case Message_Tags.ToolResp: {
+                case Message_Tags.System: {
                     ordinalConverter.write(3, into);
                     const inner = value.inner;
-                    FfiConverterTypeRole.write(inner.role, into);
+                    FfiConverterString.write(inner.content, into);
+                    return;
+                }
+                case Message_Tags.Tool: {
+                    ordinalConverter.write(4, into);
+                    const inner = value.inner;
                     FfiConverterString.write(inner.name, into);
                     FfiConverterString.write(inner.content, into);
                     return;
@@ -725,26 +828,29 @@ const FfiConverterTypeMessage = (() => {
         }
         allocationSize(value: TypeName): number {
             switch (value.tag) {
-                case Message_Tags.Message: {
+                case Message_Tags.User: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(1);
-                    size += FfiConverterTypeRole.allocationSize(inner.role);
                     size += FfiConverterString.allocationSize(inner.content);
                     size += FfiConverterArrayTypeAsset.allocationSize(inner.assets);
                     return size;
                 }
-                case Message_Tags.ToolCalls: {
+                case Message_Tags.Assistant: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(2);
-                    size += FfiConverterTypeRole.allocationSize(inner.role);
                     size += FfiConverterString.allocationSize(inner.content);
-                    size += FfiConverterArrayTypeToolCall.allocationSize(inner.toolCalls);
+                    size += FfiConverterOptionalArrayTypeToolCall.allocationSize(inner.toolCalls);
                     return size;
                 }
-                case Message_Tags.ToolResp: {
+                case Message_Tags.System: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(3);
-                    size += FfiConverterTypeRole.allocationSize(inner.role);
+                    size += FfiConverterString.allocationSize(inner.content);
+                    return size;
+                }
+                case Message_Tags.Tool: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(4);
                     size += FfiConverterString.allocationSize(inner.name);
                     size += FfiConverterString.allocationSize(inner.content);
                     return size;
@@ -1030,45 +1136,6 @@ const FfiConverterTypePromptPart = (() => {
 
 
 
-export enum Role {
-    User,
-    Assistant,
-    System,
-    Tool
-}
-
-const FfiConverterTypeRole = (() => {
-    const ordinalConverter = FfiConverterInt32;
-    type TypeName = Role;
-    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-        read(from: RustBuffer): TypeName {
-            switch (ordinalConverter.read(from)) {
-                case 1: return Role.User;
-                case 2: return Role.Assistant;
-                case 3: return Role.System;
-                case 4: return Role.Tool;
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
-        }
-        write(value: TypeName, into: RustBuffer): void {
-            switch (value) {
-                case Role.User: return ordinalConverter.write(1, into);
-                case Role.Assistant: return ordinalConverter.write(2, into);
-                case Role.System: return ordinalConverter.write(3, into);
-                case Role.Tool: return ordinalConverter.write(4, into);
-            }
-        }
-        allocationSize(value: TypeName): number {
-            return ordinalConverter.allocationSize(0);
-        }
-    }
-    return new FFIConverter();
-})();
-
-
-
-
-
 // FfiConverter for Map<string, boolean>
 const FfiConverterMapStringBool = new FfiConverterMap(FfiConverterString, FfiConverterBool);
 
@@ -2891,6 +2958,10 @@ const uniffiTypeSamplerConfigObjectFactory: UniffiObjectFactory<SamplerConfigInt
 const FfiConverterTypeSamplerConfig =  new FfiConverterObject(uniffiTypeSamplerConfigObjectFactory);
 
 
+// FfiConverter for RustDownloadProgressCallback | undefined
+const FfiConverterOptionalTypeRustDownloadProgressCallback = new FfiConverterOptional(FfiConverterTypeRustDownloadProgressCallback);
+
+
 // FfiConverter for PendingToolCall | undefined
 const FfiConverterOptionalTypePendingToolCall = new FfiConverterOptional(FfiConverterTypePendingToolCall);
 
@@ -2931,6 +3002,10 @@ const FfiConverterOptionalMapStringBool = new FfiConverterOptional(FfiConverterM
 const FfiConverterOptionalTypeSamplerConfig = new FfiConverterOptional(FfiConverterTypeSamplerConfig);
 
 
+// FfiConverter for Array<ToolCall> | undefined
+const FfiConverterOptionalArrayTypeToolCall = new FfiConverterOptional(FfiConverterArrayTypeToolCall);
+
+
 // FfiConverter for Array<Message>
 const FfiConverterArrayTypeMessage = new FfiConverterArray(FfiConverterTypeMessage);
 
@@ -2967,7 +3042,7 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_cosine_similarity() !== 63439) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_cosine_similarity");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_model() !== 63144) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_model() !== 33587) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_model");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_default() !== 10834) {
@@ -3123,10 +3198,14 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json() !== 6867) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json");
     }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress() !== 28617) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress");
+    }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call() !== 43958) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call");
     }
 
+    uniffiCallbackInterfaceRustDownloadProgressCallback.register();
     uniffiCallbackInterfaceRustToolCallback.register();
     }
 
@@ -3138,7 +3217,6 @@ export default Object.freeze({
     FfiConverterTypeNobodyWhoError,
     FfiConverterTypePendingToolCall,
     FfiConverterTypePromptPart,
-    FfiConverterTypeRole,
     FfiConverterTypeRustChat,
     FfiConverterTypeRustCrossEncoder,
     FfiConverterTypeRustEncoder,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nobodywho",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "Run LLMs locally with offline inference — React Native bindings",
   "main": "src/wrapper.ts",
   "types": "src/wrapper.ts",

package/src/chat.ts

@@ -3,7 +3,7 @@ import {
   SamplerConfig,
 } from "../generated/ts/nobodywho";
 import { Model } from "./model";
-import { type ChatMessage, fromInternal, toInternal } from "./message";
+import { type Message, fromInternal, toInternal } from "./message";
 import { TokenStream } from "./streaming";
 import type { Prompt } from "./prompt";
 import type { Tool } from "./tool";
@@ -69,11 +69,13 @@ export class Chat {
     templateVariables?: Record<string, boolean>;
     tools?: Tool[];
     sampler?: SamplerConfig;
+    onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<Chat> {
     const model = await Model.load({
       modelPath: opts.modelPath,
       useGpu: opts.useGpu,
       projectionModelPath: opts.projectionModelPath,
+      onDownloadProgress: opts.onDownloadProgress,
     });
     return new Chat({ model, ...opts });
   }
@@ -108,13 +110,13 @@ export class Chat {
   }
 
   /** Get the current chat history as a list of messages. */
-  async getChatHistory(): Promise<ChatMessage[]> {
+  async getChatHistory(): Promise<Message[]> {
     const internal = await this._inner.getChatHistory();
     return internal.map(fromInternal);
   }
 
   /** Set the chat history from a list of messages. */
-  async setChatHistory(messages: ChatMessage[]): Promise<void> {
+  async setChatHistory(messages: Message[]): Promise<void> {
     return this._inner.setChatHistory(messages.map(toInternal));
   }
 

package/src/cross_encoder.ts

@@ -35,8 +35,13 @@ export class CrossEncoder {
     modelPath: string;
     useGpu?: boolean;
     contextSize?: number;
+    onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<CrossEncoder> {
-    const model = await Model.load({ modelPath: opts.modelPath, useGpu: opts.useGpu });
+    const model = await Model.load({
+      modelPath: opts.modelPath,
+      useGpu: opts.useGpu,
+      onDownloadProgress: opts.onDownloadProgress,
+    });
     return new CrossEncoder({ model, ...opts });
   }
 

package/src/encoder.ts

@@ -31,8 +31,13 @@ export class Encoder {
     modelPath: string;
     useGpu?: boolean;
     contextSize?: number;
+    onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<Encoder> {
-    const model = await Model.load({ modelPath: opts.modelPath, useGpu: opts.useGpu });
+    const model = await Model.load({
+      modelPath: opts.modelPath,
+      useGpu: opts.useGpu,
+      onDownloadProgress: opts.onDownloadProgress,
+    });
     return new Encoder({ model, ...opts });
   }