@agent-native/core 0.77.16 → 0.77.18

package/corpus/templates/analytics/app/lib/sql-query.ts

@@ -12,40 +12,114 @@ export interface SqlQueryResult {
   schema?: { name: string; type: string }[];
 }
 
+const MAX_CONCURRENT_SQL_QUERIES = 4;
+
+type PendingSqlQuerySlot = {
+  resolve: (release: () => void) => void;
+  reject: (reason: unknown) => void;
+  signal?: AbortSignal;
+  onAbort: () => void;
+};
+
+let activeSqlQueries = 0;
+const pendingSqlQuerySlots: PendingSqlQuerySlot[] = [];
+
+function createAbortError(): Error {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException("SQL query aborted", "AbortError");
+  }
+  const error = new Error("SQL query aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function createSqlQueryRelease(): () => void {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    activeSqlQueries = Math.max(0, activeSqlQueries - 1);
+    drainSqlQuerySlots();
+  };
+}
+
+function drainSqlQuerySlots(): void {
+  while (
+    activeSqlQueries < MAX_CONCURRENT_SQL_QUERIES &&
+    pendingSqlQuerySlots.length > 0
+  ) {
+    const pending = pendingSqlQuerySlots.shift();
+    if (!pending) return;
+    pending.signal?.removeEventListener("abort", pending.onAbort);
+    if (pending.signal?.aborted) {
+      pending.reject(createAbortError());
+      continue;
+    }
+    activeSqlQueries += 1;
+    pending.resolve(createSqlQueryRelease());
+  }
+}
+
+async function acquireSqlQuerySlot(signal?: AbortSignal): Promise<() => void> {
+  if (signal?.aborted) throw createAbortError();
+  return new Promise((resolve, reject) => {
+    const pending: PendingSqlQuerySlot = {
+      resolve,
+      reject,
+      signal,
+      onAbort: () => {
+        const index = pendingSqlQuerySlots.indexOf(pending);
+        if (index >= 0) pendingSqlQuerySlots.splice(index, 1);
+        reject(createAbortError());
+      },
+    };
+    signal?.addEventListener("abort", pending.onAbort, { once: true });
+    pendingSqlQuerySlots.push(pending);
+    drainSqlQuerySlots();
+  });
+}
+
+async function readSqlQueryError(res: Response): Promise<string> {
+  const body = await res.json().catch(() => ({}));
+  return typeof body?.error === "string"
+    ? body.error
+    : `Query failed (${res.status})`;
+}
+
 export async function executeSqlQuery(
   sql: string,
   source: DataSourceType,
   signal?: AbortSignal,
 ): Promise<SqlQueryResult> {
   const token = await getIdToken();
-  const res = await fetch(appApiPath("/api/sql-query"), {
-    method: "POST",
-    signal,
-    headers: {
-      "Content-Type": "application/json",
-      ...(token && { Authorization: `Bearer ${token}` }),
-    },
-    body: JSON.stringify({ query: sql, source }),
-  });
+  const release = await acquireSqlQuerySlot(signal);
+  let res: Response;
+  try {
+    res = await fetch(appApiPath("/api/sql-query"), {
+      method: "POST",
+      signal,
+      headers: {
+        "Content-Type": "application/json",
+        ...(token && { Authorization: `Bearer ${token}` }),
+      },
+      body: JSON.stringify({ query: sql, source }),
+    });
+  } finally {
+    release();
+  }
 
   if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    return {
-      rows: [],
-      error: body.error || `Query failed (${res.status})`,
-    };
+    throw new Error(await readSqlQueryError(res));
   }
 
   const data = await res.json();
 
   if (typeof data?.error === "string") {
-    return {
-      rows: [],
-      error:
-        typeof data.message === "string" && data.message
-          ? data.message
-          : data.error,
-    };
+    throw new Error(
+      typeof data.message === "string" && data.message
+        ? data.message
+        : data.error,
+    );
   }
 
   if (data.bytesProcessed) {
@@ -68,6 +142,7 @@ export function useSqlQuery(
     refetchOnMount?: boolean | "always";
     refetchOnReconnect?: boolean | "always";
     refetchOnWindowFocus?: boolean | "always";
+    retry?: boolean | number;
     staleTime?: number;
   },
 ) {
@@ -79,6 +154,7 @@ export function useSqlQuery(
     refetchOnMount: options?.refetchOnMount ?? false,
     refetchOnReconnect: options?.refetchOnReconnect ?? false,
     refetchOnWindowFocus: options?.refetchOnWindowFocus ?? false,
+    retry: options?.retry ?? false,
     staleTime: options?.staleTime ?? 5 * 60 * 1000,
   });
 }

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/SqlChartCard.tsx

