@agent-native/core 0.95.1 → 0.97.0

package/corpus/core/src/templates/workspace-core/.agents/skills/audit-log/SKILL.md

@@ -77,6 +77,9 @@ SQL to the caller — they never leak another tenant's rows:
   (`agent` | `human` | `system`), `status`, `threadId`/`turnId`, `action`,
   `sinceMs`, `limit`.
 - `get-audit-event` — one event by id, with its redacted input payload.
+- `export-audit-events` — bulk CSV/NDJSON export (same filters minus `limit`,
+  plus `format` and `maxRows`) for offline/compliance pulls; itself audited
+  via `onRead`.
 
 Call them from the UI with `useActionQuery` to build an activity feed or a
 "who changed this" line — never hand-write a fetch to the audit table.

package/corpus/core/src/templates/workspace-core/.agents/skills/automations/SKILL.md

@@ -61,7 +61,7 @@ Use the web-request tool with ${keys.SLACK_WEBHOOK}.
 | `triggerType` | `"schedule" \| "event"`        | How the automation fires                               |
 | `event`       | `string?`                      | Event name to subscribe to (event triggers)            |
 | `condition`   | `string?`                      | Natural-language condition evaluated before dispatch   |
-| `mode`        | `"agentic" \| "deterministic"` | Full agent loop vs. fixed action set                   |
+| `mode`        | `"agentic"`                    | Full agent loop (only supported mode; `"deterministic"` was removed — never implemented, rejected at define time) |
 | `model`       | `string?`                      | Override the model for this trigger's agent loop       |
 | `domain`      | `string?`                      | Grouping tag (mail, calendar, clips, etc.)             |
 | `createdBy`   | `string?`                      | Owner email                                            |

package/corpus/core/src/templates/workspace-core/.agents/skills/observability/SKILL.md

@@ -126,6 +126,26 @@ The agent loop reads active experiments via `resolveActiveExperimentConfig()` an
 
 Compute results with `POST /_agent-native/observability/experiments/:id/results`.
 
+#### First-party hosted default-model rollout
+
+First-party apps on `agent-native.com` automatically run the July 2026
+default-model experiment for authenticated users on the Builder engine:
+
+- 80% `claude-sonnet-5`
+- 20% `gpt-5-6-luna`
+- Assignment is sticky by normalized user email and shared across templates.
+- The rollout applies only when the user, app, and deployment have not selected
+  a model. Explicit model choices and BYO provider engines always win.
+- Set `AGENT_NATIVE_HOSTED_MODEL_EXPERIMENT=off` for an emergency rollback, or
+  `true` to exercise the rollout on a non-first-party preview.
+- `$ai_generation` tracking includes `experiment_id`,
+  `experiment_variant`, and `model_selection_source` for central analysis.
+
+In production, experiment management routes require the caller's email in the
+comma-separated `AGENT_NATIVE_EXPERIMENT_ADMIN_EMAILS` allowlist. This gate is
+separate from normal app/org admin roles because an experiment affects every
+user in that deployment.
+
 ### 5. Dashboard
 
 `ObservabilityDashboard` is a React component with 5 tabs:

package/corpus/core/src/templates/workspace-core/.agents/skills/voice-transcription/SKILL.md

@@ -41,9 +41,13 @@ shared agent sidebar.
 ## Realtime speech mode
 
 Realtime speech mode is a full-duplex OpenAI Realtime WebRTC session, separate
-from the dictation providers below. It requires the authenticated user's
-`OPENAI_API_KEY`, uses the server-owned `gpt-realtime-2.1` session
-configuration, and keeps the key out of browser code.
+from the dictation providers below. It prefers the authenticated user's
+complete Builder connection and the Builder-managed metered gateway. A scoped
+`OPENAI_API_KEY` is the fallback when Builder is not connected. The server owns
+the `gpt-realtime-2.1` session configuration and keeps credentials out of
+browser code. If neither provider is configured, show **Connect Builder** as
+the primary microphone-popover action and OpenAI key setup as the secondary
+action before requesting microphone permission.
 
 - Starting voice mode collapses the chat into a persistent bottom-end speech
   orb. The orb stays visible above the chat even when the chat opens
