open-multi-agent-kit 0.78.0

package/dist/orchestration/agent-worker.js

@@ -0,0 +1,278 @@
+/**
+ * AgentWorker — 개별 워커 프로세스 관리
+ *
+ * 에이전트 YAML을 로드하고 프로세스를 스폰하여 작업을 실행합니다.
+ */
+import { spawn } from "child_process";
+import { join } from "path";
+import { renderScopedAgentYaml } from "../util/scoped-agent-file.js";
+import { assignSkills } from "./skill-assigner.js";
+import { capabilityScopesFromRouting } from "./capability-routing.js";
+import { buildChildEnv } from "../runtime/child-env.js";
+export function buildAgentWorkerSpawnEnv(workerEnv, metadata) {
+    return buildChildEnv({
+        parentEnv: process.env,
+        overrideEnv: {
+            ...workerEnv,
+            OMK_RUN_ID: metadata.runId,
+            OMK_NODE_ID: metadata.nodeId,
+            OMK_NODE_ROLE: metadata.role,
+        },
+    });
+}
+export class AgentWorker {
+    node;
+    runId;
+    agentYamlPath;
+    logHandle;
+    cwd;
+    env;
+    timeout;
+    runContext;
+    process = null;
+    abortController = null;
+    constructor(options) {
+        this.node = options.node;
+        this.runId = options.runId;
+        this.agentYamlPath = options.agentYamlPath;
+        this.logHandle = options.logHandle;
+        this.cwd = options.cwd ?? process.cwd();
+        this.env = options.env ?? {};
+        this.timeout = options.timeout ?? 300000; // 5분 기본
+        this.runContext = options.runContext;
+    }
+    /**
+     * 워커 실행
+     */
+    async execute() {
+        this.abortController = new AbortController();
+        const startTime = Date.now();
+        // In-process execution via runtime bridge
+        if (this.node.executionMode === "in-process") {
+            this.logHandle.log("info", `Executing node in-process: ${this.node.id}`);
+            const { createRuntimeBackedTaskRunner } = await import("../runtime/runtime-backed-task-runner.js");
+            const runner = await createRuntimeBackedTaskRunner({
+                cwd: this.cwd,
+                env: this.env,
+                runId: this.runId,
+                goal: this.node.name,
+            });
+            const timeoutId = this.timeout > 0
+                ? setTimeout(() => {
+                    if (!this.abortController?.signal.aborted) {
+                        this.logHandle.log("warn", `Worker timeout after ${this.timeout}ms, terminating...`);
+                        this.abort();
+                    }
+                }, this.timeout)
+                : undefined;
+            try {
+                const taskResult = await runner.run(this.node, this.env, this.abortController.signal, this.runContext);
+                const duration = Date.now() - startTime;
+                for (const line of taskResult.stdout.split("\n")) {
+                    if (line)
+                        this.logHandle.onStdout(line.trim());
+                }
+                for (const line of taskResult.stderr.split("\n")) {
+                    if (line)
+                        this.logHandle.onStderr(line.trim());
+                }
+                this.logHandle.log(taskResult.success ? "info" : "error", `Worker finished (${duration}ms)`);
+                return {
+                    success: taskResult.success,
+                    exitCode: taskResult.exitCode ?? (taskResult.success ? 0 : 1),
+                    stdout: taskResult.stdout,
+                    stderr: taskResult.stderr,
+                    metadata: {
+                        ...(taskResult.metadata ?? {}),
+                        duration,
+                        nodeId: this.node.id,
+                        role: this.node.role,
+                        capabilityScopes: capabilityScopesFromRouting(this.node.routing),
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.logHandle.log("error", `Worker process error: ${message}`);
+                throw error;
+            }
+            finally {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+            }
+        }
+        let stdout = "";
+        let stderr = "";
+        let exitCode = 1;
+        return new Promise((resolve, reject) => {
+            // omk 실행 명령어 구성
+            const command = "node";
+            const args = [
+                join(__dirname, "..", "cli", "main.js"),
+                "run",
+                "--agent-yaml", this.agentYamlPath,
+                "--node-id", this.node.id,
+                "--run-id", this.runId,
+            ];
+            this.logHandle.log("info", `Spawning worker: ${command} ${args.join(" ")}`);
+            try {
+                this.process = spawn(command, args, {
+                    cwd: this.cwd,
+                    env: buildAgentWorkerSpawnEnv(this.env, {
+                        runId: this.runId,
+                        nodeId: this.node.id,
+                        role: this.node.role,
+                    }),
+                    stdio: ["pipe", "pipe", "pipe"],
+                    signal: this.abortController.signal,
+                });
+                // stdout 처리
+                this.process.stdout?.on("data", (chunk) => {
+                    const line = chunk.toString("utf-8");
+                    stdout += line;
+                    this.logHandle.onStdout(line.trim());
+                });
+                // stderr 처리
+                this.process.stderr?.on("data", (chunk) => {
+                    const line = chunk.toString("utf-8");
+                    stderr += line;
+                    this.logHandle.onStderr(line.trim());
+                });
+                // 프로세스 종료 처리
+                this.process.on("close", (code) => {
+                    exitCode = code ?? 1;
+                    const duration = Date.now() - startTime;
+                    this.logHandle.log(exitCode === 0 ? "info" : "error", `Worker finished with exit code ${exitCode} (${duration}ms)`);
+                    resolve({
+                        success: exitCode === 0,
+                        exitCode,
+                        stdout,
+                        stderr,
+                        metadata: {
+                            duration,
+                            nodeId: this.node.id,
+                            role: this.node.role,
+                        },
+                    });
+                });
+                // 프로세스 에러 처리
+                this.process.on("error", (error) => {
+                    this.logHandle.log("error", `Worker process error: ${error.message}`);
+                    reject(error);
+                });
+                // 타임아웃 설정
+                if (this.timeout > 0) {
+                    setTimeout(() => {
+                        if (this.process && !this.process.killed) {
+                            this.logHandle.log("warn", `Worker timeout after ${this.timeout}ms, terminating...`);
+                            this.abort();
+                        }
+                    }, this.timeout);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.logHandle.log("error", `Failed to spawn worker: ${message}`);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * 워커 중단
+     */
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+        if (this.process && !this.process.killed) {
+            this.process.kill("SIGTERM");
+            // 3초 후 강제 종료
+            setTimeout(() => {
+                if (this.process && !this.process.killed) {
+                    this.process.kill("SIGKILL");
+                }
+            }, 3000);
+        }
+    }
+    /**
+     * 워커가 실행 중인지 확인
+     */
+    isRunning() {
+        return this.process !== null && !this.process.killed && this.process.exitCode === null;
+    }
+    /**
+     * 프로세스 ID 가져오기
+     */
+    getPid() {
+        return this.process?.pid;
+    }
+    /**
+     * 노드 정보 가져오기
+     */
+    getNode() {
+        return this.node;
+    }
+}
+/**
+ * 에이전트 YAML 파일 생성
+ */
+export async function createAgentYaml(node, runId, skills, outputDir) {
+    const yamlPath = join(outputDir, `${node.id}.yaml`);
+    const scopes = capabilityScopesFromRouting(node.routing, skills);
+    const capabilities = {
+        mcpScope: node.routing?.mcpServers?.length ? "none" : "project",
+        skillsScope: node.routing?.skills?.length ? "none" : "project",
+        hooksScope: node.routing?.hooks?.length ? "project" : "project",
+        skillNames: [...scopes.skills],
+        mcpNames: [...scopes.mcpServers],
+        toolNames: [...scopes.tools],
+        hookNames: [...scopes.hooks],
+    };
+    const baseAgentFile = join(outputDir, "..", "..", "..", "..", ".omk", "agents", "root.yaml");
+    const outputFile = yamlPath;
+    const yaml = renderScopedAgentYaml({
+        baseAgentFile,
+        outputFile,
+        role: node.role,
+        name: node.name,
+        resources: capabilities,
+    });
+    const { writeFile } = await import("fs/promises");
+    await writeFile(yamlPath, yaml, "utf-8");
+    return yamlPath;
+}
+/**
+ * 워커 생성 헬퍼
+ */
+export async function createAgentWorker(node, runId, logHandle, options = {}) {
+    // 스킬 할당
+    const skills = assignSkills(node);
+    // 에이전트 YAML 생성
+    const outputDir = options.cwd
+        ? join(options.cwd, ".omk", "runs", runId, "agents")
+        : join(".omk", "runs", runId, "agents");
+    const { mkdir } = await import("fs/promises");
+    await mkdir(outputDir, { recursive: true });
+    const agentYamlPath = await createAgentYaml(node, runId, skills, outputDir);
+    logHandle.log("info", `Created agent YAML: ${agentYamlPath}`);
+    const scopes = capabilityScopesFromRouting(node.routing, skills);
+    logHandle.log("info", `Assigned skills: ${scopes.skills.join(", ")}`);
+    logHandle.log("info", `Assigned MCP servers: ${scopes.mcpServers.join(", ")}`);
+    logHandle.log("info", `Assigned hooks: ${scopes.hooks.join(", ")}`);
+    if (node.routing?.skills?.length) {
+        logHandle.log("info", `Routing override skills: ${node.routing.skills.join(", ")}`);
+    }
+    if (node.routing?.mcpServers?.length) {
+        logHandle.log("info", `Routing override MCPs: ${node.routing.mcpServers.join(", ")}`);
+    }
+    if (node.routing?.hooks?.length) {
+        logHandle.log("info", `Routing override hooks: ${node.routing.hooks.join(", ")}`);
+    }
+    return new AgentWorker({
+        node,
+        runId,
+        agentYamlPath,
+        logHandle,
+        ...options,
+    });
+}

package/dist/orchestration/capability-agents.d.ts

@@ -0,0 +1,14 @@
+import type { DagNodeDefinition } from "./dag.js";
+import type { RunState } from "../contracts/orchestration.js";
+import type { EnsembleDecisionCandidateVote } from "./ensemble-decision.js";
+export interface CapabilityAgentBuildInput {
+    goal: string;
+    dependsOn: string[];
+    maxAgents?: number;
+    seedId?: string;
+    seedRole?: string;
+    seedName?: string;
+}
+export declare function buildCapabilityAgentNodes(input: CapabilityAgentBuildInput): DagNodeDefinition[];
+export declare function isCapabilityAgentNode(node: Pick<DagNodeDefinition, "id" | "routing">): boolean;
+export declare function buildCapabilityVotes(capabilityNodes: RunState["nodes"], runState: RunState): EnsembleDecisionCandidateVote[];

package/dist/orchestration/capability-agents.js

@@ -0,0 +1,180 @@
+import { selectTaskRouting } from "./routing.js";
+export function buildCapabilityAgentNodes(input) {
+    const maxAgents = Math.max(0, Math.min(input.maxAgents ?? 3, 3));
+    if (maxAgents === 0 || input.dependsOn.length === 0)
+        return [];
+    const seed = {
+        id: input.seedId ?? "capability-routing-seed",
+        name: input.seedName ?? "Route active capabilities for action digest",
+        role: input.seedRole ?? "router",
+        dependsOn: input.dependsOn,
+        maxRetries: 1,
+        cost: 2,
+        outputs: [{ name: "capability routing plan", gate: "summary" }],
+    };
+    const routing = selectTaskRouting(seed);
+    const lanes = buildCapabilityLanes(input.goal, routing).slice(0, maxAgents);
+    return lanes.map((lane) => ({
+        id: lane.id,
+        name: lane.name,
+        role: lane.role,
+        dependsOn: [...input.dependsOn],
+        maxRetries: 1,
+        priority: 2,
+        cost: 1,
+        failurePolicy: { retryable: true, blockDependents: false, skipOnFailure: true },
+        inputs: input.dependsOn.map((from) => ({
+            name: `${from} context`,
+            ref: "state.json",
+            from,
+        })),
+        outputs: [{ name: lane.outputName, gate: "none", required: false }],
+        routing: lane.routing,
+    }));
+}
+export function isCapabilityAgentNode(node) {
+    return node.routing?.autoSpawned === true || node.id.startsWith("capability-");
+}
+function buildCapabilityLanes(goal, routing) {
+    const lanes = [];
+    const skills = routing.skills ?? [];
+    const mcpServers = routing.mcpServers ?? [];
+    const tools = routing.tools ?? [];
+    const scopedTools = tools.filter((tool) => tool !== "SearchWeb" && tool !== "FetchURL");
+    const hooks = routing.hooks ?? [];
+    if (skills.length > 0) {
+        lanes.push({
+            id: "capability-skill-agent",
+            name: "Activate relevant skills for action digest",
+            role: "explorer",
+            source: "skill",
+            outputName: "skill activation handoff",
+            routing: {
+                provider: "auto",
+                providerReason: "Provider-neutral runtime owns skill activation and synthesis for auto-spawned capability lanes",
+                autoSpawned: true,
+                spawnReason: "active skill inventory matched the orchestration goal",
+                routeSource: "skill",
+                assignedCapabilities: {
+                    skills,
+                    mcpServers: [],
+                    tools: [],
+                    hooks: [],
+                },
+                requiresMcp: false,
+                requiresToolCalling: false,
+                readOnly: true,
+                evidenceRequired: false,
+                contextBudget: "tiny",
+                skills,
+                mcpServers: [],
+                tools: [],
+                hooks: [],
+                rationale: `skills=${skills.join(",")}`,
+            },
+        });
+    }
+    if (mcpServers.length > 0 || scopedTools.length > 0) {
+        lanes.push({
+            id: "capability-mcp-agent",
+            name: "Use active MCP/tools for action digest",
+            role: "researcher",
+            source: "mcp",
+            outputName: "mcp tool handoff",
+            routing: {
+                provider: "auto",
+                providerReason: "Provider-neutral runtime required because this capability lane may use live MCP/tool authority",
+                autoSpawned: true,
+                spawnReason: "active MCP/tool inventory matched the orchestration goal",
+                routeSource: "mcp",
+                assignedCapabilities: {
+                    skills: [],
+                    mcpServers,
+                    tools: scopedTools,
+                    hooks: [],
+                },
+                requiresMcp: mcpServers.length > 0,
+                requiresToolCalling: scopedTools.length > 0,
+                readOnly: true,
+                evidenceRequired: false,
+                contextBudget: "tiny",
+                skills: [],
+                mcpServers,
+                tools: scopedTools,
+                hooks: [],
+                rationale: `mcp=${mcpServers.join(",")}; tools=${scopedTools.join(",")}`,
+            },
+        });
+    }
+    if (hooks.length > 0) {
+        lanes.push({
+            id: "capability-hook-agent",
+            name: "Apply active hook constraints for action digest",
+            role: "reviewer",
+            source: "hook",
+            outputName: "hook constraint handoff",
+            routing: {
+                provider: "auto",
+                providerReason: "Provider-neutral runtime owns hook-aware guardrails and final synthesis for auto-spawned capability lanes",
+                autoSpawned: true,
+                spawnReason: "active hook inventory matched the orchestration goal",
+                routeSource: "hook",
+                assignedCapabilities: {
+                    skills: [],
+                    mcpServers: [],
+                    tools: [],
+                    hooks,
+                },
+                requiresMcp: false,
+                requiresToolCalling: false,
+                readOnly: true,
+                evidenceRequired: false,
+                contextBudget: "tiny",
+                skills: [],
+                mcpServers: [],
+                tools: [],
+                hooks,
+                rationale: `hooks=${hooks.join(",")}`,
+            },
+        });
+    }
+    return lanes;
+}
+export function buildCapabilityVotes(capabilityNodes, runState) {
+    const votes = [];
+    const pendingNodes = runState.nodes.filter((n) => n.status === "pending" || n.status === "running");
+    for (const node of capabilityNodes) {
+        if (node.status === "failed") {
+            votes.push({
+                id: node.id,
+                action: "replan",
+                weight: 0.7,
+                reason: `Capability lane ${node.id} failed`,
+            });
+            continue;
+        }
+        if (node.status === "done") {
+            votes.push({
+                id: node.id,
+                action: "continue",
+                weight: 0.5,
+                reason: `Capability lane ${node.id} is ready`,
+            });
+            continue;
+        }
+        if (pendingNodes.length > 0) {
+            const hasRouting = node.routing && ((node.routing.skills && node.routing.skills.length > 0) ||
+                (node.routing.mcpServers && node.routing.mcpServers.length > 0) ||
+                (node.routing.hooks && node.routing.hooks.length > 0));
+            votes.push({
+                id: node.id,
+                action: hasRouting ? "continue" : "replan",
+                weight: 0.6,
+                reason: hasRouting
+                    ? `Capability lane ${node.id} has scoped routing for pending work`
+                    : `Capability lane ${node.id} lacks routing hints for pending work`,
+            });
+        }
+    }
+    return votes;
+}

package/dist/orchestration/capability-routing.d.ts

@@ -0,0 +1,42 @@
+import type { DagNode, DagNodeRouting } from "./dag.js";
+export interface NodeCapabilityScopes {
+    readonly skills: readonly string[];
+    readonly mcpServers: readonly string[];
+    readonly tools: readonly string[];
+    readonly hooks: readonly string[];
+}
+export interface CapabilityRoutingEntry extends NodeCapabilityScopes {
+    readonly nodeId: string;
+    readonly name: string;
+    readonly role: string;
+    readonly provider: string;
+    readonly fallbackProvider?: string;
+    readonly candidateProviders: readonly string[];
+    readonly assignedModel?: string;
+    readonly authority?: string;
+    readonly routeSource?: string;
+    readonly rationale?: string;
+    readonly actionAtom?: DagNodeRouting["actionAtom"];
+}
+export interface CapabilityRoutingIdentity {
+    readonly owner: "omk";
+    readonly identity: "OMK root orchestrator";
+    readonly doctrine: "Models execute. OMK routes, verifies, measures, and controls.";
+    readonly goal?: string;
+    readonly capabilityAssignment: "goal-scoped";
+}
+export interface CapabilityRoutingArtifact {
+    readonly schemaVersion: 1;
+    readonly generatedAt: string;
+    readonly nodes: readonly CapabilityRoutingEntry[];
+    readonly orchestrator: CapabilityRoutingIdentity;
+}
+export declare function uniqueCapabilityNames(values: readonly (string | undefined)[]): string[];
+export declare function capabilityScopesFromRouting(routing: DagNodeRouting | undefined, fallback?: Partial<NodeCapabilityScopes>): NodeCapabilityScopes;
+export declare function mergeCapabilityScopes(...scopes: readonly (Partial<NodeCapabilityScopes> | undefined)[]): NodeCapabilityScopes;
+export declare function attachAssignedCapabilities(routing: DagNodeRouting): DagNodeRouting;
+export declare function capabilityRoutingEntry(node: DagNode): CapabilityRoutingEntry;
+export declare function renderCapabilityRoutingArtifact(nodes: readonly DagNode[], options?: string | {
+    readonly generatedAt?: string;
+    readonly goal?: string;
+}): CapabilityRoutingArtifact;

package/dist/orchestration/capability-routing.js

@@ -0,0 +1,65 @@
+export function uniqueCapabilityNames(values) {
+    return [...new Set(values.filter((value) => Boolean(value?.trim())).map((value) => value.trim()))];
+}
+export function capabilityScopesFromRouting(routing, fallback = {}) {
+    const assigned = routing?.assignedCapabilities;
+    return {
+        skills: uniqueCapabilityNames(routing?.skills ?? assigned?.skills ?? fallback.skills ?? []),
+        mcpServers: uniqueCapabilityNames(routing?.mcpServers ?? assigned?.mcpServers ?? fallback.mcpServers ?? []),
+        tools: uniqueCapabilityNames(routing?.tools ?? assigned?.tools ?? fallback.tools ?? []),
+        hooks: uniqueCapabilityNames(routing?.hooks ?? assigned?.hooks ?? fallback.hooks ?? []),
+    };
+}
+export function mergeCapabilityScopes(...scopes) {
+    return {
+        skills: uniqueCapabilityNames(scopes.flatMap((scope) => scope?.skills ?? [])),
+        mcpServers: uniqueCapabilityNames(scopes.flatMap((scope) => scope?.mcpServers ?? [])),
+        tools: uniqueCapabilityNames(scopes.flatMap((scope) => scope?.tools ?? [])),
+        hooks: uniqueCapabilityNames(scopes.flatMap((scope) => scope?.hooks ?? [])),
+    };
+}
+export function attachAssignedCapabilities(routing) {
+    const assignedCapabilities = capabilityScopesFromRouting(routing);
+    return {
+        ...routing,
+        assignedCapabilities: {
+            skills: [...assignedCapabilities.skills],
+            mcpServers: [...assignedCapabilities.mcpServers],
+            tools: [...assignedCapabilities.tools],
+            hooks: [...assignedCapabilities.hooks],
+        },
+    };
+}
+export function capabilityRoutingEntry(node) {
+    const scopes = capabilityScopesFromRouting(node.routing);
+    const provider = node.routing?.assignedProvider ?? node.routing?.provider ?? "auto";
+    return {
+        nodeId: node.id,
+        name: node.name,
+        role: node.role,
+        provider,
+        fallbackProvider: node.routing?.fallbackProvider,
+        candidateProviders: uniqueCapabilityNames(node.routing?.candidateProviders ?? []),
+        assignedModel: node.routing?.assignedModel ?? node.routing?.providerModel,
+        authority: node.routing?.assignedProviderAuthority,
+        routeSource: node.routing?.routeSource,
+        rationale: node.routing?.rationale,
+        actionAtom: node.routing?.actionAtom,
+        ...scopes,
+    };
+}
+export function renderCapabilityRoutingArtifact(nodes, options = {}) {
+    const metadata = typeof options === "string" ? { generatedAt: options } : options;
+    return {
+        schemaVersion: 1,
+        generatedAt: metadata.generatedAt ?? new Date().toISOString(),
+        orchestrator: {
+            owner: "omk",
+            identity: "OMK root orchestrator",
+            doctrine: "Models execute. OMK routes, verifies, measures, and controls.",
+            goal: metadata.goal,
+            capabilityAssignment: "goal-scoped",
+        },
+        nodes: nodes.map(capabilityRoutingEntry),
+    };
+}

package/dist/orchestration/compiled-dag-executor.d.ts

@@ -0,0 +1,56 @@
+import type { ApprovalPolicy, RunResult, RunState, TaskResult, TaskRunner } from "../contracts/orchestration.js";
+import type { OmkRuntimeScope } from "../contracts/worker-context.js";
+import { type HarnessTaskRunnerMode, type HarnessTaskRunnerOptions, type HarnessTaskRunnerProviderOptions } from "../harness/create-harness-task-runner.js";
+import type { InputEnvelope } from "../input/input-envelope.js";
+import type { ProviderPolicy } from "../providers/types.js";
+import type { EnsemblePolicy } from "./ensemble.js";
+import type { DagNode } from "./dag.js";
+import type { DagCompileResult } from "./dag-compiler-types.js";
+import { type PersistLoopArtifactsResult } from "./loop-artifacts.js";
+import type { LoopDecision, OrchestrationLoopState } from "./loop-state.js";
+export interface ExecuteCompiledDagLoopOptions {
+    persist?: boolean;
+    requestedAction?: "continue" | "replan" | "verify";
+    iteration?: number;
+    maxIterations?: number;
+    parentRunId?: string;
+    nextInputEnvelope?: InputEnvelope;
+    now?: () => Date;
+}
+export interface ExecuteCompiledDagInput {
+    root: string;
+    compiled: DagCompileResult;
+    runId?: string;
+    providerPolicy?: ProviderPolicy;
+    model?: string;
+    mcpScope?: OmkRuntimeScope;
+    skillsScope?: OmkRuntimeScope;
+    hooksScope?: OmkRuntimeScope;
+    env?: Record<string, string>;
+    mode?: HarnessTaskRunnerMode;
+    approvalPolicy?: ApprovalPolicy;
+    timeoutPreset?: string;
+    nodeTimeoutMs?: number;
+    runTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
+    signal?: AbortSignal;
+    eventRunDir?: string;
+    ensemble?: false | EnsemblePolicy;
+    resumeFromState?: RunState;
+    useRuntimeBacked?: boolean;
+    runner?: TaskRunner;
+    providerOptions?: HarnessTaskRunnerProviderOptions;
+    runtimeOptions?: HarnessTaskRunnerOptions["runtimeOptions"];
+    factories?: HarnessTaskRunnerOptions["factories"];
+    loop?: ExecuteCompiledDagLoopOptions;
+    onStateChange?: (state: RunState) => void;
+    onNodeStart?: (node: DagNode) => void;
+    onNodeComplete?: (node: DagNode, result: TaskResult) => void;
+}
+export interface ExecuteCompiledDagResult {
+    run: RunResult;
+    loopDecision: LoopDecision;
+    loopState: OrchestrationLoopState;
+    loopArtifacts?: PersistLoopArtifactsResult;
+}
+export declare function executeCompiledDag(input: ExecuteCompiledDagInput): Promise<ExecuteCompiledDagResult>;