@agent-native/core 0.98.4 → 0.98.6

package/corpus/core/docs/content/tracking.mdx

@@ -237,6 +237,8 @@ Privacy defaults are intentionally conservative but still useful for playback:
 - URLs are scrubbed with the same `scrubUrl()` helper used by browser analytics.
 - Replay capture is web-only and opt-in; it does not record native desktop screens.
 
+Framework-owned iframes, including extensions and rendered email content, are included in replay capture. The same masking and blocking selectors apply inside recorded frames. A third-party cross-origin iframe remains opaque unless its own document runs a compatible rrweb recorder with cross-origin iframe recording enabled; browser origin boundaries cannot be bypassed from the parent page.
+
 While recording, session replay also captures browser console output (`log`, `info`, `warn`, `error`, `debug`, plus window `error` / `unhandledrejection`) and network request metadata (`fetch` and XHR) as tagged rrweb custom events, so agents and the replay viewer can debug user-reported issues. Capture is on by default when replay is enabled; tune or disable it with the `sessionReplay.console` and `sessionReplay.network` options, each accepting a boolean or an options object (`{ maxEvents?: number }`, with `network` additionally accepting `captureErrorBodies` and `maxErrorBodyLength`). Request bodies and headers are never captured; response bodies are captured only as a bounded, redacted snippet for 5xx (server error) responses (`captureErrorBodies`, default true, capped at `maxErrorBodyLength` chars, default 2048) — non-5xx and network-failure responses never carry a body. URLs are scrubbed, messages are truncated, the recorder's own ingest/tracking traffic is excluded, and per-session budgets (1000 console / 2000 network events) add a truncation notice when exceeded.
 
 The Analytics template stores replay metadata in SQL (`session_recordings`) and stores chunks through private blob refs (`session_replay_chunks`). Browsers and agents never receive provider URLs. Playback goes through scoped server routes and the default agent tools return summaries or bounded replay events, not raw chunk table access.

package/corpus/core/package.json

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

@@ -22,6 +22,7 @@ import {
   claimA2ATaskForProcessing,
   getA2ATaskDispatchState,
   failStuckA2ATask,
+  failStuckQueuedA2ATask,
   touchQueuedA2ATaskDispatch,
   touchProcessingA2ATask,
 } from "./task-store.js";
@@ -43,6 +44,34 @@ 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;
 
