@agent-native/core 0.123.0 → 0.123.2

package/corpus/templates/crm/actions/navigate.ts

@@ -0,0 +1,54 @@
+import { defineAction } from "@agent-native/core/action";
+import { writeAppStateForCurrentTab } from "@agent-native/core/application-state";
+import { z } from "zod";
+
+import {
+  CRM_RECORD_KINDS,
+  CRM_SETTINGS_SECTIONS,
+  CRM_VIEWS,
+  crmNavigationPath,
+} from "../shared/crm-navigation.js";
+
+export default defineAction({
+  description:
+    "Navigate the CRM UI to work, the record grid, one record, lists, a saved view, a list or view board, tasks, proposals, a dashboard, Ask CRM, setup, or one settings tab.",
+  schema: z.object({
+    view: z.enum(CRM_VIEWS),
+    recordId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(200)
+      .optional()
+      .describe("Required for view=record."),
+    listId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(200)
+      .optional()
+      .describe(
+        "Opens that list on the /views surface. A board needs this or viewId.",
+      ),
+    viewId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(200)
+      .optional()
+      .describe("Saved view to open. A board needs this or listId."),
+    dashboardId: z.string().trim().min(1).max(200).optional(),
+    kind: z
+      .enum(CRM_RECORD_KINDS)
+      .optional()
+      .describe("Record kind tab for view=records."),
+    query: z.string().trim().max(200).optional(),
+    settingsSection: z.enum(CRM_SETTINGS_SECTIONS).optional(),
+  }),
+  http: false,
+  run: async (args) => {
+    const path = crmNavigationPath(args);
+    await writeAppStateForCurrentTab("navigate", { ...args, path });
+    return { navigatingTo: path };
+  },
+});

package/corpus/templates/crm/actions/provider-api-catalog.ts

@@ -0,0 +1,22 @@
+import { createProviderApiCatalogAction } from "@agent-native/core/provider-api/actions/provider-api";
+import { z } from "zod";
+
+import {
+  CRM_PROVIDER_API_IDS,
+  getCrmProviderApiRuntime,
+} from "../server/lib/provider-api.js";
+
+const ProviderSchema = z.enum(CRM_PROVIDER_API_IDS);
+
+export default createProviderApiCatalogAction(getCrmProviderApiRuntime(), {
+  description:
+    "List the raw HubSpot and Salesforce API capabilities available through CRM's granted workspace connections. Use before provider-api-request when a CRM convenience action cannot express an endpoint, filter, custom object, pagination mode, or API version. Returns metadata and examples, never secret values.",
+  schema: z.object({
+    provider: ProviderSchema.optional().describe(
+      "Optional provider id to inspect: hubspot or salesforce.",
+    ),
+  }),
+  http: { method: "GET" },
+  guidance:
+    "CRM actions are convenience workflows, not a provider capability limit. For an exact HubSpot or Salesforce endpoint, inspect its catalog and docs before provider-api-request. For broad work, stage a bounded paginated result, reduce it with query-staged-dataset or a data program, and report the scope, row count, pagination status, truncation, and gaps.",
+});

package/corpus/templates/crm/actions/provider-api-docs.ts

