ikoncomponents 1.6.4 → 1.6.5

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

@@ -0,0 +1,141 @@
+const EMPTY_THREAD_ERROR = new Error("This is the empty thread, a placeholder for the main thread. You cannot perform any actions on this thread instance. This error is probably because you tried to call a thread method in your render function. Call the method inside a `useEffect` hook instead.");
+export const EMPTY_THREAD_CORE = {
+    getMessageById() {
+        return undefined;
+    },
+    getBranches() {
+        return [];
+    },
+    switchToBranch() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    append() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    startRun() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    resumeRun() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    cancelRun() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    addToolResult() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    resumeToolCall() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    speak() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    stopSpeaking() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    submitFeedback() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    getModelContext() {
+        return {};
+    },
+    exportExternalState() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    importExternalState() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    unstable_loadExternalState() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    composer: {
+        attachments: [],
+        attachmentAccept: "*",
+        async addAttachment() {
+            throw EMPTY_THREAD_ERROR;
+        },
+        async removeAttachment() {
+            throw EMPTY_THREAD_ERROR;
+        },
+        isEditing: true,
+        canCancel: false,
+        isEmpty: true,
+        text: "",
+        setText() {
+            throw EMPTY_THREAD_ERROR;
+        },
+        role: "user",
+        setRole() {
+            throw EMPTY_THREAD_ERROR;
+        },
+        runConfig: {},
+        setRunConfig() {
+            throw EMPTY_THREAD_ERROR;
+        },
+        async reset() {
+            // noop
+        },
+        async clearAttachments() {
+            // noop
+        },
+        send() {
+            throw EMPTY_THREAD_ERROR;
+        },
+        cancel() {
+            // noop
+        },
+        dictation: undefined,
+        startDictation() {
+            throw EMPTY_THREAD_ERROR;
+        },
+        stopDictation() {
+            // noop
+        },
+        subscribe() {
+            return () => { };
+        },
+        unstable_on() {
+            return () => { };
+        },
+    },
+    getEditComposer() {
+        return undefined;
+    },
+    beginEdit() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    speech: undefined,
+    capabilities: {
+        switchToBranch: false,
+        switchBranchDuringRun: false,
+        edit: false,
+        reload: false,
+        cancel: false,
+        unstable_copy: false,
+        speech: false,
+        dictation: false,
+        attachments: false,
+        feedback: false,
+    },
+    isDisabled: false,
+    isLoading: false,
+    messages: [],
+    state: null,
+    suggestions: [],
+    extras: undefined,
+    subscribe() {
+        return () => { };
+    },
+    import() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    export() {
+        return { messages: [] };
+    },
+    reset() {
+        throw EMPTY_THREAD_ERROR;
+    },
+    unstable_on() {
+        return () => { };
+    },
+};

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

@@ -0,0 +1,22 @@
+import { BaseSubscribable } from "./BaseSubscribable";
+type Transform<TState, TResult> = {
+    execute: () => Promise<TResult>;
+    /** transform the state after the promise resolves */
+    then?: (state: TState, result: TResult) => TState;
+    /** transform the state during resolution and afterwards */
+    optimistic?: (state: TState) => TState;
+    /** transform the state only while loading */
+    loading?: (state: TState, task: Promise<TResult>) => TState;
+};
+export declare class OptimisticState<TState> extends BaseSubscribable {
+    private readonly _pendingTransforms;
+    private _baseValue;
+    private _cachedValue;
+    constructor(initialState: TState);
+    private _updateState;
+    get baseValue(): TState;
+    get value(): TState;
+    update(state: TState): void;
+    optimisticUpdate<TResult>(transform: Transform<TState, TResult>): Promise<TResult>;
+}
+export {};

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

