@agent-native/core 0.90.10 → 0.91.0

package/corpus/templates/analytics/server/jobs/uptime-monitors.ts

@@ -0,0 +1,123 @@
+/**
+ * Uptime monitor sweep. Mirrors server/jobs/analytics-alerts.ts: selects
+ * monitors that are due (their interval elapsed since the last check), claims
+ * each one atomically so parallel sweeps can't double-run it, probes it,
+ * records the result, opens/resolves incidents + notifies, and prunes old
+ * results so the history table stays bounded.
+ *
+ * Exported so a deployment-specific scheduled function (cron / Netlify
+ * scheduled function) can drive it without relying on a long-lived process.
+ */
+import {
+  claimMonitorRun,
+  evaluateAndNotifyMonitor,
+  listDueMonitors,
+  monitorAllowPrivateHosts,
+  pruneOldCheckResults,
+  recordMonitorResult,
+  runMonitorCheck,
+  type Monitor,
+} from "../lib/uptime-monitors";
+
+let running = false;
+let listFailureLogged = false;
+const DEFAULT_MAX_MONITORS_PER_SWEEP = 100;
+
+function maxMonitorsPerSweep(input?: number): number {
+  if (input) return Math.max(1, Math.min(500, Math.floor(input)));
+  const raw = process.env.UPTIME_MONITOR_SWEEP_LIMIT?.trim();
+  if (!raw) return DEFAULT_MAX_MONITORS_PER_SWEEP;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0
+    ? parsed
+    : DEFAULT_MAX_MONITORS_PER_SWEEP;
+}
+
+export interface UptimeSweepResult {
+  processed: number;
+  up: number;
+  failing: number;
+  failed: number;
+  remaining: number;
+}
+
+/**
+ * Run one uptime sweep. When `ownerEmail`/`orgId` are provided the sweep is
+ * scoped to that user (used by the on-demand run-monitors action); otherwise
+ * it runs across every owner (the background cron).
+ */
+export async function runDueMonitorsOnce(
+  options: {
+    ownerEmail?: string;
+    orgId?: string | null;
+    limit?: number;
+  } = {},
+): Promise<UptimeSweepResult> {
+  if (running) {
+    return { processed: 0, up: 0, failing: 0, failed: 0, remaining: 0 };
+  }
+  running = true;
+  let processed = 0;
+  let up = 0;
+  let failing = 0;
+  let failed = 0;
+  let remaining = 0;
+
+  try {
+    const sweepLimit = maxMonitorsPerSweep(options.limit);
+    const allowPrivateHosts = monitorAllowPrivateHosts();
+
+    let monitors: Monitor[];
+    try {
+      monitors = await listDueMonitors({
+        limit: sweepLimit,
+        ownerEmail: options.ownerEmail,
+        orgId: options.orgId,
+      });
+    } catch (err) {
+      // Schema not migrated yet or a transient DB error — don't let one bad
+      // sweep crash every interval firing. Log once per process.
+      if (!listFailureLogged) {
+        console.error(
+          "[uptime-monitors] Failed to list due monitors; skipping this sweep:",
+          err,
+        );
+        listFailureLogged = true;
+      }
+      return { processed: 0, up: 0, failing: 0, failed: 0, remaining: 0 };
+    }
+    listFailureLogged = false;
+    remaining = monitors.length >= sweepLimit ? 1 : 0;
+
+    for (const monitor of monitors) {
+      try {
+        const claimed = await claimMonitorRun(monitor);
+        if (!claimed) continue;
+        processed++;
+        const outcome = await runMonitorCheck(monitor, { allowPrivateHosts });
+        await recordMonitorResult(monitor, outcome);
+        await evaluateAndNotifyMonitor(monitor, outcome, {
+          email: monitor.ownerEmail,
+          orgId: monitor.orgId,
+        });
+        if (outcome.ok) up++;
+        else failing++;
+      } catch (err) {
+        failed++;
+        console.error(
+          `[uptime-monitors] Monitor ${monitor.id} (${monitor.name}) failed:`,
+          err,
+        );
+      }
+    }
+
+    // Retention prune — best-effort, never fail the sweep over it.
+    await pruneOldCheckResults().catch((err) =>
+      console.error("[uptime-monitors] result prune failed:", err),
+    );
+  } finally {
+    running = false;
+  }
+
+  return { processed, up, failing, failed, remaining };
+}

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

@@ -1,5 +1,44 @@
 import type { ActionEntry } from "@agent-native/core/server";
 
