@agent-native/core 0.118.0 → 0.118.1

package/corpus/templates/crm/actions/run-crm-signal-trackers.ts

@@ -1,275 +0,0 @@
-import { defineAction } from "@agent-native/core/action";
-import { writeAppState } from "@agent-native/core/application-state";
-import { accessFilter } from "@agent-native/core/sharing";
-import { and, eq, inArray } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-import { DEFAULT_CRM_DETECTORS } from "../server/lib/intelligence/default-detectors.js";
-import { runKeywordDetector } from "../server/lib/intelligence/keyword-detector.js";
-import { buildSmartDetectorPrompt } from "../server/lib/intelligence/smart-detector.js";
-import { buildCallEvidenceSummaryPrompt } from "../server/lib/intelligence/summary.js";
-import {
-  crmSignalIdempotencyKey,
-  evidenceExcerpts,
-  loadCrmSignalEvidence,
-} from "./_crm-signal-utils.js";
-
-export default defineAction({
-  description:
-    "Run deterministic keyword detectors and prepare bounded smart/summary requests for delegation through agent chat. Never calls an LLM or stores transcript bodies.",
-  schema: z.object({
-    recordId: z.string().trim().min(1).max(128),
-    evidenceIds: z.array(z.string().trim().min(1).max(128)).max(20).optional(),
-    trackerIds: z.array(z.string().trim().min(1).max(128)).max(20).optional(),
-    includeSummary: z.boolean().default(true),
-    idempotencyKey: z.string().trim().min(1).max(180),
-  }),
-  run: async (args, ctx) => {
-    const evidence = await loadCrmSignalEvidence({
-      recordId: args.recordId,
-      evidenceIds: args.evidenceIds,
-      role: "editor",
-    });
-    if (!evidence.length)
-      throw new Error(
-        "Attach bounded Clips call evidence before running signal detectors.",
-      );
-    const excerpts = evidenceExcerpts(evidence);
-    if (!excerpts.length)
-      throw new Error(
-        "The attached evidence has no bounded excerpt to analyze.",
-      );
-    await ensureDefaultTrackers(ctx);
-    const filters = [
-      eq(schema.crmSignalTrackers.enabled, true),
-      accessFilter(schema.crmSignalTrackers, schema.crmSignalTrackerShares),
-    ];
-    if (args.trackerIds?.length)
-      filters.push(inArray(schema.crmSignalTrackers.id, args.trackerIds));
-    const trackers = await getDb()
-      .select()
-      .from(schema.crmSignalTrackers)
-      .where(and(...filters))
-      .limit(20);
-    const now = new Date().toISOString();
-    const keywordRows: Array<typeof schema.crmSignals.$inferInsert> = [];
-    const delegated: Array<{
-      runId: string;
-      trackerId?: string;
-      kind: "smart" | "summary";
-      prompt: string;
-    }> = [];
-
-    for (const tracker of trackers) {
-      const runKey = await crmSignalIdempotencyKey(
-        ctx,
-        args.recordId,
-        `${args.idempotencyKey}:run:${tracker.id}`,
-      );
-      const [existingRun] = await getDb()
-        .select()
-        .from(schema.crmSignalRuns)
-        .where(
-          and(
-            eq(schema.crmSignalRuns.idempotencyKey, runKey.key),
-            accessFilter(schema.crmSignalRuns, schema.crmSignalRunShares),
-          ),
-        )
-        .limit(1);
-      if (existingRun) continue;
-      const runId = crypto.randomUUID();
-      if (tracker.kind === "keyword") {
-        const candidates = runKeywordDetector(
-          {
-            id: tracker.id,
-            name: tracker.name,
-            kind: "keyword",
-            keywords: safeKeywords(tracker.keywordsJson),
-          },
-          excerpts,
-        );
-        for (const candidate of candidates) {
-          const signalKey = await crmSignalIdempotencyKey(
-            ctx,
-            args.recordId,
-            `${args.idempotencyKey}:signal:${tracker.id}:${candidate.evidenceRef}:${candidate.quote}`,
-          );
-          keywordRows.push({
-            id: crypto.randomUUID(),
-            runId,
-            trackerId: tracker.id,
-            recordId: args.recordId,
-            evidenceId: candidate.evidenceRef,
-            kind: "moment",
-            label: tracker.name,
-            quote: candidate.quote,
-            speaker: candidate.speaker ?? null,
-            startSeconds: candidate.startSeconds,
-            endSeconds: candidate.endSeconds ?? null,
-            summary: "",
-            confidence: candidate.confidence,
-            detector: "keyword",
-            model: null,
-            modelVersion: null,
-            reviewStatus: "unreviewed",
-            idempotencyKey: signalKey.key,
-            ...signalKey.scope,
-            createdAt: now,
-            updatedAt: now,
-          });
-        }
-        await getDb().transaction(async (tx) => {
-          await tx.insert(schema.crmSignalRuns).values({
-            id: runId,
-            trackerId: tracker.id,
-            recordId: args.recordId,
-            kind: "keyword",
-            status: "completed",
-            evidenceCount: evidence.length,
-            idempotencyKey: runKey.key,
-            completedAt: now,
-            ...runKey.scope,
-            createdAt: now,
-            updatedAt: now,
-          });
-          const rows = keywordRows.filter((row) => row.runId === runId);
-          if (rows.length) await tx.insert(schema.crmSignals).values(rows);
-        });
-      } else {
-        const prompt = buildSmartDetectorPrompt(
-          {
-            id: tracker.id,
-            name: tracker.name,
-            description: tracker.description,
-            classifierPrompt: tracker.classifierPrompt,
-          },
-          excerpts,
-        );
-        if (!prompt) continue;
-        await getDb()
-          .insert(schema.crmSignalRuns)
-          .values({
-            id: runId,
-            trackerId: tracker.id,
-            recordId: args.recordId,
-            kind: "smart",
-            status: "queued",
-            evidenceCount: evidence.length,
-            idempotencyKey: runKey.key,
-            ...runKey.scope,
-            createdAt: now,
-            updatedAt: now,
-          });
-        delegated.push({ runId, trackerId: tracker.id, kind: "smart", prompt });
-      }
-    }
-
-    if (args.includeSummary) {
-      const runKey = await crmSignalIdempotencyKey(
-        ctx,
-        args.recordId,
-        `${args.idempotencyKey}:run:summary`,
-      );
-      const [existing] = await getDb()
-        .select({ id: schema.crmSignalRuns.id })
-        .from(schema.crmSignalRuns)
-        .where(
-          and(
-            eq(schema.crmSignalRuns.idempotencyKey, runKey.key),
-            accessFilter(schema.crmSignalRuns, schema.crmSignalRunShares),
-          ),
-        )
-        .limit(1);
-      if (!existing) {
-        const runId = crypto.randomUUID();
-        const prompt = buildCallEvidenceSummaryPrompt(
-          `CRM record ${args.recordId}`,
-          excerpts,
-        );
-        if (prompt) {
-          await getDb()
-            .insert(schema.crmSignalRuns)
-            .values({
-              id: runId,
-              trackerId: null,
-              recordId: args.recordId,
-              kind: "summary",
-              status: "queued",
-              evidenceCount: evidence.length,
-              idempotencyKey: runKey.key,
-              ...runKey.scope,
-              createdAt: now,
-              updatedAt: now,
-            });
-          delegated.push({ runId, kind: "summary", prompt });
-        }
-      }
-    }
-
-    for (const request of delegated) {
-      await writeAppState(`crm-signal-agent-request-${request.runId}`, {
-        runId: request.runId,
-        recordId: args.recordId,
-        trackerId: request.trackerId,
-        kind: request.kind,
-        evidenceIds: evidence.map((item) => item.id),
-      });
-    }
-    return {
-      keywordSignalsCreated: keywordRows.length,
-      delegatedRequests: delegated,
-    };
-  },
-});
-
-function safeKeywords(value: string): string[] {
-  try {
-    const parsed = JSON.parse(value) as unknown;
-    return Array.isArray(parsed)
-      ? parsed
-          .filter((item): item is string => typeof item === "string")
-          .slice(0, 40)
-      : [];
-  } catch {
-    return [];
-  }
-}
-
-async function ensureDefaultTrackers(
-  ctx: Parameters<typeof crmSignalIdempotencyKey>[0],
-) {
-  const db = getDb();
-  const [existing] = await db
-    .select({ id: schema.crmSignalTrackers.id })
-    .from(schema.crmSignalTrackers)
-    .where(
-      accessFilter(schema.crmSignalTrackers, schema.crmSignalTrackerShares),
-    )
-    .limit(1);
-  if (existing) return;
-  const now = new Date().toISOString();
-  for (const detector of DEFAULT_CRM_DETECTORS) {
-    const identity = await crmSignalIdempotencyKey(
-      ctx,
-      "defaults",
-      detector.id,
-    );
-    await db
-      .insert(schema.crmSignalTrackers)
-      .values({
-        id: `default-${identity.key.slice(-32)}`,
-        name: detector.name,
-        description: detector.description,
-        kind: detector.kind,
-        keywordsJson: JSON.stringify(detector.keywords ?? []),
-        classifierPrompt: detector.classifierPrompt ?? "",
-        enabled: true,
-        isDefault: true,
-        ...identity.scope,
-        createdAt: now,
-        updatedAt: now,
-      })
-      .onConflictDoNothing();
-  }
-}

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

