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

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/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/notifications/routes.d.ts

@@ -16,6 +16,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/observability/routes.d.ts

@@ -20,27 +20,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
-    id?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
+    id?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
-    id?: undefined;
     summary?: undefined;
     spans?: undefined;
+    id?: undefined;
     error: any;
     ok?: undefined;
 } | {
-    error?: undefined;
-    id?: undefined;
     summary?: undefined;
     spans?: undefined;
+    id?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/org/handlers.d.ts

@@ -72,9 +72,9 @@ export declare const setWorkspaceAppDefaultVisibilityHandler: import("h3").Event
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     success: boolean;
-    id?: undefined;
     name?: undefined;
     role?: undefined;
+    id?: undefined;
 } | {
     success?: undefined;
     id: string;

package/dist/resources/handlers.d.ts

@@ -39,8 +39,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
     error: string;
 }>;
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.d.ts

@@ -55,31 +55,31 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
     errorCode?: undefined;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error: string;
     errorCode: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     errorCode?: undefined;
     ok: boolean;
     status: string;
     error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     removed: boolean;
     error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     note?: undefined;

package/dist/server/agent-chat-plugin.d.ts

@@ -1,6 +1,7 @@
 import type { Message as A2AMessage } from "../a2a/types.js";
 import { type ActionEntry, type AgentActionSurfaceDetails, type AgentActionSurfaceResolution } from "../agent/production-agent.js";
 import type { ActiveRun } from "../agent/run-manager.js";
+import { foldAssistantTurn } from "../agent/thread-data-builder.js";
 import type { AgentChatEvent, AgentChatScope } from "../agent/types.js";
 import type { ResolvedKeyReference } from "../secrets/substitution.js";
 import { handleSharedThreadRequest, type SharedThreadRouteDependencies } from "./agent-chat/shared-thread.js";
@@ -43,6 +44,7 @@ export { finalizeClaimedAgentChatProcessRunFailure };
 export declare function runPostAgentTurnAutosave(callback: AgentChatPluginOptions["onAgentTurnComplete"] | undefined, scope: AgentChatScope | null | undefined, run: ActiveRun): Promise<void>;
 export declare function runPostAgentRunComplete(callback: AgentChatPluginOptions["onAgentRunComplete"] | undefined, scope: AgentChatScope | null | undefined, run: ActiveRun): Promise<void>;
 export declare function runPreAgentTurnAutosave(callback: AgentChatPluginOptions["onAgentTurnStart"] | undefined, scope: AgentChatScope | null | undefined, run: Pick<ActiveRun, "threadId" | "runId">): Promise<void>;
+export declare function foldAgentChatRunCompletion(repo: unknown, assistantMsg: Parameters<typeof foldAssistantTurn>[1], run: Pick<ActiveRun, "runId" | "turnId" | "parentId" | "agentKitApprovalContinuation">): any;
 /**
  * The model this mount runs with, when the caller does not pass one per request.
  *