@agent-native/core 0.79.6 → 0.79.9

package/corpus/README.md

@@ -27,5 +27,5 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 2027
-- template files: 4380
+- core files: 2029
+- template files: 4373

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @agent-native/core
 
+## 0.79.9
+
+### Patch Changes
+
+- ca677a0: Reduce noisy error capture for expected provider connection failures and transient chat recovery probes.
+
+## 0.79.8
+
+### Patch Changes
+
+- 4984f2b: Fail A2A agent tasks that end on terminal run errors without a final response, and keep app-native artifact actions ahead of generic extension creation in agent prompts.
+- 4984f2b: Centralize agent chat request context resolution so foreground and durable background workers share owner, org, timezone, and background-run setup, harden hosted credential fallback detection, and support compressed session replay uploads.
+
+## 0.79.7
+
+### Patch Changes
+
+- b7cfefe: Remove the temporary durable-background-worker hang-localizer diagnostics from the agent chat setup hot path. The analytics worker-stall bug they were added to debug is fixed and verified in prod, so the ~7 extra awaited DB round-trips per durable run setup (and their 8s-hang risk under DB stress) are no longer needed. The lasting fix and observability — the `worker_stage` column, cheap fire-and-forget `workerStep` markers, `readBackgroundRunClaim`, and the centralized request-context resolution — are retained.
+
 ## 0.79.6
 
 ### Patch Changes

package/corpus/core/docs/content/locales/zh-TW/durable-background-runs.md

