@agent-native/core 0.196.0 → 0.196.1-nightly-20260928200103

package/dist/client/AgentKitAssistantChat.js

@@ -1,4 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { hasActiveAgentRuns, } from "@agent-native/agentkit";
 import { AgentKitChat, AgentKitComposer, AgentApprovalPrompt, AgentMessageView, useAgentKit, useAgentKitControl, useAgentThread, } from "@agent-native/agentkit/react";
 import { AgentKitRoot } from "@agent-native/agentkit/react/root";
 import { AgentSuggestionBar, agentSuggestionPrompt, } from "@agent-native/toolkit/composer";
@@ -577,7 +578,7 @@ export const AgentKitAssistantChat = forwardRef(function AgentKitAssistantChat(p
                 }, children: history ? (_jsx(AgentKitHistoryProvider, { history: history, children: _jsx(AgentKitDevCheckpointProvider, { apiUrl: props.apiUrl ?? agentNativePath("/_agent-native/agent-chat"), children: _jsx(AgentKitAssistantChatBody, { ...props, threadId: threadId, handoffSnapshot: handoffSnapshot, getThreadSnapshot: getThreadSnapshot, threadRestore: threadRestore, retryThreadRestore: retryThreadRestore, onThreadRestoreLoaded: onThreadRestoreLoaded, ref: ref }) }) })) : (_jsx(AgentKitDevCheckpointProvider, { apiUrl: props.apiUrl ?? agentNativePath("/_agent-native/agent-chat"), children: _jsx(AgentKitAssistantChatBody, { ...props, threadId: threadId, handoffSnapshot: handoffSnapshot, getThreadSnapshot: getThreadSnapshot, threadRestore: threadRestore, retryThreadRestore: retryThreadRestore, onThreadRestoreLoaded: onThreadRestoreLoaded, ref: ref }) })) }) }) }));
 });
 const AgentKitAssistantChatBody = forwardRef(function AgentKitAssistantChatBody(props, ref) {
-    const { threadId, requestComposerFocus } = useAgentKit();
+    const { controller, threadId, requestComposerFocus } = useAgentKit();
     const control = useAgentKitControl(threadId);
     const thread = useAgentThread(threadId);
     const history = useOptionalAgentKitHistory();
@@ -701,7 +702,8 @@ const AgentKitAssistantChatBody = forwardRef(function AgentKitAssistantChatBody(
     const latestAssistant = useMemo(() => [...thread.messages]
         .reverse()
         .find((message) => message.role === "assistant"), [thread.messages]);
-    const isRunning = thread.activeRunIds.length > 0;
+    const isRunning = hasActiveAgentRuns(thread);
+    const isThreadRunning = useCallback(() => hasActiveAgentRuns(controller.getThread(threadId)), [controller, threadId]);
     useEffect(() => {
         if (previousPrefillRevisionRef.current === prefillRevision)
             return;
@@ -1541,7 +1543,7 @@ const AgentKitAssistantChatBody = forwardRef(function AgentKitAssistantChatBody(
         thread.queuedMessages,
         threadId,
     ]);
-    const send = useCallback(async (text, images, options) => submit(text, [], [], { intent: isRunning ? "queued" : "immediate" }, {
+    const send = useCallback(async (text, images, options) => submit(text, [], [], { intent: isThreadRunning() ? "queued" : "immediate" }, {
         ...options,
         attachments: [
             ...(options?.attachments ?? []),
@@ -1551,9 +1553,9 @@ const AgentKitAssistantChatBody = forwardRef(function AgentKitAssistantChatBody(
                 url,
             })),
         ],
-    }), [isRunning, submit]);
+    }), [isThreadRunning, submit]);
     const sendRecoveryMessage = useCallback(async (text, recoveryAction, images, attachments, references, recoveryOptions) => {
-        return submit(text, [], [], { intent: isRunning ? "queued" : "immediate" }, {
+        return submit(text, [], [], { intent: isThreadRunning() ? "queued" : "immediate" }, {
             hideUserMessage: true,
             recoveryAction,
             recoveryReferences: references,
@@ -1567,7 +1569,7 @@ const AgentKitAssistantChatBody = forwardRef(function AgentKitAssistantChatBody(
                 })),
             ],
         });
-    }, [isRunning, submit]);
+    }, [isThreadRunning, submit]);
     const resumeIntegrationPrompt = useCallback((message) => {
         if (props.isActiveComposer === false)
             return;
@@ -1576,10 +1578,10 @@ const AgentKitAssistantChatBody = forwardRef(function AgentKitAssistantChatBody(
         });
     }, [props.isActiveComposer, props.tabId, send, threadId]);
     const submitSuggestion = useCallback((prompt) => void submit(prompt, [], [], {
-        intent: isRunning ? "queued" : "immediate",
+        intent: isThreadRunning() ? "queued" : "immediate",
     }).catch((error) => {
         dispatchSetupRequiredEvent(error, props.tabId, threadId);
-    }), [isRunning, props.tabId, submit, threadId]);
+    }), [isThreadRunning, props.tabId, submit, threadId]);
     const retryDeferredSubmission = useCallback(async () => {
         if (!deferredProviderSubmissionFailureId)
             return;
@@ -1659,7 +1661,7 @@ const AgentKitAssistantChatBody = forwardRef(function AgentKitAssistantChatBody(
                 url,
             })),
         }),