@@ -0,0 +1,55 @@
+import { BaseSubscribable } from "./BaseSubscribable";
+const pipeTransforms = (initialState, extraParam, transforms) => {
+    return transforms.reduce((state, transform) => {
+        var _a;
+        return (_a = transform === null || transform === void 0 ? void 0 : transform(state, extraParam)) !== null && _a !== void 0 ? _a : state;
+    }, initialState);
+};
+export class OptimisticState extends BaseSubscribable {
+    constructor(initialState) {
+        super();
+        this._pendingTransforms = [];
+        this._baseValue = initialState;
+        this._cachedValue = initialState;
+    }
+    _updateState() {
+        this._cachedValue = this._pendingTransforms.reduce((state, transform) => {
+            return pipeTransforms(state, transform.task, [
+                transform.loading,
+                transform.optimistic,
+            ]);
+        }, this._baseValue);
+        this._notifySubscribers();
+    }
+    get baseValue() {
+        return this._baseValue;
+    }
+    get value() {
+        return this._cachedValue;
+    }
+    update(state) {
+        this._baseValue = state;
+        this._updateState();
+    }
+    async optimisticUpdate(transform) {
+        const task = transform.execute();
+        const pendingTransform = Object.assign(Object.assign({}, transform), { task });
+        try {
+            this._pendingTransforms.push(pendingTransform);
+            this._updateState();
+            const result = await task;
+            this._baseValue = pipeTransforms(this._baseValue, result, [
+                transform.optimistic,
+                transform.then,
+            ]);
+            return result;
+        }
+        finally {
+            const index = this._pendingTransforms.indexOf(pendingTransform);
+            if (index > -1) {
+                this._pendingTransforms.splice(index, 1);
+            }
+            this._updateState();
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+import { FC, PropsWithChildren, ComponentType } from "react";
+import { useAui } from "@assistant-ui/store";
+import { ThreadListRuntimeCore } from "../../../internal";
+import { BaseSubscribable } from "./BaseSubscribable";
+import { AssistantRuntime } from "../../runtime";
+type RemoteThreadListHook = () => AssistantRuntime;
+export declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
+    private useRuntimeHook;
+    private instances;
+    private useAliveThreadsKeysChanged;
+    private parent;
+    constructor(runtimeHook: RemoteThreadListHook, parent: ThreadListRuntimeCore);
+    startThreadRuntime(threadId: string): Promise<Readonly<{
+        getMessageById: (messageId: string) => {
+            parentId: string | null;
+            message: import("../../..").ThreadMessage;
+            index: number;
+        } | undefined;
+        getBranches: (messageId: string) => readonly string[];
+        switchToBranch: (branchId: string) => void;
+        append: (message: import("../../..").AppendMessage) => void;
+        startRun: (config: import("../core/ThreadRuntimeCore").StartRunConfig) => void;
+        resumeRun: (config: import("../core/ThreadRuntimeCore").ResumeRunConfig) => void;
+        cancelRun: () => void;
+        addToolResult: (options: import("..").AddToolResultOptions) => void;
+        resumeToolCall: (options: import("../core/ThreadRuntimeCore").ResumeToolCallOptions) => void;
+        speak: (messageId: string) => void;
+        stopSpeaking: () => void;
+        submitFeedback: (feedback: import("..").SubmitFeedbackOptions) => void;
+        getModelContext: () => import("../../..").ModelContext;
+        composer: import("../core/ComposerRuntimeCore").ThreadComposerRuntimeCore;
+        getEditComposer: (messageId: string) => import("../core/ComposerRuntimeCore").ComposerRuntimeCore | undefined;
+        beginEdit: (messageId: string) => void;
+        speech: import("../core/ThreadRuntimeCore").SpeechState | undefined;
+        capabilities: Readonly<import("../core/ThreadRuntimeCore").RuntimeCapabilities>;
+        isDisabled: boolean;
+        isLoading: boolean;
+        messages: readonly import("../../..").ThreadMessage[];
+        state: useAui;
+        suggestions: readonly import("..").ThreadSuggestion[];
+        extras: unknown;
+        subscribe: (callback: () => void) => import("../../..").Unsubscribe;
+        import(repository: import("..").ExportedMessageRepository): void;
+        export(): import("..").ExportedMessageRepository;
+        exportExternalState(): any;
+        importExternalState(state: any): void;
+        reset(initialMessages?: readonly import("..").ThreadMessageLike[]): void;
+        unstable_on(event: import("../core/ThreadRuntimeCore").ThreadRuntimeEventType, callback: () => void): import("../../..").Unsubscribe;
+        unstable_loadExternalState: (state: any) => void;
+    }>>;
+    getThreadRuntimeCore(threadId: string): Readonly<{
+        getMessageById: (messageId: string) => {
+            parentId: string | null;
+            message: import("../../..").ThreadMessage;
+            index: number;
+        } | undefined;
+        getBranches: (messageId: string) => readonly string[];
+        switchToBranch: (branchId: string) => void;
+        append: (message: import("../../..").AppendMessage) => void;
+        startRun: (config: import("../core/ThreadRuntimeCore").StartRunConfig) => void;
+        resumeRun: (config: import("../core/ThreadRuntimeCore").ResumeRunConfig) => void;
+        cancelRun: () => void;
+        addToolResult: (options: import("..").AddToolResultOptions) => void;
+        resumeToolCall: (options: import("../core/ThreadRuntimeCore").ResumeToolCallOptions) => void;
+        speak: (messageId: string) => void;
+        stopSpeaking: () => void;
+        submitFeedback: (feedback: import("..").SubmitFeedbackOptions) => void;
+        getModelContext: () => import("../../..").ModelContext;
+        composer: import("../core/ComposerRuntimeCore").ThreadComposerRuntimeCore;
+        getEditComposer: (messageId: string) => import("../core/ComposerRuntimeCore").ComposerRuntimeCore | undefined;
+        beginEdit: (messageId: string) => void;
+        speech: import("../core/ThreadRuntimeCore").SpeechState | undefined;
+        capabilities: Readonly<import("../core/ThreadRuntimeCore").RuntimeCapabilities>;
+        isDisabled: boolean;
+        isLoading: boolean;
+        messages: readonly import("../../..").ThreadMessage[];
+        state: useAui;
+        suggestions: readonly import("..").ThreadSuggestion[];
+        extras: unknown;
+        subscribe: (callback: () => void) => import("../../..").Unsubscribe;
+        import(repository: import("..").ExportedMessageRepository): void;
+        export(): import("..").ExportedMessageRepository;
+        exportExternalState(): any;
+        importExternalState(state: any): void;
+        reset(initialMessages?: readonly import("..").ThreadMessageLike[]): void;
+        unstable_on(event: import("../core/ThreadRuntimeCore").ThreadRuntimeEventType, callback: () => void): import("../../..").Unsubscribe;
+        unstable_loadExternalState: (state: any) => void;
+    }> | undefined;
+    stopThreadRuntime(threadId: string): void;
+    setRuntimeHook(newRuntimeHook: RemoteThreadListHook): void;
+    private _InnerActiveThreadProvider;
+    private _OuterActiveThreadProvider;
+    __internal_RenderThreadRuntimes: FC<{
+        provider: ComponentType<PropsWithChildren>;
+    }>;
+}
+export {};

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

@@ -0,0 +1,109 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useRef, useEffect, memo, useMemo, } from "react";
+import { create } from "zustand";
+import { useAui } from "@assistant-ui/store";
+import { ThreadListItemRuntimeProvider } from "../../../context/providers";
+import { BaseSubscribable } from "./BaseSubscribable";
+import { ThreadListRuntimeImpl } from "../../runtime/ThreadListRuntime";
+export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
+    constructor(runtimeHook, parent) {
+        super();
+        this.instances = new Map();
+        this.useAliveThreadsKeysChanged = create(() => ({}));
+        this._InnerActiveThreadProvider = ({ threadId }) => {
+            const { useRuntime } = this.useRuntimeHook();
+            const runtime = useRuntime();
+            const threadBinding = runtime.thread
+                .__internal_threadBinding;
+            const updateRuntime = useCallback(() => {
+                const aliveThread = this.instances.get(threadId);
+                if (!aliveThread)
+                    throw new Error("Thread not found. This is a bug in assistant-ui.");
+                aliveThread.runtime = threadBinding.getState();
+                this._notifySubscribers();
+            }, [threadId, threadBinding]);
+            const isMounted = useRef(false);
+            if (!isMounted.current) {
+                updateRuntime();
+            }
+            useEffect(() => {
+                isMounted.current = true;
+                updateRuntime();
+                return threadBinding.outerSubscribe(updateRuntime);
+            }, [threadBinding, updateRuntime]);
+            const aui = useAui();
+            const initPromiseRef = useRef(undefined);
+            useEffect(() => {
+                const runtimeCore = threadBinding.getState();
+                const setGetInitializePromise = runtimeCore["__internal_setGetInitializePromise"];
+                if (typeof setGetInitializePromise === "function") {
+                    setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);
+                }
+            }, [threadBinding]);
+            useEffect(() => {
+                return runtime.threads.main.unstable_on("initialize", () => {
+                    const state = aui.threadListItem().getState();
+                    if (state.status === "new") {
+                        initPromiseRef.current = aui.threadListItem().initialize();
+                        const dispose = runtime.thread.unstable_on("runEnd", () => {
+                            dispose();
+                            aui.threadListItem().generateTitle();
+                        });
+                    }
+                });
+            }, [runtime, aui]);
+            return null;
+        };
+        this._OuterActiveThreadProvider = memo(({ threadId, provider: Provider }) => {
+            const runtime = useMemo(() => new ThreadListRuntimeImpl(this.parent).getItemById(threadId), [threadId]);
+            return (_jsx(ThreadListItemRuntimeProvider, { runtime: runtime, children: _jsx(Provider, { children: _jsx(this._InnerActiveThreadProvider, { threadId: threadId }) }) }));
+        });
+        this.__internal_RenderThreadRuntimes = ({ provider }) => {
+            this.useAliveThreadsKeysChanged(); // trigger re-render on alive threads change
+            return Array.from(this.instances.keys()).map((threadId) => (_jsx(this._OuterActiveThreadProvider, { threadId: threadId, provider: provider }, threadId)));
+        };
+        this.parent = parent;
+        this.useRuntimeHook = create(() => ({ useRuntime: runtimeHook }));
+    }
+    startThreadRuntime(threadId) {
+        if (!this.instances.has(threadId)) {
+            this.instances.set(threadId, {});
+            this.useAliveThreadsKeysChanged.setState({}, true);
+        }
+        return new Promise((resolve, reject) => {
+            const callback = () => {
+                const instance = this.instances.get(threadId);
+                if (!instance) {
+                    dispose();
+                    reject(new Error("Thread was deleted before runtime was started"));
+                }
+                else if (!instance.runtime) {
+                    return; // misc update
+                }
+                else {
+                    dispose();
+                    resolve(instance.runtime);
+                }
+            };
+            const dispose = this.subscribe(callback);
+            callback();
+        });
+    }
+    getThreadRuntimeCore(threadId) {
+        const instance = this.instances.get(threadId);
+        if (!instance)
+            return undefined;
+        return instance.runtime;
+    }
+    stopThreadRuntime(threadId) {
+        this.instances.delete(threadId);
+        this.useAliveThreadsKeysChanged.setState({}, true);
+    }
+    setRuntimeHook(newRuntimeHook) {
+        const prevRuntimeHook = this.useRuntimeHook.getState().useRuntime;
+        if (prevRuntimeHook !== newRuntimeHook) {
+            this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);
+        }
+    }
+}

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

