@agent-native/core 0.149.1 → 0.149.3

package/dist/agent/run-manager.js

@@ -499,10 +499,24 @@ function abortInMemoryRun(run, reason = "user") {
         threadToRun.delete(run.threadId);
     }
     run.abort.abort(reason);
-    const terminalEvent = terminalEventForAbortReason(reason);
+    // Keep the abort terminal in the replay buffer as well as sending it to
+    // current subscribers. A reconnect can arrive after the live subscriber
+    // was removed but while this run is still warm in memory; closing that
+    // replay with no terminal frame makes the client manufacture a false
+    // frozen response and retry against a run that is already done.
+    const existingTerminalEvent = [...run.events]
+        .reverse()
+        .find((event) => isTerminalRunEvent(event.event));
+    const terminalRunEvent = existingTerminalEvent ?? {
+        seq: run.events.length,
+        event: terminalEventForAbortReason(reason),
+    };
+    if (!existingTerminalEvent) {
+        run.events.push(terminalRunEvent);
+    }
     for (const subscriber of run.subscribers) {
         try {
-            subscriber({ seq: run.events.length, event: terminalEvent });
+            subscriber(terminalRunEvent);
         }
         catch {
             // ignore — subscriber is being removed below
@@ -596,18 +610,116 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     // Throttle the durable progress timestamp to at most once per second so
     // a chatty token-by-token stream doesn't translate into one DB write per
     // chunk. The stuck-detector threshold is on the order of tens of seconds,
-    // so 1s resolution is plenty.
+    // so 1s resolution is plenty. Keep one write in flight and coalesce a
+    // trailing request: overlapping progress updates can exhaust a pooler and
+    // starve the heartbeat that is supposed to prove this run is alive.
+    const PROGRESS_BUMP_INTERVAL_MS = 1_000;
     let lastProgressBumpAt = 0;
+    let progressWriteInFlight = null;
+    let progressWriteTimer = null;
+    let progressWritePending = false;
+    let progressWriteAttempts = 0;
+    let progressWriteFailures = 0;
+    let consecutiveProgressWriteFailures = 0;
     const preparingActivityBytes = new Map();
     const preparingActivityTools = new Map();
     const preparingActivityRestartHighWater = new Map();
     let eventPersistenceErrorCaptured = false;
-    const bumpProgressIfDue = () => {
-        const now = Date.now();
-        if (now - lastProgressBumpAt < 1000)
+    const recordProgressWriteFailure = (error, kind) => {
+        progressWriteFailures += 1;
+        consecutiveProgressWriteFailures += 1;
+        // Keep every failure counted and retried, but sample the error capture so
+        // a database outage does not turn one long streamed input into hundreds of
+        // identical reports. The run id and event count make the sampled report
+        // useful for correlating the durable clock with the event ledger.
+        if (progressWriteFailures === 1 || progressWriteFailures % 10 === 0) {
+            const capturedError = error instanceof Error ? error : new Error(String(error));
+            console.error(`[run-manager] durable progress write ${kind} failed`, runId, {
+                attempts: progressWriteAttempts,
+                failures: progressWriteFailures,
+                consecutiveFailures: consecutiveProgressWriteFailures,
+                eventCount: run.events.length,
+            }, capturedError);
+            captureError(capturedError, {
+                route: "/_agent-native/agent-chat",
+                tags: {
+                    source: "agent-run-manager",
+                    phase: "progress",
+                    kind,
+                    consecutiveFailures: String(consecutiveProgressWriteFailures),
+                },
+                aiTraceId: runId,
+                extra: {
+                    runId,
+                    threadId,
+                    attempts: progressWriteAttempts,
+                    failures: progressWriteFailures,
+                    eventCount: run.events.length,
+                },
+            });
+        }
+    };
+    const writeProgress = async () => {
+        let updated = await bumpRunProgress(runId);
+        if (updated === false) {
+            // The initial run insert is intentionally asynchronous so the fast SSE
+            // path does not wait on SQL. If this first UPDATE wins the race, retry
+            // after that insert commits instead of permanently losing the first
+            // durable progress signal.
+            await insertRunPromise;
+            updated = await bumpRunProgress(runId);
+        }
+        if (updated === false) {
+            if (run.status !== "running")
+                return;
+            recordProgressWriteFailure(new Error("Durable progress update affected no running run row"), "no-row");
+            progressWritePending = true;
             return;
-        lastProgressBumpAt = now;
-        bumpRunProgress(runId).catch(() => { });
+        }
+        consecutiveProgressWriteFailures = 0;
+    };
+    function startProgressWrite() {
+        if (!progressWritePending ||
+            progressWriteInFlight ||
+            run.status !== "running") {
+            return;
+        }
+        progressWritePending = false;
+        lastProgressBumpAt = Date.now();
+        progressWriteAttempts += 1;
+        const write = writeProgress()
+            .catch((error) => {
+            recordProgressWriteFailure(error, "error");
+            // Retry even if no later event arrives. A transient failure must not
+            // freeze the durable clock until the next user-visible event.
+            progressWritePending = true;
+        })
+            .finally(() => {
+            progressWriteInFlight = null;
+            scheduleProgressWrite();
+        });
+        progressWriteInFlight = write;
+    }
+    function scheduleProgressWrite() {
+        if (!progressWritePending ||
+            progressWriteInFlight ||
+            progressWriteTimer ||
+            run.status !== "running") {
+            return;
+        }
+        const delayMs = Math.max(0, lastProgressBumpAt + PROGRESS_BUMP_INTERVAL_MS - Date.now());
+        if (delayMs === 0) {
+            startProgressWrite();
+            return;
+        }
+        progressWriteTimer = setTimeout(() => {
+            progressWriteTimer = null;
+            startProgressWrite();
+        }, delayMs);
+    }
+    const bumpProgressIfDue = () => {
+        progressWritePending = true;
+        scheduleProgressWrite();
     };
     const shouldBumpProgressForEvent = (event) => {
         if (event.type === "stream_keepalive")
@@ -683,6 +795,25 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     // emits nothing for minutes and carries its own 12-min timeout.
     let lastRealProgressAt = Date.now();
     let inFlightWorkCount = 0;
+    let inFlightMarkerSince = null;
+    let inFlightMarkerWrite = Promise.resolve();
+    const mirrorInFlightMarker = (inFlight) => {
+        const markerSince = inFlight ? Date.now() : inFlightMarkerSince;
+        if (inFlight) {
+            inFlightMarkerSince = markerSince;
+        }
+        else {
+            inFlightMarkerSince = null;
+        }
+        // Preserve transition order: a delayed clear must not erase the marker
+        // written for the next tool that starts before the clear reaches SQL.
+        inFlightMarkerWrite = inFlightMarkerWrite
+            .catch(() => undefined)
+            .then(() => setRunInFlightMarker(runId, inFlight, markerSince ?? undefined))
+            .catch((error) => {
+            console.error(`[run-manager] failed to mirror in-flight marker (${inFlight ? "set" : "clear"})`, runId, error instanceof Error ? error.message : error);
+        });
+    };
     const trackInFlightWork = (event) => {
         const wasIdle = inFlightWorkCount === 0;
         if (event.type === "tool_start") {
@@ -708,15 +839,15 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         // grant this demonstrably-alive run a bounded grace even when THIS
         // isolate's own heartbeat write is failing (e.g. Neon pooler saturation)
         // — `inFlightWorkCount` itself is in-memory and invisible to those other
-        // isolates. Fire-and-forget: never block event emission on this write,
-        // and a write failure here is no worse than today's behavior (the row
-        // just gets no grace). See `setRunInFlightMarker` / `IN_FLIGHT_RUN_STALE_GRACE_MS`
-        // in run-store.ts for the full reasoning and the bounded-grace derivation.
+        // isolates. Fire-and-forget: never block event emission on this write, but
+        // keep failures observable and preserve transition order. See
+        // `setRunInFlightMarker` / `IN_FLIGHT_RUN_STALE_GRACE_MS` in run-store.ts
+        // for the full reasoning and bounded-grace derivation.
         if (wasIdle && inFlightWorkCount > 0) {
-            setRunInFlightMarker(runId, true).catch(() => { });
+            mirrorInFlightMarker(true);
         }
         else if (!wasIdle && inFlightWorkCount === 0) {
-            setRunInFlightMarker(runId, false).catch(() => { });
+            mirrorInFlightMarker(false);
         }
     };
     // Make a chunk boundary durable at the instant it is decided. The terminal
@@ -1171,6 +1302,17 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         clearInterval(heartbeatTimer);
         if (softTimeoutTimer)
             clearTimeout(softTimeoutTimer);
+        if (progressWriteTimer)
+            clearTimeout(progressWriteTimer);
+        progressWriteTimer = null;
+        progressWritePending = false;
+        // A tool can throw before its matching event is emitted, or the process
+        // can reach terminal cleanup with an in-flight call still open. Do not
+        // leave the SQL grace marker attached to a terminal run.
+        if (inFlightWorkCount > 0 || inFlightMarkerSince !== null) {
+            inFlightWorkCount = 0;
+            mirrorInFlightMarker(false);
+        }
         // 5. Persist final status to SQL. Use the conditional write so a zombie
         //    run (reaped or displaced while executing) cannot clobber the newer
         //    status written by the reaper or a replacement run.

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

@@ -457,7 +457,7 @@ export declare function updateRunHeartbeat(runId: string): Promise<void>;
  * stuck-detector can tell "process alive but nothing happening" from
  * "process dead." Callers should throttle (run-manager debounces to ~1/s).
  */
-export declare function bumpRunProgress(runId: string): Promise<void>;
+export declare function bumpRunProgress(runId: string): Promise<boolean>;
 /**
  * Mirror run-manager's in-memory `inFlightWorkCount` 0<->N transitions into
  * SQL so a stale reaper running in a DIFFERENT isolate can tell a
@@ -469,17 +469,18 @@ export declare function bumpRunProgress(runId: string): Promise<void>;
  * depth belt-and-suspenders against a nested 1->2 transition clobbering the
  * ORIGINAL start time with a later one (the caller's own counter already
  * dedupes 0->1 transitions; this WHERE just makes the write itself
- * idempotent/order-independent too). `inFlight: false` always clears
- * unconditionally — if it races a fresh 0->1 write from a *different* tool
- * finishing/starting back to back, worst case is losing a few seconds of
- * grace, never gaining an incorrect one.
+ * idempotent/order-independent too). When `markerSince` is supplied for a
+ * clear, the UPDATE is conditional on the marker still having that value. The
+ * run manager serializes marker writes and supplies this token so a delayed
+ * clear from one tool cannot erase a newer tool's marker.
  *
- * Best-effort: callers fire-and-forget (`.catch(() => {})`) so a write
- * failure here never blocks event emission or aborts the run. If this write
- * itself fails (the same DB pressure that could be starving the heartbeat),
- * the row simply gets no grace — never worse than today's behavior.
+ * Best-effort: callers fire-and-forget so a write failure here never blocks
+ * event emission or aborts the run. The run manager logs marker-write failures
+ * while preserving transition order. If this write itself fails (the same DB
+ * pressure that could be starving the heartbeat), the row simply gets no grace
+ * - never worse than today's behavior.
  */
-export declare function setRunInFlightMarker(runId: string, inFlight: boolean): Promise<void>;
+export declare function setRunInFlightMarker(runId: string, inFlight: boolean, markerSince?: number): Promise<void>;
 /**
  * If the given run is marked "running" in SQL but its heartbeat is stale
  * (producer likely crashed), flip it to "errored" so watchers stop waiting.

package/dist/agent/run-store.js

@@ -1351,7 +1351,7 @@ export async function bumpRunProgress(runId) {
     await ensureRunTables();
     const client = getDbExec();
     const now = Date.now();
-    await client.execute({
+    const { rowsAffected } = await client.execute({
         // Multiple event-persistence paths and serverless isolates can bump the
         // same run concurrently. A slower, older write must never land after a
         // newer one and move the user-visible no-progress clock backwards.
@@ -1359,6 +1359,7 @@ export async function bumpRunProgress(runId) {
         sql: `UPDATE agent_runs SET last_progress_at = CASE WHEN last_progress_at IS NULL OR last_progress_at < ? THEN ? ELSE last_progress_at END WHERE id = ? AND status = 'running'`,
         args: [now, now, runId],
     });
+    return (rowsAffected ?? 0) > 0;
 }
 /**
  * Mirror run-manager's in-memory `inFlightWorkCount` 0<->N transitions into
@@ -1371,29 +1372,32 @@ export async function bumpRunProgress(runId) {
  * depth belt-and-suspenders against a nested 1->2 transition clobbering the
  * ORIGINAL start time with a later one (the caller's own counter already
  * dedupes 0->1 transitions; this WHERE just makes the write itself
- * idempotent/order-independent too). `inFlight: false` always clears
- * unconditionally — if it races a fresh 0->1 write from a *different* tool
- * finishing/starting back to back, worst case is losing a few seconds of
- * grace, never gaining an incorrect one.
+ * idempotent/order-independent too). When `markerSince` is supplied for a
+ * clear, the UPDATE is conditional on the marker still having that value. The
+ * run manager serializes marker writes and supplies this token so a delayed
+ * clear from one tool cannot erase a newer tool's marker.
  *
- * Best-effort: callers fire-and-forget (`.catch(() => {})`) so a write
- * failure here never blocks event emission or aborts the run. If this write
- * itself fails (the same DB pressure that could be starving the heartbeat),
- * the row simply gets no grace — never worse than today's behavior.
+ * Best-effort: callers fire-and-forget so a write failure here never blocks
+ * event emission or aborts the run. The run manager logs marker-write failures
+ * while preserving transition order. If this write itself fails (the same DB
+ * pressure that could be starving the heartbeat), the row simply gets no grace
+ * - never worse than today's behavior.
  */
-export async function setRunInFlightMarker(runId, inFlight) {
+export async function setRunInFlightMarker(runId, inFlight, markerSince) {
     await ensureRunTables();
     const client = getDbExec();
     if (inFlight) {
         await client.execute({
             sql: `UPDATE agent_runs SET in_flight_since = ? WHERE id = ? AND status = 'running' AND in_flight_since IS NULL`,
-            args: [Date.now(), runId],
+            args: [markerSince ?? Date.now(), runId],
         });
     }
     else {
         await client.execute({
-            sql: `UPDATE agent_runs SET in_flight_since = NULL WHERE id = ?`,
-            args: [runId],
+            sql: markerSince == null
+                ? `UPDATE agent_runs SET in_flight_since = NULL WHERE id = ?`
+                : `UPDATE agent_runs SET in_flight_since = NULL WHERE id = ? AND in_flight_since = ?`,
+            args: markerSince == null ? [runId] : [runId, markerSince],
         });
     }
 }

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

@@ -34,7 +34,7 @@ export declare function createUserMessageRunConfig(references?: Reference[], req
     model?: string;
     engine?: string;
     effort?: ReasoningEffort;
-}): {
+}, turnId?: string): {
     runConfig?: {
         custom: {
             references?: Reference[];
@@ -45,6 +45,7 @@ export declare function createUserMessageRunConfig(references?: Reference[], req
             model?: string;
             engine?: string;
             effort?: ReasoningEffort;
+            turnId?: string;
         };
     };
     metadata?: {
@@ -98,13 +99,14 @@ export declare function resolveAssistantChatSubmitIntent({ isRunning, requestedI
     isRunning: boolean;
     requestedIntent?: ComposerSubmitIntent;
 }): ComposerSubmitIntent;
-export declare function resolveAssistantChatRunningState({ forceStopped, isRuntimeRunning, isReconnecting, optimisticRunning, isAutoResuming, hasActiveServerRun, }: {
+export declare function resolveAssistantChatRunningState({ forceStopped, isRuntimeRunning, isReconnecting, optimisticRunning, isAutoResuming, hasActiveServerRun, hasTerminalRunError, }: {
     forceStopped: boolean;
     isRuntimeRunning: boolean;
     isReconnecting: boolean;
     optimisticRunning: boolean;
     isAutoResuming: boolean;
     hasActiveServerRun?: boolean;
+    hasTerminalRunError?: boolean;
 }): {
     isRunning: boolean;
     showRunningInUI: boolean;
@@ -136,6 +138,9 @@ type QueuedMessage = {
     recoveryAction?: AgentRecoveryAction;
     trackInRunsTray?: boolean;
     hideUserMessage?: boolean;
+    approvedToolCalls?: string[];
+    /** Preserve the logical turn when a hidden reconnect recovery is re-issued. */
+    turnId?: 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 +311,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 +324,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