@agent-native/core 0.145.8 → 0.146.1

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 7891
+- template files: 7903

package/corpus/templates/analytics/.agents/skills/turn-into-app/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Turn visible project context, a proven thread, skill, or workflow into a
   runnable Agent-Native app with simple buttons, visible agent steps, preview,
   and deployment handoff. Use when a user invokes `/turn-into-app` or asks to
-  make a workflow into an app.
+  make a workflow into an app, including from Claude or ChatGPT on the web.
 user-invocable: true
 scope: both
 metadata:
@@ -13,9 +13,36 @@ metadata:
 
 # Turn Into App
 
+## Host execution boundary
+
+The build location depends on the host. Treat this as a hard routing rule:
+
+- In Claude Web, ChatGPT Web, or a Claude/ChatGPT Project on the web, you are
+  the source analyst and handoff orchestrator. You must not build the app in
+  the host sandbox. Do not run `npm`, `pnpm`, `npx`, `agent-native create`, or
+  `add-app`; do not edit files, create artifacts, or start a local dev server.
+  After writing the bounded source brief, call the connected Dispatch action
+  `start-workspace-app-creation`. Pass the brief and repeatable workflow in
+  `prompt`, plus the inferred `appId`, `description`, `template`, and selected
+  `resourceIds` when available. This is the Builder handoff.
+- Do not substitute the generic `create_workspace_app` MCP tool in an online
+  host. That tool is a local workspace scaffolder, not the Builder handoff.
+- Connect the Agent-Native Dispatch MCP connector only. Dispatch uses the
+  authenticated Builder Projects API to reuse or provision the workspace
+  project before starting the Builder Cloud Agent; a separate Builder CMS MCP
+  connection is not required for this workflow.
+- If `start-workspace-app-creation` is not available or Dispatch is not
+  authenticated, stop with the connector setup needed. Do not fall back to a
+  local build or claim that the app exists.
+- In Claude Code, Codex Code, or another local code-agent runtime with a target
+  workspace, follow the local implementation steps below. The local agent may
+  scaffold, edit, run, and verify the app there.
+
 ## Default behavior
 
-This is an end-to-end build skill, not a request for an app proposal.
+For a local code-agent runtime this is an end-to-end build skill, not a request
+for an app proposal. For an online host, the end-to-end result is a verified
+Builder handoff and the resulting workspace app, not code written in the host.
 
 - With no argument, choose the source in this order: visible project context,
   then the current thread. A fresh Claude or ChatGPT Project is a valid source
@@ -47,9 +74,12 @@ private web access, invent an importer, add fake OAuth, or scrape a logged-in
 page. If the needed context is not visible, ask for an export, transcript, or
 attachment and treat that artifact as imported source material.
 
-Deliver a fresh app in a new directory, implement the repeatable workflow with
-buttons and agent handoffs, start its dev server, verify the main path, and
-continue through build/deployment handoff. Do not stop at a plan.
+For local code-agent runtimes, deliver a fresh app in a new directory,
+implement the repeatable workflow with buttons and agent handoffs, start its dev
+server, verify the main path, and continue through build/deployment handoff. Do
+not stop at a plan. For online hosts, call Dispatch first after the source brief,
+then report the returned Builder branch/path and verify the workspace app through
+Dispatch when it becomes available.
 
 ## Fresh project context mode
 
@@ -190,12 +220,12 @@ Do not use `create` for an existing workspace; it scaffolds a new standalone
 workspace rather than adding an app to the current one.
 
 When the source came from a fresh external Project and the target is a Builder
-workspace, prefer the available Dispatch MCP workspace handoff after writing
-the source brief. Call `start-workspace-app-creation` with a concise prompt,
-the inferred app id, and the brief's repeatable workflow. Pass selected
-workspace resource IDs when they are available, rather than pasting entire
-knowledge files. Continue from the returned workspace path or Builder handoff
-and report the actual verification result.
+workspace, the online host path is mandatory: after writing the source brief,
+call `start-workspace-app-creation` with a concise prompt, the inferred app id,
+and the brief's repeatable workflow. Pass selected workspace resource IDs when
+they are available, rather than pasting entire knowledge files. Continue from
+the returned workspace path or Builder branch handoff and report the actual
+verification result. Do not run the local scaffold commands in this host mode.
 
 Use a first-party template only when it materially fits the workflow. Keep the
 new app independent from the source thread's working tree unless the user

