ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ThreadMessageLike.d.ts

@@ -0,0 +1,33 @@
+import { MessageStatus, TextMessagePart, ImageMessagePart, ThreadMessage, CompleteAttachment, FileMessagePart, DataMessagePart, Unstable_AudioMessagePart } from "../../../types";
+import { ReasoningMessagePart, SourceMessagePart, ThreadStep } from "../../../types/AssistantTypes";
+import { ReadonlyJSONObject, ReadonlyJSONValue } from "assistant-stream/utils";
+export type ThreadMessageLike = {
+    readonly role: "assistant" | "user" | "system";
+    readonly content: string | readonly (TextMessagePart | ReasoningMessagePart | SourceMessagePart | ImageMessagePart | FileMessagePart | DataMessagePart | Unstable_AudioMessagePart | {
+        readonly type: "tool-call";
+        readonly toolCallId?: string;
+        readonly toolName: string;
+        readonly args?: ReadonlyJSONObject;
+        readonly argsText?: string;
+        readonly artifact?: any;
+        readonly result?: any | undefined;
+        readonly isError?: boolean | undefined;
+        readonly parentId?: string | undefined;
+        readonly messages?: readonly ThreadMessage[] | undefined;
+    })[];
+    readonly id?: string | undefined;
+    readonly createdAt?: Date | undefined;
+    readonly status?: MessageStatus | undefined;
+    readonly attachments?: readonly CompleteAttachment[] | 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 submittedFeedback?: {
+            readonly type: "positive" | "negative";
+        };
+        readonly custom?: Record<string, unknown> | undefined;
+    } | undefined;
+};
+export declare const fromThreadMessageLike: (like: ThreadMessageLike, fallbackId: string, fallbackStatus: MessageStatus) => ThreadMessage;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ThreadMessageLike.js

