@nebulaos/core 0.1.1

package/dist/workflow/definition/DefinitionBuilder.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionBuilder = void 0;
+class DefinitionBuilder {
+    build(root) {
+        const nodes = [];
+        const edges = [];
+        const walk = (wf, parentAfterNodeId) => {
+            const wfNodes = wf.__internalNodes();
+            const linearIds = wfNodes.map((n) => n.id);
+            for (const n of wfNodes) {
+                nodes.push({
+                    id: n.id,
+                    displayName: n.displayName,
+                    type: n.type,
+                    agentName: n.type === "agent" ? n.agent.name : undefined,
+                    agentId: n.type === "agent" ? n.agent.id : undefined,
+                });
+            }
+            for (let i = 0; i < linearIds.length - 1; i++) {
+                edges.push({ from: linearIds[i], to: linearIds[i + 1], type: "linear" });
+            }
+            for (let i = 0; i < wfNodes.length; i++) {
+                const node = wfNodes[i];
+                const nextId = wfNodes[i + 1]?.id ?? parentAfterNodeId;
+                if (node.type === "branch") {
+                    for (const [key, sub] of Object.entries(node.branches)) {
+                        const subIds = sub.__internalNodes().map((n) => n.id);
+                        if (subIds.length === 0)
+                            continue;
+                        edges.push({ from: node.id, to: subIds[0], type: "branch", label: key });
+                        walk(sub, nextId);
+                        if (nextId) {
+                            const terminals = this.findTerminalNodeIds(sub);
+                            for (const t of terminals)
+                                edges.push({ from: t, to: nextId, type: "merge", label: key });
+                        }
+                    }
+                }
+                if (node.type === "parallel") {
+                    node.workflows.forEach((sub, index) => {
+                        const subIds = sub.__internalNodes().map((n) => n.id);
+                        if (subIds.length === 0)
+                            return;
+                        edges.push({ from: node.id, to: subIds[0], type: "parallel", label: String(index) });
+                        walk(sub, nextId);
+                        if (nextId) {
+                            const terminals = this.findTerminalNodeIds(sub);
+                            for (const t of terminals)
+                                edges.push({ from: t, to: nextId, type: "merge", label: String(index) });
+                        }
+                    });
+                }
+            }
+        };
+        walk(root, undefined);
+        return { nodes: dedupeNodes(nodes), edges };
+    }
+    findTerminalNodeIds(wf) {
+        const wfNodes = wf.__internalNodes();
+        if (wfNodes.length === 0)
+            return [];
+        const last = wfNodes[wfNodes.length - 1];
+        if (last.type === "branch") {
+            const terminals = [];
+            for (const sub of Object.values(last.branches)) {
+                terminals.push(...this.findTerminalNodeIds(sub));
+            }
+            return terminals.length ? terminals : [last.id];
+        }
+        if (last.type === "parallel") {
+            const terminals = [];
+            for (const sub of last.workflows)
+                terminals.push(...this.findTerminalNodeIds(sub));
+            return terminals.length ? terminals : [last.id];
+        }
+        return [last.id];
+    }
+}
+exports.DefinitionBuilder = DefinitionBuilder;
+function dedupeNodes(nodes) {
+    const seen = new Set();
+    const out = [];
+    for (const n of nodes) {
+        if (seen.has(n.id))
+            continue;
+        seen.add(n.id);
+        out.push(n);
+    }
+    return out;
+}

package/dist/workflow/definition/DefinitionBuilder.spec.d.ts

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

