ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/useToolInvocations.d.ts

@@ -0,0 +1,23 @@
+import { type Tool } from "assistant-stream";
+import type { AssistantTransportCommand, AssistantTransportState } from "./types";
+type UseToolInvocationsParams = {
+    state: AssistantTransportState;
+    getTools: () => Record<string, Tool> | undefined;
+    onResult: (command: AssistantTransportCommand) => void;
+    setToolStatuses: (updater: Record<string, ToolExecutionStatus> | ((prev: Record<string, ToolExecutionStatus>) => Record<string, ToolExecutionStatus>)) => void;
+};
+export type ToolExecutionStatus = {
+    type: "executing";
+} | {
+    type: "interrupt";
+    payload: {
+        type: "human";
+        payload: unknown;
+    };
+};
+export declare function useToolInvocations({ state, getTools, onResult, setToolStatuses, }: UseToolInvocationsParams): {
+    reset: () => void;
+    abort: () => Promise<void>;
+    resume: (toolCallId: string, payload: unknown) => void;
+};
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/useToolInvocations.js

@@ -0,0 +1,199 @@
+import { useEffect, useRef, useState } from "react";
+import { createAssistantStreamController, ToolResponse, unstable_toolResultStream, } from "assistant-stream";
+import { AssistantMetaTransformStream, } from "assistant-stream/utils";
+const isArgsTextComplete = (argsText) => {
+    try {
+        JSON.parse(argsText);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+export function useToolInvocations({ state, getTools, onResult, setToolStatuses, }) {
+    const lastToolStates = useRef({});
+    const humanInputRef = useRef(new Map());
+    const acRef = useRef(new AbortController());
+    const executingCountRef = useRef(0);
+    const settledResolversRef = useRef([]);
+    const [controller] = useState(() => {
+        const [stream, controller] = createAssistantStreamController();
+        const transform = unstable_toolResultStream(getTools, () => { var _a, _b; return (_b = (_a = acRef.current) === null || _a === void 0 ? void 0 : _a.signal) !== null && _b !== void 0 ? _b : new AbortController().signal; }, (toolCallId, payload) => {
+            return new Promise((resolve, reject) => {
+                // Reject previous human input request if it exists
+                const previous = humanInputRef.current.get(toolCallId);
+                if (previous) {
+                    previous.reject(new Error("Human input request was superseded by a new request"));
+                }
+                humanInputRef.current.set(toolCallId, { resolve, reject });
+                setToolStatuses((prev) => (Object.assign(Object.assign({}, prev), { [toolCallId]: {
+                        type: "interrupt",
+                        payload: { type: "human", payload },
+                    } })));
+            });
+        }, {
+            onExecutionStart: (toolCallId) => {
+                executingCountRef.current++;
+                setToolStatuses((prev) => (Object.assign(Object.assign({}, prev), { [toolCallId]: { type: "executing" } })));
+            },
+            onExecutionEnd: (toolCallId) => {
+                executingCountRef.current--;
+                setToolStatuses((prev) => {
+                    const next = Object.assign({}, prev);
+                    delete next[toolCallId];
+                    return next;
+                });
+                // Resolve any waiting abort promises when all tools have settled
+                if (executingCountRef.current === 0) {
+                    settledResolversRef.current.forEach((resolve) => resolve());
+                    settledResolversRef.current = [];
+                }
+            },
+        });
+        stream
+            .pipeThrough(transform)
+            .pipeThrough(new AssistantMetaTransformStream())
+            .pipeTo(new WritableStream({
+            write(chunk) {
+                var _a;
+                if (chunk.type === "result") {
+                    // the tool call result was already set by the backend
+                    if ((_a = lastToolStates.current[chunk.meta.toolCallId]) === null || _a === void 0 ? void 0 : _a.hasResult)
+                        return;
+                    onResult(Object.assign({ type: "add-tool-result", toolCallId: chunk.meta.toolCallId, toolName: chunk.meta.toolName, result: chunk.result, isError: chunk.isError }, (chunk.artifact && { artifact: chunk.artifact })));
+                }
+            },
+        }));
+        return controller;
+    });
+    const ignoredToolIds = useRef(new Set());
+    const isInitialState = useRef(true);
+    useEffect(() => {
+        const processMessages = (messages) => {
+            messages.forEach((message) => {
+                message.content.forEach((content) => {
+                    if (content.type === "tool-call") {
+                        if (isInitialState.current) {
+                            ignoredToolIds.current.add(content.toolCallId);
+                        }
+                        else {
+                            if (ignoredToolIds.current.has(content.toolCallId)) {
+                                return;
+                            }
+                            let lastState = lastToolStates.current[content.toolCallId];
+                            if (!lastState) {
+                                const toolCallController = controller.addToolCallPart({
+                                    toolName: content.toolName,
+                                    toolCallId: content.toolCallId,
+                                });
+                                lastState = {
+                                    argsText: "",
+                                    hasResult: false,
+                                    argsComplete: false,
+                                    controller: toolCallController,
+                                };
+                                lastToolStates.current[content.toolCallId] = lastState;
+                            }
+                            if (content.argsText !== lastState.argsText) {
+                                if (lastState.argsComplete) {
+                                    if (process.env["NODE_ENV"] !== "production") {
+                                        console.warn("argsText updated after controller was closed:", {
+                                            previous: lastState.argsText,
+                                            next: content.argsText,
+                                        });
+                                    }
+                                }
+                                else {
+                                    if (!content.argsText.startsWith(lastState.argsText)) {
+                                        // Check if this is key reordering (both are complete JSON)
+                                        // This happens when transitioning from streaming to complete state
+                                        // and the provider returns keys in a different order
+                                        if (isArgsTextComplete(lastState.argsText) &&
+                                            isArgsTextComplete(content.argsText)) {
+                                            lastState.controller.argsText.close();
+                                            lastToolStates.current[content.toolCallId] = {
+                                                argsText: content.argsText,
+                                                hasResult: lastState.hasResult,
+                                                argsComplete: true,
+                                                controller: lastState.controller,
+                                            };
+                                            return; // Continue to next content part
+                                        }
+                                        throw new Error(`Tool call argsText can only be appended, not updated: ${content.argsText} does not start with ${lastState.argsText}`);
+                                    }
+                                    const argsTextDelta = content.argsText.slice(lastState.argsText.length);
+                                    lastState.controller.argsText.append(argsTextDelta);
+                                    const shouldClose = isArgsTextComplete(content.argsText);
+                                    if (shouldClose) {
+                                        lastState.controller.argsText.close();
+                                    }
+                                    lastToolStates.current[content.toolCallId] = {
+                                        argsText: content.argsText,
+                                        hasResult: lastState.hasResult,
+                                        argsComplete: shouldClose,
+                                        controller: lastState.controller,
+                                    };
+                                }
+                            }
+                            if (content.result !== undefined && !lastState.hasResult) {
+                                lastState.controller.setResponse(new ToolResponse({
+                                    result: content.result,
+                                    artifact: content.artifact,
+                                    isError: content.isError,
+                                }));
+                                lastState.controller.close();
+                                lastToolStates.current[content.toolCallId] = {
+                                    hasResult: true,
+                                    argsComplete: true,
+                                    argsText: lastState.argsText,
+                                    controller: lastState.controller,
+                                };
+                            }
+                        }
+                        // Recursively process nested messages
+                        if (content.messages) {
+                            processMessages(content.messages);
+                        }
+                    }
+                });
+            });
+        };
+        processMessages(state.messages);
+        if (isInitialState.current) {
+            isInitialState.current = false;
+        }
+    }, [state, controller]);
+    const abort = () => {
+        humanInputRef.current.forEach(({ reject }) => {
+            reject(new Error("Tool execution aborted"));
+        });
+        humanInputRef.current.clear();
+        acRef.current.abort();
+        acRef.current = new AbortController();
+        // Return a promise that resolves when all executing tools have settled
+        if (executingCountRef.current === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            settledResolversRef.current.push(resolve);
+        });
+    };
+    return {
+        reset: () => {
+            void abort();
+            isInitialState.current = true;
+        },
+        abort,
+        resume: (toolCallId, payload) => {
+            const handlers = humanInputRef.current.get(toolCallId);
+            if (handlers) {
+                humanInputRef.current.delete(toolCallId);
+                setToolStatuses((prev) => (Object.assign(Object.assign({}, prev), { [toolCallId]: { type: "executing" } })));
+                handlers.resolve(payload);
+            }
+            else {
+                throw new Error(`Tool call ${toolCallId} is not waiting for human input`);
+            }
+        },
+    };
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/utils.d.ts

@@ -0,0 +1,10 @@
+import { Tool, type ToolJSONSchema } from "assistant-stream";
+/**
+ * @deprecated Use `toToolsJSONSchema` from `assistant-stream` instead.
+ */
+export declare function toAISDKTools(tools: Record<string, Tool>): Record<string, ToolJSONSchema>;
+/**
+ * @deprecated Use `toToolsJSONSchema` from `assistant-stream` instead, which includes filtering by default.
+ */
+export declare function getEnabledTools(tools: Record<string, Tool>): Record<string, Tool>;
+export declare function createRequestHeaders(headersValue: Record<string, string> | Headers | (() => Promise<Record<string, string> | Headers>)): Promise<Headers>;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/utils.js

@@ -0,0 +1,19 @@
+import { toToolsJSONSchema } from "assistant-stream";
+/**
+ * @deprecated Use `toToolsJSONSchema` from `assistant-stream` instead.
+ */
+export function toAISDKTools(tools) {
+    return toToolsJSONSchema(tools, { filter: () => true });
+}
+/**
+ * @deprecated Use `toToolsJSONSchema` from `assistant-stream` instead, which includes filtering by default.
+ */
+export function getEnabledTools(tools) {
+    return Object.fromEntries(Object.entries(tools).filter(([, tool]) => !tool.disabled && tool.type !== "backend"));
+}
+export async function createRequestHeaders(headersValue) {
+    const resolvedHeaders = typeof headersValue === "function" ? await headersValue() : headersValue;
+    const headers = new Headers(resolvedHeaders);
+    headers.set("Content-Type", "application/json");
+    return headers;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore.d.ts

@@ -0,0 +1,53 @@
+import type { Attachment } from "../../../types/AttachmentTypes";
+import type { AppendMessage } from "../../../types";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { ComposerRuntimeCore, ComposerRuntimeEventType, DictationState } from "../core/ComposerRuntimeCore";
+import type { MessageRole, RunConfig } from "../../../types/AssistantTypes";
+import { BaseSubscribable } from "../remote-thread-list/BaseSubscribable";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+export declare abstract class BaseComposerRuntimeCore extends BaseSubscribable implements ComposerRuntimeCore {
+    readonly isEditing = true;
+    protected abstract getAttachmentAdapter(): AttachmentAdapter | undefined;
+    protected abstract getDictationAdapter(): DictationAdapter | undefined;
+    get attachmentAccept(): string;
+    private _attachments;
+    get attachments(): readonly Attachment[];
+    protected setAttachments(value: readonly Attachment[]): void;
+    abstract get canCancel(): boolean;
+    get isEmpty(): boolean;
+    private _text;
+    get text(): string;
+    private _role;
+    get role(): "user" | "system" | "assistant";
+    private _runConfig;
+    get runConfig(): RunConfig;
+    setText(value: string): void;
+    setRole(role: MessageRole): void;
+    setRunConfig(runConfig: RunConfig): void;
+    private _emptyTextAndAttachments;
+    private _onClearAttachments;
+    reset(): Promise<void>;
+    clearAttachments(): Promise<void>;
+    send(): Promise<void>;
+    cancel(): void;
+    protected abstract handleSend(message: Omit<AppendMessage, "parentId" | "sourceId">): void;
+    protected abstract handleCancel(): void;
+    addAttachment(file: File): Promise<void>;
+    removeAttachment(attachmentId: string): Promise<void>;
+    private _dictation;
+    private _dictationSession;
+    private _dictationUnsubscribes;
+    private _dictationBaseText;
+    private _currentInterimText;
+    private _dictationSessionIdCounter;
+    private _activeDictationSessionId;
+    private _isCleaningDictation;
+    get dictation(): DictationState | undefined;
+    private _isActiveSession;
+    startDictation(): void;
+    stopDictation(): void;
+    private _cleanupDictation;
+    private _eventSubscribers;
+    protected _notifyEventSubscribers(event: ComposerRuntimeEventType): void;
+    unstable_on(event: ComposerRuntimeEventType, callback: () => void): () => void;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore.js

@@ -0,0 +1,339 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { BaseSubscribable } from "../remote-thread-list/BaseSubscribable";
+const isAttachmentComplete = (a) => a.status.type === "complete";
+export class BaseComposerRuntimeCore extends BaseSubscribable {
+    constructor() {
+        super(...arguments);
+        this.isEditing = true;
+        this._attachments = [];
+        this._text = "";
+        this._role = "user";
+        this._runConfig = {};
+        this._dictationUnsubscribes = [];
+        this._dictationBaseText = "";
+        this._currentInterimText = "";
+        this._dictationSessionIdCounter = 0;
+        this._isCleaningDictation = false;
+        this._eventSubscribers = new Map();
+    }
+    get attachmentAccept() {
+        var _a, _b;
+        return (_b = (_a = this.getAttachmentAdapter()) === null || _a === void 0 ? void 0 : _a.accept) !== null && _b !== void 0 ? _b : "*";
+    }
+    get attachments() {
+        return this._attachments;
+    }
+    setAttachments(value) {
+        this._attachments = value;
+        this._notifySubscribers();
+    }
+    get isEmpty() {
+        return !this.text.trim() && !this.attachments.length;
+    }
+    get text() {
+        return this._text;
+    }
+    get role() {
+        return this._role;
+    }
+    get runConfig() {
+        return this._runConfig;
+    }
+    setText(value) {
+        if (this._text === value)
+            return;
+        this._text = value;
+        // When dictation is active and the user manually edits the composer text,
+        // treat the new text as the updated base so speech results are appended
+        // instead of overwriting manual edits.
+        if (this._dictation) {
+            this._dictationBaseText = value;
+            this._currentInterimText = "";
+            const { status, inputDisabled } = this._dictation;
+            this._dictation = inputDisabled ? { status, inputDisabled } : { status };
+        }
+        this._notifySubscribers();
+    }
+    setRole(role) {
+        if (this._role === role)
+            return;
+        this._role = role;
+        this._notifySubscribers();
+    }
+    setRunConfig(runConfig) {
+        if (this._runConfig === runConfig)
+            return;
+        this._runConfig = runConfig;
+        this._notifySubscribers();
+    }
+    _emptyTextAndAttachments() {
+        this._attachments = [];
+        this._text = "";
+        this._notifySubscribers();
+    }
+    async _onClearAttachments() {
+        const adapter = this.getAttachmentAdapter();
+        if (adapter) {
+            await Promise.all(this._attachments.map((a) => adapter.remove(a)));
+        }
+    }
+    async reset() {
+        if (this._attachments.length === 0 &&
+            this._text === "" &&
+            this._role === "user" &&
+            Object.keys(this._runConfig).length === 0) {
+            return;
+        }
+        this._role = "user";
+        this._runConfig = {};
+        const task = this._onClearAttachments();
+        this._emptyTextAndAttachments();
+        await task;
+    }
+    async clearAttachments() {
+        const task = this._onClearAttachments();
+        this.setAttachments([]);
+        await task;
+    }
+    async send() {
+        if (this._dictationSession) {
+            this._dictationSession.cancel();
+            this._cleanupDictation();
+        }
+        const adapter = this.getAttachmentAdapter();
+        const attachments = adapter && this.attachments.length > 0
+            ? Promise.all(this.attachments.map(async (a) => {
+                if (isAttachmentComplete(a))
+                    return a;
+                const result = await adapter.send(a);
+                return result;
+            }))
+            : [];
+        const text = this.text;
+        this._emptyTextAndAttachments();
+        const message = {
+            createdAt: new Date(),
+            role: this.role,
+            content: text ? [{ type: "text", text }] : [],
+            attachments: await attachments,
+            runConfig: this.runConfig,
+            metadata: { custom: {} },
+        };
+        this.handleSend(message);
+        this._notifyEventSubscribers("send");
+    }
+    cancel() {
+        this.handleCancel();
+    }
+    async addAttachment(file) {
+        var _a, e_1, _b, _c;
+        const adapter = this.getAttachmentAdapter();
+        if (!adapter)
+            throw new Error("Attachments are not supported");
+        const upsertAttachment = (a) => {
+            const idx = this._attachments.findIndex((attachment) => attachment.id === a.id);
+            if (idx !== -1)
+                this._attachments = [
+                    ...this._attachments.slice(0, idx),
+                    a,
+                    ...this._attachments.slice(idx + 1),
+                ];
+            else {
+                this._attachments = [...this._attachments, a];
+            }
+            this._notifySubscribers();
+        };
+        const promiseOrGenerator = adapter.add({ file });
+        if (Symbol.asyncIterator in promiseOrGenerator) {
+            try {
+                for (var _d = true, promiseOrGenerator_1 = __asyncValues(promiseOrGenerator), promiseOrGenerator_1_1; promiseOrGenerator_1_1 = await promiseOrGenerator_1.next(), _a = promiseOrGenerator_1_1.done, !_a; _d = true) {
+                    _c = promiseOrGenerator_1_1.value;
+                    _d = false;
+                    const r = _c;
+                    upsertAttachment(r);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = promiseOrGenerator_1.return)) await _b.call(promiseOrGenerator_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        else {
+            upsertAttachment(await promiseOrGenerator);
+        }
+        this._notifyEventSubscribers("attachmentAdd");
+        this._notifySubscribers();
+    }
+    async removeAttachment(attachmentId) {
+        const adapter = this.getAttachmentAdapter();
+        if (!adapter)
+            throw new Error("Attachments are not supported");
+        const index = this._attachments.findIndex((a) => a.id === attachmentId);
+        if (index === -1)
+            throw new Error("Attachment not found");
+        const attachment = this._attachments[index];
+        await adapter.remove(attachment);
+        // this._attachments.toSpliced(index, 1); - not yet widely supported
+        this._attachments = [
+            ...this._attachments.slice(0, index),
+            ...this._attachments.slice(index + 1),
+        ];
+        this._notifySubscribers();
+    }
+    get dictation() {
+        return this._dictation;
+    }
+    _isActiveSession(sessionId, session) {
+        return (this._activeDictationSessionId === sessionId &&
+            this._dictationSession === session);
+    }
+    startDictation() {
+        var _a;
+        const adapter = this.getDictationAdapter();
+        if (!adapter) {
+            throw new Error("Dictation adapter not configured");
+        }
+        if (this._dictationSession) {
+            for (const unsub of this._dictationUnsubscribes) {
+                unsub();
+            }
+            this._dictationUnsubscribes = [];
+            const oldSession = this._dictationSession;
+            oldSession.stop().catch(() => { });
+            this._dictationSession = undefined;
+        }
+        const inputDisabled = (_a = adapter.disableInputDuringDictation) !== null && _a !== void 0 ? _a : false;
+        this._dictationBaseText = this._text;
+        this._currentInterimText = "";
+        const session = adapter.listen();
+        this._dictationSession = session;
+        const sessionId = ++this._dictationSessionIdCounter;
+        this._activeDictationSessionId = sessionId;
+        this._dictation = { status: session.status, inputDisabled };
+        this._notifySubscribers();
+        const unsubSpeech = session.onSpeech((result) => {
+            if (!this._isActiveSession(sessionId, session))
+                return;
+            const isFinal = result.isFinal !== false;
+            const needsSeparator = this._dictationBaseText &&
+                !this._dictationBaseText.endsWith(" ") &&
+                result.transcript;
+            const separator = needsSeparator ? " " : "";
+            if (isFinal) {
+                this._dictationBaseText =
+                    this._dictationBaseText + separator + result.transcript;
+                this._currentInterimText = "";
+                this._text = this._dictationBaseText;
+                if (this._dictation) {
+                    const _a = this._dictation, { transcript: _ } = _a, rest = __rest(_a, ["transcript"]);
+                    this._dictation = rest;
+                }
+                this._notifySubscribers();
+            }
+            else {
+                this._currentInterimText = separator + result.transcript;
+                this._text = this._dictationBaseText + this._currentInterimText;
+                if (this._dictation) {
+                    this._dictation = Object.assign(Object.assign({}, this._dictation), { transcript: result.transcript });
+                }
+                this._notifySubscribers();
+            }
+        });
+        this._dictationUnsubscribes.push(unsubSpeech);
+        const unsubStart = session.onSpeechStart(() => {
+            var _a;
+            if (!this._isActiveSession(sessionId, session))
+                return;
+            this._dictation = Object.assign({ status: { type: "running" }, inputDisabled }, (((_a = this._dictation) === null || _a === void 0 ? void 0 : _a.transcript) && {
+                transcript: this._dictation.transcript,
+            }));
+            this._notifySubscribers();
+        });
+        this._dictationUnsubscribes.push(unsubStart);
+        const unsubEnd = session.onSpeechEnd(() => {
+            this._cleanupDictation({ sessionId });
+        });
+        this._dictationUnsubscribes.push(unsubEnd);
+        const statusInterval = setInterval(() => {
+            if (!this._isActiveSession(sessionId, session))
+                return;
+            if (session.status.type === "ended") {
+                this._cleanupDictation({ sessionId });
+            }
+        }, 100);
+        this._dictationUnsubscribes.push(() => clearInterval(statusInterval));
+    }
+    stopDictation() {
+        if (!this._dictationSession)
+            return;
+        const session = this._dictationSession;
+        const sessionId = this._activeDictationSessionId;
+        session.stop().finally(() => {
+            this._cleanupDictation({ sessionId });
+        });
+    }
+    _cleanupDictation(options) {
+        const isStaleSession = (options === null || options === void 0 ? void 0 : options.sessionId) !== undefined &&
+            options.sessionId !== this._activeDictationSessionId;
+        if (isStaleSession || this._isCleaningDictation)
+            return;
+        this._isCleaningDictation = true;
+        try {
+            for (const unsub of this._dictationUnsubscribes) {
+                unsub();
+            }
+            this._dictationUnsubscribes = [];
+            this._dictationSession = undefined;
+            this._activeDictationSessionId = undefined;
+            this._dictation = undefined;
+            this._dictationBaseText = "";
+            this._currentInterimText = "";
+            this._notifySubscribers();
+        }
+        finally {
+            this._isCleaningDictation = false;
+        }
+    }
+    _notifyEventSubscribers(event) {
+        const subscribers = this._eventSubscribers.get(event);
+        if (!subscribers)
+            return;
+        for (const callback of subscribers)
+            callback();
+    }
+    unstable_on(event, callback) {
+        const subscribers = this._eventSubscribers.get(event);
+        if (!subscribers) {
+            this._eventSubscribers.set(event, new Set([callback]));
+        }
+        else {
+            subscribers.add(callback);
+        }
+        return () => {
+            const subscribers = this._eventSubscribers.get(event);
+            if (!subscribers)
+                return;
+            subscribers.delete(callback);
+        };
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/composer/DefaultEditComposerRuntimeCore.d.ts

@@ -0,0 +1,27 @@
+import type { AppendMessage, ThreadMessage } from "../../../types";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import type { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
+import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
+export declare class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
+    private runtime;
+    private endEditCallback;
+    get canCancel(): boolean;
+    protected getAttachmentAdapter(): AttachmentAdapter | undefined;
+    protected getDictationAdapter(): DictationAdapter | undefined;
+    private _nonTextParts;
+    private _previousText;
+    private _parentId;
+    private _sourceId;
+    constructor(runtime: ThreadRuntimeCore & {
+        adapters?: {
+            attachments?: AttachmentAdapter | undefined;
+            dictation?: DictationAdapter | undefined;
+        } | undefined;
+    }, endEditCallback: () => void, { parentId, message }: {
+        parentId: string | null;
+        message: ThreadMessage;
+    });
+    handleSend(message: Omit<AppendMessage, "parentId" | "sourceId">): Promise<void>;
+    handleCancel(): void;
+}