@nebulaos/core 0.1.1

package/dist/workflow/execution/WorkflowRunner.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRunner = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:timers/promises");
+const adapters_js_1 = require("../adapters.js");
+const index_js_1 = require("../../execution-context/index.js");
+class WorkflowRunner {
+    config;
+    events;
+    telemetry;
+    state;
+    nodeExecutor;
+    constructor(config, events, telemetry, state, nodeExecutor) {
+        this.config = config;
+        this.events = events;
+        this.telemetry = telemetry;
+        this.state = state;
+        this.nodeExecutor = nodeExecutor;
+    }
+    async run(params) {
+        const executionId = params.options?.executionId ?? (0, node_crypto_1.randomUUID)();
+        const startTime = Date.now();
+        const timeoutMs = this.config.timeoutMs;
+        const maxSteps = this.config.maxSteps;
+        const stateMap = {};
+        let currentInput = params.input;
+        const exec = async () => {
+            return index_js_1.ExecutionContext.run({
+                executionId,
+                rootExecutionId: executionId,
+            }, async () => this.telemetry.inWorkflowSpan({
+                workflowId: params.workflowId,
+                executionId,
+                workflowName: params.workflowNameForTelemetry,
+                workflowInput: params.input,
+            }, async () => {
+                this.events.emit("workflow:run:start", {
+                    executionId,
+                    data: { workflowId: params.workflowId, definitionVersion: params.definition.version, input: params.input },
+                });
+                await this.state.save(executionId, {
+                    workflowId: params.workflowId,
+                    executionId,
+                    definitionVersion: params.definition.version,
+                    status: "running",
+                    currentNodeId: undefined,
+                    nodeStates: {},
+                    input: params.input,
+                    startedAt: new Date(),
+                    updatedAt: new Date(),
+                });
+                try {
+                    let executed = 0;
+                    for (const node of params.nodes) {
+                        executed++;
+                        if (maxSteps && executed > maxSteps) {
+                            const output = currentInput;
+                            this.events.emit("workflow:run:end", {
+                                executionId,
+                                data: {
+                                    workflowId: params.workflowId,
+                                    definitionVersion: params.definition.version,
+                                    status: "truncated",
+                                    output,
+                                    durationMs: Date.now() - startTime,
+                                },
+                            });
+                            return output;
+                        }
+                        currentInput = await this.executeNodeWithRetry({
+                            workflowId: params.workflowId,
+                            definitionVersion: params.definition.version,
+                            executionId,
+                            node,
+                            currentInput,
+                            state: stateMap,
+                        });
+                        stateMap[node.id] = currentInput;
+                        await this.state.save(executionId, {
+                            workflowId: params.workflowId,
+                            executionId,
+                            definitionVersion: params.definition.version,
+                            status: "running",
+                            currentNodeId: node.id,
+                            nodeStates: Object.fromEntries(Object.entries(stateMap).map(([nodeId, value]) => [nodeId, { status: "success", output: value }])),
+                            input: params.input,
+                            startedAt: new Date(startTime),
+                            updatedAt: new Date(),
+                        });
+                    }
+                    const output = currentInput;
+                    this.events.emit("workflow:run:end", {
+                        executionId,
+                        data: {
+                            workflowId: params.workflowId,
+                            definitionVersion: params.definition.version,
+                            status: "success",
+                            output,
+                            durationMs: Date.now() - startTime,
+                        },
+                    });
+                    await this.state.save(executionId, {
+                        workflowId: params.workflowId,
+                        executionId,
+                        definitionVersion: params.definition.version,
+                        status: "completed",
+                        currentNodeId: params.nodes[params.nodes.length - 1]?.id,
+                        nodeStates: {},
+                        input: params.input,
+                        output,
+                        startedAt: new Date(startTime),
+                        updatedAt: new Date(),
+                        completedAt: new Date(),
+                    });
+                    return output;
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    this.events.emit("workflow:run:error", {
+                        executionId,
+                        data: {
+                            workflowId: params.workflowId,
+                            definitionVersion: params.definition.version,
+                            error: { message: err.message, stack: err.stack, name: err.name },
+                            durationMs: Date.now() - startTime,
+                        },
+                    });
+                    throw error;
+                }
+            }));
+        };
+        if (!timeoutMs)
+            return exec();
+        return Promise.race([
+            exec(),
+            (0, promises_1.setTimeout)(timeoutMs).then(() => {
+                throw new Error(`Workflow timed out after ${timeoutMs}ms`);
+            }),
+        ]);
+    }
+    async executeNodeWithRetry(params) {
+        const policy = this.config.retryPolicy;
+        const maxAttempts = policy?.maxAttempts ?? 1;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const nodeStartTime = Date.now();
+            this.events.emit("workflow:node:start", {
+                executionId: params.executionId,
+                data: {
+                    workflowId: params.workflowId,
+                    nodeId: params.node.id,
+                    nodeType: params.node.type,
+                    attempt,
+                    input: params.currentInput,
+                },
+            });
+            try {
+                const result = await this.telemetry.inNodeSpan({
+                    executionId: params.executionId,
+                    nodeId: params.node.id,
+                    data: {
+                        workflowId: params.workflowId,
+                        executionId: params.executionId,
+                        nodeId: params.node.id,
+                        nodeType: params.node.type,
+                        definitionVersion: params.definitionVersion,
+                        attempt,
+                        input: params.currentInput, // Use full input, not truncated
+                    },
+                }, async () => this.nodeExecutor.executeOnce({ node: params.node, currentInput: params.currentInput, state: params.state, executionId: params.executionId }));
+                this.events.emit("workflow:node:end", {
+                    executionId: params.executionId,
+                    data: {
+                        workflowId: params.workflowId,
+                        nodeId: params.node.id,
+                        nodeType: params.node.type,
+                        attempt,
+                        status: "success",
+                        output: result,
+                        durationMs: Date.now() - nodeStartTime,
+                    },
+                });
+                return result;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                this.events.emit("workflow:node:end", {
+                    executionId: params.executionId,
+                    data: {
+                        workflowId: params.workflowId,
+                        nodeId: params.node.id,
+                        nodeType: params.node.type,
+                        attempt,
+                        status: "error",
+                        output: undefined,
+                        durationMs: Date.now() - nodeStartTime,
+                        error: { message: lastError.message, stack: lastError.stack, name: lastError.name },
+                    },
+                });
+                if (!policy)
+                    throw lastError;
+                if (!(0, adapters_js_1.isRetryableError)(lastError, policy) || attempt >= maxAttempts)
+                    throw lastError;
+                const delay = (0, adapters_js_1.calculateRetryDelay)(policy, attempt);
+                await (0, promises_1.setTimeout)(delay);
+            }
+        }
+        throw lastError;
+    }
+}
+exports.WorkflowRunner = WorkflowRunner;