package/dist/workflow/definition/DefinitionBuilder.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Workflow_1 = require("../Workflow");
+const DefinitionBuilder_1 = require("./DefinitionBuilder");
+describe("DefinitionBuilder", () => {
+    it("should create linear edges for linear workflows", () => {
+        const wf = new Workflow_1.Workflow({ id: "wf" })
+            .start("start", async ({ input }) => input)
+            .step("a", async ({ input }) => input)
+            .finish("finish", async ({ input }) => input);
+        const { nodes, edges } = new DefinitionBuilder_1.DefinitionBuilder().build(wf);
+        expect(nodes.map((n) => n.id)).toEqual(["start", "a", "finish"]);
+        expect(edges).toEqual([
+            { from: "start", to: "a", type: "linear" },
+            { from: "a", to: "finish", type: "linear" },
+        ]);
+    });
+    it("should include branch fan-out and merge edges", () => {
+        const wf = new Workflow_1.Workflow({ id: "wf" })
+            .step("before", async ({ input }) => input)
+            .branch("route", async () => "billing", {
+            billing: (b) => b.step("billing-step", async ({ input }) => input),
+            tech: (t) => t.step("tech-step", async ({ input }) => input),
+        })
+            .step("after", async ({ input }) => input);
+        const { edges } = new DefinitionBuilder_1.DefinitionBuilder().build(wf);
+        // Fan-out from branch node
+        expect(edges).toEqual(expect.arrayContaining([
+            { from: "before", to: "route", type: "linear" },
+            { from: "route", to: "billing-step", type: "branch", label: "billing" },
+            { from: "route", to: "tech-step", type: "branch", label: "tech" },
+        ]));
+        // Merge back into "after"
+        expect(edges).toEqual(expect.arrayContaining([
+            { from: "billing-step", to: "after", type: "merge", label: "billing" },
+            { from: "tech-step", to: "after", type: "merge", label: "tech" },
+        ]));
+    });
+    it("should include parallel fan-out and merge edges", () => {
+        const wf = new Workflow_1.Workflow({ id: "wf" })
+            .step("before", async ({ input }) => input)
+            .parallel("fanout", [
+            (p) => p.step("p1", async ({ input }) => input),
+            (p) => p.step("p2", async ({ input }) => input),
+        ])
+            .step("after", async ({ input }) => input);
+        const { edges } = new DefinitionBuilder_1.DefinitionBuilder().build(wf);
+        expect(edges).toEqual(expect.arrayContaining([
+            { from: "before", to: "fanout", type: "linear" },
+            { from: "fanout", to: "p1", type: "parallel", label: "0" },
+            { from: "fanout", to: "p2", type: "parallel", label: "1" },
+            { from: "p1", to: "after", type: "merge", label: "0" },
+            { from: "p2", to: "after", type: "merge", label: "1" },
+        ]));
+    });
+    it("should dedupe nodes across traversal", () => {
+        const wf = new Workflow_1.Workflow({ id: "wf" })
+            .step("same", async ({ input }) => input)
+            .branch("route", async () => "a", {
+            a: (w) => w.step("same", async ({ input }) => input),
+        });
+        const { nodes } = new DefinitionBuilder_1.DefinitionBuilder().build(wf);
+        // Global registry should have deduped ids
+        expect(nodes.map((n) => n.id)).toEqual(expect.arrayContaining(["same", "route", "same-2"]));
+    });
+});

package/dist/workflow/definition/DefinitionHasher.d.ts

@@ -0,0 +1,8 @@
+import type { WorkflowDefinitionEdge, WorkflowDefinitionNode } from "./types.js";
+export declare class DefinitionHasher {
+    hash(input: {
+        workflowId: string;
+        nodes: WorkflowDefinitionNode[];
+        edges: WorkflowDefinitionEdge[];
+    }): string;
+}

package/dist/workflow/definition/DefinitionHasher.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionHasher = void 0;
+const node_crypto_1 = require("node:crypto");
+class DefinitionHasher {
+    hash(input) {
+        const payload = JSON.stringify({ workflowId: input.workflowId, nodes: input.nodes, edges: input.edges });
+        return (0, node_crypto_1.createHash)("sha256").update(payload).digest("hex").slice(0, 16);
+    }
+}
+exports.DefinitionHasher = DefinitionHasher;

package/dist/workflow/definition/DefinitionHasher.spec.d.ts

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

package/dist/workflow/definition/DefinitionHasher.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefinitionHasher_1 = require("./DefinitionHasher");
+describe("DefinitionHasher", () => {
+    it("should be deterministic for same workflowId + nodes + edges", () => {
+        const hasher = new DefinitionHasher_1.DefinitionHasher();
+        const input = {
+            workflowId: "wf",
+            nodes: [{ id: "a", displayName: "a", type: "step" }],
+            edges: [],
+        };
+        expect(hasher.hash(input)).toBe(hasher.hash(input));
+    });
+    it("should change when nodes change", () => {
+        const hasher = new DefinitionHasher_1.DefinitionHasher();
+        const base = hasher.hash({
+            workflowId: "wf",
+            nodes: [{ id: "a", displayName: "a", type: "step" }],
+            edges: [],
+        });
+        const changed = hasher.hash({
+            workflowId: "wf",
+            nodes: [{ id: "a", displayName: "a", type: "step" }, { id: "b", displayName: "b", type: "step" }],
+            edges: [],
+        });
+        expect(changed).not.toBe(base);
+    });
+});

