@agent-native/core 0.90.10 → 0.90.11

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2145
-- template files: 4841
+- template files: 4843

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @agent-native/core
 
+## 0.90.11
+
+### Patch Changes
+
+- bba7332: Keep agent-chat workers on the hosted foreground timeout unless they are actually running inside a background function, preventing misrouted workers from being killed as stale runs.
+- bba7332: Fix "The model returned an empty response" on hard/long-context chat turns: interactive chat now resolves max_output_tokens to min(model ceiling, 32K) instead of the flat 4096-8192 per-engine defaults, Anthropic/Gemini numeric thinking budgets are clamped to always leave real output headroom under max_tokens, and the empty-final-response retry now raises the token ceiling and steps reasoning effort down a tier (with the retry budget raised from 1 to 2 attempts) instead of re-issuing the identical doomed request.
+- bba7332: Stop misrouted agent-chat workers from taking the large background Neon connection pool. `isBackgroundFunctionPoolContext()` no longer trusts the dispatch marker (`__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__`) — a worker dispatched toward a `-background` URL but routed onto the ~60s synchronous function would otherwise open the 8-connection worker pool while running as one of many warm sync-function instances, exhausting the Neon pooled endpoint (connection terminated / statement timeouts / failed heartbeat writes surfacing as stale runs). Only the genuine `-background` runtime marker (set at cold start) unlocks the larger pool now, mirroring the same proof-of-landing tightening applied to the worker soft-timeout.
+
 ## 0.90.10
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.90.10",
+  "version": "0.90.11",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/agent/durable-background.ts

