@agent-native/core 0.117.2 → 0.118.1

package/corpus/templates/crm/actions/configure-native-crm.ts

@@ -1,44 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { z } from "zod";
-
-import { configureNativeCrmConnection } from "../server/crm/native-adapter.js";
-import { requireCrmScope } from "./_crm-action-utils.js";
-
-export default defineAction({
-  description:
-    "Initialize a local-authoritative Native SQL CRM with accounts, people, and opportunities. It requires no provider connection or credential and uses the configured SQLite, Postgres, or D1 database.",
-  schema: z.object({
-    label: z.string().trim().min(1).max(160).optional(),
-  }),
-  audit: {
-    target: (_args, result) => {
-      const connection = result as {
-        id: string;
-        ownerEmail: string;
-        orgId: string | null;
-        visibility: "private" | "org";
-      };
-      return {
-        type: "crm-connection",
-        id: connection.id,
-        ownerEmail: connection.ownerEmail,
-        orgId: connection.orgId,
-        visibility: connection.visibility,
-      };
-    },
-    summary: (_args, result) =>
-      `Configured Native SQL CRM ${(result as { id?: string })?.id ?? ""}`,
-    recordInputs: false,
-  },
-  run: async (args, ctx?: ActionRunContext) => {
-    const result = await configureNativeCrmConnection({
-      label: args.label,
-      ownership: requireCrmScope(ctx),
-    });
-    return {
-      ...result,
-      provider: "native" as const,
-      mode: "native" as const,
-    };
-  },
-});

package/corpus/templates/crm/actions/create-crm-record.ts

