@agent-native/core 0.122.1 → 0.122.2

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

@@ -30,4 +30,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 - core files: 1671
 - toolkit files: 160
-- template files: 6461
+- template files: 6470

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @agent-native/core
 
+## 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.2",
   "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-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/server/builder-design-systems.ts

@@ -140,7 +140,7 @@ function trimTrailingSlash(value: string): string {
 export function getBuilderDesignSystemsBaseUrl(): string {
   return (
     process.env.BUILDER_DESIGN_SYSTEMS_BASE_URL ||
-    `${trimTrailingSlash(getBuilderProxyOrigin())}/design-systems/v1`
+    `${trimTrailingSlash(getBuilderProxyOrigin())}/agent-native/design-systems/v1`
   );
 }
 

package/corpus/templates/analytics/.agents/skills/dashboard-management/SKILL.md

@@ -84,6 +84,21 @@ Do not rely on undeclared time variables. Server validation rejects unbound
 first-party SQL, so declare the filter or choose an explicit non-dashboard
 scope before saving.
 
+**A bound anywhere in the SQL is not the same as every CTE having its own
+bound.** If a panel has multiple top-level CTEs (`WITH a AS (...), b AS
+(...)`) and more than one of them reads `analytics_events`, EVERY one of
+those CTEs needs its own `{{timeRange}}`/`{{<id>Start}}`/`{{<id>End}}`
+reference or literal date bound — not just the final `SELECT` or one sibling
+CTE. A CTE that computes something like "this user's first-ever active day"
+by scanning `analytics_events` with no bound at all will full-table-scan on
+every render even though the panel *looks* time-bound overall (root cause of
+a 2026-07-25 production incident: several dashboards had exactly this shape).
+Server validation checks each top-level CTE independently now, so this fails
+at save time — but write it right the first time: bound every CTE, or use
+`config.timeScope: "cohort-history"` only for a CTE that is genuinely
+defining a cohort (e.g. a first-seen date), never as a way to skip bounding
+an ordinary activity scan.
+
 ## Creating A Dashboard
 
 When the user asks for a dashboard:

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/report-panel-window.ts

@@ -1,8 +1,8 @@
-import { MAX_CONCURRENT_SQL_QUERIES } from "@shared/sql-query-limits";
-
 import type { SqlPanel } from "./types";
 
-export const REPORT_PANEL_CHUNK_SIZE = MAX_CONCURRENT_SQL_QUERIES;
+// Keep each report window within the browser-side SQL query concurrency limit
+// so a cold window does not serialize into multiple waves before readiness.
+export const REPORT_PANEL_CHUNK_SIZE = 4;
 
 export function listReportablePanelIds(panels: SqlPanel[]): string[] {
   return panels

package/corpus/templates/analytics/changelog/2026-07-25-analytics-dashboards-and-scheduled-reports-are-faster-and-mo.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-25
+---
+
+Analytics dashboards and scheduled reports are faster and more reliable with large event histories.

package/corpus/templates/analytics/server/db/schema.ts

@@ -193,6 +193,18 @@ export const bigqueryCache = table("bigquery_cache", {
   expiresAt: text("expires_at").notNull(),
 });
 
+/**
+ * First-party dashboard panel result cache — see
+ * server/lib/first-party-analytics-cache.ts.
+ */
+export const firstPartyAnalyticsCache = table("first_party_analytics_cache", {
+  key: text("key").primaryKey(),
+  sql: text("sql").notNull(),
+  result: text("result").notNull(),
+  createdAt: text("created_at").notNull(),
+  expiresAt: text("expires_at").notNull(),
+});
+
 /**
  * Public write keys for the first-party analytics ingestion endpoint.
  * The key is intentionally public/write-only: it can create events for the

package/corpus/templates/analytics/server/lib/dashboard-panel-query.ts

@@ -446,10 +446,14 @@ export async function runDashboardPanelQuery(args: {
   }
 
   if (source === "first-party") {
-    return await queryFirstPartyAnalytics(query, {
-      userEmail: ctx.userEmail,
-      orgId: ctx.orgId ?? null,
-    });
+    return await queryFirstPartyAnalytics(
+      query,
+      {
+        userEmail: ctx.userEmail,
+        orgId: ctx.orgId ?? null,
+      },
+      { cache: true },
+    );
   }
 
   if (source === "demo") {

package/corpus/templates/analytics/server/lib/dashboard-report.ts

@@ -15,6 +15,8 @@ import {
   EMBED_TOKEN_QUERY_PARAM,
 } from "@agent-native/core/shared";
 
+import { interpolate } from "../../app/pages/adhoc/sql-dashboard/interpolate";
+import { serializePanelSql } from "../../app/pages/adhoc/sql-dashboard/panel-sql";
 import {
   listReportablePanelIds,
   REPORT_PANEL_CHUNK_SIZE,
@@ -32,6 +34,7 @@ import {
   type DashboardReportCaptureOutcome,
   type DashboardReportSubscription,
 } from "./dashboard-report-subscriptions";
+import { queryFirstPartyAnalytics } from "./first-party-analytics.js";
 
 type ReportSnapshot = {
   dashboardId: string;
@@ -42,6 +45,8 @@ type ReportSnapshot = {
   reportSettingsUrl: string;
   generatedAt: string;
   panelIds: string[];
+  panels: SqlDashboardConfig["panels"];
+  variables?: Record<string, string>;
 };
 
 const DATE_FILTER_TYPES: ReadonlySet<FilterType> = new Set([
@@ -58,7 +63,9 @@ const LOCAL_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SECOND_READY_TIMEOUT_MS = 45_000;
 // Cap browser work separately from the sweep-level delivery deadline.
-const SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS = 150_000;
+// Reserve time under Netlify's 300s background-function limit for cleanup and
+// email delivery (see MAX_CAPTURE_CLEANUP_RESERVE_MS / delivery reserves below).
+const SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS = 210_000;
 const BROWSER_CLEANUP_TIMEOUT_MS = 10_000;
 const DASHBOARD_REPORT_EMAIL_TIMEOUT_MS = 10_000;
 const DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS = 5_000;
@@ -226,6 +233,8 @@ async function collectReportSnapshot(
     }),
     generatedAt: new Date().toISOString(),
     panelIds: listReportablePanelIds(config.panels),
+    panels: config.panels,
+    variables: config.variables,
   };
 }
 
@@ -375,6 +384,14 @@ function boundedStageTimeout(capMs: number, deadlineAt?: number): number {
   return Math.max(1, Math.min(capMs, remainingMs));
 }
 
+function reportDeliveryReserveMs(recipientCount: number): number {
+  return (
+    MAX_CAPTURE_CLEANUP_RESERVE_MS +
+    recipientCount * DASHBOARD_REPORT_EMAIL_TIMEOUT_MS +
+    DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS
+  );
+}
+
 async function runWithinCaptureDeadline<T>(
   operation: () => Promise<T>,
   deadlineAt?: number,
@@ -448,7 +465,15 @@ async function waitForDashboardReportReady(
         if (root.getAttribute("data-dashboard-report-ready") !== "true") {
           return false;
         }
-        return !root.querySelector("[data-dashboard-report-loading='true']");
+        if (root.querySelector("[data-dashboard-report-loading='true']")) {
+          return false;
+        }
+        // A panel that errored (including its own query-call timeout) clears
+        // its loading marker just like a successful panel, so without this
+        // check the capture would treat a broken panel as "ready" and bake
+        // its raw error text into the delivered screenshot instead of
+        // failing the attempt so the retry sweep can pick it up.
+        return !root.querySelector("[role='alert']");
       })()`,
       undefined,
       { timeout },
@@ -505,6 +530,101 @@ async function waitForDashboardReportReady(
   }
 }
 
+const PREWARM_CONCURRENCY = 3;
+const PREWARM_PANEL_TIMEOUT_MS = 20_000;
+const PREWARM_MAX_BUDGET_MS = 45_000;
+
+/**
+ * Runs first-party panel queries once, directly, before the browser capture
+ * starts, so the capture's own query-dashboard-panel calls hit a warm cache
+ * instead of several panels racing each other cold for database time inside
+ * a single capture window — that contention, not any one query alone, is
+ * what was pushing panels past their capture timeout. Best-effort: a panel
+ * that fails or times out here is simply computed cold by the capture later,
+ * exactly as it always was, so this can never make a report worse than
+ * before it existed. Bounded to time left after reserving the full chunked
+ * capture attempt and delivery tail, so prewarming cannot starve capture.
+ * The per-panel timeout only bounds how long a worker waits before logging;
+ * it is also passed to the database/cache layers, and the original query is
+ * still awaited before this function returns so it cannot overlap capture.
+ */
+async function prewarmFirstPartyPanelCache(
+  sub: DashboardReportSubscription,
+  snapshot: ReportSnapshot,
+  deadlineAt?: number,
+  recipientCount = 0,
+): Promise<void> {
+  const panels = (snapshot.panels ?? []).filter(
+    (panel) => panel.source === "first-party" && panel.sql != null,
+  );
+  if (!panels.length) return;
+
+  const remaining = deadlineAt ? deadlineAt - Date.now() : Infinity;
+  const budgetMs = Math.max(
+    0,
+    Math.min(
+      PREWARM_MAX_BUDGET_MS,
+      deadlineAt
+        ? remaining -
+            SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS -
+            reportDeliveryReserveMs(recipientCount)
+        : PREWARM_MAX_BUDGET_MS,
+    ),
+  );
+  if (budgetMs <= 0) return;
+  const prewarmDeadline = Date.now() + budgetMs;
+
+  const vars: Record<string, string> = { ...snapshot.variables };
+  for (const [key, value] of Object.entries(snapshot.filters)) {
+    if (key.startsWith("f_")) vars[key.slice(2)] = value;
+  }
+  const scope = { userEmail: sub.ownerEmail, orgId: sub.orgId ?? null };
+
+  let index = 0;
+  async function worker(): Promise<void> {
+    while (index < panels.length && Date.now() < prewarmDeadline) {
+      const panel = panels[index++];
+      const sql = interpolate(serializePanelSql(panel.sql), vars, {
+        failClosedTimeVariables: true,
+      });
+      if (!sql.trim()) continue;
+      const panelTimeoutMs = Math.max(
+        1,
+        Math.min(PREWARM_PANEL_TIMEOUT_MS, prewarmDeadline - Date.now()),
+      );
+      const query = queryFirstPartyAnalytics(sql, scope, {
+        cache: true,
+        timeoutMs: panelTimeoutMs,
+      });
+      let timeout: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          query,
+          new Promise<never>((_, reject) => {
+            timeout = setTimeout(
+              () => reject(new Error("prewarm panel timeout")),
+              panelTimeoutMs,
+            );
+            timeout.unref?.();
+          }),
+        ]);
+      } catch (err) {
+        console.warn(
+          `[dashboard-report] prewarm failed for panel ${panel.id}:`,
+          err instanceof Error ? err.message : err,
+        );
+      } finally {
+        if (timeout) clearTimeout(timeout);
+        await query.catch(() => undefined);
+      }
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: PREWARM_CONCURRENCY }, () => worker()),
+  );
+}
+
 async function assertDashboardReportPanelWindow(
   page: any,
   expectedPanelIds: string[],
@@ -1358,14 +1478,25 @@ export async function sendDashboardReportSubscription(
     () => collectReportSnapshot(sub),
     options.deadlineAt,
   );
+  try {
+    await prewarmFirstPartyPanelCache(
+      sub,
+      snapshot,
+      options.deadlineAt,
+      recipients.length,
+    );
+  } catch (err) {
+    console.warn(
+      "[dashboard-report] panel cache prewarm failed (non-fatal):",
+      err instanceof Error ? err.message : err,
+    );
+  }
   const captureTimeoutMs = options.deadlineAt
     ? Math.min(
         SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS,
         options.deadlineAt -
           Date.now() -
-          MAX_CAPTURE_CLEANUP_RESERVE_MS -
-          recipients.length * DASHBOARD_REPORT_EMAIL_TIMEOUT_MS -
-          DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS,
+          reportDeliveryReserveMs(recipients.length),
       )
     : undefined;
   const capture = await captureDashboardPngWithFallback(