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

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

@@ -1,4 +1,5 @@
 import { AGENT_TOOL_CALL_HISTORY_MEDIA_TYPE, AGENT_TOOL_RESULT_HISTORY_MEDIA_TYPE, AGENTKIT_PROTOCOL_VERSION, AgentProtocolValidationError, approvalResponseFromResume, createCapabilityUnavailableError, createCapabilityUnsupportedError, inferAgentActivityKind, negotiateAgentKitProtocolVersion, resumeEntryFromApproval, resumeOptionId, } from "@agent-native/agentkit/protocol";
+import { approvalKeyForHistory } from "../../agent/approval-key.js";
 import { AUTO_CONTINUE_OF_RUN_METADATA_KEY, AUTO_CONTINUE_PROMPT, AUTO_CONTINUE_REFUSAL_CODES, CONTINUE_OF_RUN_METADATA_KEY, CONTINUE_UNAVAILABLE_CODE, } from "../../agent/auto-continue.js";
 import { isPersistableAttachmentUrl } from "../../shared/attachments.js";
 import { parseBase64DataUrl } from "../../shared/data-url.js";
@@ -536,6 +537,16 @@ function runtimePartToProtocolPart(part, fallbackTextFormat) {
                     name: part.toolName,
                     input: part.input,
                     inputText: part.inputText,
+                    ...(part.approval?.approvalKey
+                        ? {
+                            approvalKey: part.approval.askId
+                                ? approvalKeyForHistory(part.approval.approvalKey)
+                                : part.approval.approvalKey,
+                        }
+                        : {}),
+                    ...(part.approval?.askId
+                        ? { approvalAskId: part.approval.askId }
+                        : {}),
                 },
             };
         case "tool-result":
@@ -548,6 +559,10 @@ function runtimePartToProtocolPart(part, fallbackTextFormat) {
                     result: part.result,
                     resultText: part.resultText,
                     isError: part.isError,
+                    ...(typeof part.approvalPause === "boolean"
+                        ? { approvalPause: part.approvalPause }
+                        : {}),
+                    ...(part.approvalAskId ? { approvalAskId: part.approvalAskId } : {}),
                 },
             };
         case "data":
@@ -606,6 +621,18 @@ function protocolPartToRuntimePart(part) {
                     ...(typeof data.inputText === "string"
                         ? { inputText: data.inputText }
                         : {}),
+                    ...(typeof data.approvalKey === "string" &&
+                        data.approvalKey.length > 0
+                        ? {
+                            approval: {
+                                approvalKey: data.approvalKey,
+                                ...(typeof data.approvalAskId === "string" &&
+                                    data.approvalAskId.length > 0
+                                    ? { askId: data.approvalAskId }
+                                    : {}),
+                            },
+                        }
+                        : {}),
                 };
             }
             if (part.mediaType === AGENT_TOOL_RESULT_HISTORY_MEDIA_TYPE) {
@@ -621,6 +648,13 @@ function protocolPartToRuntimePart(part) {
                         ? { resultText: data.resultText }
                         : {}),
                     ...(data.isError === true ? { isError: true } : {}),
+                    ...(typeof data.approvalPause === "boolean"
+                        ? { approvalPause: data.approvalPause }
+                        : {}),
+                    ...(typeof data.approvalAskId === "string" &&
+                        data.approvalAskId.length > 0
+                        ? { approvalAskId: data.approvalAskId }
+                        : {}),
                 };
             }
             return {
@@ -1756,7 +1790,10 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 if (invocation)
                     run.actions.set(event.toolCall.id, invocation);
                 const messageId = runtimeToolMessageId(run, event.toolCall.metadata);
-                const toolCall = runtimeToolToProtocolTool(event.toolCall, "running", undefined, undefined, messageId);
+                const toolCall = {
+                    ...runtimeToolToProtocolTool(event.toolCall, "running", undefined, undefined, messageId),
+                    runId: run.runId,
+                };
                 if (messageId) {
                     run.pendingToolMessageAssociations.delete(toolCall.id);
                 }
@@ -1815,10 +1852,23 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 const invocation = run.actions.get(event.toolCallId);
                 const previousTool = run.activeTools.get(event.toolCallId);
                 const metadata = mergeProtocolMetadata(previousTool?.metadata, invocation?.metadata, event.metadata, base.metadata, {
-                    ...(event.completedSideEffect ? { completedSideEffect: true } : {}),
+                    ...(event.completedSideEffect
+                        ? { completedSideEffect: true }
+                        : {}),
                     ...(event.chatUI ? { chatUI: event.chatUI } : {}),
                     ...(event.mcpApp ? { mcpApp: event.mcpApp } : {}),
-                });
+                }) ?? {};
+                if (event.approvalPause === true) {
+                    metadata.approvalPause = true;
+                    if (event.approvalAskId) {
+                        metadata.approvalAskId = event.approvalAskId;
+                    }
+                }
+                else {
+                    delete metadata.approvalPause;
+                    delete metadata.approvalAskId;
+                }
+                const protocolMetadata = Object.keys(metadata).length > 0 ? metadata : undefined;
                 const actionResult = invocation
                     ? actionResultFromTool({
                         invocation,
@@ -1826,7 +1876,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                         result: event.result,
                         resultText: event.resultText,
                         error,
-                        metadata,
+                        metadata: protocolMetadata,
                     })
                     : undefined;
                 if (invocation)