package/dist/workflow/execution/WorkflowRunner.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workflow/execution/WorkflowRunner.spec.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const Workflow_1 = require("../Workflow");
+const WorkflowEventBus_1 = require("./WorkflowEventBus");
+const WorkflowRunner_1 = require("./WorkflowRunner");
+const WorkflowTelemetry_1 = require("./WorkflowTelemetry");
+const WorkflowStateService_1 = require("../state/WorkflowStateService");
+const NodeExecutor_1 = require("./NodeExecutor");
+describe("WorkflowRunner", () => {
+    it("should emit run/node events in expected order", async () => {
+        const wf = new Workflow_1.Workflow({ id: "wf" })
+            .step("a", async ({ input }) => `${input}-a`)
+            .step("b", async ({ input }) => `${input}-b`);
+        const emitter = new node_events_1.EventEmitter();
+        const bus = new WorkflowEventBus_1.WorkflowEventBus(emitter);
+        const types = [];
+        emitter.on("workflow:run:start", (e) => types.push(e.type));
+        emitter.on("workflow:node:start", (e) => types.push(e.type));
+        emitter.on("workflow:node:end", (e) => types.push(e.type));
+        emitter.on("workflow:run:end", (e) => types.push(e.type));
+        const runner = new WorkflowRunner_1.WorkflowRunner({ id: "wf" }, bus, new WorkflowTelemetry_1.WorkflowTelemetry(), new WorkflowStateService_1.WorkflowStateService(undefined), new NodeExecutor_1.NodeExecutor());
+        const out = await runner.run({
+            workflowId: "wf",
+            workflowNameForTelemetry: "workflow:wf",
+            definition: wf.describe(),
+            nodes: wf.__internalNodes(),
+            input: "x",
+            options: { executionId: "exec-1" },
+        });
+        expect(out).toBe("x-a-b");
+        expect(types[0]).toBe("workflow:run:start");
+        expect(types[types.length - 1]).toBe("workflow:run:end");
+    });
+    it("should truncate when maxSteps is exceeded", async () => {
+        const wf = new Workflow_1.Workflow({ id: "wf", maxSteps: 1 })
+            .step("a", async ({ input }) => `${input}-a`)
+            .step("b", async ({ input }) => `${input}-b`);
+        const events = [];
+        wf.on("workflow:run:end", (e) => events.push(e));
+        const out = await wf.run("x", { executionId: "exec-2" });
+        expect(out).toBe("x-a"); // only first node executed
+        expect(events[0]?.data?.status).toBe("truncated");
+    });
+    it("should retry a failing node and succeed", async () => {
+        let attempts = 0;
+        const wf = new Workflow_1.Workflow({
+            id: "wf",
+            retryPolicy: { maxAttempts: 3, backoff: "fixed", initialDelay: 1 },
+        }).step("flaky", async () => {
+            attempts++;
+            if (attempts < 3)
+                throw new Error("fail");
+            return "ok";
+        });
+        const nodeEnds = [];
+        wf.on("workflow:node:end", (e) => nodeEnds.push(e));
+        const out = await wf.run("x", { executionId: "exec-3" });
+        expect(out).toBe("ok");
+        expect(attempts).toBe(3);
+        expect(nodeEnds.filter((e) => e.data.status === "error").length).toBe(2);
+        expect(nodeEnds.filter((e) => e.data.status === "success").length).toBe(1);
+    });
+    it("should error on unknown branch key", async () => {
+        const wf = new Workflow_1.Workflow({ id: "wf" }).branch("route", async () => "missing", {
+            ok: (w) => w.step("ok", async () => "ok"),
+        });
+        await expect(wf.run("x", { executionId: "exec-4" })).rejects.toThrow("Unknown branch key");
+    });
+    it("should throw on timeout", async () => {
+        const wf = new Workflow_1.Workflow({ id: "wf", timeoutMs: 30 }).step("slow", async () => {
+            await new Promise((r) => setTimeout(r, 200));
+            return "done";
+        });
+        await expect(wf.run("x", { executionId: "exec-5" })).rejects.toThrow("timed out");
+    });
+    it("should propagate error when a parallel subflow fails", async () => {
+        const wf = new Workflow_1.Workflow({ id: "wf" })
+            .step("before", async ({ input }) => input)
+            .parallel("fanout", [
+            (p) => p.step("ok", async () => "ok"),
+            (p) => p.step("boom", async () => { throw new Error("boom"); }),
+        ])
+            .step("after", async ({ input }) => input);
+        const runErrors = [];
+        wf.on("workflow:run:error", (e) => runErrors.push(e));
+        await expect(wf.run("x", { executionId: "exec-parallel-fail" })).rejects.toThrow("boom");
+        expect(runErrors.length).toBeGreaterThanOrEqual(1);
+        expect(runErrors[0].executionId).toBe("exec-parallel-fail");
+        expect(runErrors[0].data.error.message).toContain("boom");
+    });
+});