-        isRunning: () => thread.activeRunIds.length > 0,
+        isRunning: isThreadRunning,
         hasInFlightWork: () => Object.values(thread.tools).some((tool) => tool.status === "running") ||
             Object.values(thread.activities).some((activity) => activity.status === "running"),
         focusComposer: () => requestComposerFocus(threadId),
@@ -1787,6 +1789,7 @@ function AgentKitSelectionPill({ length, onClear, }) {
                     }) }), _jsx("button", { type: "button", "aria-label": t("agentChat.selection.clear"), onClick: onClear, className: "flex h-4 w-4 items-center justify-center rounded text-muted-foreground hover:bg-accent/60 hover:text-foreground", children: _jsx(IconX, { size: 11, "aria-hidden": "true" }) })] }) }));
 }
 function AgentKitTranscript({ children, threadId }) {
+    const { controller } = useAgentKit();
     const surface = useAgentKitSurface();
     const t = useT();
     const thread = useAgentThread(threadId);
@@ -1800,11 +1803,19 @@ function AgentKitTranscript({ children, threadId }) {
         browserTabId: surface.props.browserTabId,
         threadId,
         onSubmitMessage: async ({ message, context }) => {
-            await surface.onSubmit(appendAgentChatContextToMessage(message, context), [], [], { intent: surface.isRunning ? "queued" : "immediate" });
+            await surface.onSubmit(appendAgentChatContextToMessage(message, context), [], [], {
+                intent: hasActiveAgentRuns(controller.getThread(threadId))
+                    ? "queued"
+                    : "immediate",
+            });
             return { delivered: true };
         },
         onSkipMessage: async ({ message, context }) => {
-            await surface.onSubmit(appendAgentChatContextToMessage(message, context), [], [], { intent: surface.isRunning ? "queued" : "immediate" });
+            await surface.onSubmit(appendAgentChatContextToMessage(message, context), [], [], {
+                intent: hasActiveAgentRuns(controller.getThread(threadId))
+                    ? "queued"
+                    : "immediate",
+            });
             return { delivered: true };
         },
     });