@@ -1845,8 +1895,9 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     status,
                     output: event.result !== undefined ? event.result : event.resultText,
                     error,
+                    runId: run.runId,
                     ...(messageId ? { messageId } : {}),
-                    ...(metadata ? { metadata } : {}),
+                    ...(protocolMetadata ? { metadata: protocolMetadata } : {}),
                 };
                 if (messageId) {
                     run.pendingToolMessageAssociations.delete(event.toolCallId);

package/dist/client/chat/runtime.d.ts

@@ -45,6 +45,12 @@ export interface AgentChatRuntimeToolCallPart extends AgentChatRuntimeContentPar
     readonly toolName: string;
     readonly input?: unknown;
     readonly inputText?: string;
+    readonly approval?: {
+        readonly approvalKey: string;
+        readonly askId?: string;
+    };
+    /** Keeps the exact approved invocation available within the continuation budget. */
+    readonly approvedReplay?: true;
 }
 export interface AgentChatRuntimeToolResultPart extends AgentChatRuntimeContentPartBase<"tool-result"> {
     readonly toolCallId: AgentChatRuntimeToolCallId;
@@ -52,6 +58,8 @@ export interface AgentChatRuntimeToolResultPart extends AgentChatRuntimeContentP
     readonly result?: unknown;
     readonly resultText?: string;
     readonly isError?: boolean;
+    readonly approvalPause?: boolean;
+    readonly approvalAskId?: string;
     readonly mcpApp?: AgentMcpAppPayload;
     readonly chatUI?: ActionChatUIConfig;
 }
@@ -310,6 +318,8 @@ export interface AgentChatRuntimeToolDoneEvent extends AgentChatRuntimeEventBase
     readonly resultText?: string;
     readonly error?: string;
     readonly completedSideEffect?: boolean;
+    readonly approvalPause?: boolean;
+    readonly approvalAskId?: string;
     readonly mcpApp?: AgentMcpAppPayload;
     readonly chatUI?: ActionChatUIConfig;
 }

package/dist/client/chat/runtime.js

@@ -4,7 +4,7 @@ import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch
 import { getOrCreateAnalyticsSessionId } from "../analytics-session.js";
 import { agentChatStreamingUrl, agentNativePath } from "../api-path.js";
 import { CHAT_REQUEST_TOO_LARGE_MESSAGE } from "../error-format.js";
-import { appendMissingFinalResponseWarning, } from "../sse-event-processor.js";
+import { appendMissingFinalResponseWarning, findApprovalToolCallIndex, } from "../sse-event-processor.js";
 import { runOutcomeForCode } from "./run-outcome.js";
 export const AGENT_NATIVE_RUN_RESUME_STATE_METADATA_KEY = "agentNativeRunResumeState";
 const AGENTKIT_TOOL_HISTORY_OMISSION_MESSAGE_ID_PREFIX = "agentkit-tool-history-omission";
@@ -946,6 +946,42 @@ function structuredToolHistoryCandidateByteCost(candidate) {
     return (candidate.assistantParts.reduce((bytes, part) => bytes + structuredHistoryPartByteCost("assistant", part), 0) +
         candidate.resultParts.reduce((bytes, part) => bytes + structuredHistoryPartByteCost("user", part), 0));
 }
