@agent-native/core 0.149.0 → 0.149.2

package/dist/agent/production-agent.js

@@ -39,6 +39,7 @@ import { ProcessorChain, TripWire, toolCallsFromContent, } from "./processors.js
 import { startRun, subscribeToRun, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortTurnDurably, tryClaimRunSlot, isHostedRuntime, resolveRunSoftTimeoutMs, resolveRunToolTimeoutCeilingMs, } from "./run-manager.js";
 import { writeLedgerEntry, readLedgerEntry, clearLedgerForThread, insertRun, insertRunEvent, isTurnAborted, markRunAborted, updateRunHeartbeat, updateRunStatusIfRunning, setRunError, setRunTerminalReason, claimBackgroundRun, readBackgroundRunClaim, recordRunDiagnostic, countRunsForTurn, RUN_DIAG_STAGE, UNCLAIMED_BACKGROUND_RUN_GRACE_MS, } from "./run-store.js";
 import { buildCurrentTimeUserContext } from "./runtime-context.js";
+import { consumeAgentToolApproval, createAgentToolApproval, } from "./tool-approval-store.js";
 import { findCompletedJournalEntry, } from "./tool-call-journal.js";
 import { redactSensitiveFields, sanitizeToolErrorText, sanitizeToolErrorValue, } from "./tool-error-redaction.js";
 import { describeToolResultImages, extractAgentImagesFromActionResult, } from "./tool-result-images.js";
@@ -688,7 +689,7 @@ const VISIBLE_RETRY_THRESHOLD_MS = 10_000;
  */
 const FOREGROUND_FIRST_MODEL_EVENT_TIMEOUT_MS = 25_000;
 // Raised from 1 -> 2 now that each retry actually adapts (raises the token
-// ceiling and steps reasoning effort down a tier) instead of re-issuing the
+// ceiling and steps effort down a tier) instead of re-issuing the
 // exact same doomed request twice.
 const EMPTY_FINAL_RESPONSE_RETRY_LIMIT = 2;
 const MAIN_CHAT_INTERNAL_CONTINUATION_LIMIT = 6;