package/dist/workflow/definition/types.d.ts

@@ -0,0 +1,27 @@
+export type WorkflowNodeType = "start" | "step" | "agent" | "branch" | "parallel" | "finish";
+export type WorkflowDefinitionNode = {
+    id: string;
+    displayName: string;
+    type: WorkflowNodeType;
+    metadata?: Record<string, unknown>;
+    agentName?: string;
+    /**
+     * Stable agent identifier (matches runtimeResourceId used at registration time).
+     * This avoids UI needing to guess whether to use agentName vs agentId.
+     */
+    agentId?: string;
+};
+export type WorkflowDefinitionEdge = {
+    from: string;
+    to: string;
+    type: "linear" | "branch" | "parallel" | "merge";
+    label?: string;
+};
+export type WorkflowDefinition = {
+    workflowId: string;
+    name?: string;
+    description?: string;
+    version: string;
+    nodes: WorkflowDefinitionNode[];
+    edges: WorkflowDefinitionEdge[];
+};

package/dist/workflow/definition/types.js

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

package/dist/workflow/events.d.ts

@@ -0,0 +1,9 @@
+import { WorkflowRunStart, WorkflowRunEnd, WorkflowRunError, WorkflowNodeStart, WorkflowNodeEnd } from "../events/schemas.js";
+export type WorkflowEventMap = {
+    "workflow:run:start": WorkflowRunStart;
+    "workflow:run:end": WorkflowRunEnd;
+    "workflow:run:error": WorkflowRunError;
+    "workflow:node:start": WorkflowNodeStart;
+    "workflow:node:end": WorkflowNodeEnd;
+};
+export type WorkflowEventName = keyof WorkflowEventMap;

package/dist/workflow/events.js

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

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

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

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Workflow_1 = require("../Workflow");
+const Agent_1 = require("../../agent/Agent");
+const in_memory_1 = require("../../agent/memory/in-memory");
+const mock_provider_1 = require("../../__tests__/mocks/mock-provider");
+const tracing_1 = require("../../tracing");
+class CapturingExporter {
+    events = [];
+    async exportBatch(events) {
+        this.events.push(...events);
+    }
+}
+describe("Agent node integration (Workflow + Agent + Telemetry)", () => {
+    it("should execute agent node with real Agent and nest agent span under node span", async () => {
+        const exporter = new CapturingExporter();
+        tracing_1.Tracing.setExporter(exporter);
+        const provider = new mock_provider_1.MockProvider();
+        provider.enqueueResponse({
+            content: "AGENT_OK",
+            usage: { promptTokens: 1, completionTokens: 1, totalTokens: 2 },
+        });
+        const agent = new Agent_1.Agent({
+            id: "triage-agent",
+            name: "triage-agent",
+            memory: new in_memory_1.InMemory(),
+            model: provider,
+            instructions: "Return the next step.",
+        });
+        const wf = new Workflow_1.Workflow({ id: "wf" })
+            .step("before", async ({ input }) => input)
+            .agent("triage", agent, { toInput: (input) => `input:${String(input)}` })
+            .step("after", async ({ input }) => `after:${String(input)}`);
+        const out = await wf.run("x", { executionId: "exec-agent-1" });
+        expect(out).toBe("after:AGENT_OK");
+        const starts = exporter.events.filter((e) => e.type === "telemetry:span:start");
+        const nodeSpanStart = starts.find((e) => (e.span.kind === "workflow.node" || e.span.kind === "custom") &&
+            e.span.name === "workflow:node:triage");
+        expect(nodeSpanStart).toBeDefined();
+        const agentSpanStart = starts.find((e) => e.span.kind === "agent" && e.span.name === "agent:triage-agent");
+        expect(agentSpanStart).toBeDefined();
+        // Agent span must be a child of the workflow node span.
+        expect(agentSpanStart.trace.parentSpanId).toBe(nodeSpanStart.trace.spanId);
+        // And share the same traceId.
+        expect(agentSpanStart.trace.traceId).toBe(nodeSpanStart.trace.traceId);
+        // Agent node inside workflow is a separate sub-execution.
+        expect(agentSpanStart.executionId).toBeDefined();
+        expect(agentSpanStart.executionId).not.toBe("exec-agent-1");
+    });
+});

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

