@agentic-surfaces/core 0.1.1 → 0.1.3

package/dist/handlers/foreach.d.ts

@@ -0,0 +1,2 @@
+import type { NodeHandler } from "../types.js";
+export declare const foreachHandler: NodeHandler;

package/dist/handlers/foreach.js

@@ -0,0 +1,29 @@
+import jsonata from "jsonata";
+import { buildJsonataScope } from "./transform.js";
+export const foreachHandler = {
+    type: "task.foreach",
+    async execute(node, ctx) {
+        if (!ctx.services.runWorkflow) {
+            throw new Error("sub-workflow invocation not configured");
+        }
+        const itemsExpr = String(node.config.items ?? "");
+        const workflowName = String(node.config.workflow ?? "");
+        const items = await jsonata(itemsExpr).evaluate(buildJsonataScope(ctx));
+        if (!Array.isArray(items)) {
+            throw new Error("task.foreach: items expression did not evaluate to an array");
+        }
+        const results = [];
+        for (const item of items) {
+            try {
+                const subOutputs = await ctx.services.runWorkflow(workflowName, item);
+                results.push({ ok: true, item, outputs: Object.fromEntries(subOutputs) });
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                ctx.services.logger?.error?.("foreach item failed", { error: errorMessage });
+                results.push({ ok: false, item, error: errorMessage });
+            }
+        }
+        return { output: results };
+    },
+};

package/dist/handlers/http.js

