@agent-native/core 0.98.9 → 0.98.11

package/corpus/README.md

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

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @agent-native/core
 
+## 0.98.11
+
+### Patch Changes
+
+- 3a4b613: Fall back to the portable A2A processor when a configured durable background worker rejects a task dispatch, and allow apps to explicitly opt out of stale deploy-wide background flags.
+- 3a4b613: Preserve structured payloads from read-only MCP actions so external agents can inspect detailed records and replay data directly.
+- 3a4b613: Preserve unset durable-background configuration and make A2A fallback dispatches reliable when the background worker is unavailable.
+
+## 0.98.10
+
+### Patch Changes
+
+- 079713c: Fall back to the portable A2A processor when a configured durable background worker rejects a task dispatch, and allow apps to explicitly opt out of stale deploy-wide background flags.
+- 079713c: Preserve structured payloads from read-only MCP actions so external agents can inspect detailed records and replay data directly.
+
 ## 0.98.9
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.98.9",
+  "version": "0.98.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/a2a/handlers.ts

@@ -41,6 +41,7 @@ import type {
 // transitive deps) into the a2a/handlers test boundary. Must stay in sync
 // with FRAMEWORK_ROUTE_PREFIX in `server/core-routes-plugin.ts`.
 const A2A_PROCESS_TASK_PATH = "/_agent-native/a2a/_process-task";
+const PORTABLE_FALLBACK_HANDOFF_TIMEOUT_MS = 1_000;
 const A2A_QUEUED_DISPATCH_STUCK_AFTER_MS = 10_000;
 const A2A_PROCESSING_STUCK_AFTER_MS = 5 * 60 * 1000;
 const A2A_PROCESSING_HEARTBEAT_MS = 30_000;
@@ -82,33 +83,57 @@ async function fireProcessTaskDispatch(
   event: any,
   taskId: string,
   config: A2AConfig,
-  options?: { awaitResponse?: boolean },
 ): Promise<void> {
   const backgroundPath = resolveAgentChatProcessRunDispatchPath();
   const useBackgroundWorker =
     isAgentChatDurableBackgroundEnabled({
-      appOptIn: config.durableBackgroundRuns === true,
+      appOptIn: config.durableBackgroundRuns,
     }) && dispatchPathTargetsNetlifyBackgroundFunction(backgroundPath);
 
-  await fireInternalDispatch({
-    event,
-    path: useBackgroundWorker ? backgroundPath : A2A_PROCESS_TASK_PATH,
-    taskId,
-    ...(useBackgroundWorker
-      ? {
-          body: {
-            [AGENT_BACKGROUND_PROCESSOR_FIELD]: AGENT_BACKGROUND_PROCESSOR_A2A,
-          },
-        }
-      : {}),
-    // Only Netlify's background-function URL acknowledges enqueue with 202.
-    // The portable framework route keeps its HTTP response open until the
-    // processor completes, so awaiting that response would turn async
-    // message/send into a long synchronous request (or a 15s timeout).
-    ...(options?.awaitResponse && useBackgroundWorker
-      ? { awaitResponse: true }
-      : {}),
-  });
+  if (!useBackgroundWorker) {
+    await fireInternalDispatch({
+      event,
+      path: A2A_PROCESS_TASK_PATH,
+      taskId,
+    });
+    return;
+  }
+
+  try {
+    // A real Netlify background function acknowledges the enqueue quickly.
+    // Await that acknowledgement so a missing or rejected worker can fall
+    // back before the task is left in `working` with no processor.
+    await fireInternalDispatch({
+      event,
+      path: backgroundPath,
+      taskId,
+      body: {
+        [AGENT_BACKGROUND_PROCESSOR_FIELD]: AGENT_BACKGROUND_PROCESSOR_A2A,
+      },
+      awaitResponse: true,
+    });
+  } catch (backgroundError) {
+    // Deploys can retain a runtime env opt-in after the corresponding
+    // background function was removed from the build. Keep async A2A useful
+    // in that state by falling back to the portable processor route, which
+    // runs in the regular framework function with the same task/auth checks.
+    console.error(
+      "[a2a] Durable background dispatch failed; falling back to portable processor:",
+      backgroundError,
+    );
+    await fireInternalDispatch({
+      event,
+      path: A2A_PROCESS_TASK_PATH,
+      taskId,
+      // The caller is about to return after a failed background handoff.
+      // Await the portable route briefly so the request definitely leaves this
+      // invocation, but do not hold async message/send open for the full agent
+      // run. The target processor continues independently after this bounded
+      // client-side timeout if the handler takes longer.
+      awaitResponse: true,
+      responseTimeoutMs: PORTABLE_FALLBACK_HANDOFF_TIMEOUT_MS,
+    });
+  }
 }
 
 /**
@@ -525,15 +550,11 @@ async function handleSend(
     // detached dispatch fetch racing only a short settle timer can be killed
     // mid-flight when the serverless response is flushed WITHOUT rejecting —
     // see the `awaitResponse` doc on `fireInternalDispatch` in
-    // server/self-dispatch.ts. `awaitResponse: true` requests the stronger
-    // guarantee; `fireProcessTaskDispatch` only honors it for the Netlify
-    // background-worker path (fast 202 ack) and falls back to the settle
-    // race for the portable route, which holds its response open until the
-    // handler finishes.
+    // server/self-dispatch.ts. The durable worker path gets a fast 202
+    // acknowledgement; a stale-worker fallback uses a short bounded timeout
+    // because the portable route responds after processing the task.
     try {
-      await fireProcessTaskDispatch(event, task.id, config, {
-        awaitResponse: true,
-      });
+      await fireProcessTaskDispatch(event, task.id, config);
     } catch (err) {
       console.error("[a2a] Failed to dispatch process-task:", err);
     }

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

@@ -351,6 +351,12 @@ function isFlagExplicitlyDisabled(): boolean {
 export function isAgentChatDurableBackgroundEnabled(options?: {
   appOptIn?: boolean;
 }): boolean {
+  // An app-level opt-out must win over a stale deploy-wide env flag. Netlify
+  // environment variables can outlive the source config that originally set
+  // them; allowing that flag to re-enable a worker an app explicitly disabled
+  // recreates the missing-background-function failure this gate is meant to
+  // prevent.
+  if (options?.appOptIn === false) return false;
   const envOptIn = isFlagEnabled();
   const workspaceAppOptIn =
     options?.appOptIn === true &&

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

@@ -5977,7 +5977,7 @@ export function createProductionAgentHandler(
     const dispatchToBackground =
       !isBackgroundWorker &&
       isAgentChatDurableBackgroundEnabled({
-        appOptIn: options.durableBackgroundRuns === true,
+        appOptIn: options.durableBackgroundRuns,
       });
     const requestBrowserTabId = normalizeBrowserTabId(browserTabId);
     const requestChatScope = normalizeChatScope(scope);
@@ -7181,7 +7181,7 @@ export function createProductionAgentHandler(
                   // function (40s clamp) here is the correct, safe target.
                   chainViaDurableBackground:
                     isAgentChatDurableBackgroundEnabled({
-                      appOptIn: options.durableBackgroundRuns === true,
+                      appOptIn: options.durableBackgroundRuns,
                     }) && !runsInBackgroundFunction,
                   // Only changes the retry BUDGET, never the dispatch target
                   // above: a worker proven in a real background function has
@@ -7269,7 +7269,7 @@ export function createProductionAgentHandler(
       isBackgroundWorker &&
       !runsInBackgroundFunction &&
       !isAgentChatDurableBackgroundEnabled({
-        appOptIn: options.durableBackgroundRuns === true,
+        appOptIn: options.durableBackgroundRuns,
       });
     const selfChainBudget = isSynchronousSelfChainContinuation
       ? resolveSelfChainContinuationBudget(

package/corpus/core/src/mcp/build-server.ts

@@ -566,12 +566,12 @@ function purgeEmbedStartUrls(
   if (Array.isArray(value)) {
     if (seen.has(value)) return "[circular result]";
     seen.add(value);
+    // An embed marker in one array item puts the whole result in the embed
+    // routing context. Credential fields in sibling items must not survive
+    // just because the marker lives elsewhere in the array.
+    const arrayEmbedContext = embedContext || containsEmbedRoutingSignal(value);
     const out = value.map((item) =>
-      purgeEmbedStartUrls(
-        item,
-        seen,
-        embedContext || containsEmbedRoutingSignal(item),
-      ),
+      purgeEmbedStartUrls(item, seen, arrayEmbedContext),
     );
     seen.delete(value);
     return out;
@@ -1770,6 +1770,14 @@ export async function createMCPServerForRequest(
           Array.isArray(toolVisibility) &&
           toolVisibility.length > 0 &&
           toolVisibility.every((v) => v === "app");
+        const readOnlyStructuredResult =
+          entry.readOnly === true &&
+          rawResultForClient &&
+          typeof rawResultForClient === "object"
+            ? Array.isArray(rawResultForClient)
+              ? { items: rawResultForClient }
+              : rawResultForClient
+            : undefined;
         const structuredContent = mcpAppResource
           ? mcpAppStructuredContent(rawResultForClient, responseMeta)
           : isAppOnlyVisibility &&
@@ -1777,11 +1785,8 @@ export async function createMCPServerForRequest(
               typeof rawResult === "object" &&
               !Array.isArray(rawResult)
             ? (rawResult as Record<string, unknown>)
-            : entry.readOnly === true &&
-                rawResult &&
-                typeof rawResult === "object" &&
-                !Array.isArray(rawResult)
-              ? mcpAppStructuredContent(rawResultForClient, responseMeta)
+            : readOnlyStructuredResult
+              ? mcpAppStructuredContent(readOnlyStructuredResult, responseMeta)
               : undefined;
         const text = mcpAppResource
           ? conciseMcpAppToolText(name, resultForClient, structuredContent!)

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

@@ -42,7 +42,9 @@ export interface AgentChatPluginOptions {
   /**
    * Opt this app into Netlify durable background-function agent-chat runs. This
    * gives hosted agent turns the 15-minute async-function budget when the app's
-   * Netlify build also emits the background function.
+   * Netlify build also emits the background function. Set this to `false` to
+   * explicitly disable a stale deploy-wide `AGENT_CHAT_DURABLE_BACKGROUND`
+   * flag for this app.
    */
   durableBackgroundRuns?: boolean;
   /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var */

package/corpus/templates/analytics/changelog/2026-07-13-incident-lookups-use-session-evidence.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-13
+---
+
+Analytics incident lookups now use first-party session, error, and replay evidence instead of incorrectly asking you to connect a data source.

package/corpus/templates/analytics/server/lib/real-data-actions.ts

@@ -16,6 +16,17 @@ export const DATA_QUERY_ACTIONS = new Set([
   "bigquery",
   "content-calendar",
   "content-calendar-schema",
+  // First-party observability reads are grounded data for incident triage,
+  // even though they are not provider queries. Keep the final-response guard
+  // from replacing valid session/error/replay evidence with the generic
+  // "connect a source" fallback.
+  "get-error-issue",
+  "get-session-replay-events",
+  "get-session-replay-summary",
+  "get-session-replay-timeline",
+  "list-error-issues",
+  "list-session-recordings",
+  "match-error-issues",
   "gcloud",
   "gong-calls",
   "grafana",

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

@@ -257,6 +257,10 @@ export default createAgentChatPlugin({
   // Operators deploying to trusted internal environments can set
   // AGENT_PROD_CODE_EXECUTION=trusted to also enable bash/read/edit/write.
   codeExecution: { production: "sandboxed" },
+  // Analytics uses the portable A2A processor until its dedicated background
+  // worker is verified live. This explicit opt-out also protects production
+  // from a stale deploy-wide AGENT_CHAT_DURABLE_BACKGROUND flag.
+  durableBackgroundRuns: false,
   connectorCatalog: [...ANALYTICS_CONNECTOR_CATALOG],
   externalAgents: {
     // Keep the direct MCP surface deliberately curated. External agents

package/dist/a2a/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/a2a/handlers.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EACV,SAAS,EAIT,eAAe,EAGhB,MAAM,YAAY,CAAC;AA4EpB;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,GAAG,GACV,OAAO,CAAC,IAAI,CAAC,CAwEf;AAsqBD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,eAAe,CAAC,CAyC1B"}
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/a2a/handlers.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EACV,SAAS,EAIT,eAAe,EAGhB,MAAM,YAAY,CAAC;AAqGpB;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,GAAG,GACV,OAAO,CAAC,IAAI,CAAC,CAwEf;AAkqBD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,eAAe,CAAC,CAyC1B"}

package/dist/a2a/handlers.js

@@ -9,6 +9,7 @@ import { createTask, getTask, getTaskOwner, updateTask, claimA2ATaskForProcessin
 // transitive deps) into the a2a/handlers test boundary. Must stay in sync
 // with FRAMEWORK_ROUTE_PREFIX in `server/core-routes-plugin.ts`.
 const A2A_PROCESS_TASK_PATH = "/_agent-native/a2a/_process-task";
+const PORTABLE_FALLBACK_HANDOFF_TIMEOUT_MS = 1_000;
 const A2A_QUEUED_DISPATCH_STUCK_AFTER_MS = 10_000;
 const A2A_PROCESSING_STUCK_AFTER_MS = 5 * 60 * 1000;
 const A2A_PROCESSING_HEARTBEAT_MS = 30_000;
@@ -45,30 +46,52 @@ function a2aProcessingLifetimeMaxMs() {
  * into durable background runs reuse the emitted Netlify 15-minute worker;
  * other hosts and apps retain the normal portable self-webhook route.
  */
-async function fireProcessTaskDispatch(event, taskId, config, options) {
+async function fireProcessTaskDispatch(event, taskId, config) {
     const backgroundPath = resolveAgentChatProcessRunDispatchPath();
     const useBackgroundWorker = isAgentChatDurableBackgroundEnabled({
-        appOptIn: config.durableBackgroundRuns === true,
+        appOptIn: config.durableBackgroundRuns,
     }) && dispatchPathTargetsNetlifyBackgroundFunction(backgroundPath);
-    await fireInternalDispatch({
-        event,
-        path: useBackgroundWorker ? backgroundPath : A2A_PROCESS_TASK_PATH,
-        taskId,
-        ...(useBackgroundWorker
-            ? {
-                body: {
-                    [AGENT_BACKGROUND_PROCESSOR_FIELD]: AGENT_BACKGROUND_PROCESSOR_A2A,
-                },
-            }
-            : {}),
-        // Only Netlify's background-function URL acknowledges enqueue with 202.
-        // The portable framework route keeps its HTTP response open until the
-        // processor completes, so awaiting that response would turn async
-        // message/send into a long synchronous request (or a 15s timeout).
-        ...(options?.awaitResponse && useBackgroundWorker
-            ? { awaitResponse: true }
-            : {}),
-    });
+    if (!useBackgroundWorker) {
+        await fireInternalDispatch({
+            event,
+            path: A2A_PROCESS_TASK_PATH,
+            taskId,
+        });
+        return;
+    }
+    try {
+        // A real Netlify background function acknowledges the enqueue quickly.
+        // Await that acknowledgement so a missing or rejected worker can fall
+        // back before the task is left in `working` with no processor.
+        await fireInternalDispatch({
+            event,
+            path: backgroundPath,
+            taskId,
+            body: {
+                [AGENT_BACKGROUND_PROCESSOR_FIELD]: AGENT_BACKGROUND_PROCESSOR_A2A,
+            },
+            awaitResponse: true,
+        });
+    }
+    catch (backgroundError) {
+        // Deploys can retain a runtime env opt-in after the corresponding
+        // background function was removed from the build. Keep async A2A useful
+        // in that state by falling back to the portable processor route, which
+        // runs in the regular framework function with the same task/auth checks.
+        console.error("[a2a] Durable background dispatch failed; falling back to portable processor:", backgroundError);
+        await fireInternalDispatch({
+            event,
+            path: A2A_PROCESS_TASK_PATH,
+            taskId,
+            // The caller is about to return after a failed background handoff.
+            // Await the portable route briefly so the request definitely leaves this
+            // invocation, but do not hold async message/send open for the full agent
+            // run. The target processor continues independently after this bounded
+            // client-side timeout if the handler takes longer.
+            awaitResponse: true,
+            responseTimeoutMs: PORTABLE_FALLBACK_HANDOFF_TIMEOUT_MS,
+        });
+    }
 }
 /**
  * Process a previously-enqueued A2A task. Called by the `_process-task`
@@ -369,15 +392,11 @@ async function handleSend(params, config, event) {
         // detached dispatch fetch racing only a short settle timer can be killed
         // mid-flight when the serverless response is flushed WITHOUT rejecting —
         // see the `awaitResponse` doc on `fireInternalDispatch` in
-        // server/self-dispatch.ts. `awaitResponse: true` requests the stronger
-        // guarantee; `fireProcessTaskDispatch` only honors it for the Netlify
-        // background-worker path (fast 202 ack) and falls back to the settle
-        // race for the portable route, which holds its response open until the
-        // handler finishes.
+        // server/self-dispatch.ts. The durable worker path gets a fast 202
+        // acknowledgement; a stale-worker fallback uses a short bounded timeout
+        // because the portable route responds after processing the task.
         try {
-            await fireProcessTaskDispatch(event, task.id, config, {
-                awaitResponse: true,
-            });
+            await fireProcessTaskDispatch(event, task.id, config);
         }
         catch (err) {
             console.error("[a2a] Failed to dispatch process-task:", err);