@@ -6,10 +6,12 @@ import {
   IconDotsVertical,
   IconMaximize,
   IconPencil,
+  IconRefresh,
   IconTrash,
   IconCode,
   IconDownload,
 } from "@tabler/icons-react";
+import { useQueryClient } from "@tanstack/react-query";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { ChartFillHeight, SqlChart } from "@/components/dashboard/SqlChart";
@@ -43,6 +45,7 @@ import {
   TooltipTrigger,
 } from "@/components/ui/tooltip";
 
+import { serializePanelSql } from "./panel-sql";
 import type { SqlPanel } from "./types";
 import { ViewSqlPopover } from "./ViewSqlPopover";
 
@@ -66,6 +69,7 @@ export function SqlChartCard({
   editable = true,
 }: SqlChartCardProps) {
   const t = useT();
+  const queryClient = useQueryClient();
   const {
     attributes,
     listeners,
@@ -95,6 +99,18 @@ export function SqlChartCard({
     setExportCsv(handler ? () => handler : null);
   }, []);
 
+  const handleRefresh = useCallback(() => {
+    setShouldLoadData(true);
+    void queryClient.invalidateQueries({
+      queryKey: [
+        "sql-chart",
+        panel.id,
+        serializePanelSql(resolvedSql ?? panel.sql),
+        panel.source,
+      ],
+    });
+  }, [panel.id, panel.source, panel.sql, queryClient, resolvedSql]);
+
   useEffect(() => {
     if (panel.chartType === "section") {
       setShouldLoadData(true);
@@ -116,7 +132,7 @@ export function SqlChartCard({
         }
       },
       {
-        rootMargin: "800px 0px",
+        rootMargin: "320px 0px",
         threshold: 0.01,
       },
     );
@@ -310,6 +326,11 @@ export function SqlChartCard({
                       {t("sidebar.edit")}
                     </DropdownMenuItem>
                   )}
+                  {!editable ? <DropdownMenuSeparator /> : null}
+                  <DropdownMenuItem onSelect={handleRefresh}>
+                    <IconRefresh className="h-4 w-4 mr-2" />
+                    {t("sqlDashboard.refresh")}
+                  </DropdownMenuItem>
                   {editable ? (
                     <DropdownMenuItem
                       onSelect={(e) => {

package/corpus/templates/analytics/app/root.tsx

@@ -8,7 +8,7 @@ import {
 } from "@agent-native/core/client";
 import { configureTracking } from "@agent-native/core/client";
 import { useQueryClient } from "@tanstack/react-query";
-import { useState } from "react";
+import { useCallback, useState } from "react";
 import { Links, Meta, Outlet, Scripts, ScrollRestoration } from "react-router";
 import type { LinksFunction } from "react-router";
 
@@ -79,12 +79,21 @@ export function Layout({ children }: { children: React.ReactNode }) {
 
 function DbSyncBridge() {
   // Invalidate react-query caches on DB changes (agent edits, other tabs,
-  // cron jobs). The hook invalidates every active query on any non-own
-  // change event, so we no longer need to enumerate dashboard / analysis
-  // / explorer keys here. Screen-refresh is handled automatically inside
-  // AgentSidebar.
+  // cron jobs). SQL chart queries can be expensive, so they stay on explicit
+  // refresh/filter semantics instead of joining the broad action fallback.
+  // Screen-refresh is handled automatically inside AgentSidebar.
   const queryClient = useQueryClient();
-  useDbSync({ queryClient, ignoreSource: TAB_ID });
+  const shouldInvalidateForAction = useCallback(
+    (query: { queryKey: readonly unknown[] }) => {
+      return query.queryKey[0] !== "sql-chart";
+    },
+    [],
+  );
+  useDbSync({
+    queryClient,
+    ignoreSource: TAB_ID,
+    actionInvalidatePredicate: shouldInvalidateForAction,
+  });
   return null;
 }
 

package/corpus/templates/analytics/changelog/2026-06-25-dashboard-charts-no-longer-refresh-in-the-background-during-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-25
+---
+
+Dashboard charts no longer refresh in the background during agent activity and load more steadily on large dashboards.

package/corpus/templates/analytics/changelog/2026-06-25-first-party-dashboards-use-indexed-event-dates-for-faster-da.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-06-25
+---
+
+First-party dashboards use indexed event dates for faster date-range charts.

package/corpus/templates/analytics/changelog/2026-06-25-retention-and-active-user-dashboard-panels-now-count-account.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-25
+---
+
+Retention and active-user dashboard panels now exclude docs traffic, smooth retention cohorts, and use clearer signed-in visitor labels.