ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/speech/WebSpeechSynthesisAdapter.d.ts

@@ -0,0 +1,4 @@
+import { SpeechSynthesisAdapter } from "./SpeechAdapterTypes";
+export declare class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
+    speak(text: string): SpeechSynthesisAdapter.Utterance;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/speech/WebSpeechSynthesisAdapter.js

@@ -0,0 +1,41 @@
+export class WebSpeechSynthesisAdapter {
+    speak(text) {
+        const utterance = new SpeechSynthesisUtterance(text);
+        const subscribers = new Set();
+        const handleEnd = (reason, error) => {
+            if (res.status.type === "ended")
+                return;
+            res.status = { type: "ended", reason, error };
+            subscribers.forEach((handler) => handler());
+        };
+        utterance.addEventListener("end", () => handleEnd("finished"));
+        utterance.addEventListener("error", (e) => handleEnd("error", e.error));
+        window.speechSynthesis.speak(utterance);
+        const res = {
+            status: { type: "running" },
+            cancel: () => {
+                window.speechSynthesis.cancel();
+                handleEnd("cancelled");
+            },
+            subscribe: (callback) => {
+                if (res.status.type === "ended") {
+                    let cancelled = false;
+                    queueMicrotask(() => {
+                        if (!cancelled)
+                            callback();
+                    });
+                    return () => {
+                        cancelled = true;
+                    };
+                }
+                else {
+                    subscribers.add(callback);
+                    return () => {
+                        subscribers.delete(callback);
+                    };
+                }
+            },
+        };
+        return res;
+    }
+}

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

@@ -0,0 +1,3 @@
+export type { SpeechSynthesisAdapter, DictationAdapter, } from "./SpeechAdapterTypes";
+export { WebSpeechSynthesisAdapter } from "./WebSpeechSynthesisAdapter";
+export { WebSpeechDictationAdapter } from "./WebSpeechDictationAdapter";

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

@@ -0,0 +1,2 @@
+export { WebSpeechSynthesisAdapter } from "./WebSpeechSynthesisAdapter";
+export { WebSpeechDictationAdapter } from "./WebSpeechDictationAdapter";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/suggestion/SuggestionAdapter.d.ts

@@ -0,0 +1,9 @@
+import { ThreadMessage } from "../../../../types/AssistantTypes";
+import { ThreadSuggestion } from "../../core";
+type SuggestionAdapterGenerateOptions = {
+    messages: readonly ThreadMessage[];
+};
+export type SuggestionAdapter = {
+    generate: (options: SuggestionAdapterGenerateOptions) => Promise<readonly ThreadSuggestion[]> | AsyncGenerator<readonly ThreadSuggestion[], void>;
+};
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/suggestion/SuggestionAdapter.js

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

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

@@ -0,0 +1 @@
+export type { SuggestionAdapter } from "./SuggestionAdapter";

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

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/thread-history/MessageFormatAdapter.d.ts