@@ -1,148 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { accessFilter } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
-import { z } from "zod";
-
-import {
-  configureNativeCrmConnection,
-  createNativeCrmAdapter,
-} from "../server/crm/native-adapter.js";
-import { getDb, schema } from "../server/db/index.js";
-import type { CrmValue } from "../shared/crm-contract.js";
-import {
-  crmInitiatedBy,
-  isSafeCrmMutationFields,
-  MAX_CRM_FIELDS_PER_MUTATION,
-  requireCrmScope,
-  scopedCrmIdempotencyKey,
-} from "./_crm-action-utils.js";
-
-const kindToObjectType = {
-  account: "accounts",
-  person: "people",
-  opportunity: "opportunities",
-} as const;
-
-export const nativeRecordFieldsSchema = z
-  .record(z.string().trim().min(1).max(120), z.unknown())
-  .refine(
-    (fields) => Object.keys(fields).length <= MAX_CRM_FIELDS_PER_MUTATION,
-    `Provide at most ${MAX_CRM_FIELDS_PER_MUTATION} fields.`,
-  )
-  .refine(
-    isSafeCrmMutationFields,
-    "CRM fields and values cannot contain media, transcripts, data URLs, base64, or oversized JSON.",
-  );
-
-export default defineAction({
-  description:
-    "Create an account, person, or opportunity in Native SQL CRM. The record is local-authoritative, access-scoped, idempotent, audited, and has no upstream provider write.",
-  schema: z.object({
-    connectionId: z.string().trim().min(1).max(128).optional(),
-    kind: z.enum(["account", "person", "opportunity"]),
-    displayName: z.string().trim().min(1).max(500),
-    fields: nativeRecordFieldsSchema.optional(),
-    idempotencyKey: z.string().trim().min(1).max(256).optional(),
-  }),
-  audit: {
-    target: (_args, result) => {
-      const record = result as {
-        recordId: string;
-        ownerEmail: string;
-        orgId: string | null;
-        visibility: "private" | "org";
-      };
-      return {
-        type: "crm-record",
-        id: record.recordId,
-        ownerEmail: record.ownerEmail,
-        orgId: record.orgId,
-        visibility: record.visibility,
-      };
-    },
-    summary: (args) =>
-      `Created Native SQL CRM ${args.kind} ${args.displayName}`,
-    recordInputs: false,
-  },
-  run: async (args, ctx?: ActionRunContext) => {
-    const ownership = requireCrmScope(ctx);
-    const db = getDb();
-    const connectionRows = await db
-      .select({ id: schema.crmConnections.id })
-      .from(schema.crmConnections)
-      .where(
-        and(
-          eq(schema.crmConnections.provider, "native"),
-          ...(args.connectionId
-            ? [eq(schema.crmConnections.id, args.connectionId)]
-            : []),
-          accessFilter(
-            schema.crmConnections,
-            schema.crmConnectionShares,
-            undefined,
-            "editor",
-          ),
-        ),
-      )
-      .limit(args.connectionId ? 1 : 2);
-    if (!connectionRows.length && args.connectionId) {
-      throw new Error(
-        "The selected Native SQL CRM is unavailable or you do not have editor access.",
-      );
-    }
-    if (!args.connectionId && connectionRows.length > 1) {
-      throw new Error(
-        "More than one Native SQL CRM is available. Provide connectionId to choose one.",
-      );
-    }
-    const connectionId =
-      connectionRows[0]?.id ??
-      (
-        await configureNativeCrmConnection({
-          ownership,
-        })
-      ).id;
-    const objectType = kindToObjectType[args.kind];
-    const remoteId = crypto.randomUUID();
-    const fields = {
-      ...(args.fields as Record<string, CrmValue> | undefined),
-      displayName: args.displayName,
-      ...(args.kind === "person" ? {} : { name: args.displayName }),
-    };
-    const idempotencyKey = await scopedCrmIdempotencyKey({
-      ...ownership,
-      recordId: `${connectionId}:${objectType}`,
-      key: args.idempotencyKey ?? crypto.randomUUID(),
-    });
-    const adapter = await createNativeCrmAdapter({
-      connectionId,
-      initiatedBy: crmInitiatedBy(ctx),
-    });
-    const result = await adapter.applyMutation({
-      operation: "create",
-      record: {
-        connectionId,
-        provider: "native",
-        objectType,
-        kind: args.kind,
-        remoteId,
-      },
-      fields,
-      idempotencyKey,
-    });
-    if (result.status !== "applied" || !result.record?.ref.localId) {
-      throw new Error(
-        result.message ?? "Native SQL CRM record was not created.",
-      );
-    }
-    return {
-      recordId: result.record.ref.localId,
-      connectionId,
-      provider: "native" as const,
-      kind: args.kind,
-      displayName: result.record.displayName,
-      revision: result.remoteRevision,
-      ...ownership,
-    };
-  },
-});

package/corpus/templates/crm/actions/create-crm-signal-tracker.ts

@@ -1,58 +0,0 @@
-import { defineAction } from "@agent-native/core/action";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-import { requireCrmScope } from "./_crm-action-utils.js";
-
-export default defineAction({
-  description:
-    "Create a bounded keyword or delegated-agent CRM signal detector. Smart detectors define criteria only; this action never calls a model.",
-  schema: z
-    .object({
-      name: z.string().trim().min(1).max(120),
-      description: z.string().trim().max(500).default(""),
-      kind: z.enum(["keyword", "smart"]),
-      keywords: z.array(z.string().trim().min(1).max(80)).max(40).default([]),
-      classifierPrompt: z.string().trim().max(1_000).default(""),
-      enabled: z.boolean().default(true),
-    })
-    .superRefine((value, ctx) => {
-      if (value.kind === "keyword" && value.keywords.length === 0) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["keywords"],
-          message: "Keyword detectors require at least one keyword.",
-        });
-      }
-      if (value.kind === "smart" && !value.classifierPrompt) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["classifierPrompt"],
-          message: "Smart detectors require a classification criterion.",
-        });
-      }
-    }),
-  run: async (args, ctx) => {
-    const scope = requireCrmScope(ctx);
-    const now = new Date().toISOString();
-    const id = crypto.randomUUID();
-    await getDb()
-      .insert(schema.crmSignalTrackers)
-      .values({
-        id,
-        name: args.name,
-        description: args.description,
-        kind: args.kind,
-        keywordsJson: JSON.stringify(
-          args.kind === "keyword" ? args.keywords : [],
-        ),
-        classifierPrompt: args.kind === "smart" ? args.classifierPrompt : "",
-        enabled: args.enabled,
-        isDefault: false,
-        ...scope,
-        createdAt: now,
-        updatedAt: now,
-      });
-    return { id, ...args };
-  },
-});

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