+function approvedToolHistoryParts(history, askId) {
+    let call;
+    let result;
+    for (const message of history) {
+        for (const part of message.content) {
+            if (message.role === "assistant" &&
+                part.type === "tool-call" &&
+                part.approvalAskId === askId) {
+                call = part;
+            }
+            else if (message.role === "user" &&
+                part.type === "tool-result" &&
+                part.approvalPause === true &&
+                part.approvalAskId === askId) {
+                result = part;
+            }
+        }
+    }
+    return { call, result };
+}
+function approvedToolHistoryError(code, status) {
+    return Object.assign(new Error(status === 413 ? CHAT_REQUEST_TOO_LARGE_MESSAGE : "The agent run failed."), { code, status, retryable: false });
+}
+function assertApprovedToolHistory(history, askIds, status) {
+    for (const askId of askIds) {
+        const { call, result } = approvedToolHistoryParts(history, askId);
+        if (!call || !result) {
+            if (status === 413)
+                throw approvedToolHistoryError("http_413", 413);
+            throw approvedToolHistoryError("approved_tool_call_history_missing", 422);
+        }
+        if (!Object.prototype.hasOwnProperty.call(call, "input")) {
+            throw approvedToolHistoryError("http_413", 413);
+        }
+    }
+}
 function structuredTextHistoryCandidateByteCost(candidate) {
     return candidate.parts.reduce((bytes, part) => bytes + structuredHistoryPartByteCost(candidate.role, part), 0);
 }
@@ -1187,8 +1223,8 @@ function boundedJsonStringify(value, maxBytes) {
         return { status: "unserializable" };
     }
 }