@@ -169,7 +173,7 @@ client.
 
 Templates can:
 - **Disable the mic**: pass `voiceEnabled={false}` to `TiptapComposer`.
-- **Replace the button**: wrap `TiptapComposer` and render your own `extraActionButton` (the framework mic sits between `extraActionButton` and the send button).
+- **Replace the button**: wrap `TiptapComposer` and render your own `extraActionButton`; the framework mic stays immediately before the primary send/stop control. Use `stopButton` for an active-run control so the disabled send button becomes stop when the draft is empty and returns when the user types.
 - **Pre-register provider keys as `required: true`**: call `registerRequiredSecret(...)` from your own server plugin when a template needs a specific BYOK provider in onboarding.
 
 ## Don'ts

package/corpus/core/src/templates/workspace-core/package.json

@@ -32,7 +32,6 @@
     "prepare": "tsc"
   },
   "devDependencies": {
-    "typescript": "catalog:",
     "typescript-7": "catalog:"
   }
 }

package/corpus/core/src/templates/workspace-root/package.json

@@ -20,7 +20,6 @@
     "@types/node": "^24.2.1",
     "oxfmt": "catalog:",
     "tsx": "catalog:",
-    "typescript": "catalog:",
     "typescript-7": "catalog:"
   },
   "packageManager": "pnpm@10.14.0",

package/corpus/core/src/triggers/actions.ts

@@ -107,6 +107,14 @@ async function handleDefine(
     return `Error: An automation named "${name}" already exists. Use a different name or delete the existing one first.`;
   }
 