package/dist/workflow/execution/WorkflowTelemetry.d.ts

@@ -0,0 +1,13 @@
+export declare class WorkflowTelemetry {
+    inWorkflowSpan<T>(input: {
+        workflowId: string;
+        executionId: string;
+        workflowName: string;
+        workflowInput: unknown;
+    }, fn: () => Promise<T>): Promise<T>;
+    inNodeSpan<T>(input: {
+        executionId: string;
+        nodeId: string;
+        data: Record<string, unknown>;
+    }, fn: () => Promise<T>): Promise<T>;
+}

package/dist/workflow/execution/WorkflowTelemetry.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTelemetry = void 0;
+const index_js_1 = require("../../tracing/index.js");
+class WorkflowTelemetry {
+    async inWorkflowSpan(input, fn) {
+        return index_js_1.Tracing.withSpan({
+            kind: "workflow",
+            name: input.workflowName,
+            executionId: input.executionId,
+            data: { workflowId: input.workflowId, input: input.workflowInput },
+        }, async (span) => {
+            const result = await fn();
+            if (!span.isEnded)
+                await span.end({ status: "success" });
+            return result;
+        });
+    }
+    async inNodeSpan(input, fn) {
+        return index_js_1.Tracing.withSpan({
+            kind: "workflow.node",
+            name: `workflow:node:${input.nodeId}`,
+            executionId: input.executionId,
+            data: {
+                workflowId: input.data.workflowId,
+                nodeId: input.nodeId,
+                nodeType: input.data.nodeType,
+                input: input.data.input,
+            },
+        }, async (span) => {
+            try {
+                const result = await fn();
+                await span.end({ status: "success", data: { output: result } });
+                return result;
+            }
+            catch (e) {
+                await span.end({ status: "error" });
+                throw e;
+            }
+        });
+    }
+}
+exports.WorkflowTelemetry = WorkflowTelemetry;