@@ -15,7 +15,24 @@ export const httpHandler = {
     async execute(node, ctx) {
         const cfg = node.config;
         const method = (cfg.method ?? "GET").toUpperCase();
-        const url = new URL(resolveSecrets(cfg.url));
+        // urlExpression is jsonata over the run scope (per-item URLs from earlier
+        // outputs / the trigger payload); env vars in its result are resolved after.
+        // Plain `url` is env-substituted only. Exactly one must be provided.
+        let rawUrl;
+        if (cfg.urlExpression) {
+            const evaluated = await jsonata(cfg.urlExpression).evaluate(buildJsonataScope(ctx));
+            if (typeof evaluated !== "string") {
+                throw new Error("urlExpression must evaluate to a string");
+            }
+            rawUrl = resolveSecrets(evaluated);
+        }
+        else if (cfg.url) {
+            rawUrl = resolveSecrets(cfg.url);
+        }
+        else {
+            throw new Error("task.http requires either url or urlExpression");
+        }
+        const url = new URL(rawUrl);
         for (const [k, v] of Object.entries(resolveObj(cfg.query)))
             url.searchParams.set(k, v);
         if (ctx.services.dryRun && method !== "GET" && method !== "HEAD") {

package/dist/handlers/run-workflow.d.ts

@@ -0,0 +1,2 @@
+import type { NodeHandler } from "../types.js";
+export declare const runWorkflowHandler: NodeHandler;

package/dist/handlers/run-workflow.js

@@ -0,0 +1,18 @@
+import jsonata from "jsonata";
+import { buildJsonataScope } from "./transform.js";
+export const runWorkflowHandler = {
+    type: "task.run-workflow",
+    async execute(node, ctx) {
+        if (!ctx.services.runWorkflow) {
+            throw new Error("sub-workflow invocation not configured");
+        }
+        const workflowName = String(node.config.workflow ?? "");
+        const payloadExpression = node.config.payloadExpression;
+        let payload = null;
+        if (payloadExpression && typeof payloadExpression === "string" && payloadExpression.length > 0) {
+            payload = await jsonata(payloadExpression).evaluate(buildJsonataScope(ctx));
+        }
+        const outputs = await ctx.services.runWorkflow(workflowName, payload);
+        return { output: Object.fromEntries(outputs) };
+    },
+};

package/dist/index.d.ts

@@ -7,3 +7,5 @@ export * from "./cache.js";
 export * from "./observer.js";
 export * from "./secrets.js";
 export * from "./project-config.js";
+export * from "./handlers/foreach.js";
+export * from "./handlers/run-workflow.js";

package/dist/index.js

@@ -7,3 +7,5 @@ export * from "./cache.js";
 export * from "./observer.js";
 export * from "./secrets.js";
 export * from "./project-config.js";
+export * from "./handlers/foreach.js";
+export * from "./handlers/run-workflow.js";

package/dist/scheduler.d.ts

@@ -8,6 +8,13 @@ export declare function runWorkflowOnce(workflow: Workflow, opts: {
     payload?: unknown;
     observer?: RunObserver;
 }): Promise<Map<string, unknown>>;
+export declare function buildWorkflowRunner(opts: {
+    workflows: Map<string, Workflow>;
+    registry: HandlerRegistry;
+    services: Services;
+    observer?: RunObserver;
+    maxDepth?: number;
+}): (name: string, payload: unknown) => Promise<Map<string, unknown>>;
 export declare class Scheduler {
     private services;
     private registry;

package/dist/scheduler.js

@@ -1,10 +1,12 @@
 import { Cron } from "croner";
 import { HandlerRegistry } from "./registry.js";
-import { runWorkflow } from "./executor.js";
+import { runWorkflow as runWorkflowExec } from "./executor.js";
 import { transformHandler } from "./handlers/transform.js";
 import { branchHandler } from "./handlers/branch.js";
 import { httpHandler } from "./handlers/http.js";
 import { agentHandler } from "./handlers/agent.js";
+import { foreachHandler } from "./handlers/foreach.js";
+import { runWorkflowHandler } from "./handlers/run-workflow.js";
 import { ConsoleObserver } from "./observer.js";
 const passthrough = (type) => ({
     type,
@@ -20,6 +22,9 @@ export function defaultRegistry() {
     r.register(agentHandler);
     r.register(passthrough("trigger.cron"));
     r.register(passthrough("trigger.webhook"));
+    r.register(passthrough("trigger.command"));
+    r.register(foreachHandler);
+    r.register(runWorkflowHandler);
     return r;
 }
 export async function runWorkflowOnce(workflow, opts) {
@@ -28,7 +33,23 @@ export async function runWorkflowOnce(workflow, opts) {
         ?? workflow.nodes.find(n => n.type.startsWith("trigger."))?.id;
     if (!triggerNodeId)
         throw new Error(`workflow ${workflow.name} has no trigger node`);
-    return runWorkflow({ workflow, triggerNodeId, registry, services: opts.services, payload: opts.payload, observer: opts.observer });
+    return runWorkflowExec({ workflow, triggerNodeId, registry, services: opts.services, payload: opts.payload, observer: opts.observer });
+}
+export function buildWorkflowRunner(opts) {
+    const { workflows, registry, observer, maxDepth = 10 } = opts;
+    let depth = 0;
+    function runWorkflow(name, payload) {
+        const wf = workflows.get(name);
+        if (!wf)
+            throw new Error(`sub-workflow not found: "${name}"`);
+        if (depth >= maxDepth)
+            throw new Error(`max workflow depth exceeded (possible cycle): depth=${depth}`);
+        depth++;
+        const subServices = { ...opts.services, runWorkflow };
+        return runWorkflowOnce(wf, { registry, services: subServices, observer, payload })
+            .finally(() => { depth--; });
+    }
+    return runWorkflow;
 }
 export class Scheduler {
     services;

package/dist/schema.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { parse as parseYaml } from "yaml";
 const nodeType = z.enum([
-    "trigger.cron", "trigger.webhook",
+    "trigger.cron", "trigger.webhook", "trigger.command",
     "task.http", "task.transform", "task.branch",
+    "task.run-workflow", "task.foreach",
     "agent.run",
 ]);
 const retry = z.object({ maxAttempts: z.number().int().min(1), backoffMs: z.number().int().min(0) });
@@ -38,6 +39,23 @@ const workflow = z.object({
                 ctx.addIssue({ code: "custom", message: `node "${n.id}" (trigger.cron) requires a non-empty config.cron string` });
             }
         }
+        if (n.type === "task.run-workflow") {
+            const workflow = n.config.workflow;
+            if (typeof workflow !== "string" || workflow.trim() === "") {
+                ctx.addIssue({ code: "custom", message: `node "${n.id}" (task.run-workflow) requires a non-empty config.workflow string` });
+            }
+        }
+        if (n.type === "task.foreach") {
+            const cfg = n.config;
+            const items = cfg.items;
+            const wfName = cfg.workflow;
+            if (typeof items !== "string" || items.trim() === "") {
+                ctx.addIssue({ code: "custom", message: `node "${n.id}" (task.foreach) requires a non-empty config.items string` });
+            }
+            if (typeof wfName !== "string" || wfName.trim() === "") {
+                ctx.addIssue({ code: "custom", message: `node "${n.id}" (task.foreach) requires a non-empty config.workflow string` });
+            }
+        }
     }
 });
 export function loadWorkflow(yamlText) {

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import type { AgentRunner, McpServerRef } from "@agentic-surfaces/agent";
 export type { AgentRunner, McpServerRef };
-export type NodeType = "trigger.cron" | "trigger.webhook" | "task.http" | "task.transform" | "task.branch" | "agent.run";
+export type NodeType = "trigger.cron" | "trigger.webhook" | "trigger.command" | "task.http" | "task.transform" | "task.branch" | "task.run-workflow" | "task.foreach" | "agent.run";
 export interface RetryPolicy {
     maxAttempts: number;
     backoffMs: number;
@@ -44,6 +44,7 @@ export interface Services {
         runner?: string;
         mcpServers?: McpServerRef[];
     };
+    runWorkflow?: (name: string, payload: unknown) => Promise<Map<string, unknown>>;
 }
 export interface RunContext {
     workflow: Workflow;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentic-surfaces/core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "license": "MIT",
   "publishConfig": {
@@ -23,7 +23,7 @@
     "jsonata": "^2.2.1",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@agentic-surfaces/agent": "0.1.1"
+    "@agentic-surfaces/agent": "0.1.3"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",