react-native-nobodywho 2.5.0 → 4.0.0

package/generated/ts/nobodywho.ts

@@ -186,22 +186,90 @@ export async function loadModel(modelPath: string, useGpu: boolean, projectionMo
     }
     }
 /**
- * Create a TTS synthesizer.
+ * Create an SpeechToText handle. `source` is a HuggingFace repo (`hf://owner/repo`,
+ * e.g. `"hf://onnx-community/whisper-base"`) or a local directory path.
+ * `language` is an ISO 639-1 code (e.g. `"en"`); pass `None` to auto-detect.
+ * `quantization` selects the ONNX precision variant to download and load:
+ * one of `"default"`, `"fp16"`, `"int8"`, `"uint8"`, `"bnb4"`, `"q4"`, `"q4f16"`, `"quantized"`;
+ * pass `None` to use `"default"`.
  */
-export async function loadTts(source: string, architecture: string | undefined, voice: string | undefined, language: string | undefined, speed: /*f32*/number | undefined, steps: /*u32*/number | undefined, silenceDuration: /*f32*/number | undefined, precision: string | undefined, temperature: /*f32*/number | undefined, huggingfaceToken: string | undefined, device: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustTtsInterface> /*throws*/ {
+export async function loadSpeechToText(source: string, language: string | undefined, quantization: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustSpeechToTextInterface> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
         return await uniffiRustCallAsync(
             /*rustCaller:*/ uniffiCaller,
             /*rustFutureFunc:*/ () => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_tts(FfiConverterString.lower(source),FfiConverterOptionalString.lower(architecture),FfiConverterOptionalString.lower(voice),FfiConverterOptionalString.lower(language),FfiConverterOptionalFloat32.lower(speed),FfiConverterOptionalUInt32.lower(steps),FfiConverterOptionalFloat32.lower(silenceDuration),FfiConverterOptionalString.lower(precision),FfiConverterOptionalFloat32.lower(temperature),FfiConverterOptionalString.lower(huggingfaceToken),FfiConverterOptionalString.lower(device)
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_speech_to_text(FfiConverterString.lower(source),FfiConverterOptionalString.lower(language),FfiConverterOptionalString.lower(quantization)
                 );
             },
             /*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:*/ FfiConverterTypeRustTts.lift.bind(FfiConverterTypeRustTts),
+            /*liftFunc:*/ FfiConverterTypeRustSpeechToText.lift.bind(FfiConverterTypeRustSpeechToText),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+/**
+ * Create a TextToSpeech synthesizer.
+ */
+export async function loadTextToSpeech(source: string, architecture: string | undefined, voice: string | undefined, language: string | undefined, speed: /*f32*/number | undefined, steps: /*u32*/number | undefined, silenceDuration: /*f32*/number | undefined, precision: string | undefined, temperature: /*f32*/number | undefined, huggingfaceToken: string | undefined, device: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustTextToSpeechInterface> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_text_to_speech(FfiConverterString.lower(source),FfiConverterOptionalString.lower(architecture),FfiConverterOptionalString.lower(voice),FfiConverterOptionalString.lower(language),FfiConverterOptionalFloat32.lower(speed),FfiConverterOptionalUInt32.lower(steps),FfiConverterOptionalFloat32.lower(silenceDuration),FfiConverterOptionalString.lower(precision),FfiConverterOptionalFloat32.lower(temperature),FfiConverterOptionalString.lower(huggingfaceToken),FfiConverterOptionalString.lower(device)
+                );
+            },
+            /*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:*/ FfiConverterTypeRustTextToSpeech.lift.bind(FfiConverterTypeRustTextToSpeech),
+            /*liftString:*/ FfiConverterString.lift,
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+/**
+ * Create a voice activity detector. `source` is a HuggingFace repo
+ * (`hf://owner/repo`) or local directory for the Silero VAD ONNX model;
+ * `None` uses the default (`hf://onnx-community/silero-vad`). `sample_rate`
+ * is the rate of the audio you'll pass to `push` — Silero runs at 16kHz
+ * internally, anything else is resampled. `threshold`,
+ * `min_silence_duration_ms`, `min_speech_duration_ms`, and
+ * `preroll_duration_ms` default to the core `VoiceActivityDetectionConfig`
+ * defaults when omitted.
+ */
+export async function loadVoiceActivityDetection(source: string | undefined, sampleRate: /*u32*/number, threshold: /*f32*/number | undefined, minSilenceDurationMs: /*u32*/number | undefined, minSpeechDurationMs: /*u32*/number | undefined, prerollDurationMs: /*u32*/number | undefined, device: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustVoiceActivityDetectionInterface> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_voice_activity_detection(FfiConverterOptionalString.lower(source),FfiConverterUInt32.lower(sampleRate),FfiConverterOptionalFloat32.lower(threshold),FfiConverterOptionalUInt32.lower(minSilenceDurationMs),FfiConverterOptionalUInt32.lower(minSpeechDurationMs),FfiConverterOptionalUInt32.lower(prerollDurationMs),FfiConverterOptionalString.lower(device)
+                );
+            },
+            /*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:*/ FfiConverterTypeRustVoiceActivityDetection.lift.bind(FfiConverterTypeRustVoiceActivityDetection),
             /*liftString:*/ FfiConverterString.lift,
             /*asyncOpts:*/ asyncOpts_,
             /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
@@ -487,64 +555,6 @@ const FfiConverterTypeRustToolCallback = new FfiConverterCallback<RustToolCallba
 
 
 
-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();
-})();
-
-
 /**
  * A cached `.gguf` model and its on-disk size.
  */
@@ -736,6 +746,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.
  */
@@ -931,6 +1014,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",
@@ -943,7 +1229,7 @@ export const Message = (() => {
 
     type User__interface = {
         tag: Message_Tags.User;
-        inner: Readonly<{content: string; assets: Array<Asset>}>
+        inner: Readonly<{content: MessageContent}>
     };
 
     
@@ -954,13 +1240,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);
         }
 
@@ -976,7 +1262,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}>
     };
 
     
@@ -987,13 +1273,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);
         }
 
@@ -1009,7 +1295,7 @@ export const Message = (() => {
 
     type System__interface = {
         tag: Message_Tags.System;
-        inner: Readonly<{content: string}>
+        inner: Readonly<{content: MessageContent}>
     };
 
     
@@ -1020,13 +1306,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);
         }
 
@@ -1042,7 +1328,7 @@ export const Message = (() => {
 
     type Tool__interface = {
         tag: Message_Tags.Tool;
-        inner: Readonly<{name: string; content: string}>
+        inner: Readonly<{name: string; content: MessageContent}>
     };
 
     
@@ -1053,13 +1339,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);
         }
 
@@ -1099,10 +1385,10 @@ const FfiConverterTypeMessage = (() => {
     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 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();
             }
         }