@@ -1,7 +0,0 @@
-import { runScript } from "@agent-native/core/scripts";
-
-import { initCrmDataPrograms } from "./_crm-data-program-actions.js";
-
-initCrmDataPrograms();
-
-runScript();

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

@@ -1,51 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { z } from "zod";
-
-import {
-  crmDashboardStore,
-  type CrmDashboardConfig,
-} from "../server/db/index.js";
-import { requireDashboardAccess } from "./_crm-dashboard.js";
-
-const configSchema = z.object({
-  version: z.literal(1),
-  panels: z
-    .array(
-      z.object({
-        id: z.string().trim().min(1).max(120),
-        title: z.string().trim().min(1).max(160),
-        source: z.literal("program"),
-        query: z.string().trim().min(1).max(2_000),
-        chartType: z.enum(["metric", "bar", "table"]),
-      }),
-    )
-    .min(1)
-    .max(12)
-    .refine(
-      (panels) =>
-        new Set(panels.map((panel) => panel.id)).size === panels.length,
-      "Dashboard panel IDs must be unique.",
-    ),
-});
-
-export default defineAction({
-  description:
-    "Create or update an access-scoped CRM pipeline dashboard. Pass expectedUpdatedAt to reject an overwrite when the dashboard changed since it was read.",
-  schema: z.object({
-    id: z.string().trim().min(1).max(200),
-    title: z.string().trim().min(1).max(160),
-    config: configSchema,
-    expectedUpdatedAt: z.string().datetime().optional(),
-  }),
-  run: ({ id, title, config, expectedUpdatedAt }, ctx?: ActionRunContext) =>
-    crmDashboardStore.write(
-      {
-        id,
-        kind: "pipeline",
-        title,
-        config: config as CrmDashboardConfig,
-        expectedUpdatedAt,
-      },
-      requireDashboardAccess(ctx),
-    ),
-});

