@agent-native/core 0.122.1 → 0.122.3

package/README.md

@@ -39,8 +39,6 @@ Fork a working app and let the agent evolve it. **You can customize everything.*
 
 **Agent-Native Loom**
 
-Record your screen with auto-transcripts and captured browser debug logs, share a link, and let an agent read the transcript, see timestamped frames, and fix the bug.
-
 </td>
 <td width="33%" align="center" valign="top">
 
@@ -50,8 +48,6 @@ Record your screen with auto-transcripts and captured browser debug logs, share
 
 **Visual plan mode for coding agents**
 
-Install `/visual-plan` and `/visual-recap` so your coding agent can plan before it builds and recap changes after they land. High-level code reviews with diagrams, wireframes, annotations, and review links.
-
 </td>
 <td width="33%" align="center" valign="top">
 
@@ -61,8 +57,6 @@ Install `/visual-plan` and `/visual-recap` so your coding agent can plan before
 
 **Agent-Native Figma**
 
-Generate interactive HTML prototypes, compare variants, refine controls, and export the result.
-
 </td>
 </tr>
 <tr>
@@ -74,8 +68,6 @@ Generate interactive HTML prototypes, compare variants, refine controls, and exp
 
 **Agent-Native Notion/Obsidian**
 
-Edit local Markdown/MDX files, generate rich interactive custom blocks, and draft, rewrite, or publish with an agent.
-
 </td>
 <td width="33%" align="center" valign="top">
 
@@ -85,8 +77,6 @@ Edit local Markdown/MDX files, generate rich interactive custom blocks, and draf
 
 **Open-Source Alternative to Amplitude and FullStory**
 
-Connect analytics data sources, prompt for real charts, and build reusable dashboards.
-
 </td>
 <td width="33%" align="center" valign="top">
 
@@ -96,13 +86,11 @@ Connect analytics data sources, prompt for real charts, and build reusable dashb
 
 **A minimal ChatGPT-style app for your own agent**
 
-Chat-first app scaffold with durable threads, actions, auth, live sync, and a clean path to add screens or plug in your own agent backend.
-
 </td>
 </tr>
 </table>
 
