@agent-native/core 0.96.0 → 0.98.0

package/corpus/templates/analytics/actions/list-sql-dashboards.ts

@@ -7,7 +7,7 @@ import {
 import { z } from "zod";
 
 import {
-  listDashboards,
+  listDashboardSummaries,
   type DashboardArchiveFilter,
   type DashboardHiddenFilter,
 } from "../server/lib/dashboards-store";
@@ -65,10 +65,15 @@ export default defineAction({
     const ctx = { email, orgId };
     const archived = parseArchivedFilter(args.archived);
     const hidden = parseHiddenFilter(args.hidden);
-    const rows = await listDashboards(ctx, { kind: "sql", archived, hidden });
+    const rows = await listDashboardSummaries(ctx, {
+      kind: "sql",
+      archived,
+      hidden,
+    });
     return rows.map((d) => ({
       id: d.id,
-      ...(d.config as Record<string, unknown>),
+      name: d.name,
+      ...(d.parentId ? { parentId: d.parentId } : {}),
       ownerEmail: d.ownerEmail,
       orgId: d.orgId,
       visibility: d.visibility,

package/corpus/templates/analytics/actions/mutate-dashboard.ts

@@ -11,13 +11,18 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  getDashboard,
+  upsertDashboardWithRetry,
+  type DashboardRecord,
+} from "../server/lib/dashboards-store";
 import {
   applyDashboardMutationOperations,
   DASHBOARD_MUTATION_API_TYPES,
   DASHBOARD_MUTATION_EXAMPLES,
   parseDashboardMutationScript,
   type DashboardMutationOperation,
+  type DashboardMutationResult,
 } from "./dashboard-mutation-api";
 import { compactDashboardResult } from "./dashboard-panel-order";
 import { validateDashboardConfig, validatePanelSql } from "./update-dashboard";
@@ -260,33 +265,77 @@ export default defineAction({
 
     const scope = resolveScope();
     const ctx = { email: scope.email, orgId: scope.orgId };
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
-    if (existing.kind !== "sql") {
-      throw new Error(
-        `mutate-dashboard only supports SQL dashboards; "${dashboardId}" is ${existing.kind}.`,
+
+    // Recomputes the mutation from whatever dashboard state is passed in.
+    // `operations` sourced from `args.operations` are already concrete panel
+    // ids, safe to replay verbatim; `args.code` is re-parsed against `existing`
+    // every time because selectors like `panelsMatching(...)` resolve against
+    // the config at parse time, so a retry must re-resolve them against the
+    // fresh state, not reuse ids resolved from a now-stale config.
+    function computeMutation(
+      existing: Pick<DashboardRecord, "kind" | "config">,
+    ) {
+      if (existing.kind !== "sql") {
+        throw new Error(
+          `mutate-dashboard only supports SQL dashboards; "${dashboardId}" is ${existing.kind}.`,
+        );
+      }
+      const nextRoot = cloneConfig(existing.config as Record<string, unknown>);
+      const nextOperations = args.operations
+        ? (args.operations as DashboardMutationOperation[])
+        : parseDashboardMutationScript(nextRoot, args.code!);
+      const nextMutation = applyDashboardMutationOperations(
+        nextRoot,
+        nextOperations,
       );
+      const validation = validateDashboardConfig(nextRoot);
+      if (validation) throw new Error(validation);
+      return { nextRoot, nextOperations, nextMutation };
     }
 
-    const root = cloneConfig(existing.config as Record<string, unknown>);
-    const operations = args.operations
-      ? (args.operations as DashboardMutationOperation[])
-      : parseDashboardMutationScript(root, args.code!);
-    const mutation = applyDashboardMutationOperations(root, operations);
+    // Assigned inside `computeMutation`'s caller (directly for dry-run, inside
+    // the retry callback for a real save); always assigned at least once
+    // before use below, since `upsertDashboardWithRetry` only resolves after
+    // its callback has run.
+    let root: Record<string, unknown>;
+    let operations!: DashboardMutationOperation[];
+    let mutation!: DashboardMutationResult;
 
-    const validation = validateDashboardConfig(root);
-    if (validation) throw new Error(validation);
-    if (operations.some(mutationCanChangePanelSql)) {
-      const sqlError = await validatePanelSql(root);
-      if (sqlError) throw new Error(sqlError);
-    }
-
-    if (args.dryRun !== true) {
-      await upsertDashboard(dashboardId, existing.kind, root, ctx);
+    if (args.dryRun === true) {
+      const existing = await getDashboard(dashboardId, ctx);
+      if (!existing) {
+        throw new Error(
+          `dashboard "${dashboardId}" not found (or you don't have access).`,
+        );
+      }
+      const computed = computeMutation(existing);
+      root = computed.nextRoot;
+      operations = computed.nextOperations;
+      mutation = computed.nextMutation;
+      if (operations.some(mutationCanChangePanelSql)) {
+        const sqlError = await validatePanelSql(root);
+        if (sqlError) throw new Error(sqlError);
+      }
+    } else {
+      const saved = await upsertDashboardWithRetry(
+        dashboardId,
+        ctx,
+        async (existing) => {
+          const computed = computeMutation(existing);
+          if (computed.nextOperations.some(mutationCanChangePanelSql)) {
+            const sqlError = await validatePanelSql(computed.nextRoot);
+            if (sqlError) throw new Error(sqlError);
+          }
+          root = computed.nextRoot;
+          operations = computed.nextOperations;
+          mutation = computed.nextMutation;
+          return { kind: "sql" as const, body: computed.nextRoot };
+        },
+      );
+      // Use the persisted config as the source of truth for the response —
+      // structurally identical to the winning attempt's `root`, but reflects
+      // exactly what was saved.
+      root = saved.config as Record<string, unknown>;
       await syncToCollab(dashboardId, root);
     }
 

package/corpus/templates/analytics/actions/rename-analysis.ts

@@ -5,7 +5,7 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { upsertAnalysis } from "../server/lib/dashboards-store";
+import { upsertAnalysisWithRetry } from "../server/lib/dashboards-store";
 
 function resolveScope() {
   const orgId = getRequestOrgId() || null;
@@ -25,7 +25,13 @@ export default defineAction({
     if (!name) throw new Error("name is required");
 
     const ctx = resolveScope();
-    const analysis = await upsertAnalysis(args.id, { name }, ctx);
+    // Fenced through the retry helper: the patch below only ever touches
+    // `name`, so a concurrent edit (e.g. save-analysis re-running with fresh
+    // results) racing this rename is never silently overwritten — a lost
+    // race just re-reads the freshest record and reapplies the rename.
+    const analysis = await upsertAnalysisWithRetry(args.id, ctx, () => ({
+      name,
+    }));
     return { id: analysis.id, name: analysis.name };
   },
 });

package/corpus/templates/analytics/actions/rename-dashboard.ts

@@ -10,7 +10,7 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import { upsertDashboardWithRetry } from "../server/lib/dashboards-store";
 
 function resolveScope() {
   const orgId = getRequestOrgId() || null;
@@ -47,12 +47,13 @@ export default defineAction({
     if (!name) throw new Error("name is required");
 
     const ctx = resolveScope();
-    const dashboard = await getDashboard(args.id, ctx);
-    if (!dashboard) throw new Error("Dashboard not found");
-
-    const config = { ...dashboard.config, name };
-    const updated = await upsertDashboard(args.id, dashboard.kind, config, ctx);
-    await syncToCollab(args.id, config);
+    // Recomputed on every retry attempt from the freshest dashboard config, so
+    // a concurrent panel edit (mutate-dashboard/update-dashboard) racing this
+    // rename is never silently overwritten by a stale config snapshot.
+    const updated = await upsertDashboardWithRetry(args.id, ctx, (existing) => {
+      return { kind: existing.kind, body: { ...existing.config, name } };
+    });
+    await syncToCollab(args.id, updated.config);
     return { id: updated.id, name: updated.title };
   },
 });

package/corpus/templates/analytics/actions/reorder-dashboard-panels.ts

@@ -11,10 +11,11 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import { upsertDashboardWithRetry } from "../server/lib/dashboards-store";
 import {
   compactDashboardResult,
   movePanelsById,
+  type PanelOrderResult,
   type PanelOrderTarget,
 } from "./dashboard-panel-order";
 
@@ -155,20 +156,22 @@ export default defineAction({
     const dashboardId = resolveDashboardId(args);
     const scope = resolveScope();
     const ctx = { email: scope.email, orgId: scope.orgId };
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
 
-    const root = existing.config as Record<string, unknown>;
-    const orderResult = movePanelsById(
-      root,
-      args.panelIds,
-      resolveTarget(args),
+    // Recomputed on every attempt from whichever dashboard state
+    // `upsertDashboardWithRetry` hands us, so a retry after a concurrent
+    // writer's save re-applies this move against their fresh panel order
+    // instead of silently discarding it.
+    let orderResult!: PanelOrderResult;
+    const saved = await upsertDashboardWithRetry(
+      dashboardId,
+      ctx,
+      (existing) => {
+        const root = existing.config as Record<string, unknown>;
+        orderResult = movePanelsById(root, args.panelIds, resolveTarget(args));
+        return { kind: existing.kind, body: root };
+      },
     );
-    await upsertDashboard(dashboardId, existing.kind, root, ctx);
+    const root = saved.config as Record<string, unknown>;
     await syncToCollab(dashboardId, root);
 
     const compact = compactDashboardResult(root, orderResult.movedPanelIds);

package/corpus/templates/analytics/actions/update-dashboard.ts

@@ -13,12 +13,16 @@ import { z } from "zod";
 
 import { interpolate } from "../app/pages/adhoc/sql-dashboard/interpolate";
 import { dryRunQuery } from "../server/lib/bigquery";
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  upsertDashboard,
+  upsertDashboardWithRetry,
+} from "../server/lib/dashboards-store";
 import { parseDemoDescriptor } from "../server/lib/demo-source";
 import { validateFirstPartyAnalyticsSql } from "../server/lib/first-party-analytics.js";
 import {
   applyPanelOrder,
   compactDashboardResult,
+  type PanelOrderResult,
 } from "./dashboard-panel-order";
 
 /**
@@ -627,29 +631,27 @@ export default defineAction({
       );
     }
 
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
-
-    const root = existing.config as any;
-
     if (args.panelOrder) {
-      const orderDetails = applyPanelOrder(root, args.panelOrder);
-      const validation = validateDashboardConfig(root);
-      if (validation) throw new Error(validation);
-      await upsertDashboard(
+      // Recomputed on every retry attempt from the freshest dashboard config,
+      // so a concurrent writer's edit is never silently overwritten by this
+      // move.
+      let orderDetails!: PanelOrderResult;
+      const saved = await upsertDashboardWithRetry(
         dashboardId,
-        existing.kind,
-        root as Record<string, unknown>,
         ctx,
+        (existing) => {
+          const root = existing.config as Record<string, unknown>;
+          orderDetails = applyPanelOrder(root, args.panelOrder!);
+          const validation = validateDashboardConfig(root);
+          if (validation) throw new Error(validation);
+          return { kind: existing.kind, body: root };
+        },
       );
-      await syncToCollab(dashboardId, root as Record<string, unknown>);
+      const root = saved.config as Record<string, unknown>;
+      await syncToCollab(dashboardId, root);
       return dashboardResult(
         dashboardId,
-        root as Record<string, unknown>,
+        root,
         1,
         `Moved ${orderDetails.movedPanelIds.length} panel id(s) to the front of dashboard "${dashboardId}"; it now has ${orderDetails.panelCount} panel(s).`,
         orderDetails.movedPanelIds,
@@ -657,36 +659,45 @@ export default defineAction({
       );
     }
 
-    const details: string[] = [];
-    for (const op of args.ops!) {
-      try {
-        details.push(applyJsonOp(root, op as JsonOp));
-      } catch (err: any) {
-        throw new Error(`applying op ${JSON.stringify(op)}: ${err.message}`);
-      }
-    }
-
-    const validation = validateDashboardConfig(root);
-    if (validation) throw new Error(validation);
-    if (args.ops!.some((op) => opCanChangePanelSql(op as JsonOp))) {
-      const sqlError = await validatePanelSql(root);
-      if (sqlError) throw new Error(sqlError);
-    }
-
-    await upsertDashboard(
+    // Recomputed on every retry attempt from the freshest dashboard config —
+    // JSON-pointer ops are replayed against fresh state, not the stale config
+    // that produced the first (lost) attempt.
+    let appliedDetails: string[] = [];
+    const saved = await upsertDashboardWithRetry(
       dashboardId,
-      existing.kind,
-      root as Record<string, unknown>,
       ctx,
+      async (existing) => {
+        const root = existing.config as Record<string, unknown>;
+        const details: string[] = [];
+        for (const op of args.ops!) {
+          try {
+            details.push(applyJsonOp(root, op as JsonOp));
+          } catch (err: any) {
+            throw new Error(
+              `applying op ${JSON.stringify(op)}: ${err.message}`,
+            );
+          }
+        }
+
+        const validation = validateDashboardConfig(root);
+        if (validation) throw new Error(validation);
+        if (args.ops!.some((op) => opCanChangePanelSql(op as JsonOp))) {
+          const sqlError = await validatePanelSql(root);
+          if (sqlError) throw new Error(sqlError);
+        }
+        appliedDetails = details;
+        return { kind: existing.kind, body: root };
+      },
     );
-    await syncToCollab(dashboardId, root as Record<string, unknown>);
+    const root = saved.config as Record<string, unknown>;
+    await syncToCollab(dashboardId, root);
 
-    const panelCount = countPanels(root as Record<string, unknown>);
+    const panelCount = countPanels(root);
     return dashboardResult(
       dashboardId,
-      root as Record<string, unknown>,
-      details.length,
-      `Applied ${details.length} op(s); dashboard "${dashboardId}" now has ${panelCount} panel(s).`,
+      root,
+      appliedDetails.length,
+      `Applied ${appliedDetails.length} op(s); dashboard "${dashboardId}" now has ${panelCount} panel(s).`,
       [],
       args.returnConfig === true,
     );

package/corpus/templates/analytics/actions/view-screen.ts

@@ -466,34 +466,15 @@ export default defineAction({
       const email = getRequestUserEmail();
       if (email) {
         const orgId = getRequestOrgId() || null;
-        const [keys, catalog] = await Promise.all([
-          listAnalyticsPublicKeys({
-            userEmail: email,
-            orgId,
-          }),
-          listDashboardCatalog({
-            email,
-            orgId,
-          }),
-        ]);
-        const llmTemplate = catalog.find(
-          (template) => template.id === "agent-observability-llm",
-        );
+        const keys = await listAnalyticsPublicKeys({
+          userEmail: email,
+          orgId,
+        });
         screen.firstPartyAnalytics = {
           activeKeys: keys.filter((key: any) => !key.revokedAt).length,
           serverEnv: "AGENT_NATIVE_ANALYTICS_PUBLIC_KEY",
           browserEnv: "VITE_AGENT_NATIVE_ANALYTICS_PUBLIC_KEY",
         };
-        if (llmTemplate) {
-          screen.llmObservabilityDashboard = {
-            templateId: llmTemplate.id,
-            name: llmTemplate.name,
-            installed: llmTemplate.installed,
-            installedDashboardIds: llmTemplate.installedDashboards.map(
-              (dashboard) => dashboard.id,
-            ),
-          };
-        }
       }
     } else if (nav?.view === "settings") {
       screen.page = "settings";

package/corpus/templates/analytics/app/components/ResourceLoadError.tsx

@@ -0,0 +1,42 @@
+import { Button } from "@/components/ui/button";
+
+type ResourceLoadErrorProps = {
+  message: string;
+  retryLabel: string;
+  onRetry: () => void;
+  inline?: boolean;
+};
+
+export function ResourceLoadError({
+  message,
+  retryLabel,
+  onRetry,
+  inline = false,
+}: ResourceLoadErrorProps) {
+  if (inline) {
+    return (
+      <div className="px-2 py-2 text-xs text-destructive" role="status">
+        <span>{message}</span>{" "}
+        <button
+          type="button"
+          className="font-medium underline underline-offset-2 hover:text-destructive/80"
+          onClick={onRetry}
+        >
+          {retryLabel}
+        </button>
+      </div>
+    );
+  }
+
+  return (
+    <div
+      className="flex h-64 flex-col items-center justify-center gap-2 text-sm text-destructive"
+      role="status"
+    >
+      <span>{message}</span>
+      <Button size="sm" variant="outline" onClick={onRetry}>
+        {retryLabel}
+      </Button>
+    </div>
+  );
+}