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

package/dist/agent/production-agent.js

@@ -7657,6 +7657,8 @@ export function createProductionAgentHandler(options) {
             backgroundFunction: runsInBackgroundFunction,
             noProgressTimeoutMs: options.runNoProgressTimeoutMs,
             turnId: effectiveTurnId,
+            agentKitApprovalContinuation: internalContinuation &&
+                Boolean(approvedToolCallsForExecution?.length),
             turnInitiator,
             parentId: requestParentId,
             waitUntil: getRequestRunContext()?.waitUntil,

package/dist/agent/run-manager.d.ts

@@ -6,6 +6,7 @@ export interface ActiveRun {
     threadId: string;
     parentId?: string | null;
     turnId: string;
+    agentKitApprovalContinuation?: boolean;
     events: RunEvent[];
     status: RunStatus;
     subscribers: Set<(event: RunEvent) => void>;
@@ -54,6 +55,7 @@ export interface StartRunOptions {
     softTimeoutMs?: number;
     useHostedSoftTimeoutDefault?: boolean;
     turnId?: string;
+    agentKitApprovalContinuation?: boolean;
     parentId?: string | null;
     backgroundFunction?: boolean;
     noProgressTimeoutMs?: number;

package/dist/agent/run-manager.js

@@ -486,6 +486,9 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         threadId,
         ...(options?.parentId !== undefined ? { parentId: options.parentId } : {}),
         turnId: options?.turnId ?? runId,
+        ...(options?.agentKitApprovalContinuation
+            ? { agentKitApprovalContinuation: true }
+            : {}),
         events: [],
         status: "running",
         subscribers: new Set(),
@@ -1795,7 +1798,8 @@ export async function getActiveRunForThreadAsync(threadId) {
     const memRun = getActiveRunForThread(threadId);
     if (memRun && (memRun.status === "running" || memRun.events.length > 0)) {
         const sqlSnapshot = await fetchRunThreadSnapshot(memRun.runId, threadId);
-        if (!sqlSnapshot && memRun.status !== "running") {
+        if (memRun.status !== "running" &&
+            (!sqlSnapshot || sqlSnapshot.status === "running")) {
             const successor = await fetchNewerNonTerminalRunForSameTurn(threadId, memRun);
             if (successor) {
                 return {
@@ -1813,7 +1817,10 @@ export async function getActiveRunForThreadAsync(threadId) {
                 };
             }
         }
-        const status = legacyWireRunStatus(sqlSnapshot?.status ?? memRun.status);
+        const sqlStatus = sqlSnapshot?.status === "running" && memRun.status !== "running"
+            ? memRun.status
+            : (sqlSnapshot?.status ?? memRun.status);
+        const status = legacyWireRunStatus(sqlStatus);
         const heartbeatAt = status === "running"
             ? Date.now()
             : (sqlSnapshot?.heartbeatAt ?? memRun.startedAt);

package/dist/agent/thread-data-builder.d.ts

@@ -107,6 +107,7 @@ export declare function foldAssistantTurn(repo: any, assistantMsg: AssistantMess
     turnId?: string;
     runId?: string;
     parentId?: string | null;
+    agentKitOwnsContinuation?: boolean;
 }): any;
 export declare function normalizeThreadTitle(value: unknown): string;
 export declare function extractThreadMeta(repo: any): {

package/dist/agent/thread-data-builder.js

@@ -1039,6 +1039,149 @@ export function claimQueuedMessage(repo, messageId) {
     normalized[CLAIMED_QUEUED_MESSAGE_IDS_KEY] = [...claimed, messageId].slice(-MAX_CLAIMED_QUEUED_MESSAGE_IDS);
     return pruneClaimedQueuedMessages(normalized);
 }
+function snapshotEntryId(entry, kind) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    if (kind === "widget") {
+        const messageId = entry.messageId;
+        const widgetId = entry.widget?.id;
+        return typeof messageId === "string" && typeof widgetId === "string"
+            ? JSON.stringify([messageId, widgetId])
+            : undefined;
+    }
+    return typeof entry.id === "string" ? entry.id : undefined;
+}
+function snapshotMessageRunIds(agentKit) {
+    const runIds = new Map();
+    for (const event of Array.isArray(agentKit?.events) ? agentKit.events : []) {
+        if ((event?.type === "message.created" ||
+            event?.type === "message.completed") &&
+            event.message?.role === "assistant" &&
+            typeof event.message.id === "string" &&
+            typeof event.runId === "string") {
+            runIds.set(event.message.id, event.runId);
+        }
+    }
+    for (const run of Array.isArray(agentKit?.runs) ? agentKit.runs : []) {
+        if (typeof run?.activeMessageId === "string" &&
+            typeof run.id === "string") {
+            runIds.set(run.activeMessageId, run.id);
+        }
+    }
+    return runIds;
+}
+function snapshotAssistantTextKey(message, runIds) {
+    const runId = (typeof message?.id === "string" ? runIds.get(message.id) : undefined) ??
+        message?.metadata?.runId ??
+        message?.metadata?.custom?.runId;
+    if (message?.role !== "assistant" ||
+        typeof runId !== "string" ||
+        !Array.isArray(message.parts) ||
+        message.parts.length === 0 ||
+        !message.parts.every((part) => part?.type === "text" && typeof part.text === "string")) {
+        return undefined;
+    }
+    return JSON.stringify([
+        runId,
+        message.parts.map((part) => [part.text, part.format ?? null]),
+    ]);
+}
+function preferIncomingSnapshotEntry(kind, existing, incoming) {
+    if (kind === "message") {
+        const rank = (message) => message.status === "complete" ? 2 : message.status === "error" ? 1 : 0;
+        if (rank(existing) !== rank(incoming))
+            return rank(incoming) > rank(existing);
+        const partCount = (message) => Array.isArray(message.parts) ? message.parts.length : 0;
+        if (partCount(existing) !== partCount(incoming)) {
+            return partCount(incoming) > partCount(existing);
+        }
+        const textLength = (message) => (Array.isArray(message.parts) ? message.parts : []).reduce((total, part) => total + (typeof part?.text === "string" ? part.text.length : 0), 0);
+        return textLength(incoming) > textLength(existing);
+    }
+    if (kind === "toolCall") {
+        return existing.status === "running" && incoming.status !== "running";
+    }
+    return (existing.widget?.state === "active" && incoming.widget?.state !== "active");
+}
+function mergeAgentKitHistoryArray(existing, incoming, kind, existingMessageRunIds, incomingMessageRunIds) {
+    if (!Array.isArray(existing) && !Array.isArray(incoming))
+        return undefined;
+    const merged = Array.isArray(existing) ? [...existing] : [];
+    const positions = new Map();
+    const assistantTextPositions = new Map();
+    merged.forEach((entry, index) => {
+        const id = snapshotEntryId(entry, kind);
+        if (id && !positions.has(id))
+            positions.set(id, index);
+        if (kind === "message") {
+            const key = snapshotAssistantTextKey(entry, existingMessageRunIds);
+            if (key) {
+                assistantTextPositions.set(key, [
+                    ...(assistantTextPositions.get(key) ?? []),
+                    index,
+                ]);
+            }
+        }
+    });
+    const matchedAssistantTextPositions = new Set();
+    for (const entry of Array.isArray(incoming) ? incoming : []) {
+        const id = snapshotEntryId(entry, kind);
+        const idIndex = id ? positions.get(id) : undefined;
+        const textKey = kind === "message"
+            ? snapshotAssistantTextKey(entry, incomingMessageRunIds)
+            : undefined;
+        const textIndex = idIndex === undefined && textKey
+            ? assistantTextPositions
+                .get(textKey)
+                ?.find((candidate) => !matchedAssistantTextPositions.has(candidate))
+            : undefined;
+        const index = idIndex ?? textIndex;
+        if (index === undefined) {
+            if (id)
+                positions.set(id, merged.length);
+            merged.push(entry);
+        }
+        else {
+            if (kind === "message")
+                matchedAssistantTextPositions.add(index);
+            if (id && idIndex === undefined)
+                positions.set(id, index);
+            const preferIncoming = preferIncomingSnapshotEntry(kind, merged[index], entry);
+            const preferCurrentMessageId = kind === "message" &&
+                textIndex !== undefined &&
+                !preferIncomingSnapshotEntry(kind, entry, merged[index]);
+            if (preferIncoming || preferCurrentMessageId) {
+                merged[index] = entry;
+            }
+        }
+    }
+    return merged;
+}
+function mergeAgentKitHistory(existing, incoming) {
+    if (!existing ||
+        typeof existing !== "object" ||
+        Array.isArray(existing) ||
+        !incoming ||
+        typeof incoming !== "object" ||
+        Array.isArray(incoming)) {
+        return incoming ?? existing;
+    }
+    const previous = existing;
+    const next = incoming;
+    const merged = { ...previous, ...next };
+    const existingMessageRunIds = snapshotMessageRunIds(previous);
+    const incomingMessageRunIds = snapshotMessageRunIds(next);
+    for (const [key, kind] of [
+        ["messages", "message"],
+        ["toolCalls", "toolCall"],
+        ["widgets", "widget"],
+    ]) {
+        const entries = mergeAgentKitHistoryArray(previous[key], next[key], kind, existingMessageRunIds, incomingMessageRunIds);
+        if (entries)
+            merged[key] = entries;
+    }
+    return merged;
+}
 function pruneClaimedQueuedMessages(repo) {
     if (!Array.isArray(repo?.queuedMessages))
         return repo;
@@ -1079,6 +1222,9 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
         merged.queuedMessages === undefined) {
         merged.queuedMessages = existingNormalized.queuedMessages;
     }
+    if (merged.agentKit !== undefined) {
+        merged.agentKit = mergeAgentKitHistory(existingNormalized?.agentKit, merged.agentKit);
+    }
     const existingMessages = Array.isArray(existingNormalized?.messages)
         ? existingNormalized.messages
         : null;
@@ -1509,6 +1655,8 @@ function appendFoldedContent(existing, incoming) {
     }).content;
 }
 export function foldAssistantTurn(repo, assistantMsg, options) {
+    if (options.agentKitOwnsContinuation)
+        return repo;
     const turnId = options.turnId;
     const runId = options.runId;
     if (!turnId)

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
+    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
-    error?: undefined;
 }>;

package/dist/chat-threads/store.d.ts

@@ -73,6 +73,7 @@ export interface ForkThreadSourceSnapshot {
     title?: string;
     preview?: string;
     messageCount?: number;
+    fromMessageId?: string;
     scope?: ChatThreadScope | null;
 }
 export declare function createThread(ownerEmail: string, opts?: {

package/dist/chat-threads/store.js

@@ -256,28 +256,253 @@ function normalizeForkSourceSnapshot(source) {
     catch {
         return null;
     }
-    const repoMessageCount = Array.isArray(parsed.messages)
-        ? parsed.messages.length
-        : 0;
-    if (repoMessageCount <= 0)
+    const messageCount = countThreadMessages(parsed, 0);
+    if (messageCount <= 0)
         return null;
     return {
         threadData: JSON.stringify(parsed),
         title: typeof source.title === "string" ? source.title : "",
         preview: typeof source.preview === "string" ? source.preview : "",
-        messageCount: repoMessageCount,
+        messageCount,
+        ...(typeof source.fromMessageId === "string"
+            ? { fromMessageId: source.fromMessageId }
+            : {}),
         ...(Object.prototype.hasOwnProperty.call(source, "scope")
             ? { scope: source.scope ?? null }
             : {}),
     };
 }
+function countThreadMessages(value, fallback) {
+    const repo = normalizeThreadRepository(value);
+    if (!repo || typeof repo !== "object")
+        return fallback;
+    const repoMessageCount = Array.isArray(repo.messages)
+        ? repo.messages.length
+        : undefined;
+    const agentKitMessageCount = Array.isArray(repo.agentKit?.messages)
+        ? repo.agentKit.messages.length
+        : undefined;
+    if (repoMessageCount === undefined && agentKitMessageCount === undefined) {
+        return fallback;
+    }
+    return Math.max(repoMessageCount ?? 0, agentKitMessageCount ?? 0);
+}
+function forkThreadData(threadData, forkId, fromMessageId) {
+    const parsed = normalizeThreadRepository(JSON.parse(threadData));
+    const repository = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : undefined;
+    const agentKit = repository?.agentKit;
+    if (!agentKit || typeof agentKit !== "object" || Array.isArray(agentKit)) {
+        return threadData;
+    }
+    const agentKitRecord = agentKit;
+    const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+    const repositoryMessages = Array.isArray(repository.messages)
+        ? repository.messages
+        : [];
+    const protocolMessages = Array.isArray(agentKitRecord.messages)
+        ? agentKitRecord.messages
+        : [];
+    const messageId = (value) => {
+        const outer = asRecord(value);
+        const message = asRecord(outer?.message) ?? outer;
+        return typeof message?.id === "string" ? message.id : undefined;
+    };
+    const messageIds = new Set();
+    if (fromMessageId) {
+        for (const messages of [repositoryMessages, protocolMessages]) {
+            const throughIndex = messages.findIndex((message) => messageId(message) === fromMessageId);
+            if (throughIndex >= 0) {
+                for (const message of messages.slice(0, throughIndex + 1)) {
+                    const id = messageId(message);
+                    if (id)
+                        messageIds.add(id);
+                }
+            }
+        }
+        if (!messageIds.has(fromMessageId)) {
+            throw new Error(`Unknown message for fork: ${fromMessageId}`);
+        }
+    }
+    else {
+        for (const message of [...repositoryMessages, ...protocolMessages]) {
+            const id = messageId(message);
+            if (id)
+                messageIds.add(id);
+        }
+    }
+    const events = Array.isArray(agentKitRecord.events)
+        ? agentKitRecord.events
+        : [];
+    const runs = Array.isArray(agentKitRecord.runs) ? agentKitRecord.runs : [];
+    const eventBoundaries = new Map();
+    for (const rawEvent of events) {
+        const event = asRecord(rawEvent);
+        const message = asRecord(event?.message);
+        const messageId = typeof event?.messageId === "string"
+            ? event.messageId
+            : typeof message?.id === "string"
+                ? message.id
+                : undefined;
+        if (event?.type === "message.completed" &&
+            typeof event?.runId === "string" &&
+            typeof event.sequence === "number" &&
+            messageId &&
+            messageIds.has(messageId)) {
+            eventBoundaries.set(event.runId, Math.max(eventBoundaries.get(event.runId) ?? 0, event.sequence));
+        }
+    }
+    for (const rawRun of runs) {
+        const run = asRecord(rawRun);
+        if (typeof run?.id === "string" &&
+            typeof run.activeMessageId === "string" &&
+            messageIds.has(run.activeMessageId) &&
+            typeof run.lastSequence === "number") {
+            eventBoundaries.set(run.id, Math.max(eventBoundaries.get(run.id) ?? 0, run.lastSequence));
+        }
+    }
+    const retainedRunIds = new Set(eventBoundaries.keys());
+    const nonterminalRunIds = new Set(runs.flatMap((rawRun) => {
+        const run = asRecord(rawRun);
+        return typeof run?.id === "string" &&
+            (run.status === "queued" ||
+                run.status === "running" ||
+                run.status === "awaiting_approval" ||
+                run.status === "awaiting_input")
+            ? [run.id]
+            : [];
+    }));
+    const activeMessageIds = new Set(runs.flatMap((rawRun) => {
+        const run = asRecord(rawRun);
+        return typeof run?.id === "string" &&
+            nonterminalRunIds.has(run.id) &&
+            typeof run.activeMessageId === "string"
+            ? [run.activeMessageId]
+            : [];
+    }));
+    const retainedMessageId = (value) => {
+        const id = messageId(value);
+        return Boolean(id && messageIds.has(id));
+    };
+    const remapThreadId = (value) => value && typeof value === "object" && !Array.isArray(value)
+        ? { ...value, threadId: forkId }
+        : value;
+    return JSON.stringify({
+        ...repository,
+        ...(Array.isArray(repository.messages)
+            ? { messages: repositoryMessages.filter(retainedMessageId) }
+            : {}),
+        agentKit: {
+            ...agentKitRecord,
+            ...(Array.isArray(agentKitRecord.messages)
+                ? {
+                    messages: agentKitRecord.messages
+                        .filter(retainedMessageId)
+                        .map((message) => {
+                        const record = asRecord(message);
+                        return typeof record.id === "string" &&
+                            activeMessageIds.has(record.id) &&
+                            record.status === "streaming"
+                            ? { ...record, status: "complete" }
+                            : record;
+                    }),
+                }
+                : {}),
+            ...(Array.isArray(agentKitRecord.events)
+                ? {
+                    events: events.flatMap((rawEvent) => {
+                        const event = asRecord(rawEvent);
+                        const runId = event?.runId;
+                        const boundary = typeof runId === "string"
+                            ? eventBoundaries.get(runId)
+                            : undefined;
+                        if (typeof runId !== "string" ||
+                            boundary === undefined ||
+                            typeof event?.sequence !== "number" ||
+                            event.sequence > boundary) {
+                            return [];
+                        }
+                        if (nonterminalRunIds.has(runId) &&
+                            (event.type === "activity.started" ||
+                                event.type === "activity.updated")) {
+                            const activity = asRecord(event.activity);
+                            if (activity?.status === "running") {
+                                return [
+                                    {
+                                        ...event,
+                                        type: "activity.completed",
+                                        activity: { ...activity, status: "cancelled" },
+                                        threadId: forkId,
+                                    },
+                                ];
+                            }
+                        }
+                        return [remapThreadId(rawEvent)];
+                    }),
+                }
+                : {}),
+            ...(Array.isArray(agentKitRecord.runs)
+                ? {
+                    runs: runs.flatMap((rawRun) => {
+                        const run = asRecord(rawRun);
+                        if (typeof run?.id !== "string" || !retainedRunIds.has(run.id)) {
+                            return [];
+                        }
+                        const copied = {
+                            ...run,
+                            threadId: forkId,
+                        };
+                        if (nonterminalRunIds.has(run.id)) {
+                            copied.status = "cancelled";
+                            delete copied.activeMessageId;
+                        }
+                        return [copied];
+                    }),
+                }
+                : {}),
+            ...(fromMessageId && Array.isArray(agentKitRecord.toolCalls)
+                ? {
+                    toolCalls: agentKitRecord.toolCalls.filter((rawToolCall) => {
+                        const toolCall = asRecord(rawToolCall);
+                        if (typeof toolCall?.messageId === "string") {
+                            return messageIds.has(toolCall.messageId);
+                        }
+                        return (typeof toolCall?.runId === "string" &&
+                            retainedRunIds.has(toolCall.runId));
+                    }),
+                }
+                : {}),
+            ...(Array.isArray(agentKitRecord.widgets)
+                ? {
+                    widgets: agentKitRecord.widgets.filter((widget) => {
+                        const record = asRecord(widget);
+                        return (typeof record?.messageId === "string" &&
+                            messageIds.has(record.messageId));
+                    }),
+                }
+                : {}),
+            ...(Array.isArray(agentKitRecord.annotations)
+                ? {
+                    annotations: agentKitRecord.annotations.filter((annotation) => {
+                        const record = asRecord(annotation);
+                        return (typeof record?.messageId === "string" &&
+                            messageIds.has(record.messageId));
+                    }),
+                }
+                : {}),
+            ...(fromMessageId ? { suggestions: [] } : {}),
+            activeRunIds: [],
+        },
+    });
+}
 function deriveMessageCount(threadData, fallback) {
     if (typeof threadData !== "string" || !threadData.trim())
         return fallback;
     try {
-        const repo = normalizeThreadRepository(JSON.parse(threadData));
-        if (Array.isArray(repo.messages))
-            return repo.messages.length;
+        return countThreadMessages(JSON.parse(threadData), fallback);
     }
     catch {
         // Keep the stored count if the JSON blob is malformed.
@@ -485,18 +710,17 @@ export async function forkThread(sourceId, ownerEmail, opts) {
     }
     else if (snapshot &&
         source.ownerEmail === ownerEmail &&
-        snapshot.messageCount > source.messageCount) {
-        // The source row exists but the in-memory snapshot is fresher — the agent
-        // run flushed an older state to SQL, but the tab has additional unflushed
-        // messages. Overlay the snapshot before cloning so the fork captures the
-        // latest user-visible content. Guard with messageCount > stored to avoid
-        // clobbering a fresher persisted row with a stale snapshot from another
-        // tab.
+        (snapshot.fromMessageId || snapshot.messageCount > source.messageCount)) {
+        // Message-scoped forks intentionally carry a truncated snapshot even when
+        // the persisted source has later messages; full forks only overlay fresher
+        // client snapshots.
         source = {
             ...source,
             threadData: snapshot.threadData,
             title: snapshot.title || source.title,
-            preview: snapshot.preview || source.preview,
+            preview: snapshot.fromMessageId
+                ? snapshot.preview
+                : snapshot.preview || source.preview,
             messageCount: snapshot.messageCount,
         };
     }
@@ -505,6 +729,7 @@ export async function forkThread(sourceId, ownerEmail, opts) {
         return null;
     }
     const id = opts?.id ?? generateId();
+    const threadData = forkThreadData(source.threadData, id, snapshot?.fromMessageId);
     const now = Date.now();
     const title = source.title ? `${source.title} (fork)` : "";
     const client = getDbExec();
@@ -516,7 +741,7 @@ export async function forkThread(sourceId, ownerEmail, opts) {
             ownerEmail,
             title,
             source.preview,
-            source.threadData,
+            threadData,
             source.messageCount,
             now,
             now,
@@ -534,7 +759,7 @@ export async function forkThread(sourceId, ownerEmail, opts) {
         ownerEmail,
         title,
         preview: source.preview,
-        threadData: source.threadData,
+        threadData,
         messageCount: source.messageCount,
         createdAt: now,
         updatedAt: now,
@@ -787,9 +1012,7 @@ export async function updateThreadData(id, threadData, title, preview, messageCo
                     preserveExistingTopLevelKeys: options.preserveExistingTopLevelKeys ?? true,
                 });
                 nextThreadData = JSON.stringify(merged);
-                if (Array.isArray(merged.messages)) {
-                    nextMessageCount = merged.messages.length;
-                }
+                nextMessageCount = countThreadMessages(merged, messageCount);
             }
             catch {
                 // Keep the caller's serialized value if either JSON blob is malformed.