@agent-native/core 0.79.7 → 0.79.10

package/corpus/README.md

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

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @agent-native/core
 
+## 0.79.10
+
+### Patch Changes
+
+- 7e19ed6: Return plain string action results with a JSON content type so browser action clients can parse successful responses.
+
+## 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

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.79.7",
+  "version": "0.79.10",
   "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/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;

package/corpus/core/src/server/action-routes.ts

@@ -356,12 +356,16 @@ export function mountActionRoutes(
                 }
               }
 
-              // If the action returned a string, try to parse as JSON for a clean response
+              // If the action returned a string, try to parse as JSON for a
+              // clean response. Plain strings still need to go over the HTTP
+              // action transport as JSON, otherwise H3 sends text/plain and the
+              // browser action client rejects the successful 2xx response.
               if (typeof result === "string") {
                 try {
                   return JSON.parse(result);
                 } catch {
-                  return result;
+                  setResponseHeader(event, "Content-Type", "application/json");
+                  return JSON.stringify(result);
                 }
               }
 

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -147,6 +147,12 @@ import {
 import { dbExecToolParameters } from "../scripts/db/tool-schemas.js";
 import { getSetting, putSetting } from "../settings/store.js";
 import { discoverAgents } from "./agent-discovery.js";
+import {
+  resolveAgentRunOwnerContext,
+  runWithAgentRunContext,
+  seedBackgroundAgentRunOwnerContext,
+  type AgentRunOwnerContext,
+} from "./agent-run-context.js";
 import {
   AGENT_TEAM_PROCESS_RUN_PATH,
   getCurrentDelegationDepth,
@@ -159,6 +165,7 @@ import {
   getBuilderBrowserConnectUrlForOwner,
   resolveBuilderBranchProjectId,
 } from "./builder-browser.js";
+import { captureError } from "./capture-error.js";
 import { captureCliOutput } from "./cli-capture.js";
 import {
   getH3App,
@@ -871,14 +878,51 @@ export function assembleA2AFinalResponse(
   toolResults: readonly A2AToolResultSummary[],
   options: A2AArtifactResponseOptions & { event?: any } = {},
 ): { responseText: string; finalText: string } {
-  const responseText = collectFinalResponseTextFromAgentEvents(events);
+  const terminalError = getA2ATerminalErrorEvent(events);
+  const responseText = collectFinalResponseTextFromAgentEvents(events, {
+    fallbackToPreToolText: !terminalError,
+  });
   const finalText = appendA2AArtifactLinks(responseText, [...toolResults], {
     baseUrl: options.baseUrl ?? resolveArtifactBaseUrl(options.event),
     includeReferencedArtifacts: true,
   });
+  if (terminalError && !finalText.trim()) {
+    throw new Error(formatA2ATerminalError(terminalError));
+  }
   return { responseText, finalText };
 }
 
+function getA2ATerminalErrorEvent(
+  events: readonly AgentChatEvent[],
+): Extract<AgentChatEvent, { type: "error" }> | null {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type === "clear") continue;
+    if (event.type === "done") return null;
+    if (event.type === "error") return event;
+    if (event.type === "auto_continue") {
+      return {
+        type: "error",
+        error: `Agent stopped before finishing (${event.reason}).`,
+        errorCode: event.reason,
+        recoverable: true,
+      };
+    }
+  }
+  return null;
+}
+
+function formatA2ATerminalError(
+  event: Extract<AgentChatEvent, { type: "error" }>,
+): string {
+  const parts = [
+    event.error || "Agent failed before producing a final response.",
+    event.errorCode ? `code: ${event.errorCode}` : "",
+    event.details ? `details: ${event.details}` : "",
+  ].filter(Boolean);
+  return parts.join("\n");
+}
+
 /**
  * Creates the `get-framework-context` tool. Returns detailed instructions
  * for framework capabilities that are summarized in the compact prompt.
@@ -3052,6 +3096,8 @@ In Act mode, if the user asks for generated interactive UI in chat, choose the s
 
 These are **NOT** source-code changes and do **NOT** go through \`connect-builder\`. Extensions are sandboxed mini-apps — no source files are touched, no PR is opened, no build is required. Saved extensions can be edited later via \`update-extension\`.
 
+If the app exposes native actions or instructions for dashboards, reports, analyses, charts, documents, decks, or other domain artifacts, use those app-native actions first. Choose an extension only when the user explicitly asks for an extension/custom mini-app, or when the app's native artifact format cannot faithfully express the requested interaction.
+
 Keep \`create-extension\` payloads compact enough to finish quickly. For complex extensions, create a useful working v1 first, then call \`update-extension\` with focused edits for refinements instead of trying to assemble one enormous initial tool input.
 
 Generated UI content can use appAction(), appFetch(), dbQuery(), dbExec(), extensionFetch(), extensionData, agentNative.ui.output(value, opts?), and agentNative.chat.send(...)/sendToAgentChat(...). It can receive chat inputs through slotContext/window.onSlotContext. Use agentNative.ui.output for passive current values from knobs, sliders, selections, and controls; it writes application state at \`inline-ui:<extensionId>:output\` scoped to the inline extension id returned by \`render-inline-extension\` or \`show-extension-inline\`. When the user later says "use that value", "apply the current setting", or similar, read it with \`readAppState("inline-ui:<id>:output")\` instead of asking them to send it again. Use agentNative.chat.send for visible submit/apply actions that should put a message into chat. Transient extensionData is browser-local and not agent-readable, synced, promoted, or garbage-collected; use application_state/appFetch, appAction, ui.output, or chat.send for anything the agent or app must observe. Use semantic Tailwind classes like bg-background, text-foreground, bg-primary, border-border, and text-muted-foreground so the UI inherits the parent app theme.
@@ -3079,7 +3125,7 @@ Route by what the request changes, not how it is phrased. Extensions render in t
 | Ambiguous, satisfiable either way (e.g. "give me an unread view") | \`render-inline-extension\` for chat-only, \`create-extension\` for reusable |
 </routing>
 
-Worked examples: "a widget showing unread emails grouped by sender", "a dashboard summarizing my pipeline", "a tracker for my newsletter subscriptions" → \`create-extension\`. "Add an Unread tab to the left navigation", "make the subject lines wrap", "change the inbox grouping logic", "add a field to the compose form" → \`connect-builder\`.`
+Worked examples: "a widget showing unread emails grouped by sender", "a tracker for my newsletter subscriptions", "a custom kanban board with drag-and-drop rules the app does not have" → \`create-extension\`. "Add an Unread tab to the left navigation", "make the subject lines wrap", "change the inbox grouping logic", "add a field to the compose form" → \`connect-builder\`.`
     : `### Extensions Disabled
 
 Extension creation and management tools are disabled for this app. Do not claim you can create, edit, hide, or delete Agent-Native extensions unless the template exposes its own typed action for that workflow. For requests that would otherwise be handled as an extension/widget/dashboard/calculator mini-app, explain that this app has disabled extension tools and use the app's available actions instead.`;
@@ -3088,6 +3134,8 @@ Extension creation and management tools are disabled for this app. Do not claim
 
 In Act mode, if the user asks for generated interactive UI in chat, call \`render-inline-extension\` for one-time inline controls/knobs/calculators/visualizers that do not need saving. If the user asks for an **extension**, **widget**, **dashboard**, **calculator**, or **mini-app** that should be reusable or saved, call \`create-extension\` with a self-contained Alpine.js HTML body. To load a saved extension inline, call \`show-extension-inline\`. These are NOT code changes — extensions are sandboxed mini-apps. Do not preface with "let me build…" — just call the right extension action.
 
+Use app-native artifact actions first when they exist for dashboards, reports, analyses, charts, documents, decks, or similar domain artifacts. Pick \`create-extension\` only for explicit extension/custom mini-app requests or for behavior the native artifact format cannot support.
+
 Keep the first \`create-extension\` call compact and working. If the request is complex, create the v1 first and then refine with focused \`update-extension\` edits.
 
 Generated UI can read chat inputs from slotContext/window.onSlotContext, see/update app state through appFetch/appAction, use extensionData, record passive current values through agentNative.ui.output(value, opts?), and send visible results through agentNative.chat.send(...) or sendToAgentChat(...). ui.output writes \`inline-ui:<extensionId>:output\` in application state; when the user asks to use the current slider/selection/value, read \`readAppState("inline-ui:<id>:output")\`. Transient extensionData is browser-local only, so do not rely on it for values the agent or app must observe. Use semantic Tailwind theme classes.
@@ -4994,45 +5042,13 @@ export function createAgentChatPlugin(
         });
       }
 
-      type OwnerContext = {
-        owner: string;
-        anonymous: boolean;
-        name?: string;
-      };
-      const OWNER_CONTEXT_KEY = "__agentNativeOwnerContext";
-
       // Resolve owner from the H3 event's session, with an optional
       // template-provided anonymous owner for public read-only surfaces.
-      const resolveOwnerContext = async (event: any): Promise<OwnerContext> => {
-        const eventContext = event?.context as
-          | (Record<string, unknown> & { [OWNER_CONTEXT_KEY]?: OwnerContext })
-          | undefined;
-        if (eventContext?.[OWNER_CONTEXT_KEY]) {
-          return eventContext[OWNER_CONTEXT_KEY];
-        }
-
-        const session = await getSession(event);
-        if (session?.email) {
-          const resolved = {
-            owner: session.email,
-            anonymous: false,
-            name: session.name,
-          };
-          if (eventContext) eventContext[OWNER_CONTEXT_KEY] = resolved;
-          return resolved;
-        }
-
-        const anonymousOwner = await options?.anonymousOwner?.(event);
-        if (anonymousOwner) {
-          const resolved = { owner: anonymousOwner, anonymous: true };
-          if (eventContext) eventContext[OWNER_CONTEXT_KEY] = resolved;
-          return resolved;
-        }
-
-        const { createError } = await import("h3");
-        throw createError({
-          statusCode: 401,
-          statusMessage: "Unauthenticated",
+      const resolveOwnerContext = async (
+        event: any,
+      ): Promise<AgentRunOwnerContext> => {
+        return resolveAgentRunOwnerContext(event, {
+          anonymousOwner: options?.anonymousOwner,
         });
       };
 
@@ -7749,92 +7765,17 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
       // the background worker), so both go through identical context + handler
       // selection.
       const invokeAgentChatHandler = async (event: any) => {
-        // Resolve per-request auth context
+        // Resolve per-request auth context.
         const ownerContext = await resolveOwnerContext(event);
-        const owner = ownerContext.owner;
-
-        // Resolve org ID: explicit callback > session.orgId from Better Auth
-        // > implicit org membership. Better Auth leaves session.orgId null
-        // until the user explicitly switches orgs, so a fresh signup with
-        // implicit membership (e.g. domain-matched org) would otherwise see
-        // no org-scoped credentials. getOrgContext() does the same DB lookup
-        // the /builder/status endpoint uses to decide "Connected".
-        let resolvedOrgId: string | undefined;
-        if (options?.resolveOrgId) {
-          resolvedOrgId = (await options.resolveOrgId(event)) ?? undefined;
-        } else {
-          try {
-            const session = await getSession(event);
-            resolvedOrgId = session?.orgId ?? undefined;
-          } catch {
-            // Session not available
-          }
-          if (!resolvedOrgId) {
-            try {
-              const { getOrgContext } = await import("../org/context.js");
-              const ctx = await getOrgContext(event);
-              resolvedOrgId = ctx.orgId ?? undefined;
-            } catch {
-              // org_members table may not exist yet on first boot
-            }
-          }
-        }
-        // Cookieless durable background worker: getSession()/getOrgContext()
-        // resolve from the (absent) session, so org-scoped credential resolution
-        // (the Builder engine) would miss the owner's org and resolveEngine would
-        // fall back to the anthropic default — bailing on a missing key before
-        // the worker claims its run. The owner IS known here (seeded via
-        // OWNER_CONTEXT_KEY from the run's thread), so resolve the org directly
-        // from the owner email, the same active-org logic the foreground session
-        // would yield.
-        if (!resolvedOrgId && owner) {
-          try {
-            const { resolveOrgIdForEmail } = await import("../org/context.js");
-            resolvedOrgId = (await resolveOrgIdForEmail(owner)) ?? undefined;
-          } catch {
-            // org tables unavailable — proceed without org (foreground-equivalent)
-          }
-        }
-
-        // DURABLE OWNER CONTEXT, PART 2: ORG.
-        // The cookieless `_process-run` self-dispatch (and any other background
-        // re-entry) resolves the owner from the run row, but has NO session —
-        // every org resolver above ultimately derives identity from
-        // getSession(event), so they all come back null here. That silently
-        // scopes the agent to `org_id IS NULL` rows only: it sees and writes
-        // resources outside the user's org, while the foreground UI — which
-        // carries the session cookie — resolves the real org. The result is the
-        // observed split where the agent can't list/read the same resources the
-        // UI shows and writes new rows with a null org. Resolve the org from the
-        // now-known owner email (the same active-org / membership logic
-        // getOrgContext uses, minus the session) so the agent and the UI operate
-        // over the same org-scoped data.
-        if (!resolvedOrgId && owner && !ownerContext.anonymous) {
-          try {
-            const { resolveOrgIdForEmail } = await import("../org/context.js");
-            resolvedOrgId = (await resolveOrgIdForEmail(owner)) ?? undefined;
-          } catch {
-            // org tables unavailable (first boot) — leave org unscoped
-          }
-        }
 
-        // Propagate the caller's IANA timezone from `x-user-timezone` so that
-        // tool calls made by the agent (e.g. log-meal with no explicit date)
-        // resolve "today" in the user's local timezone instead of server UTC.
-        const tzRaw = getHeader(event, "x-user-timezone");
-        const timezone =
-          typeof tzRaw === "string" &&
-          tzRaw.trim().length > 0 &&
-          tzRaw.trim().length < 64
-            ? tzRaw.trim()
-            : undefined;
-
-        return runWithRequestContext(
+        return runWithAgentRunContext(
           {
-            userEmail: owner,
-            userName: ownerContext.name,
-            orgId: resolvedOrgId,
-            timezone,
+            event,
+            ownerContext,
+            resolveOrgId: options?.resolveOrgId,
+            isBackgroundWorker: Boolean(
+              (event as any).context?.__agentChatBackgroundBody,
+            ),
           },
           () => {
             // App-rendered chat can't host direct code edits — HMR/full
@@ -7949,50 +7890,29 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
           (event as any).context = (event as any).context ?? {};
           (event as any).context.__agentChatBackgroundBody = prepared.body;
 
-          // DURABLE OWNER CONTEXT: this self-dispatch is cookieless (HMAC-only —
-          // the foreground POST carried the user's session, but this background-
-          // function invocation does not). Without a session, resolveOwnerContext()
-          // falls through to its 401 "Unauthenticated" throw and the worker dies
-          // before it can even claim the run (observed in prod as the `route_threw`
-          // diag stage — every durable run only completed via the foreground
-          // circuit-breaker's inline recovery). The run's chat thread already
-          // records the authenticated owner (written by the foreground under the
-          // signed-in user), so resolve the owner from the run row — NOT from the
-          // request body, which the HMAC does not cover and a caller could forge —
-          // and pre-seed the owner context the handler reads (resolveOwnerContext
-          // returns it before attempting any session lookup).
-          let backgroundOwner: string | null = null;
-          try {
-            const { getRunOwnerEmail } = await import("../agent/run-store.js");
-            backgroundOwner = await getRunOwnerEmail(prepared.runId);
-            if (backgroundOwner) {
-              (event as any).context[OWNER_CONTEXT_KEY] = {
-                owner: backgroundOwner,
-                anonymous: false,
-              };
-            }
-          } catch {
-            // Best-effort: if the lookup fails, resolveOwnerContext runs as before
-            // and throws its normal 401, surfaced via the route_threw diagnostic.
-          }
+          // Durable owner context: this self-dispatch is cookieless (HMAC-only).
+          // Resolve the owner from the persisted run row, never the request body,
+          // then invoke the normal handler. The shared agent-run context helper
+          // expands that owner into the same user/org AsyncLocalStorage context the
+          // foreground request uses, so credential and data scoping stay aligned.
+          await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
 
           try {
-            // Run the worker INSIDE the owner's AsyncLocalStorage request context.
-            // Seeding OWNER_CONTEXT_KEY (above) only feeds getOwnerFromEvent; the
-            // engine-resolution path (detectEngineFromUserSecrets) and other
-            // owner-scoped reads use getRequestUserEmail()/getRequestOrgId(),
-            // which a cookieless background worker otherwise leaves empty. Without
-            // this, resolveEngine can't see the owner's Builder credential, falls
-            // back to the anthropic default, and — when the owner has no stored
-            // anthropic key and deploy-credential fallback is blocked — bails at
-            // the API-key check BEFORE claiming its run (the analytics durable
-            // worker's "stalls at post_model, never claims" bug).
-            const invoke = () => invokeAgentChatHandler(event);
-            return await (backgroundOwner
-              ? runWithRequestContext({ userEmail: backgroundOwner }, invoke)
-              : invoke());
+            return await invokeAgentChatHandler(event);
           } catch (err: any) {
             console.error("[agent-chat] _process-run failed:", err);
+            captureError(err, {
+              route: AGENT_CHAT_PROCESS_RUN_PATH,
+              method: getMethod(event),
+              userAgent: getHeader(event, "user-agent"),
+              tags: {
+                source: "agent-chat-bg-worker",
+                phase: "process-run",
+              },
+              extra: {
+                runId: prepared.runId,
+              },
+            });
             // DIAGNOSTIC: the worker invocation threw at the route boundary —
             // record the message so the failure cause is readable client-side.
             if (diag) {