@@ -0,0 +1,20 @@
+export interface MessageStorageEntry<TPayload> {
+    id: string;
+    parent_id: string | null;
+    format: string;
+    content: TPayload;
+}
+export interface MessageFormatItem<TMessage> {
+    parentId: string | null;
+    message: TMessage;
+}
+export interface MessageFormatRepository<TMessage> {
+    headId?: string | null;
+    messages: MessageFormatItem<TMessage>[];
+}
+export interface MessageFormatAdapter<TMessage, TStorageFormat> {
+    format: string;
+    encode(item: MessageFormatItem<TMessage>): TStorageFormat;
+    decode(stored: MessageStorageEntry<TStorageFormat>): MessageFormatItem<TMessage>;
+    getId(message: TMessage): string;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/thread-history/MessageFormatAdapter.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/thread-history/ThreadHistoryAdapter.d.ts

@@ -0,0 +1,15 @@
+import { ChatModelRunOptions, ChatModelRunResult } from "../../local";
+import { ExportedMessageRepository, ExportedMessageRepositoryItem } from "../../utils/MessageRepository";
+import { MessageFormatAdapter, MessageFormatItem, MessageFormatRepository } from "./MessageFormatAdapter";
+export type GenericThreadHistoryAdapter<TMessage> = {
+    load(): Promise<MessageFormatRepository<TMessage>>;
+    append(item: MessageFormatItem<TMessage>): Promise<void>;
+};
+export type ThreadHistoryAdapter = {
+    load(): Promise<ExportedMessageRepository & {
+        unstable_resume?: boolean;
+    }>;
+    resume?(options: ChatModelRunOptions): AsyncGenerator<ChatModelRunResult, void, unknown>;
+    append(item: ExportedMessageRepositoryItem): Promise<void>;
+    withFormat?<TMessage, TStorageFormat>(formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>): GenericThreadHistoryAdapter<TMessage>;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/thread-history/ThreadHistoryAdapter.js

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

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

@@ -0,0 +1,2 @@
+export * from "./MessageFormatAdapter";
+export * from "./ThreadHistoryAdapter";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/thread-history/index.js

@@ -0,0 +1,2 @@
+export * from "./MessageFormatAdapter";
+export * from "./ThreadHistoryAdapter";

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

@@ -0,0 +1,11 @@
+import { AssistantTransportCommand, CommandQueueState, QueuedCommand } from "./types";
+export declare const createInitialQueueState: () => CommandQueueState;
+export declare const useCommandQueue: (opts: {
+    onQueue: () => void;
+}) => {
+    state: CommandQueueState;
+    enqueue: (command: AssistantTransportCommand) => void;
+    flush: () => QueuedCommand[];
+    markDelivered: () => void;
+    reset: () => void;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/commandQueue.js

@@ -0,0 +1,47 @@
+import { useState, useCallback, useRef, useEffect } from "react";
+export const createInitialQueueState = () => ({
+    queued: [],
+    inTransit: [],
+});
+export const useCommandQueue = (opts) => {
+    const onQueueRef = useRef(opts.onQueue);
+    useEffect(() => {
+        onQueueRef.current = opts.onQueue;
+    });
+    const [, rerender] = useState(0);
+    const queueStateRef = useRef(createInitialQueueState());
+    const enqueue = (command) => {
+        queueStateRef.current = {
+            queued: [...queueStateRef.current.queued, command],
+            inTransit: queueStateRef.current.inTransit,
+        };
+        rerender((prev) => prev + 1);
+        onQueueRef.current();
+    };
+    const flush = () => {
+        if (queueStateRef.current.queued.length === 0)
+            return [];
+        const queued = queueStateRef.current.queued;
+        queueStateRef.current = {
+            queued: [],
+            inTransit: [...queueStateRef.current.inTransit, ...queued],
+        };
+        rerender((prev) => prev + 1);
+        return queued;
+    };
+    const markDelivered = () => {
+        queueStateRef.current = Object.assign(Object.assign({}, queueStateRef.current), { inTransit: [] });
+        rerender((prev) => prev + 1);
+    };
+    const reset = useCallback(() => {
+        queueStateRef.current = createInitialQueueState();
+        rerender((prev) => prev + 1);
+    }, []);
+    return {
+        state: queueStateRef.current,
+        enqueue,
+        flush,
+        markDelivered,
+        reset,
+    };
+};

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

@@ -0,0 +1,2 @@
+export { useAssistantTransportRuntime, useAssistantTransportSendCommand, useAssistantTransportState, } from "./useAssistantTransportRuntime";
+export type { AssistantTransportConnectionMetadata, AssistantTransportCommand, AssistantTransportProtocol, } from "./types";

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

@@ -0,0 +1 @@
+export { useAssistantTransportRuntime, useAssistantTransportSendCommand, useAssistantTransportState, } from "./useAssistantTransportRuntime";

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

@@ -0,0 +1,11 @@
+export type RunManager = Readonly<{
+    isRunning: boolean;
+    schedule: () => void;
+    cancel: () => void;
+}>;
+export declare function useRunManager(config: {
+    onRun: (signal: AbortSignal) => Promise<void>;
+    onFinish?: (() => void) | undefined;
+    onCancel?: (() => void) | undefined;
+    onError?: ((error: Error) => void | Promise<void>) | undefined;
+}): RunManager;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/runManager.js

@@ -0,0 +1,62 @@
+import { useCallback, useRef, useState } from "react";
+import { useLatestRef } from "./useLatestRef";
+export function useRunManager(config) {
+    const [isRunning, setIsRunning] = useState(false);
+    const stateRef = useRef({
+        pending: false,
+        abortController: null,
+    });
+    const onRunRef = useLatestRef(config.onRun);
+    const onFinishRef = useLatestRef(config.onFinish);
+    const onCancelRef = useLatestRef(config.onCancel);
+    const onErrorRef = useLatestRef(config.onError);
+    const startRun = useCallback(() => {
+        setIsRunning(true);
+        stateRef.current.pending = false;
+        const ac = new AbortController();
+        stateRef.current.abortController = ac;
+        queueMicrotask(async () => {
+            var _a, _b, _c;
+            try {
+                await onRunRef.current(ac.signal);
+            }
+            catch (error) {
+                stateRef.current.pending = false;
+                if (ac.signal.aborted) {
+                    (_a = onCancelRef.current) === null || _a === void 0 ? void 0 : _a.call(onCancelRef);
+                }
+                else {
+                    await ((_b = onErrorRef.current) === null || _b === void 0 ? void 0 : _b.call(onErrorRef, error));
+                }
+            }
+            finally {
+                (_c = onFinishRef.current) === null || _c === void 0 ? void 0 : _c.call(onFinishRef);
+                if (stateRef.current.pending) {
+                    startRun();
+                }
+                else {
+                    setIsRunning(false);
+                    stateRef.current.abortController = null;
+                }
+            }
+        });
+    }, [onRunRef, onFinishRef, onErrorRef, onCancelRef]);
+    const schedule = useCallback(() => {
+        if (stateRef.current.abortController) {
+            // Coalesce multiple schedules while running into a single follow-up run.
+            stateRef.current.pending = true;
+            return;
+        }
+        startRun();
+    }, [startRun]);
+    const cancel = useCallback(() => {
+        var _a;
+        stateRef.current.pending = false;
+        (_a = stateRef.current.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+    }, []);
+    return {
+        isRunning,
+        schedule,
+        cancel,
+    };
+}

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

@@ -0,0 +1,83 @@
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+import { ThreadMessage } from "../../../types";
+import { AttachmentAdapter, ThreadHistoryAdapter } from "..";
+import { UserCommands } from "../../../augmentations";
+import type { ToolExecutionStatus } from "./useToolInvocations";
+export type TextPart = {
+    readonly type: "text";
+    readonly text: string;
+};
+export type ImagePart = {
+    readonly type: "image";
+    readonly image: string;
+};
+export type UserMessagePart = TextPart | ImagePart;
+export type UserMessage = {
+    readonly role: "user";
+    readonly parts: readonly UserMessagePart[];
+};
+export type AssistantMessage = {
+    readonly role: "assistant";
+    readonly parts: readonly TextPart[];
+};
+export type AddMessageCommand = {
+    readonly type: "add-message";
+    readonly message: UserMessage | AssistantMessage;
+};
+export type AddToolResultCommand = {
+    readonly type: "add-tool-result";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly result: ReadonlyJSONValue;
+    readonly isError: boolean;
+    readonly artifact?: ReadonlyJSONValue;
+};
+export type AssistantTransportCommand = AddMessageCommand | AddToolResultCommand | UserCommands;
+export type AssistantTransportState = {
+    readonly messages: readonly ThreadMessage[];
+    readonly state?: ReadonlyJSONValue;
+    readonly isRunning: boolean;
+};
+export type AssistantTransportConnectionMetadata = {
+    pendingCommands: AssistantTransportCommand[];
+    isSending: boolean;
+    toolStatuses: Record<string, ToolExecutionStatus>;
+};
+export type AssistantTransportStateConverter<T> = (state: T, connectionMetadata: AssistantTransportConnectionMetadata) => AssistantTransportState;
+export type CommandQueueState = {
+    queued: AssistantTransportCommand[];
+    inTransit: AssistantTransportCommand[];
+};
+export type QueuedCommand = AssistantTransportCommand;
+export type HeadersValue = Record<string, string> | Headers;
+export type AssistantTransportProtocol = "data-stream" | "assistant-transport";
+export type AssistantTransportOptions<T> = {
+    initialState: T;
+    api: string;
+    resumeApi?: string;
+    protocol?: AssistantTransportProtocol;
+    converter: AssistantTransportStateConverter<T>;
+    headers: HeadersValue | (() => Promise<HeadersValue>);
+    body?: object | (() => Promise<object | undefined>);
+    onResponse?: (response: Response) => void;
+    onFinish?: () => void;
+    onError?: (error: Error, params: {
+        commands: AssistantTransportCommand[];
+        updateState: (updater: (state: T) => T) => void;
+    }) => void | Promise<void>;
+    /**
+     * Called when commands are cancelled.
+     *
+     * When an error occurs, queued commands are automatically cancelled after `onError` settles.
+     * In this case, the `error` parameter contains the error that caused the cancellation.
+     */
+    onCancel?: (params: {
+        commands: AssistantTransportCommand[];
+        updateState: (updater: (state: T) => T) => void;
+        error?: Error;
+    }) => void;
+    adapters?: {
+        attachments?: AttachmentAdapter | undefined;
+        history?: ThreadHistoryAdapter | undefined;
+    };
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/types.js

@@ -0,0 +1,2 @@
+export {};
+// (no task or stream-specific types needed in this module)

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

@@ -0,0 +1,10 @@
+import { AssistantRuntime } from "../../runtime/AssistantRuntime";
+import { AssistantTransportOptions, AssistantTransportCommand } from "./types";
+import { UserExternalState } from "../../../augmentations";
+export declare const useAssistantTransportSendCommand: () => (command: AssistantTransportCommand) => void;
+export declare function useAssistantTransportState(): UserExternalState;
+export declare function useAssistantTransportState<T>(selector: (state: UserExternalState) => T): T;
+/**
+ * @alpha This is an experimental API that is subject to change.
+ */
+export declare const useAssistantTransportRuntime: <T>(options: AssistantTransportOptions<T>) => AssistantRuntime;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransportRuntime.js

@@ -0,0 +1,249 @@
+"use client";
+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 { asAsyncIterableStream, } from "assistant-stream/utils";
+import { useExternalStoreRuntime } from "../external-store/useExternalStoreRuntime";
+import { useState, useRef, useMemo } from "react";
+import { AssistantMessageAccumulator, DataStreamDecoder, AssistantTransportDecoder, unstable_createInitialMessage as createInitialMessage, toToolsJSONSchema, } from "assistant-stream";
+import { useCommandQueue } from "./commandQueue";
+import { useRunManager } from "./runManager";
+import { useConvertedState } from "./useConvertedState";
+import { useToolInvocations } from "./useToolInvocations";
+import { createRequestHeaders } from "./utils";
+import { useRemoteThreadListRuntime } from "../remote-thread-list/useRemoteThreadListRuntime";
+import { InMemoryThreadListAdapter } from "../remote-thread-list/adapter/in-memory";
+import { useAui, useAuiState } from "@assistant-ui/store";
+const symbolAssistantTransportExtras = Symbol("assistant-transport-extras");
+const asAssistantTransportExtras = (extras) => {
+    if (typeof extras !== "object" ||
+        extras == null ||
+        !(symbolAssistantTransportExtras in extras))
+        throw new Error("This method can only be called when you are using useAssistantTransportRuntime");
+    return extras;
+};
+export const useAssistantTransportSendCommand = () => {
+    const aui = useAui();
+    return (command) => {
+        const extras = aui.thread().getState().extras;
+        const transportExtras = asAssistantTransportExtras(extras);
+        transportExtras.sendCommand(command);
+    };
+};
+export function useAssistantTransportState(selector = (t) => t) {
+    return useAuiState(({ thread }) => selector(asAssistantTransportExtras(thread.extras).state));
+}
+const useAssistantTransportThreadRuntime = (options) => {
+    const agentStateRef = useRef(options.initialState);
+    const [, rerender] = useState(0);
+    const resumeFlagRef = useRef(false);
+    const parentIdRef = useRef(undefined);
+    const commandQueue = useCommandQueue({
+        onQueue: () => runManager.schedule(),
+    });
+    const threadId = useAuiState(({ threadListItem }) => threadListItem.remoteId);
+    const runManager = useRunManager({
+        onRun: async (signal) => {
+            var _a, e_1, _b, _c;
+            var _d, _e, _f;
+            const isResume = resumeFlagRef.current;
+            resumeFlagRef.current = false;
+            const commands = isResume ? [] : commandQueue.flush();
+            if (commands.length === 0 && !isResume)
+                throw new Error("No commands to send");
+            const headers = await createRequestHeaders(options.headers);
+            const bodyValue = typeof options.body === "function"
+                ? await options.body()
+                : options.body;
+            const context = runtime.thread.getModelContext();
+            const response = await fetch(isResume ? options.resumeApi : options.api, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(Object.assign(Object.assign(Object.assign(Object.assign({ commands, state: agentStateRef.current, system: context.system, tools: context.tools ? toToolsJSONSchema(context.tools) : undefined, threadId }, (parentIdRef.current !== undefined && {
+                    parentId: parentIdRef.current,
+                })), context.callSettings), context.config), (bodyValue !== null && bodyValue !== void 0 ? bodyValue : {}))),
+                signal,
+            });
+            (_d = options.onResponse) === null || _d === void 0 ? void 0 : _d.call(options, response);
+            if (!response.ok) {
+                throw new Error(`Status ${response.status}: ${await response.text()}`);
+            }
+            if (!response.body) {
+                throw new Error("Response body is null");
+            }
+            // Select decoder based on protocol option
+            const protocol = (_e = options.protocol) !== null && _e !== void 0 ? _e : "data-stream";
+            const decoder = protocol === "assistant-transport"
+                ? new AssistantTransportDecoder()
+                : new DataStreamDecoder();
+            let err;
+            const stream = response.body.pipeThrough(decoder).pipeThrough(new AssistantMessageAccumulator({
+                initialMessage: createInitialMessage({
+                    unstable_state: (_f = agentStateRef.current) !== null && _f !== void 0 ? _f : null,
+                }),
+                throttle: isResume,
+                onError: (error) => {
+                    err = error;
+                },
+            }));
+            let markedDelivered = false;
+            try {
+                for (var _g = true, _h = __asyncValues(asAsyncIterableStream(stream)), _j; _j = await _h.next(), _a = _j.done, !_a; _g = true) {
+                    _c = _j.value;
+                    _g = false;
+                    const chunk = _c;
+                    if (chunk.metadata.unstable_state === agentStateRef.current)
+                        continue;
+                    if (!markedDelivered) {
+                        commandQueue.markDelivered();
+                        markedDelivered = true;
+                    }
+                    agentStateRef.current = chunk.metadata.unstable_state;
+                    rerender((prev) => prev + 1);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_g && !_a && (_b = _h.return)) await _b.call(_h);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (err) {
+                throw new Error(err);
+            }
+        },
+        onFinish: options.onFinish,
+        onCancel: () => {
+            var _a;
+            const cmds = [
+                ...commandQueue.state.inTransit,
+                ...commandQueue.state.queued,
+            ];
+            commandQueue.reset();
+            (_a = options.onCancel) === null || _a === void 0 ? void 0 : _a.call(options, {
+                commands: cmds,
+                updateState: (updater) => {
+                    agentStateRef.current = updater(agentStateRef.current);
+                    rerender((prev) => prev + 1);
+                },
+            });
+        },
+        onError: async (error) => {
+            var _a, _b;
+            const inTransitCmds = [...commandQueue.state.inTransit];
+            const queuedCmds = [...commandQueue.state.queued];
+            commandQueue.reset();
+            try {
+                await ((_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error, {
+                    commands: inTransitCmds,
+                    updateState: (updater) => {
+                        agentStateRef.current = updater(agentStateRef.current);
+                        rerender((prev) => prev + 1);
+                    },
+                }));
+            }
+            finally {
+                (_b = options.onCancel) === null || _b === void 0 ? void 0 : _b.call(options, {
+                    commands: queuedCmds,
+                    updateState: (updater) => {
+                        agentStateRef.current = updater(agentStateRef.current);
+                        rerender((prev) => prev + 1);
+                    },
+                    error: error,
+                });
+            }
+        },
+    });
+    // Tool execution status state
+    const [toolStatuses, setToolStatuses] = useState({});
+    // Reactive conversion of agent state + connection metadata → UI state
+    const pendingCommands = useMemo(() => [...commandQueue.state.inTransit, ...commandQueue.state.queued], [commandQueue.state]);
+    const converted = useConvertedState(options.converter, agentStateRef.current, pendingCommands, runManager.isRunning, toolStatuses);
+    // Create runtime
+    const runtime = useExternalStoreRuntime({
+        messages: converted.messages,
+        state: converted.state,
+        isRunning: converted.isRunning,
+        adapters: options.adapters,
+        extras: {
+            [symbolAssistantTransportExtras]: true,
+            sendCommand: (command) => {
+                commandQueue.enqueue(command);
+            },
+            state: agentStateRef.current,
+        },
+        onNew: async (message) => {
+            var _a, _b;
+            if (message.role !== "user")
+                throw new Error("Only user messages are supported");
+            // Store parentId for the request
+            parentIdRef.current = message.parentId;
+            // Convert AppendMessage to AddMessageCommand
+            const parts = [];
+            const content = [
+                ...message.content,
+                ...((_b = (_a = message.attachments) === null || _a === void 0 ? void 0 : _a.flatMap((a) => a.content)) !== null && _b !== void 0 ? _b : []),
+            ];
+            for (const contentPart of content) {
+                if (contentPart.type === "text") {
+                    parts.push({ type: "text", text: contentPart.text });
+                }
+                else if (contentPart.type === "image") {
+                    parts.push({ type: "image", image: contentPart.image });
+                }
+            }
+            const command = {
+                type: "add-message",
+                message: {
+                    role: "user",
+                    parts,
+                },
+            };
+            commandQueue.enqueue(command);
+        },
+        onCancel: async () => {
+            runManager.cancel();
+            await toolInvocations.abort();
+        },
+        onResume: async () => {
+            if (!options.resumeApi)
+                throw new Error("Must pass resumeApi to options to resume runs");
+            resumeFlagRef.current = true;
+            runManager.schedule();
+        },
+        onAddToolResult: async (toolOptions) => {
+            const command = Object.assign({ type: "add-tool-result", toolCallId: toolOptions.toolCallId, result: toolOptions.result, toolName: toolOptions.toolName, isError: toolOptions.isError }, (toolOptions.artifact && { artifact: toolOptions.artifact }));
+            commandQueue.enqueue(command);
+        },
+        onLoadExternalState: async (state) => {
+            agentStateRef.current = state;
+            toolInvocations.reset();
+            rerender((prev) => prev + 1);
+        },
+    });
+    const toolInvocations = useToolInvocations({
+        state: converted,
+        getTools: () => runtime.thread.getModelContext().tools,
+        onResult: commandQueue.enqueue,
+        setToolStatuses,
+    });
+    return runtime;
+};
+/**
+ * @alpha This is an experimental API that is subject to change.
+ */
+export const useAssistantTransportRuntime = (options) => {
+    const runtime = useRemoteThreadListRuntime({
+        runtimeHook: function RuntimeHook() {
+            return useAssistantTransportThreadRuntime(options);
+        },
+        adapter: new InMemoryThreadListAdapter(),
+        allowNesting: true,
+    });
+    return runtime;
+};

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

@@ -0,0 +1,3 @@
+import type { AssistantTransportCommand, AssistantTransportState, AssistantTransportStateConverter } from "./types";
+import type { ToolExecutionStatus } from "./useToolInvocations";
+export declare function useConvertedState<T>(converter: AssistantTransportStateConverter<T>, agentState: T, pendingCommands: AssistantTransportCommand[], isSending: boolean, toolStatuses: Record<string, ToolExecutionStatus>): AssistantTransportState;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/useConvertedState.js

@@ -0,0 +1,4 @@
+import { useMemo } from "react";
+export function useConvertedState(converter, agentState, pendingCommands, isSending, toolStatuses) {
+    return useMemo(() => converter(agentState, { pendingCommands, isSending, toolStatuses }), [converter, agentState, pendingCommands, isSending, toolStatuses]);
+}

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

@@ -0,0 +1,3 @@
+export declare function useLatestRef<T>(value: T): {
+    current: T;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/assistant-transport/useLatestRef.js

@@ -0,0 +1,8 @@
+import { useEffect, useRef } from "react";
+export function useLatestRef(value) {
+    const ref = useRef(value);
+    useEffect(() => {
+        ref.current = value;
+    }, [value]);
+    return ref;
+}