@agent-native/core 0.85.7 → 0.86.1

package/corpus/templates/analytics/app/routes/agents.tsx

@@ -0,0 +1,10 @@
+import { messagesByLocale } from "@/i18n-data";
+import Agents from "@/pages/Agents";
+
+export function meta() {
+  return [{ title: messagesByLocale["en-US"].routeTitles.agents }];
+}
+
+export default function AgentsRoute() {
+  return <Agents />;
+}

package/corpus/templates/analytics/changelog/2026-07-03-agent-admin-tools-page.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-03
+---
+
+Added an Agents page that brings monitoring, evals, experiments, feedback, and advanced database tools into one organized admin surface.

package/corpus/templates/analytics/changelog/2026-07-03-agent-llm-observability-dashboard.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-03
+---
+
+Added an Agent LLM Observability dashboard template for model cost, token, latency, and error tracking.

package/corpus/templates/analytics/changelog/2026-07-03-connect-other-app-databases-from-analytics.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-03
+---
+
+Analytics admins can now connect other agent-native app databases from Agents and inspect or repair those target databases without exposing Analytics data to all users.

package/corpus/templates/analytics/changelog/2026-07-03-session-recordings-now-include-response-bodies-for-5xx-error.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-03
+---
+
+Session recordings now include response bodies for 5xx errors so agents can see the actual server error

package/corpus/templates/analytics/docs/schemas/first-party-analytics.md

@@ -15,6 +15,12 @@ VITE_AGENT_NATIVE_ANALYTICS_PUBLIC_KEY=anpk_...
 
 The core `track()` and browser `trackEvent()` helpers automatically send to `https://analytics.agent-native.com/track` when those env vars are present. Localhost is skipped by default.
 
+Agent loop observability also uses this same tracking path. When an emitting app
+has `AGENT_NATIVE_ANALYTICS_PUBLIC_KEY` configured and observability is enabled,
+core emits one PostHog-compatible `$ai_generation` event per instrumented agent
+run with model, token, cache-token, latency, tool-count, status, and cost
+properties. Prompts, tool inputs, and model outputs are not included by default.
+
 ## Endpoint
 
 Use either endpoint shape:
@@ -98,6 +104,34 @@ Events are stored in `analytics_events`. Common query columns include:
 | `url`, `path`, `hostname`, `referrer` | Page context                                           |
 | `properties`, `context`               | Original JSON objects                                  |
 