package/corpus/templates/analytics/.agents/skills/turn-into-app/references/fresh-project.md

@@ -50,14 +50,33 @@ skills. For a ChatGPT Project or any host that exposes only the MCP connector,
 also place the skill instructions or this reference in the Project
 instructions/knowledge files. Then add and authenticate the Dispatch MCP
 connector from the packaged `adapters/chatgpt-mcp/connector.json`.
+This single connector is enough: Dispatch provisions or reuses the Builder
+project through the Builder Projects API, so do not ask the user to add a
+separate Builder CMS MCP for app creation.
+Builder's separate Fusion MCP is available as a custom remote connector at
+`https://mcp.builder.io/mcp/fusion` for direct Builder work. It can run an
+existing project, but it cannot provision the repo-backed Agent-Native
+workspace project, so it is optional and not a replacement for the Dispatch
+handoff in this skill. Do not add Builder's CMS MCP for this workflow.
+
+For Claude Web, ChatGPT Web, and their web Projects, the host is an
+orchestrator, not the build environment. After forming the source brief, call
+the Dispatch `start-workspace-app-creation` action so Builder creates the app
+in the connected workspace. Do not use the host's code interpreter, shell,
+artifact editor, `create_workspace_app`, or local `pnpm`/`npm` commands. If the
+handoff action is unavailable, stop and ask the user to authenticate Dispatch;
+do not fall back to a local sandbox build. Claude Code and Codex Code are the
+local-agent exception and may follow the implementation steps in the main
+skill.
 
 In a new Project chat, say:
 
 ```text
 Turn this project into an app. Use the visible Project instructions,
 knowledge files, and any selected successful runs as the source. Create the
-app in the connected Agent-Native workspace, keep the source brief bounded,
-and report the real path and verification result.
+app in the connected Agent-Native workspace through Dispatch and Builder, keep
+the source brief bounded, and report the real Builder branch/path and
+verification result. Do not build it in this chat's sandbox.
 ```
 
 If the host does not show the Project instructions or files to the model, stop

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

@@ -1,9 +1,4 @@
 import { defineAction, embedApp } from "@agent-native/core";
