ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-ai-sdk/src/ui/adapters/aiSDKFormatAdapter.js

@@ -0,0 +1,27 @@
+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 aiSDKV6FormatAdapter = {
+    format: "ai-sdk/v6",
+    encode(_a) {
+        var _b = _a.message, { id, parts } = _b, message = __rest(_b, ["id", "parts"]);
+        return Object.assign(Object.assign({}, message), { parts });
+    },
+    decode(stored) {
+        return {
+            parentId: stored.parent_id,
+            message: Object.assign({ id: stored.id }, stored.content),
+        };
+    },
+    getId(message) {
+        return message.id;
+    },
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/getVercelAIMessages.d.ts

@@ -0,0 +1,3 @@
+import { type ThreadMessage } from "@assistant-ui/react";
+import type { UIMessage } from "ai";
+export declare const getVercelAIMessages: <UI_MESSAGE extends UIMessage = UIMessage>(message: ThreadMessage) => UI_MESSAGE[];

package/dist/vendor/assistant-ui-ai-sdk/src/ui/getVercelAIMessages.js

@@ -0,0 +1,4 @@
+import { getExternalStoreMessages, } from "@assistant-ui/react";
+export const getVercelAIMessages = (message) => {
+    return getExternalStoreMessages(message);
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/index.d.ts

@@ -0,0 +1,4 @@
+export { useAISDKRuntime } from "./use-chat/useAISDKRuntime";
+export { useChatRuntime } from "./use-chat/useChatRuntime";
+export type { UseChatRuntimeOptions } from "./use-chat/useChatRuntime";
+export { AssistantChatTransport } from "./use-chat/AssistantChatTransport";

package/dist/vendor/assistant-ui-ai-sdk/src/ui/index.js

@@ -0,0 +1,3 @@
+export { useAISDKRuntime } from "./use-chat/useAISDKRuntime";
+export { useChatRuntime } from "./use-chat/useChatRuntime";
+export { AssistantChatTransport } from "./use-chat/AssistantChatTransport";

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/AssistantChatTransport.d.ts

@@ -0,0 +1,7 @@
+import { AssistantRuntime } from "@assistant-ui/react";
+import { DefaultChatTransport, HttpChatTransportInitOptions, UIMessage } from "ai";
+export declare class AssistantChatTransport<UI_MESSAGE extends UIMessage> extends DefaultChatTransport<UI_MESSAGE> {
+    private runtime;
+    constructor(initOptions?: HttpChatTransportInitOptions<UI_MESSAGE>);
+    setRuntime(runtime: AssistantRuntime): void;
+}

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/AssistantChatTransport.js

@@ -0,0 +1,17 @@
+import { DefaultChatTransport, } from "ai";
+import { toToolsJSONSchema } from "assistant-stream";
+export class AssistantChatTransport extends DefaultChatTransport {
+    constructor(initOptions) {
+        super(Object.assign(Object.assign({}, initOptions), { prepareSendMessagesRequest: async (options) => {
+                var _a, _b, _c, _d, _e, _f, _g;
+                const context = (_a = this.runtime) === null || _a === void 0 ? void 0 : _a.thread.getModelContext();
+                const id = (_d = (_c = (await ((_b = this.runtime) === null || _b === void 0 ? void 0 : _b.threads.mainItem.initialize()))) === null || _c === void 0 ? void 0 : _c.remoteId) !== null && _d !== void 0 ? _d : options.id;
+                const optionsEx = Object.assign(Object.assign({}, options), { body: Object.assign({ callSettings: context === null || context === void 0 ? void 0 : context.callSettings, system: context === null || context === void 0 ? void 0 : context.system, config: context === null || context === void 0 ? void 0 : context.config, tools: toToolsJSONSchema((_e = context === null || context === void 0 ? void 0 : context.tools) !== null && _e !== void 0 ? _e : {}) }, options === null || options === void 0 ? void 0 : options.body) });
+                const preparedRequest = await ((_f = initOptions === null || initOptions === void 0 ? void 0 : initOptions.prepareSendMessagesRequest) === null || _f === void 0 ? void 0 : _f.call(initOptions, optionsEx));
+                return Object.assign(Object.assign({}, preparedRequest), { body: (_g = preparedRequest === null || preparedRequest === void 0 ? void 0 : preparedRequest.body) !== null && _g !== void 0 ? _g : Object.assign(Object.assign({}, optionsEx.body), { id, messages: options.messages, trigger: options.trigger, messageId: options.messageId, metadata: options.requestMetadata }) });
+            } }));
+    }
+    setRuntime(runtime) {
+        this.runtime = runtime;
+    }
+}

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/useAISDKRuntime.d.ts

@@ -0,0 +1,19 @@
+import type { UIMessage, useChat, CreateUIMessage } from "@ai-sdk/react";
+import { type ExternalStoreAdapter, type ThreadHistoryAdapter, type AssistantRuntime, type AppendMessage } from "@assistant-ui/react";
+export type CustomToCreateMessageFunction = <UI_MESSAGE extends UIMessage = UIMessage>(message: AppendMessage) => CreateUIMessage<UI_MESSAGE>;
+export type AISDKRuntimeAdapter = {
+    adapters?: (NonNullable<ExternalStoreAdapter["adapters"]> & {
+        history?: ThreadHistoryAdapter | undefined;
+    }) | undefined;
+    toCreateMessage?: CustomToCreateMessageFunction;
+    /**
+     * Whether to automatically cancel pending interactive tool calls when the user sends a new message.
+     *
+     * When enabled (default), the pending tool calls will be marked as failed with an error message
+     * indicating the user cancelled the tool call by sending a new message.
+     *
+     * @default true
+     */
+    cancelPendingToolCallsOnSend?: boolean | undefined;
+};
+export declare const useAISDKRuntime: <UI_MESSAGE extends UIMessage = UIMessage>(chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>, { adapters, toCreateMessage: customToCreateMessage, cancelPendingToolCallsOnSend, }?: AISDKRuntimeAdapter) => AssistantRuntime;

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/useAISDKRuntime.js

@@ -0,0 +1,154 @@
+"use client";
+import { useState, useMemo } from "react";
+import { isToolUIPart } from "ai";
+import { useExternalStoreRuntime, useRuntimeAdapters, INTERNAL, getExternalStoreMessages, } from "@assistant-ui/react";
+import { sliceMessagesUntil } from "../utils/sliceMessagesUntil";
+import { toCreateMessage } from "../utils/toCreateMessage";
+import { vercelAttachmentAdapter } from "../utils/vercelAttachmentAdapter";
+import { getVercelAIMessages } from "../getVercelAIMessages";
+import { AISDKMessageConverter } from "../utils/convertMessage";
+import { aiSDKV6FormatAdapter, } from "../adapters/aiSDKFormatAdapter";
+import { useExternalHistory, toExportedMessageRepository, } from "./useExternalHistory";
+export const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreateMessage, cancelPendingToolCallsOnSend = true, } = {}) => {
+    var _a;
+    const contextAdapters = useRuntimeAdapters();
+    const [toolStatuses, setToolStatuses] = useState({});
+    const hasExecutingTools = Object.values(toolStatuses).some((s) => (s === null || s === void 0 ? void 0 : s.type) === "executing");
+    const isRunning = chatHelpers.status === "submitted" ||
+        chatHelpers.status === "streaming" ||
+        hasExecutingTools;
+    const messages = AISDKMessageConverter.useThreadMessages({
+        isRunning,
+        messages: chatHelpers.messages,
+        metadata: useMemo(() => (Object.assign({ toolStatuses }, (chatHelpers.error && { error: chatHelpers.error.message }))), [toolStatuses, chatHelpers.error]),
+    });
+    const [runtimeRef] = useState(() => ({
+        get current() {
+            return runtime;
+        },
+    }));
+    const toolInvocations = INTERNAL.useToolInvocations({
+        state: {
+            messages,
+            isRunning,
+        },
+        getTools: () => runtimeRef.current.thread.getModelContext().tools,
+        onResult: (command) => {
+            if (command.type === "add-tool-result") {
+                chatHelpers.addToolResult({
+                    tool: command.toolName,
+                    toolCallId: command.toolCallId,
+                    output: command.result,
+                });
+            }
+        },
+        setToolStatuses,
+    });
+    const isLoading = useExternalHistory(runtimeRef, (_a = adapters === null || adapters === void 0 ? void 0 : adapters.history) !== null && _a !== void 0 ? _a : contextAdapters === null || contextAdapters === void 0 ? void 0 : contextAdapters.history, AISDKMessageConverter.toThreadMessages, aiSDKV6FormatAdapter, (messages) => {
+        chatHelpers.setMessages(messages);
+    });
+    const completePendingToolCalls = async () => {
+        if (!cancelPendingToolCallsOnSend)
+            return;
+        await toolInvocations.abort();
+        // Mark any tool without a result as cancelled (uses setMessages to avoid triggering sendAutomaticallyWhen)
+        chatHelpers.setMessages((messages) => {
+            var _a;
+            const lastMessage = messages.at(-1);
+            if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) !== "assistant")
+                return messages;
+            let hasChanges = false;
+            const parts = (_a = lastMessage.parts) === null || _a === void 0 ? void 0 : _a.map((part) => {
+                if (!isToolUIPart(part))
+                    return part;
+                if (part.state === "output-available" || part.state === "output-error")
+                    return part;
+                hasChanges = true;
+                return Object.assign(Object.assign({}, part), { state: "output-error", errorText: "User cancelled tool call by sending a new message." });
+            });
+            if (!hasChanges)
+                return messages;
+            return [...messages.slice(0, -1), Object.assign(Object.assign({}, lastMessage), { parts })];
+        });
+    };
+    const runtime = useExternalStoreRuntime({
+        isRunning,
+        messages,
+        setMessages: (messages) => chatHelpers.setMessages(messages
+            .map((getVercelAIMessages))
+            .filter(Boolean)
+            .flat()),
+        onImport: (messages) => chatHelpers.setMessages(messages
+            .map((getVercelAIMessages))
+            .filter(Boolean)
+            .flat()),
+        onExportExternalState: () => {
+            // Export the thread's MessageRepository
+            const exported = runtimeRef.current.thread.export();
+            // Convert each ThreadMessage back to its original UI_MESSAGE format
+            const result = {
+                messages: exported.messages.map((item) => ({
+                    parentId: item.parentId,
+                    message: getExternalStoreMessages(item.message)[0],
+                })),
+            };
+            // Only include headId if it's defined
+            if (exported.headId !== undefined) {
+                result.headId = exported.headId;
+            }
+            return result;
+        },
+        onLoadExternalState: (repo) => {
+            // Convert MessageFormatRepository to ExportedMessageRepository
+            const exportedRepo = toExportedMessageRepository(AISDKMessageConverter.toThreadMessages, repo);
+            // Import into the thread's MessageRepository
+            runtimeRef.current.thread.import(exportedRepo);
+        },
+        onCancel: async () => {
+            chatHelpers.stop();
+            await toolInvocations.abort();
+        },
+        onNew: async (message) => {
+            await completePendingToolCalls();
+            const createMessage = (customToCreateMessage !== null && customToCreateMessage !== void 0 ? customToCreateMessage : toCreateMessage)(message);
+            await chatHelpers.sendMessage(createMessage, {
+                metadata: message.runConfig,
+            });
+        },
+        onEdit: async (message) => {
+            const newMessages = sliceMessagesUntil(chatHelpers.messages, message.parentId);
+            chatHelpers.setMessages(newMessages);
+            const createMessage = (customToCreateMessage !== null && customToCreateMessage !== void 0 ? customToCreateMessage : toCreateMessage)(message);
+            await chatHelpers.sendMessage(createMessage, {
+                metadata: message.runConfig,
+            });
+        },
+        onReload: async (parentId, config) => {
+            const newMessages = sliceMessagesUntil(chatHelpers.messages, parentId);
+            chatHelpers.setMessages(newMessages);
+            await chatHelpers.regenerate({ metadata: config.runConfig });
+        },
+        onAddToolResult: ({ toolCallId, result, isError }) => {
+            if (isError) {
+                chatHelpers.addToolOutput({
+                    state: "output-error",
+                    tool: toolCallId,
+                    toolCallId,
+                    errorText: typeof result === "string" ? result : JSON.stringify(result),
+                });
+            }
+            else {
+                chatHelpers.addToolOutput({
+                    state: "output-available",
+                    tool: toolCallId,
+                    toolCallId,
+                    output: result,
+                });
+            }
+        },
+        onResumeToolCall: (options) => toolInvocations.resume(options.toolCallId, options.payload),
+        adapters: Object.assign(Object.assign({ attachments: vercelAttachmentAdapter }, contextAdapters), adapters),
+        isLoading,
+    });
+    return runtime;
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/useChatRuntime.d.ts

