@agent-native/core 0.130.2 → 0.131.3

package/src/tracking/types.ts

@@ -3,6 +3,7 @@ export interface TrackingEvent {
   properties?: Record<string, unknown>;
   timestamp?: string;
   userId?: string;
+  anonymousId?: string;
 }
 
 export interface TrackingProvider {

package/src/triggers/actions/list-automations.ts

@@ -1,19 +1,16 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
+import {
+  listAutomationDefinitions,
+  type AutomationScope,
+} from "../../automations/service.js";
 import { describeCron, isValidCron, nextOccurrence } from "../../jobs/cron.js";
-import { resourceGetByPath, resourceList } from "../../resources/store.js";
-import { parseTriggerFrontmatter } from "../dispatcher.js";
 
 const scopeSchema = z.enum(["personal", "organization"]);
 
-function hasTriggerFrontmatter(content: string): boolean {
-  const header = content.match(/^---\n([\s\S]*?)\n---/m)?.[1] ?? "";
-  return /^triggerType\s*:/m.test(header);
-}
-
 function nextRun(
-  meta: ReturnType<typeof parseTriggerFrontmatter>["meta"],
+  meta: Awaited<ReturnType<typeof listAutomationDefinitions>>[number]["meta"],
 ): string | null {
   if (!meta.enabled) return null;
   if (meta.nextRun) return meta.nextRun;
@@ -44,12 +41,19 @@ export interface AutomationActionItem {
   lastError: string | null;
   nextRun: string | null;
   createdBy: string | null;
+  model: string | null;
+  mcpTools: string[];
+  originScopeId: string | null;
+  deliveryPlatform: string | null;
+  deliveryDestination: string | null;
+  deliveryThreadRef: string | null;
+  deliveryTenantId: string | null;
   canUpdate: boolean;
 }
 
 export default defineAction({
   description:
-    "List event-triggered and schedule-triggered automations in the selected scope. Automations are currently personal-only.",
+    "List event-triggered and schedule-triggered automations in the selected personal or organization scope.",
   agentTool: false,
   schema: z.object({
     scope: scopeSchema.default("personal"),
@@ -60,40 +64,35 @@ export default defineAction({
   run: async ({ scope }, ctx): Promise<AutomationActionItem[]> => {
     const userEmail = ctx?.userEmail;
     if (!userEmail) throw new Error("Not authenticated.");
-    if (scope === "organization") return [];
-
-    const owner = userEmail;
-    const resources = await resourceList(owner, "jobs/");
-    const automations: AutomationActionItem[] = [];
-
-    for (const resource of resources) {
-      if (!resource.path.endsWith(".md") || resource.path.endsWith(".keep")) {
-        continue;
-      }
-      const full = await resourceGetByPath(owner, resource.path);
-      if (!full || !hasTriggerFrontmatter(full.content)) continue;
-      const { meta, body } = parseTriggerFrontmatter(full.content);
-      automations.push({
-        id: full.id,
-        name: resource.path.replace(/^jobs\//, "").replace(/\.md$/, ""),
-        path: resource.path,
-        scope,
-        triggerType: meta.triggerType,
-        event: meta.event ?? null,
-        schedule: meta.schedule || null,
-        scheduleDescription: meta.schedule ? describeCron(meta.schedule) : null,
-        condition: meta.condition ?? null,
-        body,
-        enabled: meta.enabled,
-        lastRun: meta.lastRun ?? null,
-        lastStatus: meta.lastStatus ?? null,
-        lastError: meta.lastError ?? null,
-        nextRun: nextRun(meta),
-        createdBy: meta.createdBy ?? null,
-        canUpdate: true,
-      });
-    }
-
-    return automations;
+    const definitions = await listAutomationDefinitions(
+      { userEmail, orgId: ctx?.orgId },
+      scope as AutomationScope,
+    );
+    return definitions.map(({ resource, name, meta, body, canUpdate }) => ({
+      id: resource.id,
+      name,
+      path: resource.path,
+      scope: scope as AutomationScope,
+      triggerType: meta.triggerType,
+      event: meta.event ?? null,
+      schedule: meta.schedule || null,
+      scheduleDescription: meta.schedule ? describeCron(meta.schedule) : null,
+      condition: meta.condition ?? null,
+      body,
+      enabled: meta.enabled,
+      lastRun: meta.lastRun ?? null,
+      lastStatus: meta.lastStatus ?? null,
+      lastError: meta.lastError ?? null,
+      nextRun: nextRun(meta),
+      createdBy: meta.createdBy ?? null,
+      model: meta.model ?? null,
+      mcpTools: meta.mcpTools ?? [],
+      originScopeId: meta.originScopeId ?? null,
+      deliveryPlatform: meta.deliveryPlatform ?? null,
+      deliveryDestination: meta.deliveryDestination ?? null,
+      deliveryThreadRef: meta.deliveryThreadRef ?? null,
+      deliveryTenantId: meta.deliveryTenantId ?? null,
+      canUpdate,
+    }));
   },
 });

package/src/triggers/actions/manage-automation.ts

@@ -1,21 +1,15 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
-import { isValidCron, nextOccurrence } from "../../jobs/cron.js";
 import {
-  resourceDelete,
-  resourceGetByPath,
-  resourcePut,
-} from "../../resources/store.js";
-import {
-  buildTriggerContent,
-  parseTriggerFrontmatter,
-  refreshEventSubscriptions,
-} from "../dispatcher.js";
+  deleteAutomation,
+  updateAutomation,
+} from "../../automations/service.js";
+import { refreshEventSubscriptions } from "../dispatcher.js";
 
 export default defineAction({
   description:
-    "Enable, disable, or delete a personal automation from the Agent Jobs page.",
+    "Enable, disable, or delete a personal or organization automation from the Agent Automations page.",
   agentTool: false,
   schema: z.object({
     operation: z.enum(["update", "delete"]),
@@ -26,29 +20,10 @@ export default defineAction({
   run: async ({ operation, name, scope, enabled }, ctx) => {
     const userEmail = ctx?.userEmail;
     if (!userEmail) throw new Error("Not authenticated.");
-    if (scope === "organization") {
-      throw Object.assign(new Error("Automations are personal today."), {
-        statusCode: 400,
-      });
-    }
-
-    const path = `jobs/${name}.md`;
-    const resource = await resourceGetByPath(userEmail, path);
-    if (!resource) {
-      throw Object.assign(new Error(`Automation "${name}" not found.`), {
-        statusCode: 404,
-      });
-    }
-    const { meta, body } = parseTriggerFrontmatter(resource.content);
-    const header = resource.content.match(/^---\n([\s\S]*?)\n---/m)?.[1] ?? "";
-    if (!/^triggerType\s*:/m.test(header)) {
-      throw Object.assign(new Error(`Automation "${name}" not found.`), {
-        statusCode: 404,
-      });
-    }
+    const actor = { userEmail, orgId: ctx?.orgId };
 
     if (operation === "delete") {
-      await resourceDelete(resource.id);
+      await deleteAutomation(actor, scope, name);
       await refreshEventSubscriptions();
       return { deleted: true, name };
     }
@@ -57,22 +32,16 @@ export default defineAction({
         statusCode: 400,
       });
     }
-
-    meta.enabled = enabled;
-    if (
-      enabled &&
-      meta.triggerType === "schedule" &&
-      meta.schedule &&
-      isValidCron(meta.schedule)
-    ) {
-      meta.nextRun = nextOccurrence(meta.schedule).toISOString();
-    }
-    await resourcePut(
-      resource.owner,
-      resource.path,
-      buildTriggerContent(meta, body),
-    );
+    const definition = await updateAutomation(actor, {
+      name,
+      scope,
+      enabled,
+    });
     await refreshEventSubscriptions();
-    return { name, enabled: meta.enabled, nextRun: meta.nextRun ?? null };
+    return {
+      name,
+      enabled: definition.meta.enabled,
+      nextRun: definition.meta.nextRun ?? null,
+    };
   },
 });

package/src/triggers/actions.ts

@@ -10,20 +10,20 @@
  */
 
 import type { ActionEntry } from "../agent/production-agent.js";
-import { listEvents } from "../event-bus/index.js";
 import {
-  resourceListAllOwners,
-  resourcePut,
-  resourceDelete,
-  resourceGetByPath,
-  SHARED_OWNER,
-} from "../resources/store.js";
+  defineAutomation,
+  deleteAutomation,
+  listAutomationDefinitions,
+  updateAutomation,
+  type AutomationScope,
+} from "../automations/service.js";
+import { listEvents } from "../event-bus/index.js";
+import { describeCron } from "../jobs/cron.js";
 import {
-  parseTriggerFrontmatter,
-  buildTriggerContent,
-  refreshEventSubscriptions,
-} from "./dispatcher.js";
-import type { TriggerFrontmatter } from "./types.js";
+  getIntegrationRequestContext,
+  getRequestOrgId,
+} from "../server/request-context.js";
+import { refreshEventSubscriptions } from "./dispatcher.js";
 
 /* ------------------------------------------------------------------ */
 /*  Individual action handlers                                        */
@@ -54,59 +54,62 @@ async function handleListEvents(): Promise<string> {
 }
 
 async function handleList(
-  args: Record<string, string>,
+  args: Record<string, unknown>,
   getCurrentUser: () => string,
 ): Promise<string> {
-  const owner = getCurrentUser();
-  const resources = await resourceListAllOwners("jobs/");
-  const triggers = resources
-    .filter((r) => r.owner === owner || r.owner === SHARED_OWNER)
-    .filter((r) => r.path.endsWith(".md"))
-    .map((r) => {
-      const { meta, body } = parseTriggerFrontmatter(r.content);
-      const name = r.path.replace(/^jobs\//, "").replace(/\.md$/, "");
-      return { name, meta, body, owner: r.owner, id: r.id };
-    })
-    .filter((t) => {
-      if (args.domain && t.meta.domain !== args.domain) return false;
-      if (args.enabled_only === "true" && !t.meta.enabled) return false;
-      return true;
-    });
+  const scope = automationScope(args.scope);
+  const definitions = await listAutomationDefinitions(
+    { userEmail: getCurrentUser(), orgId: getRequestOrgId() },
+    scope,
+  );
+  const automations = definitions
+    .filter(({ meta }) => !args.domain || meta.domain === args.domain)
+    .filter(({ meta }) => args.enabled_only !== "true" || meta.enabled)
+    .map(({ name, meta, body, canUpdate }) => ({
+      name,
+      scope,
+      triggerType: meta.triggerType,
+      event: meta.event ?? null,
+      schedule: meta.schedule || null,
+      scheduleDescription: meta.schedule ? describeCron(meta.schedule) : null,
+      condition: meta.condition ?? null,
+      mode: meta.mode,
+      domain: meta.domain ?? null,
+      enabled: meta.enabled,
+      lastRun: meta.lastRun ?? null,
+      lastStatus: meta.lastStatus ?? null,
+      lastError: meta.lastError ?? null,
+      nextRun: meta.nextRun ?? null,
+      createdBy: meta.createdBy ?? null,
+      runAs: meta.runAs ?? null,
+      model: meta.model ?? null,
+      mcpTools: meta.mcpTools ?? [],
+      originScopeId: meta.originScopeId ?? null,
+      deliveryPlatform: meta.deliveryPlatform ?? null,
+      deliveryDestination: meta.deliveryDestination ?? null,
+      deliveryThreadRef: meta.deliveryThreadRef ?? null,
+      deliveryTenantId: meta.deliveryTenantId ?? null,
+      body,
+      canUpdate,
+    }));
+  return JSON.stringify(automations, null, 2);
+}
 
-  if (triggers.length === 0) return "No automations found.";
+function automationScope(value: unknown): AutomationScope {
+  if (value === undefined || value === null || value === "") return "personal";
+  if (value === "personal" || value === "organization") return value;
+  throw new Error('scope must be "personal" or "organization".');
+}
 
-  const lines = triggers.map((t) => {
-    const type =
-      t.meta.triggerType === "event"
-        ? `on ${t.meta.event || "?"}`
-        : `cron: ${t.meta.schedule}`;
-    const status = t.meta.enabled ? "enabled" : "disabled";
-    const lastStatus = t.meta.lastStatus ? ` (last: ${t.meta.lastStatus})` : "";
-    const condition = t.meta.condition
-      ? `\n  Condition: "${t.meta.condition}"`
-      : "";
-    const domain = t.meta.domain ? ` [${t.meta.domain}]` : "";
-    return `- **${t.name}**${domain}: ${type} → ${t.meta.mode} (${status}${lastStatus})${condition}\n  Body: ${t.body.slice(0, 100)}${t.body.length > 100 ? "..." : ""}`;
-  });
-  return lines.join("\n\n");
+function automationTriggerType(value: unknown): "schedule" | "event" {
+  if (value === "schedule" || value === "event") return value;
+  throw new Error('trigger_type must be "schedule" or "event".');
 }
 
 async function handleDefine(
-  args: Record<string, string>,
+  args: Record<string, unknown>,
   getCurrentUser: () => string,
 ): Promise<string> {
-  const owner = getCurrentUser();
-  const name = (args.name || "").replace(/[^a-z0-9-]/g, "-");
-  if (!name) return "Error: name is required (lowercase, hyphens).";
-
-  const path = `jobs/${name}.md`;
-
-  // Check if it already exists
-  const existing = await resourceGetByPath(owner, path);
-  if (existing) {
-    return `Error: An automation named "${name}" already exists. Use a different name or delete the existing one first.`;
-  }
-
   if (args.mode === "deterministic") {
     return (
       "Error: Deterministic mode was removed — it was never implemented and " +
@@ -114,94 +117,157 @@ async function handleDefine(
       "mode (agentic), and describe the exact fixed steps in the automation body."
     );
   }
+  const integration = getIntegrationRequestContext();
+  try {
+    const definition = await defineAutomation(
+      { userEmail: getCurrentUser(), orgId: getRequestOrgId() },
+      {
+        name: typeof args.name === "string" ? args.name : "",
+        scope: automationScope(args.scope),
+        triggerType: automationTriggerType(args.trigger_type),
+        body: typeof args.body === "string" ? args.body : "",
+        schedule: typeof args.schedule === "string" ? args.schedule : undefined,
+        event: typeof args.event === "string" ? args.event : undefined,
+        condition:
+          typeof args.condition === "string" ? args.condition : undefined,
+        domain: typeof args.domain === "string" ? args.domain : undefined,
+        delegatedPolicyId:
+          typeof args.delegated_policy_id === "string"
+            ? args.delegated_policy_id
+            : undefined,
+        model: typeof args.model === "string" ? args.model : undefined,
+        mcpTools: args.mcpTools,
+        delivery: integration
+          ? {
+              originScopeId: integration.scopeId,
+              platform: integration.incoming.platform,
+              destination:
+                typeof integration.incoming.platformContext.channelId ===
+                "string"
+                  ? integration.incoming.platformContext.channelId
+                  : undefined,
+              threadRef:
+                typeof integration.incoming.threadRef === "string"
+                  ? integration.incoming.threadRef
+                  : undefined,
+              tenantId: integration.incoming.tenantId,
+            }
+          : undefined,
+      },
+    );
 
-  const triggerType = args.trigger_type === "schedule" ? "schedule" : "event";
-  const meta: TriggerFrontmatter = {
-    schedule: args.schedule || "",
-    enabled: true,
-    triggerType,
-    event: args.event || undefined,
-    condition: args.condition || undefined,
-    mode: "agentic",
-    domain: args.domain || undefined,
-    delegatedPolicyId: args.delegated_policy_id || undefined,
-    createdBy: owner,
-    runAs: "creator",
-  };
-
-  const content = buildTriggerContent(meta, args.body || "");
-  await resourcePut(owner, path, content);
-
-  // Refresh event subscriptions so the new trigger is active immediately
-  await refreshEventSubscriptions();
-
-  const summary =
-    triggerType === "event"
-      ? `on ${meta.event || "?"}${meta.condition ? ` when "${meta.condition}"` : ""}`
-      : `on schedule "${meta.schedule}"`;
-
-  return `Automation "${name}" created. Fires ${summary} in ${meta.mode} mode.`;
+    await refreshEventSubscriptions();
+    return JSON.stringify({
+      created: true,
+      name: definition.name,
+      scope: definition.scope,
+      triggerType: definition.meta.triggerType,
+      event: definition.meta.event ?? null,
+      schedule: definition.meta.schedule || null,
+      nextRun: definition.meta.nextRun ?? null,
+      createdBy: definition.meta.createdBy,
+      runAs: definition.meta.runAs,
+      model: definition.meta.model ?? null,
+      mcpTools: definition.meta.mcpTools ?? [],
+      originScopeId: definition.meta.originScopeId ?? null,
+      deliveryPlatform: definition.meta.deliveryPlatform ?? null,
+      deliveryDestination: definition.meta.deliveryDestination ?? null,
+      deliveryThreadRef: definition.meta.deliveryThreadRef ?? null,
+      deliveryTenantId: definition.meta.deliveryTenantId ?? null,
+    });
+  } catch (error) {
+    return `Error: ${(error as Error).message}`;
+  }
 }
 
 async function handleUpdate(
-  args: Record<string, string>,
+  args: Record<string, unknown>,
   getCurrentUser: () => string,
 ): Promise<string> {
-  const owner = getCurrentUser();
-  const name = args.name;
-  const path = `jobs/${name}.md`;
-
-  const resource = await resourceGetByPath(owner, path);
-  if (!resource) {
-    return `Automation "${name}" not found (or you don't own it).`;
-  }
-
-  const { meta, body } = parseTriggerFrontmatter(resource.content);
-
-  if (args.enabled !== undefined) {
-    meta.enabled = args.enabled !== "false";
-  }
-  if (args.condition !== undefined) {
-    meta.condition = args.condition || undefined;
-  }
-  if (args.delegated_policy_id !== undefined) {
-    meta.delegatedPolicyId = args.delegated_policy_id || undefined;
+  try {
+    const definition = await updateAutomation(
+      { userEmail: getCurrentUser(), orgId: getRequestOrgId() },
+      {
+        name: typeof args.name === "string" ? args.name : "",
+        scope: automationScope(args.scope),
+        enabled:
+          args.enabled === undefined
+            ? undefined
+            : args.enabled === true || args.enabled === "true",
+        condition:
+          args.condition === undefined
+            ? undefined
+            : typeof args.condition === "string"
+              ? args.condition
+              : null,
+        delegatedPolicyId:
+          args.delegated_policy_id === undefined
+            ? undefined
+            : typeof args.delegated_policy_id === "string"
+              ? args.delegated_policy_id
+              : null,
+        body: typeof args.body === "string" ? args.body : undefined,
+        schedule: typeof args.schedule === "string" ? args.schedule : undefined,
+        model:
+          args.model === undefined
+            ? undefined
+            : typeof args.model === "string"
+              ? args.model
+              : null,
+        mcpTools: args.mcpTools,
+      },
+    );
+    await refreshEventSubscriptions();
+    return JSON.stringify({
+      updated: true,
+      name: definition.name,
+      scope: definition.scope,
+      triggerType: definition.meta.triggerType,
+      enabled: definition.meta.enabled,
+      schedule: definition.meta.schedule || null,
+      nextRun: definition.meta.nextRun ?? null,
+      createdBy: definition.meta.createdBy,
+      runAs: definition.meta.runAs,
+      model: definition.meta.model ?? null,
+      mcpTools: definition.meta.mcpTools ?? [],
+      originScopeId: definition.meta.originScopeId ?? null,
+      deliveryPlatform: definition.meta.deliveryPlatform ?? null,
+      deliveryDestination: definition.meta.deliveryDestination ?? null,
+      deliveryThreadRef: definition.meta.deliveryThreadRef ?? null,
+      deliveryTenantId: definition.meta.deliveryTenantId ?? null,
+    });
+  } catch (error) {
+    return `Error: ${(error as Error).message}`;
   }
-  const newBody = args.body ?? body;
-
-  await resourcePut(
-    resource.owner,
-    resource.path,
-    buildTriggerContent(meta, newBody),
-  );
-  await refreshEventSubscriptions();
-
-  return `Automation "${name}" updated.`;
 }
 
 async function handleDelete(
-  args: Record<string, string>,
+  args: Record<string, unknown>,
   getCurrentUser: () => string,
 ): Promise<string> {
-  const owner = getCurrentUser();
-  const path = `jobs/${args.name}.md`;
-
-  const resource = await resourceGetByPath(owner, path);
-  if (!resource) return `Automation "${args.name}" not found.`;
-
-  await resourceDelete(resource.id);
-  return `Automation "${args.name}" deleted.`;
+  const name = typeof args.name === "string" ? args.name : "";
+  try {
+    await deleteAutomation(
+      { userEmail: getCurrentUser(), orgId: getRequestOrgId() },
+      automationScope(args.scope),
+      name,
+    );
+    await refreshEventSubscriptions();
+    return JSON.stringify({ deleted: true, name });
+  } catch (error) {
+    return `Error: ${(error as Error).message}`;
+  }
 }
 
 async function handleFireTest(
-  args: Record<string, string>,
+  args: Record<string, unknown>,
   getCurrentUser: () => string,
 ): Promise<string> {
   // Dynamic import to avoid circular dependency at module load time
   const { emit } = await import("../event-bus/index.js");
 
   let data: Record<string, unknown> = {};
-  if (args.data) {
+  if (typeof args.data === "string" && args.data) {
     try {
       data = JSON.parse(args.data);
     } catch {
@@ -238,9 +304,9 @@ export function createAutomationToolEntries(
         description: `Manage automations (event-triggered and scheduled tasks). Use the "action" parameter to choose an operation:
 
 - **list-events**: List all registered event types that automations can subscribe to. Returns event names, descriptions, and payload schemas. Call this BEFORE defining an automation to discover available events.
-- **list**: List all automations (triggers). Shows name, event, condition, mode, status, and domain. Optional params: domain, enabled_only.
-- **define**: Create a new automation. IMPORTANT: Always confirm with the user before calling — show them a summary of what will be created. Required params: name, trigger_type, body. Optional: event, schedule, condition, mode, domain, delegated_policy_id.
-- **update**: Update an existing automation's settings (enabled, condition, body, delegated_policy_id, etc.). Required param: name.
+- **list**: List all automations (triggers). Shows trigger, status, model, MCP allowlist, and delivery metadata. Optional params: scope, domain, enabled_only.
+- **define**: Create a new automation. IMPORTANT: Always confirm with the user before calling — show them a summary of what will be created. Required params: name, trigger_type, body. Optional: scope, event, schedule, condition, mode, domain, delegated_policy_id, model, mcpTools.
+- **update**: Update an existing automation's settings without changing its creator (enabled, schedule, condition, body, policy, model, MCP allowlist). Required param: name. Use the same scope it was created in.
 - **delete**: Delete an automation. Always confirm with the user first. Required param: name.
 - **fire-test**: Fire a test event to validate automations. Emits a test.event.fired event. Optional param: data (JSON string).`,
         parameters: {
@@ -257,6 +323,12 @@ export function createAutomationToolEntries(
               description:
                 "Slug name for the automation (lowercase, hyphens). Used by define, update, and delete.",
             },
+            scope: {
+              type: "string",
+              description:
+                "Personal or organization scope. Organization automations are visible to the active organization but always execute as their creator.",
+              enum: ["personal", "organization"],
+            },
             trigger_type: {
               type: "string",
               description: '"event" or "schedule". Required for define.',
@@ -288,6 +360,17 @@ export function createAutomationToolEntries(
               description:
                 "Domain tag for grouping (mail, calendar, clips, etc.). Used by define and list.",
             },
+            model: {
+              type: "string",
+              description:
+                "Optional model id for this automation. The default model is used when omitted.",
+            },
+            mcpTools: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                'Optional explicit MCP capabilities. Use exact advertised tool names, for example ["mcp__meeting-notes__list_meetings"]. Credentials stay in the connector.',
+            },
             delegated_policy_id: {
               type: "string",
               description:
@@ -317,7 +400,15 @@ export function createAutomationToolEntries(
           required: ["action"],
         },
       },
-      run: async (args: Record<string, string>) => {
+      planMode: {
+        effect: (args) =>
+          args.action === "list" || args.action === "list-events"
+            ? "read"
+            : "write",
+        allowedValues: { action: ["list-events", "list"] },
+        description: "Plan mode allows listing automations and event types.",
+      },
+      run: async (args: Record<string, unknown>) => {
         const action = args.action;
 
         switch (action) {