ikoncomponents 1.6.5 → 1.6.7

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

@@ -1,23 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,339 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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;
-}