@@ -0,0 +1,103 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { parsePartialJsonObject } from "assistant-stream/utils";
+import { generateId } from "../../../utils/idUtils";
+export const fromThreadMessageLike = (like, fallbackId, fallbackStatus) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const { role, id, createdAt, attachments, status, metadata } = like;
+    const common = {
+        id: id !== null && id !== void 0 ? id : fallbackId,
+        createdAt: createdAt !== null && createdAt !== void 0 ? createdAt : new Date(),
+    };
+    const content = typeof like.content === "string"
+        ? [{ type: "text", text: like.content }]
+        : like.content;
+    const sanitizeImageContent = (_a) => {
+        var { image } = _a, rest = __rest(_a, ["image"]);
+        const match = image.match(/^data:image\/(png|jpeg|jpg|gif|webp);base64,(.*)$/);
+        if (match) {
+            return Object.assign(Object.assign({}, rest), { image });
+        }
+        console.warn(`Invalid image data format detected`);
+        return null;
+    };
+    if (role !== "user" && (attachments === null || attachments === void 0 ? void 0 : attachments.length))
+        throw new Error("attachments are only supported for user messages");
+    if (role !== "assistant" && status)
+        throw new Error("status is only supported for assistant messages");
+    if (role !== "assistant" && (metadata === null || metadata === void 0 ? void 0 : metadata.steps))
+        throw new Error("metadata.steps is only supported for assistant messages");
+    switch (role) {
+        case "assistant":
+            return Object.assign(Object.assign({}, common), { role, content: content
+                    .map((part) => {
+                    var _a, _b, _c, _d, _e;
+                    const type = part.type;
+                    switch (type) {
+                        case "text":
+                        case "reasoning":
+                            if (part.text.trim().length === 0)
+                                return null;
+                            return part;
+                        case "file":
+                        case "source":
+                            return part;
+                        case "image":
+                            return sanitizeImageContent(part);
+                        case "data":
+                            return part;
+                        case "tool-call": {
+                            const { parentId, messages } = part, basePart = __rest(part, ["parentId", "messages"]);
+                            const commonProps = Object.assign(Object.assign(Object.assign(Object.assign({}, basePart), { toolCallId: (_a = part.toolCallId) !== null && _a !== void 0 ? _a : `tool-${generateId()}` }), (parentId !== undefined && { parentId })), (messages !== undefined && { messages }));
+                            if (part.args) {
+                                return Object.assign(Object.assign({}, commonProps), { args: part.args, argsText: (_b = part.argsText) !== null && _b !== void 0 ? _b : JSON.stringify(part.args) });
+                            }
+                            return Object.assign(Object.assign({}, commonProps), { args: (_d = parsePartialJsonObject((_c = part.argsText) !== null && _c !== void 0 ? _c : "")) !== null && _d !== void 0 ? _d : {}, argsText: (_e = part.argsText) !== null && _e !== void 0 ? _e : "" });
+                        }
+                        default: {
+                            const unhandledType = type;
+                            throw new Error(`Unsupported assistant message part type: ${unhandledType}`);
+                        }
+                    }
+                })
+                    .filter((c) => !!c), status: status !== null && status !== void 0 ? status : fallbackStatus, metadata: Object.assign({ unstable_state: (_a = metadata === null || metadata === void 0 ? void 0 : metadata.unstable_state) !== null && _a !== void 0 ? _a : null, unstable_annotations: (_b = metadata === null || metadata === void 0 ? void 0 : metadata.unstable_annotations) !== null && _b !== void 0 ? _b : [], unstable_data: (_c = metadata === null || metadata === void 0 ? void 0 : metadata.unstable_data) !== null && _c !== void 0 ? _c : [], custom: (_d = metadata === null || metadata === void 0 ? void 0 : metadata.custom) !== null && _d !== void 0 ? _d : {}, steps: (_e = metadata === null || metadata === void 0 ? void 0 : metadata.steps) !== null && _e !== void 0 ? _e : [] }, ((metadata === null || metadata === void 0 ? void 0 : metadata.submittedFeedback) && {
+                    submittedFeedback: metadata.submittedFeedback,
+                })) });
+        case "user":
+            return Object.assign(Object.assign({}, common), { role, content: content.map((part) => {
+                    const type = part.type;
+                    switch (type) {
+                        case "text":
+                        case "image":
+                        case "audio":
+                        case "file":
+                            return part;
+                        default: {
+                            const unhandledType = type;
+                            throw new Error(`Unsupported user message part type: ${unhandledType}`);
+                        }
+                    }
+                }), attachments: attachments !== null && attachments !== void 0 ? attachments : [], metadata: {
+                    custom: (_f = metadata === null || metadata === void 0 ? void 0 : metadata.custom) !== null && _f !== void 0 ? _f : {},
+                } });
+        case "system":
+            if (content.length !== 1 || content[0].type !== "text")
+                throw new Error("System messages must have exactly one text message part.");
+            return Object.assign(Object.assign({}, common), { role, content: content, metadata: {
+                    custom: (_g = metadata === null || metadata === void 0 ? void 0 : metadata.custom) !== null && _g !== void 0 ? _g : {},
+                } });
+        default: {
+            const unsupportedRole = role;
+            throw new Error(`Unknown message role: ${unsupportedRole}`);
+        }
+    }
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/auto-status.d.ts

@@ -0,0 +1,4 @@
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+import { MessageStatus } from "../../../types";
+export declare const isAutoStatus: (status: MessageStatus) => boolean;
+export declare const getAutoStatus: (isLast: boolean, isRunning: boolean, hasInterruptedToolCalls: boolean, hasPendingToolCalls: boolean, error?: ReadonlyJSONValue) => MessageStatus;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/auto-status.js