package/corpus/templates/crm/actions/save-crm-saved-view.ts

@@ -1,119 +0,0 @@
-import { defineAction } from "@agent-native/core/action";
-import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-import { requireCrmScope, toJson } from "./_crm-action-utils.js";
-
-const filterSchema = z.record(z.string().max(120), z.unknown());
-
-export default defineAction({
-  description:
-    "Create or update a bounded, access-scoped CRM saved view. A saved view stores filters and presentation settings, never provider rows.",
-  schema: z.object({
-    id: z.string().min(1).max(128).optional(),
-    name: z.string().trim().min(1).max(120),
-    description: z.string().trim().max(500).optional(),
-    kind: z.enum(["account", "person", "opportunity"]).optional(),
-    filters: filterSchema.optional(),
-    columns: z.array(z.string().trim().min(1).max(120)).max(40).optional(),
-    sort: z
-      .array(
-        z.object({
-          field: z.string().trim().min(1).max(120),
-          direction: z.enum(["asc", "desc"]),
-        }),
-      )
-      .max(4)
-      .optional(),
-    dataProgramId: z.string().trim().min(1).max(128).optional(),
-    pinned: z.boolean().optional(),
-  }),
-  audit: {
-    target: (_args, result) => {
-      const view = result as {
-        id: string;
-        ownerEmail: string;
-        orgId: string | null;
-        visibility: "private" | "org";
-      };
-      return {
-        type: "crm-saved-view",
-        id: view.id,
-        ownerEmail: view.ownerEmail,
-        orgId: view.orgId,
-        visibility: view.visibility,
-      };
-    },
-    summary: (args) => `Saved CRM view ${args.name}`,
-  },
-  run: async (args, ctx) => {
-    const db = getDb();
-    const now = new Date().toISOString();
-    if (args.id) {
-      await assertAccess("crm-saved-view", args.id, "editor");
-      await db
-        .update(schema.crmSavedViews)
-        .set({
-          name: args.name,
-          ...(args.description !== undefined
-            ? { description: args.description }
-            : {}),
-          ...(args.kind !== undefined ? { kind: args.kind } : {}),
-          ...(args.filters !== undefined
-            ? { filtersJson: toJson(args.filters, 8_000) }
-            : {}),
-          ...(args.columns !== undefined
-            ? { columnsJson: toJson(args.columns, 4_000) }
-            : {}),
-          ...(args.sort !== undefined
-            ? { sortJson: toJson(args.sort, 2_000) }
-            : {}),
-          ...(args.dataProgramId !== undefined
-            ? { dataProgramId: args.dataProgramId }
-            : {}),
-          ...(args.pinned !== undefined ? { pinned: args.pinned } : {}),
-          updatedAt: now,
-        })
-        .where(eq(schema.crmSavedViews.id, args.id));
-      const [view] = await db
-        .select()
-        .from(schema.crmSavedViews)
-        .where(eq(schema.crmSavedViews.id, args.id))
-        .limit(1);
-      if (!view) throw new Error("CRM saved view was not found.");
-      return view;
-    }
-
-    const scope = requireCrmScope(ctx);
-    const id = crypto.randomUUID();
-    await db.insert(schema.crmSavedViews).values({
-      id,
-      name: args.name,
-      description: args.description ?? "",
-      kind: args.kind ?? null,
-      filtersJson: toJson(args.filters ?? {}, 8_000),
-      columnsJson: toJson(args.columns ?? [], 4_000),
-      sortJson: toJson(args.sort ?? [], 2_000),
-      dataProgramId: args.dataProgramId ?? null,
-      pinned: args.pinned ?? false,
-      ...scope,
-      createdAt: now,
-      updatedAt: now,
-    });
-    const [view] = await db
-      .select()
-      .from(schema.crmSavedViews)
-      .where(
-        and(
-          eq(schema.crmSavedViews.id, id),
-          eq(schema.crmSavedViews.ownerEmail, scope.ownerEmail),
-        ),
-      )
-      .limit(1);
-    if (!view)
-      throw new Error("CRM saved view could not be verified after saving.");
-    return view;
-  },
-});

