@agent-native/core 0.101.10 → 0.101.12

package/corpus/templates/analytics/server/lib/agent-chat-plan-mode.ts

@@ -16,23 +16,32 @@ export const INITIAL_TOOL_NAMES = [
   "list-analyses",
   "get-analysis",
   "save-analysis",
+  // Dashboard/extension INSPECTION stays on the initial surface so a
+  // template-clone request can resolve and inspect the source on the first
+  // turn. The MUTATING writers (update-dashboard, mutate-dashboard,
+  // create-extension, update-extension) are intentionally left off: the
+  // dashboard-construction final-response guard retries with
+  // `expandToolSurface: true` (see server/plugins/agent-chat.ts), which opens
+  // the full run registry exactly when a save is needed, and tool-search can
+  // surface them otherwise. This keeps the first-request surface under the
+  // 40-tool ceiling enforced by scripts/guard-agent-chat-context.ts.
   "get-sql-dashboard",
-  "mutate-dashboard",
+  "list-sql-dashboards",
+  "list-dashboard-templates",
+  "list-extensions",
+  "get-extension",
   "generate-chart",
   "query-agent-native-analytics",
   "bigquery",
   "search-bigquery-schema",
-  "bigquery-table-info",
   "provider-api-catalog",
   "provider-api-docs",
   "provider-api-request",
   "run-code",
   "get-code-execution",
   "provider-corpus-job",
-  "provider-corpus-jobs",
   "query-staged-dataset",
   "list-staged-datasets",
-  "delete-staged-dataset",
   "account-deep-dive",
   "hubspot-deals",
   "hubspot-records",

package/corpus/templates/analytics/server/lib/real-data-actions.ts

@@ -57,6 +57,25 @@ export const CORPUS_SOURCE_ACTIONS = new Set([
 
 export const CORPUS_REDUCTION_ACTIONS = new Set(["run-code"]);
 
+// Inspecting or cloning an existing dashboard/extension template is
+// construction progress, not a metric query. These do not satisfy
+// hasDataQueryAttempt, but they should stop the guard from steering a
+// template-clone turn into "connect a missing source". Deliberately limited
+// to read/inspection actions: update-dashboard/mutate-dashboard/
+// compose-dashboard/install-dashboard-template/create-extension/
+// update-extension can all author brand-new SQL or extension content, so
+// calling one of those alone is not proof the turn actually inspected a
+// template rather than inventing it from scratch. If the tool run also
+// includes one of these read actions, the bypass still applies even when an
+// authoring/save action ran alongside it.
+export const DASHBOARD_CONSTRUCTION_ACTIONS = new Set([
+  "get-sql-dashboard",
+  "list-sql-dashboards",
+  "list-dashboard-templates",
+  "list-extensions",
+  "get-extension",
+]);
+
 const RUN_CODE_BRIDGE_TOOLS_USED = /^bridgeToolsUsed:\s*(.+)$/im;
 
 const MCP_DATA_SOURCE_TOKENS = [
@@ -97,6 +116,41 @@ function isDataQueryActionName(name: string): boolean {
   return DATA_QUERY_ACTIONS.has(normalizeActionToolName(name));
 }
 
+function isDashboardConstructionActionName(name: string): boolean {
+  return DASHBOARD_CONSTRUCTION_ACTIONS.has(normalizeActionToolName(name));
+}
+
+// "Build/clone/template" language targeting a dashboard/extension/panel is
+// dashboard construction, distinct from an analytics-result question. Turns
+// like this may inspect and clone a template without running a metric query.
+const DASHBOARD_CONSTRUCTION_INTENT_TERMS =
+  /\b(build|create|make|clone|copy|duplicate|adapt|template|based (?:off|on)|using .{1,80}? as a template)\b/i;
+
+const DASHBOARD_CONSTRUCTION_TARGET_TERMS =
+  /\b(dashboard|extension|panel|widget)\b/i;
+
+export function looksLikeDashboardConstructionRequest(text: string): boolean {
+  const requestText = stripInjectedAnalyticsGuardContext(text);
+  const lower = requestText.toLowerCase();
+  if (!lower) return false;
+  const wantsBuild = DASHBOARD_CONSTRUCTION_INTENT_TERMS.test(lower);
+  const targetsDashboard =
+    DASHBOARD_CONSTRUCTION_TARGET_TERMS.test(lower) ||
+    lower.includes(REAL_DATA_REQUIRED_MARKER.toLowerCase());
+  return wantsBuild && targetsDashboard;
+}
+
+export function hasDashboardConstructionAttempt(
+  toolResults:
+    | Array<{ name?: string; isError?: boolean; content?: string }>
+    | undefined,
+): boolean {
+  return (toolResults ?? []).some((result) => {
+    if (result.isError) return false;
+    return isDashboardConstructionActionName(String(result.name ?? ""));
+  });
+}
+
 function isCorpusSourceActionName(name: string): boolean {
   return CORPUS_SOURCE_ACTIONS.has(normalizeActionToolName(name));
 }
@@ -253,7 +307,15 @@ export function looksLikeAnalyticsDataRequest(text: string): boolean {
 }
 
 const UNSUPPORTED_RESULT_CLAIM =
-  /(?:\b\d[\d,.]*(?:\.\d+)?\s*(?:%|percent|users?|customers?|accounts?|sessions?|events?|deals?|tickets?|issues?|calls?|messages?|signups?|pageviews?)\b|\$\s*\d|\b(?:data|query|results?)\s+(?:shows?|showed|indicates?|returned|found)\b|\b(?:i found|the top|the bottom|highest|lowest|increased|decreased|grew|declined|converted|churned|retained|averaged|total(?:ed)?|count(?:ed)?)\b)/i;
+  /(?:\b\d[\d,.]*(?:\.\d+)?\s*(?:%|percent|users?|customers?|accounts?|sessions?|events?|deals?|tickets?|issues?|calls?|messages?|signups?|pageviews?)\b|\$\s*\d|\b(?:zero|no|none)\s+(?:users?|customers?|accounts?|sessions?|events?|deals?|tickets?|issues?|calls?|messages?|signups?|pageviews?)\b|\b(?:data|query|results?)\s+(?:shows?|showed|indicates?|returned|found)\b|\b(?:i found|the top|the bottom|highest|lowest|increased|decreased|grew|declined|converted|churned|retained|averaged|total(?:ed)?|count(?:ed)?)\b)/i;
+
+// Reuse the same broad unsupported-result-claim vocabulary that gates
+// isSafeNoDataAnalyticsResponse so a dashboard-construction turn cannot
+// bypass the no-query fallback just by avoiding the narrower set of units a
+// dashboard-specific regex would otherwise miss (e.g. "signups", "accounts").
+export function draftClaimsAnalyticsMetrics(text: string): boolean {
+  return UNSUPPORTED_RESULT_CLAIM.test(String(text ?? "").trim());
+}
 
 export const GENERIC_NO_DATA_FALLBACK_MESSAGE =
   "I can't provide a grounded analytics result yet because no real data-source query ran successfully. Tell me which source to use or connect the missing source, and I'll run it before giving numbers or source-record conclusions.";

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -14,7 +14,9 @@ import {
 import { ANALYTICS_CONNECTOR_CATALOG } from "../lib/analytics-connector-catalog";
 import { credentialProviderConfigs } from "../lib/credential-keys";
 import {
+  draftClaimsAnalyticsMetrics,
   failedDataQueryAttemptMessage,
+  hasDashboardConstructionAttempt,
   hasExplicitPartialDisclosure,
   hasFailedCorpusWorkflowEvidence,
   hasDataQueryAttempt,
@@ -23,6 +25,7 @@ import {
   isSafeNoDataAnalyticsResponse,
   hasOverstatedCoverageConfidenceClaim,
   looksLikeCoverageSensitiveAnalyticsRequest,
+  looksLikeDashboardConstructionRequest,
   looksLikeStrongCoverageClaim,
   looksLikeAnalyticsDataRequest,
   needsCorpusWorkflowForCoverageSensitiveRequest,
@@ -522,6 +525,33 @@ export function realDataFinalGuard(
         "I can't make a confident exhaustive analytics claim yet because part of the source evidence was aborted, truncated, or still paginated. I need to recover the missing coverage or state the answer as partial with the inspected sample size.",
     };
   }
+  // Dashboard construction/template-clone turns may inspect and clone an
+  // existing dashboard/extension without running a metric query, as long as
+  // the draft does not invent numbers. Check this before the generic
+  // "no data query ran" fallback so a template-based extension clone is not
+  // treated the same as an unanswerable analytics-result question.
+  if (
+    looksLikeDashboardConstructionRequest(userText) &&
+    !draftClaimsAnalyticsMetrics(context.text)
+  ) {
+    if (
+      hasDashboardConstructionAttempt(context.toolResults) ||
+      isSafeNoDataAnalyticsResponse(context.text)
+    ) {
+      return null;
+    }
+    return {
+      retryMessage:
+        'This is a dashboard construction/template-clone request. Resolve the named template\'s id (use `list-sql-dashboards` if you only have a title) and call `get-sql-dashboard` with `includeConfig: true` first. If its panels are `chartType: "extension"`, use `get-extension` then `create-extension` to clone/adapt it, then `update-dashboard` to save the new dashboard. Do not invent SQL panels for an extension-backed template. Ask one clarifying filter question if needed. Only run a data-source query before presenting numbers or authoring invented SQL.',
+      fallbackMessage:
+        "I need to inspect the template dashboard (and its extension, if it uses one) before creating the new one. Tell me the template dashboard name, or confirm the org/account filter, and I'll clone it without inventing metrics.",
+      // list-sql-dashboards/list-dashboard-templates are on the initial
+      // surface, but expand anyway so a corrective retry can always reach
+      // the lookup/inspection tools this message asks for.
+      expandToolSurface: true,
+    };
+  }
+
   if (dataQueryAttempted) return null;
   if (isSafeNoDataAnalyticsResponse(context.text)) {
     if (firstPartySourceShouldBeTried) {

package/corpus/templates/content/.agents/skills/document-editing/SKILL.md

@@ -145,6 +145,29 @@ Always run this after any document modification to update the sidebar.
 
 Documents use **markdown** for content. The editor renders markdown in real time.
 
+### Math
+
+Content renders LaTeX with KaTeX while preserving the source in NFM. Use the
+canonical Content delimiters when an agent creates or edits math:
+
+```md
+Inline math: The relationship is $`E = mc^2`$ in this example.
+
+Block math:
+
+$$
+\int_0^1 x^2 dx = \frac{1}{3}
+$$
+```
+
+- Inline math uses ``$`...`$``. Do not substitute ordinary `$...$`; dollar
+  amounts in prose are intentionally not interpreted as equations.
+- Block equations use `$$` on their own lines before and after the LaTeX.
+- Keep the raw LaTeX intact when editing around an equation. Invalid or
+  unsupported expressions remain visible as source so they can be repaired.
+- Markdown exports preserve these delimiters. HTML and PDF-ready exports render
+  the equation.
+
 ## Parent-Child Hierarchy
 
 Documents form a tree via `parent_id`:

package/corpus/templates/content/app/components/editor/MathRenderer.tsx

@@ -0,0 +1,43 @@
+import { renderMathToHtml } from "@shared/math-rendering";
+import { useMemo } from "react";
+
+interface MathRendererProps {
+  latex: string;
+  displayMode: boolean;
+}
+
+export function MathRenderer({ latex, displayMode }: MathRendererProps) {
+  const rendered = useMemo(
+    () => renderMathToHtml(latex, displayMode),
+    [displayMode, latex],
+  );
+
+  if (!rendered.ok) {
+    return (
+      <code
+        className={
+          displayMode
+            ? "content-math-error content-math-error--block"
+            : "content-math-error content-math-error--inline"
+        }
+        title={rendered.error}
+      >
+        {latex || "Empty equation"}
+      </code>
+    );
+  }
+
+  return displayMode ? (
+    <span
+      className="content-math content-math--block"
+      contentEditable={false}
+      dangerouslySetInnerHTML={{ __html: rendered.html }}
+    />
+  ) : (
+    <span
+      className="content-math content-math--inline"
+      contentEditable={false}
+      dangerouslySetInnerHTML={{ __html: rendered.html }}
+    />
+  );
+}

package/corpus/templates/content/app/components/editor/SlashCommandMenu.tsx

@@ -1,8 +1,10 @@
 import { useSendToAgentChat, useT } from "@agent-native/core/client";
 import type { CreateInlineDatabaseResponse } from "@shared/api";
+import { renderMathToHtml } from "@shared/math-rendering";
 import { collapseExactRepeatedNfm, docToNfm } from "@shared/nfm";
 import { serializeRegistryBlockToMdx } from "@shared/nfm-registry";
 import {
+  IconCheck,
   IconTypography,
   IconH1,
   IconH2,
@@ -23,6 +25,8 @@ import {
   IconFileText,
   IconDatabase,
   IconVideo,
+  IconMathFunction,
+  IconSquareRoot2,
 } from "@tabler/icons-react";
 import { Editor } from "@tiptap/react";
 import { useState, useEffect, useCallback, useRef, useMemo } from "react";
@@ -30,6 +34,7 @@ import { useNavigate } from "react-router";
 import { toast } from "sonner";
 
 import { contentBlockRegistry } from "@/blocks/contentBlockRegistry";
+import { Button } from "@/components/ui/button";
 import {
   Popover,
   PopoverContent,
@@ -42,6 +47,7 @@ import { localContentComponents } from "@/local-components";
 
 import { focusMostRecentEmptyToggleSummary } from "./extensions/NotionExtensions";
 import { buildLocalComponentSlashItems } from "./localComponentSlashItems";
+import { MathRenderer } from "./MathRenderer";
 import { buildRegistrySlashItems } from "./registrySlashItems";
 
 interface SlashCommandMenuProps {
@@ -64,6 +70,13 @@ interface EditorMenuPosition {
   left: number;
 }
 
+interface EquationDraft {
+  displayMode: boolean;
+  insertionRange: { from: number; to: number };
+  slashRange: { from: number; to: number };
+  position: EditorMenuPosition;
+}
+
 interface CommandItem {
   title: string;
   description: string;
@@ -178,6 +191,47 @@ export function insertInlineDatabaseBlock(
     : chain.insertContent(content).run();
 }
 
+export function equationNodeContent(latex: string, displayMode: boolean) {
+  return displayMode
+    ? {
+        type: "notionBlockAtom",
+        attrs: { tagName: "equation", attrsJson: "{}", label: latex },
+      }
+    : {
+        type: "notionInlineAtom",
+        attrs: { tagName: "math", attrsJson: "{}", label: latex },
+      };
+}
+
+export function insertEquation(
+  editor: Editor,
+  latex: string,
+  displayMode: boolean,
+  range: { from: number; to: number },
+) {
+  const content = equationNodeContent(latex, displayMode);
+  return editor
+    .chain()
+    .focus()
+    .insertContentAt(
+      range,
+      displayMode ? [content, { type: "paragraph" }] : content,
+    )
+    .run();
+}
+
+export function getEquationInsertionRange(
+  editor: Editor,
+  slashRange: { from: number; to: number },
+  displayMode: boolean,
+) {
+  if (!displayMode) return slashRange;
+  const resolved = editor.state.doc.resolve(slashRange.from);
+  return resolved.parent.isTextblock
+    ? { from: resolved.before(), to: resolved.after() }
+    : slashRange;
+}
+
 const commands: CommandTemplate[] = [
   {
     titleKey: "editor.slash.text",
@@ -460,6 +514,16 @@ export function SlashCommandMenu({
   );
   const generateTextareaRef = useRef<HTMLTextAreaElement>(null);
 
+  const [equationDraft, setEquationDraft] = useState<EquationDraft | null>(
+    null,
+  );
+  const [equationLatex, setEquationLatex] = useState("");
+  const equationInputRef = useRef<HTMLTextAreaElement>(null);
+  const equationResult = useMemo(
+    () => renderMathToHtml(equationLatex, equationDraft?.displayMode ?? false),
+    [equationDraft?.displayMode, equationLatex],
+  );
+
   const submitGeneratePrompt = useCallback(
     (prompt: string) => {
       const trimmed = prompt.trim();
@@ -684,6 +748,80 @@ export function SlashCommandMenu({
     },
   };
 
+  const openEquationComposer = useCallback(
+    (displayMode: boolean, slashRange: { from: number; to: number } | null) => {
+      const menuPosition = position ?? getSelectionMenuPosition();
+      if (!slashRange || !menuPosition) return false;
+      setEquationLatex("");
+      setEquationDraft({
+        displayMode,
+        slashRange,
+        insertionRange: getEquationInsertionRange(
+          editor,
+          slashRange,
+          displayMode,
+        ),
+        position: menuPosition,
+      });
+      setTimeout(() => equationInputRef.current?.focus(), 0);
+      return true;
+    },
+    [editor, getSelectionMenuPosition, position],
+  );
+
+  const cancelEquation = useCallback(() => {
+    const draft = equationDraft;
+    setEquationDraft(null);
+    setEquationLatex("");
+    if (draft) {
+      editor.chain().focus().deleteRange(draft.slashRange).run();
+    }
+  }, [editor, equationDraft]);
+
+  const submitEquation = useCallback(() => {
+    if (!equationDraft || !equationResult.ok) return;
+    const latex = equationLatex.trim();
+    const { displayMode, insertionRange } = equationDraft;
+    setEquationDraft(null);
+    setEquationLatex("");
+    const inserted = insertEquation(editor, latex, displayMode, insertionRange);
+    if (!inserted) {
+      toast.error(t("editor.slash.equationInsertFailed"));
+      return;
+    }
+    void onDraftCommitted?.();
+  }, [
+    editor,
+    equationDraft,
+    equationLatex,
+    equationResult.ok,
+    onDraftCommitted,
+    t,
+  ]);
+
+  const equationCommands: CommandItem[] = isTurnInto
+    ? []
+    : [
+        {
+          title: t("editor.slash.blockEquation"),
+          description: t("editor.slash.blockEquationDescription"),
+          searchText: "latex katex math formula",
+          icon: IconMathFunction,
+          preserveSlashRange: true,
+          action: (_editor, { slashRange }) =>
+            openEquationComposer(true, slashRange),
+        },
+        {
+          title: t("editor.slash.inlineEquation"),
+          description: t("editor.slash.inlineEquationDescription"),
+          searchText: "latex katex math formula",
+          icon: IconSquareRoot2,
+          preserveSlashRange: true,
+          action: (_editor, { slashRange }) =>
+            openEquationComposer(false, slashRange),
+        },
+      ];
+
   // Registry-derived block items (the shared dev-doc / OpenAPI / structured
   // library). Filtered to Notion-compatible specs when the document is linked to
   // a Notion page. "Turn into" only converts the current text block, so these
@@ -713,9 +851,10 @@ export function SlashCommandMenu({
     title: t(cmd.titleKey),
     description: t(cmd.descriptionKey),
   });
-  const blockCommands = (isTurnInto ? turnIntoCommands : commands).map(
-    localizeCommand,
-  );
+  const blockCommands = [
+    ...(isTurnInto ? turnIntoCommands : commands).map(localizeCommand),
+    ...equationCommands,
+  ];
   const pageCommands = isTurnInto ? [] : [pageCommand, databaseCommand];
   const mediaCommands = isTurnInto
     ? []
@@ -1042,7 +1181,7 @@ export function SlashCommandMenu({
             align="start"
             side="bottom"
             className="w-[calc(100vw-2rem)] max-w-80 rounded-xl p-0"
-            onOpenAutoFocus={(e) => {
+            onOpenAutoFocus={(e: Event) => {
               e.preventDefault();
               generateTextareaRef.current?.focus();
             }}
@@ -1086,6 +1225,123 @@ export function SlashCommandMenu({
           </PopoverContent>
         </Popover>
       )}
+
+      {equationDraft && (
+        <Popover
+          open
+          onOpenChange={(open: boolean) => {
+            if (!open) cancelEquation();
+          }}
+        >
+          <PopoverTrigger asChild>
+            <span
+              className="pointer-events-none absolute size-0"
+              style={{
+                top: equationDraft.position.top,
+                left: Math.min(equationDraft.position.left, 16),
+              }}
+            />
+          </PopoverTrigger>
+          <PopoverContent
+            align="start"
+            side="bottom"
+            className="w-[calc(100vw-2rem)] max-w-md rounded-xl p-0"
+            onOpenAutoFocus={(event: Event) => {
+              event.preventDefault();
+              equationInputRef.current?.focus();
+            }}
+          >
+            <div className="p-4">
+              <div className="flex items-center gap-2 text-sm font-semibold">
+                {equationDraft.displayMode ? (
+                  <IconMathFunction
+                    className="text-muted-foreground"
+                    size={16}
+                  />
+                ) : (
+                  <IconSquareRoot2
+                    className="text-muted-foreground"
+                    size={16}
+                  />
+                )}
+                {equationDraft.displayMode
+                  ? t("editor.slash.blockEquation")
+                  : t("editor.slash.inlineEquation")}
+              </div>
+              <textarea
+                ref={equationInputRef}
+                value={equationLatex}
+                onChange={(event) => setEquationLatex(event.target.value)}
+                onKeyDown={(event) => {
+                  if (
+                    event.key === "Enter" &&
+                    (event.metaKey || event.ctrlKey) &&
+                    equationResult.ok
+                  ) {
+                    event.preventDefault();
+                    submitEquation();
+                  }
+                  if (event.key === "Escape") {
+                    event.preventDefault();
+                    cancelEquation();
+                  }
+                }}
+                rows={equationDraft.displayMode ? 3 : 2}
+                placeholder={t("editor.slash.equationPlaceholder")}
+                aria-label={t("editor.slash.equationInputLabel")}
+                aria-invalid={equationLatex.length > 0 && !equationResult.ok}
+                aria-describedby="equation-preview-status"
+                className="mt-3 w-full resize-y rounded-lg border border-input bg-background px-3 py-2 font-mono text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              />
+              <div className="mt-3 min-h-20 rounded-lg border border-border bg-muted/30 p-3">
+                <div className="mb-2 text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                  {t("editor.slash.equationPreview")}
+                </div>
+                <div className="flex min-h-9 items-center justify-center overflow-x-auto text-foreground">
+                  {equationResult.ok ? (
+                    <MathRenderer
+                      latex={equationLatex}
+                      displayMode={equationDraft.displayMode}
+                    />
+                  ) : (
+                    <span className="text-sm text-muted-foreground">
+                      {equationLatex
+                        ? t("editor.slash.equationNeedsRepair")
+                        : t("editor.slash.equationPreviewEmpty")}
+                    </span>
+                  )}
+                </div>
+              </div>
+              <p
+                id="equation-preview-status"
+                className={cn(
+                  "mt-2 min-h-5 text-xs",
+                  equationLatex && !equationResult.ok
+                    ? "text-destructive"
+                    : "text-muted-foreground",
+                )}
+              >
+                {equationLatex && !equationResult.ok
+                  ? equationResult.error
+                  : t("editor.slash.equationSubmitHint")}
+              </p>
+            </div>
+            <div className="flex items-center justify-end gap-2 border-t border-border px-4 py-3">
+              <Button variant="ghost" size="sm" onClick={cancelEquation}>
+                {t("editor.slash.cancelEquation")}
+              </Button>
+              <Button
+                size="sm"
+                onClick={submitEquation}
+                disabled={!equationResult.ok}
+              >
+                <IconCheck />
+                {t("editor.slash.insertEquation")}
+              </Button>
+            </div>
+          </PopoverContent>
+        </Popover>
+      )}
     </>
   );
 }