@@ -1,14 +0,0 @@
-import { createDeleteStagedDatasetAction } from "@agent-native/core/provider-api/actions/staged-datasets";
-import { getCredentialContext } from "@agent-native/core/server/request-context";
-import { z } from "zod";
-
-import { CRM_APP_ID } from "../server/lib/provider-api.js";
-
-export default createDeleteStagedDatasetAction({
-  description:
-    "Delete a caller-scoped staged dataset after CRM analysis is complete.",
-  schema: z.object({ datasetId: z.string().min(1) }),
-  appId: CRM_APP_ID,
-  getOwnerEmail: () => getCredentialContext()?.userEmail ?? null,
-  http: false,
-});

package/corpus/templates/crm/actions/get-crm-automation-recipe.ts

@@ -1,36 +0,0 @@
-import { defineAction } from "@agent-native/core/action";
-import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-import {
-  CLIPS_CALL_EVIDENCE_RECIPE_ID,
-  buildClipsCallEvidenceRecipe,
-} from "../shared/crm-automation-recipes.js";
-
-export default defineAction({
-  description:
-    "Return the default-off Clips call-evidence review recipe for one explicitly selected CRM record. The recipe never passes media, transcripts, or an event URL into CRM.",
-  schema: z.object({
-    recipeId: z
-      .literal(CLIPS_CALL_EVIDENCE_RECIPE_ID)
-      .default(CLIPS_CALL_EVIDENCE_RECIPE_ID),
-    recordId: z.string().trim().min(1).max(128),
-  }),
-  http: { method: "GET" },
-  readOnly: true,
-  run: async ({ recordId }) => {
-    await assertAccess("crm-record", recordId, "viewer");
-    const [record] = await getDb()
-      .select({ displayName: schema.crmRecords.displayName })
-      .from(schema.crmRecords)
-      .where(eq(schema.crmRecords.id, recordId))
-      .limit(1);
-    if (!record) throw new Error("CRM record was not found.");
-    return buildClipsCallEvidenceRecipe({
-      recordId,
-      recordLabel: record.displayName,
-    });
-  },
-});

package/corpus/templates/crm/actions/get-crm-dashboard-panel.ts

@@ -1,35 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { createProgramPanelSourceResolver } from "@agent-native/core/dashboard-storage";
-import { z } from "zod";
-
-import { crmDashboardStore } from "../server/db/index.js";
-import { CRM_APP_ID } from "../server/lib/provider-api.js";
-import { requireDashboardAccess } from "./_crm-dashboard.js";
-import { initCrmDataPrograms } from "./_crm-data-program-actions.js";
-
-const programResolver = createProgramPanelSourceResolver({ appId: CRM_APP_ID });
-
-export default defineAction({
-  description:
-    "Resolve one program-backed panel from an access-scoped CRM dashboard for the dashboard UI.",
-  schema: z.object({
-    dashboardId: z.string().trim().min(1).max(200),
-    panelId: z.string().trim().min(1).max(120),
-  }),
-  http: { method: "GET" },
-  readOnly: true,
-  agentTool: false,
-  toolCallable: false,
-  run: async ({ dashboardId, panelId }, ctx?: ActionRunContext) => {
-    const access = requireDashboardAccess(ctx);
-    const dashboard = await crmDashboardStore.get(dashboardId, access);
-    if (!dashboard) throw new Error("CRM dashboard was not found.");
-    const panel = dashboard.config.panels.find((item) => item.id === panelId);
-    if (!panel) throw new Error("CRM dashboard panel was not found.");
-    initCrmDataPrograms();
-    return programResolver.resolve(
-      { source: panel.source, query: panel.query },
-      { userEmail: access.userEmail, orgId: access.orgId ?? null },
-    );
-  },
-});