@@ -0,0 +1,9 @@
+import type { InternalNode } from "../graph/nodes.js";
+export declare class NodeExecutor {
+    executeOnce(params: {
+        node: InternalNode;
+        currentInput: unknown;
+        state: Record<string, any>;
+        executionId: string;
+    }): Promise<any>;
+}

package/dist/workflow/execution/NodeExecutor.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeExecutor = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../execution-context/index.js");
+class NodeExecutor {
+    async executeOnce(params) {
+        const { node, currentInput, state, executionId } = params;
+        switch (node.type) {
+            case "start":
+            case "step":
+            case "finish":
+                return node.handler({ input: currentInput, state });
+            case "agent": {
+                const toInput = node.toInput ??
+                    ((input) => (typeof input === "string" ? input : JSON.stringify(input)));
+                const message = toInput(currentInput, state);
+                // IMPORTANT:
+                // - agent nodes inside a workflow are tracked as independent sub-executions
+                // - they must share the same traceId, but use a different executionId
+                const agentExecutionId = (0, node_crypto_1.randomUUID)();
+                const result = await index_js_1.ExecutionContext.run({
+                    executionId: agentExecutionId,
+                    rootExecutionId: executionId,
+                    parentExecutionId: executionId,
+                }, async () => node.agent.execute(message, { executionId: agentExecutionId }));
+                return result.content;
+            }
+            case "branch": {
+                const key = await node.selector({ input: currentInput, state });
+                const wf = node.branches[key];
+                if (!wf)
+                    throw new Error(`Unknown branch key '${key}' for node '${node.id}'`);
+                return wf.run(currentInput, { executionId });
+            }
+            case "parallel": {
+                const results = await Promise.all(node.workflows.map((wf) => wf.run(currentInput, { executionId })));
+                return results;
+            }
+        }
+    }
+}
+exports.NodeExecutor = NodeExecutor;

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NodeExecutor_1 = require("./NodeExecutor");
+describe("NodeExecutor", () => {
+    it("should execute a step node", async () => {
+        const exec = new NodeExecutor_1.NodeExecutor();
+        const out = await exec.executeOnce({
+            node: {
+                id: "a",
+                displayName: "a",
+                type: "step",
+                handler: async ({ input }) => `${input}-ok`,
+            },
+            currentInput: "x",
+            state: {},
+            executionId: "exec-1",
+        });
+        expect(out).toBe("x-ok");
+    });
+    it("should execute an agent node using toInput mapping", async () => {
+        const exec = new NodeExecutor_1.NodeExecutor();
+        const calls = [];
+        const fakeAgent = {
+            name: "fake-agent",
+            execute: async (input) => {
+                calls.push(input);
+                return { content: `resp:${input}` };
+            },
+        };
+        const out = await exec.executeOnce({
+            node: {
+                id: "agent1",
+                displayName: "agent1",
+                type: "agent",
+                agent: fakeAgent,
+                toInput: (input) => `mapped:${input.value}`,
+            },
+            currentInput: { value: 123 },
+            state: {},
+            executionId: "exec-1",
+        });
+        expect(out).toBe("resp:mapped:123");
+        expect(calls).toEqual(["mapped:123"]);
+    });
+});

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

@@ -0,0 +1,14 @@
+import { EventEmitter } from "node:events";
+import type { WorkflowEventMap, WorkflowEventName } from "../events.js";
+export declare class WorkflowEventBus {
+    private readonly emitter;
+    constructor(emitter: EventEmitter);
+    on<E extends WorkflowEventName>(event: E, listener: (data: WorkflowEventMap[E]) => void): void;
+    once<E extends WorkflowEventName>(event: E, listener: (data: WorkflowEventMap[E]) => void): void;
+    off<E extends WorkflowEventName>(event: E, listener: (data: WorkflowEventMap[E]) => void): void;
+    emit<E extends WorkflowEventName>(event: E, payload: {
+        data: WorkflowEventMap[E]["data"];
+        correlationId?: string;
+        executionId?: string;
+    }): void;
+}

