@agent-native/core 0.95.1 → 0.97.0

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/app/components/layout/Sidebar.tsx

@@ -1295,7 +1295,7 @@ function persistedAnalyticsThreadId() {
   }
 }
 
-function AnalyticsChatsSection() {
+function AnalyticsChatsSection({ isAskRoute }: { isAskRoute: boolean }) {
   const navigate = useNavigate();
   const t = useT();
   const {
@@ -1439,8 +1439,9 @@ function AnalyticsChatsSection() {
       {visibleThreads.map((thread) => {
         const title = threadTitle(thread, t("chat.untitledChat"));
         const isActive =
-          thread.id === activeThreadId ||
-          thread.id === persistedAnalyticsThreadId();
+          isAskRoute &&
+          (thread.id === activeThreadId ||
+            thread.id === persistedAnalyticsThreadId());
         const isRenaming = thread.id === renamingThreadId;
         return (
           <div
@@ -2592,7 +2593,7 @@ export function Sidebar({ mobile }: { mobile?: boolean } = {}) {
                     />
                   </button>
                 </div>
-                {askOpen && <AnalyticsChatsSection />}
+                {askOpen && <AnalyticsChatsSection isAskRoute={isAskRoute} />}
               </div>
 
               {/* Sessions link */}

package/corpus/templates/analytics/app/global.css

@@ -149,6 +149,16 @@
   background-color: hsl(var(--background)) !important;
 }
 
+.analytics-chat-panel .agent-thread-content {
+  padding-top: 4.5rem;
+}
+
+.analytics-chat-panel
+  [data-agent-page-chat-scrolled]
+  [data-agent-page-chat-fade] {
+  opacity: 1;
+}
+
 @media (max-width: 767px) {
   .analytics-chat-panel [data-agent-page-new-chat] {
     display: none;

package/corpus/templates/analytics/app/pages/Ask.tsx

@@ -1,5 +1,9 @@
-import { AgentChatSurface, useT } from "@agent-native/core/client";
-import { useState } from "react";
+import {
+  AgentChatSurface,
+  useAgentChatContext,
+  useT,
+} from "@agent-native/core/client";
+import { useEffect, useMemo, useState } from "react";
 
 import {
   ANALYTICS_CHAT_STORAGE_KEY,
@@ -7,9 +11,28 @@ import {
 } from "@/lib/chat-handoff";
 import { TAB_ID } from "@/lib/tab-id";
 
+const DASHBOARD_CONTEXT_KEYS = new Set([
+  "analytics-selected-dashboard",
+  "analytics-selected-dashboard-panel",
+]);
+
 export default function AskPage() {
   const t = useT();
   const [restoreActiveThread] = useState(() => hasRecentAnalyticsChat());
+  const { items: chatContextItems, remove: removeChatContextItem } =
+    useAgentChatContext();
+  const staleDashboardContextKey = useMemo(
+    () =>
+      chatContextItems.find((item) => DASHBOARD_CONTEXT_KEYS.has(item.key))
+        ?.key ?? null,
+    [chatContextItems],
+  );
+
+  useEffect(() => {
+    if (staleDashboardContextKey) {
+      removeChatContextItem(staleDashboardContextKey);
+    }
+  }, [removeChatContextItem, staleDashboardContextKey]);
 
   return (
     <div className="analytics-ask-page flex h-full min-h-0 flex-col bg-background">

package/corpus/templates/analytics/changelog/2026-07-10-analytics-answers-simple-time-bounded-metrics-without-unnece.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-10
+---
+
+Analytics answers simple time-bounded metrics without unnecessary follow-up queries.

package/corpus/templates/analytics/changelog/2026-07-10-analytics-chat-reliably-uses-connected-data-sources-across-s.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Analytics chat reliably uses connected data sources across supported models

package/corpus/templates/analytics/changelog/2026-07-10-chat-threads-now-stay-clear-of-top-actions-and-fade-smoothly.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Chat threads now stay clear of top actions and fade smoothly beneath them while scrolling.

package/corpus/templates/analytics/changelog/2026-07-10-context-chips-can-now-be-selected-and-removed-one-at-a-time-.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-10
+---
+
+Context chips can now be selected and removed one at a time with Backspace from the start of the Ask composer.

package/corpus/templates/analytics/changelog/2026-07-10-dashboard-edits-from-the-agent-and-the-ui-at-the-same-time-n.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Dashboard edits from the agent and the UI at the same time no longer overwrite each other

package/corpus/templates/analytics/changelog/2026-07-10-the-ask-composer-no-longer-carries-dashboard-or-panel-contex.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+The Ask composer no longer carries dashboard or panel context after leaving a dashboard.

package/corpus/templates/analytics/changelog/2026-07-10-the-ask-section-stays-highlighted-while-its-chat-history-is-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+The Ask section stays highlighted while its chat history is expanded.

package/corpus/templates/analytics/changelog/2026-07-10-timed-out-bigquery-jobs-are-now-cancelled-so-they-stop-consu.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Timed-out BigQuery jobs are now cancelled so they stop consuming warehouse quota.

package/corpus/templates/analytics/package.json

@@ -25,7 +25,7 @@
     "@sparticuz/chromium-min": "^149.0.0",
     "@tabler/icons-react": "catalog:",
     "drizzle-orm": "^0.45.2",
-    "h3": "^2.0.1-rc.20",
+    "h3": "catalog:",
     "isbot": "^5",
     "playwright-core": "^1.61.1",
     "postgres": "^3.4.9",
@@ -100,7 +100,6 @@
     "tailwindcss": "catalog:",
     "three": "^0.176.0",
     "tsx": "^4.20.3",
-    "typescript": "catalog:",
     "typescript-7": "catalog:",
     "vaul": "^1.1.2",
     "vite": "catalog:",

package/corpus/templates/analytics/server/lib/bigquery.ts

@@ -241,6 +241,15 @@ export interface QueryResult {
   cached?: boolean;
 }
 
+export interface RunQueryOptions {
+  /**
+   * The current agent run's abort signal. This cancels in-flight BigQuery
+   * requests and, importantly, stops the one-second job polling wait without
+   * starting another request after the parent run has ended.
+   */
+  signal?: AbortSignal;
+}
+
 interface BigQueryField {
   name: string;
   type: string;
@@ -265,6 +274,57 @@ interface BigQueryGetQueryResultsResponse {
   totalBytesProcessed?: string;
 }
 
+function createAbortError(): Error {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException("BigQuery query aborted", "AbortError");
+  }
+  const error = new Error("BigQuery query aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) throw createAbortError();
+}
+
+function waitForPollInterval(signal?: AbortSignal): Promise<void> {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, 1000);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      reject(createAbortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+async function cancelQueryJob(
+  projectId: string,
+  jobId: string,
+  token: string,
+): Promise<void> {
+  try {
+    await fetch(
+      `https://bigquery.googleapis.com/bigquery/v2/projects/${projectId}/jobs/${jobId}/cancel`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+        },
+      },
+    );
+  } catch {
+    // Cancellation is best-effort and must not hide the original abort or
+    // timeout reason if BigQuery or the network is unavailable.
+  }
+}
+
 /**
  * Convert BigQuery REST API row format to plain objects.
  * BigQuery returns rows as { f: [{ v: value }, ...] } arrays
@@ -361,7 +421,12 @@ export async function dryRunQuery(sql: string): Promise<string | null> {
   return `BigQuery validation failed (${res.status})`;
 }
 
-export async function runQuery(sql: string): Promise<QueryResult> {
+export async function runQuery(
+  sql: string,
+  options: RunQueryOptions = {},
+): Promise<QueryResult> {
+  const { signal } = options;
+  throwIfAborted(signal);
   const { projectId, cacheScope, appEventsTable } = await getProjectInfo();
   const resolvedSql = await resolveTablePlaceholder(
     sql,
@@ -383,8 +448,10 @@ export async function runQuery(sql: string): Promise<QueryResult> {
   const token = await getAccessToken();
   const url = `https://bigquery.googleapis.com/bigquery/v2/projects/${projectId}/queries`;
 
+  throwIfAborted(signal);
   const res = await fetch(url, {
     method: "POST",
+    ...(signal ? { signal } : {}),
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
@@ -409,23 +476,33 @@ export async function runQuery(sql: string): Promise<QueryResult> {
     const resultsUrl = `https://bigquery.googleapis.com/bigquery/v2/projects/${projectId}/queries/${jobId}`;
 
     let attempts = 0;
-    while (!data.jobComplete && attempts < 60) {
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-      const pollRes = await fetch(resultsUrl, {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json",
-        },
-      });
-      if (!pollRes.ok) {
-        const text = await pollRes.text();
-        throw new Error(`BigQuery poll error ${pollRes.status}: ${text}`);
+    try {
+      while (!data.jobComplete && attempts < 60) {
+        await waitForPollInterval(signal);
+        throwIfAborted(signal);
+        const pollRes = await fetch(resultsUrl, {
+          ...(signal ? { signal } : {}),
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+          },
+        });
+        if (!pollRes.ok) {
+          const text = await pollRes.text();
+          throw new Error(`BigQuery poll error ${pollRes.status}: ${text}`);
+        }
+        data = (await pollRes.json()) as BigQueryGetQueryResultsResponse;
+        attempts++;
+      }
+    } catch (error) {
+      if (signal?.aborted) {
+        await cancelQueryJob(projectId, jobId, token);
       }
-      data = (await pollRes.json()) as BigQueryGetQueryResultsResponse;
-      attempts++;
+      throw error;
     }
 
     if (!data.jobComplete) {
+      await cancelQueryJob(projectId, jobId, token);
       throw new Error("BigQuery query timed out after 60 seconds");
     }
   }

package/corpus/templates/analytics/server/lib/dashboards-store.ts

@@ -129,6 +129,45 @@ function nanoidFallback(): string {
   );
 }
 
+/**
+ * Normalize affected-row metadata from every createGetDb backend: libSQL,
+ * PGlite, Neon, postgres.js, better-sqlite3, and D1. Mirrors
+ * templates/design/actions/update-design.ts's `affectedRowCount`.
+ */
+function affectedRowCount(result: unknown): number | undefined {
+  const candidate = result as
+    | {
+        rowsAffected?: unknown;
+        affectedRows?: unknown;
+        rowCount?: unknown;
+        count?: unknown;
+        changes?: unknown;
+        meta?: { changes?: unknown };
+      }
+    | undefined;
+  const value =
+    candidate?.rowsAffected ??
+    candidate?.affectedRows ??
+    candidate?.rowCount ??
+    candidate?.count ??
+    candidate?.changes ??
+    candidate?.meta?.changes;
+  return typeof value === "number" ? value : undefined;
+}
+
+/**
+ * Thrown when a fenced `upsertDashboard` write (an `expectedUpdatedAt` was
+ * supplied) loses its compare-and-swap because another writer changed the
+ * row first. Callers should re-read the dashboard and re-apply their mutation
+ * against the fresh config — see `upsertDashboardWithRetry`.
+ */
+export class DashboardConflictError extends Error {
+  constructor(id: string) {
+    super(`Dashboard "${id}" changed between read and write.`);
+    this.name = "DashboardConflictError";
+  }
+}
+
 function changeScope(
   ownerEmail: string,
   orgId: string | null,
@@ -466,15 +505,33 @@ async function snapshotDashboardRevision(
  * Upsert a dashboard. On create, caller becomes owner and visibility defaults
  * to `private`; users explicitly promote useful dashboards to org/public via
  * sharing. On update, `assertAccess` requires `editor`.
+ *
+ * `expectedUpdatedAt` fences the update against concurrent writers: pass the
+ * `updatedAt` observed by an earlier `getDashboard` call and the UPDATE only
+ * applies `WHERE id = ? AND updated_at = ?`. If another writer already saved
+ * in between, the fenced UPDATE affects zero rows and this throws
+ * `DashboardConflictError` instead of silently clobbering their write. Omit
+ * it (the default) to keep the prior unconditional last-write-wins behavior,
+ * which existing callers (legacy migration, revision restore, and any
+ * one-shot write that isn't a read-modify-write) still rely on.
  */
 export async function upsertDashboard(
   id: string,
   kind: DashboardKind,
   body: Record<string, unknown>,
   ctx: AccessCtx,
+  expectedUpdatedAt?: string,
 ): Promise<DashboardRecord> {
   // If the row exists (or legacy-migrates), require editor.
   const existing = await getDashboard(id, ctx);
+  if (!existing && expectedUpdatedAt !== undefined) {
+    // A fence was supplied against a specific prior version, but the row is
+    // gone (deleted, or a legacy key that failed to migrate) by the time we
+    // looked. Treat this as a conflict rather than silently creating a fresh
+    // row — the caller's mutation was computed against state that no longer
+    // exists.
+    throw new DashboardConflictError(id);
+  }
   const db = getDb() as any;
   const { title, config } = configFromSettings(body);
   const configJson = JSON.stringify(config);
@@ -487,17 +544,43 @@ export async function upsertDashboard(
       existing.kind !== kind ||
       existing.title !== title ||
       JSON.stringify(existing.config) !== configJson;
-    if (changed) await snapshotDashboardRevision(db, existing, ctx);
-    await db
-      .update(schema.dashboards)
-      .set({
-        kind,
-        title,
-        config: configJson,
-        updatedAt: nowIso(),
-        updatedBy: ctx.email,
-      })
-      .where(eq(schema.dashboards.id, id));
+    const setValues = {
+      kind,
+      title,
+      config: configJson,
+      updatedAt: nowIso(),
+      updatedBy: ctx.email,
+    };
+    if (expectedUpdatedAt !== undefined) {
+      // Fenced write. Snapshot the revision only after we know this exact
+      // write actually landed — otherwise a lost race would record a
+      // revision for a save that never happened.
+      const updateResult = await db
+        .update(schema.dashboards)
+        .set(setValues)
+        .where(
+          and(
+            eq(schema.dashboards.id, id),
+            eq(schema.dashboards.updatedAt, expectedUpdatedAt),
+          ),
+        );
+      const affected = affectedRowCount(updateResult);
+      if (affected === undefined) {
+        throw new Error(
+          "The database driver did not report an affected-row count for the fenced dashboard update.",
+        );
+      }
+      if (affected === 0) {
+        throw new DashboardConflictError(id);
+      }
+      if (changed) await snapshotDashboardRevision(db, existing, ctx);
+    } else {
+      if (changed) await snapshotDashboardRevision(db, existing, ctx);
+      await db
+        .update(schema.dashboards)
+        .set(setValues)
+        .where(eq(schema.dashboards.id, id));
+    }
   } else {
     await db.insert(schema.dashboards).values({
       id,
@@ -528,6 +611,66 @@ export async function upsertDashboard(
   return dashboard;
 }
 
+/** Max attempts (first try + retries) for `upsertDashboardWithRetry`. */
+export const DASHBOARD_SAVE_MAX_ATTEMPTS = 3;
+
+/**
+ * Read-modify-write helper for the four action call sites that fetch a
+ * dashboard, mutate its config in memory, then save it back. Fences every
+ * save with the `updatedAt` of the record `mutate` was given, so a
+ * concurrent writer (agent adds a panel while a human drags one, or two
+ * agent calls race) never gets silently clobbered.
+ *
+ * `mutate` is invoked with the freshest `DashboardRecord` on every attempt —
+ * re-fetched from `getDashboard` each time — and must recompute the
+ * `{ kind, body }` to save FROM THAT RECORD, not from a closure over an
+ * earlier read; only then does a retry actually merge both writers' changes
+ * instead of re-deriving the same stale result. `mutate` may throw a
+ * non-conflict error (e.g. validation) to abort immediately without
+ * retrying.
+ *
+ * On a lost race, this re-reads and re-invokes `mutate` up to `maxAttempts`
+ * times before failing loud with a clear error so callers never silently
+ * drop a write or loop forever.
+ */
+export async function upsertDashboardWithRetry(
+  id: string,
+  ctx: AccessCtx,
+  mutate: (
+    existing: DashboardRecord,
+  ) =>
+    | { kind: DashboardKind; body: Record<string, unknown> }
+    | Promise<{ kind: DashboardKind; body: Record<string, unknown> }>,
+  maxAttempts: number = DASHBOARD_SAVE_MAX_ATTEMPTS,
+): Promise<DashboardRecord> {
+  let lastConflict: unknown;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const existing = await getDashboard(id, ctx);
+    if (!existing) {
+      throw new Error(
+        `dashboard "${id}" not found (or you don't have access).`,
+      );
+    }
+    const { kind, body } = await mutate(existing);
+    try {
+      return await upsertDashboard(id, kind, body, ctx, existing.updatedAt);
+    } catch (err) {
+      if (err instanceof DashboardConflictError) {
+        lastConflict = err;
+        continue;
+      }
+      throw err;
+    }
+  }
+  const finalError = new Error(
+    `Could not save dashboard "${id}" after ${maxAttempts} attempt(s); it kept changing concurrently. Re-read the dashboard and try again.`,
+  );
+  if (lastConflict !== undefined) {
+    (finalError as Error & { cause?: unknown }).cause = lastConflict;
+  }
+  throw finalError;
+}
+
 export async function listDashboardRevisions(
   dashboardId: string,
   ctx: AccessCtx,