@agent-native/core 0.208.0 → 0.209.0-nightly-20261014070126

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

@@ -4,6 +4,8 @@ import { isCredentialGapCodeAgentEvent, normalizeCodeAgentTranscript, } from "..
 import { stripAgentChatContextFromMessage } from "../shared/agent-chat-context.js";
 import { RUN_NOT_STARTED_METADATA_KEY, } from "../shared/agent-chat-run-not-started.js";
 import { parseBase64DataUrl } from "../shared/data-url.js";
+import { toolInputFingerprint, toolInputsMatch, } from "../shared/tool-inputs.js";
+import { approvalKeyForHistory } from "./approval-key.js";
 import { BUILDER_GATEWAY_INTERNAL_ERROR_CODE } from "./engine/error-detail.js";
 import { INTERRUPTED_TOOL_RESULT_MARKER as INTERRUPTED_TOOL_RESULT, stringifyToolUseInputForGateway, } from "./engine/translate-anthropic.js";
 import { parseFollowUpSuggestions } from "./follow-up-suggestions.js";
@@ -138,6 +140,7 @@ function isInternalContinuationError(event) {
 export function buildAssistantMessage(events, runId, options = {}) {
     const content = [];
     const explicitUnknownOutcomes = new Set();
+    const approvalPauseCandidates = new Set();
     let toolCallCounter = 0;
     let runError = null;
     let endedAtInternalContinuationBoundary = false;
@@ -203,16 +206,17 @@ export function buildAssistantMessage(events, runId, options = {}) {
             continue;
         }
         if (event.type === "approval_required") {
-            const matchingIndex = findApprovalToolCallIndex(content, event.tool ?? "unknown", event.toolCallId);
+            const matchingIndex = findApprovalToolCallIndex(content, event.tool ?? "unknown", event.toolCallId, event.input);
             const part = content[matchingIndex];
             if (part?.type === "tool-call") {
                 part.approval = {
-                    approvalKey: event.approvalKey,
+                    approvalKey: approvalKeyForHistory(event.approvalKey),
                     ...(event.askId ? { askId: event.askId } : {}),
                     ...(event.allowPersistentApproval === false
                         ? { allowPersistentApproval: false }
                         : {}),
                 };
+                approvalPauseCandidates.add(part);
             }
             continue;
         }
@@ -244,6 +248,17 @@ export function buildAssistantMessage(events, runId, options = {}) {
             const part = content[matchingIndex];
             if (part?.type === "tool-call") {
                 part.result = event.result ?? "";
+                // Older journals have approval_required but no pause marker on tool_done.
+                const inferredLegacyPause = event.approvalPause === undefined &&
+                    approvalPauseCandidates.has(part);
+                if (event.approvalPause === true || inferredLegacyPause) {
+                    part.approvalPause = true;
+                }
+                else {
+                    delete part.approvalPause;
+                    delete part.approval;
+                }
+                approvalPauseCandidates.delete(part);
                 if (event.isError !== undefined)
                     part.isError = event.isError;
                 if (event.outcomeUnknown === true) {
@@ -484,7 +499,7 @@ function normalizeAttachmentIdentity(attachments) {
         contentType: att?.contentType,
     }));
 }
-function findApprovalToolCallIndex(content, toolName, toolCallId) {
+function findApprovalToolCallIndex(content, toolName, toolCallId, approvalInput) {
     if (toolCallId) {
         for (let i = content.length - 1; i >= 0; i--) {
             const part = content[i];
@@ -501,21 +516,26 @@ function findApprovalToolCallIndex(content, toolName, toolCallId) {
                 part.toolName === toolName &&
                 part.result === undefined &&
                 typeof part.toolCallId === "string" &&
-                /^tc_\d+$/.test(part.toolCallId)) {
+                /(?:^|:)tc_\d+$/.test(part.toolCallId) &&
+                toolInputsMatch(part.args, approvalInput)) {
                 readerLocalCandidates.push(i);
             }
         }
         return readerLocalCandidates.length === 1 ? readerLocalCandidates[0] : -1;
     }
-    for (let i = content.length - 1; i >= 0; i--) {
+    const matchingInputCandidates = [];
+    for (let i = 0; i < content.length; i += 1) {
         const part = content[i];
         if (part.type === "tool-call" &&
             part.toolName === toolName &&
-            part.result === undefined) {
-            return i;
+            part.result === undefined &&
+            toolInputsMatch(part.args, approvalInput)) {
+            matchingInputCandidates.push(i);
         }
     }
-    return -1;
+    return matchingInputCandidates.length === 1
+        ? matchingInputCandidates[0]
+        : -1;
 }
 function normalizeContentForFingerprint(content) {
     if (!Array.isArray(content))
@@ -853,6 +873,12 @@ function assistantReplayContent(message, text) {
             toolName: name,
             toolInput: stringifyToolUseInputForGateway(input),
             ...result,
+            ...(part.approvalPause === true ? { approvalPause: true } : {}),
+            ...(typeof part.approval?.askId === "string"
+                ? { approvalAskId: part.approval.askId }
+                : typeof part.approvalAskId === "string"
+                    ? { approvalAskId: part.approvalAskId }
+                    : {}),
             ...(part.isError === true || result.outcome === "unknown"
                 ? { isError: true }
                 : {}),
@@ -1327,7 +1353,227 @@ function snapshotAssistantTextKey(message, runIds) {
         message.parts.map((part) => [part.text, part.format ?? null]),
     ]);
 }
-function preferIncomingSnapshotEntry(kind, existing, incoming) {
+function snapshotAssistantText(message) {
+    if (message?.role !== "assistant" ||
+        !Array.isArray(message.parts) ||
+        message.parts.length === 0 ||
+        !message.parts.every((part) => part?.type === "text" && typeof part.text === "string")) {
+        return undefined;
+    }
+    return message.parts.map((part) => part.text).join("");
+}
+function removeSupersededAgentKitMessagePrefixes(messages, agentKit, previousAgentKit, incomingAgentKit) {
+    if (!Array.isArray(messages))
+        return undefined;
+    const completedMessagesByRun = new Map();
+    const events = [previousAgentKit, incomingAgentKit, agentKit].flatMap((snapshot) => (Array.isArray(snapshot.events) ? snapshot.events : []));
+    for (const event of events) {
+        const messageId = event?.message?.id;
+        if (event?.type !== "message.completed" ||
+            event.message?.role !== "assistant" ||
+            typeof event.runId !== "string" ||
+            typeof messageId !== "string") {
+            continue;
+        }
+        const messageIds = completedMessagesByRun.get(event.runId) ?? new Set();
+        messageIds.add(messageId);
+        completedMessagesByRun.set(event.runId, messageIds);
+    }
+    if (completedMessagesByRun.size === 0)
+        return messages;
+    const runningRunSnapshots = [previousAgentKit, incomingAgentKit].flatMap((snapshot) => Array.isArray(snapshot.runs)
+        ? snapshot.runs.flatMap((run) => run?.status === "running" &&
+            typeof run.id === "string" &&
+            typeof run.activeMessageId === "string" &&
+            typeof run.lastSequence === "number" &&
+            Number.isSafeInteger(run.lastSequence)
+            ? [{ run, messages: snapshot.messages }]
+            : [])
+        : []);
+    const removedIds = new Set();
+    for (const run of Array.isArray(agentKit.runs) ? agentKit.runs : []) {
+        if (run?.status !== "completed" ||
+            typeof run.id !== "string" ||
+            typeof run.activeMessageId !== "string" ||
+            typeof run.lastSequence !== "number" ||
+            !Number.isSafeInteger(run.lastSequence)) {
+            continue;
+        }
+        const staleRunningSnapshot = runningRunSnapshots
+            .filter(({ run: candidateRun }) => candidateRun.id === run.id &&
+            candidateRun.activeMessageId !== run.activeMessageId &&
+            candidateRun.lastSequence < run.lastSequence &&
+            !completedMessagesByRun
+                .get(run.id)
+                ?.has(candidateRun.activeMessageId))
+            .sort((left, right) => right.run.lastSequence - left.run.lastSequence)[0];
+        if (!staleRunningSnapshot ||
+            !completedMessagesByRun.get(run.id)?.has(run.activeMessageId) ||
+            !events.some((event) => event?.type === "message.completed" &&
+                event.runId === run.id &&
+                event.message?.role === "assistant" &&
+                event.message?.id === run.activeMessageId &&
+                typeof event.sequence === "number" &&
+                Number.isSafeInteger(event.sequence) &&
+                event.sequence > staleRunningSnapshot.run.lastSequence &&
+                event.sequence <= run.lastSequence)) {
+            continue;
+        }
+        const completedIndex = messages.findIndex((entry) => snapshotEntryId(entry, "message") === run.activeMessageId &&
+            entry?.role === "assistant");
+        if (completedIndex === -1)
+            continue;
+        const completedText = snapshotAssistantText(messages[completedIndex]);
+        if (completedText === undefined)
+            continue;
+        const lastUserIndexBefore = (messageIndex) => {
+            for (let index = messageIndex - 1; index >= 0; index--) {
+                if (messages[index]?.role === "user")
+                    return index;
+            }
+            return -1;
+        };
+        const lastUserIndex = lastUserIndexBefore(completedIndex);
+        if (lastUserIndex === -1 ||
+            lastUserIndexBefore(messages.findIndex((entry) => snapshotEntryId(entry, "message") ===
+                staleRunningSnapshot.run.activeMessageId)) !== lastUserIndex) {
+            continue;
+        }
+        const candidateId = staleRunningSnapshot.run.activeMessageId;
+        const candidate = Array.isArray(staleRunningSnapshot.messages)
+            ? staleRunningSnapshot.messages.find((entry) => snapshotEntryId(entry, "message") === candidateId)
+            : undefined;
+        const candidateIndex = messages.findIndex((entry) => snapshotEntryId(entry, "message") === candidateId);
+        const candidateText = snapshotAssistantText(candidate);
+        if (candidateIndex <= lastUserIndex ||
+            candidateText === undefined ||
+            candidateText.length === 0 ||
+            candidateText.length >= completedText.length ||
+            !completedText.startsWith(candidateText)) {
+            continue;
+        }
+        removedIds.add(candidateId);
+    }
+    return removedIds.size === 0
+        ? messages
+        : messages.filter((entry) => {
+            const id = snapshotEntryId(entry, "message");
+            return !id || !removedIds.has(id);
+        });
+}
+function isApprovalPauseToolCall(toolCall) {
+    if (toolCall?.metadata?.approvalPause === true)
+        return true;
+    return (typeof toolCall?.output === "string" &&
+        toolCall.output.startsWith("Awaiting") &&
+        toolCall.output.includes("did NOT execute"));
+}
+function toolCallHasCompletedSideEffect(toolCall) {
+    return toolCall?.metadata?.completedSideEffect === true;
+}
+function toolCallInputValuesMatch(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => toolCallInputValuesMatch(value, right[index])));
+    }
+    return toolInputsMatch(left, right);
+}
+function toolCallInputsMatch(existing, incoming) {
+    const existingInput = existing?.input;
+    const incomingInput = incoming?.input;
+    if (existingInput !== undefined && incomingInput !== undefined) {
+        return toolCallInputValuesMatch(existingInput, incomingInput);
+    }
+    const existingSnapshot = existing?.metadata?.agentKitSnapshot;
+    const incomingSnapshot = incoming?.metadata?.agentKitSnapshot;
+    const existingFingerprint = typeof existingSnapshot?.inputFingerprint === "string"
+        ? existingSnapshot.inputFingerprint
+        : existingInput === undefined
+            ? undefined
+            : toolInputFingerprint(existingInput);
+    const incomingFingerprint = typeof incomingSnapshot?.inputFingerprint === "string"
+        ? incomingSnapshot.inputFingerprint
+        : incomingInput === undefined
+            ? undefined
+            : toolInputFingerprint(incomingInput);
+    if (existingFingerprint || incomingFingerprint) {
+        return (typeof existingFingerprint === "string" &&
+            existingFingerprint === incomingFingerprint);
+    }
+    return existingInput === undefined && incomingInput === undefined;
+}
+function toolCallIdentityMatches(existing, incoming) {
+    return (typeof existing?.id === "string" &&
+        existing.id === incoming?.id &&
+        typeof existing?.name === "string" &&
+        existing.name === incoming?.name &&
+        toolCallInputsMatch(existing, incoming));
+}
+function toolCallsMatch(existing, incoming) {
+    return (existing?.status === "completed" &&
+        incoming?.status === "completed" &&
+        toolCallIdentityMatches(existing, incoming));
+}
+function isIncomingToolCallRunNewer(existing, incoming, existingRuns, incomingRuns) {
+    const existingRunId = existing?.runId;
+    const incomingRunId = incoming?.runId;
+    if (typeof incomingRunId !== "string")
+        return false;
+    if (typeof existingRunId !== "string")
+        return true;
+    const findRun = (runs, runId) => Array.isArray(runs) ? runs.find((run) => run?.id === runId) : undefined;
+    const existingRun = findRun(existingRuns, existingRunId);
+    const incomingRun = findRun(incomingRuns, incomingRunId);
+    if (existingRunId === incomingRunId) {
+        return (Number.isSafeInteger(existingRun?.lastSequence) &&
+            Number.isSafeInteger(incomingRun?.lastSequence) &&
+            incomingRun.lastSequence > existingRun.lastSequence);
+    }
+    const existingStartedAt = Date.parse(existingRun?.startedAt ?? "");
+    const incomingStartedAt = Date.parse(incomingRun?.startedAt ?? "");
+    return (Number.isFinite(existingStartedAt) &&
+        Number.isFinite(incomingStartedAt) &&
+        incomingStartedAt > existingStartedAt);
+}
+function prefersApprovalReplaySnapshot(existing, incoming, existingRuns, incomingRuns) {
+    if (!toolCallsMatch(existing, incoming))
+        return false;
+    const incomingIsNewer = isIncomingToolCallRunNewer(existing, incoming, existingRuns, incomingRuns);
+    return ((isApprovalPauseToolCall(existing) &&
+        toolCallHasCompletedSideEffect(incoming) &&
+        incomingIsNewer) ||
+        (toolCallHasCompletedSideEffect(existing) &&
+            isApprovalPauseToolCall(incoming) &&
+            incomingIsNewer));
+}
+function incomingRunIsNotProvenNewer(existing, incoming, existingRuns, incomingRuns) {
+    const existingRunId = existing?.runId;
+    const incomingRunId = incoming?.runId;
+    if (typeof existingRunId !== "string" && typeof incomingRunId !== "string") {
+        return false;
+    }
+    if (typeof existingRunId !== "string" || typeof incomingRunId !== "string") {
+        return true;
+    }
+    const findRun = (runs, runId) => Array.isArray(runs) ? runs.find((run) => run?.id === runId) : undefined;
+    const existingRun = findRun(existingRuns, existingRunId);
+    const incomingRun = findRun(incomingRuns, incomingRunId);
+    if (existingRunId === incomingRunId) {
+        return !(Number.isSafeInteger(existingRun?.lastSequence) &&
+            Number.isSafeInteger(incomingRun?.lastSequence) &&
+            incomingRun.lastSequence > existingRun.lastSequence);
+    }
+    const existingStartedAt = Date.parse(existingRun?.startedAt ?? "");
+    const incomingStartedAt = Date.parse(incomingRun?.startedAt ?? "");
+    return (!Number.isFinite(existingStartedAt) ||
+        !Number.isFinite(incomingStartedAt) ||
+        incomingStartedAt <= existingStartedAt);
+}
+function preferIncomingSnapshotEntry(kind, existing, incoming, existingRuns, incomingRuns) {
     if (kind === "message") {
         const rank = (message) => message.status === "complete" ? 2 : message.status === "error" ? 1 : 0;
         if (rank(existing) !== rank(incoming))
@@ -1340,6 +1586,11 @@ function preferIncomingSnapshotEntry(kind, existing, incoming) {
         return textLength(incoming) > textLength(existing);
     }
     if (kind === "toolCall") {
+        if (existing.status === "running" &&
+            incoming.status !== "running" &&
+            incomingRunIsNotProvenNewer(existing, incoming, existingRuns, incomingRuns)) {
+            return false;
+        }
         return existing.status === "running" && incoming.status !== "running";
     }
     return (existing.widget?.state === "active" && incoming.widget?.state !== "active");
@@ -1357,7 +1608,7 @@ function withToolCallMessageIdFallback(preferred, fallback) {
     }
     return preferred;
 }
-function mergeAgentKitHistoryArray(existing, incoming, kind, existingMessageRunIds, incomingMessageRunIds, promptRunIds) {
+function mergeAgentKitHistoryArray(existing, incoming, kind, existingMessageRunIds, incomingMessageRunIds, promptRunIds, existingRuns, incomingRuns) {
     if (!Array.isArray(existing) && !Array.isArray(incoming))
         return undefined;
     const merged = Array.isArray(existing) ? [...existing] : [];
@@ -1400,11 +1651,13 @@ function mergeAgentKitHistoryArray(existing, incoming, kind, existingMessageRunI
                 matchedAssistantTextPositions.add(index);
             if (id && idIndex === undefined)
                 positions.set(id, index);
-            const preferIncoming = preferIncomingSnapshotEntry(kind, merged[index], entry);
+            const preferIncoming = preferIncomingSnapshotEntry(kind, merged[index], entry, existingRuns, incomingRuns);
+            const preferApprovedReplay = kind === "toolCall" &&
+                prefersApprovalReplaySnapshot(merged[index], entry, existingRuns, incomingRuns);
             const preferCurrentMessageId = kind === "message" &&
                 textIndex !== undefined &&
-                !preferIncomingSnapshotEntry(kind, entry, merged[index]);
-            if (preferIncoming || preferCurrentMessageId) {
+                !preferIncomingSnapshotEntry(kind, entry, merged[index], incomingRuns, existingRuns);
+            if (preferIncoming || preferApprovedReplay || preferCurrentMessageId) {
                 merged[index] =
                     kind === "toolCall"
                         ? withToolCallMessageIdFallback(entry, merged[index])
@@ -2495,7 +2748,7 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConf
         ["toolCalls", "toolCall"],
         ["widgets", "widget"],
     ]) {
-        const entries = mergeAgentKitHistoryArray(previous[key], next[key], kind, existingMessageRunIds, incomingMessageRunIds, promptRunIds);
+        const entries = mergeAgentKitHistoryArray(previous[key], next[key], kind, existingMessageRunIds, incomingMessageRunIds, promptRunIds, previous.runs, next.runs);
         if (entries)
             merged[key] = entries;
     }
@@ -2569,6 +2822,9 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConf
             merged._eventRunWatermarks = previous._eventRunWatermarks;
         }
     }
+    const messages = removeSupersededAgentKitMessagePrefixes(merged.messages, merged, previous, next);
+    if (messages)
+        merged.messages = messages;
     delete merged._snapshotDelta;
     delete merged.eventRunReplacements;
     delete merged.eventRunSnapshotWatermarks;
@@ -3131,6 +3387,24 @@ function assistantContentWeight(content) {
 function appendFoldedContent(existing, incoming) {
     const merged = existing.map((p) => ({ ...p }));
     for (const part of incoming) {
+        if (part?.type === "tool-call" && part.result !== undefined) {
+            let pausedCallIndex = -1;
+            for (let index = merged.length - 1; index >= 0; index -= 1) {
+                const candidate = merged[index];
+                if (candidate?.type === "tool-call" &&
+                    candidate.approvalPause === true &&
+                    candidate.toolCallId === part.toolCallId &&
+                    candidate.toolName === part.toolName &&
+                    toolInputsMatch(candidate.args, part.args)) {
+                    pausedCallIndex = index;
+                    break;
+                }
+            }
+            if (pausedCallIndex !== -1) {
+                merged[pausedCallIndex] = { ...part };
+                continue;
+            }
+        }
         const last = merged[merged.length - 1];
         if (part?.type === "text" &&
             typeof part.text === "string" &&

package/dist/agent/tool-approval-store.d.ts

@@ -1,3 +1,4 @@
+export { hashAgentToolApprovalKey } from "./approval-key.js";
 export declare function ensureAgentToolApprovalTable(): Promise<void>;
 export declare function ensureAgentToolApprovalPolicyTable(): Promise<void>;
 export interface AgentToolApprovalBinding {
@@ -8,9 +9,9 @@ export interface AgentToolApprovalBinding {
     toolName: string;
     callId: string;
     approvalKey: string;
+    approvalId?: string;
     expiresAt?: number;
 }
-export declare function hashAgentToolApprovalKey(approvalKey: string): string;
 export interface AgentToolApprovalPolicyBinding {
     ownerEmail: string;
     orgId?: string | null;
@@ -27,6 +28,7 @@ export declare function resolveAgentToolApprovalTurnId(binding: {
     threadId?: string | null;
     requestedTurnId?: string | null;
     approvalKeys: readonly string[];
+    approvalId?: string;
 }): Promise<string | null>;
 export declare function createAgentToolApproval(binding: AgentToolApprovalBinding): Promise<string>;
 /**

package/dist/agent/tool-approval-store.js

@@ -2,7 +2,9 @@ import { createHash, randomUUID } from "node:crypto";
 import { getDbExec } from "../db/client.js";
 import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 import { retainRequestDbPoolScope } from "../db/request-pool-context.js";
+import { hashAgentToolApprovalKey } from "./approval-key.js";
 import { AGENT_TOOL_APPROVAL_INDEX_SQL, AGENT_TOOL_APPROVAL_LOGICAL_INDEX_SQL, AGENT_TOOL_APPROVAL_POLICY_INDEX_SQL, AGENT_TOOL_APPROVAL_POLICY_TABLE_SQL, AGENT_TOOL_APPROVAL_RECOVERY_INDEX_SQL, AGENT_TOOL_APPROVAL_TABLE_SQL, } from "./tool-approval-migrations.js";
+export { hashAgentToolApprovalKey } from "./approval-key.js";
 const APPROVAL_TTL_MS = 60 * 60_000;
 const APPROVAL_CLEANUP_AGE_MS = 24 * 60 * 60_000;
 let initPromise;
@@ -35,9 +37,6 @@ export async function ensureAgentToolApprovalPolicyTable() {
     }
     return policyInitPromise;
 }
-export function hashAgentToolApprovalKey(approvalKey) {
-    return createHash("sha256").update(approvalKey).digest("hex");
-}
 function normalizeApprovalPolicyBinding(binding) {
     const ownerEmail = binding.ownerEmail.trim().toLowerCase();
     const toolName = binding.toolName.trim();
@@ -85,7 +84,7 @@ export async function isAgentToolAlwaysAllowed(input) {
     const result = await getDbExec().execute({
         sql: `SELECT 1 FROM agent_tool_approval_policies
       WHERE owner_email = ?
-        AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = ?)
+        AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = CAST(? AS TEXT))
         AND tool_name = ?
         AND enabled = TRUE
       LIMIT 1`,
@@ -101,12 +100,15 @@ export async function resolveAgentToolApprovalTurnId(binding) {
     const now = Date.now();
     const hashes = approvalKeys.map(hashAgentToolApprovalKey);
     const placeholders = hashes.map(() => "?").join(", ");
+    const exactApprovalFilter = binding.approvalId ? "AND id = ?" : "";
+    const approvalIdArgs = binding.approvalId ? [binding.approvalId] : [];
     const result = await getDbExec().execute({
         sql: `SELECT turn_id FROM agent_tool_approvals
       WHERE owner_email = ?
-        AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = ?)
-        AND ((thread_id IS NULL AND CAST(? AS TEXT) IS NULL) OR thread_id = ?)
+        AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = CAST(? AS TEXT))
+        AND ((thread_id IS NULL AND CAST(? AS TEXT) IS NULL) OR thread_id = CAST(? AS TEXT))
         AND approval_key_hash IN (${placeholders})
+        ${exactApprovalFilter}
         AND status = 'pending'
         AND expires_at > ?
         AND turn_id IS NOT NULL`,
@@ -117,6 +119,7 @@ export async function resolveAgentToolApprovalTurnId(binding) {
             binding.threadId,
             binding.threadId,
             ...hashes,
+            ...approvalIdArgs,
             now,
         ],
     });
@@ -127,6 +130,14 @@ export async function resolveAgentToolApprovalTurnId(binding) {
     })
         .filter((turnId) => turnId !== null));
     const requestedTurnId = binding.requestedTurnId?.trim();
+    if (binding.approvalId) {
+        if (turnIds.size !== 1)
+            return null;
+        const exactTurnId = [...turnIds][0];
+        return requestedTurnId && requestedTurnId !== exactTurnId
+            ? null
+            : exactTurnId;
+    }
     if (requestedTurnId && turnIds.has(requestedTurnId))
         return requestedTurnId;
     return turnIds.size === 1 ? [...turnIds][0] : null;
@@ -177,21 +188,23 @@ export async function createAgentToolApproval(binding) {
 export async function consumeAgentToolApproval(binding) {
     await ensureAgentToolApprovalTable();
     const now = Date.now();
+    const exactApprovalFilter = binding.approvalId ? "AND id = ?" : "";
+    const approvalIdArgs = binding.approvalId ? [binding.approvalId] : [];
     const result = await getDbExec().execute({
         sql: `UPDATE agent_tool_approvals
       SET status = 'consumed', consumed_at = ?, updated_at = ?
       WHERE id = (
-        SELECT id FROM agent_tool_approvals
+        SELECT MIN(id) FROM agent_tool_approvals
         WHERE owner_email = ?
-          AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = ?)
-          AND ((thread_id IS NULL AND CAST(? AS TEXT) IS NULL) OR thread_id = ?)
-          AND ((turn_id IS NULL AND CAST(? AS TEXT) IS NULL) OR turn_id = ?)
+          AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = CAST(? AS TEXT))
+          AND ((thread_id IS NULL AND CAST(? AS TEXT) IS NULL) OR thread_id = CAST(? AS TEXT))
+          AND ((turn_id IS NULL AND CAST(? AS TEXT) IS NULL) OR turn_id = CAST(? AS TEXT))
           AND tool_name = ?
           AND approval_key_hash = ?
+          ${exactApprovalFilter}
           AND status = 'pending'
           AND expires_at > ?
-        ORDER BY created_at DESC
-        LIMIT 1
+        HAVING COUNT(*) = 1
       )
       AND status = 'pending'`,
         args: [
@@ -206,6 +219,7 @@ export async function consumeAgentToolApproval(binding) {
             binding.turnId ?? null,
             binding.toolName,
             hashAgentToolApprovalKey(binding.approvalKey),
+            ...approvalIdArgs,
             now,
         ],
     });

package/dist/agent/tool-call-journal.d.ts

@@ -19,7 +19,7 @@ export interface ToolCallJournal {
     interrupted: ToolCallJournalEntry[];
 }
 export declare function toolCallInputFingerprint(input: unknown): string;
-export declare function isRedactedToolCallInput(input: unknown): boolean;
+export declare function isUnavailableToolCallInput(input: unknown): boolean;
 export declare function isConsistentToolCallInputFingerprint(input: unknown, fingerprint: string | undefined, storedFingerprint?: string): boolean;
 export declare function classifyToolCallJournal(events: readonly AgentChatEvent[]): ToolCallJournal;
 export declare function isJournalEmpty(journal: ToolCallJournal): boolean;

package/dist/agent/tool-call-journal.js

@@ -17,14 +17,16 @@ function inputSignature(input) {
 export function toolCallInputFingerprint(input) {
     return createHash("sha256").update(inputSignature(input)).digest("hex");
 }
-export function isRedactedToolCallInput(input) {
+export function isUnavailableToolCallInput(input) {
     if (typeof input === "string")
         return /\[inline [^\]]+ data omitted\]/.test(input);
     if (!input || typeof input !== "object")
         return false;
-    if ("omitted" in input && input.omitted === "inline-bytes")
+    if ("omitted" in input &&
+        (input.omitted === "inline-bytes" || input.omitted === "tool-input")) {
         return true;
-    return Object.values(input).some(isRedactedToolCallInput);
+    }
+    return Object.values(input).some(isUnavailableToolCallInput);
 }
 export function isConsistentToolCallInputFingerprint(input, fingerprint, storedFingerprint) {
     if (storedFingerprint !== undefined)

package/dist/agent/types.d.ts

@@ -67,6 +67,8 @@ export type AgentChatStructuredContentPart = {
     toolName?: string;
     input?: unknown;
     args?: unknown;
+    approvalKey?: string;
+    approvalAskId?: string;
 } | {
     type: "tool-result";
     toolCallId: string;
@@ -74,6 +76,8 @@ export type AgentChatStructuredContentPart = {
     toolInput?: string;
     content: string;
     isError?: boolean;
+    approvalPause?: boolean;
+    approvalAskId?: string;
 };
 export interface AgentChatStructuredMessage {
     role: "user" | "assistant";
@@ -215,6 +219,7 @@ export interface AgentChatRequest {
     harness?: AgentChatHarnessRequest;
     trackInRunsTray?: boolean;
     approvedToolCalls?: string[];
+    approvedToolCallAskIds?: string[];
     skipPendingSelectionContext?: boolean;
 }
 export type AgentToolInput = Record<string, unknown>;
@@ -287,6 +292,8 @@ export type AgentChatEvent = {
     isError?: boolean;
     errorCode?: string;
     completedSideEffect?: boolean;
+    /** False marks current completed events; absence is reserved for older journals. */
+    approvalPause?: boolean;
     outcomeUnknown?: true;
     replayed?: true;
     fileMutation?: AgentFileMutationProof;

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

@@ -3,6 +3,7 @@ import { agentEventSequenceEnd, isAgentKitProtocolVersion, parseAgentQueuedMessa
 import { failedRunIdsWithError, isRenderedRunNotStartedNotice, projectRootAssistantMessages, } from "../../agent/thread-message-projection.js";
 import { RUN_NOT_STARTED_METADATA_KEY, retryContextFromRequest, } from "../../shared/agent-chat-run-not-started.js";
 import { assertNoInlineImageBytes, stripInlineBytes, } from "../../shared/inline-bytes.js";
+import { toolInputFingerprint } from "../../shared/tool-inputs.js";
 import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch, } from "../agent-engine-readiness.js";
 import { agentNativePath } from "../api-path.js";
 import { CHAT_REQUEST_TOO_LARGE_MESSAGE } from "../error-format.js";
@@ -1585,6 +1586,15 @@ function persistedToolCalls(toolCalls = []) {
             new TextEncoder().encode(serialized).byteLength <= 64 * 1024) {
             return [JSON.parse(serialized)];
         }
+        const metadata = asRecord(toolCall.metadata);
+        const agentKitSnapshot = asRecord(metadata?.agentKitSnapshot);
+        const inputFingerprint = toolCall.input === undefined
+            ? agentKitSnapshot?.inputFingerprint
+            : toolInputFingerprint(toolCall.input);
+        const approvalAskId = typeof metadata?.approvalAskId === "string" &&
+            metadata.approvalAskId.length <= 512
+            ? metadata.approvalAskId
+            : undefined;
         return [
             {
                 id: toolCall.id,
@@ -1593,9 +1603,17 @@ function persistedToolCalls(toolCalls = []) {
                 ...(toolCall.runId ? { runId: toolCall.runId } : {}),
                 ...(toolCall.messageId ? { messageId: toolCall.messageId } : {}),
                 metadata: {
+                    ...(metadata?.approvalPause === true ? { approvalPause: true } : {}),
+                    ...(metadata?.completedSideEffect === true
+                        ? { completedSideEffect: true }
+                        : {}),
+                    ...(approvalAskId ? { approvalAskId } : {}),
                     agentKitSnapshot: {
                         toolCallResult: "omitted",
                         reason: serialized ? "size_limit" : "not_json",
+                        ...(typeof inputFingerprint === "string"
+                            ? { inputFingerprint }
+                            : {}),
                     },
                 },
             },