package/dist/workflow/execution/WorkflowEventBus.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowEventBus = void 0;
+const index_js_1 = require("../../tracing/index.js");
+const index_js_2 = require("../../execution-context/index.js");
+const index_js_3 = require("../../domain-events/index.js");
+class WorkflowEventBus {
+    emitter;
+    constructor(emitter) {
+        this.emitter = emitter;
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+    }
+    emit(event, payload) {
+        const traceContext = index_js_1.Tracing.getContext();
+        const execContext = index_js_2.ExecutionContext.getOrUndefined();
+        const fullEvent = {
+            type: event,
+            timestamp: new Date().toISOString(),
+            trace: {
+                traceId: traceContext?.traceId ?? `fallback-${Date.now()}`,
+                spanId: traceContext?.spanId ?? `fallback-${Date.now()}`,
+                parentSpanId: traceContext?.parentId,
+            },
+            correlationId: payload.correlationId,
+            executionId: payload.executionId ?? execContext?.executionId,
+            rootExecutionId: execContext?.rootExecutionId,
+            parentExecutionId: execContext?.parentExecutionId,
+            data: payload.data,
+        };
+        index_js_3.DomainEvents.publish(fullEvent);
+        this.emitter.emit(event, fullEvent);
+    }
+}
+exports.WorkflowEventBus = WorkflowEventBus;

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

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

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

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const tracing_1 = require("../../tracing");
+const WorkflowEventBus_1 = require("./WorkflowEventBus");
+describe("WorkflowEventBus", () => {
+    it("should emit enriched events with trace context", async () => {
+        const emitter = new node_events_1.EventEmitter();
+        const bus = new WorkflowEventBus_1.WorkflowEventBus(emitter);
+        const received = [];
+        emitter.on("workflow:run:start", (e) => received.push(e));
+        await tracing_1.Tracing.withSpan({ kind: "custom", name: "test-span", executionId: "exec-1", data: {} }, async () => {
+            bus.emit("workflow:run:start", {
+                executionId: "exec-1",
+                data: { workflowId: "wf", definitionVersion: "v1", input: { a: 1 } },
+            });
+        });
+        expect(received.length).toBe(1);
+        expect(received[0].type).toBe("workflow:run:start");
+        expect(received[0].executionId).toBe("exec-1");
+        expect(received[0].trace?.traceId).toBeDefined();
+        expect(received[0].trace?.spanId).toBeDefined();
+    });
+    it("should preserve a single executionId across nested workflow runs (branch + parallel)", async () => {
+        const { Workflow } = await Promise.resolve().then(() => __importStar(require("../Workflow")));
+        const wf = new Workflow({ id: "wf" })
+            .step("before", async ({ input }) => input)
+            .branch("route", async () => "a", {
+            a: (w) => w.parallel("fanout", [
+                (p) => p.step("p1", async () => "p1"),
+                (p) => p.step("p2", async () => "p2"),
+            ]),
+        })
+            .step("after", async ({ input }) => input);
+        const executionIds = new Set();
+        wf.on("workflow:run:start", (e) => executionIds.add(e.executionId));
+        wf.on("workflow:node:start", (e) => executionIds.add(e.executionId));
+        wf.on("workflow:node:end", (e) => executionIds.add(e.executionId));
+        wf.on("workflow:run:end", (e) => executionIds.add(e.executionId));
+        await wf.run("x", { executionId: "exec-nested-1" });
+        // All workflow events in this execution must share the same executionId.
+        expect(executionIds.size).toBe(1);
+        expect(Array.from(executionIds)[0]).toBe("exec-nested-1");
+    });
+});

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

@@ -0,0 +1,26 @@
+import type { WorkflowConfig } from "../Workflow.js";
+import type { WorkflowDefinition } from "../definition/types.js";
+import type { InternalNode } from "../graph/nodes.js";
+import { WorkflowEventBus } from "./WorkflowEventBus.js";
+import { WorkflowTelemetry } from "./WorkflowTelemetry.js";
+import { WorkflowStateService } from "../state/WorkflowStateService.js";
+import { NodeExecutor } from "./NodeExecutor.js";
+export declare class WorkflowRunner {
+    private readonly config;
+    private readonly events;
+    private readonly telemetry;
+    private readonly state;
+    private readonly nodeExecutor;
+    constructor(config: WorkflowConfig<any, any>, events: WorkflowEventBus, telemetry: WorkflowTelemetry, state: WorkflowStateService, nodeExecutor: NodeExecutor);
+    run(params: {
+        workflowId: string;
+        workflowNameForTelemetry: string;
+        definition: WorkflowDefinition;
+        nodes: readonly InternalNode[];
+        input: unknown;
+        options?: {
+            executionId?: string;
+        };
+    }): Promise<any>;
+    private executeNodeWithRetry;
+}