ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/CloudFileAttachmentAdapter.js

@@ -0,0 +1,86 @@
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+const guessAttachmentType = (contentType) => {
+    if (contentType.startsWith("image/"))
+        return "image";
+    if (contentType.startsWith("text/"))
+        return "document";
+    return "file";
+};
+export class CloudFileAttachmentAdapter {
+    constructor(cloud) {
+        this.cloud = cloud;
+        this.accept = "*";
+        this.uploadedUrls = new Map();
+    }
+    add(_a) {
+        return __asyncGenerator(this, arguments, function* add_1({ file, }) {
+            const id = crypto.randomUUID();
+            const type = guessAttachmentType(file.type);
+            let attachment = {
+                id,
+                type,
+                name: file.name,
+                contentType: file.type,
+                file,
+                status: { type: "running", reason: "uploading", progress: 0 },
+            };
+            yield yield __await(attachment);
+            try {
+                const { signedUrl, publicUrl } = yield __await(this.cloud.files.generatePresignedUploadUrl({
+                    filename: file.name,
+                }));
+                yield __await(fetch(signedUrl, {
+                    method: "PUT",
+                    body: file,
+                    headers: {
+                        "Content-Type": file.type,
+                    },
+                    mode: "cors",
+                }));
+                this.uploadedUrls.set(id, publicUrl);
+                attachment = Object.assign(Object.assign({}, attachment), { status: { type: "requires-action", reason: "composer-send" } });
+                yield yield __await(attachment);
+            }
+            catch (_b) {
+                attachment = Object.assign(Object.assign({}, attachment), { status: { type: "incomplete", reason: "error" } });
+                yield yield __await(attachment);
+            }
+        });
+    }
+    async remove(attachment) {
+        this.uploadedUrls.delete(attachment.id);
+    }
+    async send(attachment) {
+        const url = this.uploadedUrls.get(attachment.id);
+        if (!url)
+            throw new Error("Attachment not uploaded");
+        this.uploadedUrls.delete(attachment.id);
+        let content;
+        if (attachment.type === "image") {
+            content = [{ type: "image", image: url, filename: attachment.name }];
+        }
+        else {
+            content = [
+                {
+                    type: "file",
+                    data: url,
+                    mimeType: attachment.contentType,
+                    filename: attachment.name,
+                },
+            ];
+        }
+        return Object.assign(Object.assign({}, attachment), { status: { type: "complete" }, content });
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/CompositeAttachmentAdapter.d.ts

@@ -0,0 +1,12 @@
+import { Attachment, PendingAttachment } from "../../../../types/AttachmentTypes";
+import { AttachmentAdapter } from "./AttachmentAdapter";
+export declare class CompositeAttachmentAdapter implements AttachmentAdapter {
+    private _adapters;
+    accept: string;
+    constructor(adapters: AttachmentAdapter[]);
+    add(state: {
+        file: File;
+    }): Promise<PendingAttachment> | AsyncGenerator<PendingAttachment, void, any>;
+    send(attachment: PendingAttachment): Promise<import("../../../..").CompleteAttachment>;
+    remove(attachment: Attachment): Promise<void>;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/CompositeAttachmentAdapter.js

@@ -0,0 +1,76 @@
+function fileMatchesAccept(file, acceptString) {
+    // Check if the accept string is "*", which allows any file
+    if (acceptString === "*") {
+        return true;
+    }
+    // Split the accept string into an array of allowed types
+    const allowedTypes = acceptString
+        .split(",")
+        .map((type) => type.trim().toLowerCase());
+    // Get the file's extension and MIME type
+    const fileExtension = `.${file.name.split(".").pop().toLowerCase()}`;
+    const fileMimeType = file.type.toLowerCase();
+    for (const type of allowedTypes) {
+        // Check for file extension match
+        if (type.startsWith(".") && type === fileExtension) {
+            return true;
+        }
+        // Check for exact MIME type match
+        if (type.includes("/") && type === fileMimeType) {
+            return true;
+        }
+        if (type === "image/*" || type === "video/*" || type === "audio/*") {
+            // Check for wildcard MIME type match
+            if (type.endsWith("/*")) {
+                const generalType = type.split("/")[0];
+                if (fileMimeType.startsWith(`${generalType}/`)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export class CompositeAttachmentAdapter {
+    constructor(adapters) {
+        this._adapters = adapters;
+        const wildcardIdx = adapters.findIndex((a) => a.accept === "*");
+        if (wildcardIdx !== -1) {
+            if (wildcardIdx !== adapters.length - 1)
+                throw new Error("A wildcard adapter (handling all files) can only be specified as the last adapter.");
+            this.accept = "*";
+        }
+        else {
+            this.accept = adapters.map((a) => a.accept).join(",");
+        }
+    }
+    add(state) {
+        for (const adapter of this._adapters) {
+            if (fileMatchesAccept(state.file, adapter.accept)) {
+                return adapter.add(state);
+            }
+        }
+        throw new Error("No matching adapter found for file");
+    }
+    async send(attachment) {
+        const adapters = this._adapters.slice();
+        for (const adapter of adapters) {
+            if (fileMatchesAccept(attachment.file, adapter.accept)) {
+                return adapter.send(attachment);
+            }
+        }
+        throw new Error("No matching adapter found for attachment");
+    }
+    async remove(attachment) {
+        const adapters = this._adapters.slice();
+        for (const adapter of adapters) {
+            if (fileMatchesAccept({
+                name: attachment.name,
+                type: attachment.contentType,
+            }, adapter.accept)) {
+                return adapter.remove(attachment);
+            }
+        }
+        throw new Error("No matching adapter found for attachment");
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/SimpleImageAttachmentAdapter.d.ts

@@ -0,0 +1,10 @@
+import { PendingAttachment, CompleteAttachment } from "../../../../types/AttachmentTypes";
+import { AttachmentAdapter } from "./AttachmentAdapter";
+export declare class SimpleImageAttachmentAdapter implements AttachmentAdapter {
+    accept: string;
+    add(state: {
+        file: File;
+    }): Promise<PendingAttachment>;
+    send(attachment: PendingAttachment): Promise<CompleteAttachment>;
+    remove(): Promise<void>;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/SimpleImageAttachmentAdapter.js

@@ -0,0 +1,32 @@
+export class SimpleImageAttachmentAdapter {
+    constructor() {
+        this.accept = "image/*";
+    }
+    async add(state) {
+        return {
+            id: state.file.name,
+            type: "image",
+            name: state.file.name,
+            contentType: state.file.type,
+            file: state.file,
+            status: { type: "requires-action", reason: "composer-send" },
+        };
+    }
+    async send(attachment) {
+        return Object.assign(Object.assign({}, attachment), { status: { type: "complete" }, content: [
+                {
+                    type: "image",
+                    image: await getFileDataURL(attachment.file),
+                },
+            ] });
+    }
+    async remove() {
+        // noop
+    }
+}
+const getFileDataURL = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+    reader.readAsDataURL(file);
+});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/SimpleTextAttachmentAdapter.d.ts

@@ -0,0 +1,10 @@
+import { CompleteAttachment, PendingAttachment } from "../../../../types/AttachmentTypes";
+import { AttachmentAdapter } from "./AttachmentAdapter";
+export declare class SimpleTextAttachmentAdapter implements AttachmentAdapter {
+    accept: string;
+    add(state: {
+        file: File;
+    }): Promise<PendingAttachment>;
+    send(attachment: PendingAttachment): Promise<CompleteAttachment>;
+    remove(): Promise<void>;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/SimpleTextAttachmentAdapter.js

@@ -0,0 +1,32 @@
+export class SimpleTextAttachmentAdapter {
+    constructor() {
+        this.accept = "text/plain,text/html,text/markdown,text/csv,text/xml,text/json,text/css";
+    }
+    async add(state) {
+        return {
+            id: state.file.name,
+            type: "document",
+            name: state.file.name,
+            contentType: state.file.type,
+            file: state.file,
+            status: { type: "requires-action", reason: "composer-send" },
+        };
+    }
+    async send(attachment) {
+        return Object.assign(Object.assign({}, attachment), { status: { type: "complete" }, content: [
+                {
+                    type: "text",
+                    text: `<attachment name=${attachment.name}>\n${await getFileText(attachment.file)}\n</attachment>`,
+                },
+            ] });
+    }
+    async remove() {
+        // noop
+    }
+}
+const getFileText = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+    reader.readAsText(file);
+});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/index.d.ts

@@ -0,0 +1,5 @@
+export type { AttachmentAdapter } from "./AttachmentAdapter";
+export { SimpleImageAttachmentAdapter } from "./SimpleImageAttachmentAdapter";
+export { SimpleTextAttachmentAdapter } from "./SimpleTextAttachmentAdapter";
+export { CompositeAttachmentAdapter } from "./CompositeAttachmentAdapter";
+export { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/index.js

@@ -0,0 +1,4 @@
+export { SimpleImageAttachmentAdapter } from "./SimpleImageAttachmentAdapter";
+export { SimpleTextAttachmentAdapter } from "./SimpleTextAttachmentAdapter";
+export { CompositeAttachmentAdapter } from "./CompositeAttachmentAdapter";
+export { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/feedback/FeedbackAdapter.d.ts

@@ -0,0 +1,42 @@
+import { ThreadMessage } from "../../../../types/AssistantTypes";
+/**
+ * Feedback data structure for rating messages.
+ */
+type FeedbackAdapterFeedback = {
+    /** The message being rated */
+    message: ThreadMessage;
+    /** The type of feedback being provided */
+    type: "positive" | "negative";
+};
+/**
+ * Interface for handling user feedback on assistant messages.
+ *
+ * FeedbackAdapter allows users to provide positive or negative feedback
+ * on assistant responses, which can be used for analytics, model improvement,
+ * or user experience tracking.
+ *
+ * @example
+ * ```tsx
+ * const feedbackAdapter: FeedbackAdapter = {
+ *   submit: (feedback) => {
+ *     console.log(`User gave ${feedback.type} feedback on message:`, feedback.message.id);
+ *
+ *     // Send to analytics service
+ *     analytics.track('message_feedback', {
+ *       messageId: feedback.message.id,
+ *       feedbackType: feedback.type,
+ *       messageContent: feedback.message.content
+ *     });
+ *   }
+ * };
+ * ```
+ */
+export type FeedbackAdapter = {
+    /**
+     * Submits user feedback for a message.
+     *
+     * @param feedback - The feedback data containing message and rating type
+     */
+    submit: (feedback: FeedbackAdapterFeedback) => void;
+};
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/feedback/FeedbackAdapter.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/feedback/index.d.ts

@@ -0,0 +1 @@
+export type { FeedbackAdapter } from "./FeedbackAdapter";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/feedback/index.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./attachment";
+export * from "./feedback";
+export * from "./speech";
+export * from "./suggestion";
+export * from "./RuntimeAdapterProvider";
+export * from "./thread-history";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/index.js

@@ -0,0 +1,6 @@
+export * from "./attachment";
+export * from "./feedback";
+export * from "./speech";
+export * from "./suggestion";
+export * from "./RuntimeAdapterProvider";
+export * from "./thread-history";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/speech/SpeechAdapterTypes.d.ts

@@ -0,0 +1,109 @@
+import { Unsubscribe } from "../../../../types";
+/**
+ * Types and interfaces for speech synthesis (text-to-speech) functionality.
+ */
+export declare namespace SpeechSynthesisAdapter {
+    /**
+     * Status of a speech synthesis operation.
+     */
+    type Status = {
+        /** Speech is starting or currently running */
+        type: "starting" | "running";
+    } | {
+        /** Speech has ended */
+        type: "ended";
+        /** Reason why speech ended */
+        reason: "finished" | "cancelled" | "error";
+        /** Error details if speech ended due to error */
+        error?: unknown;
+    };
+    /**
+     * Represents a single speech utterance with control and status tracking.
+     */
+    type Utterance = {
+        /** Current status of the utterance */
+        status: Status;
+        /** Cancel the current speech */
+        cancel: () => void;
+        /** Subscribe to status changes */
+        subscribe: (callback: () => void) => Unsubscribe;
+    };
+}
+/**
+ * Interface for text-to-speech functionality.
+ *
+ * SpeechSynthesisAdapter provides the ability to convert text content
+ * into spoken audio, with status tracking and cancellation support.
+ *
+ * @example
+ * ```tsx
+ * const speechAdapter: SpeechSynthesisAdapter = {
+ *   speak: (text) => {
+ *     const utterance = new SpeechSynthesisUtterance(text);
+ *     speechSynthesis.speak(utterance);
+ *
+ *     return {
+ *       status: { type: "starting" },
+ *       cancel: () => speechSynthesis.cancel(),
+ *       subscribe: (callback) => {
+ *         utterance.addEventListener('end', callback);
+ *         return () => utterance.removeEventListener('end', callback);
+ *       }
+ *     };
+ *   }
+ * };
+ * ```
+ */
+export type SpeechSynthesisAdapter = {
+    /**
+     * Converts text to speech and returns an utterance object for control.
+     *
+     * @param text - The text content to speak
+     * @returns An utterance object with status and control methods
+     */
+    speak: (text: string) => SpeechSynthesisAdapter.Utterance;
+};
+export declare namespace DictationAdapter {
+    type Status = {
+        type: "starting" | "running";
+    } | {
+        type: "ended";
+        reason: "stopped" | "cancelled" | "error";
+    };
+    type Result = {
+        /** The transcribed text */
+        transcript: string;
+        /**
+         * Whether this is a final (committed) result or an interim (partial) result.
+         *
+         * - `true` (final): The text should be appended to the composer input.
+         *   This text is finalized and won't change.
+         *
+         * - `false` (interim/partial): The text is a preview that may change.
+         *   It should be displayed as a preview but not appended to the input yet.
+         *   Subsequent interim results replace the previous interim result.
+         *
+         * Defaults to `true` for backwards compatibility with adapters that
+         * don't set this flag.
+         */
+        isFinal?: boolean;
+    };
+    type Session = {
+        status: Status;
+        stop: () => Promise<void>;
+        cancel: () => void;
+        onSpeechStart: (callback: () => void) => Unsubscribe;
+        onSpeechEnd: (callback: (result: Result) => void) => Unsubscribe;
+        onSpeech: (callback: (result: Result) => void) => Unsubscribe;
+    };
+}
+export type DictationAdapter = {
+    listen: () => DictationAdapter.Session;
+    /**
+     * Whether to disable text input while dictation is active.
+     * Some adapters (like ElevenLabs Scribe) return cumulative transcripts
+     * that conflict with simultaneous typing.
+     * @default false
+     */
+    disableInputDuringDictation?: boolean;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/speech/SpeechAdapterTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/speech/WebSpeechDictationAdapter.d.ts

@@ -0,0 +1,60 @@
+import type { DictationAdapter } from "./SpeechAdapterTypes";
+interface SpeechRecognitionInstance extends EventTarget {
+    lang: string;
+    continuous: boolean;
+    interimResults: boolean;
+    start(): void;
+    stop(): void;
+    abort(): void;
+}
+interface SpeechRecognitionConstructor {
+    new (): SpeechRecognitionInstance;
+}
+declare global {
+    interface Window {
+        SpeechRecognition?: SpeechRecognitionConstructor;
+        webkitSpeechRecognition?: SpeechRecognitionConstructor;
+    }
+}
+/**
+ * WebSpeechDictationAdapter provides speech-to-text (dictation) functionality using
+ * the browser's Web Speech API (SpeechRecognition).
+ *
+ * @example
+ * ```tsx
+ * const runtime = useChatRuntime({
+ *   api: "/api/chat",
+ *   adapters: {
+ *     dictation: new WebSpeechDictationAdapter(),
+ *   },
+ * });
+ * ```
+ */
+export declare class WebSpeechDictationAdapter implements DictationAdapter {
+    private _language;
+    private _continuous;
+    private _interimResults;
+    constructor(options?: {
+        /**
+         * The language for dictation (e.g., "en-US", "zh-CN").
+         * Defaults to the browser's language.
+         */
+        language?: string;
+        /**
+         * Whether to keep recording after the user stops speaking.
+         * Defaults to true.
+         */
+        continuous?: boolean;
+        /**
+         * Whether to return interim (partial) results.
+         * Defaults to true for real-time feedback.
+         */
+        interimResults?: boolean;
+    });
+    /**
+     * Check if the browser supports the Web Speech Recognition API.
+     */
+    static isSupported(): boolean;
+    listen(): DictationAdapter.Session;
+}
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/speech/WebSpeechDictationAdapter.js

@@ -0,0 +1,151 @@
+const getSpeechRecognitionAPI = () => {
+    var _a;
+    if (typeof window === "undefined")
+        return undefined;
+    return (_a = window.SpeechRecognition) !== null && _a !== void 0 ? _a : window.webkitSpeechRecognition;
+};
+/**
+ * WebSpeechDictationAdapter provides speech-to-text (dictation) functionality using
+ * the browser's Web Speech API (SpeechRecognition).
+ *
+ * @example
+ * ```tsx
+ * const runtime = useChatRuntime({
+ *   api: "/api/chat",
+ *   adapters: {
+ *     dictation: new WebSpeechDictationAdapter(),
+ *   },
+ * });
+ * ```
+ */
+export class WebSpeechDictationAdapter {
+    constructor(options = {}) {
+        var _a, _b, _c;
+        const defaultLanguage = typeof navigator !== "undefined" && navigator.language
+            ? navigator.language
+            : "en-US";
+        this._language = (_a = options.language) !== null && _a !== void 0 ? _a : defaultLanguage;
+        this._continuous = (_b = options.continuous) !== null && _b !== void 0 ? _b : true;
+        this._interimResults = (_c = options.interimResults) !== null && _c !== void 0 ? _c : true;
+    }
+    /**
+     * Check if the browser supports the Web Speech Recognition API.
+     */
+    static isSupported() {
+        return getSpeechRecognitionAPI() !== undefined;
+    }
+    listen() {
+        const SpeechRecognitionAPI = getSpeechRecognitionAPI();
+        if (!SpeechRecognitionAPI) {
+            throw new Error("SpeechRecognition is not supported in this browser. " +
+                "Try using Chrome, Edge, or Safari.");
+        }
+        const recognition = new SpeechRecognitionAPI();
+        recognition.lang = this._language;
+        recognition.continuous = this._continuous;
+        recognition.interimResults = this._interimResults;
+        const speechStartCallbacks = new Set();
+        const speechEndCallbacks = new Set();
+        const speechCallbacks = new Set();
+        let finalTranscript = "";
+        const session = {
+            status: { type: "starting" },
+            stop: async () => {
+                recognition.stop();
+                return new Promise((resolve) => {
+                    const checkEnded = () => {
+                        if (session.status.type === "ended") {
+                            resolve();
+                        }
+                        else {
+                            setTimeout(checkEnded, 50);
+                        }
+                    };
+                    checkEnded();
+                });
+            },
+            cancel: () => {
+                recognition.abort();
+            },
+            onSpeechStart: (callback) => {
+                speechStartCallbacks.add(callback);
+                return () => {
+                    speechStartCallbacks.delete(callback);
+                };
+            },
+            onSpeechEnd: (callback) => {
+                speechEndCallbacks.add(callback);
+                return () => {
+                    speechEndCallbacks.delete(callback);
+                };
+            },
+            onSpeech: (callback) => {
+                speechCallbacks.add(callback);
+                return () => {
+                    speechCallbacks.delete(callback);
+                };
+            },
+        };
+        const updateStatus = (newStatus) => {
+            session.status = newStatus;
+        };
+        recognition.addEventListener("speechstart", () => {
+            for (const cb of speechStartCallbacks)
+                cb();
+        });
+        recognition.addEventListener("start", () => {
+            updateStatus({ type: "running" });
+        });
+        recognition.addEventListener("result", (event) => {
+            var _a, _b;
+            const speechEvent = event;
+            for (let i = speechEvent.resultIndex; i < speechEvent.results.length; i++) {
+                const result = speechEvent.results[i];
+                if (!result)
+                    continue;
+                const transcript = (_b = (_a = result[0]) === null || _a === void 0 ? void 0 : _a.transcript) !== null && _b !== void 0 ? _b : "";
+                if (result.isFinal) {
+                    finalTranscript += transcript;
+                    for (const cb of speechCallbacks)
+                        cb({ transcript, isFinal: true });
+                }
+                else {
+                    for (const cb of speechCallbacks)
+                        cb({ transcript, isFinal: false });
+                }
+            }
+        });
+        recognition.addEventListener("speechend", () => {
+            // speechend fires when user stops speaking, but 'end' handles final cleanup
+        });
+        recognition.addEventListener("end", () => {
+            const currentStatus = session.status;
+            if (currentStatus.type !== "ended") {
+                updateStatus({ type: "ended", reason: "stopped" });
+            }
+            if (finalTranscript) {
+                for (const cb of speechEndCallbacks)
+                    cb({ transcript: finalTranscript });
+                finalTranscript = "";
+            }
+        });
+        recognition.addEventListener("error", (event) => {
+            const errorEvent = event;
+            if (errorEvent.error === "aborted") {
+                updateStatus({ type: "ended", reason: "cancelled" });
+            }
+            else {
+                updateStatus({ type: "ended", reason: "error" });
+                console.error("Dictation error:", errorEvent.error, errorEvent.message);
+            }
+        });
+        try {
+            recognition.start();
+        }
+        catch (error) {
+            updateStatus({ type: "ended", reason: "error" });
+            throw error;
+        }
+        return session;
+    }
+}