@@ -0,0 +1,31 @@
+const symbolAutoStatus = Symbol("autoStatus");
+const AUTO_STATUS_RUNNING = Object.freeze(Object.assign({ type: "running" }, { [symbolAutoStatus]: true }));
+const AUTO_STATUS_COMPLETE = Object.freeze(Object.assign({
+    type: "complete",
+    reason: "unknown",
+}, { [symbolAutoStatus]: true }));
+const AUTO_STATUS_PENDING = Object.freeze(Object.assign({
+    type: "requires-action",
+    reason: "tool-calls",
+}, { [symbolAutoStatus]: true }));
+const AUTO_STATUS_INTERRUPT = Object.freeze(Object.assign({
+    type: "requires-action",
+    reason: "interrupt",
+}, { [symbolAutoStatus]: true }));
+export const isAutoStatus = (status) => status[symbolAutoStatus] === true;
+export const getAutoStatus = (isLast, isRunning, hasInterruptedToolCalls, hasPendingToolCalls, error) => {
+    if (isLast && error) {
+        return Object.assign({
+            type: "incomplete",
+            reason: "error",
+            error: error,
+        }, { [symbolAutoStatus]: true });
+    }
+    return isLast && isRunning
+        ? AUTO_STATUS_RUNNING
+        : hasInterruptedToolCalls
+            ? AUTO_STATUS_INTERRUPT
+            : hasPendingToolCalls
+                ? AUTO_STATUS_PENDING
+                : AUTO_STATUS_COMPLETE;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/createMessageConverter.d.ts

@@ -0,0 +1,16 @@
+import { ThreadState } from "../../runtime";
+import { ThreadMessage } from "../../../types";
+import { useExternalMessageConverter } from "./external-message-converter";
+export declare const createMessageConverter: <T extends object>(callback: useExternalMessageConverter.Callback<T>) => {
+    useThreadMessages: ({ messages, isRunning, joinStrategy, metadata, }: {
+        messages: T[];
+        isRunning: boolean;
+        joinStrategy?: "concat-content" | "none" | undefined;
+        metadata?: useExternalMessageConverter.Metadata;
+    }) => ThreadMessage[];
+    toThreadMessages: (messages: T[], isRunning?: boolean, metadata?: useExternalMessageConverter.Metadata) => ThreadMessage[];
+    toOriginalMessages: (input: ThreadState | ThreadMessage | ThreadMessage["content"][number]) => unknown[];
+    toOriginalMessage: (input: ThreadState | ThreadMessage | ThreadMessage["content"][number]) => {};
+    useOriginalMessage: () => any;
+    useOriginalMessages: () => any;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/createMessageConverter.js

@@ -0,0 +1,49 @@
+"use client";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import { useExternalMessageConverter, convertExternalMessages, } from "./external-message-converter";
+import { getExternalStoreMessages } from "./getExternalStoreMessage";
+export const createMessageConverter = (callback) => {
+    const result = {
+        useThreadMessages: ({ messages, isRunning, joinStrategy, metadata, }) => {
+            return useExternalMessageConverter({
+                callback,
+                messages,
+                isRunning,
+                joinStrategy,
+                metadata,
+            });
+        },
+        toThreadMessages: (messages, isRunning = false, metadata = {}) => {
+            return convertExternalMessages(messages, callback, isRunning, metadata);
+        },
+        toOriginalMessages: (input) => {
+            const messages = getExternalStoreMessages(input);
+            if (messages.length === 0)
+                throw new Error("No original messages found");
+            return messages;
+        },
+        toOriginalMessage: (input) => {
+            const messages = result.toOriginalMessages(input);
+            return messages[0];
+        },
+        useOriginalMessage: () => {
+            const messageMessages = result.useOriginalMessages();
+            const first = messageMessages[0];
+            return first;
+        },
+        useOriginalMessages: () => {
+            const aui = useAui();
+            const partMessages = useAuiState((s) => {
+                if (aui.part.source)
+                    return getExternalStoreMessages(s.part);
+                return undefined;
+            });
+            const messageMessages = useAuiState(({ message }) => getExternalStoreMessages(message));
+            const messages = partMessages !== null && partMessages !== void 0 ? partMessages : messageMessages;
+            if (messages.length === 0)
+                throw new Error("No original messages found");
+            return messages;
+        },
+    };
+    return result;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/external-message-converter.d.ts

@@ -0,0 +1,32 @@
+import { ThreadMessageLike } from "./ThreadMessageLike";
+import { ThreadMessage } from "../../../types";
+import { ToolExecutionStatus } from "../assistant-transport/useToolInvocations";
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+export declare namespace useExternalMessageConverter {
+    type Message = (ThreadMessageLike & {
+        readonly convertConfig?: {
+            readonly joinStrategy?: "concat-content" | "none";
+        };
+    }) | {
+        role: "tool";
+        toolCallId: string;
+        toolName?: string | undefined;
+        result: any;
+        artifact?: any;
+        isError?: boolean;
+        messages?: readonly ThreadMessage[];
+    };
+    type Metadata = {
+        readonly toolStatuses?: Record<string, ToolExecutionStatus>;
+        readonly error?: ReadonlyJSONValue;
+    };
+    type Callback<T> = (message: T, metadata: Metadata) => Message | Message[];
+}
+export declare const convertExternalMessages: <T extends WeakKey>(messages: T[], callback: useExternalMessageConverter.Callback<T>, isRunning: boolean, metadata: useExternalMessageConverter.Metadata) => ThreadMessage[];
+export declare const useExternalMessageConverter: <T extends WeakKey>({ callback, messages, isRunning, joinStrategy, metadata, }: {
+    callback: useExternalMessageConverter.Callback<T>;
+    messages: T[];
+    isRunning: boolean;
+    joinStrategy?: "concat-content" | "none" | undefined;
+    metadata?: useExternalMessageConverter.Metadata | undefined;
+}) => ThreadMessage[];

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/external-message-converter.js

@@ -0,0 +1,273 @@
+"use client";
+import { useMemo } from "react";
+import { ThreadMessageConverter } from "./ThreadMessageConverter";
+import { getExternalStoreMessages, symbolInnerMessage, } from "./getExternalStoreMessage";
+import { fromThreadMessageLike } from "./ThreadMessageLike";
+import { getAutoStatus, isAutoStatus } from "./auto-status";
+import { generateErrorMessageId } from "../../../utils/idUtils";
+const joinExternalMessages = (messages) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const assistantMessage = {
+        role: "assistant",
+        content: [],
+    };
+    for (const output of messages) {
+        if (output.role === "tool") {
+            const toolCallIdx = assistantMessage.content.findIndex((c) => c.type === "tool-call" && c.toolCallId === output.toolCallId);
+            if (toolCallIdx !== -1) {
+                const toolCall = assistantMessage.content[toolCallIdx];
+                if (output.toolName !== undefined) {
+                    if (toolCall.toolName !== output.toolName)
+                        throw new Error(`Tool call name ${output.toolCallId} ${output.toolName} does not match existing tool call ${toolCall.toolName}`);
+                }
+                assistantMessage.content[toolCallIdx] = Object.assign(Object.assign(Object.assign({}, toolCall), {
+                    [symbolInnerMessage]: [
+                        ...((_a = toolCall[symbolInnerMessage]) !== null && _a !== void 0 ? _a : []),
+                        output,
+                    ],
+                }), { result: output.result, artifact: output.artifact, isError: output.isError, messages: output.messages });
+            }
+            else {
+                throw new Error(`Tool call ${output.toolCallId} ${output.toolName} not found in assistant message`);
+            }
+        }
+        else {
+            const role = output.role;
+            const content = (typeof output.content === "string"
+                ? [{ type: "text", text: output.content }]
+                : output.content).map((c) => (Object.assign(Object.assign({}, c), { [symbolInnerMessage]: [output] })));
+            switch (role) {
+                case "system":
+                case "user":
+                    return Object.assign(Object.assign({}, output), { content });
+                case "assistant":
+                    if (assistantMessage.content.length === 0) {
+                        assistantMessage.id = output.id;
+                        (_b = assistantMessage.createdAt) !== null && _b !== void 0 ? _b : (assistantMessage.createdAt = output.createdAt);
+                        (_c = assistantMessage.status) !== null && _c !== void 0 ? _c : (assistantMessage.status = output.status);
+                        if (output.attachments) {
+                            assistantMessage.attachments = [
+                                ...((_d = assistantMessage.attachments) !== null && _d !== void 0 ? _d : []),
+                                ...output.attachments,
+                            ];
+                        }
+                        if (output.metadata) {
+                            (_e = assistantMessage.metadata) !== null && _e !== void 0 ? _e : (assistantMessage.metadata = {});
+                            if (output.metadata.unstable_state) {
+                                assistantMessage.metadata.unstable_state =
+                                    output.metadata.unstable_state;
+                            }
+                            if (output.metadata.unstable_annotations) {
+                                assistantMessage.metadata.unstable_annotations = [
+                                    ...((_f = assistantMessage.metadata.unstable_annotations) !== null && _f !== void 0 ? _f : []),
+                                    ...output.metadata.unstable_annotations,
+                                ];
+                            }
+                            if (output.metadata.unstable_data) {
+                                assistantMessage.metadata.unstable_data = [
+                                    ...((_g = assistantMessage.metadata.unstable_data) !== null && _g !== void 0 ? _g : []),
+                                    ...output.metadata.unstable_data,
+                                ];
+                            }
+                            if (output.metadata.steps) {
+                                assistantMessage.metadata.steps = [
+                                    ...((_h = assistantMessage.metadata.steps) !== null && _h !== void 0 ? _h : []),
+                                    ...output.metadata.steps,
+                                ];
+                            }
+                            if (output.metadata.custom) {
+                                assistantMessage.metadata.custom = Object.assign(Object.assign({}, ((_j = assistantMessage.metadata.custom) !== null && _j !== void 0 ? _j : {})), output.metadata.custom);
+                            }
+                            if (output.metadata.submittedFeedback) {
+                                assistantMessage.metadata.submittedFeedback =
+                                    output.metadata.submittedFeedback;
+                            }
+                        }
+                        // TODO keep this in sync
+                    }
+                    // Add content parts, merging reasoning parts with same parentId
+                    for (const part of content) {
+                        if (part.type === "reasoning" &&
+                            "parentId" in part &&
+                            part.parentId) {
+                            const existingIdx = assistantMessage.content.findIndex((c) => c.type === "reasoning" &&
+                                "parentId" in c &&
+                                c.parentId === part.parentId);
+                            if (existingIdx !== -1) {
+                                const existing = assistantMessage.content[existingIdx];
+                                assistantMessage.content[existingIdx] = Object.assign(Object.assign(Object.assign({}, existing), { text: `${existing.text}\n\n${part.text}` }), {
+                                    [symbolInnerMessage]: [
+                                        ...((_k = existing[symbolInnerMessage]) !== null && _k !== void 0 ? _k : []),
+                                        ...((_l = part[symbolInnerMessage]) !== null && _l !== void 0 ? _l : []),
+                                    ],
+                                });
+                                continue;
+                            }
+                        }
+                        assistantMessage.content.push(part);
+                    }
+                    break;
+                default: {
+                    const unsupportedRole = role;
+                    throw new Error(`Unknown message role: ${unsupportedRole}`);
+                }
+            }
+        }
+    }
+    return assistantMessage;
+};
+const chunkExternalMessages = (callbackResults, joinStrategy) => {
+    var _a;
+    const results = [];
+    let isAssistant = false;
+    let pendingNone = false; // true if the previous assistant message had joinStrategy "none"
+    let inputs = [];
+    let outputs = [];
+    const flush = () => {
+        if (outputs.length) {
+            results.push({
+                inputs,
+                outputs,
+            });
+        }
+        inputs = [];
+        outputs = [];
+        isAssistant = false;
+        pendingNone = false;
+    };
+    for (const callbackResult of callbackResults) {
+        for (const output of callbackResult.outputs) {
+            if ((pendingNone && output.role !== "tool") ||
+                !isAssistant ||
+                output.role === "user" ||
+                output.role === "system") {
+                flush();
+            }
+            isAssistant = output.role === "assistant" || output.role === "tool";
+            if (inputs.at(-1) !== callbackResult.input) {
+                inputs.push(callbackResult.input);
+            }
+            outputs.push(output);
+            if (output.role === "assistant" &&
+                (((_a = output.convertConfig) === null || _a === void 0 ? void 0 : _a.joinStrategy) === "none" ||
+                    joinStrategy === "none")) {
+                pendingNone = true;
+            }
+        }
+    }
+    flush();
+    return results;
+};
+function createErrorAssistantMessage(error) {
+    return Object.assign({
+        id: generateErrorMessageId(),
+        role: "assistant",
+        content: [],
+        status: { type: "incomplete", reason: "error", error },
+        createdAt: new Date(),
+        metadata: {
+            unstable_state: null,
+            unstable_annotations: [],
+            unstable_data: [],
+            custom: {},
+            steps: [],
+        },
+    }, { [symbolInnerMessage]: [] });
+}
+export const convertExternalMessages = (messages, callback, isRunning, metadata) => {
+    const callbackResults = [];
+    for (const message of messages) {
+        const output = callback(message, metadata);
+        const outputs = Array.isArray(output) ? output : [output];
+        const result = { input: message, outputs };
+        callbackResults.push(result);
+    }
+    const chunks = chunkExternalMessages(callbackResults);
+    const result = chunks.map((message, idx) => {
+        const isLast = idx === chunks.length - 1;
+        const joined = joinExternalMessages(message.outputs);
+        const hasPendingToolCalls = typeof joined.content === "object" &&
+            joined.content.some((c) => c.type === "tool-call" && c.result === undefined);
+        const autoStatus = getAutoStatus(isLast, isRunning, hasPendingToolCalls, hasPendingToolCalls, isLast ? metadata.error : undefined);
+        const newMessage = fromThreadMessageLike(joined, idx.toString(), autoStatus);
+        newMessage[symbolInnerMessage] = message.inputs;
+        return newMessage;
+    });
+    if (metadata.error) {
+        const lastMessage = result.at(-1);
+        if (!lastMessage || lastMessage.role !== "assistant") {
+            result.push(createErrorAssistantMessage(metadata.error));
+        }
+    }
+    return result;
+};
+export const useExternalMessageConverter = ({ callback, messages, isRunning, joinStrategy, metadata, }) => {
+    const state = useMemo(() => ({
+        metadata: metadata !== null && metadata !== void 0 ? metadata : {},
+        callback,
+        callbackCache: new WeakMap(),
+        chunkCache: new WeakMap(),
+        converterCache: new ThreadMessageConverter(),
+    }), [callback, metadata]);
+    return useMemo(() => {
+        const callbackResults = [];
+        for (const message of messages) {
+            let result = state.callbackCache.get(message);
+            if (!result) {
+                const output = state.callback(message, state.metadata);
+                const outputs = Array.isArray(output) ? output : [output];
+                result = { input: message, outputs };
+                state.callbackCache.set(message, result);
+            }
+            callbackResults.push(result);
+        }
+        const chunks = chunkExternalMessages(callbackResults, joinStrategy).map((m) => {
+            const key = m.outputs[0];
+            if (!key)
+                return m;
+            const cached = state.chunkCache.get(key);
+            if (cached && shallowArrayEqual(cached.outputs, m.outputs))
+                return cached;
+            state.chunkCache.set(key, m);
+            return m;
+        });
+        const threadMessages = state.converterCache.convertMessages(chunks, (cache, message, idx) => {
+            const isLast = idx === chunks.length - 1;
+            const joined = joinExternalMessages(message.outputs);
+            const hasSuspendedToolCalls = typeof joined.content === "object" &&
+                joined.content.some((c) => c.type === "tool-call" && c.result === undefined);
+            const hasPendingToolCalls = typeof joined.content === "object" &&
+                joined.content.some((c) => c.type === "tool-call" && c.result === undefined);
+            const autoStatus = getAutoStatus(isLast, isRunning, hasSuspendedToolCalls, hasPendingToolCalls, isLast ? state.metadata.error : undefined);
+            if (cache &&
+                (cache.role !== "assistant" ||
+                    !isAutoStatus(cache.status) ||
+                    cache.status === autoStatus)) {
+                const inputs = getExternalStoreMessages(cache);
+                if (shallowArrayEqual(inputs, message.inputs)) {
+                    return cache;
+                }
+            }
+            const newMessage = fromThreadMessageLike(joined, idx.toString(), autoStatus);
+            newMessage[symbolInnerMessage] = message.inputs;
+            return newMessage;
+        });
+        threadMessages[symbolInnerMessage] = messages;
+        if (state.metadata.error) {
+            const lastMessage = threadMessages.at(-1);
+            if (!lastMessage || lastMessage.role !== "assistant") {
+                threadMessages.push(createErrorAssistantMessage(state.metadata.error));
+            }
+        }
+        return threadMessages;
+    }, [state, messages, isRunning, joinStrategy]);
+};
+const shallowArrayEqual = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/getExternalStoreMessage.d.ts

@@ -0,0 +1,8 @@
+import { ThreadState } from "../../runtime";
+import { ThreadMessage } from "../../../types";
+export declare const symbolInnerMessage: unique symbol;
+/**
+ * @deprecated Use `getExternalStoreMessages` (plural) instead. This function will be removed in 0.12.0.
+ */
+export declare const getExternalStoreMessage: <T>(input: ThreadMessage) => T | T[] | undefined;
+export declare const getExternalStoreMessages: <T>(input: ThreadState | ThreadMessage | ThreadMessage["content"][number]) => T[];

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/getExternalStoreMessage.js

@@ -0,0 +1,22 @@
+export const symbolInnerMessage = Symbol("innerMessage");
+const symbolInnerMessages = Symbol("innerMessages");
+/**
+ * @deprecated Use `getExternalStoreMessages` (plural) instead. This function will be removed in 0.12.0.
+ */
+export const getExternalStoreMessage = (input) => {
+    const withInnerMessages = input;
+    return withInnerMessages[symbolInnerMessage];
+};
+const EMPTY_ARRAY = [];
+export const getExternalStoreMessages = (input) => {
+    // TODO temp until 0.12.0 (migrate useExternalStoreRuntime to always set an array)
+    const container = ("messages" in input ? input.messages : input);
+    const value = container[symbolInnerMessages] || container[symbolInnerMessage];
+    if (!value)
+        return EMPTY_ARRAY;
+    if (Array.isArray(value)) {
+        return value;
+    }
+    container[symbolInnerMessages] = [value];
+    return container[symbolInnerMessages];
+};

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

@@ -0,0 +1,6 @@
+export type { ExternalStoreAdapter, ExternalStoreMessageConverter, ExternalStoreThreadListAdapter, ExternalStoreThreadData, } from "./ExternalStoreAdapter";
+export type { ThreadMessageLike } from "./ThreadMessageLike";
+export { useExternalStoreRuntime } from "./useExternalStoreRuntime";
+export { getExternalStoreMessage, getExternalStoreMessages, } from "./getExternalStoreMessage";
+export { useExternalMessageConverter, convertExternalMessages as unstable_convertExternalMessages, } from "./external-message-converter";
+export { createMessageConverter as unstable_createMessageConverter } from "./createMessageConverter";

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

@@ -0,0 +1,4 @@
+export { useExternalStoreRuntime } from "./useExternalStoreRuntime";
+export { getExternalStoreMessage, getExternalStoreMessages, } from "./getExternalStoreMessage";
+export { useExternalMessageConverter, convertExternalMessages as unstable_convertExternalMessages, } from "./external-message-converter";
+export { createMessageConverter as unstable_createMessageConverter } from "./createMessageConverter";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/useExternalStoreRuntime.d.ts

@@ -0,0 +1,3 @@
+import { ExternalStoreAdapter } from "./ExternalStoreAdapter";
+import { AssistantRuntime } from "../../runtime/AssistantRuntime";
+export declare const useExternalStoreRuntime: <T>(store: ExternalStoreAdapter<T>) => AssistantRuntime;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/useExternalStoreRuntime.js

@@ -0,0 +1,19 @@
+"use client";
+import { useEffect, useMemo, useState } from "react";
+import { ExternalStoreRuntimeCore } from "./ExternalStoreRuntimeCore";
+import { AssistantRuntimeImpl, } from "../../runtime/AssistantRuntime";
+import { useRuntimeAdapters } from "../adapters/RuntimeAdapterProvider";
+export const useExternalStoreRuntime = (store) => {
+    var _a;
+    const [runtime] = useState(() => new ExternalStoreRuntimeCore(store));
+    useEffect(() => {
+        runtime.setAdapter(store);
+    });
+    const { modelContext } = (_a = useRuntimeAdapters()) !== null && _a !== void 0 ? _a : {};
+    useEffect(() => {
+        if (!modelContext)
+            return undefined;
+        return runtime.registerModelContextProvider(modelContext);
+    }, [modelContext, runtime]);
+    return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
+};

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

@@ -0,0 +1,7 @@
+export * from "./adapters";
+export * from "./assistant-transport";
+export * from "./core";
+export * from "./external-store";
+export * from "./local";
+export * from "./remote-thread-list";
+export { ExportedMessageRepository, type ExportedMessageRepositoryItem, } from "./utils/MessageRepository";

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

@@ -0,0 +1,7 @@
+export * from "./adapters";
+export * from "./assistant-transport";
+export * from "./core";
+export * from "./external-store";
+export * from "./local";
+export * from "./remote-thread-list";
+export { ExportedMessageRepository, } from "./utils/MessageRepository";