package/dist/workflow/execution/WorkflowTelemetry.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workflow/execution/WorkflowTelemetry.spec.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tracing_1 = require("../../tracing");
+const WorkflowTelemetry_1 = require("./WorkflowTelemetry");
+class CapturingExporter {
+    events = [];
+    async exportBatch(events) {
+        this.events.push(...events);
+    }
+}
+describe("WorkflowTelemetry", () => {
+    it("should emit workflow and node spans via Tracing exporter", async () => {
+        const exporter = new CapturingExporter();
+        tracing_1.Tracing.setExporter(exporter);
+        const telemetry = new WorkflowTelemetry_1.WorkflowTelemetry();
+        const out = await telemetry.inWorkflowSpan({ workflowId: "wf", executionId: "exec-1", workflowName: "workflow:wf", workflowInput: { x: 1 } }, async () => {
+            return telemetry.inNodeSpan({ executionId: "exec-1", nodeId: "n1", data: { workflowId: "wf", nodeId: "n1", nodeType: "step" } }, async () => "ok");
+        });
+        expect(out).toBe("ok");
+        const types = exporter.events.map((e) => e.type);
+        expect(types).toEqual(expect.arrayContaining(["telemetry:span:start", "telemetry:span:end"]));
+        // Should have at least 2 spans (workflow root + node)
+        const starts = exporter.events.filter((e) => e.type === "telemetry:span:start");
+        expect(starts.length).toBeGreaterThanOrEqual(2);
+        const workflowStart = starts.find((e) => e.span?.kind === "workflow");
+        expect(workflowStart).toBeDefined();
+        const nodeStart = starts.find((e) => (e.span?.kind === "workflow.node" || e.span?.kind === "custom") &&
+            e.span?.name?.includes("workflow:node:n1"));
+        expect(nodeStart).toBeDefined();
+    });
+});

package/dist/workflow/graph/NodeNameRegistry.d.ts

@@ -0,0 +1,20 @@
+export interface NodeIdAllocator {
+    allocate(name: string): {
+        id: string;
+        displayName: string;
+    };
+}
+/**
+ * Shared registry that ensures node IDs are stable and deduped across the entire workflow tree.
+ *
+ * Rule:
+ * - First occurrence: "name"
+ * - Subsequent occurrences: "name-2", "name-3", ...
+ */
+export declare class SharedNodeNameRegistry implements NodeIdAllocator {
+    private readonly counters;
+    allocate(name: string): {
+        id: string;
+        displayName: string;
+    };
+}