@@ -0,0 +1,54 @@
+import { createProviderApiDocsAction } from "@agent-native/core/provider-api/actions/provider-api";
+import { z } from "zod";
+
+import {
+  CRM_PROVIDER_API_IDS,
+  getCrmProviderApiRuntime,
+} from "../server/lib/provider-api.js";
+
+const ProviderSchema = z.enum(CRM_PROVIDER_API_IDS);
+const BooleanFromQuerySchema = z.preprocess(
+  (value) => (typeof value === "string" ? value === "true" : value),
+  z.boolean(),
+);
+
+export default createProviderApiDocsAction(getCrmProviderApiRuntime(), {
+  description:
+    "Inspect HubSpot or Salesforce API documentation before an exact provider-api-request when the endpoint, object schema, field, filter operator, relationship, or pagination contract is uncertain.",
+  schema: z.object({
+    provider: ProviderSchema.describe("Provider whose API docs to inspect."),
+    url: z
+      .string()
+      .url()
+      .optional()
+      .describe(
+        "Optional public provider docs/spec URL. The provider catalog returns curated starting URLs.",
+      ),
+    maxBytes: z.coerce
+      .number()
+      .int()
+      .min(1_000)
+      .max(4 * 1024 * 1024)
+      .optional(),
+    maxChars: z.coerce.number().int().min(1).max(200_000).optional(),
+    responseMode: z
+      .enum(["auto", "raw", "text", "markdown", "links", "metadata", "matches"])
+      .optional(),
+    extract: z.enum(["readability", "all-visible", "none"]).optional(),
+    includeLinks: BooleanFromQuerySchema.optional(),
+    search: z
+      .object({
+        query: z.union([z.string(), z.array(z.string())]).optional(),
+        queries: z.array(z.string()).optional(),
+        terms: z.array(z.string()).optional(),
+        regex: z.string().optional(),
+        regexFlags: z.string().optional(),
+        source: z.enum(["extracted", "raw"]).optional(),
+        maxMatches: z.coerce.number().int().min(1).max(500).optional(),
+        contextChars: z.coerce.number().int().min(0).max(1_000).optional(),
+        caseSensitive: BooleanFromQuerySchema.optional(),
+      })
+      .optional(),
+  }),
+  http: { method: "GET" },
+});

package/corpus/templates/crm/actions/provider-api-request.ts

@@ -0,0 +1,92 @@
+import { createProviderApiRequestAction } from "@agent-native/core/provider-api/actions/provider-api";
+import { getCredentialContext } from "@agent-native/core/server/request-context";
+import { z } from "zod";
+
+import {
+  CRM_APP_ID,
+  CRM_PROVIDER_API_IDS,
+  getCrmProviderApiRuntime,
+} from "../server/lib/provider-api.js";
+
+const ProviderSchema = z.enum(CRM_PROVIDER_API_IDS);
+const MethodSchema = z.enum(["GET", "HEAD"]);
+
+const PaginationSchema = z
+  .object({
+    nextCursorPath: z.string().optional(),
+    cursorParam: z.string().optional(),
+    pageParam: z.string().optional(),
+    startPage: z.coerce.number().int().optional(),
+    offsetParam: z.string().optional(),
+    pageSize: z.coerce.number().int().min(1).optional(),
+    maxPages: z.coerce.number().int().min(1).max(200).optional(),
+  })
+  .optional();
+
+export default createProviderApiRequestAction(getCrmProviderApiRuntime(), {
+  description:
+    "Make an exact read-only authenticated HubSpot or Salesforce GET or HEAD request through a CRM-granted workspace connection. This is the flexible escape hatch for custom object, field, relationship, pagination, and API-version reads that CRM convenience actions do not model. It is host-constrained, access-scoped to the granted connection, and redacts secrets. Provider writes must use revision-aware CRM proposals, never this action. Use stageAs for large results instead of returning raw provider payloads to chat.",
+  schema: z
+    .object({
+      provider: ProviderSchema.describe("CRM provider: hubspot or salesforce."),
+      method: MethodSchema.default("GET"),
+      path: z
+        .string()
+        .min(1)
+        .describe(
+          "Provider API path, or a full URL on the selected connection's allowed provider host.",
+        ),
+      query: z.unknown().optional(),
+      headers: z.record(z.string(), z.unknown()).optional(),
+      auth: z.enum(["default", "none"]).default("default"),
+      connectionId: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe(
+          "Granted workspace connection id. Required for Salesforce so its actor-bound token and instance URL stay coupled.",
+        ),
+      timeoutMs: z.coerce.number().int().min(1_000).max(120_000).optional(),
+      maxBytes: z.coerce
+        .number()
+        .int()
+        .min(1_000)
+        .max(4 * 1024 * 1024)
+        .optional(),
+      stageAs: z
+        .string()
+        .min(1)
+        .optional()
+        .describe(
+          "Store response items as a caller-scoped scratch dataset and return a compact summary.",
+        ),
+      itemsPath: z.string().optional(),
+      pagination: PaginationSchema.describe(
+        "Server-side query-string pagination for a staged response. Use the provider's catalog/docs to choose its cursor fields.",
+      ),
+      saveToFile: z.string().optional(),
+      fetchAllPages: z
+        .object({
+          cursorPath: z.string(),
+          cursorParam: z.string().optional(),
+          itemsPath: z.string().optional(),
+          maxPages: z.coerce.number().int().min(1).max(50).optional(),
+        })
+        .optional(),
+    })
+    .superRefine((value, ctx) => {
+      if (value.provider === "salesforce" && !value.connectionId) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["connectionId"],
+          message:
+            "Salesforce provider reads require the granted workspace connection id.",
+        });
+      }
+    }),
+  appId: CRM_APP_ID,
+  getOwnerEmail: () => getCredentialContext()?.userEmail ?? null,
+  http: false,
+  toolCallable: false,
+});