-function toolInputForStructuredHistory(input) {
-    const serialization = boundedJsonStringify(input, MAX_TOOL_HISTORY_VALUE_BYTES);
+function toolInputForStructuredHistory(input, maxBytes = MAX_TOOL_HISTORY_VALUE_BYTES) {
+    const serialization = boundedJsonStringify(input, maxBytes);
     if (serialization.status === "too-large") {
         return { omissionText: TOOL_INPUT_SIZE_OMISSION_TEXT };
     }
@@ -1737,16 +1773,55 @@ function boundaryToolResultPartsToOmit(messages, supplementalMessages, sources,
     }
     return partsToOmit;
 }
-function nativeStructuredHistoryFromMessages(messages, currentPrompt, currentAttachmentUrls, supplementalMessages = [], supplementalHistoryOmitted = false, supplementalToolHistoryOmitted = false) {
+function assertUnambiguousKeyOnlyApprovedHistory(sources, approvedToolCalls, approvedToolCallAskIds) {
+    if (!approvedToolCalls.length || approvedToolCallAskIds.length > 0)
+        return;
+    const approvedKeys = new Set(approvedToolCalls);
+    const callCountsByKey = new Map();
+    for (const { message, parts, priority } of sources) {
+        if (message.role !== "assistant")
+            continue;
+        for (const part of parts) {
+            if (part.type !== "tool-call" ||
+                !part.approval ||
+                !approvedKeys.has(part.approval.approvalKey)) {
+                continue;
+            }
+            let calls = callCountsByKey.get(part.approval.approvalKey);
+            if (!calls) {
+                calls = { history: new Map(), supplemental: new Set() };
+                callCountsByKey.set(part.approval.approvalKey, calls);
+            }
+            if (priority) {
+                calls.supplemental.add(part.toolCallId);
+            }
+            else {
+                calls.history.set(part.toolCallId, (calls.history.get(part.toolCallId) ?? 0) + 1);
+            }
+        }
+    }
+    for (const calls of callCountsByKey.values()) {
+        const historyCallCount = [...calls.history.values()].reduce((count, occurrences) => count + occurrences, 0);
+        const supplementalCallCount = [...calls.supplemental].filter((toolCallId) => !calls.history.has(toolCallId)).length;
+        if (historyCallCount + supplementalCallCount > 1) {
+            throw approvedToolHistoryError("approved_tool_call_history_ambiguous", 422);
+        }
+    }
+}
+function nativeStructuredHistoryFromMessages(messages, currentPrompt, currentAttachmentUrls, supplementalMessages = [], supplementalHistoryOmitted = false, supplementalToolHistoryOmitted = false, approvedToolCalls = [], approvedToolCallAskIds = []) {
     const structuredHistory = [];
+    const approvedToolCallSet = new Set(approvedToolCalls);
+    const approvedToolCallAskIdSet = new Set(approvedToolCallAskIds);
     const callCandidates = [];
     const resultReferences = [];
+    const approvalAskIdByToolCallId = new Map();
     const toolHistoryParts = new Set();
     const textHistoryParts = new Set();
     const textCandidates = [];
     let toolHistoryPosition = 0;
     let hasToolHistory = false;
     const sources = boundedStructuredHistorySources(messages, currentPrompt, supplementalMessages, currentAttachmentUrls);
+    assertUnambiguousKeyOnlyApprovedHistory(sources.messages, approvedToolCalls, approvedToolCallAskIds);
     const boundaryResultsToOmit = boundaryToolResultPartsToOmit(messages, supplementalMessages, sources, supplementalToolHistoryOmitted);
     for (const { message, parts, priority, textPriority } of sources.messages) {
         if (message.role !== "user" && message.role !== "assistant")
@@ -1822,9 +1897,20 @@ function nativeStructuredHistoryFromMessages(messages, currentPrompt, currentAtt
                             addToolInputText(part.inputText);
                         }
                     }
+                    const approvedReplay = part.approvedReplay === true ||
+                        (part.approval !== undefined &&
+                            approvedToolCallSet.has(part.approval.approvalKey) &&
+                            (approvedToolCallAskIdSet.size === 0 ||
+                                (part.approval.askId !== undefined &&
+                                    approvedToolCallAskIdSet.has(part.approval.askId))));
+                    if (approvedReplay && part.input === undefined) {
+                        throw approvedToolHistoryError("approved_tool_call_input_unavailable", 422);
+                    }
                     const input = part.input === undefined
                         ? undefined
-                        : toolInputForStructuredHistory(part.input);
+                        : toolInputForStructuredHistory(part.input, approvedReplay
+                            ? MAX_ADDED_TOOL_HISTORY_BYTES
+                            : MAX_TOOL_HISTORY_VALUE_BYTES);
                     if (input && "omissionText" in input) {
                         addToolInputText(input.omissionText);
                     }
@@ -1833,7 +1919,20 @@ function nativeStructuredHistoryFromMessages(messages, currentPrompt, currentAtt
                         id: part.toolCallId,
                         name: part.toolName,
                         ...(input && "input" in input ? { input: input.input } : {}),
+                        ...(part.approval?.askId
+                            ? { approvalAskId: part.approval.askId }
+                            : {}),
+                        // The ask ID selects this call server-side; its key repeats large inputs.
+                        ...(part.approval?.approvalKey && !part.approval.askId
+                            ? { approvalKey: part.approval.approvalKey }
+                            : {}),
                     };
+                    if (part.approval?.askId) {
+                        approvalAskIdByToolCallId.set(part.toolCallId, part.approval.askId);
+                    }
+                    else {
+                        approvalAskIdByToolCallId.delete(part.toolCallId);
+                    }
                     content.push(callPart);
                     candidateAssistantParts.push(callPart);
                     toolHistoryParts.add(callPart);
@@ -1867,6 +1966,14 @@ function nativeStructuredHistoryFromMessages(messages, currentPrompt, currentAtt
                         ...(part.toolName ? { toolName: part.toolName } : {}),
                         content: toolResultForStructuredHistory(part.result, part.resultText),
                         ...(part.isError ? { isError: true } : {}),
+                        ...(part.approvalPause === true ? { approvalPause: true } : {}),
+                        ...((part.approvalAskId ??
+                            approvalAskIdByToolCallId.get(part.toolCallId))
+                            ? {
+                                approvalAskId: part.approvalAskId ??
+                                    approvalAskIdByToolCallId.get(part.toolCallId),
+                            }
+                            : {}),
                     };
                 results.push(resultPart);
                 toolHistoryParts.add(resultPart);
@@ -1888,15 +1995,34 @@ function nativeStructuredHistoryFromMessages(messages, currentPrompt, currentAtt
         !sources.hasAttachmentHistory &&
         !supplementalHistoryOmitted &&
         !supplementalToolHistoryOmitted) {
+        assertApprovedToolHistory([], approvedToolCallAskIds, 422);
         return undefined;
     }
-    return boundStructuredToolHistory(structuredHistory, callCandidates, resultReferences, textCandidates, toolHistoryParts, textHistoryParts, sources.omitted ||
+    assertApprovedToolHistory(structuredHistory, approvedToolCallAskIds, 422);
+    const boundedHistory = boundStructuredToolHistory(structuredHistory, callCandidates, resultReferences, textCandidates, toolHistoryParts, textHistoryParts, sources.omitted ||
         supplementalHistoryOmitted ||
         supplementalToolHistoryOmitted);
-}
-function pendingApprovalRuntimeMessages(state) {
+    assertApprovedToolHistory(boundedHistory, approvedToolCallAskIds, 413);
+    return boundedHistory;
+}
+function isPendingApprovedToolCall(part, approvedToolCallSet, approvedToolCallAskIdSet) {
+    return (part.approval !== undefined &&
+        approvedToolCallSet.has(part.approval.approvalKey) &&
+        (approvedToolCallAskIdSet.size === 0 ||
+            (part.approval.askId !== undefined &&
+                approvedToolCallAskIdSet.has(part.approval.askId))) &&
+        (part.result === undefined || part.approvalPause === true));
+}
+function pendingApprovalRuntimeMessages(state, approvedToolCalls, approvedToolCallAskIds) {
     const messagesReversed = [];
+    const approvedToolCallSet = new Set(approvedToolCalls);
+    const approvedToolCallAskIdSet = new Set(approvedToolCallAskIds);
+    const approvedCallCount = state.message.content.filter((part) => part.type === "tool-call" &&
+        isPendingApprovedToolCall(part, approvedToolCallSet, approvedToolCallAskIdSet)).length;
+    const reservedApprovalCallCount = Math.min(approvedCallCount, MAX_TOOL_HISTORY_CALLS);
+    const unapprovedToolPartLimit = MAX_STRUCTURED_HISTORY_TOOL_SOURCE_PARTS - reservedApprovalCallCount * 2;
     let selectedToolPartCount = 0;
+    let selectedApprovalCallCount = 0;
     let selectedTextPartCount = 0;
     let scannedPartCount = 0;
     let omitted = false;
@@ -1921,22 +2047,45 @@ function pendingApprovalRuntimeMessages(state) {
             });
             continue;
         }
-        if (part.type !== "tool-call" || part.result === undefined)
+        if (part.type !== "tool-call")
             continue;
-        if (selectedToolPartCount + 2 > MAX_STRUCTURED_HISTORY_TOOL_SOURCE_PARTS) {
-            omitted = true;
-            toolHistoryOmitted = true;
+        const awaitingApproval = part.toolCallId === state.message.pendingApprovalToolCallId;
+        const isApprovedPendingCall = isPendingApprovedToolCall(part, approvedToolCallSet, approvedToolCallAskIdSet);
+        if (part.result === undefined &&
+            !isApprovedPendingCall &&
+            !awaitingApproval) {
             continue;
         }
-        selectedToolPartCount += 2;
+        if (isApprovedPendingCall) {
+            if (selectedApprovalCallCount >= MAX_TOOL_HISTORY_CALLS) {
+                omitted = true;
+                toolHistoryOmitted = true;
+                continue;
+            }
+            selectedApprovalCallCount++;
+        }
+        else {
+            if (selectedToolPartCount + 2 > unapprovedToolPartLimit) {
+                omitted = true;
+                toolHistoryOmitted = true;
+                continue;
+            }
+            selectedToolPartCount += 2;
+        }
         messagesReversed.push({
             role: "user",
             content: [
                 {
                     type: "tool-result",
                     toolCallId: part.toolCallId,
-                    result: part.result,
+                    ...(part.approval?.askId
+                        ? { approvalAskId: part.approval.askId }
+                        : {}),
+                    result: awaitingApproval || (isApprovedPendingCall && !part.result?.trim())
+                        ? "Awaiting human approval. This action did NOT execute."
+                        : part.result,
                     ...(part.isError ? { isError: true } : {}),
+                    ...(isApprovedPendingCall ? { approvalPause: true } : {}),
                 },
             ],
         });
@@ -1948,6 +2097,8 @@ function pendingApprovalRuntimeMessages(state) {
                     toolCallId: part.toolCallId,
                     toolName: part.toolName,
                     input: part.args,
+                    approval: part.approval,
+                    ...(isApprovedPendingCall ? { approvedReplay: true } : {}),
                 },
             ],
         });