+export const INITIAL_TOOL_NAMES = [
+  "view-screen",
+  "data-source-status",
+  "list-analyses",
+  "get-analysis",
+  "save-analysis",
+  "rename-analysis",
+  "delete-analysis",
+  "get-sql-dashboard",
+  "mutate-dashboard",
+  "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",
+  "hubspot-pipelines",
+  "gong-calls",
+  "github-repo-files",
+  "jira-search",
+  "slack-messages",
+  "sentry",
+  "list-data-dictionary",
+  "save-data-dictionary-entry",
+  "navigate",
+];
+
 export const PLAN_MODE_ACT_ONLY_TOOLS = new Set([
   "query-agent-native-analytics",
   "bigquery",
@@ -9,7 +48,9 @@ export const PLAN_MODE_ACT_ONLY_TOOLS = new Set([
   "account-deep-dive",
   "hubspot-deals",
   "hubspot-records",
+  "hubspot-pipelines",
   "gong-calls",
+  "github-repo-files",
   "jira-search",
   "slack-messages",
   "sentry",

package/corpus/templates/analytics/server/lib/data-dictionary-context.ts

@@ -1,5 +1,7 @@
 type DictionaryEntry = Record<string, unknown>;
 
+const MAX_INJECTED_ENTRIES = 40;
+
 function compact(value: unknown, max = 240): string {
   const text = String(value ?? "")
     .replace(/\s+/g, " ")
@@ -72,6 +74,29 @@ function renderEntry(
   return lines;
 }
 
+function takeWithinBudget<T>(
+  entries: T[],
+  renderedCount: number,
+): { entries: T[]; renderedCount: number; omitted: number } {
+  const remaining = Math.max(0, MAX_INJECTED_ENTRIES - renderedCount);
+  const selected = entries.slice(0, remaining);
+  return {
+    entries: selected,
+    renderedCount: renderedCount + selected.length,
+    omitted: entries.length - selected.length,
+  };
+}
+
+function renderOmittedDictionaryEntries(omitted: number): string[] {
+  if (omitted <= 0) return [];
+  return [
+    `${omitted} additional data-dictionary entr${
+      omitted === 1 ? "y was" : "ies were"
+    } omitted from prompt context for efficiency. Call \`list-data-dictionary\` with a focused \`search\` or \`department\` filter before writing SQL or making claims that may depend on omitted definitions.`,
+    "",
+  ];
+}
+
 /**
  * Render data-dictionary entries as compact prompt context.
  *
@@ -100,6 +125,8 @@ export function renderDataDictionary(entries: DictionaryEntry[]): string {
     ),
   );
   const includeAiSuggestions = approved.length + humanUnreviewed.length === 0;
+  let renderedCount = 0;
+  let omittedEntries = 0;
 
   const lines: string[] = [
     "<data-dictionary>",
@@ -110,27 +137,42 @@ export function renderDataDictionary(entries: DictionaryEntry[]): string {
   ];
 
   if (approved.length) {
-    lines.push("## Approved canonical entries");
-    for (const entry of approved) {
-      lines.push(...renderEntry(entry, "approved/canonical"));
+    const budgeted = takeWithinBudget(approved, renderedCount);
+    renderedCount = budgeted.renderedCount;
+    omittedEntries += budgeted.omitted;
+    if (budgeted.entries.length) {
+      lines.push("## Approved canonical entries");
+      for (const entry of budgeted.entries) {
+        lines.push(...renderEntry(entry, "approved/canonical"));
+      }
+      lines.push("");
     }
-    lines.push("");
   }
 
   if (humanUnreviewed.length) {
-    lines.push("## Unreviewed human-authored entries");
-    for (const entry of humanUnreviewed) {
-      lines.push(...renderEntry(entry, "unreviewed/human"));
+    const budgeted = takeWithinBudget(humanUnreviewed, renderedCount);
+    renderedCount = budgeted.renderedCount;
+    omittedEntries += budgeted.omitted;
+    if (budgeted.entries.length) {
+      lines.push("## Unreviewed human-authored entries");
+      for (const entry of budgeted.entries) {
+        lines.push(...renderEntry(entry, "unreviewed/human"));
+      }
+      lines.push("");
     }
-    lines.push("");
   }
 
   if (includeAiSuggestions && aiSuggestions.length) {
-    lines.push("## AI-generated suggestions");
-    for (const entry of aiSuggestions) {
-      lines.push(...renderEntry(entry, "ai-suggestion"));
+    const budgeted = takeWithinBudget(aiSuggestions, renderedCount);
+    renderedCount = budgeted.renderedCount;
+    omittedEntries += budgeted.omitted;
+    if (budgeted.entries.length) {
+      lines.push("## AI-generated suggestions");
+      for (const entry of budgeted.entries) {
+        lines.push(...renderEntry(entry, "ai-suggestion"));
+      }
+      lines.push("");
     }
-    lines.push("");
   } else if (aiSuggestions.length) {
     lines.push(
       `${aiSuggestions.length} AI-generated unapproved suggestion${
@@ -140,6 +182,7 @@ export function renderDataDictionary(entries: DictionaryEntry[]): string {
     );
   }
 
+  lines.push(...renderOmittedDictionaryEntries(omittedEntries));
   lines.push("</data-dictionary>");
   return lines.join("\n");
 }