ikoncomponents 1.6.3 → 1.6.5

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

@@ -0,0 +1,38 @@
+import type { FileMessagePart, MessageStatus, ReasoningMessagePart, RunConfig, SourceMessagePart, TextMessagePart, ThreadAssistantMessagePart, ThreadMessage, ThreadStep, ToolCallMessagePart } from "../../../types/AssistantTypes";
+import type { ModelContext } from "../../../model-context/ModelContextTypes";
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+export type ChatModelRunUpdate = {
+    readonly content: readonly ThreadAssistantMessagePart[];
+    readonly metadata?: Record<string, unknown>;
+};
+export type ChatModelRunResult = {
+    readonly content?: readonly ThreadAssistantMessagePart[] | undefined;
+    readonly status?: MessageStatus | undefined;
+    readonly metadata?: {
+        readonly unstable_state?: ReadonlyJSONValue;
+        readonly unstable_annotations?: readonly ReadonlyJSONValue[] | undefined;
+        readonly unstable_data?: readonly ReadonlyJSONValue[] | undefined;
+        readonly steps?: readonly ThreadStep[] | undefined;
+        readonly custom?: Record<string, unknown> | undefined;
+    };
+};
+export type CoreChatModelRunResult = Omit<ChatModelRunResult, "content"> & {
+    readonly content: readonly (TextMessagePart | ReasoningMessagePart | ToolCallMessagePart | SourceMessagePart | FileMessagePart)[];
+};
+export type ChatModelRunOptions = {
+    readonly messages: readonly ThreadMessage[];
+    readonly runConfig: RunConfig;
+    readonly abortSignal: AbortSignal;
+    readonly context: ModelContext;
+    /**
+     * @deprecated This field was renamed to `context`.
+     */
+    readonly config: ModelContext;
+    readonly unstable_assistantMessageId?: string | undefined;
+    readonly unstable_threadId?: string | undefined;
+    readonly unstable_parentId?: string | null | undefined;
+    unstable_getMessage(): ThreadMessage;
+};
+export type ChatModelAdapter = {
+    run(options: ChatModelRunOptions): Promise<ChatModelRunResult> | AsyncGenerator<ChatModelRunResult, void>;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import { BaseAssistantRuntimeCore } from "../core/BaseAssistantRuntimeCore";
+import { LocalRuntimeOptionsBase } from "./LocalRuntimeOptions";
+import { LocalThreadListRuntimeCore } from "./LocalThreadListRuntimeCore";
+import { ThreadMessageLike } from "../external-store";
+export declare class LocalRuntimeCore extends BaseAssistantRuntimeCore {
+    readonly threads: LocalThreadListRuntimeCore;
+    readonly Provider: undefined;
+    private _options;
+    constructor(options: LocalRuntimeOptionsBase, initialMessages: readonly ThreadMessageLike[] | undefined);
+}

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

@@ -0,0 +1,19 @@
+import { BaseAssistantRuntimeCore } from "../core/BaseAssistantRuntimeCore";
+import { LocalThreadRuntimeCore } from "./LocalThreadRuntimeCore";
+import { LocalThreadListRuntimeCore } from "./LocalThreadListRuntimeCore";
+import { ExportedMessageRepository } from "../utils/MessageRepository";
+export class LocalRuntimeCore extends BaseAssistantRuntimeCore {
+    constructor(options, initialMessages) {
+        super();
+        this.Provider = undefined;
+        this._options = options;
+        this.threads = new LocalThreadListRuntimeCore(() => {
+            return new LocalThreadRuntimeCore(this._contextProvider, this._options);
+        });
+        if (initialMessages) {
+            this.threads
+                .getMainThreadRuntimeCore()
+                .import(ExportedMessageRepository.fromArray(initialMessages));
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { ThreadHistoryAdapter } from "../adapters/thread-history/ThreadHistoryAdapter";
+import type { AttachmentAdapter } from "../adapters/attachment/AttachmentAdapter";
+import type { ThreadMessageLike } from "../external-store";
+import type { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
+import type { SpeechSynthesisAdapter, DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import type { ChatModelAdapter } from "./ChatModelAdapter";
+import type { AssistantCloud } from "assistant-cloud";
+import type { SuggestionAdapter } from "../adapters";
+export type LocalRuntimeOptionsBase = {
+    maxSteps?: number | undefined;
+    adapters: {
+        chatModel: ChatModelAdapter;
+        history?: ThreadHistoryAdapter | undefined;
+        attachments?: AttachmentAdapter | undefined;
+        speech?: SpeechSynthesisAdapter | undefined;
+        dictation?: DictationAdapter | undefined;
+        feedback?: FeedbackAdapter | undefined;
+        suggestion?: SuggestionAdapter | undefined;
+    };
+    /**
+     * Names of tools that are allowed to interrupt the run in order to wait for human/external approval.
+     */
+    unstable_humanToolNames?: string[] | undefined;
+};
+export type LocalRuntimeOptions = Omit<LocalRuntimeOptionsBase, "adapters"> & {
+    cloud?: AssistantCloud | undefined;
+    initialMessages?: readonly ThreadMessageLike[] | undefined;
+    adapters?: Omit<LocalRuntimeOptionsBase["adapters"], "chatModel"> | undefined;
+};
+export declare const splitLocalRuntimeOptions: <T extends LocalRuntimeOptions>(options: T) => {
+    localRuntimeOptions: {
+        cloud: any;
+        initialMessages: readonly ThreadMessageLike[] | undefined;
+        maxSteps: number | undefined;
+        adapters: Omit<{
+            chatModel: ChatModelAdapter;
+            history?: ThreadHistoryAdapter | undefined;
+            attachments?: AttachmentAdapter | undefined;
+            speech?: SpeechSynthesisAdapter | undefined;
+            dictation?: DictationAdapter | undefined;
+            feedback?: FeedbackAdapter | undefined;
+            suggestion?: SuggestionAdapter | undefined;
+        }, "chatModel"> | undefined;
+        unstable_humanToolNames: string[] | undefined;
+    };
+    otherOptions: Omit<T, "adapters" | "maxSteps" | "unstable_humanToolNames" | "cloud" | "initialMessages">;
+};

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

@@ -0,0 +1,24 @@
+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;
+};
+export const splitLocalRuntimeOptions = (options) => {
+    const { cloud, initialMessages, maxSteps, adapters, unstable_humanToolNames } = options, rest = __rest(options, ["cloud", "initialMessages", "maxSteps", "adapters", "unstable_humanToolNames"]);
+    return {
+        localRuntimeOptions: {
+            cloud,
+            initialMessages,
+            maxSteps,
+            adapters,
+            unstable_humanToolNames,
+        },
+        otherOptions: rest,
+    };
+};

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

@@ -0,0 +1,45 @@
+import { ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
+import { BaseSubscribable } from "../remote-thread-list/BaseSubscribable";
+import { LocalThreadRuntimeCore } from "./LocalThreadRuntimeCore";
+export type LocalThreadFactory = () => LocalThreadRuntimeCore;
+export declare class LocalThreadListRuntimeCore extends BaseSubscribable implements ThreadListRuntimeCore {
+    private _mainThread;
+    constructor(_threadFactory: LocalThreadFactory);
+    get isLoading(): boolean;
+    getMainThreadRuntimeCore(): LocalThreadRuntimeCore;
+    get newThreadId(): string;
+    get threadIds(): readonly string[];
+    get archivedThreadIds(): readonly string[];
+    get mainThreadId(): string;
+    get threadItems(): Readonly<{
+        __DEFAULT_ID__: {
+            id: string;
+            remoteId: undefined;
+            externalId: undefined;
+            status: "regular";
+            title: undefined;
+        };
+    }>;
+    getThreadRuntimeCore(): never;
+    getLoadThreadsPromise(): Promise<void>;
+    getItemById(threadId: string): {
+        status: "regular";
+        id: string;
+        remoteId: string;
+        externalId: undefined;
+        title: undefined;
+        isMain: boolean;
+    };
+    switchToThread(): Promise<void>;
+    switchToNewThread(): Promise<void>;
+    rename(): Promise<void>;
+    archive(): Promise<void>;
+    detach(): Promise<void>;
+    unarchive(): Promise<void>;
+    delete(): Promise<void>;
+    initialize(threadId: string): Promise<{
+        remoteId: string;
+        externalId: string | undefined;
+    }>;
+    generateTitle(): never;
+}

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

@@ -0,0 +1,85 @@
+import { BaseSubscribable } from "../remote-thread-list/BaseSubscribable";
+const EMPTY_ARRAY = Object.freeze([]);
+const DEFAULT_THREAD_ID = "__DEFAULT_ID__";
+const DEFAULT_THREAD_DATA = Object.freeze({
+    [DEFAULT_THREAD_ID]: {
+        id: DEFAULT_THREAD_ID,
+        remoteId: undefined,
+        externalId: undefined,
+        status: "regular",
+        title: undefined,
+    },
+});
+export class LocalThreadListRuntimeCore extends BaseSubscribable {
+    constructor(_threadFactory) {
+        super();
+        this._mainThread = _threadFactory();
+    }
+    get isLoading() {
+        return false;
+    }
+    getMainThreadRuntimeCore() {
+        return this._mainThread;
+    }
+    get newThreadId() {
+        throw new Error("Method not implemented.");
+    }
+    get threadIds() {
+        throw EMPTY_ARRAY;
+    }
+    get archivedThreadIds() {
+        throw EMPTY_ARRAY;
+    }
+    get mainThreadId() {
+        return DEFAULT_THREAD_ID;
+    }
+    get threadItems() {
+        return DEFAULT_THREAD_DATA;
+    }
+    getThreadRuntimeCore() {
+        throw new Error("Method not implemented.");
+    }
+    getLoadThreadsPromise() {
+        throw new Error("Method not implemented.");
+    }
+    getItemById(threadId) {
+        if (threadId === this.mainThreadId) {
+            return {
+                status: "regular",
+                id: this.mainThreadId,
+                remoteId: this.mainThreadId,
+                externalId: undefined,
+                title: undefined,
+                isMain: true,
+            };
+        }
+        throw new Error("Method not implemented");
+    }
+    async switchToThread() {
+        throw new Error("Method not implemented.");
+    }
+    switchToNewThread() {
+        throw new Error("Method not implemented.");
+    }
+    rename() {
+        throw new Error("Method not implemented.");
+    }
+    archive() {
+        throw new Error("Method not implemented.");
+    }
+    detach() {
+        throw new Error("Method not implemented.");
+    }
+    unarchive() {
+        throw new Error("Method not implemented.");
+    }
+    delete() {
+        throw new Error("Method not implemented.");
+    }
+    initialize(threadId) {
+        return Promise.resolve({ remoteId: threadId, externalId: undefined });
+    }
+    generateTitle() {
+        throw new Error("Method not implemented.");
+    }
+}

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

@@ -0,0 +1,58 @@
+import type { AppendMessage } from "../../../types";
+import type { ChatModelAdapter } from "./ChatModelAdapter";
+import type { LocalRuntimeOptionsBase } from "./LocalRuntimeOptions";
+import type { AddToolResultOptions, ResumeToolCallOptions, ThreadSuggestion, ThreadRuntimeCore, StartRunConfig, ResumeRunConfig } from "../core/ThreadRuntimeCore";
+import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
+import type { ModelContextProvider } from "../../../model-context";
+export declare class LocalThreadRuntimeCore extends BaseThreadRuntimeCore implements ThreadRuntimeCore {
+    readonly capabilities: {
+        switchToBranch: boolean;
+        switchBranchDuringRun: boolean;
+        edit: boolean;
+        reload: boolean;
+        cancel: boolean;
+        unstable_copy: boolean;
+        speech: boolean;
+        dictation: boolean;
+        attachments: boolean;
+        feedback: boolean;
+    };
+    private abortController;
+    readonly isDisabled = false;
+    private _isLoading;
+    get isLoading(): boolean;
+    private _suggestions;
+    private _suggestionsController;
+    get suggestions(): readonly ThreadSuggestion[];
+    get adapters(): {
+        chatModel: ChatModelAdapter;
+        history?: import("..").ThreadHistoryAdapter | undefined;
+        attachments?: import("..").AttachmentAdapter | undefined;
+        speech?: import("..").SpeechSynthesisAdapter | undefined;
+        dictation?: import("..").DictationAdapter | undefined;
+        feedback?: import("..").FeedbackAdapter | undefined;
+        suggestion?: import("..").SuggestionAdapter | undefined;
+    };
+    constructor(contextProvider: ModelContextProvider, options: LocalRuntimeOptionsBase);
+    private _options;
+    private _lastRunConfig;
+    private _getThreadId?;
+    __internal_setGetThreadId(getThreadId: () => string | undefined): void;
+    private _getInitializePromise?;
+    __internal_setGetInitializePromise(getPromise: () => Promise<unknown> | undefined): void;
+    get extras(): undefined;
+    __internal_setOptions(options: LocalRuntimeOptionsBase): void;
+    private _loadPromise;
+    __internal_load(): Promise<void>;
+    append(message: AppendMessage): Promise<void>;
+    resumeRun({ stream, ...startConfig }: ResumeRunConfig): Promise<void>;
+    exportExternalState(): any;
+    importExternalState(): void;
+    unstable_loadExternalState(): void;
+    startRun({ parentId, runConfig }: StartRunConfig, runCallback?: ChatModelAdapter["run"]): Promise<void>;
+    private performRoundtrip;
+    detach(): void;
+    cancelRun(): void;
+    addToolResult({ messageId, toolCallId, result, isError, artifact, }: AddToolResultOptions): void;
+    resumeToolCall(_options: ResumeToolCallOptions): void;
+}