@@ -2195,10 +2346,17 @@ function mapAgentNativeEvent(raw, input) {
                 ? part.toolCallId === ev.id
                 : part.result === undefined && part.toolName === toolName));
         if (toolCall?.type === "tool-call") {
+            if (toolCall.result !== undefined && toolCall.approvalPause === true) {
+                toolCall.approvalResumeCandidate = true;
+            }
+            else {
+                delete toolCall.approvalResumeCandidate;
+            }
             toolCall.args = ev.input ?? {};
             toolCall.argsText = JSON.stringify(toolCall.args);
             if (structuredMeta)
                 toolCall.structuredMeta = structuredMeta;
+            delete toolCall.approvalPauseCandidate;
         }
         else {
             input.message.content.push({
@@ -2242,7 +2400,19 @@ function mapAgentNativeEvent(raw, input) {
             (storedToolCall?.type === "tool-call" ? storedToolCall.toolCallId : "");
         const structuredMeta = agentNativeStructuredMeta(ev);
         if (storedToolCall?.type === "tool-call") {
-            storedToolCall.result = agentNativeToolResultText(ev.result);
+            const resultText = agentNativeToolResultText(ev.result);
+            storedToolCall.result = resultText;
+            const legacyApprovalPause = ev.approvalPause === undefined &&
+                storedToolCall.approvalPauseCandidate === true;
+            if (ev.approvalPause === true || legacyApprovalPause) {
+                storedToolCall.approvalPause = true;
+            }
+            else {
+                delete storedToolCall.approvalPause;
+                delete storedToolCall.approval;
+            }
+            delete storedToolCall.approvalPauseCandidate;
+            delete storedToolCall.approvalResumeCandidate;
             storedToolCall.isError = ev.isError === true || Boolean(ev.error);
             storedToolCall.completedSideEffect = ev.completedSideEffect === true;
             if (ev.mcpApp)
@@ -2252,6 +2422,14 @@ function mapAgentNativeEvent(raw, input) {
             if (structuredMeta)
                 storedToolCall.structuredMeta = structuredMeta;
         }
+        // The approval gate emits a placeholder tool_done before execution.
+        if (input.message.pendingApprovalToolCallId === toolCallId &&
+            !input.message.approvalPending &&
+            storedToolCall?.type === "tool-call" &&
+            storedToolCall.result !== undefined &&
+            storedToolCall.approvalPause !== true) {
+            input.message.pendingApprovalToolCallId = undefined;
+        }
         const metadata = definedMetadata({ ...base.metadata, ...structuredMeta });
         const events = [
             {
@@ -2265,6 +2443,8 @@ function mapAgentNativeEvent(raw, input) {
                 resultText: ev.result,
                 error: ev.error,
                 completedSideEffect: ev.completedSideEffect === true,
+                approvalPause: storedToolCall?.approvalPause === true,
+                approvalAskId: storedToolCall?.approval?.askId,
                 mcpApp: ev.mcpApp,
                 chatUI: ev.chatUI,
             },
@@ -2323,15 +2503,33 @@ function mapAgentNativeEvent(raw, input) {
     }
     if (ev.type === "approval_required") {
         input.message.approvalPending = true;
+        const approvalKey = ev.approvalKey;
+        let approvalToolCallId = ev.toolCallId ?? ev.id;
+        if (typeof approvalKey === "string" && approvalKey.length > 0) {
+            const approvalToolCallIndex = findApprovalToolCallIndex(input.message.content, ev.tool ?? "unknown", approvalToolCallId, ev.input);
+            const part = input.message.content[approvalToolCallIndex];
+            if (part?.type === "tool-call") {
+                approvalToolCallId ??= part.toolCallId;
+                part.approval = {
+                    approvalKey,
+                    ...(ev.askId ? { askId: ev.askId } : {}),
+                    ...(ev.allowPersistentApproval === false
+                        ? { allowPersistentApproval: false }
+                        : {}),
+                };
+                part.approvalPauseCandidate = true;
+                delete part.approvalResumeCandidate;
+            }
+        }
+        input.message.pendingApprovalToolCallId = approvalToolCallId;
         return [
             {
                 type: "approval-request",
                 ...base,
-                approvalId: ev.approvalKey ?? ev.id ?? createRuntimeId("approval"),
+                approvalId: ev.askId ?? ev.approvalKey ?? ev.id ?? createRuntimeId("approval"),
                 // `approval_required` carries the model-side call id as `toolCallId`,
-                // not `id`. Without this the request falls back to matching by tool
-                // name, which picks the wrong call when two are pending at once.
-                toolCallId: ev.toolCallId ?? ev.id,
+                // not `id`. When older frames omit both ids, use the unique input match.
+                toolCallId: approvalToolCallId,
                 toolName: ev.tool,
                 message: ev.label ?? "Approve this tool call?",
                 input: ev.input,
@@ -2747,6 +2945,7 @@ function mapAgentNativeEvent(raw, input) {
     return [];
 }
 const AGENT_NATIVE_APPROVED_TOOL_CALLS_METADATA_KEY = "agentNativeApprovedToolCalls";
+const AGENT_NATIVE_APPROVED_TOOL_CALL_ASK_IDS_METADATA_KEY = "agentNativeApprovedToolCallAskIds";
 const AGENT_NATIVE_CONTINUATION_TURN_ID_METADATA_KEY = "agentNativeContinuationTurnId";
 const AGENT_NATIVE_INTERNAL_CONTINUATION_METADATA_KEY = "agentNativeInternalContinuation";
 function metadataString(metadata, key) {
@@ -2929,6 +3128,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                     .join("\n") ??
                 "";
             const approvedToolCalls = metadataStringList(turn.metadata, AGENT_NATIVE_APPROVED_TOOL_CALLS_METADATA_KEY);
+            const approvedToolCallAskIds = metadataStringList(turn.metadata, AGENT_NATIVE_APPROVED_TOOL_CALL_ASK_IDS_METADATA_KEY);
             const continuationTurnId = metadataString(turn.metadata, AGENT_NATIVE_CONTINUATION_TURN_ID_METADATA_KEY);
             const autoContinueOfRunId = metadataString(turn.metadata, AUTO_CONTINUE_OF_RUN_METADATA_KEY);
             const continueOfRunId = metadataString(turn.metadata, CONTINUE_OF_RUN_METADATA_KEY);
@@ -2946,9 +3146,9 @@ export function createAgentNativeChatRuntime(options = {}) {
             const history = nativeHistoryFromMessages(messagesForHistory, prompt, currentAttachmentUrlSet);
             const loadedSkillSlugs = loadedSkillSlugsFromMessages(turn.messages);
             const pendingApprovalHistory = approvedToolCalls && continuationMessageState
-                ? pendingApprovalRuntimeMessages(continuationMessageState)
+                ? pendingApprovalRuntimeMessages(continuationMessageState, approvedToolCalls, approvedToolCallAskIds ?? [])
                 : { messages: [], omitted: false, toolHistoryOmitted: false };
-            const structuredHistory = nativeStructuredHistoryFromMessages(messagesForHistory, prompt, currentAttachmentUrlSet, pendingApprovalHistory.messages, pendingApprovalHistory.omitted, pendingApprovalHistory.toolHistoryOmitted);
+            const structuredHistory = nativeStructuredHistoryFromMessages(messagesForHistory, prompt, currentAttachmentUrlSet, pendingApprovalHistory.messages, pendingApprovalHistory.omitted, pendingApprovalHistory.toolHistoryOmitted, approvedToolCalls, approvedToolCallAskIds);
             return {
                 message: prompt,
                 ...(latestUserMessage?.id
@@ -2976,6 +3176,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                     ? { skipPendingSelectionContext: true }
                     : {}),
                 ...(approvedToolCalls ? { approvedToolCalls } : {}),
+                ...(approvedToolCallAskIds ? { approvedToolCallAskIds } : {}),
                 ...(options.mode ? { mode: options.mode } : {}),
                 ...((turn.model ?? options.model)
                     ? { model: turn.model ?? options.model }
@@ -3000,6 +3201,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                         content: [],
                         started: false,
                         approvalPending: false,
+                        pendingApprovalToolCallId: undefined,
                         connectionPending: false,
                     },
                 };
@@ -3019,7 +3221,10 @@ export function createAgentNativeChatRuntime(options = {}) {
         continueTurn: ({ session, continuation, previousTurn, startTurn }) => {
             // Only the continuation that names a stopped run continues it; an approval
             // or connection answered later is not another continuation of that run.
-            const { [AUTO_CONTINUE_OF_RUN_METADATA_KEY]: _autoContinueOf, [CONTINUE_OF_RUN_METADATA_KEY]: _continueOf, ...previousMetadata } = previousTurn?.metadata ?? {};
+            const { [AUTO_CONTINUE_OF_RUN_METADATA_KEY]: _autoContinueOf, [CONTINUE_OF_RUN_METADATA_KEY]: _continueOf, [AGENT_NATIVE_APPROVED_TOOL_CALLS_METADATA_KEY]: _approvedToolCalls, [AGENT_NATIVE_APPROVED_TOOL_CALL_ASK_IDS_METADATA_KEY]: _approvedToolCallAskIds, ...previousMetadata } = previousTurn?.metadata ?? {};
+            const continuationMetadata = { ...continuation.metadata };
+            delete continuationMetadata[AGENT_NATIVE_APPROVED_TOOL_CALLS_METADATA_KEY];
+            delete continuationMetadata[AGENT_NATIVE_APPROVED_TOOL_CALL_ASK_IDS_METADATA_KEY];
             const turnToContinue = continuation.attachments?.length
                 ? { ...previousTurn, attachments: continuation.attachments }
                 : previousTurn;
@@ -3044,7 +3249,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                         `The ${connection.id} connection is now available. Continue the requested work.`,
                     metadata: {
                         ...previousMetadata,
-                        ...continuation.metadata,
+                        ...continuationMetadata,
                         [AGENT_NATIVE_CONTINUATION_TURN_ID_METADATA_KEY]: continuation.turnId,
                         [AGENT_NATIVE_INTERNAL_CONTINUATION_METADATA_KEY]: true,
                     },
@@ -3063,7 +3268,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                     prompt: continuation.prompt,
                     metadata: {
                         ...previousMetadata,
-                        ...continuation.metadata,
+                        ...continuationMetadata,
                         [AGENT_NATIVE_CONTINUATION_TURN_ID_METADATA_KEY]: continuation.turnId,
                         [AGENT_NATIVE_INTERNAL_CONTINUATION_METADATA_KEY]: true,
                     },
@@ -3079,6 +3284,25 @@ export function createAgentNativeChatRuntime(options = {}) {
                 });
             }
             const messageState = messageStates.get(messageStateKey);
+            const approvalParts = [
+                ...(turnToContinue?.messages ?? []).flatMap((message) => message.content),
+                ...(messageState?.message.content ?? []),
+            ].filter((part) => part.type === "tool-call" &&
+                (part.approval?.askId === approval.id ||
+                    part.approval?.approvalKey === approval.id));
+            if (approvalParts.length > 1) {
+                throw approvedToolHistoryError("approved_tool_call_history_ambiguous", 422);
+            }
+            const approvalPart = approvalParts[0];
+            const approvalKey = approvalPart?.type === "tool-call"
+                ? approvalPart.approval?.approvalKey
+                : undefined;
+            const approvalAskId = approvalPart?.type === "tool-call"
+                ? approvalPart.approval?.askId
+                : undefined;
+            if (!approvalKey) {
+                throw approvedToolHistoryError("approved_tool_call_history_missing", 422);
+            }
             if (messageState)
                 messageState.message.approvalPending = false;
             return startTurn({
@@ -3087,8 +3311,15 @@ export function createAgentNativeChatRuntime(options = {}) {
                     "Approved. Go ahead and run the requested action.",
                 metadata: {
                     ...previousMetadata,
-                    ...continuation.metadata,
-                    [AGENT_NATIVE_APPROVED_TOOL_CALLS_METADATA_KEY]: [approval.id],
+                    ...continuationMetadata,
+                    [AGENT_NATIVE_APPROVED_TOOL_CALLS_METADATA_KEY]: [approvalKey],
+                    ...(approvalAskId
+                        ? {
+                            [AGENT_NATIVE_APPROVED_TOOL_CALL_ASK_IDS_METADATA_KEY]: [
+                                approvalAskId,
+                            ],
+                        }
+                        : {}),
                     [AGENT_NATIVE_CONTINUATION_TURN_ID_METADATA_KEY]: continuation.turnId,
                     [AGENT_NATIVE_INTERNAL_CONTINUATION_METADATA_KEY]: true,
                 },