@@ -2035,7 +2046,7 @@ function AgentKitMessageSupplement(props) {
         .join("\n");
     const integration = value.role === "assistant" &&
         value.status === "complete" &&
-        thread.activeRunIds.length === 0
+        !hasActiveAgentRuns(thread)
         ? findMcpConnectionSuggestionIntegration({
             text,
             contextText,

package/dist/client/chat/agentkit-agent-native.js

@@ -1,4 +1,4 @@
-import { parseAgentThreadSnapshot } from "@agent-native/agentkit/protocol";
+import { isAgentKitProtocolVersion, parseAgentThreadSnapshot, } from "@agent-native/agentkit/protocol";
 import { agentNativePath } from "../api-path.js";
 import { dispatchAgentChatRunning } from "../use-agent-chat-running-threads.js";
 import { appendChatThreadScopeParams, } from "../use-chat-threads.js";
@@ -285,6 +285,249 @@ function storedRepository(stored) {
     }
     return repository;
 }
+function persistedError(value) {
+    const error = asRecord(value);
+    if (typeof error?.code !== "string" || typeof error.message !== "string") {
+        throw new TypeError("Agent chat run errors must include a code and message.");
+    }
+    const persisted = {
+        code: error.code.slice(0, 128),
+        message: error.message.slice(0, 2_048),
+    };
+    if (typeof error.retryable === "boolean") {
+        persisted.retryable = error.retryable;
+    }
+    if (typeof error.correlationId === "string") {
+        persisted.correlationId = error.correlationId.slice(0, 128);
+    }
+    if (error.code === "capability_unsupported" ||
+        error.code === "capability_unavailable") {
+        persisted.capability =
+            typeof error.capability === "string"
+                ? error.capability.slice(0, 128)
+                : "x-unknown";
+        persisted.retryable =
+            error.code === "capability_unsupported"
+                ? false
+                : typeof error.retryable === "boolean"
+                    ? error.retryable
+                    : false;
+    }
+    else if (error.code === "operation_unsupported") {
+        persisted.operation =
+            typeof error.operation === "string"
+                ? error.operation.slice(0, 128)
+                : "unknown";
+        persisted.retryable = false;
+    }
+    else if (error.code === "protocol_version_unsupported") {
+        persisted.supportedVersions = Array.isArray(error.supportedVersions)
+            ? error.supportedVersions.filter(isAgentKitProtocolVersion).slice(0, 32)
+            : [];
+        persisted.receivedVersions = Array.isArray(error.receivedVersions)
+            ? error.receivedVersions
+                .filter((version) => Number.isSafeInteger(version) && Number(version) > 0)
+                .slice(0, 32)
+            : [];
+        persisted.retryable = false;
+    }
+    return persisted;
+}
+function persistedAnnotation(annotation) {
+    return {
+        id: annotation.id,
+        kind: annotation.kind,
+        label: annotation.label,
+        ...(annotation.url ? { url: annotation.url } : {}),
+        ...(annotation.start !== undefined ? { start: annotation.start } : {}),
+        ...(annotation.end !== undefined ? { end: annotation.end } : {}),
+    };
+}
+function persistedAnnotations(annotations = [], messageIds) {
+    return annotations.flatMap(({ messageId, annotation }) => messageIds.has(messageId)
+        ? [{ messageId, annotation: persistedAnnotation(annotation) }]
+        : []);
+}
+function persistedFileUrl(url) {
+    return url && !/^\s*data:/i.test(url) ? url : undefined;
+}
+function persistedHistoryEvents(events = []) {
+    const sequenceByRun = new Map();
+    return events.flatMap((event) => {
+        const base = () => {
+            const sequence = (sequenceByRun.get(event.runId) ?? 0) + 1;
+            sequenceByRun.set(event.runId, sequence);
+            return {
+                id: event.id,
+                threadId: event.threadId,
+                runId: event.runId,
+                sequence,
+                occurredAt: event.occurredAt,
+            };
+        };
+        if (event.type === "run.started") {
+            return [{ ...base(), type: event.type }];
+        }
+        if (event.type === "run.completed" || event.type === "run.cancelled") {
+            return [{ ...base(), type: event.type }];
+        }
+        if (event.type === "run.failed") {
+            return [
+                { ...base(), type: event.type, error: persistedError(event.error) },
+            ];
+        }
+        if (event.type === "run.status") {
+            return [{ ...base(), type: event.type, status: event.status }];
+        }
+        if (event.type === "activity.started" ||
+            event.type === "activity.updated" ||
+            event.type === "activity.completed") {
+            const activity = event.activity;
+            return [
+                {
+                    ...base(),
+                    type: event.type,
+                    activity: {
+                        id: activity.id,
+                        kind: activity.kind,
+                        label: activity.label,
+                        status: activity.status,
+                        ...(activity.runId ? { runId: activity.runId } : {}),
+                        ...(activity.agentId ? { agentId: activity.agentId } : {}),
+                        ...(activity.startedAt ? { startedAt: activity.startedAt } : {}),
+                        ...(activity.completedAt
+                            ? { completedAt: activity.completedAt }
+                            : {}),
+                    },
+                },
+            ];
+        }
+        if (event.type === "message.completed" &&
+            event.message.role === "assistant") {
+            return [
+                {
+                    ...base(),
+                    type: event.type,
+                    message: {
+                        id: event.message.id,
+                        role: event.message.role,
+                        parts: event.message.parts.filter((part) => part.type === "text"),
+                        ...(event.message.createdAt
+                            ? { createdAt: event.message.createdAt }
+                            : {}),
+                        ...(event.message.status ? { status: event.message.status } : {}),
+                    },
+                },
+            ];
+        }
+        return [];
+    });
+}
+function persistedMessages(messages) {
+    return messages.map((message) => ({
+        id: message.id,
+        role: message.role,
+        parts: message.parts.flatMap((part) => {
+            if (part.type === "text") {
+                return [
+                    {
+                        type: "text",
+                        text: part.text,
+                        ...(part.format ? { format: part.format } : {}),
+                    },
+                ];
+            }
+            if (part.type === "citation") {
+                return [
+                    {
+                        type: "citation",
+                        title: part.title,
+                        ...(part.url ? { url: part.url } : {}),
+                        ...(part.sourceId ? { sourceId: part.sourceId } : {}),
+                    },
+                ];
+            }
+            if (part.type === "annotation") {
+                return [
+                    {
+                        type: "annotation",
+                        annotation: persistedAnnotation(part.annotation),
+                    },
+                ];
+            }
+            if (part.type === "file") {
+                const url = persistedFileUrl(part.url);
+                if (!url && !part.fileId)
+                    return [];
+                return [
+                    {
+                        type: "file",
+                        name: part.name,
+                        ...(part.mediaType ? { mediaType: part.mediaType } : {}),
+                        ...(url ? { url } : {}),
+                        ...(part.fileId ? { fileId: part.fileId } : {}),
+                    },
+                ];
+            }
+            return [];
+        }),
+        ...(message.createdAt ? { createdAt: message.createdAt } : {}),
+        ...(message.status ? { status: message.status } : {}),
+        ...(asRecord(message.metadata)?.hideUserMessage === true
+            ? { metadata: { hideUserMessage: true } }
+            : {}),
+    }));
+}
+function persistedActionWidgets(widgets = [], messageIds) {
+    return widgets.flatMap(({ messageId, widget }) => {
+        if (!messageIds.has(messageId))
+            return [];
+        const data = asRecord(widget.data);
+        if (typeof data?.toolCallId !== "string" ||
+            typeof data.toolName !== "string") {
+            return [];
+        }
+        const description = asRecord(widget.metadata)?.description;
+        return [
+            {
+                messageId,
+                widget: {
+                    id: widget.id,
+                    kind: widget.kind,
+                    data: { toolCallId: data.toolCallId, toolName: data.toolName },
+                    ...(widget.title ? { title: widget.title } : {}),
+                    ...(typeof description === "string"
+                        ? { metadata: { description } }
+                        : {}),
+                },
+            },
+        ];
+    });
+}
+function persistedToolCalls(toolCalls = []) {
+    return toolCalls.flatMap((toolCall) => {
+        const serialized = JSON.stringify(toolCall);
+        if (serialized &&
+            new TextEncoder().encode(serialized).byteLength <= 64 * 1024) {
+            return [JSON.parse(serialized)];
+        }
+        return [
+            {
+                id: toolCall.id,
+                name: toolCall.name,
+                status: toolCall.status,
+                ...(toolCall.runId ? { runId: toolCall.runId } : {}),
+                ...(toolCall.messageId ? { messageId: toolCall.messageId } : {}),
+                metadata: {
+                    agentKitSnapshot: {
+                        toolCallResult: "omitted",
+                        reason: serialized ? "size_limit" : "not_json",
+                    },
+                },
+            },
+        ];
+    });
+}
 function storedMessageId(value) {
     const outer = asRecord(value);
     const message = asRecord(outer?.message ?? outer);
@@ -452,6 +695,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
         const createdAt = timestamp(stored.createdAt, projectedAt);
         const updatedAt = timestamp(stored.updatedAt, createdAt);
         const repository = storedRepository(stored);
+        const storedMessageProjection = storedMessages(repository.messages, now, options.adapter?.textFormat);
         const queuedMessages = storedQueue(repository.queuedMessages, threadId, updatedAt);
         const agentKit = asRecord(repository.agentKit);
         const protocolSnapshot = agentKit
@@ -461,13 +705,17 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                 createdAt,
                 updatedAt,
                 metadata: asRecord(stored.metadata) ?? undefined,
-                messages: agentKit.messages,
+                messages: Array.isArray(agentKit.messages)
+                    ? agentKit.messages
+                    : storedMessageProjection,
                 events: agentKit.events,
                 runs: agentKit.runs,
                 activeRunIds: agentKit.activeRunIds,
+                suggestions: agentKit.suggestions,
                 toolCalls: agentKit.toolCalls,
                 activities: agentKit.activities,
                 widgets: agentKit.widgets,
+                annotations: agentKit.annotations,
             })
             : undefined;
         const durableMessages = storedMessages(repository.messages, now, options.adapter?.textFormat);
@@ -475,14 +723,52 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             ? reconcileDurableAssistantText(protocolSnapshot.messages, durableMessages, protocolSnapshot.events)
             : durableMessages;
         const actionWidgets = storedActionWidgets(repository.messages);
+        const canonicalToolCallMessageIds = new Map((protocolSnapshot?.toolCalls ?? []).flatMap((toolCall) => toolCall.messageId ? [[toolCall.id, toolCall.messageId]] : []));
+        const embeddedWidgetIds = new Set(messages.flatMap((message) => message.parts.flatMap((part) => part.type === "widget" ? [part.widget.id] : [])));
+        const persistedWidgetIds = new Set([
+            ...(protocolSnapshot?.widgets ?? []).map(({ widget }) => widget.id),
+            ...embeddedWidgetIds,
+        ]);
+        const messageIds = new Set(messages.map((message) => message.id));
+        const reconciledActionWidgets = actionWidgets.widgets.map(({ messageId, widget }) => {
+            const toolCallId = asRecord(widget.data)?.toolCallId;
+            const canonicalMessageId = typeof toolCallId === "string"
+                ? canonicalToolCallMessageIds.get(toolCallId)
+                : undefined;
+            return {
+                messageId: canonicalMessageId && messageIds.has(canonicalMessageId)
+                    ? canonicalMessageId
+                    : messageId,
+                widget,
+            };
+        });
+        const widgetMessageIds = new Set(reconciledActionWidgets
+            .filter(({ widget }) => !persistedWidgetIds.has(widget.id))
+            .map(({ messageId }) => messageId));
+        for (const message of storedMessageProjection) {
+            if (!widgetMessageIds.has(message.id) || messageIds.has(message.id)) {
+                continue;
+            }
+            messages.push({
+                ...message,
+                parts: message.parts.filter((part) => part.type !== "data"),
+            });
+            messageIds.add(message.id);
+        }
+        for (const { messageId, widget } of reconciledActionWidgets) {
+            if (!persistedWidgetIds.has(widget.id) && !messageIds.has(messageId)) {
+                throw new TypeError(`Action widget ${widget.id} references missing message ${messageId}.`);
+            }
+        }
         const toolCalls = new Map((protocolSnapshot?.toolCalls ?? []).map((toolCall) => [toolCall.id, toolCall]));
         for (const toolCall of actionWidgets.toolCalls) {
             if (!toolCalls.has(toolCall.id))
                 toolCalls.set(toolCall.id, toolCall);
         }
         const widgets = new Map((protocolSnapshot?.widgets ?? []).map((widget) => [widget.widget.id, widget]));
-        for (const widget of actionWidgets.widgets) {
-            if (!widgets.has(widget.widget.id)) {
+        for (const widget of reconciledActionWidgets) {
+            if (!widgets.has(widget.widget.id) &&
+                !embeddedWidgetIds.has(widget.widget.id)) {
                 widgets.set(widget.widget.id, widget);
             }
         }
@@ -499,9 +785,15 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             ...(protocolSnapshot?.activeRunIds
                 ? { activeRunIds: protocolSnapshot.activeRunIds }
                 : {}),
+            ...(protocolSnapshot?.suggestions
+                ? { suggestions: protocolSnapshot.suggestions }
+                : {}),
             ...(protocolSnapshot?.activities
                 ? { activities: protocolSnapshot.activities }
                 : {}),
+            ...(protocolSnapshot?.annotations
+                ? { annotations: protocolSnapshot.annotations }
+                : {}),
             toolCalls: [...toolCalls.values()],
             widgets: [...widgets.values()],
         };
@@ -562,6 +854,78 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             ],
         };
     }
