react-native-nobodywho 3.0.0 → 5.0.0

package/generated/ts/nobodywho.ts

@@ -344,19 +344,6 @@ export function samplerPresetDry(): SamplerConfigInterface {
             /*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).
  */
@@ -369,6 +356,9 @@ export function samplerPresetGreedy(): SamplerConfigInterface {
             /*liftString:*/ FfiConverterString.lift,
     ));
     }
+/**
+ * Constrain output to a JSON object of any shape.
+ */
 export function samplerPresetJson(): SamplerConfigInterface {
     return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
             /*caller:*/ (callStatus) => {
@@ -392,7 +382,7 @@ export function samplerPresetTemperature(temperature: /*f32*/number): SamplerCon
     ));
     }
 /**
- * Create a sampler with top-k filtering only.
+ * Create a sampler with the default steps, but top-k overridden.
  */
 export function samplerPresetTopK(topK: /*i32*/number): SamplerConfigInterface {
     return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
@@ -405,7 +395,7 @@ export function samplerPresetTopK(topK: /*i32*/number): SamplerConfigInterface {
     ));
     }
 /**
- * Create a sampler with nucleus (top-p) sampling.
+ * Create a sampler with the default steps, but nucleus (top-p) overridden.
  */
 export function samplerPresetTopP(topP: /*f32*/number): SamplerConfigInterface {
     return FfiConverterTypeSamplerConfig.lift(uniffiCaller.rustCall(
@@ -555,29 +545,32 @@ const FfiConverterTypeRustToolCallback = new FfiConverterCallback<RustToolCallba
 
 
 
-export type Asset = {
-    id: string,
-    path: string
+/**
+ * A cached `.gguf` model and its on-disk size.
+ */
+export type CachedModel = {
+    path: string,
+    size: /*u64*/bigint
 }
 
 /**
- * Generated factory for {@link Asset} record objects.
+ * Generated factory for {@link CachedModel} record objects.
  */
-export const Asset = (() => {
+export const CachedModel = (() => {
     const defaults = () => ({
     });
     const create = (() => {
-        return uniffiCreateRecord<Asset, ReturnType<typeof defaults>>(defaults);
+        return uniffiCreateRecord<CachedModel, ReturnType<typeof defaults>>(defaults);
     })();
     return Object.freeze({
         /**
-         * Create a frozen instance of {@link Asset}, with defaults specified
+         * Create a frozen instance of {@link CachedModel}, with defaults specified
          * in Rust, in the {@link nobodywho} crate.
          */
         create,
 
         /**
-         * Create a frozen instance of {@link Asset}, with defaults specified
+         * Create a frozen instance of {@link CachedModel}, with defaults specified
          * in Rust, in the {@link nobodywho} crate.
          */
         new: create,
@@ -585,27 +578,27 @@ export const Asset = (() => {
         /**
          * Defaults specified in the {@link nobodywho} crate.
          */
-        defaults: () => Object.freeze(defaults()) as Partial<Asset>,
+        defaults: () => Object.freeze(defaults()) as Partial<CachedModel>,
 
     });
 })();
 
-const FfiConverterTypeAsset = (() => {
-    type TypeName = Asset;
+const FfiConverterTypeCachedModel = (() => {
+    type TypeName = CachedModel;
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         read(from: RustBuffer): TypeName {
             return {
-                id: FfiConverterString.read(from), 
-                path: FfiConverterString.read(from)
+                path: FfiConverterString.read(from), 
+                size: FfiConverterUInt64.read(from)
             };
         }
         write(value: TypeName, into: RustBuffer): void {
-            FfiConverterString.write(value.id, into);
             FfiConverterString.write(value.path, into);
+            FfiConverterUInt64.write(value.size, into);
         }
         allocationSize(value: TypeName): number {
-            return FfiConverterString.allocationSize(value.id) + 
-            FfiConverterString.allocationSize(value.path);
+            return FfiConverterString.allocationSize(value.path) + 
+            FfiConverterUInt64.allocationSize(value.size);
             
         }
     };
@@ -613,32 +606,29 @@ const FfiConverterTypeAsset = (() => {
 })();
 
 
-/**
- * A cached `.gguf` model and its on-disk size.
- */
-export type CachedModel = {
-    path: string,
-    size: /*u64*/bigint
+export type ChatStats = {
+    contextSize: /*u32*/number,
+    contextUsed: /*u32*/number
 }
 
 /**
- * Generated factory for {@link CachedModel} record objects.
+ * Generated factory for {@link ChatStats} record objects.
  */
-export const CachedModel = (() => {
+export const ChatStats = (() => {
     const defaults = () => ({
     });
     const create = (() => {
-        return uniffiCreateRecord<CachedModel, ReturnType<typeof defaults>>(defaults);
+        return uniffiCreateRecord<ChatStats, ReturnType<typeof defaults>>(defaults);
     })();
     return Object.freeze({
         /**
-         * Create a frozen instance of {@link CachedModel}, with defaults specified
+         * Create a frozen instance of {@link ChatStats}, with defaults specified
          * in Rust, in the {@link nobodywho} crate.
          */
         create,
 
         /**
-         * Create a frozen instance of {@link CachedModel}, with defaults specified
+         * Create a frozen instance of {@link ChatStats}, with defaults specified
          * in Rust, in the {@link nobodywho} crate.
          */
         new: create,
@@ -646,27 +636,27 @@ export const CachedModel = (() => {
         /**
          * Defaults specified in the {@link nobodywho} crate.
          */
-        defaults: () => Object.freeze(defaults()) as Partial<CachedModel>,
+        defaults: () => Object.freeze(defaults()) as Partial<ChatStats>,
 
     });
 })();
 
-const FfiConverterTypeCachedModel = (() => {
-    type TypeName = CachedModel;
+const FfiConverterTypeChatStats = (() => {
+    type TypeName = ChatStats;
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         read(from: RustBuffer): TypeName {
             return {
-                path: FfiConverterString.read(from), 
-                size: FfiConverterUInt64.read(from)
+                contextSize: FfiConverterUInt32.read(from), 
+                contextUsed: FfiConverterUInt32.read(from)
             };
         }
         write(value: TypeName, into: RustBuffer): void {
-            FfiConverterString.write(value.path, into);
-            FfiConverterUInt64.write(value.size, into);
+            FfiConverterUInt32.write(value.contextSize, into);
+            FfiConverterUInt32.write(value.contextUsed, into);
         }
         allocationSize(value: TypeName): number {
-            return FfiConverterString.allocationSize(value.path) + 
-            FfiConverterUInt64.allocationSize(value.size);
+            return FfiConverterUInt32.allocationSize(value.contextSize) + 
+            FfiConverterUInt32.allocationSize(value.contextUsed);
             
         }
     };
@@ -674,29 +664,47 @@ const FfiConverterTypeCachedModel = (() => {
 })();
 
 
-export type ChatStats = {
-    contextSize: /*u32*/number,
-    contextUsed: /*u32*/number
+/**
+ * How a chat forgets old turns when its context is full. A turn is a user
+ * message and everything up to the next one; system messages are always kept.
+ */
+export type ContextShiftOptions = {
+    /**
+     * `false` disables shifting, so a full context is an error instead.
+     */
+    enabled: boolean,
+    /**
+     * Turns always kept at the start of the history.
+     */
+    keepFirstTurns: /*u32*/number,
+    /**
+     * Turns always kept at the end of the history; at least 1.
+     */
+    keepLastTurns: /*u32*/number,
+    /**
+     * Size the history is shrunk to. `null` means half the context size.
+     */
+    target: ShiftTarget | undefined
 }
 
 /**
- * Generated factory for {@link ChatStats} record objects.
+ * Generated factory for {@link ContextShiftOptions} record objects.
  */
-export const ChatStats = (() => {
-    const defaults = () => ({
+export const ContextShiftOptions = (() => {
+    const defaults = () => ({enabled: true,keepFirstTurns: 1,keepLastTurns: 2,target: undefined
     });
     const create = (() => {
-        return uniffiCreateRecord<ChatStats, ReturnType<typeof defaults>>(defaults);
+        return uniffiCreateRecord<ContextShiftOptions, ReturnType<typeof defaults>>(defaults);
     })();
     return Object.freeze({
         /**
-         * Create a frozen instance of {@link ChatStats}, with defaults specified
+         * Create a frozen instance of {@link ContextShiftOptions}, with defaults specified
          * in Rust, in the {@link nobodywho} crate.
          */
         create,
 
         /**
-         * Create a frozen instance of {@link ChatStats}, with defaults specified
+         * Create a frozen instance of {@link ContextShiftOptions}, with defaults specified
          * in Rust, in the {@link nobodywho} crate.
          */
         new: create,
@@ -704,27 +712,33 @@ export const ChatStats = (() => {
         /**
          * Defaults specified in the {@link nobodywho} crate.
          */
-        defaults: () => Object.freeze(defaults()) as Partial<ChatStats>,
+        defaults: () => Object.freeze(defaults()) as Partial<ContextShiftOptions>,
 
     });
 })();
 
-const FfiConverterTypeChatStats = (() => {
-    type TypeName = ChatStats;
+const FfiConverterTypeContextShiftOptions = (() => {
+    type TypeName = ContextShiftOptions;
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         read(from: RustBuffer): TypeName {
             return {
-                contextSize: FfiConverterUInt32.read(from), 
-                contextUsed: FfiConverterUInt32.read(from)
+                enabled: FfiConverterBool.read(from), 
+                keepFirstTurns: FfiConverterUInt32.read(from), 
+                keepLastTurns: FfiConverterUInt32.read(from), 
+                target: FfiConverterOptionalTypeShiftTarget.read(from)
             };
         }
         write(value: TypeName, into: RustBuffer): void {
-            FfiConverterUInt32.write(value.contextSize, into);
-            FfiConverterUInt32.write(value.contextUsed, into);
+            FfiConverterBool.write(value.enabled, into);
+            FfiConverterUInt32.write(value.keepFirstTurns, into);
+            FfiConverterUInt32.write(value.keepLastTurns, into);
+            FfiConverterOptionalTypeShiftTarget.write(value.target, into);
         }
         allocationSize(value: TypeName): number {
-            return FfiConverterUInt32.allocationSize(value.contextSize) + 
-            FfiConverterUInt32.allocationSize(value.contextUsed);
+            return FfiConverterBool.allocationSize(value.enabled) + 
+            FfiConverterUInt32.allocationSize(value.keepFirstTurns) + 
+            FfiConverterUInt32.allocationSize(value.keepLastTurns) + 
+            FfiConverterOptionalTypeShiftTarget.allocationSize(value.target);
             
         }
     };
@@ -804,6 +818,79 @@ const FfiConverterTypeMtpConfig = (() => {
 })();
 
 
+/**
+ * Settings to apply before a `complete` turn. An unset field keeps what the
+ * chat has; a set one stays set, like a leading system message.
+ */
+export type Options = {
+    sampler: SamplerConfigInterface | undefined,
+    /**
+     * Replaces the chat's template variables wholesale.
+     */
+    templateVariables: Map<string, boolean> | undefined,
+    /**
+     * Re-selects the chat template, so the turn re-prefills from near token
+     * zero. An empty list removes the tools.
+     */
+    tools: Array<RustToolInterface> | undefined
+}
+
+/**
+ * Generated factory for {@link Options} record objects.
+ */
+export const Options = (() => {
+    const defaults = () => ({sampler: undefined,templateVariables: undefined,tools: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<Options, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link Options}, with defaults specified
+         * in Rust, in the {@link nobodywho} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link Options}, 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<Options>,
+
+    });
+})();
+
+const FfiConverterTypeOptions = (() => {
+    type TypeName = Options;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                sampler: FfiConverterOptionalTypeSamplerConfig.read(from), 
+                templateVariables: FfiConverterOptionalMapStringBool.read(from), 
+                tools: FfiConverterOptionalArrayTypeRustTool.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterOptionalTypeSamplerConfig.write(value.sampler, into);
+            FfiConverterOptionalMapStringBool.write(value.templateVariables, into);
+            FfiConverterOptionalArrayTypeRustTool.write(value.tools, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalTypeSamplerConfig.allocationSize(value.sampler) + 
+            FfiConverterOptionalMapStringBool.allocationSize(value.templateVariables) + 
+            FfiConverterOptionalArrayTypeRustTool.allocationSize(value.tools);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
 /**
  * A pending tool call waiting for resolution from the language binding.
  */
@@ -999,6 +1086,209 @@ const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
 
 
 
+// Enum: ContentPart
+export enum ContentPart_Tags {
+    Text = "Text",
+    Image = "Image",
+    Audio = "Audio"
+}
+/**
+ * One piece of a message: a run of text, or a media file at this position.
+ * The core type's bitmap id is worker-local, so it is not mirrored — media is
+ * re-registered from the path whenever content is handed back in.
+ */
+export const ContentPart = (() => {
+    
+
+    type Text__interface = {
+        tag: ContentPart_Tags.Text;
+        inner: Readonly<{text: string}>
+    };
+
+    
+    class Text_ extends UniffiEnum implements Text__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ContentPart";
+        readonly tag = ContentPart_Tags.Text;
+        readonly inner: Readonly<{text: string}>;
+        constructor(inner: { text: string }) {
+            super("ContentPart", "Text");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { text: string }): Text_ {
+            return new Text_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Text_ {
+            return obj.tag === ContentPart_Tags.Text;
+        }
+        
+
+        
+
+    }
+    
+
+    type Image__interface = {
+        tag: ContentPart_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] = "ContentPart";
+        readonly tag = ContentPart_Tags.Image;
+        readonly inner: Readonly<{path: string}>;
+        constructor(inner: { path: string }) {
+            super("ContentPart", "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 === ContentPart_Tags.Image;
+        }
+        
+
+        
+
+    }
+    
+
+    type Audio__interface = {
+        tag: ContentPart_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] = "ContentPart";
+        readonly tag = ContentPart_Tags.Audio;
+        readonly inner: Readonly<{path: string}>;
+        constructor(inner: { path: string }) {
+            super("ContentPart", "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 === ContentPart_Tags.Audio;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is ContentPart {
+        return obj[uniffiTypeNameSymbol] === "ContentPart";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Text: Text_, 
+  Image: Image_, 
+  Audio: Audio_
+    });
+
+})();
+
+
+/**
+ * One piece of a message: a run of text, or a media file at this position.
+ * The core type's bitmap id is worker-local, so it is not mirrored — media is
+ * re-registered from the path whenever content is handed back in.
+ */
+
+export type ContentPart = InstanceType<
+    typeof ContentPart[keyof Omit<typeof ContentPart, 'instanceOf'>]
+>;
+
+// FfiConverter for enum ContentPart
+const FfiConverterTypeContentPart = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = ContentPart;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new ContentPart.Text({text: FfiConverterString.read(from) });
+                case 2: return new ContentPart.Image({path: FfiConverterString.read(from) });
+                case 3: return new ContentPart.Audio({path: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case ContentPart_Tags.Text: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.text, into);
+                    return;
+                }
+                case ContentPart_Tags.Image: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.path, into);
+                    return;
+                }
+                case ContentPart_Tags.Audio: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.path, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ContentPart_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case ContentPart_Tags.Text: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.text);
+                    return size;
+                }
+                case ContentPart_Tags.Image: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.path);
+                    return size;
+                }
+                case ContentPart_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();
+})();
+
+
+
 // Enum: Message
 export enum Message_Tags {
     User = "User",
@@ -1011,7 +1301,7 @@ export const Message = (() => {
 
     type User__interface = {
         tag: Message_Tags.User;
-        inner: Readonly<{content: string; assets: Array<Asset>}>
+        inner: Readonly<{content: MessageContent}>
     };
 
     
@@ -1022,13 +1312,13 @@ export const Message = (() => {
          */
         readonly [uniffiTypeNameSymbol] = "Message";
         readonly tag = Message_Tags.User;
-        readonly inner: Readonly<{content: string; assets: Array<Asset>}>;
-        constructor(inner: { content: string, assets: Array<Asset> }) {
+        readonly inner: Readonly<{content: MessageContent}>;
+        constructor(inner: { content: MessageContent }) {
             super("Message", "User");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { content: string, assets: Array<Asset> }): User_ {
+        static new(inner: { content: MessageContent }): User_ {
             return new User_(inner);
         }
 
@@ -1044,7 +1334,7 @@ export const Message = (() => {
 
     type Assistant__interface = {
         tag: Message_Tags.Assistant;
-        inner: Readonly<{content: string; toolCalls: Array<ToolCall> | undefined}>
+        inner: Readonly<{content: MessageContent; toolCalls: Array<ToolCall> | undefined}>
     };
 
     
@@ -1055,13 +1345,13 @@ export const Message = (() => {
          */
         readonly [uniffiTypeNameSymbol] = "Message";
         readonly tag = Message_Tags.Assistant;
-        readonly inner: Readonly<{content: string; toolCalls: Array<ToolCall> | undefined}>;
-        constructor(inner: { content: string, toolCalls: Array<ToolCall> | undefined }) {
+        readonly inner: Readonly<{content: MessageContent; toolCalls: Array<ToolCall> | undefined}>;
+        constructor(inner: { content: MessageContent, toolCalls: Array<ToolCall> | undefined }) {
             super("Message", "Assistant");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { content: string, toolCalls: Array<ToolCall> | undefined }): Assistant_ {
+        static new(inner: { content: MessageContent, toolCalls: Array<ToolCall> | undefined }): Assistant_ {
             return new Assistant_(inner);
         }
 
@@ -1077,7 +1367,7 @@ export const Message = (() => {
 
     type System__interface = {
         tag: Message_Tags.System;
-        inner: Readonly<{content: string}>
+        inner: Readonly<{content: MessageContent}>
     };
 
     
@@ -1088,13 +1378,13 @@ export const Message = (() => {
          */
         readonly [uniffiTypeNameSymbol] = "Message";
         readonly tag = Message_Tags.System;
-        readonly inner: Readonly<{content: string}>;
-        constructor(inner: { content: string }) {
+        readonly inner: Readonly<{content: MessageContent}>;
+        constructor(inner: { content: MessageContent }) {
             super("Message", "System");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { content: string }): System_ {
+        static new(inner: { content: MessageContent }): System_ {
             return new System_(inner);
         }
 
@@ -1110,7 +1400,7 @@ export const Message = (() => {
 
     type Tool__interface = {
         tag: Message_Tags.Tool;
-        inner: Readonly<{name: string; content: string}>
+        inner: Readonly<{name: string; content: MessageContent}>
     };
 
     
@@ -1121,13 +1411,13 @@ export const Message = (() => {
          */
         readonly [uniffiTypeNameSymbol] = "Message";
         readonly tag = Message_Tags.Tool;
-        readonly inner: Readonly<{name: string; content: string}>;
-        constructor(inner: { name: string, content: string }) {
+        readonly inner: Readonly<{name: string; content: MessageContent}>;
+        constructor(inner: { name: string, content: MessageContent }) {
             super("Message", "Tool");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { name: string, content: string }): Tool_ {
+        static new(inner: { name: string, content: MessageContent }): Tool_ {
             return new Tool_(inner);
         }
 
@@ -1140,101 +1430,296 @@ export const Message = (() => {
 
     }
 
-    function instanceOf(obj: any): obj is Message {
-        return obj[uniffiTypeNameSymbol] === "Message";
+    function instanceOf(obj: any): obj is Message {
+        return obj[uniffiTypeNameSymbol] === "Message";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  User: User_, 
+  Assistant: Assistant_, 
+  System: System_, 
+  Tool: Tool_
+    });
+
+})();
+
+
+
+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.User({content: FfiConverterTypeMessageContent.read(from) });
+                case 2: return new Message.Assistant({content: FfiConverterTypeMessageContent.read(from), toolCalls: FfiConverterOptionalArrayTypeToolCall.read(from) });
+                case 3: return new Message.System({content: FfiConverterTypeMessageContent.read(from) });
+                case 4: return new Message.Tool({name: FfiConverterString.read(from), content: FfiConverterTypeMessageContent.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case Message_Tags.User: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterTypeMessageContent.write(inner.content, into);
+                    return;
+                }
+                case Message_Tags.Assistant: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterTypeMessageContent.write(inner.content, into);
+                    FfiConverterOptionalArrayTypeToolCall.write(inner.toolCalls, into);
+                    return;
+                }
+                case Message_Tags.System: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterTypeMessageContent.write(inner.content, into);
+                    return;
+                }
+                case Message_Tags.Tool: {
+                    ordinalConverter.write(4, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.name, into);
+                    FfiConverterTypeMessageContent.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.User: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterTypeMessageContent.allocationSize(inner.content);
+                    return size;
+                }
+                case Message_Tags.Assistant: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterTypeMessageContent.allocationSize(inner.content);
+                    size += FfiConverterOptionalArrayTypeToolCall.allocationSize(inner.toolCalls);
+                    return size;
+                }
+                case Message_Tags.System: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterTypeMessageContent.allocationSize(inner.content);
+                    return size;
+                }
+                case Message_Tags.Tool: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(4);
+                    size += FfiConverterString.allocationSize(inner.name);
+                    size += FfiConverterTypeMessageContent.allocationSize(inner.content);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+// Enum: MessageContent
+export enum MessageContent_Tags {
+    Text = "Text",
+    Parts = "Parts",
+    Json = "Json"
+}
+export const MessageContent = (() => {
+    
+
+    type Text__interface = {
+        tag: MessageContent_Tags.Text;
+        inner: Readonly<{text: string}>
+    };
+
+    
+    class Text_ extends UniffiEnum implements Text__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "MessageContent";
+        readonly tag = MessageContent_Tags.Text;
+        readonly inner: Readonly<{text: string}>;
+        constructor(inner: { text: string }) {
+            super("MessageContent", "Text");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { text: string }): Text_ {
+            return new Text_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Text_ {
+            return obj.tag === MessageContent_Tags.Text;
+        }
+        
+
+        
+
+    }
+    
+
+    type Parts__interface = {
+        tag: MessageContent_Tags.Parts;
+        inner: Readonly<{parts: Array<ContentPart>}>
+    };
+
+    
+    class Parts_ extends UniffiEnum implements Parts__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "MessageContent";
+        readonly tag = MessageContent_Tags.Parts;
+        readonly inner: Readonly<{parts: Array<ContentPart>}>;
+        constructor(inner: { parts: Array<ContentPart> }) {
+            super("MessageContent", "Parts");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { parts: Array<ContentPart> }): Parts_ {
+            return new Parts_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Parts_ {
+            return obj.tag === MessageContent_Tags.Parts;
+        }
+        
+
+        
+
+    }
+    
+
+    type Json__interface = {
+        tag: MessageContent_Tags.Json;
+        inner: Readonly<{json: string}>
+    };
+
+    
+    /**
+     * JSON-encoded. Chat templates written for structured content receive it
+     * as a real list or map rather than as a string.
+     */
+    class Json_ extends UniffiEnum implements Json__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "MessageContent";
+        readonly tag = MessageContent_Tags.Json;
+        readonly inner: Readonly<{json: string}>;
+        constructor(inner: { json: string }) {
+            super("MessageContent", "Json");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { json: string }): Json_ {
+            return new Json_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Json_ {
+            return obj.tag === MessageContent_Tags.Json;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is MessageContent {
+        return obj[uniffiTypeNameSymbol] === "MessageContent";
     }
 
     return Object.freeze({
         instanceOf,
-  User: User_, 
-  Assistant: Assistant_, 
-  System: System_, 
-  Tool: Tool_
+  Text: Text_, 
+  Parts: Parts_, 
+  Json: Json_
     });
 
 })();
 
 
 
-export type Message = InstanceType<
-    typeof Message[keyof Omit<typeof Message, 'instanceOf'>]
+export type MessageContent = InstanceType<
+    typeof MessageContent[keyof Omit<typeof MessageContent, 'instanceOf'>]
 >;
 
-// FfiConverter for enum Message
-const FfiConverterTypeMessage = (() => {
+// FfiConverter for enum MessageContent
+const FfiConverterTypeMessageContent = (() => {
     const ordinalConverter = FfiConverterInt32;
-    type TypeName = Message;
+    type TypeName = MessageContent;
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         read(from: RustBuffer): TypeName {
             switch (ordinalConverter.read(from)) {
-                case 1: return new Message.User({content: FfiConverterString.read(from), assets: FfiConverterArrayTypeAsset.read(from) });
-                case 2: return new Message.Assistant({content: FfiConverterString.read(from), toolCalls: FfiConverterOptionalArrayTypeToolCall.read(from) });
-                case 3: return new Message.System({content: FfiConverterString.read(from) });
-                case 4: return new Message.Tool({name: FfiConverterString.read(from), content: FfiConverterString.read(from) });
+                case 1: return new MessageContent.Text({text: FfiConverterString.read(from) });
+                case 2: return new MessageContent.Parts({parts: FfiConverterArrayTypeContentPart.read(from) });
+                case 3: return new MessageContent.Json({json: FfiConverterString.read(from) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value: TypeName, into: RustBuffer): void {
             switch (value.tag) {
-                case Message_Tags.User: {
+                case MessageContent_Tags.Text: {
                     ordinalConverter.write(1, into);
                     const inner = value.inner;
-                    FfiConverterString.write(inner.content, into);
-                    FfiConverterArrayTypeAsset.write(inner.assets, into);
+                    FfiConverterString.write(inner.text, into);
                     return;
                 }
-                case Message_Tags.Assistant: {
+                case MessageContent_Tags.Parts: {
                     ordinalConverter.write(2, into);
                     const inner = value.inner;
-                    FfiConverterString.write(inner.content, into);
-                    FfiConverterOptionalArrayTypeToolCall.write(inner.toolCalls, into);
+                    FfiConverterArrayTypeContentPart.write(inner.parts, into);
                     return;
                 }
-                case Message_Tags.System: {
+                case MessageContent_Tags.Json: {
                     ordinalConverter.write(3, into);
                     const inner = value.inner;
-                    FfiConverterString.write(inner.content, into);
-                    return;
-                }
-                case Message_Tags.Tool: {
-                    ordinalConverter.write(4, into);
-                    const inner = value.inner;
-                    FfiConverterString.write(inner.name, into);
-                    FfiConverterString.write(inner.content, into);
+                    FfiConverterString.write(inner.json, into);
                     return;
                 }
                 default:
-                    // Throwing from here means that Message_Tags hasn't matched an ordinal.
+                    // Throwing from here means that MessageContent_Tags hasn't matched an ordinal.
                     throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         allocationSize(value: TypeName): number {
             switch (value.tag) {
-                case Message_Tags.User: {
+                case MessageContent_Tags.Text: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(1);
-                    size += FfiConverterString.allocationSize(inner.content);
-                    size += FfiConverterArrayTypeAsset.allocationSize(inner.assets);
+                    size += FfiConverterString.allocationSize(inner.text);
                     return size;
                 }
-                case Message_Tags.Assistant: {
+                case MessageContent_Tags.Parts: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(2);
-                    size += FfiConverterString.allocationSize(inner.content);
-                    size += FfiConverterOptionalArrayTypeToolCall.allocationSize(inner.toolCalls);
+                    size += FfiConverterArrayTypeContentPart.allocationSize(inner.parts);
                     return size;
                 }
-                case Message_Tags.System: {
+                case MessageContent_Tags.Json: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(3);
-                    size += FfiConverterString.allocationSize(inner.content);
-                    return size;
-                }
-                case Message_Tags.Tool: {
-                    const inner = value.inner;
-                    let size = ordinalConverter.allocationSize(4);
-                    size += FfiConverterString.allocationSize(inner.name);
-                    size += FfiConverterString.allocationSize(inner.content);
+                    size += FfiConverterString.allocationSize(inner.json);
                     return size;
                 }
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -1319,76 +1804,45 @@ const FfiConverterTypeNobodyWhoError = (() => {
 })();
 
 
-// Enum: PromptPart
-export enum PromptPart_Tags {
-    Text = "Text",
-    Image = "Image",
-    Audio = "Audio"
+// Enum: ShiftTarget
+export enum ShiftTarget_Tags {
+    Fraction = "Fraction",
+    Tokens = "Tokens"
 }
 /**
- * A part of a multimodal prompt.  Mirrors the core `PromptPart` enum.
+ * Size a context shift shrinks the chat history to.
  */
-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;
-        }
-        
-
-        
-
-    }
+export const ShiftTarget = (() => {
     
 
-    type Image__interface = {
-        tag: PromptPart_Tags.Image;
-        inner: Readonly<{path: string}>
+    type Fraction__interface = {
+        tag: ShiftTarget_Tags.Fraction;
+        inner: Readonly<{fraction: /*f32*/number}>
     };
 
     
-    class Image_ extends UniffiEnum implements Image__interface {
+    /**
+     * A fraction of the context size, in `(0, 1)`.
+     */
+    class Fraction_ extends UniffiEnum implements Fraction__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");
+        readonly [uniffiTypeNameSymbol] = "ShiftTarget";
+        readonly tag = ShiftTarget_Tags.Fraction;
+        readonly inner: Readonly<{fraction: /*f32*/number}>;
+        constructor(inner: { fraction: /*f32*/number }) {
+            super("ShiftTarget", "Fraction");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { path: string }): Image_ {
-            return new Image_(inner);
+        static new(inner: { fraction: /*f32*/number }): Fraction_ {
+            return new Fraction_(inner);
         }
 
-        static instanceOf(obj: any): obj is Image_ {
-            return obj.tag === PromptPart_Tags.Image;
+        static instanceOf(obj: any): obj is Fraction_ {
+            return obj.tag === ShiftTarget_Tags.Fraction;
         }
         
 
@@ -1397,31 +1851,34 @@ export const PromptPart = (() => {
     }
     
 
-    type Audio__interface = {
-        tag: PromptPart_Tags.Audio;
-        inner: Readonly<{path: string}>
+    type Tokens__interface = {
+        tag: ShiftTarget_Tags.Tokens;
+        inner: Readonly<{tokens: /*u32*/number}>
     };
 
     
-    class Audio_ extends UniffiEnum implements Audio__interface {
+    /**
+     * A number of tokens, below the context size.
+     */
+    class Tokens_ extends UniffiEnum implements Tokens__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");
+        readonly [uniffiTypeNameSymbol] = "ShiftTarget";
+        readonly tag = ShiftTarget_Tags.Tokens;
+        readonly inner: Readonly<{tokens: /*u32*/number}>;
+        constructor(inner: { tokens: /*u32*/number }) {
+            super("ShiftTarget", "Tokens");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { path: string }): Audio_ {
-            return new Audio_(inner);
+        static new(inner: { tokens: /*u32*/number }): Tokens_ {
+            return new Tokens_(inner);
         }
 
-        static instanceOf(obj: any): obj is Audio_ {
-            return obj.tag === PromptPart_Tags.Audio;
+        static instanceOf(obj: any): obj is Tokens_ {
+            return obj.tag === ShiftTarget_Tags.Tokens;
         }
         
 
@@ -1429,84 +1886,70 @@ export const PromptPart = (() => {
 
     }
 
-    function instanceOf(obj: any): obj is PromptPart {
-        return obj[uniffiTypeNameSymbol] === "PromptPart";
+    function instanceOf(obj: any): obj is ShiftTarget {
+        return obj[uniffiTypeNameSymbol] === "ShiftTarget";
     }
 
     return Object.freeze({
         instanceOf,
-  Text: Text_, 
-  Image: Image_, 
-  Audio: Audio_
+  Fraction: Fraction_, 
+  Tokens: Tokens_
     });
 
 })();
 
 
 /**
- * A part of a multimodal prompt.  Mirrors the core `PromptPart` enum.
+ * Size a context shift shrinks the chat history to.
  */
 
-export type PromptPart = InstanceType<
-    typeof PromptPart[keyof Omit<typeof PromptPart, 'instanceOf'>]
+export type ShiftTarget = InstanceType<
+    typeof ShiftTarget[keyof Omit<typeof ShiftTarget, 'instanceOf'>]
 >;
 
-// FfiConverter for enum PromptPart
-const FfiConverterTypePromptPart = (() => {
+// FfiConverter for enum ShiftTarget
+const FfiConverterTypeShiftTarget = (() => {
     const ordinalConverter = FfiConverterInt32;
-    type TypeName = PromptPart;
+    type TypeName = ShiftTarget;
     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) });
+                case 1: return new ShiftTarget.Fraction({fraction: FfiConverterFloat32.read(from) });
+                case 2: return new ShiftTarget.Tokens({tokens: FfiConverterUInt32.read(from) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value: TypeName, into: RustBuffer): void {
             switch (value.tag) {
-                case PromptPart_Tags.Text: {
+                case ShiftTarget_Tags.Fraction: {
                     ordinalConverter.write(1, into);
                     const inner = value.inner;
-                    FfiConverterString.write(inner.content, into);
+                    FfiConverterFloat32.write(inner.fraction, into);
                     return;
                 }
-                case PromptPart_Tags.Image: {
+                case ShiftTarget_Tags.Tokens: {
                     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);
+                    FfiConverterUInt32.write(inner.tokens, into);
                     return;
                 }
                 default:
-                    // Throwing from here means that PromptPart_Tags hasn't matched an ordinal.
+                    // Throwing from here means that ShiftTarget_Tags hasn't matched an ordinal.
                     throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         allocationSize(value: TypeName): number {
             switch (value.tag) {
-                case PromptPart_Tags.Text: {
+                case ShiftTarget_Tags.Fraction: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(1);
-                    size += FfiConverterString.allocationSize(inner.content);
+                    size += FfiConverterFloat32.allocationSize(inner.fraction);
                     return size;
                 }
-                case PromptPart_Tags.Image: {
+                case ShiftTarget_Tags.Tokens: {
                     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);
+                    size += FfiConverterUInt32.allocationSize(inner.tokens);
                     return size;
                 }
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -1562,6 +2005,10 @@ const FfiConverterTypeVoiceActivityDetectionEvent = (() => {
 
 
 
+// FfiConverter for Map</*i32*/number, /*f32*/number>
+const FfiConverterMapInt32Float32 = new FfiConverterMap(FfiConverterInt32, FfiConverterFloat32);
+
+
 // FfiConverter for Map<string, boolean>
 const FfiConverterMapStringBool = new FfiConverterMap(FfiConverterString, FfiConverterBool);
 
@@ -1586,10 +2033,23 @@ export interface RustChatInterface {
     /**
      * Send a multimodal prompt (text + images/audio) and get a token stream.
      *
-     * `parts` is an ordered list of `PromptPart` items.
+     * `parts` is an ordered list of `ContentPart` items.
      * Image and audio parts should contain a local file-system path.
      */
-    askWithPrompt(parts: Array<PromptPart>) : RustTokenStreamInterface;
+    askWithPrompt(parts: Array<ContentPart>) : RustTokenStreamInterface;
+    /**
+     * Answer a full list of messages and get a token stream, replacing the chat
+     * history.
+     *
+     * The list is the whole conversation, used as given: it must be non-empty and
+     * end in a user or tool message. A leading system message sets the chat's system
+     * prompt; leave it out and the prompt already on the chat is kept. A later one
+     * stays in the history, for the chat template to render in place. The response
+     * is appended, and the next `ask` continues from there.
+     *
+     * `options` follows the same rule for the chat's other settings.
+     */
+    complete(messages: Array<Message>, options: Options)  /*throws*/: RustTokenStreamInterface;
     /**
      * Get the current chat history as a list of messages.
      */
@@ -1628,6 +2088,10 @@ export interface RustChatInterface {
      * Set the chat history from a list of messages.
      */
     setChatHistory(messages: Array<Message>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
+    /**
+     * Set how old turns are forgotten when the context is full.
+     */
+    setContextShift(options: ContextShiftOptions, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<void>;
     /**
      * Set the sampler configuration.
      */
@@ -1656,7 +2120,7 @@ export interface RustChatInterface {
      * Tokenize a multimodal prompt and return the token IDs.
      * Text tokens produce an integer ID; image/audio embedding slots produce null.
      */
-    tokenizeWithPrompt(parts: Array<PromptPart>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Array</*i32*/number | undefined>>;
+    tokenizeWithPrompt(parts: Array<ContentPart>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Array</*i32*/number | undefined>>;
 }
 
 
@@ -1677,8 +2141,11 @@ export class RustChat extends UniffiAbstractObject implements RustChatInterface
      * detects the device's physical core count (performance cores only, on
      * Apple silicon), since hyperthreads and efficiency cores make inference
      * slower. Clamped to the CPU count.
+     *
+     * `context_shift` sets how old turns are forgotten when the context is
+     * full; `null` uses the defaults.
      */
-    constructor(model: RustModelInterface, systemPrompt: string | undefined, contextSize: /*u32*/number, templateVariables: Map<string, boolean> | undefined, tools: Array<RustToolInterface> | undefined, sampler: SamplerConfigInterface | undefined, mtp: MtpConfig | undefined, threadCount: /*u32*/number | undefined) /*throws*/ {
+    constructor(model: RustModelInterface, systemPrompt: string | undefined, contextSize: /*u32*/number, templateVariables: Map<string, boolean> | undefined, tools: Array<RustToolInterface> | undefined, sampler: SamplerConfigInterface | undefined, mtp: MtpConfig | undefined, threadCount: /*u32*/number | undefined, contextShift: ContextShiftOptions | undefined) /*throws*/ {
         super();
         const pointer =
             
@@ -1694,6 +2161,7 @@ export class RustChat extends UniffiAbstractObject implements RustChatInterface
         FfiConverterOptionalTypeSamplerConfig.lower(sampler),
         FfiConverterOptionalTypeMtpConfig.lower(mtp),
         FfiConverterOptionalUInt32.lower(threadCount),
+        FfiConverterOptionalTypeContextShiftOptions.lower(contextShift),
                 callStatus);
             },
             /*liftString:*/ FfiConverterString.lift,
@@ -1741,14 +2209,40 @@ export class RustChat extends UniffiAbstractObject implements RustChatInterface
     /**
      * Send a multimodal prompt (text + images/audio) and get a token stream.
      *
-     * `parts` is an ordered list of `PromptPart` items.
+     * `parts` is an ordered list of `ContentPart` items.
      * Image and audio parts should contain a local file-system path.
      */
- askWithPrompt(parts: Array<PromptPart>): RustTokenStreamInterface {
+ askWithPrompt(parts: Array<ContentPart>): 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),
+        FfiConverterArrayTypeContentPart.lower(parts),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Answer a full list of messages and get a token stream, replacing the chat
+     * history.
+     *
+     * The list is the whole conversation, used as given: it must be non-empty and
+     * end in a user or tool message. A leading system message sets the chat's system
+     * prompt; leave it out and the prompt already on the chat is kept. A later one
+     * stays in the history, for the chat template to render in place. The response
+     * is appended, and the next `ask` continues from there.
+     *
+     * `options` follows the same rule for the chat's other settings.
+     */
+ complete(messages: Array<Message>, options: Options): RustTokenStreamInterface /*throws*/ {
+    return FfiConverterTypeRustTokenStream.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_complete(uniffiTypeRustChatObjectFactory.clonePointer(this), 
+        FfiConverterArrayTypeMessage.lower(messages),
+        FfiConverterTypeOptions.lower(options),
                 callStatus);
             },
             /*liftString:*/ FfiConverterString.lift,
@@ -2036,6 +2530,37 @@ async  setChatHistory(messages: Array<Message>, asyncOpts_?: { signal: AbortSign
     }
     }
     
+    /**
+     * Set how old turns are forgotten when the context is full.
+     */
+async  setContextShift(options: ContextShiftOptions, 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_context_shift(
+                    uniffiTypeRustChatObjectFactory.clonePointer(this),
+                    FfiConverterTypeContextShiftOptions.lower(options)
+                );
+            },
+            /*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.
      */
@@ -2206,7 +2731,7 @@ async  tokenize(message: string, asyncOpts_?: { signal: AbortSignal }): Promise<
      * Tokenize a multimodal prompt and return the token IDs.
      * Text tokens produce an integer ID; image/audio embedding slots produce null.
      */
-async  tokenizeWithPrompt(parts: Array<PromptPart>, asyncOpts_?: { signal: AbortSignal }): Promise<Array</*i32*/number | undefined>> /*throws*/ {
+async  tokenizeWithPrompt(parts: Array<ContentPart>, asyncOpts_?: { signal: AbortSignal }): Promise<Array</*i32*/number | undefined>> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
         return await uniffiRustCallAsync(
@@ -2214,7 +2739,7 @@ async  tokenizeWithPrompt(parts: Array<PromptPart>, asyncOpts_?: { signal: Abort
             /*rustFutureFunc:*/ () => {
                 return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustchat_tokenize_with_prompt(
                     uniffiTypeRustChatObjectFactory.clonePointer(this),
-                    FfiConverterArrayTypePromptPart.lower(parts)
+                    FfiConverterArrayTypeContentPart.lower(parts)
                 );
             },
             /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_rust_buffer,
@@ -2670,6 +3195,7 @@ const FfiConverterTypeRustEncoder =  new FfiConverterObject(uniffiTypeRustEncode
 export interface RustModelInterface {
     
     maxCtx() : /*u32*/number;
+    source() : string;
 }
 
 
@@ -2698,6 +3224,16 @@ private constructor(pointer: UniffiHandle) {
     ));
     }
     
+ source(): string {
+    return FfiConverterString.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustmodel_source(uniffiTypeRustModelObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
 
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
@@ -3859,6 +4395,18 @@ const FfiConverterTypeRustVoiceActivityDetection =  new FfiConverterObject(uniff
 
 export interface SamplerBuilderInterface {
     
+    /**
+     * Constrain output to a grammar, given as either Lark or GBNF.
+     */
+    constrainWithGrammar(grammar: string) : SamplerBuilderInterface;
+    /**
+     * Constrain output to a JSON schema, given as a JSON string.
+     */
+    constrainWithJsonSchema(schema: string) : SamplerBuilderInterface;
+    /**
+     * Constrain output to a regular expression.
+     */
+    constrainWithRegex(pattern: string) : SamplerBuilderInterface;
     /**
      * Sample from the probability distribution (weighted random selection).
      */
@@ -3868,13 +4416,34 @@ export interface SamplerBuilderInterface {
      */
     dry(multiplier: /*f32*/number, base: /*f32*/number, allowedLength: /*i32*/number, penaltyLastN: /*i32*/number, seqBreakers: Array<string>) : SamplerBuilderInterface;
     /**
-     * Deprecated: Use `sampler_preset_constrain_with_grammar()` instead. It accepts both Lark and GBNF strings.
+     * Apply dynamic temperature scaling (a.k.a. entropy) described in the paper
+     * <https://arxiv.org/abs/2309.02772>.
+     *
+     * Args:
+     * temperature: Temperature value (lower = more focused, higher = more random)
+     * delta: Dynamic temperature range. The final temperature will be in the range of `[temperature - delta; temperature + delta]`.
+     * exponent: Temperature is calculated as `entropy^exponent` (bounded by the range above)
      */
-    grammar(grammar: string, triggerOn: string | undefined, root: string) : SamplerBuilderInterface;
+    dynamicTemperature(temperature: /*f32*/number, delta: /*f32*/number, exponent: /*f32*/number) : SamplerBuilderInterface;
     /**
      * Always select the most probable token (deterministic).
      */
     greedy() : SamplerConfigInterface;
+    /**
+     * Constrain output to a JSON object of any shape. Use
+     * `constrain_with_json_schema()` to pin down the structure too.
+     */
+    json() : SamplerBuilderInterface;
+    /**
+     * Modify the likelihood of specific tokens.
+     *
+     * Args:
+     * biases: Mapping from token ID to its bias.
+     * The bias modifies the likelihood of the token being selected
+     * (`>0.0` means higher probability of the token being selected).
+     * Use `-Infinity` to ban a token.
+     */
+    logitBias(biases: Map</*i32*/number, /*f32*/number>) : SamplerBuilderInterface;
     /**
      * Keep tokens with probability above min_p * (probability of most likely token).
      */
@@ -3904,6 +4473,14 @@ export interface SamplerBuilderInterface {
      * Keep only the top K most probable tokens.
      */
     topK(topK: /*i32*/number) : SamplerBuilderInterface;
+    /**
+     * Top-nσ sampling as described in academic paper "Top-nσ: Not All Logits Are You Need"
+     * <https://arxiv.org/pdf/2411.07641>
+     *
+     * Args:
+     * n: Number of standard deviations from the mean to include in sampling.
+     */
+    topNSigma(n: /*f32*/number) : SamplerBuilderInterface;
     /**
      * Keep tokens whose cumulative probability is below top_p.
      */
@@ -3944,6 +4521,48 @@ export class SamplerBuilder extends UniffiAbstractObject implements SamplerBuild
     
 
     
+    /**
+     * Constrain output to a grammar, given as either Lark or GBNF.
+     */
+ constrainWithGrammar(grammar: string): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_constrain_with_grammar(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterString.lower(grammar),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Constrain output to a JSON schema, given as a JSON string.
+     */
+ constrainWithJsonSchema(schema: string): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_constrain_with_json_schema(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterString.lower(schema),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Constrain output to a regular expression.
+     */
+ constrainWithRegex(pattern: string): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_constrain_with_regex(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterString.lower(pattern),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
     /**
      * Sample from the probability distribution (weighted random selection).
      */
@@ -3976,15 +4595,21 @@ export class SamplerBuilder extends UniffiAbstractObject implements SamplerBuild
     }
     
     /**
-     * Deprecated: Use `sampler_preset_constrain_with_grammar()` instead. It accepts both Lark and GBNF strings.
+     * Apply dynamic temperature scaling (a.k.a. entropy) described in the paper
+     * <https://arxiv.org/abs/2309.02772>.
+     *
+     * Args:
+     * temperature: Temperature value (lower = more focused, higher = more random)
+     * delta: Dynamic temperature range. The final temperature will be in the range of `[temperature - delta; temperature + delta]`.
+     * exponent: Temperature is calculated as `entropy^exponent` (bounded by the range above)
      */
- grammar(grammar: string, triggerOn: string | undefined, root: string): SamplerBuilderInterface {
+ dynamicTemperature(temperature: /*f32*/number, delta: /*f32*/number, exponent: /*f32*/number): 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),
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_dynamic_temperature(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(temperature),
+        FfiConverterFloat32.lower(delta),
+        FfiConverterFloat32.lower(exponent),
                 callStatus);
             },
             /*liftString:*/ FfiConverterString.lift,
@@ -4004,6 +4629,40 @@ export class SamplerBuilder extends UniffiAbstractObject implements SamplerBuild
     ));
     }
     
+    /**
+     * Constrain output to a JSON object of any shape. Use
+     * `constrain_with_json_schema()` to pin down the structure too.
+     */
+ json(): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_json(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Modify the likelihood of specific tokens.
+     *
+     * Args:
+     * biases: Mapping from token ID to its bias.
+     * The bias modifies the likelihood of the token being selected
+     * (`>0.0` means higher probability of the token being selected).
+     * Use `-Infinity` to ban a token.
+     */
+ logitBias(biases: Map</*i32*/number, /*f32*/number>): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_logit_bias(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterMapInt32Float32.lower(biases),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
     /**
      * Keep tokens with probability above min_p * (probability of most likely token).
      */
@@ -4110,6 +4769,24 @@ export class SamplerBuilder extends UniffiAbstractObject implements SamplerBuild
     ));
     }
     
+    /**
+     * Top-nσ sampling as described in academic paper "Top-nσ: Not All Logits Are You Need"
+     * <https://arxiv.org/pdf/2411.07641>
+     *
+     * Args:
+     * n: Number of standard deviations from the mean to include in sampling.
+     */
+ topNSigma(n: /*f32*/number): SamplerBuilderInterface {
+    return FfiConverterTypeSamplerBuilder.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_samplerbuilder_top_n_sigma(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(n),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
     /**
      * Keep tokens whose cumulative probability is below top_p.
      */
@@ -4373,6 +5050,10 @@ const FfiConverterOptionalFloat32 = new FfiConverterOptional(FfiConverterFloat32
 const FfiConverterOptionalInt32 = new FfiConverterOptional(FfiConverterInt32);
 
 
+// FfiConverter for ContextShiftOptions | undefined
+const FfiConverterOptionalTypeContextShiftOptions = new FfiConverterOptional(FfiConverterTypeContextShiftOptions);
+
+
 // FfiConverter for MtpConfig | undefined
 const FfiConverterOptionalTypeMtpConfig = new FfiConverterOptional(FfiConverterTypeMtpConfig);
 
@@ -4397,10 +5078,6 @@ const FfiConverterArrayFloat32 = new FfiConverterArray(FfiConverterFloat32);
 const FfiConverterArrayInt16 = new FfiConverterArray(FfiConverterInt16);
 
 
-// FfiConverter for Array<Asset>
-const FfiConverterArrayTypeAsset = new FfiConverterArray(FfiConverterTypeAsset);
-
-
 // FfiConverter for Array<CachedModel>
 const FfiConverterArrayTypeCachedModel = new FfiConverterArray(FfiConverterTypeCachedModel);
 
@@ -4417,6 +5094,10 @@ const FfiConverterArrayTypeToolParameter = new FfiConverterArray(FfiConverterTyp
 const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
 
 
+// FfiConverter for ShiftTarget | undefined
+const FfiConverterOptionalTypeShiftTarget = new FfiConverterOptional(FfiConverterTypeShiftTarget);
+
+
 // FfiConverter for Map<string, boolean> | undefined
 const FfiConverterOptionalMapStringBool = new FfiConverterOptional(FfiConverterMapStringBool);
 
@@ -4433,12 +5114,12 @@ const FfiConverterOptionalTypeSamplerConfig = new FfiConverterOptional(FfiConver
 const FfiConverterOptionalArrayTypeToolCall = new FfiConverterOptional(FfiConverterArrayTypeToolCall);
 
 
-// FfiConverter for Array<Message>
-const FfiConverterArrayTypeMessage = new FfiConverterArray(FfiConverterTypeMessage);
+// FfiConverter for Array<ContentPart>
+const FfiConverterArrayTypeContentPart = new FfiConverterArray(FfiConverterTypeContentPart);
 
 
-// FfiConverter for Array<PromptPart>
-const FfiConverterArrayTypePromptPart = new FfiConverterArray(FfiConverterTypePromptPart);
+// FfiConverter for Array<Message>
+const FfiConverterArrayTypeMessage = new FfiConverterArray(FfiConverterTypeMessage);
 
 
 // FfiConverter for Array<RustToolInterface>
@@ -4514,22 +5195,19 @@ function uniffiEnsureInitialized() {
     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() !== 8103) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_json() !== 42303) {
         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) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_top_k() !== 56996) {
         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) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_top_p() !== 22588) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_top_p");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_ask() !== 53575) {
@@ -4538,9 +5216,12 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_ask_with_json_prompt() !== 63877) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_ask_with_json_prompt");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_ask_with_prompt() !== 65089) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_ask_with_prompt() !== 46807) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_ask_with_prompt");
     }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_complete() !== 24327) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_complete");
+    }
     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");
     }
@@ -4568,6 +5249,9 @@ function uniffiEnsureInitialized() {
     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_context_shift() !== 58540) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_set_context_shift");
+    }
     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");
     }
@@ -4586,7 +5270,7 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_tokenize() !== 52520) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_tokenize");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_tokenize_with_prompt() !== 60528) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustchat_tokenize_with_prompt() !== 15286) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustchat_tokenize_with_prompt");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustcrossencoder_rank() !== 55500) {
@@ -4604,6 +5288,9 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustmodel_max_ctx() !== 52004) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustmodel_max_ctx");
     }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustmodel_source() !== 39358) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustmodel_source");
+    }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustspeechtotext_transcribe_file() !== 59975) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustspeechtotext_transcribe_file");
     }
@@ -4646,18 +5333,33 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustvoiceactivitydetection_segment() !== 39967) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustvoiceactivitydetection_segment");
     }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_constrain_with_grammar() !== 36786) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_constrain_with_grammar");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_constrain_with_json_schema() !== 45268) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_constrain_with_json_schema");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_constrain_with_regex() !== 1166) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_constrain_with_regex");
+    }
     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() !== 3547) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_grammar");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dynamic_temperature() !== 5004) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dynamic_temperature");
     }
     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_json() !== 18949) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_json");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_logit_bias() !== 61844) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_logit_bias");
+    }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_min_p() !== 33705) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_min_p");
     }
@@ -4679,6 +5381,9 @@ function uniffiEnsureInitialized() {
     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_n_sigma() !== 44336) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_top_n_sigma");
+    }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_top_p() !== 54577) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_top_p");
     }
@@ -4691,7 +5396,7 @@ function uniffiEnsureInitialized() {
     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_rustchat_new() !== 2313) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rustchat_new() !== 4810) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rustchat_new");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rustcrossencoder_new() !== 9022) {
@@ -4735,14 +5440,16 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
-    FfiConverterTypeAsset,
     FfiConverterTypeCachedModel,
     FfiConverterTypeChatStats,
+    FfiConverterTypeContentPart,
+    FfiConverterTypeContextShiftOptions,
     FfiConverterTypeMessage,
+    FfiConverterTypeMessageContent,
     FfiConverterTypeMtpConfig,
     FfiConverterTypeNobodyWhoError,
+    FfiConverterTypeOptions,
     FfiConverterTypePendingToolCall,
-    FfiConverterTypePromptPart,
     FfiConverterTypeRustChat,
     FfiConverterTypeRustCrossEncoder,
     FfiConverterTypeRustEncoder,
@@ -4755,6 +5462,7 @@ export default Object.freeze({
     FfiConverterTypeRustVoiceActivityDetection,
     FfiConverterTypeSamplerBuilder,
     FfiConverterTypeSamplerConfig,
+    FfiConverterTypeShiftTarget,
     FfiConverterTypeToolCall,
     FfiConverterTypeToolParameter,
     FfiConverterTypeVoiceActivityDetectionEvent,