package/corpus/templates/crm/actions/sync-crm.ts

@@ -1,146 +0,0 @@
-import { defineAction, type ActionRunContext } from "@agent-native/core/action";
-import { accessFilter, assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
-import { z } from "zod";
-
-import {
-  createConnectedCrmAdapter,
-  isConnectedCrmProvider,
-} from "../server/crm/adapter.js";
-import {
-  MAX_SYNC_PAGE_SIZE,
-  MAX_SYNC_PAGES,
-  syncCrmMirror,
-} from "../server/crm/crm-mirror.js";
-import { getDb, schema } from "../server/db/index.js";
-import { requireCrmScope } from "./_crm-action-utils.js";
-
-const idList = z
-  .array(z.string().trim().min(1).max(160))
-  .min(1)
-  .max(50)
-  .optional();
-const syncScopeSchema = z
-  .object({
-    pipelineIds: idList,
-    ownerIds: idList,
-    recordIds: idList,
-    associatedRecordIds: idList,
-    updatedAfter: z.string().datetime({ offset: true }).optional(),
-    includeDeleted: z.boolean().default(false),
-  })
-  .superRefine((scope, issue) => {
-    if (
-      !scope.pipelineIds &&
-      !scope.ownerIds &&
-      !scope.recordIds &&
-      !scope.associatedRecordIds &&
-      !scope.updatedAfter
-    ) {
-      issue.addIssue({
-        code: "custom",
-        message:
-          "A sync requires a bounded cohort selector: pipelineIds, ownerIds, recordIds, associatedRecordIds, or updatedAfter.",
-      });
-    }
-  });
-
-export default defineAction({
-  description:
-    "Thinly mirror one bounded HubSpot or Salesforce CRM object cohort. It discovers field policy first, mirrors only explicit safe fields, and returns a continuation cursor instead of claiming an exhaustive sync.",
-  schema: z.object({
-    connectionId: z.string().trim().min(1).max(128),
-    objectType: z.string().trim().min(1).max(120),
-    scope: syncScopeSchema,
-    fieldAllowList: z
-      .array(z.string().trim().min(1).max(120))
-      .min(1)
-      .max(80)
-      .optional(),
-    allowCustomObject: z.boolean().default(false),
-    cursor: z.string().trim().min(1).max(2_000).optional(),
-    pageSize: z.coerce
-      .number()
-      .int()
-      .min(1)
-      .max(MAX_SYNC_PAGE_SIZE)
-      .default(MAX_SYNC_PAGE_SIZE),
-    maxPages: z.coerce
-      .number()
-      .int()
-      .min(1)
-      .max(MAX_SYNC_PAGES)
-      .default(MAX_SYNC_PAGES),
-  }),
-  audit: {
-    target: (args, result) => {
-      const response = result as {
-        ownerEmail: string;
-        orgId: string | null;
-        visibility: "private" | "org";
-      };
-      return {
-        type: "crm-connection",
-        id: args.connectionId,
-        ownerEmail: response.ownerEmail,
-        orgId: response.orgId,
-        visibility: response.visibility,
-      };
-    },
-    summary: (args) => `Synced bounded CRM ${args.objectType} cohort`,
-    recordInputs: false,
-  },
-  run: async (args, ctx?: ActionRunContext) => {
-    await assertAccess("crm-connection", args.connectionId, "editor");
-    const db = getDb();
-    const [connection] = await db
-      .select()
-      .from(schema.crmConnections)
-      .where(
-        and(
-          eq(schema.crmConnections.id, args.connectionId),
-          accessFilter(
-            schema.crmConnections,
-            schema.crmConnectionShares,
-            undefined,
-            "editor",
-          ),
-        ),
-      )
-      .limit(1);
-    if (!connection || connection.status === "disconnected")
-      throw new Error("CRM connection is unavailable.");
-    if (
-      !isConnectedCrmProvider(connection.provider) ||
-      !connection.workspaceConnectionId
-    )
-      throw new Error(
-        "CRM sync requires a connected HubSpot or Salesforce workspace connection.",
-      );
-    const ownership = requireCrmScope(ctx);
-    const adapter = await createConnectedCrmAdapter({
-      provider: connection.provider,
-      connectionId: connection.workspaceConnectionId,
-      userEmail: ownership.ownerEmail,
-      orgId: ownership.orgId,
-    });
-    const result = await syncCrmMirror({
-      connectionId: connection.id,
-      objectType: args.objectType,
-      scope: { objectType: args.objectType, ...args.scope },
-      fieldAllowList: args.fieldAllowList,
-      allowCustomObject: args.allowCustomObject,
-      cursor: args.cursor,
-      pageSize: args.pageSize,
-      maxPages: args.maxPages,
-      ownership,
-      adapter,
-    });
-    return {
-      ...result,
-      ownerEmail: ownership.ownerEmail,
-      orgId: ownership.orgId,
-      visibility: ownership.visibility,
-    };
-  },
-});