+  if (args.mode === "deterministic") {
+    return (
+      "Error: Deterministic mode was removed — it was never implemented and " +
+      "automations that set it never fired. Create the automation without " +
+      "mode (agentic), and describe the exact fixed steps in the automation body."
+    );
+  }
+
   const triggerType = args.trigger_type === "schedule" ? "schedule" : "event";
   const meta: TriggerFrontmatter = {
     schedule: args.schedule || "",
@@ -114,7 +122,7 @@ async function handleDefine(
     triggerType,
     event: args.event || undefined,
     condition: args.condition || undefined,
-    mode: args.mode === "deterministic" ? "deterministic" : "agentic",
+    mode: "agentic",
     domain: args.domain || undefined,
     createdBy: owner,
     runAs: "creator",
@@ -268,8 +276,8 @@ export function createAutomationToolEntries(
             mode: {
               type: "string",
               description:
-                '"agentic" (full agent loop, can use tools) or "deterministic" (fixed actions only). Used by define.',
-              enum: ["agentic", "deterministic"],
+                '"agentic" (full agent loop, can use tools) — the only supported mode. Used by define.',
+              enum: ["agentic"],
             },
             domain: {
               type: "string",

package/corpus/core/src/triggers/types.ts

@@ -15,7 +15,13 @@ export interface TriggerFrontmatter {
   event?: string;
   /** Natural-language condition evaluated by Haiku before dispatch. */
   condition?: string;
-  /** "agentic" = full runAgentLoop. "deterministic" = fixed action set. */
+  /**
+   * "agentic" = full runAgentLoop; the only mode `manage-automations` will
+   * define/update going forward. "deterministic" was removed from the
+   * advertised surface (never implemented) and is legacy-only: rows created
+   * before the removal may still carry it, and the dispatcher's
+   * warn-and-skip branch keeps them inert by design — do not make them fire.
+   */
   mode: "agentic" | "deterministic";
   /** Domain tag for filtering in per-template UIs. */
   domain?: string;

package/corpus/core/src/vite/client.ts

@@ -1898,6 +1898,7 @@ function ssrStubPlugin(packages: string[]): Plugin | null {
     "useCurrentEditor",
     "useEditor",
     "useLocalRuntime",
+    "useMessagePartReasoning",
     "useMessagePartText",
     "useMessageRuntime",
     "useThread",

package/corpus/templates/analytics/AGENTS.md

@@ -20,6 +20,13 @@ details live in `.agents/skills/`.
   status) and the injected `<data-dictionary>` to learn what exists and which
   table/columns/join paths to use. Don't fan out blind queries when the catalog
   already answers where a fact lives.
+- Simple time-bounded metric fast path: when the data dictionary or a known
+  canonical source already identifies the metric, run one bounded aggregate.
+  Once that query returns a valid result, answer immediately with the source,
+  time window, row count, and only necessary caveats. Do not schema-discover,
+  retry, enrich, or add breakdowns unless the query fails or its result
+  conflicts with the known metric definition. This never waives the real-data
+  requirement: do not answer from a guess, stale value, or unverified result.
 - Clarify-first for ambiguous ad-hoc work: when the metric definition, date
   range, or grain is ambiguous and a wrong guess would change the numbers, use
   the `ask-question` clarifying tool (multiple-choice) before computing. Ask at

package/corpus/templates/analytics/actions/bigquery.ts

@@ -1,4 +1,5 @@
 import { AgentActionStopError, defineAction } from "@agent-native/core";
+import type { ActionRunContext } from "@agent-native/core/action";
 import { z } from "zod";
 
 import { runQuery } from "../server/lib/bigquery";
@@ -49,6 +50,23 @@ function stopForBigQueryNotConfigured(message: string): never {
   });
 }
 
+function stopForBigQueryCancellation(): never {
+  const message =
+    "The BigQuery query was cancelled because the agent run ended before it could finish.";
+  throw new AgentActionStopError(message, {
+    errorCode: "run_cancelled",
+    toolResult: JSON.stringify(
+      {
+        error: "run_cancelled",
+        message,
+        recoverable: false,
+      },
+      null,
+      2,
+    ),
+  });
+}
+
 export default defineAction({
   description:
     "Query the user-configured BigQuery data warehouse. Use this when the user asks for warehouse SQL, BigQuery, or a data-dictionary metric/table that lives in BigQuery. If the user names a provider action such as Jira or Pylon, use that provider action first and do not use BigQuery unless the user explicitly asks for a warehouse copy. Pass standard SQL via the `sql` arg. Do NOT use `db-query` for warehouse data (it only reaches the app's own SQL database). If a query fails with a schema or SQL error (unknown dataset/table/column, syntax), treat it as a normal debugging signal: inspect the real schema with `search-bigquery-schema` (or query INFORMATION_SCHEMA), correct the query based on the error, and run it again — a few corrective attempts are expected. Surface the error to the user only if it still fails after a few attempts or is non-recoverable (missing credentials, permission, quota). Never rerun identical failing SQL, and never substitute made-up numbers for data you could not query.",
@@ -57,10 +75,16 @@ export default defineAction({
   }),
   readOnly: true,
   toolCallable: true,
-  run: async (args) => {
+  run: async (args, context?: ActionRunContext) => {
     try {
-      return await runQuery(args.sql);
+      return await runQuery(args.sql, { signal: context?.signal });
     } catch (err) {
+      // A run cancellation is terminal for this invocation. Returning it as a
+      // recoverable SQL error would invite the agent to retry work after the
+      // parent run has already ended. Normalize the provider's AbortError so
+      // the generic tool-error path cannot record it as a warehouse failure.
+      if (context?.signal?.aborted) stopForBigQueryCancellation();
+
       const msg = err instanceof Error ? err.message : String(err);
       if (
         /GOOGLE_APPLICATION_CREDENTIALS_JSON not configured/i.test(msg) ||

package/corpus/templates/analytics/actions/compose-dashboard.ts

@@ -11,7 +11,11 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  getDashboard,
+  upsertDashboard,
+  upsertDashboardWithRetry,
+} from "../server/lib/dashboards-store";
 import { validateFirstPartyAnalyticsSql } from "../server/lib/first-party-analytics.js";
 import {
   buildFirstPartyDashboardFilters,
@@ -235,61 +239,85 @@ export default defineAction({
         ? (existing.config.name as string)
         : args.dashboardId);
 
+    function withFilters(
+      config: Record<string, unknown>,
+    ): Record<string, unknown> {
+      return composedPanels.some((panel) =>
+        usesFirstPartyDashboardFilters(panel.sql),
+      )
+        ? withFirstPartyDashboardFilters(config)
+        : config;
+    }
+
     let finalConfig: Record<string, unknown>;
     let appendedCount = composedPanels.length;
     let skippedExistingIds: string[] = [];
 
     if (existing && !args.overwrite) {
       // Append: preserve existing panels + order, add only new panel ids.
-      const existingConfig = existing.config as Record<string, unknown>;
-      const existingPanels = Array.isArray(existingConfig.panels)
-        ? (existingConfig.panels as Array<Record<string, unknown>>)
-        : [];
-      const existingIds = new Set(
-        existingPanels
-          .map((p) => (typeof p?.id === "string" ? p.id : null))
-          .filter((id): id is string => !!id),
+      // Recomputed on every retry attempt from the freshest existing config —
+      // via upsertDashboardWithRetry — so a panel a concurrent writer just
+      // added is never silently dropped by this merge.
+      const saved = await upsertDashboardWithRetry(
+        args.dashboardId,
+        ctx,
+        (freshExisting) => {
+          const existingConfig = freshExisting.config as Record<
+            string,
+            unknown
+          >;
+          const existingPanels = Array.isArray(existingConfig.panels)
+            ? (existingConfig.panels as Array<Record<string, unknown>>)
+            : [];
+          const existingIds = new Set(
+            existingPanels
+              .map((p) => (typeof p?.id === "string" ? p.id : null))
+              .filter((id): id is string => !!id),
+          );
+          const toAppend: ComposedPanel[] = [];
+          const skipped: string[] = [];
+          for (const panel of composedPanels) {
+            if (existingIds.has(panel.id)) {
+              skipped.push(panel.id);
+              continue;
+            }
+            toAppend.push(panel);
+            existingIds.add(panel.id);
+          }
+          appendedCount = toAppend.length;
+          skippedExistingIds = skipped;
+          const merged = withFilters({
+            ...existingConfig,
+            name:
+              typeof existingConfig.name === "string" &&
+              existingConfig.name.trim()
+                ? existingConfig.name
+                : dashboardName,
+            panels: [...existingPanels, ...toAppend],
+          });
+          return { kind: "sql" as const, body: merged };
+        },
       );
-      const toAppend: ComposedPanel[] = [];
-      for (const panel of composedPanels) {
-        if (existingIds.has(panel.id)) {
-          skippedExistingIds.push(panel.id);
-          continue;
-        }
-        toAppend.push(panel);
-        existingIds.add(panel.id);
-      }
-      appendedCount = toAppend.length;
-      finalConfig = {
-        ...existingConfig,
-        name:
-          typeof existingConfig.name === "string" && existingConfig.name.trim()
-            ? existingConfig.name
-            : dashboardName,
-        panels: [...existingPanels, ...toAppend],
-      };
+      finalConfig = saved.config as Record<string, unknown>;
     } else {
       // Create or overwrite: a fresh config with exactly the composed panels.
-      finalConfig = {
+      // No prior state can be lost here — create has none, and
+      // `overwrite: true` is an explicit full-replace request rather than a
+      // read-modify-write, so it saves unconditionally like update-dashboard's
+      // full-config replace mode.
+      finalConfig = withFilters({
         name: dashboardName,
         description:
           "First-party analytics dashboard composed from the metric catalog.",
         panels: composedPanels,
-      };
-    }
-
-    if (
-      composedPanels.some((panel) => usesFirstPartyDashboardFilters(panel.sql))
-    ) {
-      finalConfig = withFirstPartyDashboardFilters(finalConfig);
+      });
+      await upsertDashboard(args.dashboardId, "sql", finalConfig, ctx);
     }
 
     const panelCount = Array.isArray(finalConfig.panels)
       ? (finalConfig.panels as unknown[]).length
       : 0;
 
-    // Single atomic save through the same store path update-dashboard uses.
-    await upsertDashboard(args.dashboardId, "sql", finalConfig, ctx);
     await syncToCollab(args.dashboardId, finalConfig);
 
     const parts: string[] = [];

package/corpus/templates/analytics/actions/data-source-status.ts

@@ -190,7 +190,25 @@ export default defineAction({
           workspaceConnection,
         };
       });
+    const configuredDataSources = providers
+      .filter((provider) => provider.configured)
+      .map((provider) => ({
+        provider: provider.provider,
+        label: provider.label,
+        via:
+          provider.configuredKeys.length > 0 &&
+          provider.workspaceConnection.grantState === "connected"
+            ? "credentials-and-workspace"
+            : provider.workspaceConnection.grantState === "connected"
+              ? "workspace"
+              : "credentials",
+      }));
     return {
+      // Keep a compact, explicit summary first so models do not infer source
+      // availability from the much larger per-credential list below.
+      hasConfiguredDataSources: configuredDataSources.length > 0,
+      configuredDataSourceCount: configuredDataSources.length,
+      configuredDataSources,
       credentials: results,
       providers,
       total: results.length,

package/corpus/templates/analytics/actions/mutate-dashboard.ts

@@ -11,13 +11,18 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  getDashboard,
+  upsertDashboardWithRetry,
+  type DashboardRecord,
+} from "../server/lib/dashboards-store";
 import {
   applyDashboardMutationOperations,
   DASHBOARD_MUTATION_API_TYPES,
   DASHBOARD_MUTATION_EXAMPLES,
   parseDashboardMutationScript,
   type DashboardMutationOperation,
+  type DashboardMutationResult,
 } from "./dashboard-mutation-api";
 import { compactDashboardResult } from "./dashboard-panel-order";
 import { validateDashboardConfig, validatePanelSql } from "./update-dashboard";
@@ -260,33 +265,77 @@ export default defineAction({
 
     const scope = resolveScope();
     const ctx = { email: scope.email, orgId: scope.orgId };
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
-    if (existing.kind !== "sql") {
-      throw new Error(
-        `mutate-dashboard only supports SQL dashboards; "${dashboardId}" is ${existing.kind}.`,
+
+    // Recomputes the mutation from whatever dashboard state is passed in.
+    // `operations` sourced from `args.operations` are already concrete panel
+    // ids, safe to replay verbatim; `args.code` is re-parsed against `existing`
+    // every time because selectors like `panelsMatching(...)` resolve against
+    // the config at parse time, so a retry must re-resolve them against the
+    // fresh state, not reuse ids resolved from a now-stale config.
+    function computeMutation(
+      existing: Pick<DashboardRecord, "kind" | "config">,
+    ) {
+      if (existing.kind !== "sql") {
+        throw new Error(
+          `mutate-dashboard only supports SQL dashboards; "${dashboardId}" is ${existing.kind}.`,
+        );
+      }
+      const nextRoot = cloneConfig(existing.config as Record<string, unknown>);
+      const nextOperations = args.operations
+        ? (args.operations as DashboardMutationOperation[])
+        : parseDashboardMutationScript(nextRoot, args.code!);
+      const nextMutation = applyDashboardMutationOperations(
+        nextRoot,
+        nextOperations,
       );
+      const validation = validateDashboardConfig(nextRoot);
+      if (validation) throw new Error(validation);
+      return { nextRoot, nextOperations, nextMutation };
     }
 
-    const root = cloneConfig(existing.config as Record<string, unknown>);
-    const operations = args.operations
-      ? (args.operations as DashboardMutationOperation[])
-      : parseDashboardMutationScript(root, args.code!);
-    const mutation = applyDashboardMutationOperations(root, operations);
+    // Assigned inside `computeMutation`'s caller (directly for dry-run, inside
+    // the retry callback for a real save); always assigned at least once
+    // before use below, since `upsertDashboardWithRetry` only resolves after
+    // its callback has run.
+    let root: Record<string, unknown>;
+    let operations!: DashboardMutationOperation[];
+    let mutation!: DashboardMutationResult;
 
-    const validation = validateDashboardConfig(root);
-    if (validation) throw new Error(validation);
-    if (operations.some(mutationCanChangePanelSql)) {
-      const sqlError = await validatePanelSql(root);
-      if (sqlError) throw new Error(sqlError);
-    }
-
-    if (args.dryRun !== true) {
-      await upsertDashboard(dashboardId, existing.kind, root, ctx);
+    if (args.dryRun === true) {
+      const existing = await getDashboard(dashboardId, ctx);
+      if (!existing) {
+        throw new Error(
+          `dashboard "${dashboardId}" not found (or you don't have access).`,
+        );
+      }
+      const computed = computeMutation(existing);
+      root = computed.nextRoot;
+      operations = computed.nextOperations;
+      mutation = computed.nextMutation;
+      if (operations.some(mutationCanChangePanelSql)) {
+        const sqlError = await validatePanelSql(root);
+        if (sqlError) throw new Error(sqlError);
+      }
+    } else {
+      const saved = await upsertDashboardWithRetry(
+        dashboardId,
+        ctx,
+        async (existing) => {
+          const computed = computeMutation(existing);
+          if (computed.nextOperations.some(mutationCanChangePanelSql)) {
+            const sqlError = await validatePanelSql(computed.nextRoot);
+            if (sqlError) throw new Error(sqlError);
+          }
+          root = computed.nextRoot;
+          operations = computed.nextOperations;
+          mutation = computed.nextMutation;
+          return { kind: "sql" as const, body: computed.nextRoot };
+        },
+      );
+      // Use the persisted config as the source of truth for the response —
+      // structurally identical to the winning attempt's `root`, but reflects
+      // exactly what was saved.
+      root = saved.config as Record<string, unknown>;
       await syncToCollab(dashboardId, root);
     }
 

package/corpus/templates/analytics/actions/reorder-dashboard-panels.ts

@@ -11,10 +11,11 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import { upsertDashboardWithRetry } from "../server/lib/dashboards-store";
 import {
   compactDashboardResult,
   movePanelsById,
+  type PanelOrderResult,
   type PanelOrderTarget,
 } from "./dashboard-panel-order";
 
@@ -155,20 +156,22 @@ export default defineAction({
     const dashboardId = resolveDashboardId(args);
     const scope = resolveScope();
     const ctx = { email: scope.email, orgId: scope.orgId };
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
 
-    const root = existing.config as Record<string, unknown>;
-    const orderResult = movePanelsById(
-      root,
-      args.panelIds,
-      resolveTarget(args),
+    // Recomputed on every attempt from whichever dashboard state
+    // `upsertDashboardWithRetry` hands us, so a retry after a concurrent
+    // writer's save re-applies this move against their fresh panel order
+    // instead of silently discarding it.
+    let orderResult!: PanelOrderResult;
+    const saved = await upsertDashboardWithRetry(
+      dashboardId,
+      ctx,
+      (existing) => {
+        const root = existing.config as Record<string, unknown>;
+        orderResult = movePanelsById(root, args.panelIds, resolveTarget(args));
+        return { kind: existing.kind, body: root };
+      },
     );
-    await upsertDashboard(dashboardId, existing.kind, root, ctx);
+    const root = saved.config as Record<string, unknown>;
     await syncToCollab(dashboardId, root);
 
     const compact = compactDashboardResult(root, orderResult.movedPanelIds);