package/corpus/templates/crm/actions/query-staged-dataset.ts

@@ -0,0 +1,44 @@
+import { createQueryStagedDatasetAction } from "@agent-native/core/provider-api/actions/staged-datasets";
+import { z } from "zod";
+
+import { CRM_APP_ID } from "../server/lib/provider-api.js";
+
+const WhereSchema = z.object({
+  column: z.string().min(1),
+  op: z.enum([
+    "equals",
+    "not_equals",
+    "contains",
+    "not_contains",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "exists",
+    "not_exists",
+  ]),
+  value: z.unknown().optional(),
+});
+
+const AggregateSchema = z.object({
+  column: z.string().min(1),
+  op: z.enum(["sum", "avg", "count", "min", "max", "count_distinct"]),
+  as: z.string().optional(),
+});
+
+export default createQueryStagedDatasetAction({
+  description:
+    "Filter, project, sort, or aggregate a caller-scoped staged CRM provider dataset without re-fetching the provider. For exhaustive CRM analysis, stage every bounded page first and report the dataset's source scope, row count, pagination status, truncation, and gaps.",
+  schema: z.object({
+    datasetId: z.string().min(1),
+    where: z.array(WhereSchema).optional(),
+    groupBy: z.array(z.string().min(1)).optional(),
+    aggregate: z.array(AggregateSchema).optional(),
+    select: z.array(z.string().min(1)).optional(),
+    orderBy: z.string().optional(),
+    orderDir: z.enum(["asc", "desc"]).optional(),
+    limit: z.coerce.number().int().min(1).max(10_000).optional(),
+  }),
+  http: false,
+  appId: CRM_APP_ID,
+});

package/corpus/templates/crm/actions/record-crm-call-insight.ts

