@agent-native/core 0.161.22 → 0.162.0

package/corpus/templates/slides/server/handlers/index-design-system-sources.ts

@@ -1,12 +1,14 @@
 import {
   FeatureNotConfiguredError,
-  getSession,
   indexBuilderDesignSystem,
 } from "@agent-native/core/server";
 import { defineEventHandler, readBody, setResponseStatus } from "h3";
 
 import { upsertBuilderProxyDesignSystem } from "../lib/builder-design-system-proxy.js";
-import { withSlidesRequestContext } from "./request-auth-context.js";
+import {
+  resolveSlidesRequestAuth,
+  withSlidesRequestContext,
+} from "./request-auth-context.js";
 
 /**
  * Finalizes Builder DSI indexing from upload tokens produced by the
@@ -14,8 +16,14 @@ import { withSlidesRequestContext } from "./request-auth-context.js";
  * storage; this endpoint only forwards the opaque tokens.
  */
 export const indexDesignSystemSources = defineEventHandler(async (event) => {
-  const session = await getSession(event).catch(() => null);
-  if (!session?.email) {
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  const session = auth.context;
+  const sessionEmail = session.email;
+  if (!sessionEmail) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }
@@ -45,21 +53,28 @@ export const indexDesignSystemSources = defineEventHandler(async (event) => {
   }));
 
   try {
-    return await withSlidesRequestContext(event, async ({ email, orgId }) => {
-      const result = await indexBuilderDesignSystem({ sources, projectName });
-      const proxy = await upsertBuilderProxyDesignSystem({
-        result,
-        ownerEmail: email ?? session.email,
-        orgId: orgId ?? null,
-        projectName,
-        sourceKind: "figma",
-      });
-      return {
-        ...result,
-        ...proxy,
-        uploadedFileCount: uploadTokens.length,
-      };
-    });
+    return await withSlidesRequestContext(
+      event,
+      async ({ email, orgId }) => {
+        const result = await indexBuilderDesignSystem({
+          sources,
+          projectName,
+        });
+        const proxy = await upsertBuilderProxyDesignSystem({
+          result,
+          ownerEmail: email ?? sessionEmail,
+          orgId: orgId ?? null,
+          projectName,
+          sourceKind: "figma",
+        });
+        return {
+          ...result,
+          ...proxy,
+          uploadedFileCount: uploadTokens.length,
+        };
+      },
+      session,
+    );
   } catch (err) {
     if (err instanceof FeatureNotConfiguredError) {
       setResponseStatus(event, 412);

package/corpus/templates/slides/server/handlers/share.ts

@@ -116,7 +116,7 @@ async function createShareLink(event: any, deckId: string) {
   }
 
   const slides = storedDeck.slides.map((slide: unknown, index: number) =>
-    toSharedDeckSlide(slide, index),
+    toSharedDeckSlide(slide, index, { includeNotes: false }),
   );
 
   await db.insert(schema.deckShareLinks).values({

package/corpus/templates/slides/server/plugins/agent-chat.ts

@@ -57,7 +57,7 @@ export default createAgentChatPlugin({
     return authContext.orgId === undefined ? null : authContext.orgId;
   },
   prepareRequest: prepareSlidesChatAttachments,
-  systemPrompt: `You are an AI deck assistant. You create, edit, import, export, style, share, and navigate decks through actions and shared application state. For a newly created presentation, use create-deck with slides: [] only when you are creating the deck yourself, then add-slide sequentially with full rendered HTML. The legacy generate-slides-ai action returns Markdown drafts and is not part of the persisted presentation workflow.
+  systemPrompt: `You are an AI deck assistant. You create, edit, import, export, style, share, and navigate decks through actions and shared application state. For a newly created presentation, use create-deck with slides: [] only when you are creating the deck yourself, then add-slide sequentially with full rendered HTML. The legacy generate-slides-ai action returns Markdown drafts and is not part of the persisted presentation workflow. When speaker notes are requested, keep presenter-only text in each slide's notes field rather than the slide HTML, and preserve notes during source-preserving edits.
 
 When the user asks to improve, beautify, restyle, or make an uploaded/existing deck on-brand, treat it as an in-place source-preserving edit unless the user explicitly asks to rewrite the story or change slide count. First call view-screen when the active deck is unclear, then get-deck with compact=true for deck orientation. If you need slide markup, call get-deck with compact=false explicitly and only when the edit requires the full HTML. If get-deck.sourceImport exists, preserve its slide count, order, IDs, factual copy, notes, images, charts, tables, diagrams, freeform objects, and source aspect ratio. For a deck-wide restyle, use one patch-deck call with requireAllSourceSlides=true and one patch-slide operation with fields.content for every source slide ID; the action rejects partial coverage. Do not split a full-deck restyle into arbitrary batches or use one-by-one update-slide calls - reserve update-slide for targeted one-slide edits. After the patch succeeds, verify with get-deck using compact=true so the verification does not retransmit every slide's HTML. Do not claim a partial or initial pass. Do not use add-slide, delete, reorder, or replace source imagery with generic cards for this workflow. If sourceImport.fidelity is partial or imagesSkipped is nonzero, stop and report the exact fidelity warning instead of claiming a reliable improvement.
 For a targeted one-slide edit, prefer get-deck with the stable slideId from view-screen or compact get-deck. It returns only that slide's full HTML by default, so do not load the full deck when one slide is enough. For code-style edits, request compact=false and format=true, then call update-slide with that slide's contentHash as baseContentHash and an ordered edits list. Use exact replace, insert-before/after, replace-between, or regex-replace edits; include expectedMatches for ambiguous markers. The action applies the whole list atomically under the deck lock, so a failed required match writes nothing. Set format=true on update-slide when readable line breaks should be persisted. Use fullContent only for an intentional full rewrite. Pass compact=true when you only need a lightweight check of that slide.

package/corpus/templates/slides/server/routes/api/deck-agent-context.json.get.ts

@@ -77,7 +77,7 @@ export default defineEventHandler(async (event) => {
   const data = parseDeckData(deck.data);
   const slides = Array.isArray(data.slides)
     ? data.slides.map((slide: unknown, index: number) =>
-        toSharedDeckSlide(slide, index),
+        toSharedDeckSlide(slide, index, { includeNotes: false }),
       )
     : [];
 

package/corpus/templates/slides/server/routes/api/exports/[filename].get.ts

@@ -2,9 +2,10 @@ import { createReadStream } from "fs";
 import { stat } from "fs/promises";
 import path from "path";
 
-import { getSession, streamFile } from "@agent-native/core/server";
+import { streamFile } from "@agent-native/core/server";
 import { defineEventHandler, getRouterParam, setResponseStatus } from "h3";
 
+import { resolveSlidesRequestAuth } from "../../../handlers/request-auth-context.js";
 import { tenantExportDir } from "../../../lib/tenant-files.js";
 
 const CONTENT_TYPES: Record<string, string> = {
@@ -15,8 +16,13 @@ const CONTENT_TYPES: Record<string, string> = {
 };
 
 export default defineEventHandler(async (event) => {
-  const session = await getSession(event).catch(() => null);
-  if (!session?.email) {
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  const session = auth.context;
+  if (!session.email) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }

package/corpus/templates/slides/server/routes/api/exports/google-slides.post.ts

@@ -1,10 +1,11 @@
-import { getSession, runWithRequestContext } from "@agent-native/core/server";
+import { runWithRequestContext } from "@agent-native/core/server";
 import {
   defineEventHandler,
   readMultipartFormData,
   setResponseStatus,
 } from "h3";
 
+import { resolveSlidesRequestAuth } from "../../../handlers/request-auth-context.js";
 import { getGoogleDocsAccessToken } from "../../../lib/google-docs-oauth.js";
 
 const PPTX_CONTENT_TYPE =
@@ -28,8 +29,14 @@ const UPLOAD_URL =
  * See "Export Behavior" in `templates/slides/AGENTS.md` for the routing rule.
  */
 export default defineEventHandler(async (event) => {
-  const session = await getSession(event).catch(() => null);
-  if (!session?.email) {
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  const session = auth.context;
+  const sessionEmail = session.email;
+  if (!sessionEmail) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }
@@ -50,8 +57,8 @@ export default defineEventHandler(async (event) => {
   // be org-scoped vault secrets, and resolving them without the org reports the
   // integration as unconfigured.
   const account = await runWithRequestContext(
-    { userEmail: session.email, orgId: session.orgId },
-    () => getGoogleDocsAccessToken(session.email),
+    { userEmail: sessionEmail, orgId: session.orgId },
+    () => getGoogleDocsAccessToken(sessionEmail),
   );
   if (!account) {
     setResponseStatus(event, 409);

package/corpus/templates/slides/server/routes/api/exports/html.post.ts

@@ -1,17 +1,19 @@
 import path from "path";
 
-import {
-  getSession,
-  readBody,
-  runWithRequestContext,
-} from "@agent-native/core/server";
+import { readBody, runWithRequestContext } from "@agent-native/core/server";
 import { defineEventHandler, setResponseStatus } from "h3";
 
 import exportHtmlAction from "../../../../actions/export-html.js";
+import { resolveSlidesRequestAuth } from "../../../handlers/request-auth-context.js";
 
 export default defineEventHandler(async (event) => {
-  const session = await getSession(event).catch(() => null);
-  if (!session?.email) {
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  const session = auth.context;
+  if (!session.email) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }

package/corpus/templates/slides/server/routes/api/exports/pptx.post.ts

@@ -1,20 +1,22 @@
 import path from "path";
 
-import {
-  getSession,
-  readBody,
-  runWithRequestContext,
-} from "@agent-native/core/server";
+import { readBody, runWithRequestContext } from "@agent-native/core/server";
 import { defineEventHandler, setResponseStatus } from "h3";
 
 import exportPptxAction from "../../../../actions/export-pptx.js";
+import { resolveSlidesRequestAuth } from "../../../handlers/request-auth-context.js";
 
 const PPTX_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.presentationml.presentation";
 
 export default defineEventHandler(async (event) => {
-  const session = await getSession(event).catch(() => null);
-  if (!session?.email) {
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  const session = auth.context;
+  if (!session.email) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }

package/corpus/templates/slides/shared/api.ts

@@ -126,6 +126,11 @@ export interface SharedDeckSlide {
   splitByParagraph?: boolean;
 }
 
+export interface SharedDeckSlideOptions {
+  /** Include presenter-only notes for an authenticated internal read. */
+  includeNotes?: boolean;
+}
+
 const SHARED_SLIDE_TRANSITIONS = new Set<SharedSlideTransition>([
   "instant",
   "none",
@@ -216,12 +221,13 @@ function normalizeSlideAnimation(
 export function toSharedDeckSlide(
   value: unknown,
   index: number,
+  options: SharedDeckSlideOptions = {},
 ): SharedDeckSlide {
   const slide = isRecord(value) ? value : {};
   const shared: SharedDeckSlide = {
     id: normalizeString(slide.id, `slide-${index + 1}`),
     content: normalizeString(slide.content, ""),
-    notes: "",
+    notes: options.includeNotes ? normalizeString(slide.notes, "") : "",
     layout: normalizeString(slide.layout, "content"),
   };
 

package/corpus/templates/tasks/.agents/skills/real-time-sync/SKILL.md

@@ -50,7 +50,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
 
    For list/sidebar queries, use the same pattern — pass the counter into the queryKey of every list query you want to keep fresh.
 
-4. **Fallback** polling calls `/_agent-native/poll?since=N`. It runs every 2 seconds until SSE is connected, then relaxes to 15 seconds (`SSE_FALLBACK_INTERVAL_MS`). If SSE is disabled or unavailable (e.g., edge/serverless deployments), polling continues at the 2 s cadence. Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
+4. **Fallback** polling calls `/_agent-native/poll?since=N`. It polls every 2 seconds only while an agent run is in flight; otherwise it idles at 60 seconds whether or not SSE is connected (`SSE_FALLBACK_INTERVAL_MS` and `IDLE_POLL_INTERVAL_MS`, both 60 s). A hidden tab polls no faster than every 10 seconds (`HIDDEN_POLL_INTERVAL_MS`). Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
 
 5. When the agent writes to the database, the version increments, SSE/polling detects it, and React Query refetches the affected queries.
 

package/dist/agent/engine/builder-engine.js

@@ -138,10 +138,17 @@ class BuilderEngine {
             }, creditsLane);
             return;
         }
+        // The Builder gateway has an "auto" fallback mode, but Agent Native owns
+        // model selection. Always send a concrete model so the gateway cannot
+        // select an organization-level override or another fallback model.
+        const requestedModel = opts.model.trim();
+        const model = requestedModel.length === 0 || requestedModel === "auto"
+            ? BUILDER_DEFAULT_MODEL
+            : requestedModel;
         const messages = engineMessagesToBuilderGatewayAnthropic(opts.messages);
         const tools = engineToolsToAnthropic(opts.tools);
         const thinkingBudget = opts.providerOptions?.anthropic?.thinking?.budgetTokens;
-        const reasoningEffort = normalizeReasoningEffortForModel(opts.model, opts.reasoningEffort ??
+        const reasoningEffort = normalizeReasoningEffortForModel(model, opts.reasoningEffort ??
             (typeof thinkingBudget === "number"
                 ? mapReasoningEffort(thinkingBudget)
                 : undefined));
@@ -200,13 +207,13 @@ class BuilderEngine {
                 }
             }
         }
-        const gptToolsRequireExplicitNoReasoning = cachedTools.length > 0 && isGPTReasoningModel(opts.model);
+        const gptToolsRequireExplicitNoReasoning = cachedTools.length > 0 && isGPTReasoningModel(model);
         const body = {
-            model: opts.model,
+            model,
             messages: cachedMessages,
             ...(systemValue !== undefined ? { system: systemValue } : {}),
             ...(cachedTools.length > 0 ? { tools: cachedTools } : {}),
-            max_tokens: resolveMaxOutputTokensForEngine(this.name, opts.maxOutputTokens, opts.model),
+            max_tokens: resolveMaxOutputTokensForEngine(this.name, opts.maxOutputTokens, model),
             ...(typeof opts.temperature === "number"
                 ? { temperature: opts.temperature }
                 : {}),
@@ -232,7 +239,7 @@ class BuilderEngine {
         // gateway outage are the same capture.
         const payload = JSON.stringify(body);
         const requestShape = {
-            model: opts.model,
+            model,
             payloadBytes: new TextEncoder().encode(payload).length,
             toolCount: cachedTools.length,
             messageCount: cachedMessages.length,
@@ -242,7 +249,7 @@ class BuilderEngine {
         gatewayUrl.searchParams.set("apiKey", spaceId);
         const orgLabel = creds.orgName || "unknown-org";
         const tStart = Date.now();
-        console.log(`[builder-engine] → POST ${gatewayUrl.origin}${gatewayUrl.pathname} model=${opts.model} tools=${tools.length} org=${orgLabel}`);
+        console.log(`[builder-engine] → POST ${gatewayUrl.origin}${gatewayUrl.pathname} model=${model} tools=${tools.length} org=${orgLabel}`);
         const gatewayTimeoutMs = getBuilderGatewayTimeoutMs();
         const gatewayAbort = createGatewayAbortSignal(opts.abortSignal, gatewayTimeoutMs);
         try {
@@ -269,7 +276,7 @@ class BuilderEngine {
                 if (timedOut || isBuilderGatewayNetworkError(err)) {
                     captureBuilderGatewayTransportError(err, {
                         phase: "request",
-                        model: opts.model,
+                        model,
                         gatewayUrl,
                         timeoutMs: gatewayAbort.effectiveTimeoutMs(),
                         timedOut,
@@ -325,7 +332,7 @@ class BuilderEngine {
                 }, creditsLane, requestShape);
                 return;
             }
-            yield* parseJsonlStream(reader, opts.model, {
+            yield* parseJsonlStream(reader, model, {
                 creditsLane,
                 abortSignal: gatewayAbort.signal,
                 didGatewayTimeout: gatewayAbort.didTimeout,

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

@@ -261,17 +261,42 @@ export function backfillEngineMessagesToolResults(messages) {
 // ---------------------------------------------------------------------------
 // EngineMessage → Anthropic.MessageParam
 // ---------------------------------------------------------------------------
+/**
+ * A thinking block replays only with the signature Anthropic issued for it, or
+ * (redacted) with its encrypted payload. An empty signature is not a fallback:
+ * the native API rejects the whole request, so a turn that streamed fine dies
+ * with a provider error pointing nowhere near the cause. Drop the unsendable
+ * block and say so instead of coercing it into a guaranteed 400.
+ *
+ * Not applied to the Builder gateway: its tolerance for an unsigned thinking
+ * block is unverified, so that path keeps its existing behavior rather than
+ * trading a working request for an untested one.
+ */
+function replayableAnthropicPart(part) {
+    if (part.type !== "thinking")
+        return true;
+    if (part.redactedData || part.signature)
+        return true;
+    console.warn("[anthropic-engine] dropping a thinking block with no signature; it cannot be replayed");
+    return false;
+}
 export function engineMessageToAnthropic(msg, opts) {
     const builderGateway = opts?.builderGateway === true;
+    const content = builderGateway
+        ? msg.content
+        : msg.content.filter(replayableAnthropicPart);
     return {
         role: msg.role,
-        content: msg.content.map((p) => enginePartToAnthropic(p, builderGateway)),
+        content: content.map((p) => enginePartToAnthropic(p, builderGateway)),
     };
 }
 /** Messages for the Anthropic HTTP API (strict schema — no extra tool_result fields). */
 export function engineMessagesToAnthropic(messages) {
     const normalized = backfillEngineMessagesToolResults(messages);
-    return normalized.map((m) => engineMessageToAnthropic(m));
+    return normalized.flatMap((m) => {
+        const translated = engineMessageToAnthropic(m);
+        return translated.content.length > 0 ? [translated] : [];
+    });
 }
 /**
  * Messages for the Builder LLM gateway (Gemini-backed). Same Anthropic-shaped

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

@@ -700,7 +700,7 @@ export interface ExecuteAgentToolCallOptions {
     threadId?: string;
     turnId?: string;
     approvedToolCalls?: string[];
-    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<void>;
+    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<string | void>;
     consumeApproval?: (binding: AgentApprovalBinding) => Promise<boolean>;
     send?: (event: AgentChatEvent) => void;
 }
@@ -877,7 +877,7 @@ export declare function runAgentLoop(opts: {
      * so client-supplied history is never the authorization source; direct loop
      * callers may omit them when they own the surrounding approval boundary.
      */
-    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<void>;
+    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<string | void>;
     consumeApproval?: (binding: AgentApprovalBinding) => Promise<boolean>;
     /**
      * In-loop processor seam (see `processors.ts`). Each processor can observe
@@ -1351,5 +1351,20 @@ export declare function resolveAgentRequestReasoningEffort({ model, requestEffor
     requestEffort?: unknown;
     configuredEffort?: ReasoningEffort;
 }): ReasoningEffort | undefined;
+export type AgentModelSelectionSource = "request" | "configured" | "stored" | "default";
+/**
+ * Resolve the model before the engine boundary. `auto` is a UI sentinel, not
+ * a model to forward to the gateway, so it gives way to an AN org/user
+ * default, then the configured global engine default.
+ */
+export declare function resolveAgentModelSelection(options: {
+    requestModel?: string | null;
+    configuredModel?: string | null;
+    storedModel?: string | null;
+    defaultModel: string;
+}): {
+    model: string;
+    source: AgentModelSelectionSource;
+};
 export declare function createProductionAgentHandler(options: ProductionAgentOptions): H3EventHandler;
 export { getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortTurnDurably, subscribeToRun, };

package/dist/agent/production-agent.js

@@ -4331,7 +4331,14 @@ export async function runAgentLoop(opts) {
                     mustApprove = true;
                 }
                 if (mustApprove) {
-                    await opts.onApprovalRequired?.(approvalBinding);
+                    // `askId` identifies THIS gate hit, distinct from any earlier ask
+                    // for the same approvalKey/toolCallId. A failed resume (expired
+                    // grant, turn-id mismatch) re-enters this branch and mints a new
+                    // askId, which is how the client tells "an already-approved card
+                    // re-rendered" apart from "a fresh ask after the grant didn't land"
+                    // — without it, a stale client-side "approved" mark permanently
+                    // hides Approve/Deny with no way to retry.
+                    const askId = (await opts.onApprovalRequired?.(approvalBinding)) || undefined;
                     send({
                         type: "tool_start",
                         id: toolCall.id,
@@ -4343,6 +4350,7 @@ export async function runAgentLoop(opts) {
                         tool: toolCall.name,
                         input: toolCall.input,
                         approvalKey,
+                        ...(askId ? { askId } : {}),
                         ...(toolCall.id ? { toolCallId: toolCall.id } : {}),
                     });
                     // Audit the blocked attempt: the action did NOT run, but "the agent
@@ -6275,6 +6283,27 @@ function progressStepFromAgentChatEvent(event) {
 export function resolveAgentRequestReasoningEffort({ model, requestEffort, configuredEffort, }) {
     return normalizeReasoningEffortForRequest(model, isReasoningEffort(requestEffort) ? requestEffort : configuredEffort);
 }
+function isConcreteModelSelection(model) {
+    const normalized = typeof model === "string" ? model.trim() : "";
+    return normalized.length > 0 && normalized !== "auto";
+}
+/**
+ * Resolve the model before the engine boundary. `auto` is a UI sentinel, not
+ * a model to forward to the gateway, so it gives way to an AN org/user
+ * default, then the configured global engine default.
+ */
+export function resolveAgentModelSelection(options) {
+    if (isConcreteModelSelection(options.requestModel)) {
+        return { model: options.requestModel, source: "request" };
+    }
+    if (isConcreteModelSelection(options.configuredModel)) {
+        return { model: options.configuredModel, source: "configured" };
+    }
+    if (isConcreteModelSelection(options.storedModel)) {
+        return { model: options.storedModel, source: "stored" };
+    }
+    return { model: options.defaultModel, source: "default" };
+}
 export function createProductionAgentHandler(options) {
     if (options.resolveActionSurface) {
         assertRequestActionSurfaceIsolation();
@@ -6644,21 +6673,23 @@ export function createProductionAgentHandler(options) {
         // DIAGNOSTIC-ONLY: bracket stored-model resolution (getStoredModelForEngine
         // settings read).
         workerStep("model_start");
-        const storedModel = requestModel == null && configuredModel == null
+        const requestModelIsExplicit = isConcreteModelSelection(requestModel);
+        const configuredModelIsExplicit = isConcreteModelSelection(configuredModel);
+        const storedModel = !requestModelIsExplicit && !configuredModelIsExplicit
             ? await getStoredModelForEngine(engine, { appId: options.appId })
             : undefined;
-        const modelCandidate = requestModel ?? configuredModel ?? storedModel ?? engine.defaultModel;
+        const modelSelection = resolveAgentModelSelection({
+            requestModel,
+            configuredModel,
+            storedModel,
+            defaultModel: engine.defaultModel,
+        });
+        const modelCandidate = modelSelection.model;
         // DIAGNOSTIC-ONLY: stored-model resolution finished.
         workerStep("model_done");
         const model = normalizeModelForEngine(engine, modelCandidate);
         let effectiveModel = model;
-        let modelSelectionSource = requestModel != null
-            ? "request"
-            : configuredModel != null
-                ? "configured"
-                : storedModel != null
-                    ? "stored"
-                    : "default";
+        let modelSelectionSource = modelSelection.source;
         let experimentAssignments = [];
         // Database-backed experiments remain available to app operators.
         try {
@@ -7171,7 +7202,7 @@ export function createProductionAgentHandler(options) {
         };
         const approvalHooks = {
             onApprovalRequired: async (binding) => {
-                await createAgentToolApproval(approvalStoreBinding(binding));
+                return createAgentToolApproval(approvalStoreBinding(binding));
             },
             consumeApproval: async (binding) => {
                 if (!ownerEmail)
@@ -7211,12 +7242,12 @@ export function createProductionAgentHandler(options) {
                 const { threadDataToEngineMessages } = await import("./thread-data-builder.js");
                 const priorThreadData = (await getThread(effectiveThreadId))
                     ?.threadData;
-                // `threadDataToEngineMessages` takes one argument and flattens tool
-                // calls to text by design. The second argument never existed anywhere
-                // in the repo, so this failed `tsc` and broke every production build
-                // between 16:29 and now -- it reached main only because admin merges
-                // do not wait for the typecheck that would have caught it.
-                const resumed = threadDataToEngineMessages(priorThreadData);
+                // Replay what earlier chunks DID, not just what they said: the default
+                // text-only rebuild drops every tool call and result, so the next chunk
+                // re-runs work already committed and cannot see its output.
+                const resumed = threadDataToEngineMessages(priorThreadData, {
+                    includeToolCalls: true,
+                });
                 if (resumed.length > 0) {
                     const actionPreparationTool = typeof backgroundRunMarker?.actionPreparationTool === "string" &&
                         backgroundRunMarker.actionPreparationTool.trim()

package/dist/agent/thread-data-builder.d.ts

@@ -21,6 +21,7 @@ interface ContentPart {
     approval?: {
         approvalKey: string;
         dismissed?: boolean;
+        askId?: string;
     };
 }
 interface BuildAssistantMessageOptions {

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

@@ -144,7 +144,10 @@ export function buildAssistantMessage(events, runId, options = {}) {
             const matchingIndex = findApprovalToolCallIndex(content, event.tool ?? "unknown", event.toolCallId);
             const part = content[matchingIndex];
             if (part?.type === "tool-call") {
-                part.approval = { approvalKey: event.approvalKey };
+                part.approval = {
+                    approvalKey: event.approvalKey,
+                    ...(event.askId ? { askId: event.askId } : {}),
+                };
             }
             continue;
         }
@@ -744,14 +747,13 @@ function assistantReplayContent(message, text) {
             ? part.args
             : {};
         assistant.push({ type: "tool-call", id, name, input });
-        if (part.result === undefined)
-            continue;
+        const result = part.result === undefined ? INTERRUPTED_TOOL_RESULT : part.result;
         results.push({
             type: "tool-result",
             toolCallId: id,
             toolName: name,
             toolInput: stringifyToolUseInputForGateway(input),
-            content: replayedToolResultContent(part.result),
+            content: replayedToolResultContent(result),
             ...(part.isError === true ? { isError: true } : {}),
         });
     }

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

@@ -21,7 +21,16 @@ export declare function resolveAgentToolApprovalTurnId(binding: {
     requestedTurnId?: string | null;
     approvalKeys: readonly string[];
 }): Promise<string | null>;
-export declare function createAgentToolApproval(binding: AgentToolApprovalBinding): Promise<void>;
+/**
+ * Creates the durable pending-approval row and returns its id as the "ask"
+ * identity for this specific gate hit. Every call is a fresh row (a fresh
+ * id), including a second gate hit for the same `approvalKey` after a prior
+ * grant failed to be consumed — so the id doubles as the signal the client
+ * needs to tell "this approval_required is the one I already approved,
+ * re-rendered" apart from "this is a NEW ask for the same tool call". See
+ * `ApprovalAffordance` in client/chat/tool-call-display.tsx.
+ */
+export declare function createAgentToolApproval(binding: AgentToolApprovalBinding): Promise<string>;
 /**
  * Atomically consume the server-created approval for one logical tool call.
  * The model's call id is transport metadata and can change when Dispatch