@@ -0,0 +1,74 @@
+---
+title: "持久背景執行"
+description: "長時間的代理聊天回合可以在獨立的 15 分鐘 Netlify 背景函式中執行，而不是佔用同步請求，讓多步驟工作在伺服器端完成，不需要用戶端看守續跑。每個應用可自行選用；前景斷路器會讓聊天在背景 worker 未啟動時仍可繼續運作。"
+---
+
+# 持久背景執行
+
+> **適用對象：**部署 agent-native 應用、希望長時間多步驟代理回合在伺服器端完成的人，以及想了解 `AGENT_CHAT_DURABLE_BACKGROUND` 旗標和第二個 Netlify 函式用途的人。這是框架內建的選用功能，不需要撰寫任何應用程式碼。
+
+一般託管代理回合會在同步請求函式中執行，並受平台請求逾時限制（Netlify 免費方案約 10 秒，框架約 40 秒軟逾時，之後必須把控制權交回用戶端並「從上次中斷的地方繼續」）。這對快速回答沒有問題，但長時間的代理回合（許多工具呼叫、大量分析）會在多次由用戶端驅動的續跑之間來回跳轉。
+
+持久背景執行會把那個長回合移到**獨立的 Netlify 背景函式**，並提供 **15 分鐘**預算。該回合會在伺服器端的一次呼叫中執行完成；UI 只需要串流結果。
+
+## 兩個函式，不是一個 {#two-functions}
+
+已部署的應用正好有兩個伺服器函式，幾乎所有請求都會打到第一個。只有被分派的代理回合會在第二個函式上執行。
+
+```an-diagram title="server 處理所有事；只有被分派的代理回合在背景函式上執行" summary="同步 server 函式提供頁面、actions、API 和前景聊天 POST；它會用 HMAC 將長回合分派到有 15 分鐘預算的背景函式。"
+{
+  "html": "<div class=\"diagram-bg-runs\"><div class=\"diagram-panel\" data-rough><div class=\"diagram-pill\">server &middot; synchronous</div><div class=\"diagram-box\">頁面 / SSR</div><div class=\"diagram-box\">Actions</div><div class=\"diagram-box\">API + 框架路由</div><div class=\"diagram-box\">前景聊天 POST <small class=\"diagram-muted\">決定 + 分派</small></div><small class=\"diagram-muted\">約 10 秒逾時 &middot; 幾乎所有請求</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;<br><small>HMAC 202</small></div><div class=\"diagram-panel\" data-rough><div class=\"diagram-pill accent\">server-agent-background &middot; background:true</div><div class=\"diagram-box\">_process-run worker</div><div class=\"diagram-box\">代理回合：LLM + 工具呼叫</div><small class=\"diagram-ok\">15 分鐘預算 &middot; 僅限被分派的回合</small></div></div>",
+  "css": ".diagram-bg-runs{display:flex;align-items:stretch;gap:14px;flex-wrap:wrap}.diagram-bg-runs .diagram-panel{display:flex;flex-direction:column;gap:8px;padding:14px;flex:1;min-width:230px}.diagram-bg-runs .diagram-box{padding:8px 10px}.diagram-bg-runs .diagram-arrow{display:flex;flex-direction:column;justify-content:center;text-align:center;min-width:90px;font-size:20px}"
+}
+```
+
+應用或範本程式碼中**沒有任何需要標記的地方**。當函式的 `export const config` 含有 `background: true`（或函式名稱以 `-background` 結尾）時，Netlify 就會把它視為背景函式。啟用此功能時，框架的建置步驟會自動產生 `server-agent-background` 包裝器；應用作者不需要自行宣告。
+
+## 背景中會執行什麼，以及如何選擇 {#what-runs}
+
+只有長時間的代理聊天回合，也就是會重新進入代理迴圈的內部 `_process-run` 分派（LLM 呼叫 + 工具執行）。頁面、actions 和一般 API 呼叫一律在 `server` 上同步執行。
+
+前景聊天 POST 會**逐回合**決定。只有下列三個條件同時成立時，才會分派到背景函式：
+
+- `AGENT_CHAT_DURABLE_BACKGROUND` 為真值（`true` / `1` / `yes` / `on`），
+- 應用正在託管環境中執行（在平台上，而非本機開發），以及
+- 已設定 `A2A_SECRET`（分派是 HMAC 簽署的自我呼叫；沒有 secret 就無法簽署，因此該回合會留在線上同步執行）。
+
+若缺少任何條件，該回合就會和以前一樣在線上同步執行。這個旗標會在**建置時間**讀取（決定是否輸出背景函式），也會在**執行時間**讀取（決定是否分派），因此啟用後需要重新部署。
+
+## 生命週期與斷路器 {#lifecycle}
+
+Netlify async function 會在**排入**呼叫的瞬間回傳 `202`；這不代表 worker 已實際執行。因此前景不會盲目相信 `202`：分派後會短暫輪詢，確認 worker 是否真的**認領**該 run；若沒有認領，前景會在線上同步復原。
+
+```an-diagram title="前景一律回傳可運作的回合" summary="分派時，前景會等待一段寬限時間讓 worker 認領 run；若認領成功，前景會訂閱它；若未認領，前景會自行認領並在線上同步執行該回合。"
+{
+  "html": "<div class=\"diagram-bg-life\"><div class=\"diagram-box\" data-rough>前景 POST</div><div class=\"diagram-arrow diagram-muted\">&rarr;</div><div class=\"diagram-box\" data-rough>插入 run + HMAC 分派 &rarr; 202</div><div class=\"diagram-arrow diagram-muted\">&rarr;</div><div class=\"diagram-panel center\" data-rough><strong>Worker 是否在寬限時間內認領？</strong><small class=\"diagram-ok\">是 &rarr; 串流背景 worker（最多 15 分鐘）</small><small class=\"diagram-warn\">否 &rarr; 斷路器在線上同步復原該回合</small></div></div>",
+  "css": ".diagram-bg-life{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.diagram-bg-life .diagram-arrow{font-size:20px}.diagram-bg-life .center{display:flex;flex-direction:column;gap:4px;padding:12px}"
+}
+```
+
+認領會透過 `dispatch_mode` 從 `background` 變成 `background-processing` 來觀察（只有 worker 的原子認領會這樣做）。寬限時間必須涵蓋 worker 冷啟動；較重的應用曾觀察到需要比原本 8 秒更久，因此目前是 **15 秒**（仍在前景約 40 秒軟逾時內）。如果 worker 從未認領，無論是故障或只是啟動太慢，都會在寬限時間後回退到線上同步執行，所以該回合仍會完成；代價是先等待寬限時間所增加的延遲。
+
+```an-callout
+{
+  "tone": "success",
+  "body": "無論哪種情況，前景都會回傳可運作的回合：worker 及時認領時使用背景 worker，否則使用線上同步回合。因此，即使 worker 失敗，持久背景執行也應該保留聊天正確性；但設定錯誤或認領過慢的 worker 可能會在同步復原接手前增加回退延遲（最多到寬限時間）。"
+}
+```
+
+## 成本與取捨 {#cost}
+
+Netlify 背景函式是**付費方案**功能（Personal / Pro，不含免費方案），並依運算時間計費（GB-hour）。因此多分鐘的代理回合會比短同步呼叫花費更多運算量；但它大致上**取代**了舊模式，也就是回合撞到約 40 秒限制後，用戶端重新送出多次續跑請求。這是把同一份工作合併到一次長呼叫中，不是純粹額外增加。
+
+```an-callout
+{
+  "tone": "info",
+  "body": "持久背景執行是每個應用可選用的功能，預設為關閉。使用 AGENT_CHAT_DURABLE_BACKGROUND=true（加上 A2A_SECRET）啟用並重新部署。若要驗證某個回合真的使用 worker，請檢查該 run 是否到達 dispatch_mode=background-processing，而不是回退到線上同步復原。"
+}
+```
+
+## 相關
+
+- [**持久恢復**](/docs/durable-resume) — 中斷的 run 如何恢復而不重複已完成的副作用（另一個永遠啟用的保護）。
+- [**部署**](/docs/deployment) — 應用及其函式如何建置並部署到平台。
+- [**A2A Protocol**](/docs/a2a-protocol) — `A2A_SECRET` 與持久 worker 重用的 HMAC 簽署自我分派。

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.79.6",
+  "version": "0.79.9",
   "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/production-agent.ts

