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

package/agent-native.eject.json

@@ -18,6 +18,7 @@
         "notion",
         "gmail",
         "google_calendar",
+        "bigquery",
         "google_docs",
         "google_drive",
         "google_sheets",

package/dist/agent/approval-key.d.ts

@@ -0,0 +1,2 @@
+export declare function hashAgentToolApprovalKey(approvalKey: string): string;
+export declare function approvalKeyForHistory(approvalKey: string): string;

package/dist/agent/approval-key.js

@@ -0,0 +1,12 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+const APPROVAL_KEY_HISTORY_PREFIX = "agent-tool-approval-key-sha256:";
+const HASHED_APPROVAL_KEY_PATTERN = /^agent-tool-approval-key-sha256:[a-f0-9]{64}$/;
+export function hashAgentToolApprovalKey(approvalKey) {
+    return bytesToHex(sha256(new TextEncoder().encode(approvalKey)));
+}
+export function approvalKeyForHistory(approvalKey) {
+    if (HASHED_APPROVAL_KEY_PATTERN.test(approvalKey))
+        return approvalKey;
+    return `${APPROVAL_KEY_HISTORY_PREFIX}${hashAgentToolApprovalKey(approvalKey)}`;
+}

package/dist/agent/context-xray/tokenize.js

@@ -7,9 +7,18 @@ async function loadTokenizer() {
         // browser fallback, while the documented estimate below is sufficient
         // when an edge runtime cannot resolve the tokenizer.
         tokenizerPromise = import(/* @vite-ignore */ TOKENIZER_MODULE_ID)
-            .then((mod) => typeof mod.countTokens === "function"
-            ? mod.countTokens
-            : null)
+            .then((mod) => {
+            // The package's countTokens rebuilds the BPE encoder on every call
+            // (~20 ms); counting a whole context part by part before each model
+            // call turned that into seconds of dead time per turn.
+            if (typeof mod.getTokenizer === "function") {
+                const encoder = mod.getTokenizer();
+                return (text) => encoder.encode(text.normalize("NFKC"), "all").length;
+            }
+            return typeof mod.countTokens === "function"
+                ? mod.countTokens
+                : null;
+        })
             .catch(() => null);
     }
     return tokenizerPromise;

package/dist/agent/engine/translate-anthropic.js