@@ -0,0 +1,160 @@
+import { defineAction } from "@agent-native/core/action";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { isSafeCrmEvidenceExcerpt } from "../server/crm/crm-field-firewall.js";
+import { getDb, schema } from "../server/db/index.js";
+import {
+  crmSignalIdempotencyKey,
+  signalTupleError,
+} from "./_crm-signal-utils.js";
+
+const insightSchema = z.object({
+  evidenceId: z.string().trim().min(1).max(128),
+  kind: z.enum(["call-summary", "next-step"]),
+  label: z.string().trim().min(1).max(120),
+  summary: z.string().trim().min(1).max(1_200).refine(isSafeCrmEvidenceExcerpt),
+  quote: z
+    .string()
+    .trim()
+    .max(1_200)
+    .refine(isSafeCrmEvidenceExcerpt)
+    .optional(),
+  quoteSeconds: z.coerce.number().finite().min(0).max(86_400),
+});
+
+export default defineAction({
+  description:
+    "Atomically record a bounded, evidence-cited call recap or next-step set produced through agent chat. No transcript body or raw model response is accepted.",
+  schema: z.object({
+    runId: z.string().trim().min(1).max(128),
+    recordId: z.string().trim().min(1).max(128),
+    insights: z.array(insightSchema).min(1).max(20),
+    model: z.string().trim().min(1).max(120),
+    modelVersion: z.string().trim().max(120).optional(),
+    idempotencyKey: z.string().trim().min(1).max(180),
+  }),
+  run: async (args, ctx) => {
+    await Promise.all([
+      assertAccess("crm-record", args.recordId, "editor"),
+      assertAccess("crm-signal-run", args.runId, "editor"),
+      ...args.insights.map((item) =>
+        assertAccess("crm-call-evidence", item.evidenceId, "viewer"),
+      ),
+    ]);
+    const db = getDb();
+    const [run] = await db
+      .select()
+      .from(schema.crmSignalRuns)
+      .where(
+        and(
+          eq(schema.crmSignalRuns.id, args.runId),
+          accessFilter(schema.crmSignalRuns, schema.crmSignalRunShares),
+        ),
+      )
+      .limit(1);
+    const evidenceIds = [
+      ...new Set(args.insights.map((item) => item.evidenceId)),
+    ];
+    const evidence = await db
+      .select()
+      .from(schema.crmCallEvidence)
+      .where(
+        and(
+          inArray(schema.crmCallEvidence.id, evidenceIds),
+          accessFilter(schema.crmCallEvidence, schema.crmCallEvidenceShares),
+        ),
+      )
+      .limit(20);
+    if (
+      !run ||
+      run.kind !== "summary" ||
+      run.recordId !== args.recordId ||
+      evidence.length !== evidenceIds.length ||
+      evidence.some((item) => item.recordId !== args.recordId)
+    )
+      signalTupleError(
+        "The summary run, evidence, and record do not form an accessible tuple.",
+      );
+    const byId = new Map(evidence.map((item) => [item.id, item]));
+    const now = new Date().toISOString();
+    const rows: Array<typeof schema.crmSignals.$inferInsert> = [];
+    for (const [index, item] of args.insights.entries()) {
+      const source = byId.get(item.evidenceId)!;
+      const excerpt = source.quote.trim() || source.summary.trim();
+      if (item.quote && !excerpt.includes(item.quote))
+        throw new Error(
+          "Every insight quote must be an exact substring of its stored bounded evidence excerpt.",
+        );
+      const start = source.startSeconds ?? 0;
+      if (
+        item.quoteSeconds < start ||
+        (source.endSeconds !== null && item.quoteSeconds > source.endSeconds)
+      )
+        throw new Error(
+          "Every insight timestamp must fall inside its evidence excerpt.",
+        );
+      const idem = await crmSignalIdempotencyKey(
+        ctx,
+        args.recordId,
+        `${args.idempotencyKey}:${index}`,
+      );
+      rows.push({
+        id: crypto.randomUUID(),
+        runId: args.runId,
+        trackerId: null,
+        recordId: args.recordId,
+        evidenceId: item.evidenceId,
+        kind: item.kind,
+        label: item.label,
+        quote: item.quote ?? "",
+        speaker: source.speaker,
+        startSeconds: item.quoteSeconds,
+        endSeconds: source.endSeconds,
+        summary: item.summary,
+        confidence: 100,
+        detector: "agent",
+        model: args.model,
+        modelVersion: args.modelVersion ?? null,
+        reviewStatus: "unreviewed",
+        idempotencyKey: idem.key,
+        ...idem.scope,
+        createdAt: now,
+        updatedAt: now,
+      });
+    }
+    const existing = await db
+      .select({ key: schema.crmSignals.idempotencyKey })
+      .from(schema.crmSignals)
+      .where(
+        and(
+          inArray(
+            schema.crmSignals.idempotencyKey,
+            rows.map((row) => row.idempotencyKey),
+          ),
+          accessFilter(schema.crmSignals, schema.crmSignalShares),
+        ),
+      );
+    const existingKeys = new Set(existing.map((item) => item.key));
+    const pending = rows.filter((row) => !existingKeys.has(row.idempotencyKey));
+    await db.transaction(async (tx) => {
+      if (pending.length) await tx.insert(schema.crmSignals).values(pending);
+      await tx
+        .update(schema.crmSignalRuns)
+        .set({
+          status: "completed",
+          model: args.model,
+          modelVersion: args.modelVersion ?? null,
+          completedAt: now,
+          updatedAt: now,
+        })
+        .where(eq(schema.crmSignalRuns.id, args.runId));
+    });
+    return {
+      created: pending.length,
+      replayed: rows.length - pending.length,
+      signalIds: pending.map((row) => row.id),
+    };
+  },
+});

package/corpus/templates/crm/actions/record-crm-smart-signal.ts