@@ -1111,28 +1397,27 @@ const FfiConverterTypeMessage = (() => {
                 case Message_Tags.User: {
                     ordinalConverter.write(1, into);
                     const inner = value.inner;
-                    FfiConverterString.write(inner.content, into);
-                    FfiConverterArrayTypeAsset.write(inner.assets, into);
+                    FfiConverterTypeMessageContent.write(inner.content, into);
                     return;
                 }
                 case Message_Tags.Assistant: {
                     ordinalConverter.write(2, into);
                     const inner = value.inner;
-                    FfiConverterString.write(inner.content, into);
+                    FfiConverterTypeMessageContent.write(inner.content, into);
                     FfiConverterOptionalArrayTypeToolCall.write(inner.toolCalls, into);
                     return;
                 }
                 case Message_Tags.System: {
                     ordinalConverter.write(3, into);
                     const inner = value.inner;
-                    FfiConverterString.write(inner.content, into);
+                    FfiConverterTypeMessageContent.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);
+                    FfiConverterTypeMessageContent.write(inner.content, into);
                     return;
                 }
                 default:
@@ -1145,28 +1430,27 @@ const FfiConverterTypeMessage = (() => {
                 case Message_Tags.User: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(1);
-                    size += FfiConverterString.allocationSize(inner.content);
-                    size += FfiConverterArrayTypeAsset.allocationSize(inner.assets);
+                    size += FfiConverterTypeMessageContent.allocationSize(inner.content);
                     return size;
                 }
                 case Message_Tags.Assistant: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(2);
-                    size += FfiConverterString.allocationSize(inner.content);
+                    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 += FfiConverterString.allocationSize(inner.content);
+                    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 += FfiConverterString.allocationSize(inner.content);
+                    size += FfiConverterTypeMessageContent.allocationSize(inner.content);
                     return size;
                 }
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -1178,94 +1462,18 @@ const FfiConverterTypeMessage = (() => {
 
 
 
-
-// Flat error type: NobodyWhoError
-export enum NobodyWhoError_Tags {
-    Error = "Error"
-}
-export const NobodyWhoError = (() => {
-    class Error extends UniffiError {
-        /**
-         * @private
-         * This field is private and should not be used.
-         */
-        readonly [uniffiTypeNameSymbol]: string = "NobodyWhoError";
-        /**
-         * @private
-         * This field is private and should not be used.
-         */
-        readonly [variantOrdinalSymbol] = 1;
-
-        readonly tag = NobodyWhoError_Tags.Error;
-
-        constructor(message: string) {
-            super("NobodyWhoError", "Error", message);
-        }
-
-        static instanceOf(e: any): e is Error {
-            return (
-                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 1
-            );
-        }
-    }
-
-    // Utility function which does not rely on instanceof.
-    function instanceOf(e: any): e is NobodyWhoError {
-        return (e as any)[uniffiTypeNameSymbol] === "NobodyWhoError";
-    }
-    return {
-        Error,
-        instanceOf,
-    };
-})();
-
-// Union type for NobodyWhoError error type.
-
-
-export type NobodyWhoError = InstanceType<
-    typeof NobodyWhoError[keyof Omit<typeof NobodyWhoError, 'instanceOf'>]
->;
-
-const FfiConverterTypeNobodyWhoError = (() => {
-    const intConverter = FfiConverterInt32;
-    type TypeName = NobodyWhoError;
-    class FfiConverter extends AbstractFfiConverterByteArray<TypeName> {
-        read(from: RustBuffer): TypeName {
-            switch (intConverter.read(from)) {
-                case 1: return new NobodyWhoError.Error(FfiConverterString.read(from)
-                );
-            
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
-        }
-        write(value: TypeName, into: RustBuffer): void {
-            const obj = value as any;
-            const index = obj[variantOrdinalSymbol] as number;
-            intConverter.write(index, into);
-        }
-        allocationSize(value: TypeName): number {
-            return intConverter.allocationSize(0);
-        }
-    }
-    return new FfiConverter();
-})();
-
-
-// Enum: PromptPart
-export enum PromptPart_Tags {
+// Enum: MessageContent
+export enum MessageContent_Tags {
     Text = "Text",
-    Image = "Image",
-    Audio = "Audio"
+    Parts = "Parts",
+    Json = "Json"
 }
-/**
- * A part of a multimodal prompt.  Mirrors the core `PromptPart` enum.
- */
-export const PromptPart = (() => {
+export const MessageContent = (() => {
     
 
     type Text__interface = {
-        tag: PromptPart_Tags.Text;
-        inner: Readonly<{content: string}>
+        tag: MessageContent_Tags.Text;
+        inner: Readonly<{text: string}>
     };
 
     
@@ -1274,20 +1482,20 @@ export const PromptPart = (() => {
          * @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");
+        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: { content: string }): Text_ {
+        static new(inner: { text: string }): Text_ {
             return new Text_(inner);
         }
 
         static instanceOf(obj: any): obj is Text_ {
-            return obj.tag === PromptPart_Tags.Text;
+            return obj.tag === MessageContent_Tags.Text;
         }
         
 
@@ -1296,31 +1504,31 @@ export const PromptPart = (() => {
     }
     
 
-    type Image__interface = {
-        tag: PromptPart_Tags.Image;
-        inner: Readonly<{path: string}>
+    type Parts__interface = {
+        tag: MessageContent_Tags.Parts;
+        inner: Readonly<{parts: Array<ContentPart>}>
     };
 
     
-    class Image_ extends UniffiEnum implements Image__interface {
+    class Parts_ extends UniffiEnum implements Parts__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] = "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: { path: string }): Image_ {
-            return new Image_(inner);
+        static new(inner: { parts: Array<ContentPart> }): Parts_ {
+            return new Parts_(inner);
         }
 
-        static instanceOf(obj: any): obj is Image_ {
-            return obj.tag === PromptPart_Tags.Image;
+        static instanceOf(obj: any): obj is Parts_ {
+            return obj.tag === MessageContent_Tags.Parts;
         }
         
 
@@ -1329,120 +1537,236 @@ export const PromptPart = (() => {
     }
     
 
-    type Audio__interface = {
-        tag: PromptPart_Tags.Audio;
-        inner: Readonly<{path: string}>
+    type Json__interface = {
+        tag: MessageContent_Tags.Json;
+        inner: Readonly<{json: string}>
     };
 
     
-    class Audio_ extends UniffiEnum implements Audio__interface {
+    /**
+     * 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] = "PromptPart";
-        readonly tag = PromptPart_Tags.Audio;
-        readonly inner: Readonly<{path: string}>;
-        constructor(inner: { path: string }) {
-            super("PromptPart", "Audio");
+        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: { path: string }): Audio_ {
-            return new Audio_(inner);
+        static new(inner: { json: string }): Json_ {
+            return new Json_(inner);
         }
 
-        static instanceOf(obj: any): obj is Audio_ {
-            return obj.tag === PromptPart_Tags.Audio;
+        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,
+  Text: Text_, 
+  Parts: Parts_, 
+  Json: Json_
+    });
+
+})();
+
+
+
+export type MessageContent = InstanceType<
+    typeof MessageContent[keyof Omit<typeof MessageContent, 'instanceOf'>]
+>;
+
+// FfiConverter for enum MessageContent
+const FfiConverterTypeMessageContent = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = MessageContent;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.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 MessageContent_Tags.Text: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.text, into);
+                    return;
+                }
+                case MessageContent_Tags.Parts: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterArrayTypeContentPart.write(inner.parts, into);
+                    return;
+                }
+                case MessageContent_Tags.Json: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.json, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that MessageContent_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case MessageContent_Tags.Text: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.text);
+                    return size;
+                }
+                case MessageContent_Tags.Parts: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterArrayTypeContentPart.allocationSize(inner.parts);
+                    return size;
+                }
+                case MessageContent_Tags.Json: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.json);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+// Flat error type: NobodyWhoError
+export enum NobodyWhoError_Tags {
+    Error = "Error"
+}
+export const NobodyWhoError = (() => {
+    class Error extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "NobodyWhoError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 1;
+
+        readonly tag = NobodyWhoError_Tags.Error;
+
+        constructor(message: string) {
+            super("NobodyWhoError", "Error", message);
         }
-        
-
-        
 
+        static instanceOf(e: any): e is Error {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 1
+            );
+        }
     }
 
-    function instanceOf(obj: any): obj is PromptPart {
-        return obj[uniffiTypeNameSymbol] === "PromptPart";
+    // Utility function which does not rely on instanceof.
+    function instanceOf(e: any): e is NobodyWhoError {
+        return (e as any)[uniffiTypeNameSymbol] === "NobodyWhoError";
     }
-
-    return Object.freeze({
+    return {
+        Error,
         instanceOf,
-  Text: Text_, 
-  Image: Image_, 
-  Audio: Audio_
-    });
+    };
+})();
+
+// Union type for NobodyWhoError error type.
+
 
+export type NobodyWhoError = InstanceType<
+    typeof NobodyWhoError[keyof Omit<typeof NobodyWhoError, 'instanceOf'>]
+>;
+
+const FfiConverterTypeNobodyWhoError = (() => {
+    const intConverter = FfiConverterInt32;
+    type TypeName = NobodyWhoError;
+    class FfiConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (intConverter.read(from)) {
+                case 1: return new NobodyWhoError.Error(FfiConverterString.read(from)
+                );
+            
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            const obj = value as any;
+            const index = obj[variantOrdinalSymbol] as number;
+            intConverter.write(index, into);
+        }
+        allocationSize(value: TypeName): number {
+            return intConverter.allocationSize(0);
+        }
+    }
+    return new FfiConverter();
 })();
 
 
 /**
- * A part of a multimodal prompt.  Mirrors the core `PromptPart` enum.
+ * `push` always returns one of these: `Speech`/`Silence` for the confirmed
+ * state when unchanged since the last call, or `SpeechStarted`/`SpeechEnded`
+ * on the call that confirmed the transition.
  */
+export enum VoiceActivityDetectionEvent {
+    Speech,
+    SpeechStarted,
+    SpeechEnded,
+    Silence
+}
 
-export type PromptPart = InstanceType<
-    typeof PromptPart[keyof Omit<typeof PromptPart, 'instanceOf'>]
->;
-
-// FfiConverter for enum PromptPart
-const FfiConverterTypePromptPart = (() => {
+const FfiConverterTypeVoiceActivityDetectionEvent = (() => {
     const ordinalConverter = FfiConverterInt32;
-    type TypeName = PromptPart;
+    type TypeName = VoiceActivityDetectionEvent;
     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 VoiceActivityDetectionEvent.Speech;
+                case 2: return VoiceActivityDetectionEvent.SpeechStarted;
+                case 3: return VoiceActivityDetectionEvent.SpeechEnded;
+                case 4: return VoiceActivityDetectionEvent.Silence;
                 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();
+            switch (value) {
+                case VoiceActivityDetectionEvent.Speech: return ordinalConverter.write(1, into);
+                case VoiceActivityDetectionEvent.SpeechStarted: return ordinalConverter.write(2, into);
+                case VoiceActivityDetectionEvent.SpeechEnded: return ordinalConverter.write(3, into);
+                case VoiceActivityDetectionEvent.Silence: return ordinalConverter.write(4, into);
             }
         }
         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 ordinalConverter.allocationSize(0);
         }
     }
     return new FFIConverter();
@@ -1450,6 +1774,12 @@ const FfiConverterTypePromptPart = (() => {
 
 
 
+
+
+// FfiConverter for Map</*i32*/number, /*f32*/number>
+const FfiConverterMapInt32Float32 = new FfiConverterMap(FfiConverterInt32, FfiConverterFloat32);
+
+
 // FfiConverter for Map<string, boolean>
 const FfiConverterMapStringBool = new FfiConverterMap(FfiConverterString, FfiConverterBool);
 
@@ -1474,10 +1804,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, end
+     * in a user or tool message, and carry a system message only first. That system
+     * message sets the chat's system prompt; leave it out and the prompt already on
+     * the chat is kept. 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.
      */
@@ -1544,7 +1887,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>>;
 }
 
 
@@ -1629,14 +1972,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, end
+     * in a user or tool message, and carry a system message only first. That system
+     * message sets the chat's system prompt; leave it out and the prompt already on
+     * the chat is kept. 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,
@@ -2094,7 +2463,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(
@@ -2102,7 +2471,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,
@@ -2384,6 +2753,10 @@ export interface RustEncoderInterface {
      * Encode text into an embedding vector.
      */
     encode(text: string, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Array</*f32*/number>>;
+    /**
+     * Encode multiple texts into embedding vectors, preserving input order.
+     */
+    encodeBatch(texts: Array<string>, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<Array<Array</*f32*/number>>>;
 }
 
 
@@ -2445,6 +2818,37 @@ async  encode(text: string, asyncOpts_?: { signal: AbortSignal }): Promise<Array
     }
     }
     
+    /**
+     * Encode multiple texts into embedding vectors, preserving input order.
+     */
+async  encodeBatch(texts: Array<string>, asyncOpts_?: { signal: AbortSignal }): Promise<Array<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_rustencoder_encode_batch(
+                    uniffiTypeRustEncoderObjectFactory.clonePointer(this),
+                    FfiConverterArrayString.lower(texts)
+                );
+            },
+            /*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:*/ FfiConverterArrayArrayFloat32.lift.bind(FfiConverterArrayArrayFloat32),
+            /*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}
@@ -2627,35 +3031,35 @@ const FfiConverterTypeRustModel =  new FfiConverterObject(uniffiTypeRustModelObj
 
 
 /**
- * Speech-to-text handle. Wraps `nobodywho::stt::Stt`.
- * Use `transcribe_file` or `transcribe_pcm` to get a `RustSTTStream`.
+ * Speech-to-text handle. Wraps `nobodywho::speech_to_text::SpeechToText`.
+ * Use `transcribe_file` or `transcribe_pcm` to get a `RustSpeechToTextStream`.
  */
-export interface RustSttInterface {
+export interface RustSpeechToTextInterface {
     
     /**
      * Start transcribing an audio file (WAV / MP3).
-     * Returns a `RustSTTStream` to consume tokens as they are generated.
+     * Returns a `RustSpeechToTextStream` to consume tokens as they are generated.
      */
-    transcribeFile(path: string)  /*throws*/: RustSttStreamInterface;
+    transcribeFile(path: string)  /*throws*/: RustSpeechToTextStreamInterface;
     /**
      * Start transcribing raw i16 PCM samples (e.g. from a microphone stream).
      * `sample_rate` is the capture rate in Hz; the backend resamples to 16 kHz internally.
      */
-    transcribePcm(samples: Array</*i16*/number>, sampleRate: /*u32*/number)  /*throws*/: RustSttStreamInterface;
+    transcribePcm(samples: Array</*i16*/number>, sampleRate: /*u32*/number)  /*throws*/: RustSpeechToTextStreamInterface;
 }
 
 
 /**
- * Speech-to-text handle. Wraps `nobodywho::stt::Stt`.
- * Use `transcribe_file` or `transcribe_pcm` to get a `RustSTTStream`.
+ * Speech-to-text handle. Wraps `nobodywho::speech_to_text::SpeechToText`.
+ * Use `transcribe_file` or `transcribe_pcm` to get a `RustSpeechToTextStream`.
  */
-export class RustStt extends UniffiAbstractObject implements RustSttInterface {
+export class RustSpeechToText extends UniffiAbstractObject implements RustSpeechToTextInterface {
 
-    readonly [uniffiTypeNameSymbol] = "RustStt";
+    readonly [uniffiTypeNameSymbol] = "RustSpeechToText";
     readonly [destructorGuardSymbol]: UniffiGcObject;
     readonly [pointerLiteralSymbol]: UniffiHandle;
     /**
-     * Create an STT handle. `source` is a HuggingFace repo (`hf://owner/repo`,
+     * Create an SpeechToText handle. `source` is a HuggingFace repo (`hf://owner/repo`,
      * e.g. `"hf://onnx-community/whisper-base"`) or a local directory path.
      * `language` is an ISO 639-1 code (e.g. `"en"`); pass `None` to auto-detect.
      * `quantization` selects the ONNX precision variant to download and load:
@@ -2669,7 +3073,7 @@ export class RustStt extends UniffiAbstractObject implements RustSttInterface {
         uniffiCaller.rustCallWithError(
             /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
             /*caller:*/ (callStatus) => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_ruststt_new(
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_rustspeechtotext_new(
         FfiConverterString.lower(source),
         FfiConverterOptionalString.lower(language),
         FfiConverterOptionalString.lower(quantization),
@@ -2678,7 +3082,7 @@ export class RustStt extends UniffiAbstractObject implements RustSttInterface {
             /*liftString:*/ FfiConverterString.lift,
     );
         this[pointerLiteralSymbol] = pointer;
-        this[destructorGuardSymbol] = uniffiTypeRustSttObjectFactory.bless(pointer);
+        this[destructorGuardSymbol] = uniffiTypeRustSpeechToTextObjectFactory.bless(pointer);
     }
 
     
@@ -2686,37 +3090,208 @@ export class RustStt extends UniffiAbstractObject implements RustSttInterface {
     
     /**
      * Start transcribing an audio file (WAV / MP3).
-     * Returns a `RustSTTStream` to consume tokens as they are generated.
+     * Returns a `RustSpeechToTextStream` to consume tokens as they are generated.
      */
- transcribeFile(path: string): RustSttStreamInterface /*throws*/ {
-    return FfiConverterTypeRustSTTStream.lift(
+ transcribeFile(path: string): RustSpeechToTextStreamInterface /*throws*/ {
+    return FfiConverterTypeRustSpeechToTextStream.lift(
         uniffiCaller.rustCallWithError(
             /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
             /*caller:*/ (callStatus) => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_ruststt_transcribe_file(uniffiTypeRustSttObjectFactory.clonePointer(this), 
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustspeechtotext_transcribe_file(uniffiTypeRustSpeechToTextObjectFactory.clonePointer(this), 
         FfiConverterString.lower(path),
                 callStatus);
             },
             /*liftString:*/ FfiConverterString.lift,
-    ));
+    ));
+    }
+    
+    /**
+     * Start transcribing raw i16 PCM samples (e.g. from a microphone stream).
+     * `sample_rate` is the capture rate in Hz; the backend resamples to 16 kHz internally.
+     */
+ transcribePcm(samples: Array</*i16*/number>, sampleRate: /*u32*/number): RustSpeechToTextStreamInterface /*throws*/ {
+    return FfiConverterTypeRustSpeechToTextStream.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustspeechtotext_transcribe_pcm(uniffiTypeRustSpeechToTextObjectFactory.clonePointer(this), 
+        FfiConverterArrayInt16.lower(samples),
+        FfiConverterUInt32.lower(sampleRate),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeRustSpeechToTextObjectFactory.pointer(this);
+            uniffiTypeRustSpeechToTextObjectFactory.freePointer(pointer);
+            uniffiTypeRustSpeechToTextObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj: any): obj is RustSpeechToText {
+        return uniffiTypeRustSpeechToTextObjectFactory.isConcreteType(obj);
+    }
+
+    
+}
+
+const uniffiTypeRustSpeechToTextObjectFactory: UniffiObjectFactory<RustSpeechToTextInterface> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): RustSpeechToTextInterface {
+        const instance = Object.create(RustSpeechToText.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "RustSpeechToText";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_rustspeechtotext_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+    },
+
+    pointer(obj: RustSpeechToTextInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: RustSpeechToTextInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rustspeechtotext(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rustspeechtotext(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj: any): obj is RustSpeechToTextInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustSpeechToText";
+    },
+}})();
+// FfiConverter for RustSpeechToTextInterface
+const FfiConverterTypeRustSpeechToText =  new FfiConverterObject(uniffiTypeRustSpeechToTextObjectFactory);
+
+
+/**
+ * A stream of transcript tokens from a Whisper SpeechToText run.
+ */
+export interface RustSpeechToTextStreamInterface {
+    
+    /**
+     * Wait for transcription to finish and return the full transcript.
+     */
+    completed(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string>;
+    /**
+     * Get the next transcript token. Returns `None` when transcription is complete.
+     */
+    nextToken(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string | undefined>;
+}
+
+
+/**
+ * A stream of transcript tokens from a Whisper SpeechToText run.
+ */
+export class RustSpeechToTextStream extends UniffiAbstractObject implements RustSpeechToTextStreamInterface {
+
+    readonly [uniffiTypeNameSymbol] = "RustSpeechToTextStream";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeRustSpeechToTextStreamObjectFactory.bless(pointer);
+}
+
+    
+
+    
+    /**
+     * Wait for transcription to finish and return the full transcript.
+     */
+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_rustspeechtotextstream_completed(
+                    uniffiTypeRustSpeechToTextStreamObjectFactory.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;
+    }
     }
     
     /**
-     * Start transcribing raw i16 PCM samples (e.g. from a microphone stream).
-     * `sample_rate` is the capture rate in Hz; the backend resamples to 16 kHz internally.
+     * Get the next transcript token. Returns `None` when transcription is complete.
      */
- transcribePcm(samples: Array</*i16*/number>, sampleRate: /*u32*/number): RustSttStreamInterface /*throws*/ {
-    return FfiConverterTypeRustSTTStream.lift(
-        uniffiCaller.rustCallWithError(
-            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
-            /*caller:*/ (callStatus) => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_ruststt_transcribe_pcm(uniffiTypeRustSttObjectFactory.clonePointer(this), 
-        FfiConverterArrayInt16.lower(samples),
-        FfiConverterUInt32.lower(sampleRate),
-                callStatus);
+async  nextToken(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_rustspeechtotextstream_next_token(
+                    uniffiTypeRustSpeechToTextStreamObjectFactory.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;
+    }
     }
     
 
@@ -2726,28 +3301,28 @@ export class RustStt extends UniffiAbstractObject implements RustSttInterface {
     uniffiDestroy(): void {
         const ptr = (this as any)[destructorGuardSymbol];
         if (ptr !== undefined) {
-            const pointer = uniffiTypeRustSttObjectFactory.pointer(this);
-            uniffiTypeRustSttObjectFactory.freePointer(pointer);
-            uniffiTypeRustSttObjectFactory.unbless(ptr);
+            const pointer = uniffiTypeRustSpeechToTextStreamObjectFactory.pointer(this);
+            uniffiTypeRustSpeechToTextStreamObjectFactory.freePointer(pointer);
+            uniffiTypeRustSpeechToTextStreamObjectFactory.unbless(ptr);
             delete (this as any)[destructorGuardSymbol];
         }
     }
 
-    static instanceOf(obj: any): obj is RustStt {
-        return uniffiTypeRustSttObjectFactory.isConcreteType(obj);
+    static instanceOf(obj: any): obj is RustSpeechToTextStream {
+        return uniffiTypeRustSpeechToTextStreamObjectFactory.isConcreteType(obj);
     }
 
     
 }
 
-const uniffiTypeRustSttObjectFactory: UniffiObjectFactory<RustSttInterface> = (() => {
+const uniffiTypeRustSpeechToTextStreamObjectFactory: UniffiObjectFactory<RustSpeechToTextStreamInterface> = (() => {
     
     return {
-    create(pointer: UniffiHandle): RustSttInterface {
-        const instance = Object.create(RustStt.prototype);
+    create(pointer: UniffiHandle): RustSpeechToTextStreamInterface {
+        const instance = Object.create(RustSpeechToTextStream.prototype);
         instance[pointerLiteralSymbol] = pointer;
         instance[destructorGuardSymbol] = this.bless(pointer);
-        instance[uniffiTypeNameSymbol] = "RustStt";
+        instance[uniffiTypeNameSymbol] = "RustSpeechToTextStream";
         return instance;
     },
 
@@ -2755,7 +3330,7 @@ const uniffiTypeRustSttObjectFactory: UniffiObjectFactory<RustSttInterface> = ((
     bless(p: UniffiHandle): UniffiGcObject {
         return uniffiCaller.rustCall(
             /*caller:*/ (status) =>
-                nativeModule().ubrn_uniffi_internal_fn_method_ruststt_ffi__bless_pointer(p, status),
+                nativeModule().ubrn_uniffi_internal_fn_method_rustspeechtotextstream_ffi__bless_pointer(p, status),
             /*liftString:*/ FfiConverterString.lift
         );
     },
@@ -2764,120 +3339,122 @@ const uniffiTypeRustSttObjectFactory: UniffiObjectFactory<RustSttInterface> = ((
         ptr.markDestroyed();
     },
 
-    pointer(obj: RustSttInterface): UniffiHandle {
+    pointer(obj: RustSpeechToTextStreamInterface): UniffiHandle {
         if ((obj as any)[destructorGuardSymbol] === undefined) {
             throw new UniffiInternalError.UnexpectedNullPointer();
         }
         return (obj as any)[pointerLiteralSymbol];
     },
 
-    clonePointer(obj: RustSttInterface): UniffiHandle {
+    clonePointer(obj: RustSpeechToTextStreamInterface): UniffiHandle {
         const pointer = this.pointer(obj);
         return uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_ruststt(pointer, callStatus),
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rustspeechtotextstream(pointer, callStatus),
             /*liftString:*/ FfiConverterString.lift
         );
     },
 
     freePointer(pointer: UniffiHandle): void {
         uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_ruststt(pointer, callStatus),
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rustspeechtotextstream(pointer, callStatus),
             /*liftString:*/ FfiConverterString.lift
         );
     },
 
-    isConcreteType(obj: any): obj is RustSttInterface {
-        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustStt";
+    isConcreteType(obj: any): obj is RustSpeechToTextStreamInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustSpeechToTextStream";
     },
 }})();
-// FfiConverter for RustSttInterface
-const FfiConverterTypeRustSTT =  new FfiConverterObject(uniffiTypeRustSttObjectFactory);
+// FfiConverter for RustSpeechToTextStreamInterface
+const FfiConverterTypeRustSpeechToTextStream =  new FfiConverterObject(uniffiTypeRustSpeechToTextStreamObjectFactory);
 
 
-/**
- * A stream of transcript tokens from a Whisper STT run.
- */
-export interface RustSttStreamInterface {
+export interface RustTextToSpeechInterface {
     
     /**
-     * Wait for transcription to finish and return the full transcript.
+     * Synthesize text and return WAV bytes.
      */
-    completed(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string>;
+    synthesize(text: string)  /*throws*/: ArrayBuffer;
     /**
-     * Get the next transcript token. Returns `None` when transcription is complete.
+     * Synthesize text asynchronously and return WAV bytes.
      */
-    nextToken(asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<string | undefined>;
+    synthesizeAsync(text: string, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<ArrayBuffer>;
 }
 
 
-/**
- * A stream of transcript tokens from a Whisper STT run.
- */
-export class RustSttStream extends UniffiAbstractObject implements RustSttStreamInterface {
+export class RustTextToSpeech extends UniffiAbstractObject implements RustTextToSpeechInterface {
 
-    readonly [uniffiTypeNameSymbol] = "RustSttStream";
+    readonly [uniffiTypeNameSymbol] = "RustTextToSpeech";
     readonly [destructorGuardSymbol]: UniffiGcObject;
     readonly [pointerLiteralSymbol]: UniffiHandle;
-    // No primary constructor declared for this class.
-private constructor(pointer: UniffiHandle) {
-    super();
-    this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] = uniffiTypeRustSttStreamObjectFactory.bless(pointer);
-}
+    /**
+     * Create a TextToSpeech synthesizer.
+     */
+    constructor(source: string, architecture: string | undefined, voice: string | undefined, language: string | undefined, speed: /*f32*/number | undefined, steps: /*u32*/number | undefined, silenceDuration: /*f32*/number | undefined, precision: string | undefined, temperature: /*f32*/number | undefined, huggingfaceToken: string | undefined, device: string | undefined) /*throws*/ {
+        super();
+        const pointer =
+            
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_rusttexttospeech_new(
+        FfiConverterString.lower(source),
+        FfiConverterOptionalString.lower(architecture),
+        FfiConverterOptionalString.lower(voice),
+        FfiConverterOptionalString.lower(language),
+        FfiConverterOptionalFloat32.lower(speed),
+        FfiConverterOptionalUInt32.lower(steps),
+        FfiConverterOptionalFloat32.lower(silenceDuration),
+        FfiConverterOptionalString.lower(precision),
+        FfiConverterOptionalFloat32.lower(temperature),
+        FfiConverterOptionalString.lower(huggingfaceToken),
+        FfiConverterOptionalString.lower(device),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    );
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeRustTextToSpeechObjectFactory.bless(pointer);
+    }
 
     
 
     
     /**
-     * Wait for transcription to finish and return the full transcript.
+     * Synthesize text and return WAV bytes.
      */
-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_ruststtstream_completed(
-                    uniffiTypeRustSttStreamObjectFactory.clonePointer(this)
-                    
-                );
+ synthesize(text: string): ArrayBuffer /*throws*/ {
+    return FfiConverterArrayBuffer.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rusttexttospeech_synthesize(uniffiTypeRustTextToSpeechObjectFactory.clonePointer(this), 
+        FfiConverterString.lower(text),
+                callStatus);
             },
-            /*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 transcript token. Returns `None` when transcription is complete.
+     * Synthesize text asynchronously and return WAV bytes.
      */
-async  nextToken(asyncOpts_?: { signal: AbortSignal }): Promise<string | undefined> /*throws*/ {
+async  synthesizeAsync(text: string, asyncOpts_?: { signal: AbortSignal }): Promise<ArrayBuffer> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
         return await uniffiRustCallAsync(
             /*rustCaller:*/ uniffiCaller,
             /*rustFutureFunc:*/ () => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_ruststtstream_next_token(
-                    uniffiTypeRustSttStreamObjectFactory.clonePointer(this)
-                    
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rusttexttospeech_synthesize_async(
+                    uniffiTypeRustTextToSpeechObjectFactory.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:*/ FfiConverterOptionalString.lift.bind(FfiConverterOptionalString),
+            /*liftFunc:*/ FfiConverterArrayBuffer.lift.bind(FfiConverterArrayBuffer),
             /*liftString:*/ FfiConverterString.lift,
             /*asyncOpts:*/ asyncOpts_,
             /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
@@ -2897,28 +3474,28 @@ async  nextToken(asyncOpts_?: { signal: AbortSignal }): Promise<string | undefin
     uniffiDestroy(): void {
         const ptr = (this as any)[destructorGuardSymbol];
         if (ptr !== undefined) {
-            const pointer = uniffiTypeRustSttStreamObjectFactory.pointer(this);
-            uniffiTypeRustSttStreamObjectFactory.freePointer(pointer);
-            uniffiTypeRustSttStreamObjectFactory.unbless(ptr);
+            const pointer = uniffiTypeRustTextToSpeechObjectFactory.pointer(this);
+            uniffiTypeRustTextToSpeechObjectFactory.freePointer(pointer);
+            uniffiTypeRustTextToSpeechObjectFactory.unbless(ptr);
             delete (this as any)[destructorGuardSymbol];
         }
     }
 
-    static instanceOf(obj: any): obj is RustSttStream {
-        return uniffiTypeRustSttStreamObjectFactory.isConcreteType(obj);
+    static instanceOf(obj: any): obj is RustTextToSpeech {
+        return uniffiTypeRustTextToSpeechObjectFactory.isConcreteType(obj);
     }
 
     
 }
 
-const uniffiTypeRustSttStreamObjectFactory: UniffiObjectFactory<RustSttStreamInterface> = (() => {
+const uniffiTypeRustTextToSpeechObjectFactory: UniffiObjectFactory<RustTextToSpeechInterface> = (() => {
     
     return {
-    create(pointer: UniffiHandle): RustSttStreamInterface {
-        const instance = Object.create(RustSttStream.prototype);
+    create(pointer: UniffiHandle): RustTextToSpeechInterface {
+        const instance = Object.create(RustTextToSpeech.prototype);
         instance[pointerLiteralSymbol] = pointer;
         instance[destructorGuardSymbol] = this.bless(pointer);
-        instance[uniffiTypeNameSymbol] = "RustSttStream";
+        instance[uniffiTypeNameSymbol] = "RustTextToSpeech";
         return instance;
     },
 
@@ -2926,7 +3503,7 @@ const uniffiTypeRustSttStreamObjectFactory: UniffiObjectFactory<RustSttStreamInt
     bless(p: UniffiHandle): UniffiGcObject {
         return uniffiCaller.rustCall(
             /*caller:*/ (status) =>
-                nativeModule().ubrn_uniffi_internal_fn_method_ruststtstream_ffi__bless_pointer(p, status),
+                nativeModule().ubrn_uniffi_internal_fn_method_rusttexttospeech_ffi__bless_pointer(p, status),
             /*liftString:*/ FfiConverterString.lift
         );
     },
@@ -2935,34 +3512,34 @@ const uniffiTypeRustSttStreamObjectFactory: UniffiObjectFactory<RustSttStreamInt
         ptr.markDestroyed();
     },
 
-    pointer(obj: RustSttStreamInterface): UniffiHandle {
+    pointer(obj: RustTextToSpeechInterface): UniffiHandle {
         if ((obj as any)[destructorGuardSymbol] === undefined) {
             throw new UniffiInternalError.UnexpectedNullPointer();
         }
         return (obj as any)[pointerLiteralSymbol];
     },
 
-    clonePointer(obj: RustSttStreamInterface): UniffiHandle {
+    clonePointer(obj: RustTextToSpeechInterface): UniffiHandle {
         const pointer = this.pointer(obj);
         return uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_ruststtstream(pointer, callStatus),
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rusttexttospeech(pointer, callStatus),
             /*liftString:*/ FfiConverterString.lift
         );
     },
 
     freePointer(pointer: UniffiHandle): void {
         uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_ruststtstream(pointer, callStatus),
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rusttexttospeech(pointer, callStatus),
             /*liftString:*/ FfiConverterString.lift
         );
     },
 
-    isConcreteType(obj: any): obj is RustSttStreamInterface {
-        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustSttStream";
+    isConcreteType(obj: any): obj is RustTextToSpeechInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustTextToSpeech";
     },
 }})();
-// FfiConverter for RustSttStreamInterface
-const FfiConverterTypeRustSTTStream =  new FfiConverterObject(uniffiTypeRustSttStreamObjectFactory);
+// FfiConverter for RustTextToSpeechInterface
+const FfiConverterTypeRustTextToSpeech =  new FfiConverterObject(uniffiTypeRustTextToSpeechObjectFactory);
 
 
 export interface RustTokenStreamInterface {
@@ -3328,67 +3905,115 @@ const uniffiTypeRustToolObjectFactory: UniffiObjectFactory<RustToolInterface> =
 const FfiConverterTypeRustTool =  new FfiConverterObject(uniffiTypeRustToolObjectFactory);
 
 
-export interface RustTtsInterface {
+/**
+ * Voice activity detector. Wraps `nobodywho::voice_activity_detection::VoiceActivityDetection`.
+ * Feed audio chunks via `push`; once `push` returns `SpeechEnded`, call
+ * `finish` to get that turn's captured audio (with pre-roll) and reset.
+ */
+export interface RustVoiceActivityDetectionInterface {
     
     /**
-     * Synthesize text and return WAV bytes.
+     * Return the current turn's captured audio (from the confirmed
+     * `SpeechStarted`, including a small pre-roll, through to
+     * `SpeechEnded`) and reset internal state for the next turn. Empty if
+     * speech was never confirmed.
      */
-    synthesize(text: string)  /*throws*/: ArrayBuffer;
+    finish() : Array</*i16*/number>;
     /**
-     * Synthesize text asynchronously and return WAV bytes.
+     * Feed the newest chunk of i16 PCM audio (not the whole accumulated
+     * buffer — the detector tracks the current turn internally). Always
+     * returns the current confirmed state: `Speech`/`Silence` if unchanged
+     * since the last call, or `SpeechStarted`/`SpeechEnded` on the call that
+     * confirmed the transition.
      */
-    synthesizeAsync(text: string, asyncOpts_?: { signal: AbortSignal })  /*throws*/: Promise<ArrayBuffer>;
+    push(chunk: Array</*i16*/number>)  /*throws*/: VoiceActivityDetectionEvent;
+    /**
+     * Detect every speech segment in a complete audio buffer, returning
+     * each segment's audio (with a short pre-roll) in order. Unlike `push`,
+     * correctly finds every segment regardless of buffer size — use this
+     * for offline/batch processing instead of live streaming.
+     */
+    segment(samples: Array</*i16*/number>)  /*throws*/: Array<Array</*i16*/number>>;
 }
 
 
-export class RustTts extends UniffiAbstractObject implements RustTtsInterface {
+/**
+ * Voice activity detector. Wraps `nobodywho::voice_activity_detection::VoiceActivityDetection`.
+ * Feed audio chunks via `push`; once `push` returns `SpeechEnded`, call
+ * `finish` to get that turn's captured audio (with pre-roll) and reset.
+ */
+export class RustVoiceActivityDetection extends UniffiAbstractObject implements RustVoiceActivityDetectionInterface {
 
-    readonly [uniffiTypeNameSymbol] = "RustTts";
+    readonly [uniffiTypeNameSymbol] = "RustVoiceActivityDetection";
     readonly [destructorGuardSymbol]: UniffiGcObject;
     readonly [pointerLiteralSymbol]: UniffiHandle;
     /**
-     * Create a TTS synthesizer.
+     * Create a voice activity detector.
+     *
+     * `source` is a HuggingFace repo (`hf://owner/repo`) or local directory
+     * for the Silero VAD ONNX model; `None` uses the default
+     * (`hf://onnx-community/silero-vad`). `sample_rate` is the rate of the
+     * audio you'll pass to `push` — Silero runs at 16kHz internally,
+     * anything else is resampled. `threshold`, `min_silence_duration_ms`,
+     * `min_speech_duration_ms`, and `preroll_duration_ms` default to the
+     * core `VoiceActivityDetectionConfig` defaults when omitted.
      */
-    constructor(source: string, architecture: string | undefined, voice: string | undefined, language: string | undefined, speed: /*f32*/number | undefined, steps: /*u32*/number | undefined, silenceDuration: /*f32*/number | undefined, precision: string | undefined, temperature: /*f32*/number | undefined, huggingfaceToken: string | undefined, device: string | undefined) /*throws*/ {
+    constructor(source: string | undefined, sampleRate: /*u32*/number, threshold: /*f32*/number | undefined, minSilenceDurationMs: /*u32*/number | undefined, minSpeechDurationMs: /*u32*/number | undefined, prerollDurationMs: /*u32*/number | undefined, device: string | undefined) /*throws*/ {
         super();
         const pointer =
             
         uniffiCaller.rustCallWithError(
             /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
             /*caller:*/ (callStatus) => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_rusttts_new(
-        FfiConverterString.lower(source),
-        FfiConverterOptionalString.lower(architecture),
-        FfiConverterOptionalString.lower(voice),
-        FfiConverterOptionalString.lower(language),
-        FfiConverterOptionalFloat32.lower(speed),
-        FfiConverterOptionalUInt32.lower(steps),
-        FfiConverterOptionalFloat32.lower(silenceDuration),
-        FfiConverterOptionalString.lower(precision),
-        FfiConverterOptionalFloat32.lower(temperature),
-        FfiConverterOptionalString.lower(huggingfaceToken),
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_constructor_rustvoiceactivitydetection_new(
+        FfiConverterOptionalString.lower(source),
+        FfiConverterUInt32.lower(sampleRate),
+        FfiConverterOptionalFloat32.lower(threshold),
+        FfiConverterOptionalUInt32.lower(minSilenceDurationMs),
+        FfiConverterOptionalUInt32.lower(minSpeechDurationMs),
+        FfiConverterOptionalUInt32.lower(prerollDurationMs),
         FfiConverterOptionalString.lower(device),
                 callStatus);
             },
             /*liftString:*/ FfiConverterString.lift,
     );
         this[pointerLiteralSymbol] = pointer;
-        this[destructorGuardSymbol] = uniffiTypeRustTtsObjectFactory.bless(pointer);
+        this[destructorGuardSymbol] = uniffiTypeRustVoiceActivityDetectionObjectFactory.bless(pointer);
     }
 
     
 
     
     /**
-     * Synthesize text and return WAV bytes.
+     * Return the current turn's captured audio (from the confirmed
+     * `SpeechStarted`, including a small pre-roll, through to
+     * `SpeechEnded`) and reset internal state for the next turn. Empty if
+     * speech was never confirmed.
      */
- synthesize(text: string): ArrayBuffer /*throws*/ {
-    return FfiConverterArrayBuffer.lift(
+ finish(): Array</*i16*/number> {
+    return FfiConverterArrayInt16.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustvoiceactivitydetection_finish(uniffiTypeRustVoiceActivityDetectionObjectFactory.clonePointer(this), 
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
+    /**
+     * Feed the newest chunk of i16 PCM audio (not the whole accumulated
+     * buffer — the detector tracks the current turn internally). Always
+     * returns the current confirmed state: `Speech`/`Silence` if unchanged
+     * since the last call, or `SpeechStarted`/`SpeechEnded` on the call that
+     * confirmed the transition.
+     */
+ push(chunk: Array</*i16*/number>): VoiceActivityDetectionEvent /*throws*/ {
+    return FfiConverterTypeVoiceActivityDetectionEvent.lift(
         uniffiCaller.rustCallWithError(
             /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
             /*caller:*/ (callStatus) => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rusttts_synthesize(uniffiTypeRustTtsObjectFactory.clonePointer(this), 
-        FfiConverterString.lower(text),
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustvoiceactivitydetection_push(uniffiTypeRustVoiceActivityDetectionObjectFactory.clonePointer(this), 
+        FfiConverterArrayInt16.lower(chunk),
                 callStatus);
             },
             /*liftString:*/ FfiConverterString.lift,
@@ -3396,34 +4021,22 @@ export class RustTts extends UniffiAbstractObject implements RustTtsInterface {
     }
     
     /**
-     * Synthesize text asynchronously and return WAV bytes.
+     * Detect every speech segment in a complete audio buffer, returning
+     * each segment's audio (with a short pre-roll) in order. Unlike `push`,
+     * correctly finds every segment regardless of buffer size — use this
+     * for offline/batch processing instead of live streaming.
      */
-async  synthesizeAsync(text: string, asyncOpts_?: { signal: AbortSignal }): Promise<ArrayBuffer> /*throws*/ {
-    const __stack = uniffiIsDebug ? new Error().stack : undefined;
-    try {
-        return await uniffiRustCallAsync(
-            /*rustCaller:*/ uniffiCaller,
-            /*rustFutureFunc:*/ () => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rusttts_synthesize_async(
-                    uniffiTypeRustTtsObjectFactory.clonePointer(this),
-                    FfiConverterString.lower(text)
-                );
+ segment(samples: Array</*i16*/number>): Array<Array</*i16*/number>> /*throws*/ {
+    return FfiConverterArrayArrayInt16.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_method_rustvoiceactivitydetection_segment(uniffiTypeRustVoiceActivityDetectionObjectFactory.clonePointer(this), 
+        FfiConverterArrayInt16.lower(samples),
+                callStatus);
             },
-            /*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:*/ FfiConverterArrayBuffer.lift.bind(FfiConverterArrayBuffer),
             /*liftString:*/ FfiConverterString.lift,
-            /*asyncOpts:*/ asyncOpts_,
-            /*errorHandler:*/ FfiConverterTypeNobodyWhoError.lift.bind(FfiConverterTypeNobodyWhoError)
-        );
-    } catch (__error: any) {
-        if (uniffiIsDebug && __error instanceof Error) {
-            __error.stack = __stack;
-        }
-        throw __error;
-    }
+    ));
     }
     
 
@@ -3433,28 +4046,28 @@ async  synthesizeAsync(text: string, asyncOpts_?: { signal: AbortSignal }): Prom
     uniffiDestroy(): void {
         const ptr = (this as any)[destructorGuardSymbol];
         if (ptr !== undefined) {
-            const pointer = uniffiTypeRustTtsObjectFactory.pointer(this);
-            uniffiTypeRustTtsObjectFactory.freePointer(pointer);
-            uniffiTypeRustTtsObjectFactory.unbless(ptr);
+            const pointer = uniffiTypeRustVoiceActivityDetectionObjectFactory.pointer(this);
+            uniffiTypeRustVoiceActivityDetectionObjectFactory.freePointer(pointer);
+            uniffiTypeRustVoiceActivityDetectionObjectFactory.unbless(ptr);
             delete (this as any)[destructorGuardSymbol];
         }
     }
 
-    static instanceOf(obj: any): obj is RustTts {
-        return uniffiTypeRustTtsObjectFactory.isConcreteType(obj);
+    static instanceOf(obj: any): obj is RustVoiceActivityDetection {
+        return uniffiTypeRustVoiceActivityDetectionObjectFactory.isConcreteType(obj);
     }
 
     
 }
 
-const uniffiTypeRustTtsObjectFactory: UniffiObjectFactory<RustTtsInterface> = (() => {
+const uniffiTypeRustVoiceActivityDetectionObjectFactory: UniffiObjectFactory<RustVoiceActivityDetectionInterface> = (() => {
     
     return {
-    create(pointer: UniffiHandle): RustTtsInterface {
-        const instance = Object.create(RustTts.prototype);
+    create(pointer: UniffiHandle): RustVoiceActivityDetectionInterface {
+        const instance = Object.create(RustVoiceActivityDetection.prototype);
         instance[pointerLiteralSymbol] = pointer;
         instance[destructorGuardSymbol] = this.bless(pointer);
-        instance[uniffiTypeNameSymbol] = "RustTts";
+        instance[uniffiTypeNameSymbol] = "RustVoiceActivityDetection";
         return instance;
     },
 
@@ -3462,7 +4075,7 @@ const uniffiTypeRustTtsObjectFactory: UniffiObjectFactory<RustTtsInterface> = ((
     bless(p: UniffiHandle): UniffiGcObject {
         return uniffiCaller.rustCall(
             /*caller:*/ (status) =>
-                nativeModule().ubrn_uniffi_internal_fn_method_rusttts_ffi__bless_pointer(p, status),
+                nativeModule().ubrn_uniffi_internal_fn_method_rustvoiceactivitydetection_ffi__bless_pointer(p, status),
             /*liftString:*/ FfiConverterString.lift
         );
     },
@@ -3471,34 +4084,34 @@ const uniffiTypeRustTtsObjectFactory: UniffiObjectFactory<RustTtsInterface> = ((
         ptr.markDestroyed();
     },
 
-    pointer(obj: RustTtsInterface): UniffiHandle {
+    pointer(obj: RustVoiceActivityDetectionInterface): UniffiHandle {
         if ((obj as any)[destructorGuardSymbol] === undefined) {
             throw new UniffiInternalError.UnexpectedNullPointer();
         }
         return (obj as any)[pointerLiteralSymbol];
     },
 
-    clonePointer(obj: RustTtsInterface): UniffiHandle {
+    clonePointer(obj: RustVoiceActivityDetectionInterface): UniffiHandle {
         const pointer = this.pointer(obj);
         return uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rusttts(pointer, callStatus),
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_clone_rustvoiceactivitydetection(pointer, callStatus),
             /*liftString:*/ FfiConverterString.lift
         );
     },
 
     freePointer(pointer: UniffiHandle): void {
         uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rusttts(pointer, callStatus),
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_free_rustvoiceactivitydetection(pointer, callStatus),
             /*liftString:*/ FfiConverterString.lift
         );
     },
 
-    isConcreteType(obj: any): obj is RustTtsInterface {
-        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustTts";
+    isConcreteType(obj: any): obj is RustVoiceActivityDetectionInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "RustVoiceActivityDetection";
     },
 }})();
-// FfiConverter for RustTtsInterface
-const FfiConverterTypeRustTts =  new FfiConverterObject(uniffiTypeRustTtsObjectFactory);
+// FfiConverter for RustVoiceActivityDetectionInterface
+const FfiConverterTypeRustVoiceActivityDetection =  new FfiConverterObject(uniffiTypeRustVoiceActivityDetectionObjectFactory);
 
 
 export interface SamplerBuilderInterface {
@@ -3511,6 +4124,16 @@ export interface SamplerBuilderInterface {
      * 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 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)
+     */
+    dynamicTemperature(temperature: /*f32*/number, delta: /*f32*/number, exponent: /*f32*/number) : SamplerBuilderInterface;
     /**
      * Deprecated: Use `sampler_preset_constrain_with_grammar()` instead. It accepts both Lark and GBNF strings.
      */
@@ -3519,6 +4142,16 @@ export interface SamplerBuilderInterface {
      * Always select the most probable token (deterministic).
      */
     greedy() : SamplerConfigInterface;
+    /**
+     * 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).
      */
@@ -3548,6 +4181,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.
      */
@@ -3619,6 +4260,28 @@ export class SamplerBuilder extends UniffiAbstractObject implements SamplerBuild
     ));
     }
     
+    /**
+     * 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)
+     */
+ 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_dynamic_temperature(uniffiTypeSamplerBuilderObjectFactory.clonePointer(this), 
+        FfiConverterFloat32.lower(temperature),
+        FfiConverterFloat32.lower(delta),
+        FfiConverterFloat32.lower(exponent),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+    
     /**
      * Deprecated: Use `sampler_preset_constrain_with_grammar()` instead. It accepts both Lark and GBNF strings.
      */
@@ -3648,6 +4311,26 @@ export class SamplerBuilder extends UniffiAbstractObject implements SamplerBuild
     ));
     }
     
+    /**
+     * 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).
      */
@@ -3754,6 +4437,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.
      */
@@ -4041,10 +4742,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);
 
@@ -4077,12 +4774,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>
@@ -4093,6 +4790,14 @@ const FfiConverterArrayTypeRustTool = new FfiConverterArray(FfiConverterTypeRust
 const FfiConverterArrayOptionalInt32 = new FfiConverterArray(FfiConverterOptionalInt32);
 
 
+// FfiConverter for Array<Array</*f32*/number>>
+const FfiConverterArrayArrayFloat32 = new FfiConverterArray(FfiConverterArrayFloat32);
+
+
+// FfiConverter for Array<Array</*i16*/number>>
+const FfiConverterArrayArrayInt16 = new FfiConverterArray(FfiConverterArrayInt16);
+
+
 // FfiConverter for Array<RustToolInterface> | undefined
 const FfiConverterOptionalArrayTypeRustTool = new FfiConverterOptional(FfiConverterArrayTypeRustTool);
 
@@ -4126,8 +4831,14 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_model() !== 22964) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_model");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_tts() !== 26587) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_tts");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_speech_to_text() !== 3224) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_speech_to_text");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_text_to_speech() !== 45176) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_text_to_speech");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_voice_activity_detection() !== 42331) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_voice_activity_detection");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_constrain_with_grammar() !== 13698) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_sampler_preset_constrain_with_grammar");
@@ -4168,9 +4879,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() !== 37833) {
+        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");
     }
@@ -4216,7 +4930,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) {
@@ -4228,20 +4942,29 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustencoder_encode() !== 52601) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustencoder_encode");
     }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustencoder_encode_batch() !== 20675) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustencoder_encode_batch");
+    }
     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_ruststt_transcribe_file() !== 43975) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_ruststt_transcribe_file");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustspeechtotext_transcribe_file() !== 59975) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustspeechtotext_transcribe_file");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustspeechtotext_transcribe_pcm() !== 9293) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustspeechtotext_transcribe_pcm");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_ruststt_transcribe_pcm() !== 61166) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_ruststt_transcribe_pcm");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustspeechtotextstream_completed() !== 15944) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustspeechtotextstream_completed");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_ruststtstream_completed() !== 22443) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_ruststtstream_completed");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustspeechtotextstream_next_token() !== 8103) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustspeechtotextstream_next_token");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_ruststtstream_next_token() !== 38526) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_ruststtstream_next_token");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttexttospeech_synthesize() !== 61700) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttexttospeech_synthesize");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttexttospeech_synthesize_async() !== 14494) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttexttospeech_synthesize_async");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttokenstream_completed() !== 26060) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttokenstream_completed");
@@ -4258,11 +4981,14 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttool_resolve_pending_call() !== 10096) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttool_resolve_pending_call");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttts_synthesize() !== 56024) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttts_synthesize");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustvoiceactivitydetection_finish() !== 1447) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustvoiceactivitydetection_finish");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustvoiceactivitydetection_push() !== 58012) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustvoiceactivitydetection_push");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttts_synthesize_async() !== 54670) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttts_synthesize_async");
+    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_dist() !== 23376) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dist");
@@ -4270,12 +4996,18 @@ function uniffiEnsureInitialized() {
     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_dynamic_temperature() !== 5004) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_dynamic_temperature");
+    }
     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_greedy() !== 32898) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_samplerbuilder_greedy");
     }
+    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");
     }
@@ -4297,6 +5029,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");
     }
@@ -4318,8 +5053,11 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rustencoder_new() !== 27902) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rustencoder_new");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_ruststt_new() !== 44850) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_ruststt_new");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rustspeechtotext_new() !== 9249) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rustspeechtotext_new");
+    }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rusttexttospeech_new() !== 55766) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rusttexttospeech_new");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new() !== 9431) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new");
@@ -4327,8 +5065,8 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new_async() !== 54521) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new_async");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rusttts_new() !== 34899) {
-        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rusttts_new");
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rustvoiceactivitydetection_new() !== 47351) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_rustvoiceactivitydetection_new");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerbuilder_new() !== 50214) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_samplerbuilder_new");
@@ -4350,26 +5088,29 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
-    FfiConverterTypeAsset,
     FfiConverterTypeCachedModel,
     FfiConverterTypeChatStats,
+    FfiConverterTypeContentPart,
     FfiConverterTypeMessage,
+    FfiConverterTypeMessageContent,
     FfiConverterTypeMtpConfig,
     FfiConverterTypeNobodyWhoError,
+    FfiConverterTypeOptions,
     FfiConverterTypePendingToolCall,
-    FfiConverterTypePromptPart,
     FfiConverterTypeRustChat,
     FfiConverterTypeRustCrossEncoder,
     FfiConverterTypeRustEncoder,
     FfiConverterTypeRustModel,
-    FfiConverterTypeRustSTT,
-    FfiConverterTypeRustSTTStream,
+    FfiConverterTypeRustSpeechToText,
+    FfiConverterTypeRustSpeechToTextStream,
+    FfiConverterTypeRustTextToSpeech,
     FfiConverterTypeRustTokenStream,
     FfiConverterTypeRustTool,
-    FfiConverterTypeRustTts,
+    FfiConverterTypeRustVoiceActivityDetection,
     FfiConverterTypeSamplerBuilder,
     FfiConverterTypeSamplerConfig,
     FfiConverterTypeToolCall,
     FfiConverterTypeToolParameter,
+    FfiConverterTypeVoiceActivityDetectionEvent,
   }
 });