@@ -0,0 +1,139 @@
+import { ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
+import { RemoteThreadInitializeResponse, RemoteThreadListOptions } from "./types";
+import { BaseSubscribable } from "./BaseSubscribable";
+import { FC } from "react";
+import { AssistantMessageStream } from "assistant-stream";
+import { ModelContextProvider } from "../../../model-context";
+type RemoteThreadData = {
+    readonly id: string;
+    readonly remoteId: undefined;
+    readonly externalId: undefined;
+    readonly status: "new";
+    readonly title: undefined;
+} | {
+    readonly id: string;
+    readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
+    readonly remoteId: undefined;
+    readonly externalId: undefined;
+    readonly status: "regular" | "archived";
+    readonly title?: string | undefined;
+} | {
+    readonly id: string;
+    readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
+    readonly remoteId: string;
+    readonly externalId: string | undefined;
+    readonly status: "regular" | "archived";
+    readonly title?: string | undefined;
+};
+type THREAD_MAPPING_ID = string & {
+    __brand: "THREAD_MAPPING_ID";
+};
+export declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable implements ThreadListRuntimeCore {
+    private readonly contextProvider;
+    private _options;
+    private readonly _hookManager;
+    private _loadThreadsPromise;
+    private _mainThreadId;
+    private readonly _state;
+    get threadItems(): Readonly<Record<THREAD_MAPPING_ID, RemoteThreadData>>;
+    getLoadThreadsPromise(): Promise<void>;
+    constructor(options: RemoteThreadListOptions, contextProvider: ModelContextProvider);
+    private useProvider;
+    __internal_setOptions(options: RemoteThreadListOptions): void;
+    __internal_load(): void;
+    get isLoading(): boolean;
+    get threadIds(): readonly string[];
+    get archivedThreadIds(): readonly string[];
+    get newThreadId(): string | undefined;
+    get mainThreadId(): string;
+    getMainThreadRuntimeCore(): Readonly<{
+        getMessageById: (messageId: string) => {
+            parentId: string | null;
+            message: import("../../..").ThreadMessage;
+            index: number;
+        } | undefined;
+        getBranches: (messageId: string) => readonly string[];
+        switchToBranch: (branchId: string) => void;
+        append: (message: import("../../..").AppendMessage) => void;
+        startRun: (config: import("../core/ThreadRuntimeCore").StartRunConfig) => void;
+        resumeRun: (config: import("../core/ThreadRuntimeCore").ResumeRunConfig) => void;
+        cancelRun: () => void;
+        addToolResult: (options: import("..").AddToolResultOptions) => void;
+        resumeToolCall: (options: import("../core/ThreadRuntimeCore").ResumeToolCallOptions) => void;
+        speak: (messageId: string) => void;
+        stopSpeaking: () => void;
+        submitFeedback: (feedback: import("..").SubmitFeedbackOptions) => void;
+        getModelContext: () => import("../../..").ModelContext;
+        composer: import("../core/ComposerRuntimeCore").ThreadComposerRuntimeCore;
+        getEditComposer: (messageId: string) => import("../core/ComposerRuntimeCore").ComposerRuntimeCore | undefined;
+        beginEdit: (messageId: string) => void;
+        speech: import("../core/ThreadRuntimeCore").SpeechState | undefined;
+        capabilities: Readonly<import("../core/ThreadRuntimeCore").RuntimeCapabilities>;
+        isDisabled: boolean;
+        isLoading: boolean;
+        messages: readonly import("../../..").ThreadMessage[];
+        state: AssistantMessageStream;
+        suggestions: readonly import("..").ThreadSuggestion[];
+        extras: unknown;
+        subscribe: (callback: () => void) => import("../../..").Unsubscribe;
+        import(repository: import("..").ExportedMessageRepository): void;
+        export(): import("..").ExportedMessageRepository;
+        exportExternalState(): any;
+        importExternalState(state: any): void;
+        reset(initialMessages?: readonly import("..").ThreadMessageLike[]): void;
+        unstable_on(event: import("../core/ThreadRuntimeCore").ThreadRuntimeEventType, callback: () => void): import("../../..").Unsubscribe;
+        unstable_loadExternalState: (state: any) => void;
+    }>;
+    getThreadRuntimeCore(threadIdOrRemoteId: string): Readonly<{
+        getMessageById: (messageId: string) => {
+            parentId: string | null;
+            message: import("../../..").ThreadMessage;
+            index: number;
+        } | undefined;
+        getBranches: (messageId: string) => readonly string[];
+        switchToBranch: (branchId: string) => void;
+        append: (message: import("../../..").AppendMessage) => void;
+        startRun: (config: import("../core/ThreadRuntimeCore").StartRunConfig) => void;
+        resumeRun: (config: import("../core/ThreadRuntimeCore").ResumeRunConfig) => void;
+        cancelRun: () => void;
+        addToolResult: (options: import("..").AddToolResultOptions) => void;
+        resumeToolCall: (options: import("../core/ThreadRuntimeCore").ResumeToolCallOptions) => void;
+        speak: (messageId: string) => void;
+        stopSpeaking: () => void;
+        submitFeedback: (feedback: import("..").SubmitFeedbackOptions) => void;
+        getModelContext: () => import("../../..").ModelContext;
+        composer: import("../core/ComposerRuntimeCore").ThreadComposerRuntimeCore;
+        getEditComposer: (messageId: string) => import("../core/ComposerRuntimeCore").ComposerRuntimeCore | undefined;
+        beginEdit: (messageId: string) => void;
+        speech: import("../core/ThreadRuntimeCore").SpeechState | undefined;
+        capabilities: Readonly<import("../core/ThreadRuntimeCore").RuntimeCapabilities>;
+        isDisabled: boolean;
+        isLoading: boolean;
+        messages: readonly import("../../..").ThreadMessage[];
+        state: AssistantMessageStream;
+        suggestions: readonly import("..").ThreadSuggestion[];
+        extras: unknown;
+        subscribe: (callback: () => void) => import("../../..").Unsubscribe;
+        import(repository: import("..").ExportedMessageRepository): void;
+        export(): import("..").ExportedMessageRepository;
+        exportExternalState(): any;
+        importExternalState(state: any): void;
+        reset(initialMessages?: readonly import("..").ThreadMessageLike[]): void;
+        unstable_on(event: import("../core/ThreadRuntimeCore").ThreadRuntimeEventType, callback: () => void): import("../../..").Unsubscribe;
+        unstable_loadExternalState: (state: any) => void;
+    }>;
+    getItemById(threadIdOrRemoteId: string): RemoteThreadData | undefined;
+    switchToThread(threadIdOrRemoteId: string): Promise<void>;
+    switchToNewThread(): Promise<void>;
+    initialize: (threadId: string) => Promise<RemoteThreadInitializeResponse>;
+    generateTitle: (threadId: string) => Promise<void>;
+    rename(threadIdOrRemoteId: string, newTitle: string): Promise<void>;
+    private _ensureThreadIsNotMain;
+    archive(threadIdOrRemoteId: string): Promise<void>;
+    unarchive(threadIdOrRemoteId: string): Promise<void>;
+    delete(threadIdOrRemoteId: string): Promise<void>;
+    detach(threadIdOrRemoteId: string): Promise<void>;
+    private useBoundIds;
+    __internal_RenderComponent: FC;
+}
+export {};