@@ -3972,25 +3972,6 @@ export function createProductionAgentHandler(
           `${s}=${Date.now() - setupT0}ms`,
         ).catch(() => {});
     };
-    // DIAGNOSTIC-ONLY: AWAITED worker mark. Fire-and-forget workerStep marks
-    // after `post_model_ok` stopped landing even though writes still work
-    // there — so the worker's MAIN FLOW stalls between post_model and pre_claim
-    // (not a write hang). Awaited marks block until they land (or withDbTimeout-
-    // reject), so `worker_stage` reliably advances to the last phase the main
-    // flow actually reached — pinpointing the stall. Bg worker only.
-    const awaitedWorkerMark = async (s: string) => {
-      if (!isBackgroundWorker || !bgRunId) return;
-      try {
-        await recordRunDiagnostic(
-          bgRunId,
-          RUN_DIAG_STAGE.workerSetupStep,
-          `${s}=${Date.now() - setupT0}ms`,
-        );
-      } catch {
-        // bounded by withDbTimeout; ignore — the absence of the next mark is
-        // itself the signal.
-      }
-    };
     // Whether this worker is REALLY executing inside a 15-min Netlify
     // `-background` function (proven by the runtime function name), not merely a
     // `_process-run` re-entry that may have landed on the ~60s synchronous
@@ -4215,35 +4196,6 @@ export function createProductionAgentHandler(
     );
 
     options.onEngineResolved?.(engine, model);
-    // DIAGNOSTIC-ONLY: localize where the worker stalls AFTER model_done. These
-    // land in `worker_stage` (foreground-independent), so even though the
-    // foreground overwrites `diag_stage` on inline recovery, the worker's last
-    // reached point survives. If the last worker_stage is `model_done`, writes
-    // hang right after model resolution (DB connection); if it's
-    // `engine_resolved`/`systemprompt_enter`, the stall is in the named step.
-    workerStep("engine_resolved");
-    // DIAGNOSTIC-ONLY: AWAITED probe (bg worker only). worker_stage stalls at
-    // `model_done` even though the code right after is trivial sync — this
-    // distinguishes the two causes: if `post_model_awaited` lands, DB writes
-    // still work after model_done and the stall is later in the main flow; if it
-    // never lands (stays `model_done`), the bg-fn DB connection itself is hung
-    // right after model resolution. `recordRunDiagnostic` is `withDbTimeout`-
-    // bounded, so a hung write rejects (caught) rather than blocking forever.
-    if (isBackgroundWorker && bgRunId) {
-      const probeStart = Date.now();
-      try {
-        await recordRunDiagnostic(
-          bgRunId,
-          RUN_DIAG_STAGE.workerSetupStep,
-          "post_model_awaited",
-        );
-        workerStep(`post_model_ok=${Date.now() - probeStart}ms`);
-      } catch (e) {
-        workerStep(
-          `post_model_threw=${Date.now() - probeStart}ms:${String((e as Error)?.message ?? e).slice(0, 80)}`,
-        );
-      }
-    }
 
     // One-line per-turn resolution log so it's obvious in dev which engine
     // is actually handling the request. `requestEngine` is what the client
@@ -4254,14 +4206,6 @@ export function createProductionAgentHandler(
       `[agent-chat] resolved engine=${engine.name} model=${model} requestEngine=${requestEngine ?? "(none)"}`,
     );
 