package/dist/workflow/graph/NodeNameRegistry.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedNodeNameRegistry = void 0;
+/**
+ * Shared registry that ensures node IDs are stable and deduped across the entire workflow tree.
+ *
+ * Rule:
+ * - First occurrence: "name"
+ * - Subsequent occurrences: "name-2", "name-3", ...
+ */
+class SharedNodeNameRegistry {
+    counters = new Map();
+    allocate(name) {
+        const current = this.counters.get(name) ?? 0;
+        const next = current + 1;
+        this.counters.set(name, next);
+        const id = next === 1 ? name : `${name}-${next}`;
+        return { id, displayName: name };
+    }
+}
+exports.SharedNodeNameRegistry = SharedNodeNameRegistry;

package/dist/workflow/graph/NodeNameRegistry.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workflow/graph/NodeNameRegistry.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NodeNameRegistry_1 = require("./NodeNameRegistry");
+describe("SharedNodeNameRegistry", () => {
+    it("should allocate stable ids and dedupe with -2 suffix", () => {
+        const reg = new NodeNameRegistry_1.SharedNodeNameRegistry();
+        expect(reg.allocate("triage")).toEqual({ id: "triage", displayName: "triage" });
+        expect(reg.allocate("triage")).toEqual({ id: "triage-2", displayName: "triage" });
+        expect(reg.allocate("triage")).toEqual({ id: "triage-3", displayName: "triage" });
+    });
+    it("should keep independent counters per name", () => {
+        const reg = new NodeNameRegistry_1.SharedNodeNameRegistry();
+        expect(reg.allocate("a").id).toBe("a");
+        expect(reg.allocate("b").id).toBe("b");
+        expect(reg.allocate("a").id).toBe("a-2");
+        expect(reg.allocate("b").id).toBe("b-2");
+    });
+});

package/dist/workflow/graph/WorkflowGraph.d.ts

@@ -0,0 +1,14 @@
+import type { SharedNodeNameRegistry } from "./NodeNameRegistry.js";
+import type { InternalNode } from "./nodes.js";
+export declare class WorkflowGraph {
+    private readonly registry;
+    private readonly nodes;
+    constructor(registry: SharedNodeNameRegistry);
+    allocateId(name: string): {
+        id: string;
+        displayName: string;
+    };
+    add(node: InternalNode): void;
+    list(): readonly InternalNode[];
+    getRegistry(): SharedNodeNameRegistry;
+}

package/dist/workflow/graph/WorkflowGraph.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowGraph = void 0;
+class WorkflowGraph {
+    registry;
+    nodes = [];
+    constructor(registry) {
+        this.registry = registry;
+    }
+    allocateId(name) {
+        return this.registry.allocate(name);
+    }
+    add(node) {
+        this.nodes.push(node);
+    }
+    list() {
+        return this.nodes;
+    }
+    getRegistry() {
+        return this.registry;
+    }
+}
+exports.WorkflowGraph = WorkflowGraph;

package/dist/workflow/graph/nodes.d.ts

@@ -0,0 +1,26 @@
+import type { Agent } from "../../agent/Agent.js";
+import type { Workflow } from "../Workflow.js";
+import type { WorkflowAgentNodeOptions, WorkflowNodeHandler } from "../types.js";
+export type InternalNode = {
+    id: string;
+    displayName: string;
+    type: "start" | "step" | "finish";
+    handler: WorkflowNodeHandler<any, any>;
+} | {
+    id: string;
+    displayName: string;
+    type: "agent";
+    agent: Agent;
+    toInput?: WorkflowAgentNodeOptions["toInput"];
+} | {
+    id: string;
+    displayName: string;
+    type: "branch";
+    selector: WorkflowNodeHandler<any, string>;
+    branches: Record<string, Workflow<any, any>>;
+} | {
+    id: string;
+    displayName: string;
+    type: "parallel";
+    workflows: Workflow<any, any>[];
+};