@@ -260,12 +260,12 @@ export function backgroundRunMarkerExpectsBackgroundRuntime(
 }
 
 export function shouldUseBackgroundFunctionTimeoutForWorker(
-  marker: unknown,
+  _marker: unknown,
 ): boolean {
-  return (
-    isInBackgroundFunctionRuntime() ||
-    backgroundRunMarkerExpectsBackgroundRuntime(marker)
-  );
+  // The dispatch marker says which URL the foreground targeted, not where the
+  // request actually landed. Only the worker runtime proof can safely lift the
+  // hosted 40s clamp to the 15-minute background-function budget.
+  return isInBackgroundFunctionRuntime();
 }
 
 export function backgroundRuntimeDiagnosticDetail(marker: unknown): string {

package/corpus/core/src/agent/engine/ai-sdk-engine.ts

@@ -19,7 +19,10 @@ import {
 } from "../../server/credential-provider.js";
 import { normalizeReasoningEffortForModel } from "../../shared/reasoning-effort.js";
 import { AI_SDK_MODEL_CONFIG, type AISDKProvider } from "../model-config.js";
-import { resolveMaxOutputTokensForEngine } from "./output-tokens.js";
+import {
+  clampThinkingBudgetTokens,
+  resolveMaxOutputTokensForEngine,
+} from "./output-tokens.js";
 import {
   engineToolsToAISDK,
   engineMessagesToAISDK,
@@ -262,16 +265,34 @@ class AISDKEngine implements AgentEngine {
       toolResultImages: this.capabilities.vision,
     });
 
+    // Resolved once so both `maxOutputTokens` (below, in the streamText call)
+    // and the thinking-budget headroom clamp agree on the same ceiling.
+    const resolvedMaxOutputTokens = resolveMaxOutputTokensForEngine(
+      this.name,
+      opts.maxOutputTokens,
+      opts.model,
+    );
+
     // Build providerOptions for Anthropic-native features when using Anthropic provider
     const providerOpts: Record<string, unknown> = {};
     if (this.provider === "anthropic" && opts.providerOptions?.anthropic) {
       const anthropicOpts = opts.providerOptions.anthropic;
       if (anthropicOpts.thinking) {
+        // Only the "enabled" config carries a numeric budgetTokens; clamp it
+        // so thinking can't consume the entire maxOutputTokens budget and
+        // leave zero room for the actual response ("adaptive" thinking has
+        // no budgetTokens field at all per @ai-sdk/anthropic's schema).
         providerOpts.anthropic = {
           ...((providerOpts.anthropic as object) ?? {}),
           thinking: {
             type: "enabled",
-            budgetTokens: anthropicOpts.thinking.budgetTokens,
+            budgetTokens:
+              typeof anthropicOpts.thinking.budgetTokens === "number"
+                ? clampThinkingBudgetTokens(
+                    anthropicOpts.thinking.budgetTokens,
+                    resolvedMaxOutputTokens,
+                  )
+                : anthropicOpts.thinking.budgetTokens,
           },
         };
       }
@@ -309,11 +330,26 @@ class AISDKEngine implements AgentEngine {
         // Gemini 3.x models reject thinkingBudget — they require thinkingLevel.
         // Gemini 2.5.x models use thinkingBudget (integer token count or -1).
         const isGemini3 = /^gemini-3/.test(opts.model);
+        const thinkingBudget = googleThinkingBudget(reasoningEffort);
         providerOpts.google = {
           ...((providerOpts.google as object) ?? {}),
           thinkingConfig: isGemini3
             ? { thinkingLevel: gemini3ThinkingLevel(reasoningEffort) }
-            : { thinkingBudget: googleThinkingBudget(reasoningEffort) },
+            : {
+                // Unlike Anthropic's adaptive thinking, Gemini 2.5's
+                // thinkingBudget IS a concrete numeric token count, so the
+                // same headroom clamp applies: at "max" effort this maps to
+                // 32000 tokens, which can equal (or exceed) a small
+                // maxOutputTokens cap and leave zero room for the actual
+                // response. Preserve Gemini's -1 "dynamic" sentinel.
+                thinkingBudget:
+                  thinkingBudget > 0
+                    ? clampThinkingBudgetTokens(
+                        thinkingBudget,
+                        resolvedMaxOutputTokens,
+                      )
+                    : thinkingBudget,
+              },
         };
       }
     }
@@ -326,11 +362,7 @@ class AISDKEngine implements AgentEngine {
         system: opts.systemPrompt,
         messages,
         tools: aiSdkTools,
-        maxOutputTokens: resolveMaxOutputTokensForEngine(
-          this.name,
-          opts.maxOutputTokens,
-          opts.model,
-        ),
+        maxOutputTokens: resolvedMaxOutputTokens,
         ...(opts.temperature !== undefined
           ? { temperature: opts.temperature }
           : {}),

package/corpus/core/src/agent/engine/anthropic-engine.ts

@@ -19,7 +19,10 @@ import {
   LLM_MISSING_CREDENTIALS_ERROR_CODE,
   LLM_MISSING_CREDENTIALS_MESSAGE,
 } from "./credential-errors.js";
-import { resolveMaxOutputTokensForEngine } from "./output-tokens.js";
+import {
+  clampThinkingBudgetTokens,
+  resolveMaxOutputTokensForEngine,
+} from "./output-tokens.js";
 import {
   engineToolsToAnthropic,
   engineMessagesToAnthropic,
@@ -67,12 +70,31 @@ class AnthropicEngine implements AgentEngine {
     const messages = engineMessagesToAnthropic(opts.messages);
     const anthropicOpts = opts.providerOptions?.anthropic;
 
+    // Resolved once so both max_tokens and the thinking-budget headroom
+    // clamp below agree on the same ceiling.
+    const resolvedMaxOutputTokens = resolveMaxOutputTokensForEngine(
+      this.name,
+      opts.maxOutputTokens,
+      opts.model,
+    );
+
     // Build extra body params for Anthropic-native features
     const extra: Record<string, unknown> = {};
     if (anthropicOpts?.thinking) {
       extra.thinking = {
         type: anthropicOpts.thinking.type,
-        budget_tokens: anthropicOpts.thinking.budgetTokens,
+        // Only the "enabled" config carries a numeric budget_tokens; clamp it
+        // so thinking can't consume the entire max_tokens budget and leave
+        // zero room for the actual response ("adaptive" thinking has no
+        // budget_tokens field at all, so it passes through unclamped).
+        budget_tokens:
+          anthropicOpts.thinking.type === "enabled" &&
+          typeof anthropicOpts.thinking.budgetTokens === "number"
+            ? clampThinkingBudgetTokens(
+                anthropicOpts.thinking.budgetTokens,
+                resolvedMaxOutputTokens,
+              )
+            : anthropicOpts.thinking.budgetTokens,
       };
     }
     if (anthropicOpts?.topK !== undefined) {
@@ -139,11 +161,7 @@ class AnthropicEngine implements AgentEngine {
 
     const requestParams: any = {
       model: opts.model,
-      max_tokens: resolveMaxOutputTokensForEngine(
-        this.name,
-        opts.maxOutputTokens,
-        opts.model,
-      ),
+      max_tokens: resolvedMaxOutputTokens,
       system: systemBlocks,
       tools: cachedTools.length > 0 ? cachedTools : undefined,
       messages: cachedMessages,

package/corpus/core/src/agent/engine/output-tokens.ts

@@ -13,6 +13,100 @@ export const DEFAULT_AI_SDK_MAX_OUTPUT_TOKENS = 4096;
 export const DEFAULT_ANTHROPIC_MAX_OUTPUT_TOKENS = 8192;
 export const DEFAULT_BUILDER_MAX_OUTPUT_TOKENS = 8192;
 
+// ---------------------------------------------------------------------------
+// Main interactive chat path
+//
+// The per-engine defaults above (4096-8192) exist for internal/eval/
+// observational-memory callers that intentionally want a small explicit cap.
+// The main interactive chat turn (the one the end user is staring at) needs
+// real headroom: on long-context or reasoning-heavy turns, a tiny completion
+// budget means extended thinking alone can consume the entire response,
+// leaving zero tokens for visible text/tool calls ("empty response" bug).
+// These helpers give the chat path a much higher floor while staying at or
+// under each model's documented ceiling — they never lower the ceiling.
+// ---------------------------------------------------------------------------
+
+/** Cap for the first attempt of an interactive chat turn. */
+export const MAIN_CHAT_MAX_OUTPUT_TOKENS_CAP = 32_000;
+/**
+ * Cap used only when retrying a turn that came back with an empty final
+ * response (see production-agent.ts's empty-final-response retry). Higher
+ * than the first-attempt cap so the retry meaningfully raises the ceiling.
+ */
+export const EMPTY_RESPONSE_RETRY_MAX_OUTPUT_TOKENS_CAP = 64_000;
+
+/**
+ * Resolve the max_output_tokens floor for the first attempt of an
+ * interactive chat turn: min(model ceiling, 32K). Always at or above the
+ * flat per-engine defaults above, regardless of whether the model is known.
+ */
+export function resolveMainChatMaxOutputTokens(modelId?: string): number {
+  return Math.min(
+    getMaxOutputTokensForModel(modelId),
+    MAIN_CHAT_MAX_OUTPUT_TOKENS_CAP,
+  );
+}
+
+/**
+ * Resolve the max_output_tokens to use when retrying a turn after an empty
+ * final response: min(model ceiling, 64K).
+ */
+export function resolveEmptyResponseRetryMaxOutputTokens(
+  modelId?: string,
+): number {
+  return Math.min(
+    getMaxOutputTokensForModel(modelId),
+    EMPTY_RESPONSE_RETRY_MAX_OUTPUT_TOKENS_CAP,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Extended-thinking budget headroom
+//
+// Anthropic's `thinking: { type: "enabled", budget_tokens }` config requires
+// budget_tokens >= 1024 and STRICTLY LESS THAN max_tokens (confirmed against
+// the installed @anthropic-ai/sdk@0.90.0 type defs — see ThinkingConfigEnabled
+// in resources/messages/messages.d.ts). budget_tokens counts toward
+// max_tokens, so an unclamped large budget can leave too little (or zero)
+// room for the actual visible completion. This clamp guarantees at least
+// max(8000, 40% of maxOutputTokens) tokens of non-thinking headroom.
+//
+// Note: this only applies to the explicit numeric-budget "enabled" config.
+// Anthropic's `type: "adaptive"` thinking config (used by the
+// reasoningEffort -> output_config.effort mapping in anthropic-engine.ts /
+// ai-sdk-engine.ts) has NO budget_tokens field at all per the SDK types, so
+// there is nothing to clamp there — those callers rely on the raised
+// maxOutputTokens ceiling above instead.
+// ---------------------------------------------------------------------------
+
+/** Anthropic's documented minimum extended-thinking budget. */
+export const ANTHROPIC_MIN_THINKING_BUDGET_TOKENS = 1024;
+
+/**
+ * Clamp a requested Anthropic thinking budget so it leaves guaranteed
+ * headroom under `maxOutputTokens` for non-thinking output, and stays within
+ * the provider's valid range (>= 1024, < maxOutputTokens).
+ */
+export function clampThinkingBudgetTokens(
+  requestedBudgetTokens: number,
+  maxOutputTokens: number,
+): number | undefined {
+  if (maxOutputTokens <= ANTHROPIC_MIN_THINKING_BUDGET_TOKENS) {
+    return undefined;
+  }
+  const headroom = Math.max(8000, Math.round(0.4 * maxOutputTokens));
+  const budgetCapForHeadroom = Math.max(
+    ANTHROPIC_MIN_THINKING_BUDGET_TOKENS,
+    maxOutputTokens - headroom,
+  );
+  // budget_tokens must stay strictly below max_tokens per the API contract.
+  const strictUpperBound = maxOutputTokens - 1;
+  return Math.max(
+    ANTHROPIC_MIN_THINKING_BUDGET_TOKENS,
+    Math.min(requestedBudgetTokens, budgetCapForHeadroom, strictUpperBound),
+  );
+}
+
 function parsePositiveInteger(value: unknown): number | null {
   if (typeof value === "string" && value.trim() === "") return null;
   const n =

package/corpus/core/src/agent/production-agent.ts

@@ -45,6 +45,7 @@ import { fireInternalDispatch } from "../server/self-dispatch.js";
 import {
   isReasoningEffort,
   normalizeReasoningEffortForModel,
+  stepDownReasoningEffort,
   type ReasoningEffort,
 } from "../shared/reasoning-effort.js";
 import { actionPreparationContinuationNote } from "./action-continuation-guidance.js";
@@ -77,7 +78,11 @@ import {
   normalizeModelForEngine,
   isResolvedEngineUsableForRequest,
 } from "./engine/index.js";
-import { resolveMaxOutputTokensForEngine } from "./engine/output-tokens.js";
+import {
+  resolveEmptyResponseRetryMaxOutputTokens,
+  resolveMainChatMaxOutputTokens,
+  resolveMaxOutputTokensForEngine,
+} from "./engine/output-tokens.js";
 import { PROVIDER_TO_ENV } from "./engine/provider-env-vars.js";
 import {
   backfillEngineMessagesToolResults,
@@ -1015,7 +1020,10 @@ const TOOL_INPUT_ACTIVITY_INTERVAL_MS = 1500;
 const ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS = 90_000;
 const ACTION_PREPARATION_ZERO_BYTE_RESTART_LIMIT = 2;
 const MODEL_STREAM_NO_PROGRESS_TIMEOUT_MS = 90_000;
-const EMPTY_FINAL_RESPONSE_RETRY_LIMIT = 1;
+// 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
+// exact same doomed request twice.
+const EMPTY_FINAL_RESPONSE_RETRY_LIMIT = 2;
 const MAIN_CHAT_INTERNAL_CONTINUATION_LIMIT = 6;
 const RUN_BUDGET_EXHAUSTED_ERROR_CODE = "run_budget_exhausted";
 const RUN_BUDGET_EXHAUSTED_MESSAGE =
@@ -2736,6 +2744,12 @@ export async function runAgentLoop(opts: {
   let finalGuardRetries = 0;
   let emptyFinalResponseRetries = 0;
   let iterations = 0;
+  // Overridden (raised tokens, lowered effort) only after an empty-final-
+  // response retry below — kept separate from `opts.maxOutputTokens`/
+  // `opts.reasoningEffort` so the very first attempt is unaffected and later
+  // tool-loop turns revert to the caller's original request after a success.
+  let effectiveMaxOutputTokens = opts.maxOutputTokens;
+  let effectiveReasoningEffort = opts.reasoningEffort;
 
   // Set when an in-loop processor aborts via `abort()` / throws a `TripWire`.
   // The loop emits the `tripwire` event, surfaces the reason as a final
@@ -2845,10 +2859,10 @@ export async function runAgentLoop(opts: {
           abortSignal: signal,
           maxOutputTokens: resolveMaxOutputTokensForEngine(
             engine.name,
-            opts.maxOutputTokens,
+            effectiveMaxOutputTokens,
             model,
           ),
-          reasoningEffort: opts.reasoningEffort,
+          reasoningEffort: effectiveReasoningEffort,
           providerOptions: opts.providerOptions,
         };
 
@@ -3351,8 +3365,10 @@ export async function runAgentLoop(opts: {
       // text — typically when reasoning consumes the entire output-token
       // budget. Without a final text part the SSE stream still ends with a
       // clean `done`, which renders as a totally empty assistant bubble.
-      // Retry once so a transient reasoning-budget miss can still finish; if
-      // the retry also has no visible content, surface a plain-language error.
+      // Retry so a reasoning-budget miss can still finish; each retry raises
+      // the token ceiling and steps reasoning effort down a tier so it's not
+      // just re-issuing the identical doomed request. If retries also come
+      // back empty, surface a plain-language error.
       const hasEmptyFinalResponse =
         !guardEmittedFallback &&
         collectTextParts(assistantContentForHistory).trim().length === 0 &&
@@ -3360,6 +3376,11 @@ export async function runAgentLoop(opts: {
       if (hasEmptyFinalResponse) {
         if (emptyFinalResponseRetries < EMPTY_FINAL_RESPONSE_RETRY_LIMIT) {
           emptyFinalResponseRetries += 1;
+          effectiveMaxOutputTokens =
+            resolveEmptyResponseRetryMaxOutputTokens(model);
+          effectiveReasoningEffort = stepDownReasoningEffort(
+            effectiveReasoningEffort,
+          );
           appendAgentLoopContinuation(messages, "max_tokens");
           continue;
         }
@@ -3369,6 +3390,8 @@ export async function runAgentLoop(opts: {
         });
       } else {
         emptyFinalResponseRetries = 0;
+        effectiveMaxOutputTokens = opts.maxOutputTokens;
+        effectiveReasoningEffort = opts.reasoningEffort;
       }
       break;
     }
@@ -6795,6 +6818,11 @@ export function createProductionAgentHandler(
           orgId: getRequestOrgId() ?? null,
           attachments: requestAttachments,
           reasoningEffort,
+          // The interactive chat turn needs real completion headroom — the
+          // flat per-engine defaults (4096-8192) exist for internal/eval
+          // callers and are far below what a hard, long-context turn needs
+          // once extended thinking is in play. See output-tokens.ts.
+          maxOutputTokens: resolveMainChatMaxOutputTokens(effectiveModel),
           providerOptions: options.providerOptions,
           executionMode: requestMode,
           maxIterations: loopSettings.maxIterations,

package/corpus/core/src/agent/types.ts

@@ -180,8 +180,9 @@ export interface AgentChatRequest {
     continuationCount?: number;
     /**
      * True when the dispatcher expects the self-POST to land in a real
-     * Netlify `-background` function (15-min budget) rather than the ~60s
-     * synchronous function. See `shouldUseBackgroundFunctionTimeoutForWorker`.
+     * Netlify `-background` function rather than the ~60s synchronous function.
+     * This is diagnostic only; the 15-minute budget is unlocked by the worker's
+     * actual runtime marker.
      */
     backgroundFunctionRuntimeExpected?: boolean;
     /**

package/corpus/core/src/db/client.ts

@@ -856,15 +856,18 @@ export function isBackgroundFunctionPoolContext(): boolean {
   ) {
     return true;
   }
-  // Set by the HMAC-authenticated agent-chat `_process-run` route before it
-  // re-enters the normal chat handler. This mirrors the marker-only runtime
-  // proof used by durable-background.ts without importing agent code into db/.
-  if (
-    (globalThis as Record<string, unknown>)
-      .__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ === true
-  ) {
-    return true;
-  }
+  // NOTE: we deliberately do NOT trust `__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__`
+  // here. That flag is set from the dispatch MARKER (which URL the foreground
+  // targeted), not from proof the request actually LANDED on a background
+  // function. A worker dispatched toward `-background` but routed onto the ~60s
+  // synchronous function would otherwise take the 8-connection background pool
+  // while running as one of MANY warm sync-function instances — multiplying
+  // Neon connections and exhausting the pooled endpoint ("connection
+  // terminated" / statement timeouts / failed heartbeat writes → stale runs).
+  // The genuine `-background` function sets `__AGENT_NATIVE_BACKGROUND_RUNTIME__`
+  // as its first cold-start statement, so a real background worker still gets
+  // the larger pool via the check above. Mirrors the same proof-of-landing
+  // tightening applied to `shouldUseBackgroundFunctionTimeoutForWorker`.
   const lambdaName = process.env.AWS_LAMBDA_FUNCTION_NAME;
   if (
     typeof lambdaName === "string" &&

package/corpus/core/src/shared/reasoning-effort.ts

@@ -98,6 +98,29 @@ export function reasoningEffortLabel(effort: ReasoningEffort | undefined) {
   return REASONING_EFFORT_LABELS[effort ?? "auto"];
 }
 
+/**
+ * One tier down from each effort, stopping at "minimal" — "none"/"auto"
+ * (not really "tiers") and "minimal" itself are left unchanged. Used by the
+ * empty-final-response retry so a retried turn asks for meaningfully less
+ * reasoning instead of repeating the exact request that came back empty.
+ */
+const REASONING_EFFORT_STEP_DOWN: Partial<
+  Record<ReasoningEffort, ReasoningEffort>
+> = {
+  max: "xhigh",
+  xhigh: "high",
+  high: "medium",
+  medium: "low",
+  low: "minimal",
+};
+
+export function stepDownReasoningEffort(
+  effort: ReasoningEffort | undefined,
+): ReasoningEffort | undefined {
+  if (!effort) return effort;
+  return REASONING_EFFORT_STEP_DOWN[effort] ?? effort;
+}
+
 function isGPTReasoningModel(model: string) {
   return /^gpt-5/.test(model) || /^o\d/.test(model);
 }

package/corpus/templates/clips/actions/regenerate-chapters.ts

@@ -23,6 +23,12 @@ export default defineAction({
     "Ask the agent to generate chapters for this recording based on its transcript (and the full video when Include full video is enabled). The agent identifies topic transitions and calls set-chapters.",
   schema: z.object({
     recordingId: z.string().describe("Recording ID"),
+    openInChat: z
+      .boolean()
+      .optional()
+      .describe(
+        "When true, focus the queued generation request in the agent chat instead of keeping it hidden.",
+      ),
   }),
   run: async (args) => {
     await assertAccess("recording", args.recordingId, "editor");
@@ -57,6 +63,7 @@ export default defineAction({
       segmentsJson: transcript?.segmentsJson ?? "[]",
       transcriptText: transcript?.fullText ?? "",
       includeFullVideoInAi,
+      openInChat: args.openInChat === true,
       message: withFullVideoAiInstructions(
         baseMessage,
         args.recordingId,

package/corpus/templates/clips/app/hooks/use-auto-title.ts

@@ -15,6 +15,7 @@ import {
   agentNativePath,
   callAction,
   sendToAgentChat,
+  type AgentChatMessage,
 } from "@agent-native/core/client";
 import { fullVideoAiModelSelection } from "@shared/clips-ai-prefs";
 import { useEffect, useRef } from "react";
@@ -55,6 +56,7 @@ interface AiRequest {
   thresholdMs?: number;
   message?: string;
   includeFullVideoInAi?: boolean;
+  openInChat?: boolean;
 }
 
 const DISPATCHABLE_REQUESTS = new Set([
@@ -201,25 +203,33 @@ function buildRequestContext(rec: RecordingSummary, request: AiRequest) {
   };
 }
 
-function dispatchAiRequest(rec: RecordingSummary, request: AiRequest) {
+export function buildAiRequestChatOptions(
+  rec: RecordingSummary,
+  request: AiRequest,
+): AgentChatMessage {
   const includeFullVideo = request.includeFullVideoInAi === true;
   const gemini = includeFullVideo ? fullVideoAiModelSelection() : null;
-  sendToAgentChat({
+  const openInChat = request.openInChat === true;
+  return {
     message:
       request.message ??
       `Handle queued ${request.kind} work for recording ${rec.id}.`,
     context: JSON.stringify(buildRequestContext(rec, request)),
     submit: true,
-    openSidebar: false,
+    openSidebar: openInChat ? true : false,
     newTab: true,
-    background: true,
+    background: !openInChat,
     ...(gemini
       ? {
           engine: gemini.engine,
           model: gemini.model,
         }
       : {}),
-  });
+  };
+}
+
+function dispatchAiRequest(rec: RecordingSummary, request: AiRequest) {
+  sendToAgentChat(buildAiRequestChatOptions(rec, request));
 }
 
 function parseJsonArray(raw: string | undefined): unknown[] {

package/corpus/templates/clips/app/routes/download.tsx

@@ -4,7 +4,6 @@ import {
   IconBrandApple,
   IconBrandWindows,
   IconExternalLink,
-  IconPlayerRecord,
 } from "@tabler/icons-react";
 import { useEffect, useState } from "react";
 
@@ -201,9 +200,18 @@ export default function DownloadPage() {
             href={appPath("/")}
             className="flex items-center gap-2 font-semibold"
           >
-            <span className="grid h-7 w-7 place-items-center rounded-md bg-primary text-primary-foreground">
-              <IconPlayerRecord className="h-4 w-4" />
-            </span>
+            <img
+              src={appPath("/agent-native-icon-light.svg")}
+              alt=""
+              aria-hidden="true"
+              className="block h-4 w-auto shrink-0 dark:hidden"
+            />
+            <img
+              src={appPath("/agent-native-icon-dark.svg")}
+              alt=""
+              aria-hidden="true"
+              className="hidden h-4 w-auto shrink-0 dark:block"
+            />
             <span>Clips</span>
           </a>
           <a

package/corpus/templates/clips/app/routes/r.$recordingId.tsx

@@ -1096,6 +1096,7 @@ export default function RecordingPage() {
                   onSelect={() =>
                     regenerateChapters.mutate({
                       recordingId: recording.id,
+                      openInChat: true,
                     } as any)
                   }
                 >

package/corpus/templates/clips/changelog/2026-07-07-auto-generated-chapter-requests-now-open-the-matching-agent-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+Auto-generated chapter requests now open the matching agent chat tab.

package/corpus/templates/clips/changelog/2026-07-07-the-clips-desktop-download-page-now-uses-the-agent-native-ap.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-07
+---
+
+The Clips Desktop download page now uses the Agent Native app icon in its header.

package/dist/agent/durable-background.d.ts

@@ -103,7 +103,7 @@ export declare function isHostedRuntimeForDurableBackground(): boolean;
  */
 export declare function isInBackgroundFunctionRuntime(): boolean;
 export declare function backgroundRunMarkerExpectsBackgroundRuntime(marker: unknown): boolean;
-export declare function shouldUseBackgroundFunctionTimeoutForWorker(marker: unknown): boolean;
+export declare function shouldUseBackgroundFunctionTimeoutForWorker(_marker: unknown): boolean;
 export declare function backgroundRuntimeDiagnosticDetail(marker: unknown): string;
 /**
  * The single gate. True when the env flag is explicitly enabled, or a workspace

package/dist/agent/durable-background.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"durable-background.d.ts","sourceRoot":"","sources":["../../src/agent/durable-background.ts"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,2CACE,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,4BAA4B,CAAC;AAExE;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC,gDAA0D,CAAC;AAiC1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,sCAAsC,IAAI,MAAM,CAQ/D;AAED,wBAAgB,4CAA4C,CAC1D,YAAY,EAAE,MAAM,GACnB,OAAO,CAET;AAED;;;GAGG;AACH,eAAO,MAAM,iCAAiC,kCACb,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBAAoB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAsB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAsBvD;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,OAAO,GACd,OAAO,CAOT;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,OAAO,GACd,OAAO,CAKT;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAQzE;AAwCD;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,CAAC,EAAE;IAC5D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAWV;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC,qCACb,CAAC;AAiBrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qCAAqC,IAAI,OAAO,CAM/D;AAED,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAC7B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEN;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAahE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,qBAAqB,CAiDvB"}
+{"version":3,"file":"durable-background.d.ts","sourceRoot":"","sources":["../../src/agent/durable-background.ts"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,2CACE,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,4BAA4B,CAAC;AAExE;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC,gDAA0D,CAAC;AAiC1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,sCAAsC,IAAI,MAAM,CAQ/D;AAED,wBAAgB,4CAA4C,CAC1D,YAAY,EAAE,MAAM,GACnB,OAAO,CAET;AAED;;;GAGG;AACH,eAAO,MAAM,iCAAiC,kCACb,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBAAoB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAsB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAsBvD;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,OAAO,GACd,OAAO,CAOT;AAED,wBAAgB,2CAA2C,CACzD,OAAO,EAAE,OAAO,GACf,OAAO,CAKT;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAQzE;AAwCD;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,CAAC,EAAE;IAC5D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAWV;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC,qCACb,CAAC;AAiBrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qCAAqC,IAAI,OAAO,CAM/D;AAED,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAC7B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEN;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAahE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,qBAAqB,CAiDvB"}

package/dist/agent/durable-background.js

@@ -225,9 +225,11 @@ export function backgroundRunMarkerExpectsBackgroundRuntime(marker) {
         marker
             .backgroundFunctionRuntimeExpected === true);
 }
-export function shouldUseBackgroundFunctionTimeoutForWorker(marker) {
-    return (isInBackgroundFunctionRuntime() ||
-        backgroundRunMarkerExpectsBackgroundRuntime(marker));
+export function shouldUseBackgroundFunctionTimeoutForWorker(_marker) {
+    // The dispatch marker says which URL the foreground targeted, not where the
+    // request actually landed. Only the worker runtime proof can safely lift the
+    // hosted 40s clamp to the 15-minute background-function budget.
+    return isInBackgroundFunctionRuntime();
 }
 export function backgroundRuntimeDiagnosticDetail(marker) {
     return [