@@ -0,0 +1,150 @@
+import { defineAction } from "@agent-native/core/action";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { isSafeCrmEvidenceExcerpt } from "../server/crm/crm-field-firewall.js";
+import { getDb, schema } from "../server/db/index.js";
+import {
+  crmSignalIdempotencyKey,
+  signalTupleError,
+} from "./_crm-signal-utils.js";
+
+export default defineAction({
+  description:
+    "Record one delegated-agent detector hit only after grounding it to an access-scoped evidence excerpt and queued smart run.",
+  schema: z.object({
+    runId: z.string().trim().min(1).max(128),
+    trackerId: z.string().trim().min(1).max(128),
+    recordId: z.string().trim().min(1).max(128),
+    evidenceId: z.string().trim().min(1).max(128),
+    quote: z.string().trim().min(1).max(1_200).refine(isSafeCrmEvidenceExcerpt),
+    confidence: z.coerce.number().finite().min(0).max(100),
+    model: z.string().trim().min(1).max(120),
+    modelVersion: z.string().trim().max(120).optional(),
+    idempotencyKey: z.string().trim().min(1).max(180),
+  }),
+  run: async (args, ctx) => {
+    await Promise.all([
+      assertAccess("crm-record", args.recordId, "editor"),
+      assertAccess("crm-signal-run", args.runId, "editor"),
+      assertAccess("crm-signal-tracker", args.trackerId, "viewer"),
+      assertAccess("crm-call-evidence", args.evidenceId, "viewer"),
+    ]);
+    const db = getDb();
+    const [[run], [tracker], [evidence]] = await Promise.all([
+      db
+        .select()
+        .from(schema.crmSignalRuns)
+        .where(
+          and(
+            eq(schema.crmSignalRuns.id, args.runId),
+            accessFilter(schema.crmSignalRuns, schema.crmSignalRunShares),
+          ),
+        )
+        .limit(1),
+      db
+        .select()
+        .from(schema.crmSignalTrackers)
+        .where(
+          and(
+            eq(schema.crmSignalTrackers.id, args.trackerId),
+            accessFilter(
+              schema.crmSignalTrackers,
+              schema.crmSignalTrackerShares,
+            ),
+          ),
+        )
+        .limit(1),
+      db
+        .select()
+        .from(schema.crmCallEvidence)
+        .where(
+          and(
+            eq(schema.crmCallEvidence.id, args.evidenceId),
+            accessFilter(schema.crmCallEvidence, schema.crmCallEvidenceShares),
+          ),
+        )
+        .limit(1),
+    ]);
+    if (
+      !run ||
+      !tracker ||
+      !evidence ||
+      run.kind !== "smart" ||
+      run.recordId !== args.recordId ||
+      run.trackerId !== args.trackerId ||
+      tracker.kind !== "smart" ||
+      evidence.recordId !== args.recordId
+    )
+      signalTupleError(
+        "The signal run, tracker, evidence, and record do not form an accessible tuple.",
+      );
+    const source = evidence.quote.trim() || evidence.summary.trim();
+    if (!source.includes(args.quote))
+      throw new Error(
+        "The signal quote must be an exact substring of the stored bounded evidence excerpt.",
+      );
+    const idem = await crmSignalIdempotencyKey(
+      ctx,
+      args.recordId,
+      args.idempotencyKey,
+    );
+    const [existing] = await db
+      .select()
+      .from(schema.crmSignals)
+      .where(
+        and(
+          eq(schema.crmSignals.idempotencyKey, idem.key),
+          accessFilter(schema.crmSignals, schema.crmSignalShares),
+        ),
+      )
+      .limit(1);
+    if (existing) return existing;
+    const now = new Date().toISOString();
+    const id = crypto.randomUUID();
+    await db.transaction(async (tx) => {
+      await tx.insert(schema.crmSignals).values({
+        id,
+        runId: args.runId,
+        trackerId: args.trackerId,
+        recordId: args.recordId,
+        evidenceId: args.evidenceId,
+        kind: "moment",
+        label: tracker.name,
+        quote: args.quote,
+        speaker: evidence.speaker,
+        startSeconds: evidence.startSeconds,
+        endSeconds: evidence.endSeconds,
+        summary: "",
+        confidence: args.confidence,
+        detector: "agent",
+        model: args.model,
+        modelVersion: args.modelVersion ?? null,
+        reviewStatus: "unreviewed",
+        idempotencyKey: idem.key,
+        ...idem.scope,
+        createdAt: now,
+        updatedAt: now,
+      });
+      await tx
+        .update(schema.crmSignalRuns)
+        .set({
+          status: "completed",
+          model: args.model,
+          modelVersion: args.modelVersion ?? null,
+          completedAt: now,
+          updatedAt: now,
+        })
+        .where(eq(schema.crmSignalRuns.id, args.runId));
+    });
+    const [saved] = await db
+      .select()
+      .from(schema.crmSignals)
+      .where(eq(schema.crmSignals.id, id))
+      .limit(1);
+    if (!saved)
+      throw new Error("CRM signal could not be verified after saving.");
+    return saved;
+  },
+});