-import {
-  hasCollabState,
-  applyText,
-  seedFromText,
-} from "@agent-native/core/collab";
 import {
   getRequestUserEmail,
   getRequestOrgId,
@@ -11,6 +6,7 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import { queueDashboardCollabSync } from "../server/lib/dashboard-collab-sync";
 import { validateFirstPartyDashboardTimeScope } from "../server/lib/dashboard-time-scope";
 import {
   getDashboard,
@@ -27,27 +23,6 @@ import {
   usesFirstPartyDashboardFilters,
 } from "../server/lib/first-party-metric-catalog";
 
-/**
- * Push the saved config through the collab layer so open dashboard editors get
- * the change in real time (mirrors update-dashboard).
- */
-async function syncToCollab(
-  dashboardId: string,
-  config: Record<string, unknown>,
-): Promise<void> {
-  const docId = `dash-${dashboardId}`;
-  const configStr = JSON.stringify(config);
-  try {
-    if (await hasCollabState(docId)) {
-      await applyText(docId, configStr, "content", "agent");
-    } else {
-      await seedFromText(docId, configStr);
-    }
-  } catch {
-    // Collab sync is best-effort — the SQL write is the source of truth.
-  }
-}
-
 const WINDOWS = new Set<MetricWindow>(["30d", "90d", "all"]);
 
 function normalizeWindow(raw: unknown): MetricWindow | undefined {
@@ -329,7 +304,7 @@ export default defineAction({
       ? (finalConfig.panels as unknown[]).length
       : 0;
 
-    await syncToCollab(args.dashboardId, finalConfig);
+    queueDashboardCollabSync(args.dashboardId, finalConfig, "agent");
 
     const parts: string[] = [];
     if (existing && !args.overwrite) {

package/corpus/templates/analytics/actions/get-sql-dashboard.ts

@@ -10,8 +10,10 @@ import {
   buildDashboardAgentContext,
   buildDashboardSeedAgentContext,
 } from "../server/lib/agent-readable-resource-context";
+import { repairCanonicalFirstPartyDashboardQueries } from "../server/lib/canonical-first-party-dashboard-repair";
 import { loadDashboardSeed } from "../server/lib/dashboard-seeds";
 import { getDashboard } from "../server/lib/dashboards-store";
+import { FIRST_PARTY_DASHBOARD_ID } from "../server/lib/first-party-metric-catalog";
 
 export default defineAction({
   description:
@@ -63,15 +65,28 @@ export default defineAction({
     const dash = await getDashboard(args.id, ctx);
     if (!dash || dash.kind !== "sql") {
       const seed = loadDashboardSeed(args.id);
-      if (seed)
-        return buildDashboardSeedAgentContext(args.id, seed, {
+      if (seed) {
+        const config =
+          args.id === FIRST_PARTY_DASHBOARD_ID
+            ? repairCanonicalFirstPartyDashboardQueries(seed).config
+            : seed;
+        return buildDashboardSeedAgentContext(args.id, config, {
           includeConfig: args.includeConfig === true,
         });
+      }
       throw Object.assign(new Error("Dashboard not found"), {
         statusCode: 404,
       });
     }
-    return buildDashboardAgentContext(dash, {
+    const dashboard =
+      args.id === FIRST_PARTY_DASHBOARD_ID
+        ? {
+            ...dash,
+            config: repairCanonicalFirstPartyDashboardQueries(dash.config)
+              .config,
+          }
+        : dash;
+    return buildDashboardAgentContext(dashboard, {
       includeConfig: args.includeConfig === true,
     });
   },

package/corpus/templates/analytics/actions/migrate-first-party-analytics-to-bigquery.ts

@@ -5,10 +5,13 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import {
+  getFirstPartyAnalyticsBigQueryBackfillJob,
+  queueFirstPartyAnalyticsBigQueryBackfill,
+} from "../server/jobs/analytics-bigquery-backfill.js";
 import { requireAnalyticsAdminContext } from "../server/lib/db-admin-connections.js";
 import {
   assertFirstPartyAnalyticsBigQueryReady,
-  backfillFirstPartyAnalyticsBatch,
   getFirstPartyAnalyticsBackend,
   saveFirstPartyAnalyticsBackend,
 } from "../server/lib/first-party-analytics-backend.js";
@@ -35,18 +38,23 @@ const migrationSchema = z.object({
     .describe(
       "Optional BigQuery table reference as dataset.table or project.dataset.table. The default is <BIGQUERY_PROJECT_ID>.analytics.first_party_analytics_events_raw.",
     ),
-  cursor: z.string().trim().optional(),
-  limit: z.number().int().min(1).max(5_000).optional(),
+  limit: z
+    .number()
+    .int()
+    .min(1)
+    .max(750)
+    .optional()
+    .describe("Optional per-page limit used when mode is prepare."),
   confirm: z.boolean().optional(),
 });
 
 export default defineAction({
   description:
-    "UI-only production migration for the current Analytics organization. Run prepare to validate the configured BigQuery table and enter dual-write mode, call backfill repeatedly with the returned cursor until complete, then call cutover with confirm=true. New /track events stay in Postgres during dual-write, so a BigQuery outage does not silently lose live data. Cutover is the only step that stops analytics event and rollup writes to Postgres; public-key metadata, derived exception issues, and session-replay data remain in the SQL store.",
+    "Production migration for the current Analytics organization. Run prepare to validate the configured BigQuery table, enter dual-write mode, and enqueue a durable single-flight worker. The worker uses bounded pages, a persisted cursor, a lease, and a database-pressure gate; it pauses instead of competing with live traffic. Call status or backfill to inspect progress, then call cutover with confirm=true only after the worker reports completed. New /track events stay in Postgres during dual-write, so a BigQuery outage does not silently lose live data. Cutover is the only step that stops first-party event and rollup writes to Postgres; public-key metadata, derived exception issues, and session-replay data remain in the SQL store.",
   schema: migrationSchema,
   agentTool: false,
   needsApproval: ({ mode }) => mode === "cutover",
-  run: async ({ mode, table, cursor, limit, confirm }) => {
+  run: async ({ mode, table, limit, confirm }) => {
     const scope = await resolveScope();
     const current = await getFirstPartyAnalyticsBackend(scope);
     const configuredTable = table ?? current.table;
@@ -56,27 +64,74 @@ export default defineAction({
         current.sink === "postgres"
           ? null
           : await assertFirstPartyAnalyticsBigQueryReady(current.table);
+      const job =
+        current.sink === "postgres"
+          ? null
+          : await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
       return {
         ...current,
+        backfillCursor:
+          current.sink === "dual"
+            ? (job?.cursor ?? null)
+            : current.backfillCursor,
+        backfillCompleted:
+          current.sink === "dual"
+            ? job?.status === "completed"
+            : current.backfillCompleted,
         ready: Boolean(ready),
         rowCount: ready?.rowCount ?? null,
         table: ready?.table.fullyQualified ?? current.table,
+        job,
       };
     }
 
     if (mode === "prepare") {
+      if (current.sink === "bigquery") {
+        throw new Error(
+          "This organization has already cut over to BigQuery; preparing it again is not supported.",
+        );
+      }
       const ready =
         await assertFirstPartyAnalyticsBigQueryReady(configuredTable);
+      const existingJob =
+        await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
+      if (existingJob && existingJob.table !== ready.table.fullyQualified) {
+        throw new Error(
+          `BigQuery backfill already targets ${existingJob.table}; prepare the existing migration before changing tables.`,
+        );
+      }
+      const initialCursor =
+        existingJob?.cursor ?? current.backfillCursor ?? null;
+      if (
+        !existingJob &&
+        current.sink === "dual" &&
+        !initialCursor &&
+        ready.rowCount > 0
+      ) {
+        throw new Error(
+          "Refusing to restart an existing dual-write BigQuery backfill without its legacy cursor; recover the migration cursor before preparing again.",
+        );
+      }
+      const initialCompleted =
+        existingJob?.status === "completed" ||
+        current.backfillCompleted === true;
       await saveFirstPartyAnalyticsBackend(scope, {
         sink: "dual",
         table: ready.table.fullyQualified,
-        backfillCursor: null,
-        backfillCompleted: false,
+        backfillCursor: initialCursor,
+        backfillCompleted: initialCompleted,
       });
+      const job = await queueFirstPartyAnalyticsBigQueryBackfill(
+        scope,
+        ready.table.fullyQualified,
+        limit,
+        initialCursor,
+      );
       return {
         sink: "dual" as const,
         table: ready.table.fullyQualified,
         existingBigQueryRows: ready.rowCount,
+        job,
         next: "backfill",
       };
     }
@@ -87,23 +142,18 @@ export default defineAction({
           "Prepare the organization for dual-write before starting the BigQuery backfill.",
         );
       }
-      const result = await backfillFirstPartyAnalyticsBatch(
-        scope,
-        cursor ?? current.backfillCursor ?? null,
-        limit ?? 500,
-        current.table,
-      );
-      await saveFirstPartyAnalyticsBackend(scope, {
-        sink: "dual",
-        table: current.table,
-        backfillCursor: result.nextCursor,
-        backfillCompleted: result.complete,
-      });
+      const job = await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
+      if (!job) {
+        throw new Error(
+          "Prepare the organization before enqueueing the BigQuery backfill.",
+        );
+      }
       return {
-        ...result,
         sink: "dual" as const,
         table: current.table,
-        next: result.complete ? "cutover" : "backfill",
+        job,
+        next: job.status === "completed" ? "cutover" : "backfill",
+        queued: job.status !== "completed",
       };
     }
 
@@ -112,16 +162,17 @@ export default defineAction({
         "Cutover requires confirm=true because it stops first-party event and rollup writes to Postgres for this organization.",
       );
     }
-    if (current.sink !== "dual" || current.backfillCompleted !== true) {
+    const job = await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
+    if (current.sink !== "dual" || job?.status !== "completed") {
       throw new Error(
-        "Complete the dual-write backfill before cutting over to BigQuery.",
+        "Wait for the durable dual-write backfill job to report completed before cutting over to BigQuery.",
       );
     }
     const ready = await assertFirstPartyAnalyticsBigQueryReady(current.table);
     await saveFirstPartyAnalyticsBackend(scope, {
       sink: "bigquery",
       table: ready.table.fullyQualified,
-      backfillCursor: current.backfillCursor,
+      backfillCursor: job.cursor,
       backfillCompleted: true,
     });
     return {

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

@@ -1,9 +1,4 @@
 import { defineAction, embedApp } from "@agent-native/core";
-import {
-  applyText,
-  hasCollabState,
-  seedFromText,
-} from "@agent-native/core/collab";
 import {
   buildDeepLink,
   getRequestOrgId,
@@ -11,6 +6,10 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import {
+  DASHBOARD_COLLAB_SYNC_TIMEOUT_MS,
+  queueDashboardCollabSync,
+} from "../server/lib/dashboard-collab-sync";
 import {
   getDashboard,
   upsertDashboardWithRetry,
@@ -171,24 +170,6 @@ function cloneConfig(config: Record<string, unknown>): Record<string, unknown> {
   return JSON.parse(JSON.stringify(config)) as Record<string, unknown>;
 }
 
-async function syncToCollab(
-  dashboardId: string,
-  config: Record<string, unknown>,
-): Promise<void> {
-  const docId = `dash-${dashboardId}`;
-  const configStr = JSON.stringify(config);
-  try {
-    const exists = await hasCollabState(docId);
-    if (exists) {
-      await applyText(docId, configStr, "content", "agent");
-    } else {
-      await seedFromText(docId, configStr);
-    }
-  } catch {
-    // SQL remains the source of truth; live collab sync is best-effort.
-  }
-}
-
 function sqlValidationScope(
   operations: DashboardMutationOperation[],
 ): ReadonlySet<string> | "all" | null {
@@ -399,7 +380,10 @@ export default defineAction({
       // 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);
+      // SQL is the durable source of truth. Collab sync is a convenience for
+      // already-open editors, so it must never hold the saved mutation hostage
+      // behind an unavailable database or a stale per-document write lock.
+      queueDashboardCollabSync(dashboardId, root, "agent");
     }
 
     const compact = compactDashboardResult(root, movedPanelIdsFrom(operations));
@@ -421,6 +405,14 @@ export default defineAction({
       insertedPanelIds: mutation.insertedPanelIds,
       removedPanelIds: mutation.removedPanelIds,
       dashboardFieldsChanged: mutation.dashboardFieldsChanged,
+      ...(args.dryRun === true
+        ? { collabSync: { status: "skipped" as const } }
+        : {
+            collabSync: {
+              status: "queued" as const,
+              timeoutMs: DASHBOARD_COLLAB_SYNC_TIMEOUT_MS,
+            },
+          }),
       ...(args.returnConfig === true ? { config: root } : {}),
       ...(args.returnTypes === true
         ? {

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

@@ -1,15 +1,11 @@
 import { defineAction } from "@agent-native/core";
-import {
-  hasCollabState,
-  applyText,
-  seedFromText,
-} from "@agent-native/core/collab";
 import {
   getRequestUserEmail,
   getRequestOrgId,
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import { queueDashboardCollabSync } from "../server/lib/dashboard-collab-sync";
 import { upsertDashboardWithRetry } from "../server/lib/dashboards-store";
 
 function resolveScope() {
@@ -19,24 +15,6 @@ function resolveScope() {
   return { orgId, email };
 }
 
-async function syncToCollab(
-  dashboardId: string,
-  config: Record<string, unknown>,
-  requestSource?: string,
-): Promise<void> {
-  const docId = `dash-${dashboardId}`;
-  const configStr = JSON.stringify(config);
-  try {
-    if (await hasCollabState(docId)) {
-      await applyText(docId, configStr, "content", requestSource);
-    } else {
-      await seedFromText(docId, configStr);
-    }
-  } catch {
-    // Best-effort: SQL remains the source of truth.
-  }
-}
-
 export default defineAction({
   description: "Rename a saved analytics dashboard by ID.",
   schema: z.object({
@@ -54,7 +32,7 @@ export default defineAction({
     const updated = await upsertDashboardWithRetry(args.id, ctx, (existing) => {
       return { kind: existing.kind, body: { ...existing.config, name } };
     });
-    await syncToCollab(
+    queueDashboardCollabSync(
       args.id,
       updated.config,
       actionContext?.caller === "frontend" ? undefined : "agent",

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

@@ -1,9 +1,4 @@
 import { defineAction, embedApp } from "@agent-native/core";
-import {
-  applyText,
-  hasCollabState,
-  seedFromText,
-} from "@agent-native/core/collab";
 import {
   buildDeepLink,
   getRequestOrgId,
@@ -11,6 +6,7 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import { queueDashboardCollabSync } from "../server/lib/dashboard-collab-sync";
 import { upsertDashboardWithRetry } from "../server/lib/dashboards-store";
 import {
   compactDashboardResult,
@@ -74,24 +70,6 @@ function resolveTarget(args: {
   return { position: args.position ?? "top" };
 }
 
-async function syncToCollab(
-  dashboardId: string,
-  config: Record<string, unknown>,
-): Promise<void> {
-  const docId = `dash-${dashboardId}`;
-  const configStr = JSON.stringify(config);
-  try {
-    const exists = await hasCollabState(docId);
-    if (exists) {
-      await applyText(docId, configStr, "content", "agent");
-    } else {
-      await seedFromText(docId, configStr);
-    }
-  } catch {
-    // SQL remains the source of truth; live collab sync is best-effort.
-  }
-}
-
 export default defineAction({
   agentTool: false,
   description:
@@ -172,7 +150,7 @@ export default defineAction({
       },
     );
     const root = saved.config as Record<string, unknown>;
-    await syncToCollab(dashboardId, root);
+    queueDashboardCollabSync(dashboardId, root, "agent");
 
     const compact = compactDashboardResult(root, orderResult.movedPanelIds);
     return {

package/corpus/templates/analytics/actions/restore-dashboard-revision.ts

@@ -1,15 +1,11 @@
 import { defineAction } from "@agent-native/core";
-import {
-  applyText,
-  hasCollabState,
-  seedFromText,
-} from "@agent-native/core/collab";
 import {
   getRequestOrgId,
   getRequestUserEmail,
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import { queueDashboardCollabSync } from "../server/lib/dashboard-collab-sync";
 import { restoreDashboardRevision } from "../server/lib/dashboards-store";
 
 function resolveScope() {
@@ -19,25 +15,6 @@ function resolveScope() {
   return { orgId, email };
 }
 
-async function syncToCollab(
-  dashboardId: string,
-  config: Record<string, unknown>,
-  requestSource?: string,
-): Promise<void> {
-  const docId = `dash-${dashboardId}`;
-  const configStr = JSON.stringify(config);
-  try {
-    const exists = await hasCollabState(docId);
-    if (exists) {
-      await applyText(docId, configStr, "content", requestSource);
-    } else {
-      await seedFromText(docId, configStr);
-    }
-  } catch {
-    // SQL is the source of truth; open editors also refetch on the dashboards signal.
-  }
-}
-
 export default defineAction({
   description:
     "Restore a dashboard to a saved history revision, snapshotting the current dashboard first.",
@@ -63,7 +40,7 @@ export default defineAction({
       );
     }
     const { dashboard, snapshotRevisionId } = restored;
-    await syncToCollab(
+    queueDashboardCollabSync(
       dashboard.id,
       dashboard.config,
       actionContext?.caller === "frontend" ? undefined : "agent",