-View the full app gallery at **[agent-native.com/apps](https://agent-native.com/apps)**, or build from scratch with the **[framework guide](https://agent-native.com/docs/getting-started)**.
+View the [full gallery](https://agent-native.com/apps), or build from scratch with the **[framework guide](https://agent-native.com/docs/getting-started)**.
 
 ## Quick Start
 

package/corpus/README.md

@@ -28,6 +28,6 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 1671
+- core files: 1673
 - toolkit files: 160
-- template files: 6461
+- template files: 6472

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.122.3
+
+### Patch Changes
+
+- 6dd7ee0: Recover long-running messaging integrations across hosted function boundaries while preserving one logical agent turn and one final platform reply.
+
+## 0.122.2
+
+### Patch Changes
+
+- 905bdba: Improve tool-input recovery, stale-run handling, and design-system routing reliability.
+
 ## 0.122.1
 
 ### Patch Changes

package/corpus/core/package.json

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

@@ -3369,6 +3369,59 @@ function normalizeOptionalToolPlaceholders(
   return { input: normalized, changed: true };
 }
 
+/**
+ * Models routinely JSON-encode a field's value into a string when the tool
+ * schema wants an object/array — e.g. `config: "{\"name\":...}"` instead of
+ * `config: {name:...}`, or `operations: "[...]"` instead of `operations: [...]`.
+ * Seen across every app profiled in the 2026-07-25 reliability sweep
+ * (brain's `update-source` config, analytics' `mutate-dashboard`/
+ * `update-dashboard` operations/ops/config) and the model does NOT
+ * self-correct across repeated identical retries — it burns the full
+ * `MAX_IDENTICAL_TOOL_ERRORS` retry budget on the same wrong shape every
+ * time. Evidence-gated exactly like `normalizeOptionalToolPlaceholders`:
+ * only coerce a field whose CURRENT value fails schema validation (so a
+ * legitimate string value is never touched — a field schema-valid as a
+ * string is never also schema-valid as object/array) and whose parsed form
+ * passes. Never touches values that are already the right shape.
+ */
+function coerceStringifiedJsonToolValues(
+  schema: RawJsonSchema | undefined,
+  input: unknown,
+): { input: unknown; changed: boolean } {
+  if (!schema?.properties || !input || typeof input !== "object") {
+    return { input, changed: false };
+  }
+  if (Array.isArray(input)) return { input, changed: false };
+
+  let normalized: Record<string, unknown> | null = null;
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    if (typeof value !== "string" || value.trim().length === 0) continue;
+    const propertySchema = schema.properties[key];
+    if (!propertySchema || typeof propertySchema !== "object") continue;
+    const expectedType = (propertySchema as { type?: unknown }).type;
+    const expectsObjectOrArray =
+      expectedType === "object" ||
+      expectedType === "array" ||
+      (Array.isArray(expectedType) &&
+        (expectedType.includes("object") || expectedType.includes("array")));
+    if (!expectsObjectOrArray) continue;
+    if (schemaAcceptsToolValue(propertySchema, value)) continue;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) continue;
+    if (!schemaAcceptsToolValue(propertySchema, parsed)) continue;
+    normalized ??= { ...(input as Record<string, unknown>) };
+    normalized[key] = parsed;
+  }
+  return normalized
+    ? { input: normalized, changed: true }
+    : { input, changed: false };
+}
+
 function getRawToolInputValidator(schema: RawJsonSchema): ValidateFunction {
   const cached = rawToolInputValidatorCache.get(schema);
   if (cached) return cached;
@@ -4354,6 +4407,17 @@ export async function runAgentLoop(opts: {
       if (placeholderNormalization.changed) {
         toolCall = { ...toolCall, input: placeholderNormalization.input };
       }
+      const jsonStringCoercion = actionEntry
+        ? coerceStringifiedJsonToolValues(
+            actionEntry.tool.parameters,
+            toolCall.input,
+          )
+        : { input: toolCall.input, changed: false };
+      if (jsonStringCoercion.changed) {
+        toolCall = { ...toolCall, input: jsonStringCoercion.input };
+      }
+      const toolInputNormalized =
+        placeholderNormalization.changed || jsonStringCoercion.changed;
       const wireToolInput = JSON.stringify(toolCall.input ?? {});
       const normalizedToolInput = normalizeToolCallInputForHistory(
         toolCall.input,
@@ -4776,7 +4840,7 @@ export async function runAgentLoop(opts: {
       });
 
       const toolCallSchemaError = toolCallErrors.get(toolCall.id);
-      if (toolCallSchemaError && !placeholderNormalization.changed) {
+      if (toolCallSchemaError && !toolInputNormalized) {
         const result = finalizeToolErrorResult(
           toolInputSchemaErrorResult(
             toolCall.name,

package/corpus/core/src/agent/run-loop-with-resume.ts

@@ -124,6 +124,18 @@ async function appendContinuationAndJournal(
   appendToolCallJournalNote(messages, events);
 }
 
+/**
+ * Rebuild the same safe continuation context for a logical turn that resumes
+ * in a fresh hosted invocation.
+ */
+export async function appendDurableContinuationContext(
+  messages: EngineMessage[],
+  reason: AgentLoopContinuationReason,
+  threadId: string,
+): Promise<void> {
+  await appendContinuationAndJournal(messages, reason, threadId);
+}
+
 async function hasCompletedSideEffectToolCallInCurrentTurn(
   threadId: string | undefined,
   localEvents: readonly AgentChatEvent[] = [],

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

@@ -173,6 +173,34 @@ export const UNCLAIMED_BACKGROUND_RUN_FAST_SWEEP_MS = 20_000;
  */
 const STALE_RUN_RECOVERY_MAX_TURN_RUNS = 25;
 
+/**
+ * Circuit breaker for a DETERMINISTIC dead-on-arrival loop: some request
+ * shapes make the worker hang almost immediately every single time (e.g. an
+ * un-timed-out provider fetch that blocks the event loop) rather than merely
+ * hitting a transient blip. Because `attemptStaleRunRecovery` replays the
+ * SAME captured `dispatch_payload` on every successor (never a fresh
+ * request), such a turn was retrying an unwinnable request up to
+ * `STALE_RUN_RECOVERY_MAX_TURN_RUNS` (25) times — ~25 * 53s ≈ 22 minutes,
+ * each cycle re-billing the full input context — before finally giving up.
+ * Confirmed live in prod (assets: one turn cycled 24x, each attempt an
+ * identical ~32K-token request that made a token of real progress around
+ * ~8s in then went completely silent for the rest of its life until the 45s
+ * reap). Stop recovering after this many CONSECUTIVE stale_run reaps that
+ * each made near-zero real progress — a single blip never trips it (needs
+ * 3 in a row), and a run that's genuinely grinding through long work right
+ * up to its heartbeat window is untouched (see `hasNoForwardProgress`).
+ */
+const STALE_RUN_RECOVERY_CONSECUTIVE_NO_PROGRESS_LIMIT = 3;
+
+/**
+ * A reaped run counts as having made no forward progress if it never
+ * emitted a real event (`last_progress_at` unset) or died within this many
+ * ms of starting — well short of the 45s background reap window, so a run
+ * that was legitimately working almost up to the reap boundary is not
+ * penalized. See `STALE_RUN_RECOVERY_CONSECUTIVE_NO_PROGRESS_LIMIT`.
+ */
+const STALE_RUN_RECOVERY_NO_PROGRESS_WINDOW_MS = 20_000;
+
 /**
  * Maximum time the stale reapers (`reapIfStale`, `reapAllStaleRuns`,
  * `cleanupOldRuns`'s heartbeat-stale pass) will suspend reaping a "running"
@@ -1361,7 +1389,8 @@ type StaleRunRecoveryOutcome =
   | { outcome: "not_background" }
   | { outcome: "payload_missing" }
   | { outcome: "newer_run_exists" }
-  | { outcome: "budget_exhausted" };
+  | { outcome: "budget_exhausted" }
+  | { outcome: "repeated_no_progress" };
 
 /**
  * Mirrors `production-agent.ts`'s `generateRunId` — duplicated (not
@@ -1477,6 +1506,37 @@ async function attemptStaleRunRecovery(
     return { outcome: "budget_exhausted" };
   }
 
+  // See `STALE_RUN_RECOVERY_CONSECUTIVE_NO_PROGRESS_LIMIT`: a run whose last
+  // N attempts (including the one just reaped, already written by the
+  // caller's UPDATE earlier in this same transaction) all died as stale_run
+  // having made essentially no real progress is retrying an unwinnable
+  // request, not recovering from a blip. Stop far short of the 25-run/~22min
+  // budget above instead of grinding through it.
+  const { rows: recentRows } = await db.execute({
+    sql: `SELECT error_code, started_at, last_progress_at FROM agent_runs WHERE turn_id = ? ORDER BY started_at DESC LIMIT ?`,
+    args: [turnId, STALE_RUN_RECOVERY_CONSECUTIVE_NO_PROGRESS_LIMIT],
+  });
+  const recent = (recentRows ?? []) as Array<{
+    error_code?: string | null;
+    started_at: number | string;
+    last_progress_at: number | string | null;
+  }>;
+  const allDeadOnArrival =
+    recent.length === STALE_RUN_RECOVERY_CONSECUTIVE_NO_PROGRESS_LIMIT &&
+    recent.every((r) => {
+      if (r.error_code !== STALE_RUN_ERROR_EVENT.errorCode) return false;
+      const started = Number(r.started_at) || 0;
+      const progress =
+        r.last_progress_at == null ? null : Number(r.last_progress_at);
+      return (
+        progress === null ||
+        progress - started < STALE_RUN_RECOVERY_NO_PROGRESS_WINDOW_MS
+      );
+    });
+  if (allDeadOnArrival) {
+    return { outcome: "repeated_no_progress" };
+  }
+
   const successorRunId = generateRecoveryRunId();
   const now = Date.now();
   await db.execute({

package/corpus/core/src/integrations/a2a-continuation-processor.ts

@@ -19,12 +19,30 @@ import {
   claimA2AContinuationDelivery,
   claimDueA2AContinuations,
   completeA2AContinuation,
+  failA2AContinuationsForIntegrationTask,
   failA2AContinuation,
   getA2AContinuation,
+  hasActiveA2AContinuationsForIntegrationTask,
+  listRecoverableA2AIntegrationTasks,
+  recoverDueA2AContinuationIds,
   rescheduleA2AContinuation,
   type A2AContinuation,
+  type RecoverableA2AIntegrationTask,
 } from "./a2a-continuations-store.js";
+import {
+  completeIntegrationCampaignTaskAfterA2A,
+  failDisabledIntegrationCampaignTask,
+  getIntegrationCampaignForTask,
+} from "./integration-campaigns-store.js";
+import {
+  dispatchPendingIntegrationTask,
+  isIntegrationDurableDispatchEnabledForTask,
+} from "./integration-durable-dispatch.js";
 import { signInternalToken } from "./internal-token.js";
+import {
+  getNextPendingTaskForThread,
+  getPendingTask,
+} from "./pending-tasks-store.js";
 import { getThreadMapping } from "./thread-mapping-store.js";
 import type {
   OutgoingMessage,
@@ -150,10 +168,62 @@ export async function processDueA2AContinuations(options: {
   }
 }
 
+/**
+ * Durable scheduler wake-up only: make a bounded set of due/stale rows
+ * eligible, then invoke their normal processors. It never polls remote A2A
+ * tasks or runs a mutation itself, keeping the scheduled route within its
+ * short execution budget. Duplicate wake-ups are safe because each processor
+ * still takes the store's atomic claim before it can progress or deliver.
+ */
+export async function recoverDueA2AContinuations(options?: {
+  limit?: number;
+  webhookBaseUrl?: string;
+}): Promise<{ dispatched: number; failed: number }> {
+  const limit = options?.limit ?? 5;
+  const candidateTasks = await listRecoverableA2AIntegrationTasks(200);
+  const eligibleTaskIds: string[] = [];
+  for (const task of candidateTasks) {
+    const enabled = isIntegrationDurableDispatchEnabledForTask({
+      platform: task.platform,
+      externalThreadId: task.externalThreadId,
+      platformContext: task.dispatchScope
+        ? { channelId: task.dispatchScope }
+        : undefined,
+    });
+    if (enabled) {
+      eligibleTaskIds.push(task.id);
+      if (eligibleTaskIds.length >= limit) break;
+    } else {
+      await failDisabledDurableA2ATask(task);
+    }
+  }
+  const ids = await recoverDueA2AContinuationIds(limit, eligibleTaskIds);
+  let dispatched = 0;
+  let failed = 0;
+
+  await Promise.all(
+    ids.map(async (id) => {
+      try {
+        await dispatchA2AContinuation(id, options?.webhookBaseUrl);
+        dispatched += 1;
+      } catch (err) {
+        failed += 1;
+        console.error(
+          `[integrations] Failed to recover A2A continuation ${id}:`,
+          err,
+        );
+      }
+    }),
+  );
+
+  return { dispatched, failed };
+}
+
 async function processClaimedContinuation(
   continuation: A2AContinuation,
   options: { adapters: Map<string, PlatformAdapter> },
 ): Promise<void> {
+  if (!(await durableContinuationScopeStillEnabled(continuation))) return;
   const adapter = options.adapters.get(continuation.platform);
   if (!adapter) {
     await failA2AContinuation(
@@ -300,6 +370,66 @@ async function processClaimedContinuation(
   );
 }
 
+async function durableContinuationScopeStillEnabled(
+  continuation: A2AContinuation,
+): Promise<boolean> {
+  const campaign = await getIntegrationCampaignForTask(
+    continuation.integrationTaskId,
+  );
+  if (!campaign) return true;
+  if (campaign.status === "completed" || campaign.status === "failed") {
+    await failA2AContinuation(
+      continuation.id,
+      "Owning integration campaign is already terminal",
+    );
+    return false;
+  }
+  const task = await getPendingTask(continuation.integrationTaskId);
+  const enabled =
+    task?.status === "processing" &&
+    isIntegrationDurableDispatchEnabledForTask({
+      platform: task.platform,
+      externalThreadId: task.externalThreadId,
+      platformContext: task.dispatchScope
+        ? { channelId: task.dispatchScope }
+        : undefined,
+    });
+  if (enabled) return true;
+
+  await failDisabledDurableA2ATask({
+    id: continuation.integrationTaskId,
+    platform: task?.platform ?? continuation.platform,
+    externalThreadId: task?.externalThreadId ?? continuation.externalThreadId,
+    dispatchScope: task?.dispatchScope ?? null,
+    status: task?.status ?? "missing",
+  });
+  return false;
+}
+
+async function failDisabledDurableA2ATask(
+  task: RecoverableA2AIntegrationTask,
+): Promise<void> {
+  const message = "Durable integration campaign was disabled for this scope";
+  await failA2AContinuationsForIntegrationTask(task.id, message);
+  await failDisabledIntegrationCampaignTask(task.id, message);
+  const nextTask = await getNextPendingTaskForThread(
+    task.platform,
+    task.externalThreadId,
+  );
+  if (nextTask) {
+    await dispatchPendingIntegrationTask({
+      taskId: nextTask.id,
+      task: {
+        platform: task.platform,
+        externalThreadId: task.externalThreadId,
+        platformContext: nextTask.dispatchScope
+          ? { channelId: nextTask.dispatchScope }
+          : undefined,
+      },
+    });
+  }
+}
+
 async function resumeA2AContinuationProgress(
   continuation: A2AContinuation,
   adapter: PlatformAdapter,
@@ -372,6 +502,7 @@ async function notifyAndFailA2AContinuation(
   reason: string,
   progress: PlatformRunProgress | null = null,
 ): Promise<void> {
+  if (!(await durableContinuationScopeStillEnabled(continuation))) return;
   const deliveryContinuation = await claimA2AContinuationDelivery(
     continuation.id,
   );
@@ -399,9 +530,17 @@ async function notifyAndFailA2AContinuation(
       `[integrations] Failed to notify ${deliveryContinuation.platform} about failed A2A continuation ${deliveryContinuation.id}:`,
       err,
     );
+    if (deliveryContinuation.attempts >= MAX_ATTEMPTS) {
+      await failA2AContinuation(deliveryContinuation.id, reason);
+      await completeParentCampaignAfterTerminalA2A(deliveryContinuation);
+      return;
+    }
+    await rescheduleAndRedispatchA2AContinuation(deliveryContinuation.id);
+    return;
   }
 
   await failA2AContinuation(deliveryContinuation.id, reason);
+  await completeParentCampaignAfterTerminalA2A(deliveryContinuation);
 }
 
 async function deliverAndCompleteA2AContinuation(
@@ -410,6 +549,7 @@ async function deliverAndCompleteA2AContinuation(
   text: string,
   progress: PlatformRunProgress | null = null,
 ): Promise<void> {
+  if (!(await durableContinuationScopeStillEnabled(continuation))) return;
   const deliveryContinuation = await claimA2AContinuationDelivery(
     continuation.id,
   );
@@ -589,6 +729,7 @@ async function completeAfterSuccessfulDelivery(
   for (let attempt = 0; attempt < COMPLETE_AFTER_DELIVERY_ATTEMPTS; attempt++) {
     try {
       await completeA2AContinuation(continuation.id);
+      await completeParentCampaignAfterTerminalA2A(continuation);
       return;
     } catch (err) {
       lastError = err;
@@ -602,6 +743,47 @@ async function completeAfterSuccessfulDelivery(
   );
 }
 
+async function completeParentCampaignAfterTerminalA2A(
+  continuation: A2AContinuation,
+): Promise<void> {
+  const campaign = await getIntegrationCampaignForTask(
+    continuation.integrationTaskId,
+  );
+  if (!campaign) return;
+  if (
+    await hasActiveA2AContinuationsForIntegrationTask(
+      continuation.integrationTaskId,
+    )
+  ) {
+    return;
+  }
+  const completed = await completeIntegrationCampaignTaskAfterA2A(
+    continuation.integrationTaskId,
+  );
+  if (!completed) return;
+
+  const nextTask = await getNextPendingTaskForThread(
+    continuation.platform,
+    continuation.externalThreadId,
+  );
+  if (!nextTask) return;
+  await dispatchPendingIntegrationTask({
+    taskId: nextTask.id,
+    task: {
+      platform: continuation.platform,
+      externalThreadId: continuation.externalThreadId,
+      platformContext: nextTask.dispatchScope
+        ? { channelId: nextTask.dispatchScope }
+        : undefined,
+    },
+  }).catch((err) => {
+    console.error(
+      `[integrations] Failed to wake successor ${nextTask.id} after A2A parent completion:`,
+      err,
+    );
+  });
+}
+
 function formatContinuationFailureMessage(
   continuation: A2AContinuation,
   reason: string,