@@ -189,6 +189,10 @@ export function backfillEngineMessagesToolResults(messages) {
                 toolInput,
                 content: interrupted ? INTERRUPTED_TOOL_RESULT_FOR_MODEL : part.content,
                 ...(part.isError || interrupted ? { isError: true } : {}),
+                ...(part.approvalPause === undefined
+                    ? {}
+                    : { approvalPause: part.approvalPause }),
+                ...(part.approvalAskId ? { approvalAskId: part.approvalAskId } : {}),
                 ...(part.images && part.images.length > 0
                     ? { images: part.images }
                     : {}),

package/dist/agent/engine/types.d.ts

@@ -64,6 +64,8 @@ export interface EngineToolResultPart {
     toolInput: string;
     content: string;
     isError?: boolean;
+    approvalPause?: boolean;
+    approvalAskId?: string;
     outcome?: "unknown";
     images?: EngineToolResultImagePart[];
 }

package/dist/agent/production-agent.d.ts

@@ -530,6 +530,7 @@ export declare const MAX_SAME_ERROR_ACROSS_ARGUMENTS = 3;
 export declare const MAX_IDENTICAL_TOOL_CALLS = 8;
 export interface TerminalActionStop {
     message: string;
+    transcriptMessage?: string;
     errorCode?: string;
     details?: string;
 }
@@ -545,6 +546,9 @@ export type AgentToolCallExecutionResult = {
 } | {
     status: "failed";
     output: string;
+    terminalError?: Extract<AgentChatEvent, {
+        type: "error";
+    }>;
 };
 export interface ExecuteAgentToolCallOptions {
     actions: Record<string, ActionEntry>;
@@ -564,6 +568,7 @@ export interface ExecuteAgentToolCallOptions {
     threadId?: string;
     turnId?: string;
     approvedToolCalls?: string[];
+    approvedToolCallAskId?: string;
     onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<string | void>;
     consumeApproval?: (binding: AgentApprovalBinding) => Promise<boolean>;
     isToolAlwaysAllowed?: (binding: AgentApprovalBinding) => Promise<boolean>;
@@ -574,6 +579,7 @@ export interface AgentApprovalBinding {
     input: unknown;
     callId: string;
     approvalKey: string;
+    approvalId?: string;
 }
 export declare function executeAgentToolCall(options: ExecuteAgentToolCallOptions): Promise<AgentToolCallExecutionResult>;
 export declare function filterInitialEngineTools(tools: EngineTool[], initialToolNames?: string[]): EngineTool[];
@@ -592,11 +598,19 @@ export declare function buildFirstRequestPayloadDetail(input: {
     availableToolCount: number;
 }): string;
 export declare function toolCallCacheKey(toolName: string, input: unknown): string;
-export declare function findApprovedStructuredToolCall(history: AgentChatStructuredMessage[] | undefined, approvedToolCalls: readonly string[] | undefined): {
-    name: string;
-    input: unknown;
-    callId: string;
-} | undefined;
+export declare function findApprovedStructuredToolCall(history: AgentChatStructuredMessage[] | undefined, approvedToolCalls: readonly string[] | undefined, approvedToolCallAskIds?: readonly string[]): {
+    status: "found";
+    toolCall: {
+        name: string;
+        input: unknown;
+        callId: string;
+        approvalAskId?: string;
+    };
+} | {
+    status: "ambiguous";
+} | {
+    status: "missing";
+};
 export declare function normalizeToolErrorForBreaker(error: string): string;
 /**
  * Tool errors the model has no way to clear: the missing thing lives outside
@@ -695,6 +709,7 @@ export declare function runAgentLoop(opts: {
         hardMaxResultChars?: number;
     };
     approvedToolCalls?: string[];
+    approvedToolCallAskId?: string;
     /**
      * Server-side approval persistence hooks. The HTTP transport supplies these
      * so client-supplied history is never the authorization source; direct loop

package/dist/agent/production-agent.js

@@ -83,7 +83,7 @@ import { writeLedgerEntry, readLedgerEntry, clearLedgerForThread, AgentTurnIniti
 import { buildCurrentTimeUserContext } from "./runtime-context.js";
 import { claimSetupResume, setupResumeRefusedRunId, } from "./setup-resume-claim.js";
 import { consumeAgentToolApproval, createAgentToolApproval, isAgentToolAlwaysAllowed, resolveAgentToolApprovalTurnId, } from "./tool-approval-store.js";
-import { findCompletedJournalEntry } from "./tool-call-journal.js";
+import { findCompletedJournalEntry, isUnavailableToolCallInput, } from "./tool-call-journal.js";
 import { redactSensitiveFields, sanitizeToolErrorText, sanitizeToolErrorValue, } from "./tool-error-redaction.js";
 import { describeToolResultImages, extractAgentImagesFromActionResult, } from "./tool-result-images.js";
 import { createToolSearchEntry, extractToolSearchResultNames, filterActionsForAgentDiscovery, readLoadedToolNames, searchToolRegistry, TOOL_SEARCH_ACTION_NAME, withLoadedToolNames, } from "./tool-search.js";
@@ -1332,6 +1332,17 @@ export function serializeDurableDispatchPayload(body) {
     }
     return payload;
 }
+function approvedInputRequiresForeground(input) {
+    const originalPayload = JSON.stringify({ input });
+    try {
+        return serializeDurableDispatchPayload({ input }) !== originalPayload;
+    }
+    catch (error) {
+        if (error instanceof DurableAttachmentReferenceRequiredError)
+            return true;
+        throw error;
+    }
+}
 function toolInputActivityLabel(toolName) {
     return toolName ? `Preparing ${toolName} action` : "Preparing action input";
 }
@@ -2165,6 +2176,12 @@ export function structuredHistoryToEngineMessages(history, imageResolutions) {
                     toolInput,
                     content: wire.content,
                     ...(part.isError ? { isError: true } : {}),
+                    ...(typeof part.approvalPause === "boolean"
+                        ? { approvalPause: part.approvalPause }
+                        : {}),
+                    ...(typeof part.approvalAskId === "string"
+                        ? { approvalAskId: part.approvalAskId }
+                        : {}),
                 });
             }
         }
@@ -3100,6 +3117,9 @@ export async function executeAgentToolCall(options) {
     const events = [];
     const send = (event) => {
         events.push(event);
+        if (event.type === "text" && event.text === "Tool execution complete.") {
+            return;
+        }
         options.send?.(event);
     };
     const controller = options.signal ? null : new AbortController();
@@ -3138,6 +3158,7 @@ export async function executeAgentToolCall(options) {
             threadId: options.threadId,
             turnId: options.turnId,
             approvedToolCalls: options.approvedToolCalls,
+            approvedToolCallAskId: options.approvedToolCallAskId,
             onApprovalRequired: options.onApprovalRequired,
             consumeApproval: options.consumeApproval,
             isToolAlwaysAllowed: options.isToolAlwaysAllowed,
@@ -3153,6 +3174,7 @@ export async function executeAgentToolCall(options) {
     const completed = [...events]
         .reverse()
         .find((event) => event.type === "tool_done" && event.tool === options.name);
+    const terminalError = events.find((event) => event.type === "error" && event.recoverable === false);
     if (approval) {
         return {
             status: "approval_required",
@@ -3160,6 +3182,13 @@ export async function executeAgentToolCall(options) {
             output: completed?.result ?? `Awaiting human approval to run ${options.name}.`,
         };
     }
+    if (terminalError) {
+        return {
+            status: "failed",
+            output: completed?.result ?? terminalError.error,
+            terminalError,
+        };
+    }
     if (!completed) {
         return {
             status: "failed",
@@ -3304,12 +3333,14 @@ function stableStringify(value) {
 export function toolCallCacheKey(toolName, input) {
     return `${toolName}:${stableStringify(normalizeToolCallInputForHistory(input, toolName))}`;
 }
-export function findApprovedStructuredToolCall(history, approvedToolCalls) {
-    if (!Array.isArray(history) || !approvedToolCalls?.length)
-        return undefined;
+export function findApprovedStructuredToolCall(history, approvedToolCalls, approvedToolCallAskIds) {
+    if (!Array.isArray(history) || !approvedToolCalls?.length) {
+        return { status: "missing" };
+    }
     const approved = new Set(approvedToolCalls);
+    const approvedAskIds = new Set(approvedToolCallAskIds ?? []);
     const calls = new Map();
-    let match;
+    const matches = [];
     for (const message of history) {
         if (message.role === "assistant") {
             for (const part of message.content) {
@@ -3327,7 +3358,14 @@ export function findApprovedStructuredToolCall(history, approvedToolCalls) {
                         : "";
                 if (!callId || !name)
                     continue;
-                calls.set(callId, { name, input: part.input ?? part.args ?? {} });
+                calls.set(callId, {
+                    name,
+                    input: part.input !== undefined
+                        ? part.input
+                        : (part.args ?? { omitted: "tool-input" }),
+                    ...(part.approvalKey ? { approvalKey: part.approvalKey } : {}),
+                    ...(part.approvalAskId ? { approvalAskId: part.approvalAskId } : {}),
+                });
             }
             continue;
         }
@@ -3335,19 +3373,53 @@ export function findApprovedStructuredToolCall(history, approvedToolCalls) {
             if (part.type !== "tool-result")
                 continue;
             const call = calls.get(part.toolCallId);
-            if (!call || !approved.has(toolCallCacheKey(call.name, call.input))) {
+            if (!call) {
                 continue;
             }
-            const result = part.content.toLowerCase();
-            if (!result.includes("did not execute") &&
-                !result.includes("awaiting human approval") &&
-                !result.includes("waiting for your approval")) {
+            const matchesApproval = approvedAskIds.size > 0
+                ? Boolean(call.approvalAskId && approvedAskIds.has(call.approvalAskId))
+                : approved.has(call.approvalKey ?? toolCallCacheKey(call.name, call.input));
+            if (!matchesApproval) {
                 continue;
             }
-            match = { ...call, callId: part.toolCallId };
+            if (part.approvalPause !== true)
+                continue;
+            if (approvedAskIds.size > 0 &&
+                (!call.approvalAskId ||
+                    !approvedAskIds.has(call.approvalAskId) ||
+                    part.approvalAskId !== call.approvalAskId)) {
+                continue;
+            }
+            if (call.approvalAskId &&
+                part.approvalAskId &&
+                call.approvalAskId !== part.approvalAskId) {
+                continue;
+            }
+            matches.push({
+                name: call.name,
+                input: call.input,
+                callId: part.toolCallId,
+                ...((part.approvalAskId ?? call.approvalAskId)
+                    ? { approvalAskId: part.approvalAskId ?? call.approvalAskId }
+                    : {}),
+            });
         }
     }
-    return match;
+    if (approvedAskIds.size > 0) {
+        const distinctAskIds = new Set(matches.map((match) => match.approvalAskId).filter(Boolean));
+        if (distinctAskIds.size !== 1 ||
+            distinctAskIds.size !== approvedAskIds.size) {
+            return { status: matches.length === 0 ? "missing" : "ambiguous" };
+        }
+        const exactMatches = matches.filter((match) => approvedAskIds.has(match.approvalAskId ?? ""));
+        if (exactMatches.length === 0)
+            return { status: "missing" };
+        return { status: "found", toolCall: exactMatches.at(-1) };
+    }
+    if (matches.length > 1)
+        return { status: "ambiguous" };
+    const toolCall = matches[0];
+    return toolCall ? { status: "found", toolCall } : { status: "missing" };
 }
 const INTERRUPTED_TOOL_LEDGER_POLL_MS = process.env.NODE_ENV === "test" ? 0 : 2_000;
 async function waitForInterruptedToolLedgerEntry(opts) {
@@ -4330,7 +4402,7 @@ export async function runAgentLoop(opts) {
     const sendTerminalActionStop = (stop) => {
         if (stop.errorCode === "needs-approval" ||
             stop.errorCode === "awaiting-user-input") {
-            send({ type: "text", text: stop.message });
+            send({ type: "text", text: stop.transcriptMessage ?? stop.message });
             return;
         }
         send({
@@ -5132,12 +5204,23 @@ export async function runAgentLoop(opts) {
         let requestedActionStop = null;
         let requestedConnection;
         let turnYieldedToUser = false;
-        const noteToolCallSucceeded = (actionEntry) => {
+        const noteToolCallSucceeded = (actionEntry, toolName, toolInput) => {
             if (actionEntry.endsTurn !== true)
                 return;
             turnYieldedToUser = true;
+            const question = toolName === "ask-question" &&
+                typeof toolInput === "object" &&
+                toolInput !== null &&
+                "question" in toolInput &&
+                typeof toolInput.question === "string"
+                ? toolInput.question.trim()
+                : "";
+            const waitingMessage = "Waiting for your answer before continuing";
             requestedActionStop ??= {
-                message: "Waiting for your answer before continuing.",
+                message: question
+                    ? `${waitingMessage}: ${question}`
+                    : `${waitingMessage}.`,
+                transcriptMessage: `${waitingMessage}.`,
                 errorCode: "awaiting-user-input",
             };
         };
@@ -5396,13 +5479,16 @@ export async function runAgentLoop(opts) {
                 }
             }
             const approvalKey = toolCallCacheKey(toolCall.name, toolCall.input);
+            const requestedApproval = approvedToolCallKeys.delete(approvalKey);
             const approvalBinding = {
                 toolName: toolCall.name,
                 input: toolCall.input,
                 callId: toolCall.id,
                 approvalKey,
+                ...(requestedApproval && opts.approvedToolCallAskId
+                    ? { approvalId: opts.approvedToolCallAskId }
+                    : {}),
             };
-            const requestedApproval = approvedToolCallKeys.delete(approvalKey);
             const wasApproved = requestedApproval && opts.consumeApproval
                 ? await opts.consumeApproval(approvalBinding)
                 : requestedApproval;
@@ -5489,6 +5575,7 @@ export async function runAgentLoop(opts) {
                         input: journalToolInput,
                         result,
                         completedSideEffect: false,
+                        approvalPause: true,
                     });
                     recordToolResult(result, false);
                     turnYieldedToUser = true;
@@ -5550,7 +5637,7 @@ export async function runAgentLoop(opts) {
                             : {}),
                     });
                     recordToolResult(result, false, journaled.artifacts);
-                    noteToolCallSucceeded(actionEntry);
+                    noteToolCallSucceeded(actionEntry, toolCall.name, toolCall.input);
                     resetAfterSuccessfulWrite(toolCall.name, toolCall.input);
                     return {
                         type: "tool-result",
@@ -5614,7 +5701,7 @@ export async function runAgentLoop(opts) {
                                 : {}),
                         });
                         recordToolResult(result, false, ledgerResult.artifacts);
-                        noteToolCallSucceeded(actionEntry);
+                        noteToolCallSucceeded(actionEntry, toolCall.name, toolCall.input);
                         resetAfterSuccessfulWrite(toolCall.name, toolCall.input);
                         return {
                             type: "tool-result",
@@ -6160,7 +6247,7 @@ export async function runAgentLoop(opts) {
                 });
                 recordToolResult(result, isError, toolArtifacts, receipt);
                 if (!isError) {
-                    noteToolCallSucceeded(actionEntry);
+                    noteToolCallSucceeded(actionEntry, toolCall.name, toolCall.input);
                     if (cacheKey) {
                         readOnlyToolResultCache.set(cacheKey, {
                             content: result,
@@ -7364,6 +7451,9 @@ export async function chainServerDrivenContinuation(opts) {
             }
             : {}),
     };
+    // Approval selectors apply only to the request that consumes their one-shot grants.
+    delete continuationBody.approvedToolCalls;
+    delete continuationBody.approvedToolCallAskIds;
     delete continuationBody[AGENT_CHAT_BACKGROUND_RUN_FIELD];
     try {
         if (await d.isTurnAborted(effectiveThreadId, effectiveTurnId)) {
@@ -7769,7 +7859,7 @@ export function createProductionAgentHandler(options) {
             }
             backgroundRunClaimedEarly = true;
         }
-        const dispatchToBackground = !isBackgroundWorker &&
+        let dispatchToBackground = !isBackgroundWorker &&
             isAgentChatDurableBackgroundEnabled({
                 appOptIn: options.durableBackgroundRuns,
             });
@@ -7826,23 +7916,117 @@ export function createProductionAgentHandler(options) {
             setResponseStatus(event, 401);
             return { error: "Background agent runs require a persisted initiator" };
         }
-        const requestedApprovedToolCalls = Array.isArray(body.approvedToolCalls) && body.approvedToolCalls.length > 0
-            ? body.approvedToolCalls
-                .filter((key) => typeof key === "string")
-                .slice(0, 200)
+        const submittedApprovedToolCalls = body.approvedToolCalls;
+        if (submittedApprovedToolCalls !== undefined &&
+            (!Array.isArray(submittedApprovedToolCalls) ||
+                submittedApprovedToolCalls.length > 200 ||
+                submittedApprovedToolCalls.some((key) => typeof key !== "string" || key.length === 0))) {
+            setResponseStatus(event, 422);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_invalid",
+                retryable: false,
+            };
+        }
+        const requestedApprovedToolCalls = Array.isArray(submittedApprovedToolCalls) &&
+            submittedApprovedToolCalls.length > 0
+            ? submittedApprovedToolCalls
             : undefined;
-        const resolvedApprovalTurnId = !isBackgroundWorker &&
-            ownerEmail &&
-            threadId &&
-            requestedApprovedToolCalls?.length
+        const submittedApprovedToolCallAskIds = body.approvedToolCallAskIds;
+        if (submittedApprovedToolCallAskIds !== undefined &&
+            (!Array.isArray(submittedApprovedToolCallAskIds) ||
+                submittedApprovedToolCallAskIds.length > 200 ||
+                submittedApprovedToolCallAskIds.some((id) => typeof id !== "string" || id.length === 0 || id.trim() !== id))) {
+            setResponseStatus(event, 422);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_ask_id_invalid",
+                retryable: false,
+            };
+        }
+        const requestedApprovedToolCallAskIds = Array.isArray(submittedApprovedToolCallAskIds) &&
+            submittedApprovedToolCallAskIds.length > 0
+            ? submittedApprovedToolCallAskIds
+            : undefined;
+        // The approval fast path replays one call, so reject batches before any key can be dropped.
+        if (requestedApprovedToolCalls && requestedApprovedToolCalls.length > 1) {
+            setResponseStatus(event, 422);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_count_unsupported",
+                retryable: false,
+            };
+        }
+        if (requestedApprovedToolCallAskIds &&
+            (requestedApprovedToolCallAskIds.length !== 1 ||
+                requestedApprovedToolCalls?.length !== 1)) {
+            setResponseStatus(event, 422);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_ask_id_count_unsupported",
+                retryable: false,
+            };
+        }
+        const approvedToolCallLookup = findApprovedStructuredToolCall(requestStructuredHistory, requestedApprovedToolCalls, requestedApprovedToolCallAskIds);
+        if (approvedToolCallLookup.status === "ambiguous") {
+            setResponseStatus(event, 422);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_history_ambiguous",
+                retryable: false,
+            };
+        }
+        const exactApprovedToolCall = approvedToolCallLookup.status === "found"
+            ? approvedToolCallLookup.toolCall
+            : undefined;
+        if (requestedApprovedToolCalls?.length && !exactApprovedToolCall) {
+            setResponseStatus(event, 422);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_history_missing",
+                retryable: false,
+            };
+        }
+        if (exactApprovedToolCall &&
+            isUnavailableToolCallInput(exactApprovedToolCall.input)) {
+            setResponseStatus(event, 422);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_input_unavailable",
+                retryable: false,
+            };
+        }
+        if (dispatchToBackground && exactApprovedToolCall) {
+            if (approvedInputRequiresForeground(exactApprovedToolCall.input)) {
+                // The dispatch payload must not persist raw bytes; execute while this request still has them.
+                dispatchToBackground = false;
+            }
+        }
+        const approvedToolCallsForExecution = exactApprovedToolCall
+            ? [
+                toolCallCacheKey(exactApprovedToolCall.name, exactApprovedToolCall.input),
+            ]
+            : requestedApprovedToolCalls;
+        const resolvedApprovalTurnId = ownerEmail && threadId && approvedToolCallsForExecution?.length
             ? await resolveAgentToolApprovalTurnId({
                 ownerEmail,
                 orgId: getRequestOrgId() ?? null,
                 threadId,
                 requestedTurnId: requestTurnId,
-                approvalKeys: requestedApprovedToolCalls,
+                approvalKeys: approvedToolCallsForExecution,
+                ...(requestedApprovedToolCallAskIds
+                    ? { approvalId: requestedApprovedToolCallAskIds[0] }
+                    : {}),
             })
             : null;
+        if (requestedApprovedToolCallAskIds?.length && !resolvedApprovalTurnId) {
+            setResponseStatus(event, 409);
+            return {
+                error: "The agent run failed.",
+                code: "approved_tool_call_not_pending",
+                retryable: false,
+            };
+        }
         // The continuation marker is client-controlled. Defer setup admission only
         // for automatic successors when the named stop and turn can be checked
         // under the run-slot lock. A user's manual Continue starts new work and
@@ -8836,7 +9020,6 @@ export function createProductionAgentHandler(options) {
         // may truncate tool arguments and intentionally assigns fresh replay ids.
         // The loop still consumes only a matching server-created grant for the
         // current owner/org/thread/turn/tool/input tuple.
-        const exactApprovedToolCall = findApprovedStructuredToolCall(requestStructuredHistory, requestedApprovedToolCalls);
         const firstRequestPayloadDetail = buildFirstRequestPayloadDetail({
             isFirstRequest: requestHistory.length === 0,
             systemPrompt: requestSystemPrompt,
@@ -8851,7 +9034,7 @@ export function createProductionAgentHandler(options) {
         const isClientTurnContinuation = !isBackgroundWorker &&
             internalContinuation === true &&
             !continueOf &&
-            !requestedApprovedToolCalls?.length &&
+            !approvedToolCallsForExecution?.length &&
             typeof message === "string" &&
             message.startsWith(AGENT_INTERNAL_CONTINUE_PROMPT) &&
             typeof threadId === "string" &&
@@ -8921,7 +9104,7 @@ export function createProductionAgentHandler(options) {
                     ...(turnInitiator ? { turnInitiator } : {}),
                     replayCompletedTurn: typeof requestTurnId === "string" &&
                         Boolean(requestTurnId.trim()) &&
-                        !requestedApprovedToolCalls,
+                        !approvedToolCallsForExecution,
                     dispatchMode: dispatchToBackground
                         ? "background"
                         : foregroundSelfChainEligible
@@ -8982,6 +9165,7 @@ export function createProductionAgentHandler(options) {
                 toolName: binding.toolName,
                 callId: binding.callId,
                 approvalKey: binding.approvalKey,
+                ...(binding.approvalId ? { approvalId: binding.approvalId } : {}),
             };
         };
         const approvalHooks = {
@@ -9003,7 +9187,6 @@ export function createProductionAgentHandler(options) {
                 });
             },
         };
-        const approvedToolCallsForExecution = requestedApprovedToolCalls;
         if (isBackgroundWorker &&
             (await isTurnAborted(effectiveThreadId, effectiveTurnId))) {
             await markRunAborted(runId, "user").catch(() => { });
@@ -9779,6 +9962,11 @@ export function createProductionAgentHandler(options) {
                 ...(approvedToolCallsForExecution
                     ? { approvedToolCalls: approvedToolCallsForExecution }
                     : {}),
+                ...(requestedApprovedToolCallAskIds
+                    ? {
+                        approvedToolCallAskId: requestedApprovedToolCallAskIds[0],
+                    }
+                    : {}),
                 onApprovalRequired: approvalHooks.onApprovalRequired,
                 consumeApproval: approvalHooks.consumeApproval,
                 isToolAlwaysAllowed: approvalHooks.isToolAlwaysAllowed,
@@ -9816,6 +10004,11 @@ export function createProductionAgentHandler(options) {
                         threadId: effectiveThreadId,
                         turnId: effectiveTurnId,
                         approvedToolCalls: approvedToolCallsForExecution,
+                        ...(requestedApprovedToolCallAskIds
+                            ? {
+                                approvedToolCallAskId: requestedApprovedToolCallAskIds[0],
+                            }
+                            : {}),
                         onApprovalRequired: approvalHooks.onApprovalRequired,
                         consumeApproval: approvalHooks.consumeApproval,
                         isToolAlwaysAllowed: approvalHooks.isToolAlwaysAllowed,