ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/local/LocalThreadRuntimeCore.js

@@ -0,0 +1,441 @@
+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;
+};
+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); }
+};
+import { fromThreadMessageLike, generateId } from "../../../internal";
+import { shouldContinue } from "./shouldContinue";
+import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
+class AbortError extends Error {
+    constructor(detach, message) {
+        super(message);
+        this.name = "AbortError";
+        this.detach = detach;
+    }
+}
+export class LocalThreadRuntimeCore extends BaseThreadRuntimeCore {
+    get isLoading() {
+        return this._isLoading;
+    }
+    get suggestions() {
+        return this._suggestions;
+    }
+    get adapters() {
+        return this._options.adapters;
+    }
+    constructor(contextProvider, options) {
+        super(contextProvider);
+        this.capabilities = {
+            switchToBranch: true,
+            switchBranchDuringRun: true,
+            edit: true,
+            reload: true,
+            cancel: true,
+            unstable_copy: true,
+            speech: false,
+            dictation: false,
+            attachments: false,
+            feedback: false,
+        };
+        this.abortController = null;
+        this.isDisabled = false;
+        this._isLoading = false;
+        this._suggestions = [];
+        this._suggestionsController = null;
+        this._lastRunConfig = {};
+        this.__internal_setOptions(options);
+    }
+    __internal_setGetThreadId(getThreadId) {
+        this._getThreadId = getThreadId;
+    }
+    __internal_setGetInitializePromise(getPromise) {
+        this._getInitializePromise = getPromise;
+    }
+    get extras() {
+        return undefined;
+    }
+    __internal_setOptions(options) {
+        var _a, _b, _c, _d;
+        if (this._options === options)
+            return;
+        this._options = options;
+        let hasUpdates = false;
+        const canSpeak = ((_a = options.adapters) === null || _a === void 0 ? void 0 : _a.speech) !== undefined;
+        if (this.capabilities.speech !== canSpeak) {
+            this.capabilities.speech = canSpeak;
+            hasUpdates = true;
+        }
+        const canDictate = ((_b = options.adapters) === null || _b === void 0 ? void 0 : _b.dictation) !== undefined;
+        if (this.capabilities.dictation !== canDictate) {
+            this.capabilities.dictation = canDictate;
+            hasUpdates = true;
+        }
+        const canAttach = ((_c = options.adapters) === null || _c === void 0 ? void 0 : _c.attachments) !== undefined;
+        if (this.capabilities.attachments !== canAttach) {
+            this.capabilities.attachments = canAttach;
+            hasUpdates = true;
+        }
+        const canFeedback = ((_d = options.adapters) === null || _d === void 0 ? void 0 : _d.feedback) !== undefined;
+        if (this.capabilities.feedback !== canFeedback) {
+            this.capabilities.feedback = canFeedback;
+            hasUpdates = true;
+        }
+        if (hasUpdates)
+            this._notifySubscribers();
+    }
+    __internal_load() {
+        var _a, _b;
+        if (this._loadPromise)
+            return this._loadPromise;
+        const promise = (_b = (_a = this.adapters.history) === null || _a === void 0 ? void 0 : _a.load()) !== null && _b !== void 0 ? _b : Promise.resolve(null);
+        this._isLoading = true;
+        this._notifySubscribers();
+        this._loadPromise = promise
+            .then((repo) => {
+            var _a, _b;
+            if (!repo)
+                return;
+            this.repository.import(repo);
+            if (repo.messages.length > 0) {
+                this.ensureInitialized();
+            }
+            this._notifySubscribers();
+            const resume = (_b = (_a = this.adapters.history) === null || _a === void 0 ? void 0 : _a.resume) === null || _b === void 0 ? void 0 : _b.bind(this.adapters.history);
+            if (repo.unstable_resume && resume) {
+                this.startRun({
+                    parentId: this.repository.headId,
+                    sourceId: this.repository.headId,
+                    runConfig: this._lastRunConfig,
+                }, resume);
+            }
+        })
+            .finally(() => {
+            this._isLoading = false;
+            this._notifySubscribers();
+        });
+        return this._loadPromise;
+    }
+    async append(message) {
+        var _a, _b, _c, _d;
+        this.ensureInitialized();
+        const initPromise = (_a = this._getInitializePromise) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (initPromise) {
+            await initPromise;
+        }
+        const newMessage = fromThreadMessageLike(message, generateId(), {
+            type: "complete",
+            reason: "unknown",
+        });
+        this.repository.addOrUpdateMessage(message.parentId, newMessage);
+        (_b = this._options.adapters.history) === null || _b === void 0 ? void 0 : _b.append(Object.assign({ parentId: message.parentId, message: newMessage }, (message.runConfig !== undefined && { runConfig: message.runConfig })));
+        const startRun = (_c = message.startRun) !== null && _c !== void 0 ? _c : message.role === "user";
+        if (startRun) {
+            await this.startRun({
+                parentId: newMessage.id,
+                sourceId: message.sourceId,
+                runConfig: (_d = message.runConfig) !== null && _d !== void 0 ? _d : {},
+            });
+        }
+        else {
+            this.repository.resetHead(newMessage.id);
+            this._notifySubscribers();
+        }
+    }
+    resumeRun(_a) {
+        var { stream } = _a, startConfig = __rest(_a, ["stream"]);
+        if (!stream)
+            throw new Error("You must pass a stream parameter to resume runs.");
+        return this.startRun(startConfig, stream);
+    }
+    exportExternalState() {
+        throw new Error("Runtime does not support exporting external states.");
+    }
+    importExternalState() {
+        throw new Error("Runtime does not support importing external states.");
+    }
+    unstable_loadExternalState() {
+        throw new Error("Runtime does not support importing external states.");
+    }
+    async startRun({ parentId, runConfig }, runCallback) {
+        var _a, e_1, _b, _c;
+        var _d, _e, _f;
+        this.ensureInitialized();
+        // add assistant message
+        const id = generateId();
+        let message = {
+            id,
+            role: "assistant",
+            status: { type: "running" },
+            content: [],
+            metadata: {
+                unstable_state: this.state,
+                unstable_annotations: [],
+                unstable_data: [],
+                steps: [],
+                custom: {},
+            },
+            createdAt: new Date(),
+        };
+        this._notifyEventSubscribers("runStart");
+        try {
+            this._suggestions = [];
+            (_d = this._suggestionsController) === null || _d === void 0 ? void 0 : _d.abort();
+            this._suggestionsController = null;
+            this._notifySubscribers();
+            do {
+                message = await this.performRoundtrip(parentId, message, runConfig, runCallback);
+                runCallback = undefined;
+            } while (shouldContinue(message, this._options.unstable_humanToolNames));
+        }
+        finally {
+            this._notifyEventSubscribers("runEnd");
+        }
+        this._suggestionsController = new AbortController();
+        const signal = this._suggestionsController.signal;
+        if (this.adapters.suggestion &&
+            ((_e = message.status) === null || _e === void 0 ? void 0 : _e.type) !== "requires-action") {
+            const promiseOrGenerator = (_f = this.adapters.suggestion) === null || _f === void 0 ? void 0 : _f.generate({
+                messages: this.messages,
+            });
+            if (Symbol.asyncIterator in promiseOrGenerator) {
+                try {
+                    for (var _g = true, promiseOrGenerator_1 = __asyncValues(promiseOrGenerator), promiseOrGenerator_1_1; promiseOrGenerator_1_1 = await promiseOrGenerator_1.next(), _a = promiseOrGenerator_1_1.done, !_a; _g = true) {
+                        _c = promiseOrGenerator_1_1.value;
+                        _g = false;
+                        const r = _c;
+                        if (signal.aborted)
+                            break;
+                        this._suggestions = r;
+                        this._notifySubscribers();
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_g && !_a && (_b = promiseOrGenerator_1.return)) await _b.call(promiseOrGenerator_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            else {
+                const result = await promiseOrGenerator;
+                if (signal.aborted)
+                    return;
+                this._suggestions = result;
+                this._notifySubscribers();
+            }
+        }
+    }
+    async performRoundtrip(parentId, message, runConfig, runCallback) {
+        var _a, e_2, _b, _c;
+        var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const messages = parentId ? this.repository.getMessages(parentId) : [];
+        // abort existing run
+        (_d = this.abortController) === null || _d === void 0 ? void 0 : _d.abort();
+        this.abortController = new AbortController();
+        const initialContent = message.content;
+        const initialAnnotations = (_e = message.metadata) === null || _e === void 0 ? void 0 : _e.unstable_annotations;
+        const initialData = (_f = message.metadata) === null || _f === void 0 ? void 0 : _f.unstable_data;
+        const initialSteps = (_g = message.metadata) === null || _g === void 0 ? void 0 : _g.steps;
+        const initalCustom = (_h = message.metadata) === null || _h === void 0 ? void 0 : _h.custom;
+        const updateMessage = (m) => {
+            var _a, _b, _c, _d, _e, _f;
+            const newSteps = (_a = m.metadata) === null || _a === void 0 ? void 0 : _a.steps;
+            const steps = newSteps
+                ? [...(initialSteps !== null && initialSteps !== void 0 ? initialSteps : []), ...newSteps]
+                : undefined;
+            const newAnnotations = (_b = m.metadata) === null || _b === void 0 ? void 0 : _b.unstable_annotations;
+            const newData = (_c = m.metadata) === null || _c === void 0 ? void 0 : _c.unstable_data;
+            const annotations = newAnnotations
+                ? [...(initialAnnotations !== null && initialAnnotations !== void 0 ? initialAnnotations : []), ...newAnnotations]
+                : undefined;
+            const data = newData ? [...(initialData !== null && initialData !== void 0 ? initialData : []), ...newData] : undefined;
+            message = Object.assign(Object.assign(Object.assign(Object.assign({}, message), (m.content
+                ? { content: [...initialContent, ...((_d = m.content) !== null && _d !== void 0 ? _d : [])] }
+                : undefined)), { status: (_e = m.status) !== null && _e !== void 0 ? _e : message.status }), (m.metadata
+                ? {
+                    metadata: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, message.metadata), (m.metadata.unstable_state
+                        ? { unstable_state: m.metadata.unstable_state }
+                        : undefined)), (annotations
+                        ? { unstable_annotations: annotations }
+                        : undefined)), (data ? { unstable_data: data } : undefined)), (steps ? { steps } : undefined)), (((_f = m.metadata) === null || _f === void 0 ? void 0 : _f.custom)
+                        ? {
+                            custom: Object.assign(Object.assign({}, (initalCustom !== null && initalCustom !== void 0 ? initalCustom : {})), m.metadata.custom),
+                        }
+                        : undefined)),
+                }
+                : undefined));
+            this.repository.addOrUpdateMessage(parentId, message);
+            this._notifySubscribers();
+        };
+        const maxSteps = (_j = this._options.maxSteps) !== null && _j !== void 0 ? _j : 2;
+        const steps = (_m = (_l = (_k = message.metadata) === null || _k === void 0 ? void 0 : _k.steps) === null || _l === void 0 ? void 0 : _l.length) !== null && _m !== void 0 ? _m : 0;
+        if (steps >= maxSteps) {
+            // reached max tool steps
+            updateMessage({
+                status: {
+                    type: "incomplete",
+                    reason: "tool-calls",
+                },
+            });
+            return message;
+        }
+        else {
+            updateMessage({
+                status: {
+                    type: "running",
+                },
+            });
+            // Switch to the new message branch right after adding it for the first time
+            this.repository.resetHead(message.id);
+            this._notifySubscribers();
+        }
+        try {
+            this._lastRunConfig = runConfig !== null && runConfig !== void 0 ? runConfig : {};
+            const context = this.getModelContext();
+            runCallback =
+                runCallback !== null && runCallback !== void 0 ? runCallback : this.adapters.chatModel.run.bind(this.adapters.chatModel);
+            const abortSignal = this.abortController.signal;
+            const threadId = (_o = this._getThreadId) === null || _o === void 0 ? void 0 : _o.call(this);
+            const promiseOrGenerator = runCallback({
+                messages,
+                runConfig: this._lastRunConfig,
+                abortSignal,
+                context,
+                config: context,
+                unstable_assistantMessageId: message.id,
+                unstable_threadId: threadId,
+                unstable_parentId: parentId,
+                unstable_getMessage() {
+                    return message;
+                },
+            });
+            // handle async iterator for streaming results
+            if (Symbol.asyncIterator in promiseOrGenerator) {
+                try {
+                    for (var _q = true, promiseOrGenerator_2 = __asyncValues(promiseOrGenerator), promiseOrGenerator_2_1; promiseOrGenerator_2_1 = await promiseOrGenerator_2.next(), _a = promiseOrGenerator_2_1.done, !_a; _q = true) {
+                        _c = promiseOrGenerator_2_1.value;
+                        _q = false;
+                        const r = _c;
+                        if (abortSignal.aborted) {
+                            updateMessage({
+                                status: { type: "incomplete", reason: "cancelled" },
+                            });
+                            break;
+                        }
+                        updateMessage(r);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_q && !_a && (_b = promiseOrGenerator_2.return)) await _b.call(promiseOrGenerator_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            else {
+                updateMessage(await promiseOrGenerator);
+            }
+            if (message.status.type === "running") {
+                updateMessage({
+                    status: { type: "complete", reason: "unknown" },
+                });
+            }
+        }
+        catch (e) {
+            // TODO this should be handled by the run result stream
+            if (e instanceof AbortError) {
+                updateMessage({
+                    status: { type: "incomplete", reason: "cancelled" },
+                });
+            }
+            else if (e instanceof Error && e.name === "AbortError") {
+                updateMessage({
+                    status: { type: "incomplete", reason: "cancelled" },
+                });
+            }
+            else {
+                updateMessage({
+                    status: {
+                        type: "incomplete",
+                        reason: "error",
+                        error: e instanceof Error
+                            ? e.message
+                            : `[${typeof e}] ${new String(e).toString()}`,
+                    },
+                });
+                throw e;
+            }
+        }
+        finally {
+            this.abortController = null;
+            if (message.status.type === "complete" ||
+                message.status.type === "incomplete") {
+                await ((_p = this._options.adapters.history) === null || _p === void 0 ? void 0 : _p.append({
+                    parentId,
+                    message: message,
+                    runConfig: this._lastRunConfig,
+                }));
+            }
+        }
+        return message;
+    }
+    detach() {
+        var _a;
+        const error = new AbortError(true);
+        (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort(error);
+        this.abortController = null;
+    }
+    cancelRun() {
+        var _a;
+        const error = new AbortError(false);
+        (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort(error);
+        this.abortController = null;
+    }
+    addToolResult({ messageId, toolCallId, result, isError, artifact, }) {
+        const messageData = this.repository.getMessage(messageId);
+        const { parentId } = messageData;
+        let { message } = messageData;
+        if (message.role !== "assistant")
+            throw new Error("Tried to add tool result to non-assistant message");
+        let added = false;
+        let found = false;
+        const newContent = message.content.map((c) => {
+            if (c.type !== "tool-call")
+                return c;
+            if (c.toolCallId !== toolCallId)
+                return c;
+            found = true;
+            if (!c.result)
+                added = true;
+            return Object.assign(Object.assign({}, c), { result,
+                artifact,
+                isError });
+        });
+        if (!found)
+            throw new Error("Tried to add tool result to non-existing tool call");
+        message = Object.assign(Object.assign({}, message), { content: newContent });
+        this.repository.addOrUpdateMessage(parentId, message);
+        if (added &&
+            shouldContinue(message, this._options.unstable_humanToolNames)) {
+            this.performRoundtrip(parentId, message, this._lastRunConfig);
+        }
+    }
+    resumeToolCall(_options) {
+        throw new Error("Local runtime does not support resuming tool calls.");
+    }
+}

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

@@ -0,0 +1,7 @@
+export { useLocalRuntime } from "./useLocalRuntime";
+/**
+ * @deprecated Use `useLocalRuntime` instead.
+ */
+export { useLocalRuntime as useLocalThreadRuntime } from "./useLocalRuntime";
+export type { LocalRuntimeOptions } from "./LocalRuntimeOptions";
+export type { ChatModelAdapter, ChatModelRunOptions, ChatModelRunResult, ChatModelRunUpdate, } from "./ChatModelAdapter";

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

@@ -0,0 +1,5 @@
+export { useLocalRuntime } from "./useLocalRuntime";
+/**
+ * @deprecated Use `useLocalRuntime` instead.
+ */
+export { useLocalRuntime as useLocalThreadRuntime } from "./useLocalRuntime";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/local/shouldContinue.d.ts

@@ -0,0 +1,2 @@
+import type { ThreadAssistantMessage } from "../../../types";
+export declare const shouldContinue: (result: ThreadAssistantMessage, humanToolNames: string[] | undefined) => boolean;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/local/shouldContinue.js

@@ -0,0 +1,14 @@
+export const shouldContinue = (result, humanToolNames) => {
+    var _a, _b;
+    // TODO legacy behavior -- make specifying human tool names required
+    if (humanToolNames === undefined) {
+        return (((_a = result.status) === null || _a === void 0 ? void 0 : _a.type) === "requires-action" &&
+            result.status.reason === "tool-calls" &&
+            result.content.every((c) => c.type !== "tool-call" || !!c.result));
+    }
+    return (((_b = result.status) === null || _b === void 0 ? void 0 : _b.type) === "requires-action" &&
+        result.status.reason === "tool-calls" &&
+        result.content.every((c) => c.type !== "tool-call" ||
+            !!c.result ||
+            !humanToolNames.includes(c.toolName)));
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/local/useLocalRuntime.d.ts

@@ -0,0 +1,3 @@
+import type { ChatModelAdapter } from "./ChatModelAdapter";
+import type { LocalRuntimeOptions } from "./LocalRuntimeOptions";
+export declare const useLocalRuntime: (adapter: ChatModelAdapter, { cloud, ...options }?: LocalRuntimeOptions) => import("../../runtime").AssistantRuntime;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/local/useLocalRuntime.js

@@ -0,0 +1,59 @@
+"use client";
+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 { useEffect, useMemo, useRef, useState } from "react";
+import { LocalRuntimeCore } from "./LocalRuntimeCore";
+import { useRuntimeAdapters } from "../adapters/RuntimeAdapterProvider";
+import { useRemoteThreadListRuntime } from "../remote-thread-list/useRemoteThreadListRuntime";
+import { useCloudThreadListAdapter } from "../remote-thread-list/adapter/cloud";
+import { AssistantRuntimeImpl } from "../../../internal";
+import { useAuiState } from "@assistant-ui/store";
+const useLocalThreadRuntime = (adapter, _a) => {
+    var _b;
+    var { initialMessages } = _a, options = __rest(_a, ["initialMessages"]);
+    const _c = (_b = useRuntimeAdapters()) !== null && _b !== void 0 ? _b : {}, { modelContext } = _c, threadListAdapters = __rest(_c, ["modelContext"]);
+    const opt = Object.assign(Object.assign({}, options), { adapters: Object.assign(Object.assign(Object.assign({}, threadListAdapters), options.adapters), { chatModel: adapter }) });
+    const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
+    const threadIdRef = useRef(undefined);
+    threadIdRef.current = useAuiState(({ threadListItem }) => threadListItem.remoteId);
+    useEffect(() => {
+        runtime.threads
+            .getMainThreadRuntimeCore()
+            .__internal_setGetThreadId(() => threadIdRef.current);
+    }, [runtime]);
+    useEffect(() => {
+        return () => {
+            runtime.threads.getMainThreadRuntimeCore().detach();
+        };
+    }, [runtime]);
+    useEffect(() => {
+        runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
+        runtime.threads.getMainThreadRuntimeCore().__internal_load();
+    });
+    useEffect(() => {
+        if (!modelContext)
+            return undefined;
+        return runtime.registerModelContextProvider(modelContext);
+    }, [modelContext, runtime]);
+    return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
+};
+export const useLocalRuntime = (adapter, _a = {}) => {
+    var { cloud } = _a, options = __rest(_a, ["cloud"]);
+    const cloudAdapter = useCloudThreadListAdapter({ cloud });
+    return useRemoteThreadListRuntime({
+        runtimeHook: function RuntimeHook() {
+            return useLocalThreadRuntime(adapter, options);
+        },
+        adapter: cloudAdapter,
+        allowNesting: true,
+    });
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/BaseSubscribable.d.ts

@@ -0,0 +1,7 @@
+import { Unsubscribe } from "../../../types";
+export declare class BaseSubscribable {
+    private _subscribers;
+    subscribe(callback: () => void): Unsubscribe;
+    waitForUpdate(): Promise<void>;
+    protected _notifySubscribers(): void;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/BaseSubscribable.js

@@ -0,0 +1,39 @@
+export class BaseSubscribable {
+    constructor() {
+        this._subscribers = new Set();
+    }
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    waitForUpdate() {
+        return new Promise((resolve) => {
+            const unsubscribe = this.subscribe(() => {
+                unsubscribe();
+                resolve();
+            });
+        });
+    }
+    _notifySubscribers() {
+        const errors = [];
+        for (const callback of this._subscribers) {
+            try {
+                callback();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0) {
+            if (errors.length === 1) {
+                throw errors[0];
+            }
+            else {
+                for (const error of errors) {
+                    console.error(error);
+                }
+                throw new AggregateError(errors);
+            }
+        }
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/EMPTY_THREAD_CORE.d.ts

@@ -0,0 +1,2 @@
+import type { ThreadRuntimeCore } from "../../../internal";
+export declare const EMPTY_THREAD_CORE: ThreadRuntimeCore;