@agent-native/core 0.90.11 → 0.91.1

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

@@ -115,6 +115,7 @@ export default defineAction({
   description:
     "Save an ad-hoc analysis as a reusable artifact. Do not call this for ordinary in-chat analysis or deep-dive answers unless the user explicitly asks to save/create a reusable analysis, or this turn is re-running an existing saved analysis. Stores the analysis question, instructions for re-running, data sources used, and compact results. " +
     "This creates a reusable analysis that anyone can re-run later to get updated results. " +
+    "Saved analyses appear in the Analyses sidebar, so do not use this as scratch storage, as a transient summary, or as a duplicate companion artifact when creating a dashboard or extension unless the user explicitly asked for a saved analysis too. " +
     "Call this only after you've gathered real evidence and include non-empty, compact resultData with structured evidence from those data-source action results. For qualitative analyses, resultData may include call/message IDs, short transcript excerpts, coded themes, mention counts, and sentiment labels derived from actual source records. Never include full Gong transcripts, full tool outputs, or bulk raw provider payloads.",
   schema: z.object({
     id: z

package/corpus/templates/analytics/actions/save-monitor.ts

@@ -0,0 +1,145 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { hostFromUrl, saveMonitor } from "../server/lib/uptime-monitors";
+
+/**
+ * Friendly default name from a URL: the host without a leading `www.`
+ * (e.g. `example.com` from `https://www.example.com/health`). Keeps
+ * agent-created monitors sensible when no name is provided.
+ */
+function deriveNameFromUrl(url: string): string {
+  return hostFromUrl((url ?? "").trim()).replace(/^www\./i, "");
+}
+
+const assertionSchema = z.object({
+  type: z
+    .enum([
+      "body_contains",
+      "body_absent",
+      "header_contains",
+      "header_equals",
+      "max_latency_ms",
+    ])
+    .describe(
+      "Assertion type: body_contains/body_absent check the response text; header_contains/header_equals check a response header; max_latency_ms flags a slow response (degraded).",
+    ),
+  value: z
+    .union([z.string(), z.number()])
+    .describe(
+      "Expected value: text for body/header checks, milliseconds for max_latency_ms.",
+    ),
+  header: z
+    .string()
+    .optional()
+    .describe("Header name (required for header_contains / header_equals)."),
+});
+
+const statusMatcherSchema = z
+  .union([
+    z.object({
+      mode: z.literal("class"),
+      classes: z
+        .array(z.string())
+        .describe('Status classes to accept, e.g. ["2xx","3xx"].'),
+    }),
+    z.object({
+      mode: z.literal("list"),
+      codes: z
+        .array(z.number().int())
+        .describe("Exact status codes to accept, e.g. [200,204]."),
+    }),
+    z.object({
+      mode: z.literal("range"),
+      min: z.number().int(),
+      max: z.number().int(),
+    }),
+  ])
+  .describe(
+    "Which HTTP status counts as healthy. Defaults to the 2xx class when omitted.",
+  );
+
+export default defineAction({
+  description:
+    "Create or update an uptime monitor that pings a URL on a schedule and alerts when it is down, returns the wrong status, is too slow, or its body is missing/contains specific text.",
+  schema: z.object({
+    id: z.string().optional().describe("Existing monitor id to update."),
+    name: z
+      .string()
+      .optional()
+      .describe(
+        "Human-readable monitor name. Optional — defaults to the URL host (without www) when omitted or blank.",
+      ),
+    url: z.string().describe("Absolute http(s) URL to probe."),
+    method: z
+      .enum(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"])
+      .optional()
+      .describe("HTTP method for the probe (default GET)."),
+    requestHeaders: z
+      .record(z.string(), z.string())
+      .optional()
+      .describe("Extra request headers as a key/value object."),
+    requestBody: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Optional request body for POST/PUT/PATCH."),
+    intervalSeconds: z
+      .number()
+      .int()
+      .min(30)
+      .max(86400)
+      .optional()
+      .describe("How often to check, in seconds (default 300, min 30)."),
+    timeoutMs: z
+      .number()
+      .int()
+      .min(1000)
+      .max(120000)
+      .optional()
+      .describe("Request timeout in milliseconds (default 15000)."),
+    expectedStatus: statusMatcherSchema.optional(),
+    assertions: z
+      .array(assertionSchema)
+      .optional()
+      .describe("Response-body/header/latency assertions to evaluate."),
+    followRedirects: z
+      .boolean()
+      .optional()
+      .describe("Follow 3xx redirects to allowed hosts (default true)."),
+    severity: z
+      .enum(["warning", "critical"])
+      .optional()
+      .describe("Alert severity when the monitor fails (default critical)."),
+    channels: z
+      .array(z.string())
+      .optional()
+      .describe("Notification channels, e.g. inbox, email, slack, webhook."),
+    emailRecipients: z
+      .array(z.string().email())
+      .optional()
+      .describe("Email recipients used by the email channel."),
+    cooldownMinutes: z
+      .number()
+      .int()
+      .min(0)
+      .max(1440)
+      .optional()
+      .describe(
+        "Minutes to suppress a repeat 'down' alert after a recent recovery (anti-flap; default 15).",
+      ),
+    enabled: z.boolean().optional().describe("Whether the monitor is active."),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    const name = args.name?.trim() || deriveNameFromUrl(args.url);
+    return saveMonitor({ ...args, name }, { email, orgId });
+  },
+});

package/corpus/templates/analytics/actions/save-status-page.ts

@@ -0,0 +1,47 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { saveStatusPage } from "../server/lib/status-pages";
+
+export default defineAction({
+  description:
+    "Create or update a public status page. Pass id to update, omit to create. Include monitors to set the full included set (each with an optional display-name override and per-monitor showUrl opt-in).",
+  schema: z.object({
+    id: z.string().optional().describe("Status page id (omit to create)."),
+    slug: z
+      .string()
+      .optional()
+      .describe("Public URL slug; auto-derived from the title when omitted."),
+    title: z.string().optional().describe("Status page title."),
+    description: z.string().nullable().optional(),
+    published: z
+      .boolean()
+      .optional()
+      .describe("Whether the page is publicly readable."),
+    showUptimeBars: z.boolean().optional(),
+    showOverallUptime: z.boolean().optional(),
+    showResponseTime: z.boolean().optional(),
+    density: z.enum(["comfortable", "compact"]).optional(),
+    alignment: z.enum(["left", "center"]).optional(),
+    monitors: z
+      .array(
+        z.object({
+          monitorId: z.string(),
+          displayName: z.string().nullable().optional(),
+          showUrl: z.boolean().optional(),
+        }),
+      )
+      .optional()
+      .describe("Full set of included monitors, in display order."),
+  }),
+  run: async (input) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return saveStatusPage(input, { email, orgId });
+  },
+});

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

@@ -12,6 +12,7 @@ import { z } from "zod";
 import { listAnalyticsAlertRules } from "../server/lib/analytics-alerts";
 import { listDashboardCatalog } from "../server/lib/dashboard-catalog";
 import { getAnalysis, getDashboard } from "../server/lib/dashboards-store";
+import { getErrorIssue, listErrorIssues } from "../server/lib/error-capture.js";
 import { listAnalyticsPublicKeys } from "../server/lib/first-party-analytics.js";
 import {
   getSessionReplaySummary,
@@ -19,6 +20,11 @@ import {
   replayRangeToIso,
   type ReplayRange,
 } from "../server/lib/session-replay.js";
+import {
+  getStatusPagePreview,
+  listStatusPages,
+} from "../server/lib/status-pages.js";
+import { getMonitor, listMonitors } from "../server/lib/uptime-monitors.js";
 
 const SESSION_FILTER_KEYS = new Set(["range", "app", "q"]);
 const REPLAY_RANGES = new Set(["24h", "7d", "30d", "90d", "all"]);
@@ -150,6 +156,212 @@ export default defineAction({
           screen.sessionReplayError = error?.message || String(error);
         }
       }
+    } else if (nav?.view === "monitoring") {
+      screen.page = "monitoring";
+      const monitoringView =
+        nav?.monitoringView === "errors" ? "errors" : "uptime";
+      screen.monitoringView = monitoringView;
+      screen.monitoringSurfaces = [
+        {
+          id: "uptime",
+          label: "Uptime",
+          path: "/monitoring",
+          includes: [
+            "synthetic HTTP/status uptime checks",
+            "latency + body/header assertions",
+            "incidents",
+            "down/degraded alerting",
+          ],
+        },
+        {
+          id: "status-pages",
+          label: "Status pages",
+          path: "/monitoring?statuspage=list",
+          includes: [
+            "public status page config (under the uptime subview)",
+            "monitor selection + ordering",
+            "publish / slug management",
+            "public URL /status/<slug>",
+          ],
+        },
+        {
+          id: "errors",
+          label: "Errors",
+          path: "/monitoring?view=errors",
+          includes: [
+            "captured JavaScript exceptions",
+            "grouped error issues",
+            "linked session replays",
+          ],
+        },
+      ];
+      const email = getRequestUserEmail();
+      if (email) {
+        const orgId = getRequestOrgId() || null;
+        try {
+          if (monitoringView === "errors") {
+            if (nav?.errorIssueId) {
+              screen.errorIssueId = nav.errorIssueId;
+              const detail = await getErrorIssue(
+                { userEmail: email, orgId },
+                nav.errorIssueId,
+              );
+              const issue = detail.issue;
+              const sample = detail.events[0];
+              screen.errorIssue = {
+                id: issue.id,
+                title: issue.title,
+                type: issue.type,
+                culprit: issue.culprit,
+                level: issue.level,
+                status: issue.status,
+                firstSeenAt: issue.firstSeenAt,
+                lastSeenAt: issue.lastSeenAt,
+                eventCount: issue.eventCount,
+                usersAffected: issue.usersAffected,
+                assignee: issue.assignee,
+                app: issue.app,
+                template: issue.template,
+                lastSessionRecordingPath: issue.lastSessionRecordingPath,
+                sampleEvent: sample
+                  ? {
+                      message: sample.message,
+                      culprit: sample.culprit,
+                      handled: sample.handled,
+                      url: sample.url,
+                      occurredAt: sample.occurredAt,
+                      sessionRecordingPath: sample.sessionRecordingPath,
+                    }
+                  : null,
+                linkedSessions: detail.sessions.slice(0, 5),
+              };
+            } else {
+              const issues = await listErrorIssues(
+                { userEmail: email, orgId },
+                { status: "unresolved", limit: 25 },
+              );
+              screen.errorIssues = issues.map((issue) => ({
+                id: issue.id,
+                title: issue.title,
+                culprit: issue.culprit,
+                level: issue.level,
+                status: issue.status,
+                eventCount: issue.eventCount,
+                usersAffected: issue.usersAffected,
+                lastSeenAt: issue.lastSeenAt,
+              }));
+            }
+          } else if (nav?.statusPageId) {
+            // Status pages are a config sub-view under the uptime panel.
+            screen.uptimeSubview = "status-pages";
+            if (nav.statusPageId === "new") {
+              screen.statusPageMode = "create";
+            } else if (nav.statusPageId === "list") {
+              const pages = await listStatusPages({ email, orgId });
+              screen.statusPages = pages.map((page) => ({
+                id: page.id,
+                slug: page.slug,
+                title: page.title,
+                published: page.published,
+                monitorCount: page.monitors.length,
+                publicUrl: `/status/${page.slug}`,
+                updatedAt: page.updatedAt,
+              }));
+            } else {
+              screen.statusPageId = nav.statusPageId;
+              const preview = await getStatusPagePreview(nav.statusPageId, {
+                email,
+                orgId,
+              });
+              if (preview) {
+                const { page, view } = preview;
+                screen.statusPage = {
+                  id: page.id,
+                  slug: page.slug,
+                  title: page.title,
+                  description: page.description,
+                  published: page.published,
+                  publicUrl: `/status/${page.slug}`,
+                  layout: {
+                    density: page.density,
+                    alignment: page.alignment,
+                    showUptimeBars: page.showUptimeBars,
+                    showOverallUptime: page.showOverallUptime,
+                    showResponseTime: page.showResponseTime,
+                  },
+                  monitorCount: page.monitors.length,
+                  overall: view.overall,
+                  counts: view.counts,
+                  includedMonitors: view.monitors.map((monitor) => ({
+                    id: monitor.id,
+                    name: monitor.name,
+                    host: monitor.host,
+                    status: monitor.status,
+                    uptime24h: monitor.windows.uptime24h,
+                    uptime7d: monitor.windows.uptime7d,
+                  })),
+                  updatedAt: page.updatedAt,
+                };
+              }
+            }
+          } else if (nav?.monitorId === "new") {
+            screen.monitorMode = "create";
+          } else if (nav?.monitorId) {
+            screen.monitorId = nav.monitorId;
+            const detail = await getMonitor(nav.monitorId, { email, orgId });
+            if (detail) {
+              const monitor = detail.monitor;
+              const openIncidents = detail.incidents.filter(
+                (incident) => !incident.resolvedAt,
+              );
+              screen.monitor = {
+                id: monitor.id,
+                name: monitor.name,
+                url: monitor.url,
+                method: monitor.method,
+                enabled: monitor.enabled,
+                severity: monitor.severity,
+                intervalSeconds: monitor.intervalSeconds,
+                lastStatus: monitor.lastStatus,
+                lastCheckedAt: monitor.lastCheckedAt,
+                lastSuccessAt: monitor.lastSuccessAt,
+                lastError: monitor.lastError,
+                lastLatencyMs: monitor.lastLatencyMs,
+                lastStatusCode: monitor.lastStatusCode,
+                consecutiveFailures: monitor.consecutiveFailures,
+                uptime24h: monitor.uptime24h,
+                uptime7d: monitor.uptime7d,
+                checks24h: monitor.checks24h,
+                openIncidentCount: openIncidents.length,
+                recentIncidents: detail.incidents
+                  .slice(0, 5)
+                  .map((incident) => ({
+                    id: incident.id,
+                    startedAt: incident.startedAt,
+                    resolvedAt: incident.resolvedAt,
+                    status: incident.status,
+                    severity: incident.severity,
+                    cause: incident.cause,
+                  })),
+              };
+            }
+          } else {
+            const monitors = await listMonitors({ email, orgId });
+            screen.monitors = monitors.map((monitor) => ({
+              id: monitor.id,
+              name: monitor.name,
+              url: monitor.url,
+              enabled: monitor.enabled,
+              lastStatus: monitor.lastStatus,
+              lastCheckedAt: monitor.lastCheckedAt,
+              uptime24h: monitor.uptime24h,
+              uptime7d: monitor.uptime7d,
+            }));
+          }
+        } catch (error: any) {
+          screen.monitoringError = error?.message || String(error);
+        }
+      }
     } else if (nav?.view === "overview" || nav?.view === "home" || !nav?.view) {
       screen.page = "ask";
     } else if (nav?.view === "ask") {

package/corpus/templates/analytics/app/components/layout/Header.tsx

@@ -20,6 +20,7 @@ const pageTitleKeys: Record<string, string> = {
   "/catalog": "navigation.templateCatalog",
   "/analyses": "navigation.analyses",
   "/sessions": "navigation.sessions",
+  "/monitoring": "navigation.monitoring",
   "/agents": "navigation.agents",
   "/dashboards/explorer": "navigation.explorer",
   "/settings": "navigation.settings",

package/corpus/templates/analytics/app/components/layout/Layout.tsx

@@ -147,6 +147,12 @@ export function Layout({ children }: LayoutProps) {
     location.pathname.startsWith("/extensions/");
   const isSessionsRoute = isAnalyticsSessionsRoute(location.pathname);
   const isSessionDetailRoute = /^\/sessions\/[^/]+/.test(location.pathname);
+  // Monitoring renders its own header row (section tabs / "Back to monitors"
+  // + the relocated agent toggle), so skip the framework Header to avoid a
+  // redundant second title bar.
+  const isMonitoringRoute =
+    location.pathname === "/monitoring" ||
+    location.pathname.startsWith("/monitoring/");
   const isAskRoute = location.pathname === "/ask";
   const chatHomeHandoffActive = useAgentChatHomeHandoff({
     storageKey: ANALYTICS_CHAT_STORAGE_KEY,
@@ -222,7 +228,10 @@ export function Layout({ children }: LayoutProps) {
   const contentFrame = (
     <div className="flex h-full flex-1 flex-col overflow-hidden">
       <MobileNav showNewChat={isAskRoute} />
-      {!isExtensionsRoute && !isAskRoute && !isSessionDetailRoute && <Header />}
+      {!isExtensionsRoute &&
+        !isAskRoute &&
+        !isSessionDetailRoute &&
+        !isMonitoringRoute && <Header />}
       <InvitationBanner />
       <main
         className={