package/dist/workflow/graph/nodes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/workflow/queue/WorkflowQueueService.d.ts

@@ -0,0 +1,22 @@
+import type { IWorkflowQueue } from "../adapters.js";
+import type { InternalNode } from "../graph/nodes.js";
+import type { WorkflowDefinition } from "../definition/types.js";
+import { WorkflowStateService } from "../state/WorkflowStateService.js";
+export declare class WorkflowQueueService {
+    private readonly queue;
+    private readonly state;
+    constructor(queue: IWorkflowQueue | undefined, state: WorkflowStateService);
+    enqueue(input: {
+        workflowId: string;
+        definition: WorkflowDefinition;
+        nodes: readonly InternalNode[];
+        rawInput: unknown;
+    }): Promise<{
+        executionId: string;
+    }>;
+    getStatus(executionId: string): Promise<{
+        status: any;
+        currentStep?: string;
+        progress?: number;
+    }>;
+}

package/dist/workflow/queue/WorkflowQueueService.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowQueueService = void 0;
+const node_crypto_1 = require("node:crypto");
+class WorkflowQueueService {
+    queue;
+    state;
+    constructor(queue, state) {
+        this.queue = queue;
+        this.state = state;
+    }
+    async enqueue(input) {
+        if (!this.queue)
+            throw new Error("Queue adapter not configured");
+        const executionId = (0, node_crypto_1.randomUUID)();
+        await this.state.save(executionId, {
+            workflowId: input.workflowId,
+            executionId,
+            definitionVersion: input.definition.version,
+            status: "pending",
+            currentNodeId: undefined,
+            nodeStates: {},
+            input: input.rawInput,
+            startedAt: new Date(),
+            updatedAt: new Date(),
+        });
+        const first = input.nodes[0];
+        if (first) {
+            await this.queue.enqueue({
+                executionId,
+                workflowId: input.workflowId,
+                nodeId: first.id,
+                nodeName: first.displayName,
+                input: input.rawInput,
+                attempt: 1,
+                createdAt: new Date(),
+            });
+        }
+        return { executionId };
+    }
+    async getStatus(executionId) {
+        if (!this.queue?.getStatus)
+            throw new Error("Queue adapter does not implement getStatus()");
+        return this.queue.getStatus(executionId);
+    }
+}
+exports.WorkflowQueueService = WorkflowQueueService;

package/dist/workflow/state/WorkflowStateService.d.ts

@@ -0,0 +1,7 @@
+import type { WorkflowState, IWorkflowStateStore } from "../adapters.js";
+export declare class WorkflowStateService {
+    private readonly store;
+    constructor(store: IWorkflowStateStore | undefined);
+    save(executionId: string, state: WorkflowState): Promise<void>;
+    load(executionId: string): Promise<WorkflowState | null>;
+}

package/dist/workflow/state/WorkflowStateService.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowStateService = void 0;
+class WorkflowStateService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async save(executionId, state) {
+        if (!this.store)
+            return;
+        await this.store.save(executionId, state);
+    }
+    async load(executionId) {
+        if (!this.store)
+            return null;
+        return this.store.load(executionId);
+    }
+}
+exports.WorkflowStateService = WorkflowStateService;

package/dist/workflow/types.d.ts

@@ -0,0 +1,16 @@
+export type WorkflowNodeContext<TInput = any> = {
+    input: TInput;
+    state: Record<string, any>;
+};
+export type WorkflowNodeHandler<TInput, TOutput> = (ctx: WorkflowNodeContext<TInput>) => Promise<TOutput>;
+export type WorkflowRunStatus = "success" | "error" | "truncated";
+export type WorkflowRunOptions = {
+    executionId?: string;
+};
+export type WorkflowAgentNodeOptions = {
+    /**
+     * Maps the current workflow input into a user message for the agent.
+     * If not provided, strings are passed as-is and non-strings are JSON.stringified.
+     */
+    toInput?: (input: unknown, state: Record<string, any>) => string;
+};

package/dist/workflow/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });