react-native-nobodywho 0.0.1 → 0.1.0

package/generated/ts/nobodywho.ts

@@ -0,0 +1,3048 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import nativeModule, {
+  type UniffiRustFutureContinuationCallback,
+  type UniffiForeignFutureDroppedCallback,
+  type UniffiForeignFutureDroppedCallbackStruct,
+  type UniffiForeignFutureResultU8,
+  type UniffiForeignFutureCompleteU8,
+  type UniffiForeignFutureResultI8,
+  type UniffiForeignFutureCompleteI8,
+  type UniffiForeignFutureResultU16,
+  type UniffiForeignFutureCompleteU16,
+  type UniffiForeignFutureResultI16,
+  type UniffiForeignFutureCompleteI16,
+  type UniffiForeignFutureResultU32,
+  type UniffiForeignFutureCompleteU32,
+  type UniffiForeignFutureResultI32,
+  type UniffiForeignFutureCompleteI32,
+  type UniffiForeignFutureResultU64,
+  type UniffiForeignFutureCompleteU64,
+  type UniffiForeignFutureResultI64,
+  type UniffiForeignFutureCompleteI64,
+  type UniffiForeignFutureResultF32,
+  type UniffiForeignFutureCompleteF32,
+  type UniffiForeignFutureResultF64,
+  type UniffiForeignFutureCompleteF64,
+  type UniffiForeignFutureResultRustBuffer,
+  type UniffiForeignFutureCompleteRustBuffer,
+  type UniffiForeignFutureResultVoid,
+  type UniffiForeignFutureCompleteVoid,
+  type UniffiVTableCallbackInterfaceRustToolCallback,
+} from "./nobodywho-ffi";
+import {
+  type FfiConverter, 
+  type UniffiByteArray, 
+  type UniffiGcObject, 
+  type UniffiHandle, 
+  type UniffiObjectFactory, 
+  type UniffiReferenceHolder, 
+  type UniffiRustCallStatus, 
+  AbstractFfiConverterByteArray, 
+  FfiConverterArray, 
+  FfiConverterBool, 
+  FfiConverterCallback, 
+  FfiConverterFloat32, 
+  FfiConverterInt32, 
+  FfiConverterMap, 
+  FfiConverterObject, 
+  FfiConverterOptional, 
+  FfiConverterUInt32, 
+  FfiConverterUInt64, 
+  RustBuffer, 
+  UniffiAbstractObject, 
+  UniffiEnum, 
+  UniffiError, 
+  UniffiInternalError, 
+  UniffiResult, 
+  UniffiRustCaller, 
+  destructorGuardSymbol, 
+  pointerLiteralSymbol, 
+  uniffiCreateFfiConverterString, 
+  uniffiCreateRecord, 
+  uniffiRustCallAsync, 
+  uniffiTraitInterfaceCall, 
+  uniffiTypeNameSymbol, 
+  variantOrdinalSymbol } from "uniffi-bindgen-react-native";
+
+// Get converters from the other files, if any.
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+// Public interface members begin here.
+
+/**
+ * Compute the cosine similarity between two vectors.
+ */
+export function cosineSimilarity(a: Array</*f32*/number>, b: Array</*f32*/number>): /*f32*/number {
+    return FfiConverterFloat32.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_cosine_similarity(
+        FfiConverterArrayFloat32.lower(a),
+        FfiConverterArrayFloat32.lower(b),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Load a GGUF model from disk.
+ * This is a free function instead of an async constructor because
+ * uniffi-bindgen-react-native generates invalid JS (`async static` instead
+ * of `static async`) for async constructors.
+ */
+export async function loadModel(modelPath: string, useGpu: boolean, imageModelPath: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<ModelInterface> /*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(imageModelPath)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_u64,
+            /*liftFunc:*/ FfiConverterTypeModel.lift.bind(FfiConverterTypeModel),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+/**
+ * Get the default sampler configuration.
+ */
+export function samplerPresetDefault(): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_default(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Create a DRY sampler preset to reduce repetition.
+ */
+export function samplerPresetDry(): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_dry(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Create a sampler with a custom grammar constraint.
+ */
+export function samplerPresetGrammar(grammar: string): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_grammar(
+        FfiConverterString.lower(grammar),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Create a greedy sampler (always picks most probable token).
+ */
+export function samplerPresetGreedy(): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_greedy(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Create a sampler configured for JSON output generation.
+ */
+export function samplerPresetJson(): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_json(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Create a sampler with temperature scaling.
+ */
+export function samplerPresetTemperature(temperature: /*f32*/number): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_temperature(
+        FfiConverterFloat32.lower(temperature),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Create a sampler with top-k filtering only.
+ */
+export function samplerPresetTopK(topK: /*i32*/number): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_top_k(
+        FfiConverterInt32.lower(topK),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Create a sampler with nucleus (top-p) sampling.
+ */
+export function samplerPresetTopP(topP: /*f32*/number): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_top_p(
+        FfiConverterFloat32.lower(topP),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+
+
+
+
+
+/**
+ * Callback interface for tool functions.
+ * Implement this in your language to provide the tool's logic.
+ * The `call` method receives the tool arguments as a JSON string
+ * and should return the tool's result as a string.
+ */
+export interface RustToolCallback {
+    
+    call(argumentsJson: string) : string;
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceRustToolCallback: { vtable: UniffiVTableCallbackInterfaceRustToolCallback; register: () => void; } = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        call: (
+            uniffiHandle: bigint,
+            argumentsJson: Uint8Array,) => {
+            const uniffiMakeCall = 
+            ()
+            : string => {
+                const jsCallback = FfiConverterTypeRustToolCallback.lift(uniffiHandle);
+                return jsCallback.call(
+                    FfiConverterString.lift(argumentsJson)
+                )
+            };
+            const uniffiResult = UniffiResult.ready<Uint8Array>();
+            const uniffiHandleSuccess = (obj: any) => {
+                UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj));
+            };
+            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 => {
+            // RustToolCallback: this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeRustToolCallback.drop(uniffiHandle);
+        },
+        uniffiClone: (uniffiHandle: UniffiHandle): UniffiHandle => {
+            return FfiConverterTypeRustToolCallback.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rusttoolcallback(
+            uniffiCallbackInterfaceRustToolCallback.vtable
+        );
+    },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeRustToolCallback = new FfiConverterCallback<RustToolCallback>();
+
+
+
+
+
+
+export type Asset = {
+    id: string,
+    path: string
+}
+
+/**
+ * Generated factory for {@link Asset} record objects.
+ */
+export const Asset = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<Asset, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link Asset}, with defaults specified
+         * in Rust, in the {@link nobodywho} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link Asset}, with defaults specified
+         * in Rust, in the {@link nobodywho} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link nobodywho} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<Asset>,
+
+    });
+})();
+
+const FfiConverterTypeAsset = (() => {
+    type TypeName = Asset;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                id: FfiConverterString.read(from), 
+                path: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.id, into);
+            FfiConverterString.write(value.path, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.id) + 
+            FfiConverterString.allocationSize(value.path);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ToolCall = {
+    name: string,
+    argumentsJson: string
+}
+
+/**
+ * Generated factory for {@link ToolCall} record objects.
+ */
+export const ToolCall = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ToolCall, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link ToolCall}, with defaults specified
+         * in Rust, in the {@link nobodywho} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link ToolCall}, with defaults specified
+         * in Rust, in the {@link nobodywho} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link nobodywho} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<ToolCall>,
+
+    });
+})();
+
+const FfiConverterTypeToolCall = (() => {
+    type TypeName = ToolCall;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                name: FfiConverterString.read(from), 
+                argumentsJson: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.name, into);
+            FfiConverterString.write(value.argumentsJson, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.name) + 
+            FfiConverterString.allocationSize(value.argumentsJson);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ToolParameter = {
+    name: string,
+    /**
+     * JSON Schema for this parameter (e.g. `{"type": "string"}`).
+     */
+    schema: string
+}
+
+/**
+ * Generated factory for {@link ToolParameter} record objects.
+ */
+export const ToolParameter = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ToolParameter, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link ToolParameter}, with defaults specified
+         * in Rust, in the {@link nobodywho} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link ToolParameter}, with defaults specified
+         * in Rust, in the {@link nobodywho} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link nobodywho} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<ToolParameter>,
+
+    });
+})();
+
+const FfiConverterTypeToolParameter = (() => {
+    type TypeName = ToolParameter;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                name: FfiConverterString.read(from), 
+                schema: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.name, into);
+            FfiConverterString.write(value.schema, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.name) + 
+            FfiConverterString.allocationSize(value.schema);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+const stringConverter = {
+    stringToBytes: (s: string) =>
+        uniffiCaller.rustCall((status) => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(s, status)),
+    bytesToString: (ab: UniffiByteArray) =>
+        uniffiCaller.rustCall((status) => nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(ab, status)),
+    stringByteLength: (s: string) =>
+        uniffiCaller.rustCall((status) => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, status)),
+};
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+
+
+
+
+
+// Enum: Message
+export enum Message_Tags {
+    Message = "Message",
+    ToolCalls = "ToolCalls",
+    ToolResp = "ToolResp"
+}
+export const Message = (() => {
+    
+
+    type Message__interface = {
+        tag: Message_Tags.Message;
+        inner: Readonly<{role: Role; content: string; assets: Array<Asset>}>
+    };
+
+    
+    class Message_ extends UniffiEnum implements Message__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");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { role: Role, content: string, assets: Array<Asset> }): Message_ {
+            return new Message_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Message_ {
+            return obj.tag === Message_Tags.Message;
+        }
+        
+
+        
+
+    }
+    
+
+    type ToolCalls__interface = {
+        tag: Message_Tags.ToolCalls;
+        inner: Readonly<{role: Role; content: string; toolCalls: Array<ToolCall>}>
+    };
+
+    
+    class ToolCalls_ extends UniffiEnum implements ToolCalls__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");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { role: Role, content: string, toolCalls: Array<ToolCall> }): ToolCalls_ {
+            return new ToolCalls_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ToolCalls_ {
+            return obj.tag === Message_Tags.ToolCalls;
+        }
+        
+
+        
+
+    }
+    
+
+    type ToolResp__interface = {
+        tag: Message_Tags.ToolResp;
+        inner: Readonly<{role: Role; name: string; content: string}>
+    };
+
+    
+    class ToolResp_ extends UniffiEnum implements ToolResp__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");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { role: Role, name: string, content: string }): ToolResp_ {
+            return new ToolResp_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ToolResp_ {
+            return obj.tag === Message_Tags.ToolResp;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is Message {
+        return obj[uniffiTypeNameSymbol] === "Message";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Message: Message_, 
+  ToolCalls: ToolCalls_, 
+  ToolResp: ToolResp_
+    });
+
+})();
+
+
+
+export type Message = InstanceType<
+    typeof Message[keyof Omit<typeof Message, 'instanceOf'>]
+>;
+
+// FfiConverter for enum Message
+const FfiConverterTypeMessage = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = Message;
+    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) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case Message_Tags.Message: {
+                    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: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterTypeRole.write(inner.role, into);
+                    FfiConverterString.write(inner.content, into);
+                    FfiConverterArrayTypeToolCall.write(inner.toolCalls, into);
+                    return;
+                }
+                case Message_Tags.ToolResp: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterTypeRole.write(inner.role, into);
+                    FfiConverterString.write(inner.name, into);
+                    FfiConverterString.write(inner.content, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that Message_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case Message_Tags.Message: {
+                    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: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterTypeRole.allocationSize(inner.role);
+                    size += FfiConverterString.allocationSize(inner.content);
+                    size += FfiConverterArrayTypeToolCall.allocationSize(inner.toolCalls);
+                    return size;
+                }
+                case Message_Tags.ToolResp: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterTypeRole.allocationSize(inner.role);
+                    size += FfiConverterString.allocationSize(inner.name);
+                    size += FfiConverterString.allocationSize(inner.content);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+// Error type: NobodyWhoError
+
+// Enum: NobodyWhoError
+export enum NobodyWhoError_Tags {
+    Error = "Error"
+}
+export const NobodyWhoError = (() => {
+    
+
+    type Error__interface = {
+        tag: NobodyWhoError_Tags.Error;
+        inner: Readonly<{message: string}>
+    };
+
+    
+    class Error_ extends UniffiError implements Error__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "NobodyWhoError";
+        readonly tag = NobodyWhoError_Tags.Error;
+        readonly inner: Readonly<{message: string}>;
+        constructor(inner: { message: string }) {
+            super("NobodyWhoError", "Error");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { message: string }): Error_ {
+            return new Error_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Error_ {
+            return obj.tag === NobodyWhoError_Tags.Error;
+        }
+        
+
+        
+        static hasInner(obj: any): obj is Error_ {
+            return Error_.instanceOf(obj);
+        }
+
+        static getInner(obj: Error_): Readonly<{message: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is NobodyWhoError {
+        return obj[uniffiTypeNameSymbol] === "NobodyWhoError";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Error: Error_
+    });
+
+})();
+
+
+
+export type NobodyWhoError = InstanceType<
+    typeof NobodyWhoError[keyof Omit<typeof NobodyWhoError, 'instanceOf'>]
+>;
+
+// FfiConverter for enum NobodyWhoError
+const FfiConverterTypeNobodyWhoError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = NobodyWhoError;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new NobodyWhoError.Error({message: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case NobodyWhoError_Tags.Error: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.message, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that NobodyWhoError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case NobodyWhoError_Tags.Error: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.message);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+// Enum: PromptPart
+export enum PromptPart_Tags {
+    Text = "Text",
+    Image = "Image",
+    Audio = "Audio"
+}
+/**
+ * A part of a multimodal prompt.  Mirrors the core `PromptPart` enum.
+ */
+export const PromptPart = (() => {
+    
+
+    type Text__interface = {
+        tag: PromptPart_Tags.Text;
+        inner: Readonly<{content: string}>
+    };
+
+    
+    class Text_ extends UniffiEnum implements Text__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PromptPart";
+        readonly tag = PromptPart_Tags.Text;
+        readonly inner: Readonly<{content: string}>;
+        constructor(inner: { content: string }) {
+            super("PromptPart", "Text");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { content: string }): Text_ {
+            return new Text_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Text_ {
+            return obj.tag === PromptPart_Tags.Text;
+        }
+        
+
+        
+
+    }
+    
+
+    type Image__interface = {
+        tag: PromptPart_Tags.Image;
+        inner: Readonly<{path: string}>
+    };
+
+    
+    class Image_ extends UniffiEnum implements Image__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PromptPart";
+        readonly tag = PromptPart_Tags.Image;
+        readonly inner: Readonly<{path: string}>;
+        constructor(inner: { path: string }) {
+            super("PromptPart", "Image");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { path: string }): Image_ {
+            return new Image_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Image_ {
+            return obj.tag === PromptPart_Tags.Image;
+        }
+        
+
+        
+
+    }
+    
+
+    type Audio__interface = {
+        tag: PromptPart_Tags.Audio;
+        inner: Readonly<{path: string}>
+    };
+
+    
+    class Audio_ extends UniffiEnum implements Audio__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PromptPart";
+        readonly tag = PromptPart_Tags.Audio;
+        readonly inner: Readonly<{path: string}>;
+        constructor(inner: { path: string }) {
+            super("PromptPart", "Audio");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { path: string }): Audio_ {
+            return new Audio_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Audio_ {
+            return obj.tag === PromptPart_Tags.Audio;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is PromptPart {
+        return obj[uniffiTypeNameSymbol] === "PromptPart";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Text: Text_, 
+  Image: Image_, 
+  Audio: Audio_
+    });
+
+})();
+
+
+/**
+ * A part of a multimodal prompt.  Mirrors the core `PromptPart` enum.
+ */
+
+export type PromptPart = InstanceType<
+    typeof PromptPart[keyof Omit<typeof PromptPart, 'instanceOf'>]
+>;
+
+// FfiConverter for enum PromptPart
+const FfiConverterTypePromptPart = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = PromptPart;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new PromptPart.Text({content: FfiConverterString.read(from) });
+                case 2: return new PromptPart.Image({path: FfiConverterString.read(from) });
+                case 3: return new PromptPart.Audio({path: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case PromptPart_Tags.Text: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.content, into);
+                    return;
+                }
+                case PromptPart_Tags.Image: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.path, into);
+                    return;
+                }
+                case PromptPart_Tags.Audio: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.path, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that PromptPart_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case PromptPart_Tags.Text: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.content);
+                    return size;
+                }
+                case PromptPart_Tags.Image: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.path);
+                    return size;
+                }
+                case PromptPart_Tags.Audio: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.path);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+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);
+
+
+export interface CrossEncoderInterface {
+    
+    /**
+     * Rank documents by relevance to a query. Returns similarity scores.
+     */
+    rank(query: string, documents: Array<string>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Array</*f32*/number>>;
+    /**
+     * Rank documents and return them sorted by descending relevance.
+     * Returns a JSON string of [document, score] pairs since UniFFI
+     * doesn't support tuples directly.
+     */
+    rankAndSortJson(query: string, documents: Array<string>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string>;
+}
+
+
+export class CrossEncoder extends UniffiAbstractObject implements CrossEncoderInterface {
+
+    readonly [uniffiTypeNameSymbol] = "CrossEncoder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    /**
+     * Create a new cross-encoder for ranking documents by relevance.
+     */
+    constructor(model: ModelInterface, contextSize: /*u32*/number | undefined) {
+        super();
+        const pointer =
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_crossencoder_new(
+        FfiConverterTypeModel.lower(model),
+        FfiConverterOptionalUInt32.lower(contextSize),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    );
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeCrossEncoderObjectFactory.bless(pointer);
+    }
+
+    
+
+    
+    /**
+     * Rank documents by relevance to a query. Returns similarity scores.
+     */
+async  rank(query: string, documents: Array<string>, asyncOpts_?: { signal: AbortSignal }): Promise<Array</*f32*/number>> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_crossencoder_rank(
+                    uniffiTypeCrossEncoderObjectFactory.clonePointer(this),
+                    FfiConverterString.lower(query),FfiConverterArrayString.lower(documents)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterArrayFloat32.lift.bind(FfiConverterArrayFloat32),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Rank documents and return them sorted by descending relevance.
+     * Returns a JSON string of [document, score] pairs since UniFFI
+     * doesn't support tuples directly.
+     */
+async  rankAndSortJson(query: string, documents: Array<string>, asyncOpts_?: { signal: AbortSignal }): Promise<string> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_crossencoder_rank_and_sort_json(
+                    uniffiTypeCrossEncoderObjectFactory.clonePointer(this),
+                    FfiConverterString.lower(query),FfiConverterArrayString.lower(documents)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeCrossEncoderObjectFactory.pointer(this);
+            uniffiTypeCrossEncoderObjectFactory.freePointer(pointer);
+            uniffiTypeCrossEncoderObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is CrossEncoder {
+        return uniffiTypeCrossEncoderObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeCrossEncoderObjectFactory: UniffiObjectFactory<CrossEncoderInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): CrossEncoderInterface {
+        const instance = Object.create(CrossEncoder.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "CrossEncoder";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_crossencoder_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: CrossEncoderInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: CrossEncoderInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_crossencoder(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_crossencoder(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is CrossEncoderInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "CrossEncoder";
+    },
+}})();
+// FfiConverter for CrossEncoderInterface
+const FfiConverterTypeCrossEncoder =  new FfiConverterObject(uniffiTypeCrossEncoderObjectFactory);
+
+
+export interface EncoderInterface {
+    
+    /**
+     * Encode text into an embedding vector.
+     */
+    encode(text: string, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Array</*f32*/number>>;
+}
+
+
+export class Encoder extends UniffiAbstractObject implements EncoderInterface {
+
+    readonly [uniffiTypeNameSymbol] = "Encoder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    /**
+     * Create a new encoder for generating text embeddings.
+     */
+    constructor(model: ModelInterface, contextSize: /*u32*/number | undefined) {
+        super();
+        const pointer =
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_encoder_new(
+        FfiConverterTypeModel.lower(model),
+        FfiConverterOptionalUInt32.lower(contextSize),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    );
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeEncoderObjectFactory.bless(pointer);
+    }
+
+    
+
+    
+    /**
+     * Encode text into an embedding vector.
+     */
+async  encode(text: string, asyncOpts_?: { signal: AbortSignal }): Promise<Array</*f32*/number>> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_encoder_encode(
+                    uniffiTypeEncoderObjectFactory.clonePointer(this),
+                    FfiConverterString.lower(text)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterArrayFloat32.lift.bind(FfiConverterArrayFloat32),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeEncoderObjectFactory.pointer(this);
+            uniffiTypeEncoderObjectFactory.freePointer(pointer);
+            uniffiTypeEncoderObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is Encoder {
+        return uniffiTypeEncoderObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeEncoderObjectFactory: UniffiObjectFactory<EncoderInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): EncoderInterface {
+        const instance = Object.create(Encoder.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "Encoder";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_encoder_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: EncoderInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: EncoderInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_encoder(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_encoder(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is EncoderInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "Encoder";
+    },
+}})();
+// FfiConverter for EncoderInterface
+const FfiConverterTypeEncoder =  new FfiConverterObject(uniffiTypeEncoderObjectFactory);
+
+
+export interface ModelInterface {
+    
+}
+
+
+export class Model extends UniffiAbstractObject implements ModelInterface {
+
+    readonly [uniffiTypeNameSymbol] = "Model";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeModelObjectFactory.bless(pointer);
+}
+
+    
+
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeModelObjectFactory.pointer(this);
+            uniffiTypeModelObjectFactory.freePointer(pointer);
+            uniffiTypeModelObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is Model {
+        return uniffiTypeModelObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeModelObjectFactory: UniffiObjectFactory<ModelInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): ModelInterface {
+        const instance = Object.create(Model.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "Model";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_model_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: ModelInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: ModelInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_model(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_model(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is ModelInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "Model";
+    },
+}})();
+// FfiConverter for ModelInterface
+const FfiConverterTypeModel =  new FfiConverterObject(uniffiTypeModelObjectFactory);
+
+
+export interface RustChatInterface {
+    
+    /**
+     * Send a message and get a token stream for the response.
+     */
+    ask(message: string) : RustTokenStreamInterface;
+    /**
+     * Send a multimodal prompt (text + images/audio) and get a token stream.
+     *
+     * `parts` is an ordered list of `PromptPart` items.
+     * Image and audio parts should contain a local file-system path.
+     */
+    askWithPrompt(parts: Array<PromptPart>) : RustTokenStreamInterface;
+    /**
+     * Get the current chat history as a list of messages.
+     */
+    getChatHistory(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Array<Message>>;
+    /**
+     * Get the current sampler configuration as a JSON string.
+     */
+    getSamplerConfigJson(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string>;
+    /**
+     * Get the current system prompt.
+     */
+    getSystemPrompt(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string | undefined>;
+    /**
+     * Get all template variables.
+     */
+    getTemplateVariables(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Map<string, boolean>>;
+    /**
+     * Reset the chat context with a new system prompt and tools.
+     */
+    resetContext(systemPrompt: string | undefined, tools: Array<RustToolInterface> | undefined, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Reset the chat history, keeping the system prompt and tools.
+     */
+    resetHistory(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Set the chat history from a list of messages.
+     */
+    setChatHistory(messages: Array<Message>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Set the sampler configuration.
+     */
+    setSamplerConfig(sampler: SamplerConfigInterface, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Set the system prompt.
+     */
+    setSystemPrompt(systemPrompt: string | undefined, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Set a template variable.
+     */
+    setTemplateVariable(name: string, value: boolean, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Set the tools available to the model.
+     */
+    setTools(tools: Array<RustToolInterface>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Stop the current generation.
+     */
+    stopGeneration() : void;
+}
+
+
+export class RustChat extends UniffiAbstractObject implements RustChatInterface {
+
+    readonly [uniffiTypeNameSymbol] = "RustChat";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    /**
+     * Create a new chat session.
+     */
+    constructor(model: ModelInterface, systemPrompt: string | undefined, contextSize: /*u32*/number, templateVariables: Map<string, boolean> | undefined, tools: Array<RustToolInterface> | undefined, sampler: SamplerConfigInterface | undefined) {
+        super();
+        const pointer =
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_rustchat_new(
+        FfiConverterTypeModel.lower(model),
+        FfiConverterOptionalString.lower(systemPrompt),
+        FfiConverterUInt32.lower(contextSize),
+        FfiConverterOptionalMapStringBool.lower(templateVariables),
+        FfiConverterOptionalArrayTypeRustTool.lower(tools),
+        FfiConverterOptionalTypeSamplerConfig.lower(sampler),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    );
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeRustChatObjectFactory.bless(pointer);
+    }
+
+    
+
+    
+    /**
+     * Send a message and get a token stream for the response.
+     */
+ ask(message: string): RustTokenStreamInterface {
+    return FfiConverterTypeRustTokenStream.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_ask(uniffiTypeRustChatObjectFactory.clonePointer(this), 
+        FfiConverterString.lower(message),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Send a multimodal prompt (text + images/audio) and get a token stream.
+     *
+     * `parts` is an ordered list of `PromptPart` items.
+     * Image and audio parts should contain a local file-system path.
+     */
+ askWithPrompt(parts: Array<PromptPart>): RustTokenStreamInterface {
+    return FfiConverterTypeRustTokenStream.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_ask_with_prompt(uniffiTypeRustChatObjectFactory.clonePointer(this), 
+        FfiConverterArrayTypePromptPart.lower(parts),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Get the current chat history as a list of messages.
+     */
+async  getChatHistory(asyncOpts_?: { signal: AbortSignal }): Promise<Array<Message>> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_get_chat_history(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this)
+                    
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterArrayTypeMessage.lift.bind(FfiConverterArrayTypeMessage),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Get the current sampler configuration as a JSON string.
+     */
+async  getSamplerConfigJson(asyncOpts_?: { signal: AbortSignal }): Promise<string> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_get_sampler_config_json(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this)
+                    
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Get the current system prompt.
+     */
+async  getSystemPrompt(asyncOpts_?: { signal: AbortSignal }): Promise<string | undefined> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_get_system_prompt(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this)
+                    
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterOptionalString.lift.bind(FfiConverterOptionalString),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Get all template variables.
+     */
+async  getTemplateVariables(asyncOpts_?: { signal: AbortSignal }): Promise<Map<string, boolean>> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_get_template_variables(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this)
+                    
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterMapStringBool.lift.bind(FfiConverterMapStringBool),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Reset the chat context with a new system prompt and tools.
+     */
+async  resetContext(systemPrompt: string | undefined, tools: Array<RustToolInterface> | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_reset_context(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this),
+                    FfiConverterOptionalString.lower(systemPrompt),FfiConverterOptionalArrayTypeRustTool.lower(tools)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Reset the chat history, keeping the system prompt and tools.
+     */
+async  resetHistory(asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_reset_history(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this)
+                    
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Set the chat history from a list of messages.
+     */
+async  setChatHistory(messages: Array<Message>, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_set_chat_history(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this),
+                    FfiConverterArrayTypeMessage.lower(messages)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Set the sampler configuration.
+     */
+async  setSamplerConfig(sampler: SamplerConfigInterface, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_set_sampler_config(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this),
+                    FfiConverterTypeSamplerConfig.lower(sampler)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Set the system prompt.
+     */
+async  setSystemPrompt(systemPrompt: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_set_system_prompt(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this),
+                    FfiConverterOptionalString.lower(systemPrompt)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Set a template variable.
+     */
+async  setTemplateVariable(name: string, value: boolean, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_set_template_variable(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this),
+                    FfiConverterString.lower(name),FfiConverterBool.lower(value)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Set the tools available to the model.
+     */
+async  setTools(tools: Array<RustToolInterface>, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_set_tools(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this),
+                    FfiConverterArrayTypeRustTool.lower(tools)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Stop the current generation.
+     */
+ stopGeneration(): void {uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => { nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_stop_generation(uniffiTypeRustChatObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    );
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeRustChatObjectFactory.pointer(this);
+            uniffiTypeRustChatObjectFactory.freePointer(pointer);
+            uniffiTypeRustChatObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is RustChat {
+        return uniffiTypeRustChatObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeRustChatObjectFactory: UniffiObjectFactory<RustChatInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): RustChatInterface {
+        const instance = Object.create(RustChat.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "RustChat";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_rustchat_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: RustChatInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: RustChatInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rustchat(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rustchat(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is RustChatInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustChat";
+    },
+}})();
+// FfiConverter for RustChatInterface
+const FfiConverterTypeRustChat =  new FfiConverterObject(uniffiTypeRustChatObjectFactory);
+
+
+export interface RustTokenStreamInterface {
+    
+    /**
+     * Wait for the full response to complete and return it.
+     */
+    completed(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string>;
+    /**
+     * Get the next token. Returns None when generation is complete.
+     */
+    nextToken(asyncOpts_?: { signal: AbortSignal }) : Promise<string | undefined>;
+}
+
+
+export class RustTokenStream extends UniffiAbstractObject implements RustTokenStreamInterface {
+
+    readonly [uniffiTypeNameSymbol] = "RustTokenStream";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeRustTokenStreamObjectFactory.bless(pointer);
+}
+
+    
+
+    
+    /**
+     * Wait for the full response to complete and return it.
+     */
+async  completed(asyncOpts_?: { signal: AbortSignal }): Promise<string> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rusttokenstream_completed(
+                    uniffiTypeRustTokenStreamObjectFactory.clonePointer(this)
+                    
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+    /**
+     * Get the next token. Returns None when generation is complete.
+     */
+async  nextToken(asyncOpts_?: { signal: AbortSignal }): Promise<string | undefined> {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rusttokenstream_next_token(
+                    uniffiTypeRustTokenStreamObjectFactory.clonePointer(this)
+                    
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_free_rust_buffer,
+            /*liftFunc:*/ FfiConverterOptionalString.lift.bind(FfiConverterOptionalString),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeRustTokenStreamObjectFactory.pointer(this);
+            uniffiTypeRustTokenStreamObjectFactory.freePointer(pointer);
+            uniffiTypeRustTokenStreamObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is RustTokenStream {
+        return uniffiTypeRustTokenStreamObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeRustTokenStreamObjectFactory: UniffiObjectFactory<RustTokenStreamInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): RustTokenStreamInterface {
+        const instance = Object.create(RustTokenStream.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "RustTokenStream";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_rusttokenstream_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: RustTokenStreamInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: RustTokenStreamInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rusttokenstream(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rusttokenstream(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is RustTokenStreamInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustTokenStream";
+    },
+}})();
+// FfiConverter for RustTokenStreamInterface
+const FfiConverterTypeRustTokenStream =  new FfiConverterObject(uniffiTypeRustTokenStreamObjectFactory);
+
+
+export interface RustToolInterface {
+    
+    /**
+     * Get the JSON schema for this tool's parameters as a string.
+     */
+    getSchemaJson() : string;
+}
+
+
+export class RustTool extends UniffiAbstractObject implements RustToolInterface {
+
+    readonly [uniffiTypeNameSymbol] = "RustTool";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    /**
+     * Create a tool that the model can call during inference.
+     *
+     * `parameters` is an ordered list of parameter definitions.
+     * Each entry has a `name` and a `type` (e.g. `"string"`, `"integer"`, `"number"`, `"boolean"`).
+     * The order matters — binding layers use it to map positional arguments
+     * in the user's callback function to named JSON parameters.
+     *
+     * Supported types: `"string"`, `"integer"` / `"int"`, `"number"` / `"float"` / `"double"`,
+     * `"boolean"` / `"bool"`.
+     * A JSON schema is generated automatically from this list.
+     *
+     * The callback receives the model's arguments as a JSON string
+     * (e.g. `{"city": "London", "degrees": 22}`).
+     * Each binding layer wraps the user's function to parse this JSON and
+     * pass individual typed arguments to the original function.
+     */
+    constructor(name: string, description: string, parameters: Array<ToolParameter>, callback: RustToolCallback) {
+        super();
+        const pointer =
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_rusttool_new(
+        FfiConverterString.lower(name),
+        FfiConverterString.lower(description),
+        FfiConverterArrayTypeToolParameter.lower(parameters),
+        FfiConverterTypeRustToolCallback.lower(callback),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    );
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeRustToolObjectFactory.bless(pointer);
+    }
+
+    
+
+    
+    /**
+     * Get the JSON schema for this tool's parameters as a string.
+     */
+ getSchemaJson(): string {
+    return FfiConverterString.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rusttool_get_schema_json(uniffiTypeRustToolObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeRustToolObjectFactory.pointer(this);
+            uniffiTypeRustToolObjectFactory.freePointer(pointer);
+            uniffiTypeRustToolObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is RustTool {
+        return uniffiTypeRustToolObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeRustToolObjectFactory: UniffiObjectFactory<RustToolInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): RustToolInterface {
+        const instance = Object.create(RustTool.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "RustTool";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_rusttool_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: RustToolInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: RustToolInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rusttool(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rusttool(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is RustToolInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustTool";
+    },
+}})();
+// FfiConverter for RustToolInterface
+const FfiConverterTypeRustTool =  new FfiConverterObject(uniffiTypeRustToolObjectFactory);
+
+
+export interface SamplerBuilderInterface {
+    
+    /**
+     * Sample from the probability distribution (weighted random selection).
+     */
+    dist() : SamplerConfigInterface;
+    /**
+     * DRY (Don't Repeat Yourself) sampler to reduce repetition.
+     */
+    dry(multiplier: /*f32*/number, base: /*f32*/number, allowedLength: /*i32*/number, penaltyLastN: /*i32*/number, seqBreakers: Array<string>) : SamplerBuilderInterface;
+    /**
+     * Apply a grammar constraint to enforce structured output.
+     */
+    grammar(grammar: string, triggerOn: string | undefined, root: string) : SamplerBuilderInterface;
+    /**
+     * Always select the most probable token (deterministic).
+     */
+    greedy() : SamplerConfigInterface;
+    /**
+     * Keep tokens with probability above min_p * (probability of most likely token).
+     */
+    minP(minP: /*f32*/number, minKeep: /*u32*/number) : SamplerBuilderInterface;
+    /**
+     * Use Mirostat v1 algorithm for perplexity-controlled sampling.
+     */
+    mirostatV1(tau: /*f32*/number, eta: /*f32*/number, m: /*i32*/number) : SamplerConfigInterface;
+    /**
+     * Use Mirostat v2 algorithm for perplexity-controlled sampling.
+     */
+    mirostatV2(tau: /*f32*/number, eta: /*f32*/number) : SamplerConfigInterface;
+    /**
+     * Apply repetition penalties to discourage repeated tokens.
+     */
+    penalties(penaltyLastN: /*i32*/number, penaltyRepeat: /*f32*/number, penaltyFreq: /*f32*/number, penaltyPresent: /*f32*/number) : SamplerBuilderInterface;
+    /**
+     * Apply temperature scaling to the probability distribution.
+     */
+    temperature(temperature: /*f32*/number) : SamplerBuilderInterface;
+    /**
+     * Keep only the top K most probable tokens.
+     */
+    topK(topK: /*i32*/number) : SamplerBuilderInterface;
+    /**
+     * Keep tokens whose cumulative probability is below top_p.
+     */
+    topP(topP: /*f32*/number, minKeep: /*u32*/number) : SamplerBuilderInterface;
+    /**
+     * Typical sampling: keeps tokens close to expected information content.
+     */
+    typicalP(typP: /*f32*/number, minKeep: /*u32*/number) : SamplerBuilderInterface;
+    /**
+     * XTC sampler that probabilistically excludes high-probability tokens.
+     */
+    xtc(xtcProbability: /*f32*/number, xtcThreshold: /*f32*/number, minKeep: /*u32*/number) : SamplerBuilderInterface;
+}
+
+
+export class SamplerBuilder extends UniffiAbstractObject implements SamplerBuilderInterface {
+
+    readonly [uniffiTypeNameSymbol] = "SamplerBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    /**
+     * Create a new SamplerBuilder to construct a custom sampler chain.
+     */
+    constructor() {
+        super();
+        const pointer =
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_samplerbuilder_new(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    );
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeSamplerBuilderObjectFactory.bless(pointer);
+    }
+
+    
+
+    
+    /**
+     * Sample from the probability distribution (weighted random selection).
+     */
+ dist(): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_dist(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * DRY (Don't Repeat Yourself) sampler to reduce repetition.
+     */
+ dry(multiplier: /*f32*/number, base: /*f32*/number, allowedLength: /*i32*/number, penaltyLastN: /*i32*/number, seqBreakers: Array<string>): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_dry(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(multiplier),
+        FfiConverterFloat32.lower(base),
+        FfiConverterInt32.lower(allowedLength),
+        FfiConverterInt32.lower(penaltyLastN),
+        FfiConverterArrayString.lower(seqBreakers),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Apply a grammar constraint to enforce structured output.
+     */
+ grammar(grammar: string, triggerOn: string | undefined, root: string): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_grammar(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterString.lower(grammar),
+        FfiConverterOptionalString.lower(triggerOn),
+        FfiConverterString.lower(root),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Always select the most probable token (deterministic).
+     */
+ greedy(): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_greedy(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Keep tokens with probability above min_p * (probability of most likely token).
+     */
+ minP(minP: /*f32*/number, minKeep: /*u32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_min_p(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(minP),
+        FfiConverterUInt32.lower(minKeep),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Use Mirostat v1 algorithm for perplexity-controlled sampling.
+     */
+ mirostatV1(tau: /*f32*/number, eta: /*f32*/number, m: /*i32*/number): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_mirostat_v1(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(tau),
+        FfiConverterFloat32.lower(eta),
+        FfiConverterInt32.lower(m),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Use Mirostat v2 algorithm for perplexity-controlled sampling.
+     */
+ mirostatV2(tau: /*f32*/number, eta: /*f32*/number): SamplerConfigInterface {
+    return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_mirostat_v2(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(tau),
+        FfiConverterFloat32.lower(eta),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Apply repetition penalties to discourage repeated tokens.
+     */
+ penalties(penaltyLastN: /*i32*/number, penaltyRepeat: /*f32*/number, penaltyFreq: /*f32*/number, penaltyPresent: /*f32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_penalties(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterInt32.lower(penaltyLastN),
+        FfiConverterFloat32.lower(penaltyRepeat),
+        FfiConverterFloat32.lower(penaltyFreq),
+        FfiConverterFloat32.lower(penaltyPresent),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Apply temperature scaling to the probability distribution.
+     */
+ temperature(temperature: /*f32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_temperature(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(temperature),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Keep only the top K most probable tokens.
+     */
+ topK(topK: /*i32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_top_k(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterInt32.lower(topK),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Keep tokens whose cumulative probability is below top_p.
+     */
+ topP(topP: /*f32*/number, minKeep: /*u32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_top_p(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(topP),
+        FfiConverterUInt32.lower(minKeep),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Typical sampling: keeps tokens close to expected information content.
+     */
+ typicalP(typP: /*f32*/number, minKeep: /*u32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_typical_p(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(typP),
+        FfiConverterUInt32.lower(minKeep),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * XTC sampler that probabilistically excludes high-probability tokens.
+     */
+ xtc(xtcProbability: /*f32*/number, xtcThreshold: /*f32*/number, minKeep: /*u32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_xtc(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(xtcProbability),
+        FfiConverterFloat32.lower(xtcThreshold),
+        FfiConverterUInt32.lower(minKeep),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeSamplerBuilderObjectFactory.pointer(this);
+            uniffiTypeSamplerBuilderObjectFactory.freePointer(pointer);
+            uniffiTypeSamplerBuilderObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is SamplerBuilder {
+        return uniffiTypeSamplerBuilderObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeSamplerBuilderObjectFactory: UniffiObjectFactory<SamplerBuilderInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): SamplerBuilderInterface {
+        const instance = Object.create(SamplerBuilder.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "SamplerBuilder";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_samplerbuilder_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: SamplerBuilderInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: SamplerBuilderInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_samplerbuilder(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_samplerbuilder(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is SamplerBuilderInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "SamplerBuilder";
+    },
+}})();
+// FfiConverter for SamplerBuilderInterface
+const FfiConverterTypeSamplerBuilder =  new FfiConverterObject(uniffiTypeSamplerBuilderObjectFactory);
+
+
+export interface SamplerConfigInterface {
+    
+    /**
+     * Serialize the sampler configuration to a JSON string.
+     */
+    toJson()  /*throws*/: string;
+}
+
+
+export class SamplerConfig extends UniffiAbstractObject implements SamplerConfigInterface {
+
+    readonly [uniffiTypeNameSymbol] = "SamplerConfig";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeSamplerConfigObjectFactory.bless(pointer);
+}
+
+    
+    /**
+     * Deserialize a sampler configuration from a JSON string.
+     */
+static fromJson(jsonStr: string): SamplerConfigInterface /*throws*/ {
+    return FfiConverterTypeSamplerConfig.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_samplerconfig_from_json(
+        FfiConverterString.lower(jsonStr),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+
+    
+    /**
+     * Serialize the sampler configuration to a JSON string.
+     */
+ toJson(): string /*throws*/ {
+    return FfiConverterString.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerconfig_to_json(uniffiTypeSamplerConfigObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeSamplerConfigObjectFactory.pointer(this);
+            uniffiTypeSamplerConfigObjectFactory.freePointer(pointer);
+            uniffiTypeSamplerConfigObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is SamplerConfig {
+        return uniffiTypeSamplerConfigObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeSamplerConfigObjectFactory: UniffiObjectFactory<SamplerConfigInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): SamplerConfigInterface {
+        const instance = Object.create(SamplerConfig.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "SamplerConfig";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_samplerconfig_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: SamplerConfigInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: SamplerConfigInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_samplerconfig(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_samplerconfig(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is SamplerConfigInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "SamplerConfig";
+    },
+}})();
+// FfiConverter for SamplerConfigInterface
+const FfiConverterTypeSamplerConfig =  new FfiConverterObject(uniffiTypeSamplerConfigObjectFactory);
+
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+
+// FfiConverter for /*u32*/number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+
+
+// FfiConverter for Array</*f32*/number>
+const FfiConverterArrayFloat32 = new FfiConverterArray(FfiConverterFloat32);
+
+
+// FfiConverter for Array<Asset>
+const FfiConverterArrayTypeAsset = new FfiConverterArray(FfiConverterTypeAsset);
+
+
+// FfiConverter for Array<ToolCall>
+const FfiConverterArrayTypeToolCall = new FfiConverterArray(FfiConverterTypeToolCall);
+
+
+// FfiConverter for Array<ToolParameter>
+const FfiConverterArrayTypeToolParameter = new FfiConverterArray(FfiConverterTypeToolParameter);
+
+
+// FfiConverter for Array<string>
+const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
+
+
+// FfiConverter for Map<string, boolean> | undefined
+const FfiConverterOptionalMapStringBool = new FfiConverterOptional(FfiConverterMapStringBool);
+
+
+// FfiConverter for SamplerConfigInterface | undefined
+const FfiConverterOptionalTypeSamplerConfig = new FfiConverterOptional(FfiConverterTypeSamplerConfig);
+
+
+// FfiConverter for Array<Message>
+const FfiConverterArrayTypeMessage = new FfiConverterArray(FfiConverterTypeMessage);
+
+
+// FfiConverter for Array<PromptPart>
+const FfiConverterArrayTypePromptPart = new FfiConverterArray(FfiConverterTypePromptPart);
+
+
+// FfiConverter for Array<RustToolInterface>
+const FfiConverterArrayTypeRustTool = new FfiConverterArray(FfiConverterTypeRustTool);
+
+
+// FfiConverter for Array<RustToolInterface> | undefined
+const FfiConverterOptionalArrayTypeRustTool = new FfiConverterOptional(FfiConverterArrayTypeRustTool);
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ubrn_ffi_nobodywho_uniffi_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    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() !== 19243) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_model");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_default() !== 10834) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_default");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_dry() !== 55378) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_dry");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_grammar() !== 29288) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_grammar");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_greedy() !== 13219) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_greedy");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_json() !== 40006) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_json");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_temperature() !== 64803) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_temperature");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_top_k() !== 44137) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_top_k");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_top_p() !== 54893) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_top_p");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_crossencoder_rank() !== 14399) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_crossencoder_rank");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_crossencoder_rank_and_sort_json() !== 4173) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_crossencoder_rank_and_sort_json");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_encoder_encode() !== 21765) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_encoder_encode");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_ask() !== 53575) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_ask");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_ask_with_prompt() !== 65089) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_ask_with_prompt");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_get_chat_history() !== 12722) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_get_chat_history");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_get_sampler_config_json() !== 33078) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_get_sampler_config_json");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_get_system_prompt() !== 57727) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_get_system_prompt");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_get_template_variables() !== 19616) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_get_template_variables");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_reset_context() !== 47191) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_reset_context");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_reset_history() !== 12058) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_reset_history");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_set_chat_history() !== 6058) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_set_chat_history");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_set_sampler_config() !== 28012) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_set_sampler_config");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_set_system_prompt() !== 31690) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_set_system_prompt");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_set_template_variable() !== 64000) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_set_template_variable");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_set_tools() !== 55680) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_set_tools");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_stop_generation() !== 24711) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_stop_generation");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttokenstream_completed() !== 26060) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttokenstream_completed");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttokenstream_next_token() !== 44770) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttokenstream_next_token");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttool_get_schema_json() !== 4679) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttool_get_schema_json");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dist() !== 23376) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dist");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dry() !== 35315) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dry");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_grammar() !== 24369) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_grammar");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_greedy() !== 32898) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_greedy");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_min_p() !== 33705) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_min_p");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_mirostat_v1() !== 58563) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_mirostat_v1");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_mirostat_v2() !== 41682) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_mirostat_v2");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_penalties() !== 40767) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_penalties");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_temperature() !== 8456) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_temperature");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_top_k() !== 26600) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_top_k");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_top_p() !== 54577) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_top_p");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_typical_p() !== 28727) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_typical_p");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_xtc() !== 22853) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_xtc");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerconfig_to_json() !== 51798) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerconfig_to_json");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_crossencoder_new() !== 12491) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_crossencoder_new");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_encoder_new() !== 32094) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_encoder_new");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rustchat_new() !== 6355) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rustchat_new");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new() !== 54104) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerbuilder_new() !== 50214) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_samplerbuilder_new");
+    }
+    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_rusttoolcallback_call() !== 43958) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call");
+    }
+
+    uniffiCallbackInterfaceRustToolCallback.register();
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeAsset,
+    FfiConverterTypeCrossEncoder,
+    FfiConverterTypeEncoder,
+    FfiConverterTypeMessage,
+    FfiConverterTypeModel,
+    FfiConverterTypeNobodyWhoError,
+    FfiConverterTypePromptPart,
+    FfiConverterTypeRole,
+    FfiConverterTypeRustChat,
+    FfiConverterTypeRustTokenStream,
+    FfiConverterTypeRustTool,
+    FfiConverterTypeSamplerBuilder,
+    FfiConverterTypeSamplerConfig,
+    FfiConverterTypeToolCall,
+    FfiConverterTypeToolParameter,
+  }
+});