+    async function persistThreadSnapshot(input) {
+        const stored = await fetchThread(input.threadId);
+        if (!stored) {
+            throw new Error(`Agent chat thread ${input.threadId} does not exist.`);
+        }
+        const repository = storedRepository(stored);
+        const previousAgentKit = asRecord(repository.agentKit) ?? {};
+        const compactEvents = persistedHistoryEvents(input.snapshot.events);
+        const compactRunIds = new Set(compactEvents.map((event) => event.runId));
+        const eventsById = new Map();
+        const previousEvents = Array.isArray(previousAgentKit.events)
+            ? previousAgentKit.events
+            : [];
+        for (const event of previousEvents) {
+            const record = asRecord(event);
+            if (typeof record?.id === "string" &&
+                typeof record.runId === "string" &&
+                !compactRunIds.has(record.runId)) {
+                eventsById.set(record.id, event);
+            }
+        }
+        for (const event of compactEvents) {
+            eventsById.set(event.id, event);
+        }
+        const runsById = new Map();
+        const previousRuns = Array.isArray(previousAgentKit.runs)
+            ? previousAgentKit.runs
+            : [];
+        for (const run of [...previousRuns, ...(input.snapshot.runs ?? [])]) {
+            const record = asRecord(run);
+            if (typeof record?.id === "string")
+                runsById.set(record.id, run);
+        }
+        const snapshotMessageIds = new Set(input.snapshot.messages.map((message) => message.id));
+        const annotations = input.snapshot.annotations ??
+            (Array.isArray(previousAgentKit.annotations)
+                ? previousAgentKit.annotations
+                : []);
+        const agentKit = {
+            ...previousAgentKit,
+            messages: persistedMessages(input.snapshot.messages),
+            widgets: persistedActionWidgets(input.snapshot.widgets, new Set(input.snapshot.messages.map((message) => message.id))),
+            toolCalls: persistedToolCalls(input.snapshot.toolCalls),
+            events: [...eventsById.values()],
+            runs: [...runsById.values()].map((run) => {
+                const record = asRecord(run);
+                return record && record.error !== undefined
+                    ? { ...record, error: persistedError(record.error) }
+                    : run;
+            }),
+            activeRunIds: input.snapshot.activeRunIds ?? [],
+            suggestions: input.snapshot.suggestions ?? previousAgentKit.suggestions,
+            annotations: persistedAnnotations(annotations, snapshotMessageIds),
+        };
+        const requestHeaders = await headers({ sessionId: input.threadId });
+        requestHeaders.set("content-type", "application/json");
+        const snapshotRepository = { ...repository };
+        delete snapshotRepository.queuedMessages;
+        const response = await fetcher(scopedThreadEndpoint(`${apiUrl}/threads/${encodeURIComponent(input.threadId)}`, options), {
+            method: "PUT",
+            headers: requestHeaders,
+            body: JSON.stringify({
+                threadData: JSON.stringify({ ...snapshotRepository, agentKit }),
+                title: input.snapshot.title ??
+                    (typeof stored.title === "string" ? stored.title : ""),
+                preview: typeof stored.preview === "string" ? stored.preview : "",
+                messageCount: input.snapshot.messages.length,
+            }),
+        });
+        if (!response.ok)
+            throw await responseError(response);
+    }
     async function persistQueueMutation(threadId, mutation) {
         const requestHeaders = await headers({ sessionId: threadId });
         requestHeaders.set("content-type", "application/json");
@@ -641,6 +1005,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
         },
         operations: {
             ...options.operations,
+            persistThreadSnapshot: options.operations?.persistThreadSnapshot ?? persistThreadSnapshot,
             getThread: async ({ threadId }) => {
                 const thread = await snapshot(threadId);
                 if (!thread)
@@ -741,23 +1106,59 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                 let forkSource;
                 if (fromMessageId) {
                     const repository = storedRepository(source);
-                    if (!Array.isArray(repository.messages)) {
+                    const agentKit = asRecord(repository.agentKit);
+                    const sourceMessages = Array.isArray(agentKit?.messages)
+                        ? agentKit.messages
+                        : repository.messages;
+                    if (!Array.isArray(sourceMessages)) {
                         throw new Error("The Agent-Native thread cannot be forked from a message without durable history.");
                     }
-                    const throughIndex = repository.messages.findIndex((message) => storedMessageId(message) === fromMessageId);
+                    const throughIndex = sourceMessages.findIndex((message) => storedMessageId(message) === fromMessageId);
                     if (throughIndex < 0) {
                         throw new Error("Unknown message for fork: " + fromMessageId);
                     }
-                    const messages = repository.messages.slice(0, throughIndex + 1);
+                    const messages = sourceMessages.slice(0, throughIndex + 1);
+                    const retainedMessageIds = new Set(messages
+                        .map(storedMessageId)
+                        .filter((id) => Boolean(id)));
+                    const legacyMessages = Array.isArray(repository.messages)
+                        ? repository.messages.filter((message) => retainedMessageIds.has(storedMessageId(message) ?? ""))
+                        : undefined;
+                    const retainedAgentKit = agentKit && Array.isArray(agentKit.messages)
+                        ? {
+                            ...agentKit,
+                            messages,
+                            ...(Array.isArray(agentKit.widgets)
+                                ? {
+                                    widgets: agentKit.widgets.filter((entry) => {
+                                        const widget = asRecord(entry);
+                                        return (typeof widget?.messageId === "string" &&
+                                            retainedMessageIds.has(widget.messageId));
+                                    }),
+                                }
+                                : {}),
+                            ...(Array.isArray(agentKit.toolCalls)
+                                ? {
+                                    toolCalls: agentKit.toolCalls.filter((entry) => {
+                                        const toolCall = asRecord(entry);
+                                        return (typeof toolCall?.messageId !== "string" ||
+                                            retainedMessageIds.has(toolCall.messageId));
+                                    }),
+                                }
+                                : {}),
+                        }
+                        : undefined;
                     forkSource = {
                         threadData: JSON.stringify({
                             ...repository,
-                            messages,
+                            ...(legacyMessages ? { messages: legacyMessages } : {}),
+                            ...(retainedAgentKit ? { agentKit: retainedAgentKit } : {}),
                             queuedMessages: [],
                         }),
                         title: title ?? (typeof source.title === "string" ? source.title : ""),
                         preview: "",
                         messageCount: messages.length,
+                        fromMessageId,
                     };
                 }
                 const requestHeaders = await headers({ sessionId: threadId });

package/dist/client/chat/agentkit-protocol.js

@@ -2610,6 +2610,9 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         };
     }
     const hostOperations = options.operations;
+    if (hostOperations?.persistThreadSnapshot) {
+        transport.persistThreadSnapshot = hostOperations.persistThreadSnapshot;
+    }
     if (hostOperations?.createThread) {
         transport.createThread = (input = {}, context) => {
             const metadata = mergeTrustedProtocolMetadata(options.metadata, input.metadata);

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
     url?: undefined;
     id?: undefined;