ikoncomponents 1.6.5 → 1.6.8

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

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

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

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

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

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

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