-    // DIAGNOSTIC-ONLY: the worker reaches post_model_ok but never aw_env — the
-    // only exit between them is this anthropic key check. Capture the exact
-    // resolution state so we know WHY effectiveApiKey is falsy in the worker
-    // (owner not resolved from the HMAC/thread? owner has no stored key? deploy
-    // fallback blocked?) vs the foreground which resolves it fine.
-    await awaitedWorkerMark(
-      `apikey_state:engine=${engine.name},owner=${ownerEmail ? "Y" : "N"},userKey=${userApiKey ? "Y" : "N"},effKey=${effectiveApiKey ? "Y" : "N"},block=${shouldBlockDeployCredentialFallback()}`,
-    );
     // Check for API key before starting a run (only for anthropic engine)
     if (engine.name === "anthropic" && !effectiveApiKey) {
       setResponseHeader(event, "Content-Type", "text/event-stream");
@@ -4289,7 +4233,6 @@ export function createProductionAgentHandler(
     // reached db_request_ctx but not env_config hung in attachment upload or
     // engine/model resolution.
     workerStep("env_config");
-    await awaitedWorkerMark("aw_env");
     // Run all independent pre-send steps in parallel. Each of these hits
     // the DB or invokes an action; running them sequentially was the
     // single biggest contributor to pre-LLM latency.
@@ -4305,17 +4248,11 @@ export function createProductionAgentHandler(
     const systemPromptThunk = (): Promise<string> =>
       (async (): Promise<string> => {
         const sysPromptStart = Date.now();
-        // Brackets the system-prompt build (which runs the template's
-        // extraContext / data-dictionary). If worker_stage stalls at
-        // `systemprompt_enter` with no `systemprompt_done`, the build itself is
-        // the stall point.
-        workerStep("systemprompt_enter");
         try {
           const built =
             typeof options.systemPrompt === "function"
               ? await options.systemPrompt(event)
               : options.systemPrompt;
-          workerStep("systemprompt_done");
           return built;
         } catch (error) {
           systemPromptError = error;
@@ -4614,7 +4551,6 @@ export function createProductionAgentHandler(
     // DIAGNOSTIC-ONLY: all parallel context gathering (system prompt, screen,
     // files, loop settings, enriched message) resolved.
     workerStep("context_all");
-    await awaitedWorkerMark("aw_presend");
 
     if (systemPromptError) {
       setResponseHeader(event, "Content-Type", "text/event-stream");
@@ -4645,7 +4581,6 @@ export function createProductionAgentHandler(
     setupMark("actions");
     // DIAGNOSTIC-ONLY: action/tool resolution + engine-tool filtering finished.
     workerStep("action_tool_setup");
-    await awaitedWorkerMark("aw_actions");
     const requestSystemPrompt =
       requestMode === "plan"
         ? `${systemPrompt}\n\n${PLAN_MODE_SYSTEM_PROMPT}`
@@ -4760,7 +4695,6 @@ export function createProductionAgentHandler(
     // DIAGNOSTIC-ONLY: owner/thread resolution + runId/effectiveThreadId +
     // chained-continuation thread fetch finished.
     workerStep("owner_thread");
-    await awaitedWorkerMark("aw_owner");
 
     // Persist the user's turn exactly once. The foreground POST does this
     // before dispatching; the background worker must NOT repeat it (it re-enters
@@ -5178,33 +5112,6 @@ export function createProductionAgentHandler(
     // DIAGNOSTIC-ONLY: last stage before startRun fires. A worker that reaches
     // prestart but never workerStarted is hanging inside startRun itself.
     workerStep("prestart");
-    // DIAGNOSTIC-ONLY: AWAITED probe right before startRun (bg worker only). If
-    // worker_stage reaches `pre_claim_ok` but the run never flips to
-    // `worker_started`, the stall is inside startRun's claim itself; if it never
-    // reaches `pre_claim_*`, the stall is somewhere in the setup between
-    // post_model and here.
-    if (isBackgroundWorker && bgRunId) {
-      const claimProbeStart = Date.now();
-      try {
-        await recordRunDiagnostic(
-          bgRunId,
-          RUN_DIAG_STAGE.workerSetupStep,
-          "pre_claim",
-        );
-        workerStep(`pre_claim_ok=${Date.now() - claimProbeStart}ms`);
-      } catch (e) {
-        workerStep(
-          `pre_claim_threw=${Date.now() - claimProbeStart}ms:${String((e as Error)?.message ?? e).slice(0, 80)}`,
-        );
-      }
-    }
-    // DIAGNOSTIC-ONLY: peak-ish RSS (MB) + assembled system-prompt size (KB) at
-    // prestart. The analytics bg worker dies right after model_done; if the
-    // FOREGROUND (identical build, writes land) is already near the ~1024MB
-    // Netlify function limit, an OOM kill in the heavier worker explains the
-    // freeze. Both numbers ride along in the existing setup-timings detail.
-    setupMarks.rssMB = Math.round(process.memoryUsage().rss / 1048576);
-    setupMarks.promptKB = Math.round((systemPrompt?.length ?? 0) / 1024);
     const setupDetail =
       Object.entries(setupMarks)
         .map(([k, v]) => `${k}=${v}`)

package/corpus/core/src/agent/run-manager.ts

@@ -1,4 +1,5 @@
 import { captureError } from "../server/capture-error.js";
+import { isLlmCredentialError } from "./engine/credential-errors.js";
 import { EngineError } from "./engine/types.js";
 import {
   insertRun,
@@ -149,10 +150,15 @@ function getEngineRunErrorDetails(err: EngineError): string | undefined {
 function shouldCaptureRunError(err: unknown): boolean {
   if (!(err instanceof EngineError)) return true;
   const errorCode = getEngineRunErrorCode(err);
+  if (isLlmCredentialError(err, errorCode)) return false;
+  if (err.statusCode === 401 || err.statusCode === 403) return false;
+  if (/^40[13] status code\b/i.test(err.message)) return false;
+  if (err.message.trim().toLowerCase() === "connection error.") return false;
   if (!errorCode) return true;
   const normalizedCode = errorCode.toLowerCase();
   return (
     !normalizedCode.startsWith("credits-limit") &&
+    normalizedCode !== "builder_gateway_network_error" &&
     normalizedCode !== "provider_rate_limited" &&
     normalizedCode !== "rate_limit_exceeded"
   );
@@ -423,6 +429,8 @@ export function startRun(
   let pendingTerminalEvent: RunEvent | null = null;
 
   const captureRunError = (error: unknown, phase: "run" | "completion") => {
+    const errorCode =
+      error instanceof EngineError ? getEngineRunErrorCode(error) : undefined;
     captureError(error, {
       route: "/_agent-native/agent-chat",
       tags: {
@@ -431,7 +439,7 @@ export function startRun(
         runStatus: run.status,
         softTimedOut: softTimedOut ? "true" : "false",
         abortReason: run.abortReason,
-        errorCode: error instanceof EngineError ? error.errorCode : undefined,
+        errorCode,
       },
       extra: {
         runId,

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -717,7 +717,7 @@ function continuationRepeatSignature(content: ContentPart[]): string {
     .map((segment) => segment.replace(/[^a-z0-9]+/g, " ").trim())
     .filter((segment) => segment.length > 0);
   if (segments.length === 0) return "";
-  return Array.from(new Set(segments)).sort().join("");
+  return Array.from(new Set(segments)).sort().join("\u0000");
 }
 
 /**
@@ -771,7 +771,7 @@ function inFlightToolInputSignature(
   part: Extract<ContentPart, { type: "tool-call" }>,
 ): string {
   const raw = part.argsText ?? stableJson(part.args);
-  return `${raw.length}${raw.slice(0, 256)}`;
+  return `${raw.length}\u0000${raw.slice(0, 256)}`;
 }
 
 function toolContinuationKey(
@@ -964,6 +964,10 @@ function retryDelay(attempt: number, abortSignal: AbortSignal): Promise<void> {
   return delay(ms, abortSignal);
 }
 
+function shouldCaptureRecoveryHttpStatus(status: number): boolean {
+  return status < 500 || status >= 600;
+}
+
 function generateTurnId(): string {
   if (
     typeof crypto !== "undefined" &&
@@ -1518,15 +1522,17 @@ export function createAgentChatAdapter(
                 lastReconnectError = new Error(
                   `Reconnect failed: ${reconnectRes.status}`,
                 );
-                captureChatClientError(
-                  lastReconnectError,
-                  "reconnect-current-response",
-                  {
-                    status: reconnectRes.status,
-                    hasBody: Boolean(reconnectRes.body),
-                    attempt,
-                  },
-                );
+                if (shouldCaptureRecoveryHttpStatus(reconnectRes.status)) {
+                  captureChatClientError(
+                    lastReconnectError,
+                    "reconnect-current-response",
+                    {
+                      status: reconnectRes.status,
+                      hasBody: Boolean(reconnectRes.body),
+                      attempt,
+                    },
+                  );
+                }
                 reconnectErrorCaptured = true;
                 break;
               }
@@ -1610,11 +1616,13 @@ export function createAgentChatAdapter(
                 lastActiveRunError = new Error(
                   `Active run lookup failed: ${activeRes.status}`,
                 );
-                captureChatClientError(
-                  lastActiveRunError,
-                  "reconnect-active-response",
-                  { status: activeRes.status, attempt },
-                );
+                if (shouldCaptureRecoveryHttpStatus(activeRes.status)) {
+                  captureChatClientError(
+                    lastActiveRunError,
+                    "reconnect-active-response",
+                    { status: activeRes.status, attempt },
+                  );
+                }
                 return false;
               }
               const active = await activeRes.json();

package/corpus/core/src/client/session-replay.ts

@@ -630,6 +630,72 @@ function buildReplayBody(
   return `${envelopeJson.slice(0, -1)},"events":[${eventJsonParts.join(",")}]}`;
 }
 
+interface ReplayUploadBody {
+  body: BodyInit;
+  headers: Record<string, string>;
+  compressed: boolean;
+}
+
+async function gzipReplayBody(body: string): Promise<Blob | null> {
+  if (
+    typeof CompressionStream === "undefined" ||
+    typeof Blob === "undefined" ||
+    typeof Response === "undefined"
+  ) {
+    return null;
+  }
+  try {
+    const stream = new Blob([body], { type: "application/json" })
+      .stream()
+      .pipeThrough(new CompressionStream("gzip"));
+    const compressed = await new Response(stream).arrayBuffer();
+    return new Blob([compressed], { type: "application/json" });
+  } catch {
+    return null;
+  }
+}
+
+async function buildReplayUploadBody(body: string): Promise<ReplayUploadBody> {
+  const compressed = await gzipReplayBody(body);
+  if (compressed) {
+    return {
+      body: compressed,
+      compressed: true,
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Encoding": "gzip",
+      },
+    };
+  }
+  return {
+    body,
+    compressed: false,
+    headers: {
+      "Content-Type": "text/plain;charset=UTF-8",
+    },
+  };
+}
+
+async function sendReplayUpload(
+  options: NormalizedSessionReplayOptions,
+  body: string,
+): Promise<void> {
+  const upload = await buildReplayUploadBody(body);
+  if (!upload.compressed && navigator.sendBeacon) {
+    const sent = navigator.sendBeacon(options.endpoint, body);
+    if (sent) return;
+  }
+  await fetch(options.endpoint, {
+    method: "POST",
+    body: upload.body,
+    keepalive: true,
+    headers: {
+      ...upload.headers,
+      "X-Agent-Native-Analytics-Key": options.publicKey,
+    },
+  }).catch(() => {});
+}
+
 function isFinalFlushReason(reason: string): boolean {
   return [
     "manual",
@@ -649,19 +715,7 @@ export async function flushSessionReplay(reason = "manual"): Promise<void> {
   if (!body || !state.options) return;
   state.flushing = true;
   try {
-    if (navigator.sendBeacon) {
-      const sent = navigator.sendBeacon(state.options.endpoint, body);
-      if (sent) return;
-    }
-    await fetch(state.options.endpoint, {
-      method: "POST",
-      body,
-      keepalive: true,
-      headers: {
-        "Content-Type": "text/plain;charset=UTF-8",
-        "X-Agent-Native-Analytics-Key": state.options.publicKey,
-      },
-    }).catch(() => {});
+    await sendReplayUpload(state.options, body);
   } finally {
     state.flushing = false;
   }

package/corpus/core/src/onboarding/default-steps.ts

@@ -121,9 +121,9 @@ const llmStep: OnboardingStep = {
         await import("../server/credential-provider.js");
       if (await resolveHasCompleteBuilderConnection()) return true;
     } catch {
-      if (process.env.BUILDER_PRIVATE_KEY && process.env.BUILDER_PUBLIC_KEY) {
-        return true;
-      }
+      // Credential storage may be unavailable during early boot. Do not fall
+      // back to deployment-level Builder env here; the scoped resolver owns the
+      // policy for when that is safe.
     }
     try {
       if (await detectEngineFromUserSecrets()) return true;