@agent-native/core 0.130.2 → 0.131.3

package/corpus/core/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/corpus/core/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) {