package/corpus/templates/crm/actions/get-crm-dashboard.ts

@@ -1,14 +0,0 @@
-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: "Get one access-scoped CRM dashboard by ID.",
-  schema: z.object({ id: z.string().trim().min(1).max(200) }),
-  http: { method: "GET" },
-  readOnly: true,
-  run: ({ id }, ctx?: ActionRunContext) =>
-    crmDashboardStore.get(id, requireDashboardAccess(ctx)),
-});

package/corpus/templates/crm/actions/get-crm-overview.ts

@@ -1,13 +0,0 @@
-import { defineAction } from "@agent-native/core/action";
-import { z } from "zod";
-
-import { getCrmOverview } from "../server/db/crm-store.js";
-
-export default defineAction({
-  description:
-    "Return a compact, access-scoped CRM work overview: open follow-up tasks, recently active mirrored records, and pending write proposals.",
-  schema: z.object({}),
-  http: { method: "GET" },
-  readOnly: true,
-  run: () => getCrmOverview(),
-});

package/corpus/templates/crm/actions/get-crm-pipeline-data.ts

@@ -1,61 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { accessFilter } from "@agent-native/core/sharing";
-import { and, asc, eq } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-import { requireDashboardAccess } from "./_crm-dashboard.js";
-
-const MAX_PIPELINE_RECORDS = 500;
-
-export default defineAction({
-  description:
-    "Return bounded, access-scoped pipeline totals grouped by opportunity stage. This is the CRM-owned read source for the Pipeline dashboard data program.",
-  schema: z.object({}),
-  http: { method: "GET" },
-  readOnly: true,
-  run: async (_args, ctx?: ActionRunContext) => {
-    const access = requireDashboardAccess(ctx);
-    const records = await getDb()
-      .select({
-        stage: schema.crmRecords.stage,
-        amount: schema.crmRecords.amount,
-      })
-      .from(schema.crmRecords)
-      .where(
-        and(
-          eq(schema.crmRecords.kind, "opportunity"),
-          eq(schema.crmRecords.tombstone, false),
-          accessFilter(schema.crmRecords, schema.crmRecordShares, access),
-        ),
-      )
-      .orderBy(asc(schema.crmRecords.stage))
-      .limit(MAX_PIPELINE_RECORDS);
-
-    const stages = new Map<
-      string,
-      { stage: string; pipelineValue: number; opportunities: number }
-    >();
-    for (const record of records) {
-      const stage = record.stage?.trim() || "Unstaged";
-      const total = stages.get(stage) ?? {
-        stage,
-        pipelineValue: 0,
-        opportunities: 0,
-      };
-      total.pipelineValue += Number.isFinite(record.amount)
-        ? record.amount!
-        : 0;
-      total.opportunities += 1;
-      stages.set(stage, total);
-    }
-    const rows = [...stages.values()].sort((a, b) =>
-      a.stage.localeCompare(b.stage),
-    );
-    return {
-      rows,
-      truncated: records.length === MAX_PIPELINE_RECORDS,
-      sourceRecordLimit: MAX_PIPELINE_RECORDS,
-    };
-  },
-});

package/corpus/templates/crm/actions/get-crm-record.ts