@@ -0,0 +1,11 @@
+import { type UIMessage } from "@ai-sdk/react";
+import type { AssistantCloud } from "assistant-cloud";
+import { AssistantRuntime } from "@assistant-ui/react";
+import { type AISDKRuntimeAdapter, type CustomToCreateMessageFunction } from "./useAISDKRuntime";
+import { ChatInit } from "ai";
+export type UseChatRuntimeOptions<UI_MESSAGE extends UIMessage = UIMessage> = ChatInit<UI_MESSAGE> & {
+    cloud?: AssistantCloud | undefined;
+    adapters?: AISDKRuntimeAdapter["adapters"] | undefined;
+    toCreateMessage?: CustomToCreateMessageFunction;
+};
+export declare const useChatRuntime: <UI_MESSAGE extends UIMessage = UIMessage>({ cloud, ...options }?: UseChatRuntimeOptions<UI_MESSAGE>) => AssistantRuntime;

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/useChatRuntime.js

@@ -0,0 +1,55 @@
+"use client";
+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 { useChat } from "@ai-sdk/react";
+import { unstable_useCloudThreadListAdapter, unstable_useRemoteThreadListRuntime, useAuiState, } from "@assistant-ui/react";
+import { useAISDKRuntime, } from "./useAISDKRuntime";
+import { AssistantChatTransport } from "./AssistantChatTransport";
+import { useEffect, useMemo, useRef } from "react";
+const useDynamicChatTransport = (transport) => {
+    const transportRef = useRef(transport);
+    useEffect(() => {
+        transportRef.current = transport;
+    });
+    const dynamicTransport = useMemo(() => new Proxy(transportRef.current, {
+        get(_, prop) {
+            const res = transportRef.current[prop];
+            return typeof res === "function"
+                ? res.bind(transportRef.current)
+                : res;
+        },
+    }), []);
+    return dynamicTransport;
+};
+const useChatThreadRuntime = (options) => {
+    const _a = options !== null && options !== void 0 ? options : {}, { adapters, transport: transportOptions, toCreateMessage } = _a, chatOptions = __rest(_a, ["adapters", "transport", "toCreateMessage"]);
+    const transport = useDynamicChatTransport(transportOptions !== null && transportOptions !== void 0 ? transportOptions : new AssistantChatTransport());
+    const id = useAuiState(({ threadListItem }) => threadListItem.id);
+    const chat = useChat(Object.assign(Object.assign({}, chatOptions), { id,
+        transport }));
+    const runtime = useAISDKRuntime(chat, Object.assign({ adapters }, (toCreateMessage && { toCreateMessage })));
+    if (transport instanceof AssistantChatTransport) {
+        transport.setRuntime(runtime);
+    }
+    return runtime;
+};
+export const useChatRuntime = (_a = {}) => {
+    var { cloud } = _a, options = __rest(_a, ["cloud"]);
+    const cloudAdapter = unstable_useCloudThreadListAdapter({ cloud });
+    return unstable_useRemoteThreadListRuntime({
+        runtimeHook: function RuntimeHook() {
+            return useChatThreadRuntime(options);
+        },
+        adapter: cloudAdapter,
+        allowNesting: true,
+    });
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/useExternalHistory.d.ts

@@ -0,0 +1,4 @@
+import { AssistantRuntime, ThreadHistoryAdapter, ThreadMessage, MessageFormatAdapter, MessageFormatRepository, ExportedMessageRepository } from "@assistant-ui/react";
+import { RefObject } from "react";
+export declare const toExportedMessageRepository: <TMessage>(toThreadMessages: (messages: TMessage[]) => ThreadMessage[], messages: MessageFormatRepository<TMessage>) => ExportedMessageRepository;
+export declare const useExternalHistory: <TMessage>(runtimeRef: RefObject<AssistantRuntime>, historyAdapter: ThreadHistoryAdapter | undefined, toThreadMessages: (messages: TMessage[]) => ThreadMessage[], storageFormatAdapter: MessageFormatAdapter<TMessage, any>, onSetMessages: (messages: TMessage[]) => void) => boolean;

package/dist/vendor/assistant-ui-ai-sdk/src/ui/use-chat/useExternalHistory.js

@@ -0,0 +1,91 @@
+"use client";
+import { getExternalStoreMessages, INTERNAL, useAui, } from "@assistant-ui/react";
+import { useRef, useEffect, useState, useCallback } from "react";
+const { MessageRepository } = INTERNAL;
+export const toExportedMessageRepository = (toThreadMessages, messages) => {
+    return {
+        headId: messages.headId,
+        messages: messages.messages.map((m) => {
+            const message = toThreadMessages([m.message])[0];
+            return Object.assign(Object.assign({}, m), { message });
+        }),
+    };
+};
+export const useExternalHistory = (runtimeRef, historyAdapter, toThreadMessages, storageFormatAdapter, onSetMessages) => {
+    const loadedRef = useRef(false);
+    const aui = useAui();
+    const optionalThreadListItem = useCallback(() => (aui.threadListItem.source ? aui.threadListItem() : null), [aui]);
+    const [isLoading, setIsLoading] = useState(false);
+    const historyIds = useRef(new Set());
+    const onSetMessagesRef = useRef(() => onSetMessages);
+    useEffect(() => {
+        onSetMessagesRef.current = onSetMessages;
+    });
+    // Load messages from history adapter on mount
+    useEffect(() => {
+        var _a;
+        if (!historyAdapter || loadedRef.current)
+            return;
+        const loadHistory = async () => {
+            var _a;
+            setIsLoading(true);
+            try {
+                const repo = await ((_a = historyAdapter
+                    .withFormat) === null || _a === void 0 ? void 0 : _a.call(historyAdapter, storageFormatAdapter).load());
+                if (repo && repo.messages.length > 0) {
+                    const converted = toExportedMessageRepository(toThreadMessages, repo);
+                    runtimeRef.current.thread.import(converted);
+                    const tempRepo = new MessageRepository();
+                    tempRepo.import(converted);
+                    const messages = tempRepo.getMessages();
+                    onSetMessagesRef.current(messages.map((getExternalStoreMessages)).flat());
+                    historyIds.current = new Set(converted.messages.map((m) => m.message.id));
+                }
+            }
+            catch (error) {
+                console.error("Failed to load message history:", error);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        if (!loadedRef.current) {
+            loadedRef.current = true;
+            if (!((_a = optionalThreadListItem()) === null || _a === void 0 ? void 0 : _a.getState().remoteId)) {
+                setIsLoading(false);
+                return;
+            }
+            loadHistory();
+        }
+    }, [
+        historyAdapter,
+        storageFormatAdapter,
+        toThreadMessages,
+        runtimeRef,
+        optionalThreadListItem,
+    ]);
+    useEffect(() => {
+        return runtimeRef.current.thread.subscribe(async () => {
+            var _a;
+            const { messages, isRunning } = runtimeRef.current.thread.getState();
+            if (isRunning)
+                return;
+            for (let i = 0; i < messages.length; i++) {
+                const message = messages[i];
+                if (message.status === undefined ||
+                    message.status.type === "complete" ||
+                    message.status.type === "incomplete") {
+                    if (historyIds.current.has(message.id))
+                        continue;
+                    historyIds.current.add(message.id);
+                    const parentId = i > 0 ? messages[i - 1].id : null;
+                    await ((_a = historyAdapter === null || historyAdapter === void 0 ? void 0 : historyAdapter.withFormat) === null || _a === void 0 ? void 0 : _a.call(historyAdapter, storageFormatAdapter).append({
+                        parentId,
+                        message: getExternalStoreMessages(message)[0],
+                    }));
+                }
+            }
+        });
+    }, [historyAdapter, storageFormatAdapter, runtimeRef]);
+    return isLoading;
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/utils/convertMessage.d.ts

@@ -0,0 +1,15 @@
+import { type UIMessage } from "ai";
+import { type useExternalMessageConverter } from "@assistant-ui/react";
+export declare const AISDKMessageConverter: {
+    useThreadMessages: ({ messages, isRunning, joinStrategy, metadata, }: {
+        messages: UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>[];
+        isRunning: boolean;
+        joinStrategy?: "concat-content" | "none" | undefined;
+        metadata?: useExternalMessageConverter.Metadata;
+    }) => import("@assistant-ui/react").ThreadMessage[];
+    toThreadMessages: (messages: UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>[], isRunning?: boolean, metadata?: useExternalMessageConverter.Metadata) => import("@assistant-ui/react").ThreadMessage[];
+    toOriginalMessages: (input: import("@assistant-ui/react").ThreadState | import("@assistant-ui/react").ThreadMessage | import("@assistant-ui/react").ThreadMessage["content"][number]) => unknown[];
+    toOriginalMessage: (input: import("@assistant-ui/react").ThreadState | import("@assistant-ui/react").ThreadMessage | import("@assistant-ui/react").ThreadMessage["content"][number]) => {};
+    useOriginalMessage: () => any;
+    useOriginalMessages: () => any;
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/utils/convertMessage.js

@@ -0,0 +1,159 @@
+import { isToolUIPart, getToolName } from "ai";
+import { unstable_createMessageConverter, } from "@assistant-ui/react";
+function stripClosingDelimiters(json) {
+    return json.replace(/[}\]"]+$/, "");
+}
+const convertParts = (message, metadata) => {
+    if (!message.parts || message.parts.length === 0) {
+        return [];
+    }
+    return message.parts
+        .filter((p) => p.type !== "step-start" && p.type !== "file")
+        .map((part) => {
+        var _a;
+        const type = part.type;
+        // Handle text parts
+        if (type === "text") {
+            return {
+                type: "text",
+                text: part.text,
+            };
+        }
+        // Handle reasoning parts
+        if (type === "reasoning") {
+            return {
+                type: "reasoning",
+                text: part.text,
+            };
+        }
+        // Handle tool parts (both static tool-* and dynamic-tool)
+        // In AI SDK v6, isToolUIPart returns true for both static and dynamic tools
+        if (isToolUIPart(part)) {
+            // Use getToolName which works for both static and dynamic tools
+            const toolName = getToolName(part);
+            const toolCallId = part.toolCallId;
+            // Extract args and result based on state
+            let args = {};
+            let result;
+            let isError = false;
+            if (part.state === "input-streaming" ||
+                part.state === "input-available") {
+                args = part.input || {};
+            }
+            else if (part.state === "output-available") {
+                args = part.input || {};
+                result = part.output;
+            }
+            else if (part.state === "output-error") {
+                args = part.input || {};
+                isError = true;
+                result = { error: part.errorText };
+            }
+            let argsText = JSON.stringify(args);
+            if (part.state === "input-streaming") {
+                // the argsText is not complete, so we need to strip the closing delimiters
+                // these are added by the AI SDK in fix-json
+                argsText = stripClosingDelimiters(argsText);
+            }
+            const toolStatus = (_a = metadata.toolStatuses) === null || _a === void 0 ? void 0 : _a[toolCallId];
+            return Object.assign({ type: "tool-call", toolName,
+                toolCallId,
+                argsText,
+                args,
+                result,
+                isError }, ((toolStatus === null || toolStatus === void 0 ? void 0 : toolStatus.type) === "interrupt" && {
+                interrupt: toolStatus.payload,
+                status: {
+                    type: "requires-action",
+                    reason: "interrupt",
+                },
+            }));
+        }
+        // Handle source-url parts
+        if (type === "source-url") {
+            return {
+                type: "source",
+                sourceType: "url",
+                id: part.sourceId,
+                url: part.url,
+                title: part.title || "",
+            };
+        }
+        // Handle source-document parts
+        if (type === "source-document") {
+            console.warn(`Source document part type ${type} is not yet supported in conversion`);
+            return null;
+        }
+        // Handle data-* parts (AI SDK v5 data parts)
+        if (type.startsWith("data-")) {
+            const name = type.substring(5);
+            return {
+                type: "data",
+                name,
+                data: part.data,
+            };
+        }
+        // For unsupported types, we'll skip them instead of throwing
+        console.warn(`Unsupported message part type: ${type}`);
+        return null;
+    })
+        .filter(Boolean);
+};
+export const AISDKMessageConverter = unstable_createMessageConverter((message, metadata) => {
+    var _a;
+    // UIMessage doesn't have createdAt, so we'll use current date or undefined
+    const createdAt = new Date();
+    switch (message.role) {
+        case "user":
+            return {
+                role: "user",
+                id: message.id,
+                createdAt,
+                content: convertParts(message, metadata),
+                attachments: (_a = message.parts) === null || _a === void 0 ? void 0 : _a.filter((p) => p.type === "file").map((part, idx) => {
+                    var _a, _b;
+                    return {
+                        id: idx.toString(),
+                        type: part.mediaType.startsWith("image/") ? "image" : "file",
+                        name: (_a = part.filename) !== null && _a !== void 0 ? _a : "file",
+                        content: [
+                            part.mediaType.startsWith("image/")
+                                ? {
+                                    type: "image",
+                                    image: part.url,
+                                    filename: part.filename,
+                                }
+                                : {
+                                    type: "file",
+                                    filename: part.filename,
+                                    data: part.url,
+                                    mimeType: part.mediaType,
+                                },
+                        ],
+                        contentType: (_b = part.mediaType) !== null && _b !== void 0 ? _b : "unknown/unknown",
+                        status: { type: "complete" },
+                    };
+                }),
+                metadata: message.metadata,
+            };
+        case "system":
+            return {
+                role: "system",
+                id: message.id,
+                createdAt,
+                content: convertParts(message, metadata),
+                metadata: message.metadata,
+            };
+        case "assistant":
+            return {
+                role: "assistant",
+                id: message.id,
+                createdAt,
+                content: convertParts(message, metadata),
+                metadata: message.metadata,
+            };
+        default:
+            console.warn(`Unsupported message role: ${message.role}`);
+            return [];
+    }
+});

package/dist/vendor/assistant-ui-ai-sdk/src/ui/utils/sliceMessagesUntil.d.ts

@@ -0,0 +1,2 @@
+import type { UIMessage } from "ai";
+export declare const sliceMessagesUntil: <UI_MESSAGE extends UIMessage = UIMessage>(messages: UI_MESSAGE[], messageId: string | null) => UI_MESSAGE[];

package/dist/vendor/assistant-ui-ai-sdk/src/ui/utils/sliceMessagesUntil.js

@@ -0,0 +1,12 @@
+export const sliceMessagesUntil = (messages, messageId) => {
+    var _a;
+    if (messageId == null)
+        return [];
+    let messageIdx = messages.findIndex((m) => m.id === messageId);
+    if (messageIdx === -1)
+        throw new Error("useVercelAIThreadState: Message not found. This is likely an internal bug in assistant-ui.");
+    while (((_a = messages[messageIdx + 1]) === null || _a === void 0 ? void 0 : _a.role) === "assistant") {
+        messageIdx++;
+    }
+    return messages.slice(0, messageIdx + 1);
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/utils/toCreateMessage.d.ts

@@ -0,0 +1,3 @@
+import { AppendMessage } from "@assistant-ui/react";
+import { CreateUIMessage, UIMessage } from "ai";
+export declare const toCreateMessage: <UI_MESSAGE extends UIMessage = UIMessage>(message: AppendMessage) => CreateUIMessage<UI_MESSAGE>;

package/dist/vendor/assistant-ui-ai-sdk/src/ui/utils/toCreateMessage.js

@@ -0,0 +1,27 @@
+export const toCreateMessage = (message) => {
+    var _a, _b;
+    const inputParts = [
+        ...message.content.filter((c) => c.type !== "file"),
+        ...((_b = (_a = message.attachments) === null || _a === void 0 ? void 0 : _a.flatMap((a) => a.content.map((c) => (Object.assign(Object.assign({}, c), { filename: a.name }))))) !== null && _b !== void 0 ? _b : []),
+    ];
+    const parts = inputParts.map((part) => {
+        switch (part.type) {
+            case "text":
+                return {
+                    type: "text",
+                    text: part.text,
+                };
+            case "image":
+                return Object.assign(Object.assign({ type: "file", url: part.image }, (part.filename && { filename: part.filename })), { mediaType: "image/png" });
+            case "file":
+                return Object.assign({ type: "file", url: part.data, mediaType: part.mimeType }, (part.filename && { filename: part.filename }));
+            default:
+                throw new Error(`Unsupported part type: ${part.type}`);
+        }
+    });
+    return {
+        role: message.role,
+        parts,
+        metadata: message.metadata,
+    };
+};

package/dist/vendor/assistant-ui-ai-sdk/src/ui/utils/vercelAttachmentAdapter.d.ts

@@ -0,0 +1,2 @@
+import { AttachmentAdapter } from "@assistant-ui/react";
+export declare const vercelAttachmentAdapter: AttachmentAdapter;