+/**
+ * Hard cap on how long a task may sit in submitted/working (never reaching
+ * `processing`) before the dispatch-retry loop in
+ * `refireStuckAsyncTaskIfNeeded` gives up and fails it. Without this, a
+ * persistently failing dispatch (missing background function, bad A2A
+ * secret, 404) throttles-and-retries forever — the queued bucket otherwise
+ * has no terminal state. Override with A2A_QUEUED_LIFETIME_MAX_MS.
+ */
+function a2aQueuedLifetimeMaxMs(): number {
+  const raw = Number(process.env.A2A_QUEUED_LIFETIME_MAX_MS);
+  if (Number.isFinite(raw) && raw > 0) return raw;
+  return 3 * 60 * 1000;
+}
+
+/**
+ * Hard cap on total time a task may spend in `processing`, independent of
+ * the liveness heartbeat. `A2A_PROCESSING_STUCK_AFTER_MS` alone only catches
+ * a dead process — a hung await inside a still-alive process keeps
+ * `updated_at` fresh via the heartbeat forever. This bounds that case
+ * without cutting off legitimately long runs under it. Override with
+ * A2A_PROCESSING_LIFETIME_MAX_MS.
+ */
+function a2aProcessingLifetimeMaxMs(): number {
+  const raw = Number(process.env.A2A_PROCESSING_LIFETIME_MAX_MS);
+  if (Number.isFinite(raw) && raw > 0) return raw;
+  return 30 * 60 * 1000;
+}
+
 /**
  * Dispatch an async A2A task to a fresh function execution. Apps that opted
  * into durable background runs reuse the emitted Netlify 15-minute worker;
@@ -52,6 +81,7 @@ async function fireProcessTaskDispatch(
   event: any,
   taskId: string,
   config: A2AConfig,
+  options?: { awaitResponse?: boolean },
 ): Promise<void> {
   const backgroundPath = resolveAgentChatProcessRunDispatchPath();
   const useBackgroundWorker =
@@ -70,6 +100,13 @@ async function fireProcessTaskDispatch(
           },
         }
       : {}),
+    // 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 }
+      : {}),
   });
 }
 
@@ -483,9 +520,22 @@ async function handleSend(
     );
     const working = await updateTask(task.id, { state: "working" });
 
-    fireProcessTaskDispatch(event, task.id, config).catch((err) => {
+    // Awaited, not fire-and-forget: this handler is about to return, and a
+    // 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.
+    try {
+      await fireProcessTaskDispatch(event, task.id, config, {
+        awaitResponse: true,
+      });
+    } catch (err) {
       console.error("[a2a] Failed to dispatch process-task:", err);
-    });
+    }
 
     return { ...jsonRpcResult(0, working ?? task), _id: 0 };
   }
@@ -750,30 +800,54 @@ async function refireStuckAsyncTaskIfNeeded(
   if (!state.metadata?.__a2a_processor) return false;
 
   const now = Date.now();
-  if (
-    (state.statusState === "submitted" || state.statusState === "working") &&
-    state.updatedAt <= now - A2A_QUEUED_DISPATCH_STUCK_AFTER_MS
-  ) {
-    if (await touchQueuedA2ATaskDispatch(taskId)) {
-      await fireProcessTaskDispatch(event, taskId, config);
+
+  if (state.statusState === "submitted" || state.statusState === "working") {
+    const queuedLifetimeCutoff = now - a2aQueuedLifetimeMaxMs();
+    if (state.createdAt <= queuedLifetimeCutoff) {
+      // Dispatch has kept failing (or was never delivered) long enough that
+      // retrying further would just repeat the same failure forever — stop
+      // refiring and surface a terminal error instead of throttling forever.
+      return failStuckQueuedA2ATask(
+        taskId,
+        queuedLifetimeCutoff,
+        "The async A2A task could not be started because dispatch kept failing. Please retry the request.",
+      );
+    }
+
+    if (state.updatedAt <= now - A2A_QUEUED_DISPATCH_STUCK_AFTER_MS) {
+      if (!(await touchQueuedA2ATaskDispatch(taskId))) return false;
+      try {
+        await fireProcessTaskDispatch(event, taskId, config);
+      } catch (err) {
+        console.error(
+          "[a2a] Failed to refire stuck queued task dispatch:",
+          err,
+        );
+        return false;
+      }
       return true;
     }
     return false;
   }
 
-  if (
-    state.statusState === "processing" &&
-    state.updatedAt <= now - A2A_PROCESSING_STUCK_AFTER_MS
-  ) {
-    // A processor that died mid-handler may have already performed
-    // side-effectful work. Retrying from the top can duplicate artifacts, so
-    // fail deterministically and let the caller issue an intentional retry.
-    const failed = await failStuckA2ATask(
-      taskId,
-      now - A2A_PROCESSING_STUCK_AFTER_MS,
-      "The async A2A processor timed out before completing. Please retry the request.",
-    );
-    return failed;
+  if (state.statusState === "processing") {
+    const processingStuckCutoff = now - A2A_PROCESSING_STUCK_AFTER_MS;
+    const processingLifetimeCutoff = now - a2aProcessingLifetimeMaxMs();
+    const isStale = state.updatedAt <= processingStuckCutoff;
+    const isOverLifetime = state.createdAt <= processingLifetimeCutoff;
+    if (isStale || isOverLifetime) {
+      // A processor that died mid-handler may have already performed
+      // side-effectful work. Retrying from the top can duplicate artifacts, so
+      // fail deterministically and let the caller issue an intentional retry.
+      return failStuckA2ATask(
+        taskId,
+        processingStuckCutoff,
+        isStale
+          ? "The async A2A processor timed out before completing. Please retry the request."
+          : "The async A2A processor exceeded its maximum run time. Please retry the request.",
+        processingLifetimeCutoff,
+      );
+    }
   }
 
   return false;

package/corpus/core/src/a2a/task-store.ts

@@ -200,11 +200,12 @@ export async function getA2ATaskDispatchState(id: string): Promise<{
   statusState: string;
   metadata: Record<string, unknown> | undefined;
   updatedAt: number;
+  createdAt: number;
 } | null> {
   await ensureTable();
   const client = getDbExec();
   const { rows } = await client.execute({
-    sql: `SELECT id, status_state, metadata, updated_at FROM a2a_tasks WHERE id = ?`,
+    sql: `SELECT id, status_state, metadata, created_at, updated_at FROM a2a_tasks WHERE id = ?`,
     args: [id],
   });
   const row = rows[0] as any;
@@ -214,6 +215,7 @@ export async function getA2ATaskDispatchState(id: string): Promise<{
     statusState: row.status_state as string,
     metadata: row.metadata ? JSON.parse(row.metadata as string) : undefined,
     updatedAt: Number(row.updated_at ?? 0),
+    createdAt: Number(row.created_at ?? 0),
   };
 }
 
@@ -269,10 +271,21 @@ export async function resetStuckA2ATaskForRetry(
   return affected !== 0;
 }
 
+/**
+ * Fail a processing task once it is stuck. Two independent conditions can
+ * trigger this, either of which alone is sufficient:
+ *   - `updated_at <= processingCutoff`: no heartbeat/progress touch in a
+ *     while — the processor likely died.
+ *   - `created_at <= createdAtCutoff` — a hard wall on total run time. A
+ *     hung await inside a still-alive process keeps `updated_at` fresh via
+ *     the liveness heartbeat forever, so staleness alone never trips; age
+ *     since creation is the only bound that catches it.
+ */
 export async function failStuckA2ATask(
   id: string,
   processingCutoff: number,
   reason: string,
+  createdAtCutoff?: number,
 ): Promise<boolean> {
   await ensureTable();
   const client = getDbExec();
@@ -282,6 +295,10 @@ export async function failStuckA2ATask(
     role: "agent",
     parts: [{ type: "text", text: reason }],
   };
+  const ageCondition =
+    createdAtCutoff !== undefined
+      ? `AND (updated_at <= ? OR created_at <= ?)`
+      : `AND updated_at <= ?`;
   const result = await client.execute({
     sql: `UPDATE a2a_tasks
             SET status_state = 'failed',
@@ -290,8 +307,53 @@ export async function failStuckA2ATask(
                 updated_at = ?
           WHERE id = ?
             AND status_state = 'processing'
-            AND updated_at <= ?`,
-    args: [JSON.stringify(message), timestamp, now, id, processingCutoff],
+            ${ageCondition}`,
+    args:
+      createdAtCutoff !== undefined
+        ? [
+            JSON.stringify(message),
+            timestamp,
+            now,
+            id,
+            processingCutoff,
+            createdAtCutoff,
+          ]
+        : [JSON.stringify(message), timestamp, now, id, processingCutoff],
+  });
+  const affected = getAffectedRowCount(result);
+  return affected !== 0;
+}
+
+/**
+ * Fail a queued (submitted/working) task whose age since creation exceeds
+ * `createdAtCutoff` — the dispatch-retry loop kept throttling/refiring
+ * without ever reaching `processing`. Mirrors `failStuckA2ATask` but is
+ * gated on the queued state set and on `created_at` (queued tasks have no
+ * heartbeat, so staleness of `updated_at` isn't a meaningful signal here).
+ */
+export async function failStuckQueuedA2ATask(
+  id: string,
+  createdAtCutoff: number,
+  reason: string,
+): Promise<boolean> {
+  await ensureTable();
+  const client = getDbExec();
+  const now = Date.now();
+  const timestamp = new Date().toISOString();
+  const message: Message = {
+    role: "agent",
+    parts: [{ type: "text", text: reason }],
+  };
+  const result = await client.execute({
+    sql: `UPDATE a2a_tasks
+            SET status_state = 'failed',
+                status_message = ?,
+                status_timestamp = ?,
+                updated_at = ?
+          WHERE id = ?
+            AND status_state IN ('submitted', 'working')
+            AND created_at <= ?`,
+    args: [JSON.stringify(message), timestamp, now, id, createdAtCutoff],
   });
   const affected = getAffectedRowCount(result);
   return affected !== 0;

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

@@ -364,17 +364,18 @@ export function isAgentChatDurableBackgroundEnabled(options?: {
 }
 
 /**
- * Env flag for the FOREGROUND server-driven self-chain. DEFAULT-ON for hosted
- * deployments with `A2A_SECRET`: unset/empty/unknown means enabled, and an app
- * opts OUT with an explicit falsy value (`false`/`0`/`no`/`off`). Deliberately
- * kept separate from `AGENT_CHAT_DURABLE_BACKGROUND` so this narrower
- * capability can be disabled independently of the full durable-background
- * worker path.
+ * Env flag for the FOREGROUND server-driven self-chain. DEFAULT-OFF: a hosted
+ * app must explicitly opt in with a truthy value (`true`/`1`/`yes`/`on`). A
+ * regular Netlify function has a fixed 60-second wall, and a self-dispatched
+ * successor can otherwise be killed before it persists its next continuation.
+ * Keep this separate from `AGENT_CHAT_DURABLE_BACKGROUND` so the experimental
+ * regular-function chain can be enabled independently after its deployment is
+ * proven safe.
  */
 export const AGENT_CHAT_FOREGROUND_SELF_CHAIN_ENV =
   "AGENT_CHAT_FOREGROUND_SELF_CHAIN";
 
-function isForegroundSelfChainExplicitlyDisabled(): boolean {
+function isForegroundSelfChainExplicitlyEnabled(): boolean {
   // Read the literal key (not `process.env[CONST]`) so guard:no-env-credentials
   // can statically verify it against the allowlisted `AGENT_*` prefix. Keep this
   // in sync with AGENT_CHAT_FOREGROUND_SELF_CHAIN_ENV.
@@ -382,10 +383,10 @@ function isForegroundSelfChainExplicitlyDisabled(): boolean {
   if (raw == null) return false;
   const normalized = raw.trim().toLowerCase();
   return (
-    normalized === "0" ||
-    normalized === "false" ||
-    normalized === "no" ||
-    normalized === "off"
+    normalized === "1" ||
+    normalized === "true" ||
+    normalized === "yes" ||
+    normalized === "on"
   );
 }
 
@@ -395,10 +396,9 @@ function isForegroundSelfChainExplicitlyDisabled(): boolean {
  * server-side self-dispatch on the REGULAR function (not a Netlify
  * `-background` function) instead of depending on the client to re-POST
  * `auto_continue`. Composes exactly like `isAgentChatDurableBackgroundEnabled`:
- * true when the runtime is hosted AND `A2A_SECRET` is configured (the HMAC
- * handoff authenticates the self-dispatch), unless the env flag is explicitly
- * falsy. False otherwise — and false means the existing client-driven
- * `auto_continue` re-POST path is used unchanged, byte-for-byte.
+ * true only when the env flag is explicitly truthy, the runtime is hosted, and
+ * `A2A_SECRET` is configured (the HMAC handoff authenticates the dispatch).
+ * False means the existing client-driven `auto_continue` re-POST path is used.
  *
  * Deliberately independent of `isAgentChatDurableBackgroundEnabled`: an app can
  * use this narrower capability without opting into the full 15-min
@@ -410,7 +410,7 @@ function isForegroundSelfChainExplicitlyDisabled(): boolean {
  */
 export function isAgentChatForegroundSelfChainEnabled(): boolean {
   return (
-    !isForegroundSelfChainExplicitlyDisabled() &&
+    isForegroundSelfChainExplicitlyEnabled() &&
     isHostedRuntimeForDurableBackground() &&
     hasConfiguredA2ASecret()
   );

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

@@ -17,7 +17,11 @@ import {
   readDeployCredentialEnv,
   recordProviderCredentialAuthFailure,
 } from "../../server/credential-provider.js";
-import { normalizeReasoningEffortForModel } from "../../shared/reasoning-effort.js";
+import {
+  anthropicManualThinkingBudget,
+  normalizeReasoningEffortForModel,
+  supportsClaudeAdaptiveThinking,
+} from "../../shared/reasoning-effort.js";
 import { AI_SDK_MODEL_CONFIG, type AISDKProvider } from "../model-config.js";
 import {
   clampThinkingBudgetTokens,
@@ -316,13 +320,26 @@ class AISDKEngine implements AgentEngine {
         const explicitThinking = (
           providerOpts.anthropic as { thinking?: unknown } | undefined
         )?.thinking;
-        providerOpts.anthropic = {
-          ...((providerOpts.anthropic as object) ?? {}),
-          thinking: explicitThinking ?? { type: "adaptive" },
-          ...(explicitThinking
-            ? {}
-            : { outputConfig: { effort: reasoningEffort } }),
-        };
+        if (explicitThinking || supportsClaudeAdaptiveThinking(opts.model)) {
+          providerOpts.anthropic = {
+            ...((providerOpts.anthropic as object) ?? {}),
+            thinking: explicitThinking ?? { type: "adaptive" },
+            ...(explicitThinking
+              ? {}
+              : { outputConfig: { effort: reasoningEffort } }),
+          };
+        } else {
+          const budgetTokens = clampThinkingBudgetTokens(
+            anthropicManualThinkingBudget(reasoningEffort),
+            resolvedMaxOutputTokens,
+          );
+          providerOpts.anthropic = {
+            ...((providerOpts.anthropic as object) ?? {}),
+            ...(budgetTokens === undefined
+              ? {}
+              : { thinking: { type: "enabled", budgetTokens } }),
+          };
+        }
       } else if (this.provider === "openai") {
         providerOpts.openai = {
           ...((providerOpts.openai as object) ?? {}),

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

@@ -13,7 +13,11 @@ import {
   readDeployCredentialEnv,
   recordProviderCredentialAuthFailure,
 } from "../../server/credential-provider.js";
-import { normalizeReasoningEffortForModel } from "../../shared/reasoning-effort.js";
+import {
+  anthropicManualThinkingBudget,
+  normalizeReasoningEffortForModel,
+  supportsClaudeAdaptiveThinking,
+} from "../../shared/reasoning-effort.js";
 import { ANTHROPIC_MODEL_CONFIG } from "../model-config.js";
 import {
   LLM_MISSING_CREDENTIALS_ERROR_CODE,
@@ -105,8 +109,18 @@ class AnthropicEngine implements AgentEngine {
       opts.reasoningEffort,
     );
     if (reasoningEffort && !extra.thinking) {
-      extra.thinking = { type: "adaptive" };
-      extra.output_config = { effort: reasoningEffort };
+      if (supportsClaudeAdaptiveThinking(opts.model)) {
+        extra.thinking = { type: "adaptive" };
+        extra.output_config = { effort: reasoningEffort };
+      } else {
+        const budgetTokens = clampThinkingBudgetTokens(
+          anthropicManualThinkingBudget(reasoningEffort),
+          resolvedMaxOutputTokens,
+        );
+        if (budgetTokens !== undefined) {
+          extra.thinking = { type: "enabled", budget_tokens: budgetTokens };
+        }
+      }
     }
 
     // Apply prompt caching to the system prompt and tools by default.

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

@@ -71,12 +71,12 @@ export function resolveEmptyResponseRetryMaxOutputTokens(
 // 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.
+// Note: this applies to every numeric-budget "enabled" config, including the
+// compatibility fallback for Claude models that do not support adaptive
+// thinking. Anthropic's `type: "adaptive"` config (used by the
+// reasoningEffort -> output_config.effort mapping for supported models) 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.
 // ---------------------------------------------------------------------------
 
 /** Anthropic's documented minimum extended-thinking budget. */