@@ -1,75 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { z } from "zod";
-
-import {
-  createConnectedCrmAdapter,
-  isConnectedCrmProvider,
-} from "../server/crm/adapter.js";
-import { createNativeCrmAdapter } from "../server/crm/native-adapter.js";
-import { loadVerifiedReadThroughRecord } from "../server/crm/read-through.js";
-import {
-  getCrmRecord,
-  getCrmRecordReadContext,
-  getReadThroughRelationshipSummaries,
-} from "../server/db/crm-store.js";
-
-export default defineAction({
-  description:
-    "Return one access-scoped CRM record with bounded mirrored fields, recent interaction metadata, call-evidence references, and tasks. It never returns raw provider payloads, media, or transcripts.",
-  schema: z.object({
-    recordId: z.string().min(1).describe("Local CRM record ID."),
-  }),
-  http: { method: "GET" },
-  readOnly: true,
-  run: async ({ recordId }, ctx?: ActionRunContext) => {
-    const context = await getCrmRecordReadContext(recordId);
-    if (!context) {
-      const error = new Error("CRM record not found") as Error & {
-        statusCode?: number;
-      };
-      error.statusCode = 404;
-      throw error;
-    }
-    const adapter =
-      context.provider === "native"
-        ? await createNativeCrmAdapter({
-            connectionId: context.connectionId,
-            accessTier: "viewer",
-          })
-        : isConnectedCrmProvider(context.provider) &&
-            context.workspaceConnectionId
-          ? await createConnectedCrmAdapter({
-              provider: context.provider,
-              connectionId: context.workspaceConnectionId,
-              ...(ctx?.userEmail ? { userEmail: ctx.userEmail } : {}),
-              ...(ctx?.orgId !== undefined ? { orgId: ctx.orgId } : {}),
-            })
-          : null;
-    if (!adapter) {
-      throw new Error("CRM access cannot be verified for this record.");
-    }
-    const readThrough = await loadVerifiedReadThroughRecord({
-      adapter,
-      context,
-    });
-    const relatedRecords = await getReadThroughRelationshipSummaries({
-      context,
-      relationships: readThrough.relationships,
-      currentScopes: readThrough.currentScopes,
-    });
-    const record = await getCrmRecord(recordId, {
-      displayName: readThrough.remote.displayName,
-      fields: readThrough.remote.fields,
-      remoteRevision: readThrough.remote.remoteRevision,
-      remoteUpdatedAt: readThrough.remote.remoteUpdatedAt,
-      relatedRecords,
-      accessScope: readThrough.currentScope,
-    });
-    if (record) return record;
-    const error = new Error("CRM record not found") as Error & {
-      statusCode?: number;
-    };
-    error.statusCode = 404;
-    throw error;
-  },
-});

package/corpus/templates/crm/actions/install-crm-pipeline-dashboard.ts