@@ -2120,6 +2121,8 @@ export async function executeAgentToolCall(options) {
             threadId: options.threadId,
             turnId: options.turnId,
             approvedToolCalls: options.approvedToolCalls,
+            onApprovalRequired: options.onApprovalRequired,
+            consumeApproval: options.consumeApproval,
         });
     }
     catch (error) {
@@ -2307,6 +2310,51 @@ function stableStringify(value) {
 export function toolCallCacheKey(toolName, input) {
     return `${toolName}:${stableStringify(normalizeToolCallInputForHistory(input))}`;
 }
+export function findApprovedStructuredToolCall(history, approvedToolCalls) {
+    if (!Array.isArray(history) || !approvedToolCalls?.length)
+        return undefined;
+    const approved = new Set(approvedToolCalls);
+    const calls = new Map();
+    let match;
+    for (const message of history) {
+        if (message.role === "assistant") {
+            for (const part of message.content) {
+                if (part.type !== "tool-call")
+                    continue;
+                const callId = typeof part.id === "string"
+                    ? part.id
+                    : typeof part.toolCallId === "string"
+                        ? part.toolCallId
+                        : "";
+                const name = typeof part.name === "string"
+                    ? part.name
+                    : typeof part.toolName === "string"
+                        ? part.toolName
+                        : "";
+                if (!callId || !name)
+                    continue;
+                calls.set(callId, { name, input: part.input ?? part.args ?? {} });
+            }
+            continue;
+        }
+        for (const part of message.content) {
+            if (part.type !== "tool-result")
+                continue;
+            const call = calls.get(part.toolCallId);
+            if (!call || !approved.has(toolCallCacheKey(call.name, call.input))) {
+                continue;
+            }
+            const result = part.content.toLowerCase();
+            if (!result.includes("did not execute") &&
+                !result.includes("awaiting human approval") &&
+                !result.includes("waiting for your approval")) {
+                continue;
+            }
+            match = { ...call, callId: part.toolCallId };
+        }
+    }
+    return match;
+}
 const INTERRUPTED_TOOL_LEDGER_POLL_MS = process.env.NODE_ENV === "test" ? 0 : 2_000;
 async function waitForInterruptedToolLedgerEntry(opts) {
     const pollMs = INTERRUPTED_TOOL_LEDGER_POLL_MS;
@@ -3965,7 +4013,16 @@ export async function runAgentLoop(opts) {
             const approvalKey = toolCallCacheKey(toolCall.name, toolCall.input);
             // Consume a grant on its first exact match. A second identical call in
             // the same continuation must request its own human approval.
-            const wasApproved = approvedToolCallKeys.delete(approvalKey);
+            const approvalBinding = {
+                toolName: toolCall.name,
+                input: toolCall.input,
+                callId: toolCall.id,
+                approvalKey,
+            };
+            const requestedApproval = approvedToolCallKeys.delete(approvalKey);
+            const wasApproved = requestedApproval && opts.consumeApproval
+                ? await opts.consumeApproval(approvalBinding)
+                : requestedApproval;
             if (actionEntry.needsApproval && !wasApproved) {
                 let mustApprove = false;
                 try {
@@ -3989,6 +4046,7 @@ export async function runAgentLoop(opts) {
                     mustApprove = true;
                 }
                 if (mustApprove) {
+                    await opts.onApprovalRequired?.(approvalBinding);
                     send({
                         type: "tool_start",
                         id: toolCall.id,
@@ -6433,6 +6491,12 @@ export function createProductionAgentHandler(options) {
             ...historyMessages,
             { role: "user", content: userContent },
         ];
+        const requestedApprovedToolCalls = Array.isArray(body.approvedToolCalls) && body.approvedToolCalls.length > 0
+            ? body.approvedToolCalls
+                .filter((key) => typeof key === "string")
+                .slice(0, 200)
+            : undefined;
+        const exactApprovedToolCall = findApprovedStructuredToolCall(structuredHistory, requestedApprovedToolCalls);
         const firstRequestPayloadDetail = buildFirstRequestPayloadDetail({
             isFirstRequest: history.length === 0,
             systemPrompt: requestSystemPrompt,
@@ -6486,6 +6550,38 @@ export function createProductionAgentHandler(options) {
             : typeof requestTurnId === "string" && requestTurnId.trim()
                 ? requestTurnId.trim()
                 : runId;
+        const approvalStoreBinding = (binding) => {
+            if (!ownerEmail) {
+                throw new Error("Cannot create or consume an approval without an authenticated owner");
+            }
+            return {
+                ownerEmail,
+                orgId: getRequestOrgId() ?? null,
+                threadId: effectiveThreadId,
+                turnId: effectiveTurnId,
+                toolName: binding.toolName,
+                callId: binding.callId,
+                approvalKey: binding.approvalKey,
+            };
+        };
+        const approvalHooks = {
+            onApprovalRequired: async (binding) => {
+                await createAgentToolApproval(approvalStoreBinding(binding));
+            },
+            consumeApproval: async (binding) => {
+                if (!ownerEmail)
+                    return false;
+                return consumeAgentToolApproval(approvalStoreBinding(binding));
+            },
+        };
+        const exactApprovedToolEntry = exactApprovedToolCall
+            ? requestActions[exactApprovedToolCall.name]
+            : undefined;
+        const approvedToolCallsForExecution = exactApprovedToolCall && exactApprovedToolEntry?.needsApproval
+            ? [
+                toolCallCacheKey(exactApprovedToolCall.name, exactApprovedToolCall.input),
+            ]
+            : undefined;
         if (isBackgroundWorker &&
             (await isTurnAborted(effectiveThreadId, effectiveTurnId))) {
             await markRunAborted(runId, "user").catch(() => { });
@@ -7236,15 +7332,13 @@ export function createProductionAgentHandler(options) {
                     ? { threadId: effectiveThreadId, turnId: effectiveTurnId }
                     : {}),
                 // Human-in-the-loop approval grants for this turn (sanitized — the
-                // request is untrusted; accept only a bounded list of string keys).
-                ...(Array.isArray(body.approvedToolCalls) &&
-                    body.approvedToolCalls.length
-                    ? {
-                        approvedToolCalls: body.approvedToolCalls
-                            .filter((k) => typeof k === "string")
-                            .slice(0, 200),
-                    }
+                // request is untrusted; only the exact structured call is passed to
+                // the loop, where the durable grant is consumed atomically.
+                ...(approvedToolCallsForExecution
+                    ? { approvedToolCalls: approvedToolCallsForExecution }
                     : {}),
+                onApprovalRequired: approvalHooks.onApprovalRequired,
+                consumeApproval: approvalHooks.consumeApproval,
                 // A worker PROVEN to be running inside the real 15-min Netlify
                 // `-background` function (`runsInBackgroundFunction`) has minutes of
                 // budget left on THIS invocation. Let it catch a recoverable
@@ -7269,6 +7363,31 @@ export function createProductionAgentHandler(options) {
             send({ type: "activity", label: "Contacting model" });
             let instrumented = false;
             try {
+                if (exactApprovedToolCall &&
+                    approvedToolCallsForExecution &&
+                    requestActions[exactApprovedToolCall.name]) {
+                    send({
+                        type: "activity",
+                        label: `Running approved ${exactApprovedToolCall.name} action`,
+                        tool: exactApprovedToolCall.name,
+                    });
+                    await executeAgentToolCall({
+                        actions: requestActions,
+                        name: exactApprovedToolCall.name,
+                        input: exactApprovedToolCall.input,
+                        callId: exactApprovedToolCall.callId,
+                        signal: agentLoopOpts.signal,
+                        ownerEmail,
+                        orgId: getRequestOrgId() ?? null,
+                        threadId: effectiveThreadId,
+                        turnId: effectiveTurnId,
+                        approvedToolCalls: approvedToolCallsForExecution,
+                        onApprovalRequired: approvalHooks.onApprovalRequired,
+                        consumeApproval: approvalHooks.consumeApproval,
+                        send,
+                    });
+                    return;
+                }
                 try {
                     const { getObservabilityConfig, instrumentAgentLoop } = await import("../observability/traces.js");
                     const obsConfig = await getObservabilityConfig();

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

@@ -0,0 +1,18 @@
+export interface AgentToolApprovalBinding {
+    ownerEmail: string;
+    orgId?: string | null;
+    threadId?: string | null;
+    turnId?: string | null;
+    toolName: string;
+    callId: string;
+    approvalKey: string;
+    expiresAt?: number;
+}
+export declare function hashAgentToolApprovalKey(approvalKey: string): string;
+export declare function createAgentToolApproval(binding: AgentToolApprovalBinding): Promise<void>;
+/**
+ * Atomically consume the server-created approval for one exact tool call.
+ * Client history and approval keys are only lookup input; the pending row is
+ * the authorization boundary and cannot be manufactured by the client.
+ */
+export declare function consumeAgentToolApproval(binding: AgentToolApprovalBinding): Promise<boolean>;

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

@@ -0,0 +1,122 @@
+import { createHash, randomUUID } from "node:crypto";
+import { getDbExec, intType, isPostgres, retryOnDdlRace, } from "../db/client.js";
+import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
+const APPROVAL_TTL_MS = 15 * 60_000;
+const APPROVAL_CLEANUP_AGE_MS = 24 * 60 * 60_000;
+let initPromise;
+async function ensureAgentToolApprovalTable() {
+    if (!initPromise) {
+        initPromise = (async () => {
+            const createSql = `CREATE TABLE IF NOT EXISTS agent_tool_approvals (
+  id TEXT PRIMARY KEY,
+  owner_email TEXT NOT NULL,
+  org_id TEXT,
+  thread_id TEXT,
+  turn_id TEXT,
+  tool_name TEXT NOT NULL,
+  call_id TEXT NOT NULL,
+  approval_key_hash TEXT NOT NULL,
+  status TEXT NOT NULL,
+  expires_at ${intType()} NOT NULL,
+  consumed_at ${intType()},
+  created_at ${intType()} NOT NULL,
+  updated_at ${intType()} NOT NULL
+)`;
+            const indexSql = `CREATE INDEX IF NOT EXISTS idx_agent_tool_approvals_binding
+        ON agent_tool_approvals(owner_email, org_id, thread_id, tool_name, call_id, status)`;
+            if (isPostgres()) {
+                await ensureTableExists("agent_tool_approvals", createSql);
+                await ensureIndexExists("idx_agent_tool_approvals_binding", indexSql);
+                return;
+            }
+            const client = getDbExec();
+            await retryOnDdlRace(() => client.execute(createSql));
+            await retryOnDdlRace(() => client.execute(indexSql));
+        })().catch((error) => {
+            initPromise = undefined;
+            throw error;
+        });
+    }
+    return initPromise;
+}
+export function hashAgentToolApprovalKey(approvalKey) {
+    return createHash("sha256").update(approvalKey).digest("hex");
+}
+export async function createAgentToolApproval(binding) {
+    await ensureAgentToolApprovalTable();
+    const now = Date.now();
+    const expiresAt = binding.expiresAt ?? now + APPROVAL_TTL_MS;
+    await getDbExec().execute({
+        sql: `INSERT INTO agent_tool_approvals
+      (id, owner_email, org_id, thread_id, turn_id, tool_name, call_id,
+       approval_key_hash, status, expires_at, consumed_at, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, NULL, ?, ?)`,
+        args: [
+            `agent-tool-approval-${randomUUID()}`,
+            binding.ownerEmail,
+            binding.orgId ?? null,
+            binding.threadId ?? null,
+            binding.turnId ?? null,
+            binding.toolName,
+            binding.callId,
+            hashAgentToolApprovalKey(binding.approvalKey),
+            expiresAt,
+            now,
+            now,
+        ],
+    });
+    // Cleanup is hygiene only. Expired rows remain unusable because consume uses
+    // an atomic status and expiry predicate, so cleanup failures must not affect
+    // the approval that was just recorded.
+    try {
+        await getDbExec().execute({
+            sql: `DELETE FROM agent_tool_approvals
+        WHERE expires_at < ? AND status <> 'pending'`,
+            args: [now - APPROVAL_CLEANUP_AGE_MS],
+        });
+    }
+    catch (error) {
+        console.warn("[agent] Could not clean expired tool approval records", error);
+    }
+}
+/**
+ * Atomically consume the server-created approval for one exact tool call.
+ * Client history and approval keys are only lookup input; the pending row is
+ * the authorization boundary and cannot be manufactured by the client.
+ */
+export async function consumeAgentToolApproval(binding) {
+    await ensureAgentToolApprovalTable();
+    const now = Date.now();
+    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
+        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 tool_name = ?
+          AND call_id = ?
+          AND approval_key_hash = ?
+          AND status = 'pending'
+          AND expires_at > ?
+        ORDER BY created_at DESC
+        LIMIT 1
+      )
+      AND status = 'pending'`,
+        args: [
+            now,
+            now,
+            binding.ownerEmail,
+            binding.orgId ?? null,
+            binding.orgId ?? null,
+            binding.threadId ?? null,
+            binding.threadId ?? null,
+            binding.toolName,
+            binding.callId,
+            hashAgentToolApprovalKey(binding.approvalKey),
+            now,
+        ],
+    });
+    return result.rowsAffected === 1;
+}

package/dist/agent/types.d.ts

@@ -189,7 +189,7 @@ export interface AgentChatRequest {
     model?: string;
     /** Per-request engine override (sent alongside model for cross-provider switches). */
     engine?: string;
-    /** Per-request reasoning effort override (ephemeral, from the composer picker). */
+    /** Per-request effort override (ephemeral, from the composer picker). */
     effort?: ReasoningEffort;
     /** Usage-tracking label for this call (e.g. "chat", "summarize"). Default: "chat". */
     usageLabel?: string;

package/dist/cli/code-agent-executor.js

@@ -471,7 +471,14 @@ async function executeClaudeCliRun(options) {
     });
     try {
         const result = await runClaudeCodeParticipant({
-            role: options.permissionMode === "full-auto" ? "driver" : "watchdog",
+            // Claude's driver uses acceptEdits, which is the closest available
+            // mapping for auto-edit and full-auto. Keep ask-before-edit on the
+            // read-only watchdog path because this non-interactive runner has no
+            // approval channel to honor an edit prompt safely.
+            role: options.permissionMode === "auto-edit" ||
+                options.permissionMode === "full-auto"
+                ? "driver"
+                : "watchdog",
             prompt: buildClaudeCliPrompt(options.run, options.prompt),
             cwd,
             model,
@@ -604,7 +611,9 @@ async function executeClaudeCliRun(options) {
 }
 function buildClaudeCliPrompt(run, prompt) {
     const permissionMode = run.permissionMode ?? "full-auto";
-    const mode = permissionMode === "full-auto" ? "Auto" : "Plan";
+    const mode = permissionMode === "auto-edit" || permissionMode === "full-auto"
+        ? "Auto"
+        : "Plan";
     const modeInstruction = mode === "Plan"
         ? "Inspect and explain only. Do not edit files or run mutating commands."
         : "Edit and verify as needed. Do not create, switch, reset, rebase, or stash git branches.";

package/dist/client/AgentPanel.js

@@ -24,6 +24,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { Tooltip as DesignSystemTooltip } from "@agent-native/toolkit/design-system";
 import { IconMessageCircle, IconMessageDots, IconTerminal2, IconSettings, IconLayoutSidebarRightCollapse, IconLayoutGrid, IconCheck, IconPlus, IconX, IconDotsVertical, IconHistory, IconArrowsHorizontal, IconArrowsMaximize, IconExternalLink, } from "@tabler/icons-react";
 import React, { useState, useEffect, useRef, useCallback, useMemo, lazy, Suspense, startTransition, } from "react";
+import { flushSync } from "react-dom";
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuTrigger, } from "./components/ui/dropdown-menu.js";
 import { normalizeTooltipText } from "./components/ui/tooltip.js";
 import { ErrorReportActions } from "./ErrorReportActions.js";
@@ -1700,6 +1701,26 @@ export function AgentSidebar({ children, emptyStateText = "How can I help you?",
             return next;
         });
     }, []);
+    // `view-transition-name` is only legal to carry while a transition is
+    // actually capturing. Left on permanently it makes the panel its own
+    // stacking context and the containing block for every fixed/absolute
+    // descendant, and enlists it as a captured group in unrelated transitions
+    // (any React Router `viewTransition` navigation), which is how overlays end
+    // up painted at stale offsets. Apply it only around the drawer morph, and
+    // flush it into the DOM first: `startViewTransition` captures the old state
+    // before it invokes the callback, so a name applied in a normal React commit
+    // would land too late to be captured.
+    const [drawerMorphing, setDrawerMorphing] = useState(false);
+    const runDrawerMorph = useCallback((apply) => {
+        flushSync(() => setDrawerMorphing(true));
+        const settle = () => setDrawerMorphing(false);
+        const transition = startAgentChatViewTransition(apply);
+        if (!transition) {
+            settle();
+            return;
+        }
+        transition.finished.then(settle, settle);
+    }, []);
     const snapTo75Percent = useCallback(() => {
         if (drawerExitTimerRef.current !== null) {
             clearTimeout(drawerExitTimerRef.current);
@@ -1719,8 +1740,8 @@ export function AgentSidebar({ children, emptyStateText = "How can I help you?",
             }
             catch { }
         };
-        startAgentChatViewTransition(apply);
-    }, [drawerPlaceholderWidth, isWideDrawer, width]);
+        runDrawerMorph(apply);
+    }, [runDrawerMorph, drawerPlaceholderWidth, isWideDrawer, width]);
     const exitWideDrawer = useCallback(() => {
         if (!isWideDrawer || drawerExitTimerRef.current !== null)
             return;
@@ -1738,8 +1759,8 @@ export function AgentSidebar({ children, emptyStateText = "How can I help you?",
                 setIsWideDrawer(false);
             }, SIDEBAR_ANIMATION_MS + 32);
         };
-        startAgentChatViewTransition(apply);
-    }, [drawerPlaceholderWidth, isWideDrawer]);
+        runDrawerMorph(apply);
+    }, [runDrawerMorph, drawerPlaceholderWidth, isWideDrawer]);
     const handleResizeStart = useCallback(() => setIsResizing(true), []);
     const handleResizeEnd = useCallback(() => setIsResizing(false), []);
     const isLeft = position === "left";
@@ -1820,7 +1841,9 @@ export function AgentSidebar({ children, emptyStateText = "How can I help you?",
             borderLeft: isLeft ? "none" : "1px solid hsl(var(--border))",
             borderRight: isLeft ? "1px solid hsl(var(--border))" : "none",
             display: "flex",
-            viewTransitionName: SIDEBAR_DRAWER_VIEW_TRANSITION_NAME,
+            ...(drawerMorphing
+                ? { viewTransitionName: SIDEBAR_DRAWER_VIEW_TRANSITION_NAME }
+                : null),
         };
     }
     else {
@@ -1841,7 +1864,9 @@ export function AgentSidebar({ children, emptyStateText = "How can I help you?",
             display: desktopAnimationEnabled || panelOpen ? "flex" : "none",
             minWidth: desktopAnimationEnabled ? 0 : undefined,
             pointerEvents: desktopAnimationEnabled && !panelOpen ? "none" : undefined,
-            viewTransitionName: SIDEBAR_DRAWER_VIEW_TRANSITION_NAME,
+            ...(drawerMorphing
+                ? { viewTransitionName: SIDEBAR_DRAWER_VIEW_TRANSITION_NAME }
+                : null),
         };
     }
     // Mount the live chat surface only while visible or actively needed. Keeping

package/dist/client/AssistantChat.d.ts

@@ -136,6 +136,7 @@ type QueuedMessage = {
     recoveryAction?: AgentRecoveryAction;
     trackInRunsTray?: boolean;
     hideUserMessage?: boolean;
+    approvedToolCalls?: string[];
     /**
      * Model/engine/effort snapshotted at enqueue time, for the same reason
      * `requestMode` is: the picker is global and live, so a queue that flushes
@@ -306,7 +307,7 @@ export interface AssistantChatProps {
     defaultModel?: string;
     /** Selected engine override for this conversation */
     selectedEngine?: string;
-    /** Selected reasoning effort override for this conversation */
+    /** Selected effort override for this conversation */
     selectedEffort?: ReasoningEffort;
     /** Available engine/model list for the model picker */
     availableModels?: Array<{
@@ -319,7 +320,7 @@ export interface AssistantChatProps {
     modelListLoading?: boolean;
     /** Callback when user picks a model from the picker */
     onModelChange?: (model: string, engine: string) => void;
-    /** Callback when user picks a reasoning effort from the picker */
+    /** Callback when user picks an effort from the picker */
     onEffortChange?: (effort: ReasoningEffort) => void;
     /**
      * Optional secondary model menu (e.g. an image-generation model) shown inside

package/dist/client/AssistantChat.js

@@ -3102,7 +3102,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                         ...(messageAttachments.length > 0
                             ? { attachments: messageAttachments }
                             : {}),
-                        ...createUserMessageRunConfig(next.references, next.requestMode, next.recoveryAction, next.trackInRunsTray, undefined, next.id, next.hideUserMessage, {
+                        ...createUserMessageRunConfig(next.references, next.requestMode, next.recoveryAction, next.trackInRunsTray, next.approvedToolCalls, next.id, next.hideUserMessage, {
                             model: next.model,
                             engine: next.engine,
                             effort: next.effort,
@@ -3433,7 +3433,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
         stopActiveRunRef.current({ preserveQueuedMessages: true });
     }, [applyLocalQueuedMessages]);
     const visibleQueuedMessages = useMemo(() => queuedMessages.filter((message) => !message.hideUserMessage), [queuedMessages]);
-    const addToQueue = useCallback(async (text, images, references, attachments, requestMode, intent = "queued", recoveryAction, includeComposerContext = false, trackInRunsTray = false, preserveReconnectAutoRecoveryBudget = false, hideUserMessage = false, submitMessageId) => {
+    const addToQueue = useCallback(async (text, images, references, attachments, requestMode, intent = "queued", recoveryAction, includeComposerContext = false, trackInRunsTray = false, preserveReconnectAutoRecoveryBudget = false, hideUserMessage = false, submitMessageId, approvedToolCalls) => {
         if (isAgentChatSubmitCancelled(submitMessageId))
             return;
         if (engineSetupRequired) {
@@ -3582,6 +3582,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                     recoveryAction,
                     trackInRunsTray,
                     hideUserMessage,
+                    approvedToolCalls,
                     ...modelSnapshot,
                 },
             ]);
@@ -3602,6 +3603,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                     recoveryAction,
                     trackInRunsTray,
                     hideUserMessage,
+                    approvedToolCalls,
                     ...modelSnapshot,
                 },
             ]);
@@ -3615,7 +3617,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                     ...(messageAttachments.length > 0
                         ? { attachments: messageAttachments }
                         : {}),
-                    ...createUserMessageRunConfig(references, effectiveRequestMode, recoveryAction, trackInRunsTray, undefined, undefined, hideUserMessage),
+                    ...createUserMessageRunConfig(references, effectiveRequestMode, recoveryAction, trackInRunsTray, approvedToolCalls, undefined, hideUserMessage),
                 });
             }
             catch (error) {
@@ -4006,31 +4008,16 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
         getApprovalResolution,
         onApprovalResolved: recordApprovalResolution,
         onApprove: (approvalKey) => {
-            markOptimisticRunning();
-            appendThreadMessage({
-                role: "user",
-                content: [
-                    {
-                        type: "text",
-                        text: "Approved. Go ahead and run the requested action.",
-                    },
-                ],
-                ...createUserMessageRunConfig(undefined, execMode === "plan"
-                    ? "plan"
-                    : execMode === "build"
-                        ? "act"
-                        : undefined, undefined, undefined, [approvalKey]),
-            });
+            void addToQueue("Approved. Go ahead and run the requested action.", undefined, undefined, undefined, undefined, "queued", undefined, false, false, false, false, undefined, [approvalKey]);
         },
         ...(approvalActions?.onDeny ? { onDeny: approvalActions.onDeny } : {}),
         ...(approvalActions?.onAlwaysAllow
             ? { onAlwaysAllow: approvalActions.onAlwaysAllow }
             : {}),
     }), [
-        appendThreadMessage,
+        addToQueue,
         execMode,
         getApprovalResolution,
-        markOptimisticRunning,
         approvalActions,
         recordApprovalResolution,
     ]);

package/dist/client/agent-chat/index.d.ts

@@ -39,4 +39,4 @@ export { AGENT_SIDEBAR_DEFAULT_MAX_WIDTH, AGENT_SIDEBAR_MIN_WIDTH, AGENT_SIDEBAR
 export { clearReservedToolRenderersForTests, clearToolRenderersForTests, registerActionChatRenderer, registerFallbackToolRenderer, registerReservedActionChatRenderer, registerReservedFallbackToolRenderer, registerReservedToolRenderer, registerToolRenderer, resolveToolRenderer, type ActionChatRendererRegistration, type ToolRendererComponent, type ToolRendererContext, type ToolRendererMatch, type ToolRendererProps, type ToolRendererRegistration, } from "../chat/tool-render-registry.js";
 export * from "../chat/connectors.js";
 export * from "../chat/runtime.js";
-export { CHAT_FIRST_APP_LAYOUT_STORAGE_KEY, CHAT_FIRST_DEFAULT_APP_IDS, CHAT_FIRST_SURFACE_TABS_STORAGE_KEY, CHAT_FIRST_SURFACE_PANEL_STORAGE_KEY, CHAT_FIRST_SURFACE_WIDTH_DEFAULT, CHAT_FIRST_SURFACE_WIDTH_MIN, clampChatFirstSurfaceWidth, CHAT_FIRST_MODE_STORAGE_KEY, CHAT_FIRST_MODE_CHANGED_EVENT, CHAT_FIRST_OPEN_APP_EVENT, CHAT_FIRST_OPEN_BROWSER_EVENT, CHAT_FIRST_WATCH_SESSION_EVENT, CHAT_FIRST_SURFACE_CATALOG, chatFirstSurfaceTabId, closeChatFirstSessionWatch, emitChatFirstOpenApp, emitChatFirstOpenBrowser, emitChatFirstSessionWatch, getChatFirstSessionWatchStore, getChatFirstSurfaceTabsStore, getChatFirstSurfacePanelStore, orderChatFirstAppIds, readChatFirstAppLayout, resolveChatFirstAppTarget, resolveChatFirstBrowserTarget, resolveChatFirstSessionId, normalizeChatFirstSessionReference, readChatFirstMode, readChatFirstModeState, readChatFirstSurfaceWidth, subscribeChatFirstOpenApp, subscribeChatFirstOpenBrowser, subscribeChatFirstSessionWatch, useChatFirstSessionWatch, useChatFirstSurfaceResize, useChatFirstSurfacePanel, useChatFirstSurfaceTabs, writeChatFirstAppLayout, writeChatFirstMode, writeChatFirstSurfaceWidth, type ChatFirstAppLayoutPreference, type ChatFirstModeReadResult, type ChatFirstAppRegistration, type ChatFirstAppResolution, type ChatFirstAppTarget, type ChatFirstAgentActivity, type ChatFirstAgentActivityStatus, type ChatFirstOpenAppDelivery, type ChatFirstOpenAppDetail, type ChatFirstOpenBrowserDetail, type ChatFirstBrowserResolution, type ChatFirstSessionKind, type ChatFirstSessionReference, type ChatFirstSessionWatchDelivery, type ChatFirstSessionWatchState, type ChatFirstSessionWatchStore, type ChatFirstSurfaceKind, type ChatFirstSurfaceTab, type ChatFirstSurfacePanelState, type ChatFirstSurfacePanelStore, type ChatFirstSurfaceTabsState, type ChatFirstSurfaceTabsStore, } from "../chat-first.js";
+export { CHAT_FIRST_APP_LAYOUT_STORAGE_KEY, CHAT_FIRST_DEFAULT_APP_IDS, CHAT_FIRST_SURFACE_TABS_STORAGE_KEY, CHAT_FIRST_SURFACE_PANEL_STORAGE_KEY, CHAT_FIRST_SURFACE_WIDTH_DEFAULT, CHAT_FIRST_SURFACE_WIDTH_MIN, clampChatFirstSurfaceWidth, CHAT_FIRST_MODE_STORAGE_KEY, CHAT_FIRST_MODE_CHANGED_EVENT, CHAT_FIRST_OPEN_APP_EVENT, CHAT_FIRST_OPEN_BROWSER_EVENT, CHAT_FIRST_WATCH_SESSION_EVENT, CHAT_FIRST_SURFACE_CATALOG, chatFirstSurfaceTabId, closeChatFirstSessionWatch, emitChatFirstOpenApp, emitChatFirstOpenBrowser, emitChatFirstSessionWatch, getChatFirstSessionWatchStore, getChatFirstSurfaceTabsStore, getChatFirstSurfacePanelStore, orderChatFirstAppIds, readChatFirstAppLayout, resolveChatFirstAppTarget, resolveChatFirstBrowserTarget, resolveChatFirstSessionId, normalizeChatFirstSessionReference, readChatFirstMode, readChatFirstModeState, readChatFirstSurfaceWidth, subscribeChatFirstOpenApp, subscribeChatFirstOpenBrowser, subscribeChatFirstSessionWatch, useChatFirstSessionWatch, useChatFirstSurfaceResize, useChatFirstSurfacePanel, useChatFirstSurfaceTabs, writeChatFirstAppLayout, writeChatFirstMode, writeChatFirstSurfaceWidth, type ChatFirstAppLayoutPreference, type ChatFirstModeReadResult, type ChatFirstAppRegistration, type ChatFirstAppResolution, type ChatFirstAppTarget, type ChatFirstAppSurfacePlacement, type ChatFirstAgentActivity, type ChatFirstAgentActivityStatus, type ChatFirstOpenAppDelivery, type ChatFirstOpenAppDetail, type ChatFirstOpenBrowserDetail, type ChatFirstBrowserResolution, type ChatFirstSessionKind, type ChatFirstSessionReference, type ChatFirstSessionWatchDelivery, type ChatFirstSessionWatchState, type ChatFirstSessionWatchStore, type ChatFirstSurfaceKind, type ChatFirstSurfaceTab, type ChatFirstSurfacePanelState, type ChatFirstSurfacePanelStore, type ChatFirstSurfaceTabsState, type ChatFirstSurfaceTabsStore, } from "../chat-first.js";

package/dist/client/agent-chat-adapter.js

@@ -85,6 +85,16 @@ const LARGE_INPUT_TOOL_NAMES = new Set([
 ]);
 const MAX_HISTORY_LARGE_TOOL_ARGS_CHARS = 200_000;
 const STARTUP_RESPONSE_TIMEOUT_MS = 45_000;
+function dispatchTerminalChatUiCleanup(tabId) {
+    if (typeof window === "undefined")
+        return;
+    // Some terminal outcomes are synthesized by the adapter after recovery
+    // (for example, a completed tool whose final response timed out) and never
+    // pass through a terminal SSE frame. Clear both halves of the status UI so
+    // the wrap-up result cannot leave a preparation label or "Resuming" state.
+    window.dispatchEvent(new CustomEvent("agent-chat:activity-clear", { detail: { tabId } }));
+    window.dispatchEvent(new CustomEvent("agent-chat:stream-progress", { detail: { tabId } }));
+}
 // ── Background follow mode ──────────────────────────────────────────────────
 // For server-continued runs (dispatchMode starts with "background" or equals
 // "foreground-self-chain") the SERVER normally chains continuation chunks
@@ -3526,6 +3536,7 @@ export function createAgentChatAdapter(options) {
             }
             finally {
                 if (typeof window !== "undefined") {
+                    dispatchTerminalChatUiCleanup(tabId);
                     window.dispatchEvent(new CustomEvent("agentNative.chatRunning", {
                         detail: { isRunning: false, tabId },
                     }));

package/dist/client/agent-chat.d.ts

@@ -42,7 +42,7 @@ export interface AgentChatMessage {
     model?: string;
     /** Engine preference paired with model for cross-provider switches. */
     engine?: string;
-    /** Reasoning effort preference paired with model. */
+    /** Effort preference paired with model. */
     effort?: ReasoningEffort;
     /**
      * Execution mode for this submitted turn. When omitted, sendToAgentChat

package/dist/client/chat/markdown-renderer.js

@@ -264,6 +264,8 @@ function rememberStreamingText(resetKey, targetText, visibleText) {
     if (oldestKey !== undefined)
         smoothStreamingTextCache.delete(oldestKey);
 }
+/** Stable placeholder so the grapheme ref stays `string[]` before it is seeded. */
+const EMPTY_GRAPHEMES = [];
 export function useSmoothStreamingText(targetText, streaming, resetKey) {
     const prefersReducedMotion = usePrefersReducedMotion();
     const [visibleText, setVisibleText] = useState(() => {
@@ -276,9 +278,19 @@ export function useSmoothStreamingText(targetText, streaming, resetKey) {
         return sliceGraphemes(targetText, graphemes, initialSmoothStreamingGraphemeCount(graphemes));
     });
     const visibleTextRef = useRef(visibleText);
-    const visibleCountRef = useRef(splitStreamingTextGraphemes(visibleText).length);
     const targetTextRef = useRef(targetText);
-    const targetGraphemesRef = useRef(splitStreamingTextGraphemes(targetText));
+    // `useRef(expr)` evaluates `expr` on EVERY render and throws it away after
+    // mount. Segmenting here therefore ran a full Intl.Segmenter pass per commit
+    // — up to 60Hz per streaming message — and, because `visibleText` is a strict
+    // prefix of `targetText`, that pass could never hit the incremental path and
+    // evicted the shared segmenter cache for every other live stream too. Seed
+    // once; the streaming effect below keeps both refs authoritative after that.
+    const visibleCountRef = useRef(-1);
+    const targetGraphemesRef = useRef(EMPTY_GRAPHEMES);
+    if (visibleCountRef.current < 0) {
+        targetGraphemesRef.current = splitStreamingTextGraphemes(targetText);
+        visibleCountRef.current = splitStreamingTextGraphemes(visibleText).length;
+    }
     const frameRef = useRef(null);
     const lastCommitAtRef = useRef(0);
     const pauseUntilRef = useRef(0);