+## LLM observability events
+
+Core emits LLM usage as first-party events with:
+
+```txt
+event_name = '$ai_generation'
+```
+
+Useful query fields live in `properties`:
+
+| Property                                         | Description                               |
+| ------------------------------------------------ | ----------------------------------------- |
+| `$ai_trace_id`, `run_id`                         | Agent run id                              |
+| `$ai_session_id`, `thread_id`                    | Chat/thread id, when available            |
+| `$ai_model`, `model`                             | Model used                                |
+| `$ai_provider`, `provider`                       | Engine/provider name                      |
+| `$ai_input_tokens`, `input_tokens`               | Input tokens                              |
+| `$ai_output_tokens`, `output_tokens`             | Output tokens                             |
+| `cache_read_tokens`, `cache_write_tokens`        | Prompt-cache token counts                 |
+| `$ai_total_cost_usd`, `cost_usd`                 | Estimated run cost in USD                 |
+| `cost_cents_x100`                                | Estimated run cost in centicents          |
+| `$ai_latency`, `duration_ms`                     | Run duration in seconds / milliseconds    |
+| `tool_calls`, `successful_tools`, `failed_tools` | Tool-call counts                          |
+| `$ai_is_error`, `status`, `$ai_error`            | Error status and message, when applicable |
+
+Install the `agent-observability-llm` dashboard template for canned panels over
+these events.
+
 Example dashboard panel:
 
 ```json

package/corpus/templates/analytics/docs/schemas/tracked-events.md

@@ -24,6 +24,12 @@ Events tracked by application instrumentation and stored in the configured appli
 - `agent chat message submitted` — User sends an agent chat message
 - `agent chat message received` — AI responds
 - `agent chat code applied` — AI-generated code applied to project
+- `$ai_generation` — One instrumented agent-loop LLM generation emitted through
+  server-side tracking. Properties include `$ai_trace_id`, `$ai_session_id`,
+  `$ai_model`, `$ai_provider`, `$ai_input_tokens`, `$ai_output_tokens`,
+  `$ai_latency`, `$ai_total_cost_usd`, `run_id`, `thread_id`,
+  `cost_cents_x100`, `duration_ms`, `tool_calls`, `status`, and error fields.
+  Prompt and response content are excluded by default.
 
 ### Content Editing
 

package/corpus/templates/analytics/package.json

@@ -60,8 +60,8 @@
     "@radix-ui/react-toggle": "^1.1.9",
     "@radix-ui/react-toggle-group": "^1.1.10",
     "@radix-ui/react-tooltip": "^1.2.7",
-    "@react-router/dev": "^8.0.1",
-    "@react-router/fs-routes": "^8.0.1",
+    "@react-router/dev": "^8.1.0",
+    "@react-router/fs-routes": "^8.1.0",
     "@react-three/drei": "^10.7.7",
     "@react-three/fiber": "^9.6.0",
     "@swc/core": "^1.13.3",
@@ -93,7 +93,7 @@
     "react-hook-form": "^7.71.2",
     "react-i18next": "^17.0.8",
     "react-resizable-panels": "^4.10.0",
-    "react-router": "^8.0.1",
+    "react-router": "^8.1.0",
     "recharts": "^3.8.1",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",

package/corpus/templates/analytics/seeds/dashboards/agent-observability-llm.json

@@ -0,0 +1,173 @@
+{
+  "name": "Agent LLM Observability",
+  "description": "LLM generation volume, latency, errors, token usage, and cost recorded through Agent Native tracking as PostHog-compatible `$ai_generation` events. Source: first-party analytics_events.",
+  "columns": 3,
+  "panels": [
+    {
+      "id": "llm-generations-30d",
+      "title": "LLM Generations (30d)",
+      "chartType": "metric",
+      "source": "first-party",
+      "width": 1,
+      "sql": "SELECT COUNT(*) AS count FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD')",
+      "config": {
+        "yKey": "count",
+        "yFormatter": "number",
+        "description": "Agent LLM generation events emitted by core observability tracking over the last 30 days."
+      }
+    },
+    {
+      "id": "llm-cost-30d",
+      "title": "LLM Cost (30d)",
+      "chartType": "metric",
+      "source": "first-party",
+      "width": 1,
+      "sql": "SELECT COALESCE(SUM(COALESCE(NULLIF(properties::jsonb ->> '$ai_total_cost_usd', '')::float, NULLIF(properties::jsonb ->> 'cost_usd', '')::float, COALESCE(NULLIF(properties::jsonb ->> 'cost_cents_x100', '')::float, 0) / 10000.0)), 0) AS cost_usd FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD')",
+      "config": {
+        "yKey": "cost_usd",
+        "yFormatter": "currency",
+        "description": "Estimated provider spend from tracked LLM generation events."
+      }
+    },
+    {
+      "id": "llm-avg-latency-30d",
+      "title": "Avg LLM Latency (30d)",
+      "chartType": "metric",
+      "source": "first-party",
+      "width": 1,
+      "sql": "SELECT COALESCE(AVG(COALESCE(NULLIF(properties::jsonb ->> 'duration_ms', '')::float, NULLIF(properties::jsonb ->> '$ai_latency', '')::float * 1000.0)), 0) AS latency_ms FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD')",
+      "config": {
+        "yKey": "latency_ms",
+        "yFormatter": "duration",
+        "description": "Average agent loop latency for tracked LLM generations."
+      }
+    },
+    {
+      "id": "llm-error-rate-30d",
+      "title": "LLM Error Rate (30d)",
+      "chartType": "metric",
+      "source": "first-party",
+      "width": 1,
+      "sql": "SELECT CASE WHEN COUNT(*) = 0 THEN 0 ELSE COUNT(*) FILTER (WHERE lower(COALESCE(properties::jsonb ->> '$ai_is_error', properties::jsonb ->> 'status', '')) IN ('true', 'error'))::float / COUNT(*) END AS rate FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD')",
+      "config": {
+        "yKey": "rate",
+        "yFormatter": "percent",
+        "description": "Share of tracked LLM generations that ended in an error status."
+      }
+    },
+    {
+      "id": "llm-cost-over-time",
+      "title": "LLM Cost Over Time by App",
+      "chartType": "area",
+      "source": "first-party",
+      "width": 2,
+      "sql": "SELECT event_date AS date, COALESCE(NULLIF(app, ''), NULLIF(template, ''), 'unknown') AS app, COALESCE(SUM(COALESCE(NULLIF(properties::jsonb ->> '$ai_total_cost_usd', '')::float, NULLIF(properties::jsonb ->> 'cost_usd', '')::float, COALESCE(NULLIF(properties::jsonb ->> 'cost_cents_x100', '')::float, 0) / 10000.0)), 0) AS cost_usd FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD') GROUP BY event_date, COALESCE(NULLIF(app, ''), NULLIF(template, ''), 'unknown') ORDER BY date, app",
+      "config": {
+        "xKey": "date",
+        "yKey": "cost_usd",
+        "yFormatter": "currency",
+        "pivot": {
+          "xKey": "date",
+          "seriesKey": "app",
+          "valueKey": "cost_usd"
+        },
+        "stacked": true,
+        "description": "Daily estimated LLM cost stacked by emitting app/template."
+      }
+    },
+    {
+      "id": "llm-cost-by-model",
+      "title": "LLM Cost by Model",
+      "chartType": "bar",
+      "source": "first-party",
+      "width": 1,
+      "sql": "SELECT COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') AS model, COALESCE(SUM(COALESCE(NULLIF(properties::jsonb ->> '$ai_total_cost_usd', '')::float, NULLIF(properties::jsonb ->> 'cost_usd', '')::float, COALESCE(NULLIF(properties::jsonb ->> 'cost_cents_x100', '')::float, 0) / 10000.0)), 0) AS cost_usd FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD') GROUP BY COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') ORDER BY cost_usd DESC LIMIT 20",
+      "config": {
+        "xKey": "model",
+        "yKey": "cost_usd",
+        "yFormatter": "currency",
+        "color": "var(--brand-purple)",
+        "description": "Estimated LLM cost grouped by model over the last 30 days."
+      }
+    },
+    {
+      "id": "llm-tokens-over-time",
+      "title": "LLM Tokens Over Time by Model",
+      "chartType": "area",
+      "source": "first-party",
+      "width": 2,
+      "sql": "SELECT event_date AS date, COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') AS model, SUM(COALESCE(NULLIF(properties::jsonb ->> '$ai_input_tokens', '')::float, NULLIF(properties::jsonb ->> 'input_tokens', '')::float, 0) + COALESCE(NULLIF(properties::jsonb ->> '$ai_output_tokens', '')::float, NULLIF(properties::jsonb ->> 'output_tokens', '')::float, 0)) AS tokens FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD') GROUP BY event_date, COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') ORDER BY date, model",
+      "config": {
+        "xKey": "date",
+        "yKey": "tokens",
+        "yFormatter": "number",
+        "pivot": {
+          "xKey": "date",
+          "seriesKey": "model",
+          "valueKey": "tokens"
+        },
+        "stacked": true,
+        "description": "Input plus output tokens per day, stacked by model."
+      }
+    },
+    {
+      "id": "llm-latency-by-model",
+      "title": "LLM Latency by Model",
+      "chartType": "bar",
+      "source": "first-party",
+      "width": 1,
+      "sql": "SELECT COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') AS model, COALESCE(AVG(COALESCE(NULLIF(properties::jsonb ->> 'duration_ms', '')::float, NULLIF(properties::jsonb ->> '$ai_latency', '')::float * 1000.0)), 0) AS latency_ms FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD') GROUP BY COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') ORDER BY latency_ms DESC LIMIT 20",
+      "config": {
+        "xKey": "model",
+        "yKey": "latency_ms",
+        "yFormatter": "duration",
+        "color": "var(--brand-teal)",
+        "description": "Average tracked LLM generation latency grouped by model."
+      }
+    },
+    {
+      "id": "top-expensive-llm-runs",
+      "title": "Top Expensive LLM Runs",
+      "chartType": "table",
+      "source": "first-party",
+      "width": 3,
+      "sql": "SELECT timestamp, COALESCE(NULLIF(app, ''), NULLIF(template, ''), 'unknown') AS app, COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') AS model, COALESCE(NULLIF(user_id, ''), NULLIF(anonymous_id, ''), 'anonymous') AS user_key, COALESCE(NULLIF(properties::jsonb ->> 'run_id', ''), NULLIF(properties::jsonb ->> '$ai_trace_id', '')) AS run_id, ROUND((COALESCE(NULLIF(properties::jsonb ->> '$ai_total_cost_usd', '')::float, NULLIF(properties::jsonb ->> 'cost_usd', '')::float, COALESCE(NULLIF(properties::jsonb ->> 'cost_cents_x100', '')::float, 0) / 10000.0))::numeric, 4) AS cost_usd, ROUND((COALESCE(NULLIF(properties::jsonb ->> 'duration_ms', '')::float, NULLIF(properties::jsonb ->> '$ai_latency', '')::float * 1000.0, 0))::numeric) AS duration_ms, COALESCE(NULLIF(properties::jsonb ->> 'tool_calls', '')::int, 0) AS tool_calls FROM analytics_events WHERE event_name = '$ai_generation' AND event_date >= to_char(CURRENT_DATE - INTERVAL '30 days', 'YYYY-MM-DD') ORDER BY cost_usd DESC LIMIT 25",
+      "config": {
+        "description": "Highest estimated-cost agent runs in the last 30 days.",
+        "columns": [
+          { "key": "timestamp", "label": "Time", "format": "date" },
+          { "key": "app", "label": "App" },
+          { "key": "model", "label": "Model" },
+          { "key": "user_key", "label": "User" },
+          { "key": "run_id", "label": "Run ID" },
+          { "key": "cost_usd", "label": "Cost", "format": "currency" },
+          { "key": "duration_ms", "label": "Duration", "format": "duration" },
+          { "key": "tool_calls", "label": "Tools", "format": "number" }
+        ],
+        "sortable": true,
+        "limit": 25
+      }
+    },
+    {
+      "id": "recent-llm-errors",
+      "title": "Recent LLM Errors",
+      "chartType": "table",
+      "source": "first-party",
+      "width": 3,
+      "sql": "SELECT timestamp, COALESCE(NULLIF(app, ''), NULLIF(template, ''), 'unknown') AS app, COALESCE(NULLIF(properties::jsonb ->> '$ai_model', ''), NULLIF(properties::jsonb ->> 'model', ''), 'unknown') AS model, COALESCE(NULLIF(user_id, ''), NULLIF(anonymous_id, ''), 'anonymous') AS user_key, COALESCE(NULLIF(properties::jsonb ->> 'run_id', ''), NULLIF(properties::jsonb ->> '$ai_trace_id', '')) AS run_id, COALESCE(NULLIF(properties::jsonb ->> 'error_message', ''), NULLIF(properties::jsonb ->> '$ai_error', ''), 'error') AS error FROM analytics_events WHERE event_name = '$ai_generation' AND lower(COALESCE(properties::jsonb ->> '$ai_is_error', properties::jsonb ->> 'status', '')) IN ('true', 'error') ORDER BY timestamp DESC LIMIT 25",
+      "config": {
+        "description": "Most recent tracked LLM generation errors.",
+        "columns": [
+          { "key": "timestamp", "label": "Time", "format": "date" },
+          { "key": "app", "label": "App" },
+          { "key": "model", "label": "Model" },
+          { "key": "user_key", "label": "User" },
+          { "key": "run_id", "label": "Run ID" },
+          { "key": "error", "label": "Error" }
+        ],
+        "sortable": true,
+        "limit": 25
+      }
+    }
+  ]
+}

package/corpus/templates/analytics/server/db/schema.ts

@@ -234,6 +234,33 @@ export const analyticsAlertIncidents = table("analytics_alert_incidents", {
   orgId: text("org_id"),
 });
 
+/**
+ * Admin-only registry of external agent-native app databases that Analytics can
+ * inspect. Secret values live in app_secrets; this table stores metadata and
+ * secret keys scoped to the active organization.
+ */
+export const analyticsDbAdminConnections = table(
+  "analytics_db_admin_connections",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    appId: text("app_id"),
+    appUrl: text("app_url"),
+    databaseUrlSecretKey: text("database_url_secret_key").notNull(),
+    databaseAuthTokenSecretKey: text("database_auth_token_secret_key"),
+    createdBy: text("created_by").notNull(),
+    createdAt: text("created_at").notNull().default(now()),
+    updatedAt: text("updated_at").notNull().default(now()),
+    orgId: text("org_id").notNull(),
+  },
+  (connection) => ({
+    orgUpdatedIdx: index("analytics_db_admin_connections_org_updated_idx").on(
+      connection.orgId,
+      connection.updatedAt,
+    ),
+  }),
+);
+
 /**
  * Session replay summaries recorded through the first-party analytics replay
  * endpoint. Raw replay chunks live in session_replay_chunks and are only read

package/corpus/templates/analytics/server/jobs/analytics-alerts.ts

@@ -7,6 +7,7 @@ import {
 } from "../lib/analytics-alerts";
 
 let running = false;
+let listRulesFailureLogged = false;
 const DEFAULT_MAX_RULES_PER_SWEEP = 100;
 
 function maxRulesPerSweep(input?: number): number {
@@ -47,11 +48,28 @@ export async function runAnalyticsAlertsOnce(
     await ensureDefaultHttp5xxSpikeAlertRules().catch((err) => {
       console.error("[analytics-alerts] Default 5xx alert seed failed:", err);
     });
-    const rules = await listEnabledAnalyticsAlertRules({
-      limit: sweepLimit,
-      ownerEmail: options.ownerEmail,
-      orgId: options.orgId,
-    });
+    let rules: Awaited<ReturnType<typeof listEnabledAnalyticsAlertRules>>;
+    try {
+      rules = await listEnabledAnalyticsAlertRules({
+        limit: sweepLimit,
+        ownerEmail: options.ownerEmail,
+        orgId: options.orgId,
+      });
+    } catch (err) {
+      // Schema not migrated yet (e.g. a deploy that hasn't picked up the
+      // analytics_alert_rules migration) or a transient DB error — don't let
+      // one bad sweep crash the whole interval/cron invocation every time it
+      // fires. Log once per process so the failure is still visible.
+      if (!listRulesFailureLogged) {
+        console.error(
+          "[analytics-alerts] Failed to list enabled alert rules; skipping this sweep:",
+          err,
+        );
+        listRulesFailureLogged = true;
+      }
+      return { processed: 0, triggered: 0, failed: 0, remaining: 0 };
+    }
+    listRulesFailureLogged = false;
     remaining = rules.length >= sweepLimit ? 1 : 0;
 
     for (const rule of rules) {

package/corpus/templates/analytics/server/lib/analytics-alerts.ts

@@ -2,7 +2,18 @@ import { createHash, randomUUID } from "node:crypto";
 
 import { notifyWithDelivery } from "@agent-native/core/notifications";
 import { recordChange } from "@agent-native/core/server";
-import { and, asc, desc, eq, gte, isNull, lte, or, sql } from "drizzle-orm";
+import {
+  and,
+  asc,
+  desc,
+  eq,
+  gte,
+  inArray,
+  isNull,
+  lte,
+  or,
+  sql,
+} from "drizzle-orm";
 
 import { getDb, schema } from "../db/index.js";
 
@@ -435,6 +446,16 @@ export async function deleteAnalyticsAlertRule(
   });
 }
 
+const DEFAULT_ALERT_SEED_CHUNK_SIZE = 500;
+
+function chunkArray<T>(items: T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+
 export async function ensureDefaultHttp5xxSpikeAlertRules(): Promise<{
   checked: number;
   created: number;
@@ -442,8 +463,9 @@ export async function ensureDefaultHttp5xxSpikeAlertRules(): Promise<{
   if (!defaultHttp5xxAlertEnabled()) return { checked: 0, created: 0 };
 
   const scopes = await defaultHttp5xxAlertScopes();
+  if (!scopes.length) return { checked: 0, created: 0 };
+
   const db = getDb() as any;
-  let created = 0;
   const threshold = envInt(
     "ANALYTICS_DEFAULT_HTTP_5XX_ALERT_THRESHOLD",
     5,
@@ -463,17 +485,28 @@ export async function ensureDefaultHttp5xxSpikeAlertRules(): Promise<{
     24 * 60,
   );
 
+  const scopesById = new Map<string, AccessCtx>();
   for (const scope of scopes) {
-    const id = defaultHttp5xxAlertId(scope.email, scope.orgId);
-    const [existing] = await db
+    scopesById.set(defaultHttp5xxAlertId(scope.email, scope.orgId), scope);
+  }
+  const allIds = Array.from(scopesById.keys());
+
+  const existingIds = new Set<string>();
+  for (const idChunk of chunkArray(allIds, DEFAULT_ALERT_SEED_CHUNK_SIZE)) {
+    const rows = await db
       .select({ id: schema.analyticsAlertRules.id })
       .from(schema.analyticsAlertRules)
-      .where(eq(schema.analyticsAlertRules.id, id))
-      .limit(1);
-    if (existing) continue;
+      .where(inArray(schema.analyticsAlertRules.id, idChunk));
+    for (const row of rows) existingIds.add(row.id);
+  }
 
-    const now = nowIso();
-    await db.insert(schema.analyticsAlertRules).values({
+  const missingIds = allIds.filter((id) => !existingIds.has(id));
+  if (!missingIds.length) return { checked: scopes.length, created: 0 };
+
+  const now = nowIso();
+  const rowsToInsert = missingIds.map((id) => {
+    const scope = scopesById.get(id)!;
+    return {
       id,
       name: "Hosted app HTTP 5xx spike",
       description:
@@ -482,12 +515,12 @@ export async function ensureDefaultHttp5xxSpikeAlertRules(): Promise<{
       filters: JSON.stringify([
         { field: "properties.status_class", value: "5xx" },
       ]),
-      thresholdMode: "event_count",
+      thresholdMode: "event_count" as const,
       distinctBy: null,
       threshold,
       windowMinutes,
       cooldownMinutes,
-      severity: "critical",
+      severity: "critical" as const,
       channels: JSON.stringify(["inbox"]),
       emailRecipients: JSON.stringify([]),
       enabled: true,
@@ -495,8 +528,20 @@ export async function ensureDefaultHttp5xxSpikeAlertRules(): Promise<{
       updatedAt: now,
       ownerEmail: scope.email,
       orgId: scope.orgId,
-    });
-    created++;
+    };
+  });
+
+  let created = 0;
+  for (const rowChunk of chunkArray(
+    rowsToInsert,
+    DEFAULT_ALERT_SEED_CHUNK_SIZE,
+  )) {
+    const inserted = await db
+      .insert(schema.analyticsAlertRules)
+      .values(rowChunk)
+      .onConflictDoNothing()
+      .returning({ id: schema.analyticsAlertRules.id });
+    created += inserted.length;
   }
 
   return { checked: scopes.length, created };

package/corpus/templates/analytics/server/lib/dashboard-catalog.ts

@@ -944,6 +944,29 @@ export const dashboardCatalogEntries: DashboardCatalogEntry[] = [
     visibleInCatalog: false,
     buildConfig: () => seedConfig("agent-native-templates-first-party"),
   },
+  {
+    id: "agent-observability-llm",
+    name: "Agent LLM Observability",
+    description:
+      "LLM generation volume, latency, errors, token usage, and cost captured as first-party `$ai_generation` tracking events.",
+    category: "Observability",
+    defaultDashboardId: "agent-observability-llm",
+    dataSources: ["first-party"],
+    tags: [
+      "ai",
+      "llm",
+      "observability",
+      "cost",
+      "tokens",
+      "latency",
+      "posthog",
+      "first-party",
+    ],
+    panelCount: 10,
+    version: CATALOG_VERSION,
+    recommended: true,
+    buildConfig: () => seedConfig("agent-observability-llm"),
+  },
   {
     id: "skills-cli-funnel",
     name: "Skills CLI Funnel",

package/corpus/templates/analytics/server/lib/dashboard-seeds.ts

@@ -3,11 +3,16 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import firstPartyTemplateTrafficSeed from "../../seeds/dashboards/agent-native-templates-first-party.json" with { type: "json" };
+import agentObservabilityLlmSeed from "../../seeds/dashboards/agent-observability-llm.json" with { type: "json" };
 import googleAnalyticsSeed from "../../seeds/dashboards/google-analytics.json" with { type: "json" };
 import nodeExporterFullSeed from "../../seeds/dashboards/node-exporter-full.json" with { type: "json" };
 import skillsCliFunnelSeed from "../../seeds/dashboards/skills-cli-funnel.json" with { type: "json" };
 
 const shippedSeeds: Record<string, Record<string, unknown>> = {
+  "agent-observability-llm": agentObservabilityLlmSeed as Record<
+    string,
+    unknown
+  >,
   "agent-native-templates-first-party": firstPartyTemplateTrafficSeed as Record<
     string,
     unknown