@@ -1,81 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { upsertDataProgram } from "@agent-native/core/data-programs";
-import { z } from "zod";
-
-import { crmDashboardStore } from "../server/db/index.js";
-import { CRM_APP_ID } from "../server/lib/provider-api.js";
-import {
-  createPipelineDashboardConfig,
-  crmPipelineDashboardId,
-  CRM_PIPELINE_PROGRAM_CODE,
-  CRM_PIPELINE_PROGRAM_COLUMNS,
-  CRM_PIPELINE_PROGRAM_NAME,
-  CRM_PIPELINE_PROGRAM_TITLE,
-  CRM_PIPELINE_REFRESH_TTL_MS,
-  CRM_PIPELINE_DASHBOARD_TITLE,
-  requireDashboardAccess,
-} from "./_crm-dashboard.js";
-import getCrmPipelineData from "./get-crm-pipeline-data.js";
-
-export default defineAction({
-  description:
-    "Install or update your CRM Pipeline dashboard and its owned data program. Safe to rerun: it verifies the access-scoped source first, upserts the program by owner and name, then revision-writes the dashboard.",
-  schema: z.object({}),
-  run: async (_args, ctx?: ActionRunContext) => {
-    const access = requireDashboardAccess(ctx);
-    const preview = await getCrmPipelineData.run({}, ctx);
-
-    const program = await upsertDataProgram({
-      appId: CRM_APP_ID,
-      name: CRM_PIPELINE_PROGRAM_NAME,
-      title: CRM_PIPELINE_PROGRAM_TITLE,
-      description:
-        "Access-scoped opportunity totals by stage for the CRM Pipeline dashboard.",
-      code: CRM_PIPELINE_PROGRAM_CODE,
-      outputColumns: JSON.stringify(CRM_PIPELINE_PROGRAM_COLUMNS),
-      refreshMode: "ttl",
-      refreshTtlMs: CRM_PIPELINE_REFRESH_TTL_MS,
-      background: false,
-      ownerEmail: access.userEmail,
-      orgId: access.orgId ?? null,
-    });
-    if (
-      program.appId !== CRM_APP_ID ||
-      program.name !== CRM_PIPELINE_PROGRAM_NAME
-    ) {
-      throw new Error(
-        "CRM Pipeline data program could not be verified after saving.",
-      );
-    }
-
-    const dashboardId = crmPipelineDashboardId(access);
-    const existing = await crmDashboardStore.get(dashboardId, access);
-    const dashboard = await crmDashboardStore.write(
-      {
-        id: dashboardId,
-        kind: "pipeline",
-        title: CRM_PIPELINE_DASHBOARD_TITLE,
-        config: createPipelineDashboardConfig(program.id),
-        ...(existing ? { expectedUpdatedAt: existing.updatedAt } : {}),
-      },
-      access,
-    );
-    if (dashboard.config.panels.length !== 3) {
-      throw new Error(
-        "CRM Pipeline dashboard could not be verified after saving.",
-      );
-    }
-
-    return {
-      dashboard,
-      dashboardId: dashboard.id,
-      programId: program.id,
-      created: !existing,
-      programPreview: {
-        rowCount: preview.rows.length,
-        columns: CRM_PIPELINE_PROGRAM_COLUMNS,
-        truncated: preview.truncated,
-      },
-    };
-  },
-});

package/corpus/templates/crm/actions/list-crm-dashboard-revisions.ts

@@ -1,15 +0,0 @@
-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:
-    "List the bounded revision history for one access-scoped CRM dashboard.",
-  schema: z.object({ id: z.string().trim().min(1).max(200) }),
-  http: { method: "GET" },
-  readOnly: true,
-  run: ({ id }, ctx?: ActionRunContext) =>
-    crmDashboardStore.listRevisions(id, requireDashboardAccess(ctx)),
-});

package/corpus/templates/crm/actions/list-crm-dashboards.ts

@@ -1,15 +0,0 @@
-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:
-    "List up to 50 active CRM dashboards the current user can access.",
-  schema: z.object({}),
-  http: { method: "GET" },
-  readOnly: true,
-  run: async (_args, ctx?: ActionRunContext) =>
-    (await crmDashboardStore.list(requireDashboardAccess(ctx))).slice(0, 50),
-});

package/corpus/templates/crm/actions/list-crm-proposals.ts

@@ -1,31 +0,0 @@
-import { defineAction } from "@agent-native/core/action";
-import { z } from "zod";
-
-import { listCrmProposals } from "../server/db/crm-store.js";
-
-export default defineAction({
-  description:
-    "List bounded, access-scoped CRM mutation proposals and their review status. Proposal payloads are intentionally omitted from this list surface.",
-  schema: z.object({
-    recordId: z.string().min(1).optional(),
-    status: z
-      .enum([
-        "pending",
-        "approved",
-        "applied",
-        "rejected",
-        "conflict",
-        "failed",
-      ])
-      .optional(),
-    limit: z.coerce.number().int().min(1).max(100).default(50),
-    cursor: z
-      .string()
-      .regex(/^\d+$/)
-      .optional()
-      .describe("Cursor returned by a previous page."),
-  }),
-  http: { method: "GET" },
-  readOnly: true,
-  run: (input) => listCrmProposals(input),
-});