@agent-native/core 0.118.0 → 0.119.0

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

@@ -1,92 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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/restore-crm-dashboard-revision.ts

@@ -1,23 +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:
-    "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;
-  },
-});

package/corpus/templates/crm/actions/review-crm-signal.ts

@@ -1,31 +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";
-
-export default defineAction({
-  description:
-    "Confirm, dismiss, or return one access-scoped CRM signal to the unreviewed queue.",
-  schema: z.object({
-    signalId: z.string().trim().min(1).max(128),
-    reviewStatus: z.enum(["unreviewed", "confirmed", "dismissed"]),
-  }),
-  run: async (args) => {
-    await assertAccess("crm-signal", args.signalId, "editor");
-    const now = new Date().toISOString();
-    await getDb()
-      .update(schema.crmSignals)
-      .set({ reviewStatus: args.reviewStatus, updatedAt: now })
-      .where(eq(schema.crmSignals.id, args.signalId));
-    const [saved] = await getDb()
-      .select()
-      .from(schema.crmSignals)
-      .where(eq(schema.crmSignals.id, args.signalId))
-      .limit(1);
-    if (!saved)
-      throw new Error("CRM signal could not be verified after review.");
-    return saved;
-  },
-});

package/corpus/templates/crm/actions/run-crm-saved-view-program.ts

@@ -1,103 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { runDataProgram } from "@agent-native/core/data-programs";
-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 { CRM_APP_ID } from "../server/lib/provider-api.js";
-import { isSafeCrmMutationFields } from "./_crm-action-utils.js";
-
-export default defineAction({
-  description:
-    "Run the data program linked to one access-scoped CRM saved view and return a bounded, sanitized preview.",
-  schema: z.object({
-    viewId: z.string().trim().min(1).max(128),
-  }),
-  agentTool: false,
-  toolCallable: false,
-  run: async ({ viewId }, ctx?: ActionRunContext) => {
-    if (!ctx?.userEmail) {
-      throw new Error("CRM data programs require an authenticated user.");
-    }
-    const [view] = await getDb()
-      .select({ dataProgramId: schema.crmSavedViews.dataProgramId })
-      .from(schema.crmSavedViews)
-      .where(
-        and(
-          eq(schema.crmSavedViews.id, viewId),
-          accessFilter(schema.crmSavedViews, schema.crmSavedViewShares),
-        ),
-      )
-      .limit(1);
-    if (!view?.dataProgramId) {
-      throw new Error("This CRM saved view has no data program.");
-    }
-    const result = await runDataProgram({
-      programId: view.dataProgramId,
-      appId: CRM_APP_ID,
-      params: {},
-      ctx: { userEmail: ctx.userEmail, orgId: ctx.orgId ?? null },
-      triggeredBy: "agent",
-    });
-    if (!result.ok) {
-      return {
-        ok: false as const,
-        code: result.error.code,
-        message: "The saved view data program could not run.",
-        ...(result.lastGoodRun
-          ? {
-              lastGoodRun: {
-                rowCount: result.lastGoodRun.rows.length,
-                columns: safeColumns(result.lastGoodRun.schema),
-                sampleRows: safeSampleRows(result.lastGoodRun.rows),
-                truncated: result.lastGoodRun.truncated,
-                asOfMs: result.lastGoodRun.asOfMs,
-              },
-            }
-          : {}),
-      };
-    }
-    return {
-      ok: true as const,
-      rowCount: result.rows.length,
-      columns: safeColumns(result.schema),
-      sampleRows: safeSampleRows(result.rows),
-      asOfMs: result.asOfMs,
-      cacheHit: result.cacheHit,
-      stale: result.stale,
-      truncated: result.truncated,
-    };
-  },
-});
-
-function safeColumns(columns: Array<{ name: string; type: string }>) {
-  return columns
-    .filter(
-      (column) =>
-        column.name.length <= 120 &&
-        isSafeCrmMutationFields({ [column.name]: "preview" }),
-    )
-    .slice(0, 12);
-}
-
-function safeSampleRows(rows: Array<Record<string, unknown>>) {
-  return rows.slice(0, 5).map((row) =>
-    Object.fromEntries(
-      Object.entries(row)
-        .filter(
-          ([fieldName, value]) =>
-            isSafeCrmMutationFields({ [fieldName]: value }) &&
-            (value === null ||
-              typeof value === "string" ||
-              typeof value === "number" ||
-              typeof value === "boolean"),
-        )
-        .slice(0, 12)
-        .map(([fieldName, value]) => [
-          fieldName,
-          typeof value === "string" ? value.slice(0, 500) : value,
-        ]),
-    ),
-  );
-}