package/corpus/templates/crm/actions/remove-crm-list-entry.ts

@@ -0,0 +1,79 @@
+import { defineAction } from "@agent-native/core/action";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { requireCrmListEntry } from "./_crm-list-utils.js";
+
+export default defineAction({
+  description:
+    "Remove one entry from a CRM list. This deletes the list membership and the values held on that entry only. The underlying CRM record, its own attributes, and any other entries it has — in this list or another — are left completely intact. It is NOT a way to delete a record.",
+  schema: z.object({
+    entryId: z.string().trim().min(1).max(128),
+  }),
+  audit: {
+    target: (_args, result) => {
+      const entry = result as {
+        entryId: string;
+        ownerEmail: string;
+        orgId: string | null;
+        visibility: "private" | "org" | "public";
+      };
+      return {
+        type: "crm-list-entry",
+        id: entry.entryId,
+        ownerEmail: entry.ownerEmail,
+        orgId: entry.orgId,
+        visibility: entry.visibility,
+      };
+    },
+    summary: (args) => `Removed CRM list entry ${args.entryId}`,
+  },
+  run: async (args) => {
+    const db = getDb();
+    const entry = await requireCrmListEntry(db, args.entryId, "editor");
+
+    await db.transaction(async (tx) => {
+      // Entry-scoped value rows only: `entry_id` is the record-vs-entry
+      // discriminator, so the record's own attribute history is untouched.
+      await tx
+        .delete(schema.crmRecordFields)
+        .where(
+          and(
+            eq(schema.crmRecordFields.entryId, entry.id),
+            accessFilter(
+              schema.crmRecordFields,
+              schema.crmRecordFieldShares,
+              undefined,
+              "editor",
+            ),
+          ),
+        );
+      await tx
+        .delete(schema.crmListEntries)
+        .where(
+          and(
+            eq(schema.crmListEntries.id, entry.id),
+            accessFilter(
+              schema.crmListEntries,
+              schema.crmListEntryShares,
+              undefined,
+              "editor",
+            ),
+          ),
+        );
+    });
+
+    return {
+      entryId: entry.id,
+      listId: entry.listId,
+      recordId: entry.recordId,
+      removed: true as const,
+      recordDeleted: false as const,
+      ownerEmail: entry.ownerEmail,
+      orgId: entry.orgId,
+      visibility: entry.visibility,
+    };
+  },
+});

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

@@ -0,0 +1,23 @@
+import { defineAction, type ActionRunContext } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { crmDashboardStore } from "../server/db/index.js";
+import { requireDashboardAccess } from "./_crm-dashboard.js";
+
+export default defineAction({
+  description:
+    "Restore one revision of an access-scoped CRM dashboard. The restore is revision-aware and fails if the dashboard changed concurrently.",
+  schema: z.object({
+    id: z.string().trim().min(1).max(200),
+    revisionId: z.string().trim().min(1).max(200),
+  }),
+  run: async ({ id, revisionId }, ctx?: ActionRunContext) => {
+    const dashboard = await crmDashboardStore.restore(
+      id,
+      revisionId,
+      requireDashboardAccess(ctx),
+    );
+    if (!dashboard) throw new Error("CRM dashboard revision was not found.");
+    return dashboard;
+  },
+});