@xopcai/xopc 0.0.409 → 0.0.411

package/dist/src/workflows/engine/workflow-engine.js

@@ -1,719 +0,0 @@
-import { validateWorkflowJsonSchema } from "../domain/schema-validation.js";
-import { workflowStepLabel } from "../../agent/workflow/step-labels.js";
-import { createGraphWorkflowRuntime } from "../runtime/graph-workflow-runtime.js";
-import { randomUUID } from "node:crypto";
-//#region src/workflows/engine/workflow-engine.ts
-var WorkflowEngine = class {
-	constructor(options) {
-		this.options = options;
-	}
-	async startRun(definition, options) {
-		const runId = options.runId ?? randomUUID();
-		const createdAtMs = Date.now();
-		const phaseTitleToId = buildPhaseTitleToId(definition);
-		let currentPhaseId;
-		let eventQueue = Promise.resolve();
-		const progressRecorders = /* @__PURE__ */ new Map();
-		const runtimeAgentStatuses = /* @__PURE__ */ new Map();
-		const subagentConversationIds = /* @__PURE__ */ new Map();
-		const run = {
-			id: runId,
-			definitionId: definition.id,
-			definitionVersion: definition.version,
-			title: definition.title,
-			goal: options.goal ?? definition.description,
-			input: options.input ?? {},
-			status: "queued",
-			source: options.source,
-			metadata: options.metadata,
-			metrics: {
-				agentCount: 0,
-				doneAgentCount: 0,
-				errorAgentCount: 0,
-				skippedAgentCount: 0,
-				artifactCount: 0
-			},
-			createdAtMs
-		};
-		const appendEvent = (type, payload, createdAtMsOverride) => {
-			eventQueue = eventQueue.then(() => this.options.eventStore.append({
-				runId,
-				type,
-				payload,
-				createdAtMs: createdAtMsOverride
-			})).then(async (event) => {
-				this.options.onEventAppended?.(event);
-				const view = await this.options.runStore.rebuildRunView(runId);
-				if (view) this.options.onRunViewUpdated?.(view);
-			});
-			return eventQueue;
-		};
-		await appendEvent("run_queued", { run }, createdAtMs);
-		await this.callHooks((hook) => hook.beforeRun?.({
-			definition,
-			run
-		}));
-		await appendEvent("run_started", { startedAtMs: Date.now() });
-		try {
-			const runtimeResult = await withWorkflowTimeout((this.options.runtime ?? createGraphWorkflowRuntime()).run(definition.graph, {
-				runner: this.options.runner,
-				resolveModelId: this.options.resolveModelId
-			}, {
-				cwd: this.options.cwd,
-				args: options.input,
-				goal: options.goal ?? definition.description,
-				signal: options.signal,
-				concurrency: options.concurrency ?? definition.defaults.concurrency,
-				maxSubagents: options.maxSubagents ?? definition.defaults.maxSubagents,
-				tokenBudget: options.tokenBudget,
-				onPhase: (title) => {
-					const nextPhaseId = phaseTitleToId.get(title) ?? normalizePhaseId(title);
-					if (currentPhaseId && currentPhaseId !== nextPhaseId) appendEvent("phase_completed", { phaseId: currentPhaseId });
-					currentPhaseId = nextPhaseId;
-					appendEvent("phase_started", {
-						phaseId: nextPhaseId,
-						title
-					});
-				},
-				onLog: (message) => {
-					appendEvent("log_appended", { message });
-				},
-				onNodeStart: (event) => {
-					appendEvent("node_started", event);
-				},
-				onNodeEnd: (event) => {
-					appendEvent("node_completed", {
-						nodeId: event.nodeId,
-						kind: event.kind,
-						title: event.title,
-						status: event.status,
-						resultPreview: previewWorkflowValue(event.result),
-						error: event.error
-					});
-				},
-				onAgentQueued: (event) => {
-					const agentId = formatRuntimeAgentId(event.id);
-					const subagentConversationId = this.options.subagentConversationIdFactory?.({
-						runId,
-						agentId
-					}) ?? randomUUID();
-					subagentConversationIds.set(event.id, subagentConversationId);
-					runtimeAgentStatuses.set(event.id, "queued");
-					const phaseId = event.phase ? phaseTitleToId.get(event.phase) ?? normalizePhaseId(event.phase) : currentPhaseId;
-					this.callHooks((hook) => hook.beforeAgent?.({
-						runId,
-						agentId,
-						label: event.label,
-						phaseId,
-						prompt: event.prompt
-					}));
-					appendEvent("agent_queued", {
-						agentId,
-						nodeId: event.nodeId,
-						label: event.label,
-						phaseId,
-						prompt: event.prompt,
-						conversationId: subagentConversationId,
-						invocation: event.invocation
-					});
-				},
-				onAgentStart: (event) => {
-					const currentStatus = runtimeAgentStatuses.get(event.id);
-					if (currentStatus && currentStatus !== "queued" && currentStatus !== "running") return;
-					runtimeAgentStatuses.set(event.id, "running");
-					appendEvent("agent_started", {
-						agentId: formatRuntimeAgentId(event.id),
-						nodeId: event.nodeId
-					});
-				},
-				onAgentEnd: (event) => {
-					const currentStatus = runtimeAgentStatuses.get(event.id);
-					if (currentStatus && currentStatus !== "queued" && currentStatus !== "running") return;
-					const agentId = formatRuntimeAgentId(event.id);
-					const completedStatus = normalizeCompletedAgentStatus(event.status);
-					runtimeAgentStatuses.set(event.id, completedStatus);
-					const resultPreview = previewWorkflowValue(event.result);
-					progressRecorders.get(event.id)?.completeOpenSteps(completedStatus === "done" ? "done" : "error");
-					progressRecorders.delete(event.id);
-					appendEvent("agent_completed", {
-						agentId,
-						nodeId: event.nodeId,
-						status: completedStatus,
-						resultPreview,
-						error: completedStatus === "error" ? "Subagent failed" : void 0
-					}).then(() => this.callHooks((hook) => hook.afterAgent?.({
-						runId,
-						agentId,
-						status: completedStatus,
-						resultPreview
-					})).catch(() => void 0));
-				},
-				enhanceSubagentRun: (ctx) => {
-					const recorder = new AgentProgressRecorder({
-						agentId: formatRuntimeAgentId(ctx.id),
-						appendEvent
-					});
-					progressRecorders.set(ctx.id, recorder);
-					const agentId = formatRuntimeAgentId(ctx.id);
-					const conversationId = subagentConversationIds.get(ctx.id) ?? this.options.subagentConversationIdFactory?.({
-						runId,
-						agentId
-					}) ?? randomUUID();
-					subagentConversationIds.set(ctx.id, conversationId);
-					return {
-						conversationId,
-						instructions: this.options.contextInstructions,
-						sessionMetadata: {
-							parentConversationId: this.options.parentConversationId,
-							projectId: this.options.projectId,
-							workflowRunId: runId,
-							workflowDefinitionId: definition.id,
-							workflowAgentId: agentId,
-							workflowNodeId: ctx.nodeId,
-							workflowAgentLabel: ctx.label
-						},
-						onProgress: (event) => recorder.onProgress(event)
-					};
-				}
-			}), options.timeoutSec ?? definition.defaults.timeoutSec);
-			await eventQueue;
-			if (currentPhaseId) await appendEvent("phase_completed", { phaseId: currentPhaseId });
-			const result = requireWorkflowResultEnvelope(runtimeResult.result);
-			assertWorkflowOutput(definition, result.data === void 0 ? result.summary : result.data);
-			await appendEvent("run_completed", { result });
-			await this.callHooks((hook) => hook.afterRun?.({
-				runId,
-				status: "succeeded"
-			}));
-		} catch (err) {
-			await eventQueue;
-			const error = toWorkflowRunError(err, options.signal?.aborted === true, options.signal?.reason);
-			const terminalAgentStatus = error.code === "cancelled" || error.code === "timeout" ? "skipped" : "error";
-			await this.completeOutstandingRuntimeAgents({
-				runId,
-				statuses: runtimeAgentStatuses,
-				progressRecorders,
-				appendEvent,
-				status: terminalAgentStatus,
-				error: terminalAgentStatus === "error" ? error.message : void 0
-			});
-			if (error.code === "cancelled") {
-				await appendEvent("run_cancelled", { reason: error.message });
-				await this.callHooks((hook) => hook.afterRun?.({
-					runId,
-					status: "cancelled"
-				}));
-			} else {
-				await appendEvent("run_failed", { error });
-				await this.callHooks((hook) => hook.afterRun?.({
-					runId,
-					status: "failed"
-				}));
-			}
-		}
-		const view = await this.options.runStore.readRunView(runId);
-		if (!view) throw new Error(`workflow run view was not created for ${runId}`);
-		return view;
-	}
-	async startReplayRun(definition, options) {
-		const runId = options.runId ?? randomUUID();
-		const createdAtMs = Date.now();
-		let eventQueue = Promise.resolve();
-		const progressRecorders = /* @__PURE__ */ new Map();
-		const run = {
-			id: runId,
-			definitionId: definition.id,
-			definitionVersion: definition.version,
-			title: `${definition.title} replay`,
-			goal: options.goal ?? definition.description,
-			input: options.input ?? {},
-			status: "queued",
-			source: options.source,
-			metadata: options.metadata,
-			metrics: {
-				agentCount: 0,
-				doneAgentCount: 0,
-				errorAgentCount: 0,
-				skippedAgentCount: 0,
-				artifactCount: 0
-			},
-			createdAtMs
-		};
-		const appendEvent = (type, payload, createdAtMsOverride) => {
-			eventQueue = eventQueue.then(() => this.options.eventStore.append({
-				runId,
-				type,
-				payload,
-				createdAtMs: createdAtMsOverride
-			})).then(async (event) => {
-				this.options.onEventAppended?.(event);
-				const view = await this.options.runStore.rebuildRunView(runId);
-				if (view) this.options.onRunViewUpdated?.(view);
-			});
-			return eventQueue;
-		};
-		await appendEvent("run_queued", { run }, createdAtMs);
-		await this.callHooks((hook) => hook.beforeRun?.({
-			definition,
-			run
-		}));
-		await appendEvent("run_started", { startedAtMs: Date.now() });
-		try {
-			const result = await withWorkflowTimeout(this.runReplayTargets({
-				definition,
-				runId,
-				targets: options.targets,
-				signal: options.signal,
-				appendEvent,
-				progressRecorders
-			}), options.timeoutSec ?? definition.defaults.timeoutSec);
-			await eventQueue;
-			if (result.errors.length > 0) {
-				await appendEvent("run_failed", { error: {
-					code: "runtime_error",
-					message: `Replay completed with ${result.errors.length} failed target${result.errors.length === 1 ? "" : "s"}.`,
-					detail: result.errors.join("\n"),
-					recoverable: true
-				} });
-				await this.callHooks((hook) => hook.afterRun?.({
-					runId,
-					status: "failed"
-				}));
-			} else {
-				await appendEvent("run_completed", { result: buildReplayResultEnvelope(options, result.results) });
-				await this.callHooks((hook) => hook.afterRun?.({
-					runId,
-					status: "succeeded"
-				}));
-			}
-		} catch (err) {
-			await eventQueue;
-			const error = toWorkflowRunError(err, options.signal?.aborted === true, options.signal?.reason);
-			if (error.code === "cancelled") {
-				await appendEvent("run_cancelled", { reason: error.message });
-				await this.callHooks((hook) => hook.afterRun?.({
-					runId,
-					status: "cancelled"
-				}));
-			} else {
-				await appendEvent("run_failed", { error });
-				await this.callHooks((hook) => hook.afterRun?.({
-					runId,
-					status: "failed"
-				}));
-			}
-		}
-		const view = await this.options.runStore.readRunView(runId);
-		if (!view) throw new Error(`workflow replay run view was not created for ${runId}`);
-		return view;
-	}
-	async runReplayTargets(params) {
-		const results = [];
-		const errors = [];
-		const targetsByPhase = groupReplayTargetsByPhase(params.targets);
-		for (const group of targetsByPhase) {
-			throwIfSignalAborted(params.signal);
-			if (group.phaseId && group.phaseTitle) await params.appendEvent("phase_started", {
-				phaseId: group.phaseId,
-				title: group.phaseTitle
-			});
-			const phaseResults = await Promise.all(group.targets.map((target) => this.runReplayTarget({
-				...params,
-				target
-			})));
-			results.push(...phaseResults);
-			errors.push(...phaseResults.filter((item) => item.status === "error").map((item) => `${item.label}: ${item.error ?? "failed"}`));
-			if (group.phaseId && phaseResults.every((item) => item.status === "done")) await params.appendEvent("phase_completed", { phaseId: group.phaseId });
-		}
-		return {
-			results,
-			errors
-		};
-	}
-	async runReplayTarget(params) {
-		const { target } = params;
-		const invocation = normalizeReplayInvocation(target);
-		const conversationId = this.options.subagentConversationIdFactory?.({
-			runId: params.runId,
-			agentId: target.agentId
-		}) ?? randomUUID();
-		await this.callHooks((hook) => hook.beforeAgent?.({
-			runId: params.runId,
-			agentId: target.agentId,
-			label: invocation.label,
-			phaseId: target.phaseId,
-			prompt: invocation.prompt
-		}));
-		await params.appendEvent("agent_queued", {
-			agentId: target.agentId,
-			label: invocation.label,
-			phaseId: target.phaseId,
-			prompt: invocation.prompt,
-			conversationId,
-			invocation
-		});
-		await params.appendEvent("agent_started", { agentId: target.agentId });
-		const recorder = new AgentProgressRecorder({
-			agentId: target.agentId,
-			appendEvent: params.appendEvent
-		});
-		params.progressRecorders.set(target.agentId, recorder);
-		try {
-			throwIfSignalAborted(params.signal);
-			const model = resolveReplayModel(invocation, this.options.resolveModelId);
-			const result = await this.options.runner.run(invocation.prompt, {
-				label: invocation.label,
-				schema: invocation.schema,
-				allowedToolNames: invocation.toolset,
-				maxIterations: invocation.maxIterations,
-				phase: invocation.phase ?? target.phaseTitle,
-				signal: params.signal,
-				model,
-				conversationId,
-				sessionMetadata: {
-					parentConversationId: this.options.parentConversationId,
-					projectId: this.options.projectId,
-					workflowRunId: params.runId,
-					workflowDefinitionId: params.definition.id,
-					workflowAgentId: target.agentId,
-					workflowAgentLabel: invocation.label
-				},
-				instructions: this.options.contextInstructions,
-				onProgress: (event) => recorder.onProgress(event)
-			});
-			throwIfSignalAborted(params.signal);
-			const status = result === null ? "error" : "done";
-			const resultPreview = previewWorkflowValue(result);
-			recorder.completeOpenSteps(status === "done" ? "done" : "error");
-			await params.appendEvent("agent_completed", {
-				agentId: target.agentId,
-				status,
-				resultPreview,
-				error: status === "error" ? "Replay target failed" : void 0
-			});
-			await this.callHooks((hook) => hook.afterAgent?.({
-				runId: params.runId,
-				agentId: target.agentId,
-				status,
-				resultPreview
-			}));
-			return {
-				agentId: target.agentId,
-				label: invocation.label,
-				phaseId: target.phaseId,
-				status,
-				resultPreview
-			};
-		} catch (err) {
-			if (params.signal?.aborted) throw err;
-			const message = err instanceof Error ? err.message : String(err);
-			recorder.completeOpenSteps("error");
-			await params.appendEvent("agent_completed", {
-				agentId: target.agentId,
-				status: "error",
-				error: message
-			});
-			await this.callHooks((hook) => hook.afterAgent?.({
-				runId: params.runId,
-				agentId: target.agentId,
-				status: "error"
-			}));
-			return {
-				agentId: target.agentId,
-				label: invocation.label,
-				phaseId: target.phaseId,
-				status: "error",
-				error: message
-			};
-		} finally {
-			params.progressRecorders.delete(target.agentId);
-		}
-	}
-	async completeOutstandingRuntimeAgents(params) {
-		for (const [id, currentStatus] of params.statuses) {
-			if (currentStatus !== "queued" && currentStatus !== "running") continue;
-			params.statuses.set(id, params.status);
-			params.progressRecorders.get(id)?.completeOpenSteps(params.status === "done" ? "done" : "error");
-			params.progressRecorders.delete(id);
-			const agentId = formatRuntimeAgentId(id);
-			await params.appendEvent("agent_completed", {
-				agentId,
-				status: params.status,
-				error: params.error
-			});
-			await this.callHooks((hook) => hook.afterAgent?.({
-				runId: params.runId,
-				agentId,
-				status: params.status
-			}));
-		}
-	}
-	async callHooks(call) {
-		for (const hook of this.options.hooks ?? []) try {
-			await call(hook);
-		} catch {}
-	}
-};
-var WorkflowEngineRunError = class extends Error {
-	constructor(code, message, recoverable, detail) {
-		super(message);
-		this.code = code;
-		this.recoverable = recoverable;
-		this.detail = detail;
-		this.name = "WorkflowEngineRunError";
-	}
-};
-var AgentProgressRecorder = class {
-	activeToolStepIds = /* @__PURE__ */ new Map();
-	activeIterationStepId = null;
-	activeThinkingStepId = null;
-	activeLlmStepId = null;
-	sequence = 0;
-	constructor(options) {
-		this.options = options;
-	}
-	onProgress(event) {
-		switch (event.type) {
-			case "tool_start":
-				this.startToolStep(event);
-				return;
-			case "tool_end":
-				this.completeToolStep(event);
-				return;
-			case "iteration":
-				this.replaceSingletonStep("iteration", this.buildIterationLabel(event.count, event.max), "llm");
-				return;
-			case "thinking_delta":
-				this.ensureSingletonStep("thinking", "Thinking", "thinking");
-				return;
-			case "text_delta":
-				this.ensureSingletonStep("llm", "Writing response", "llm");
-				return;
-			default: return;
-		}
-	}
-	completeOpenSteps(status) {
-		for (const stepId of this.activeToolStepIds.values()) this.options.appendEvent("agent_step_completed", {
-			agentId: this.options.agentId,
-			stepId,
-			status
-		});
-		this.activeToolStepIds.clear();
-		this.completeSingletonStep("iteration", status);
-		this.completeSingletonStep("thinking", status);
-		this.completeSingletonStep("llm", status);
-	}
-	startToolStep(event) {
-		const stepId = this.nextStepId("tool");
-		const { label, detail } = workflowStepLabel(event.toolName, event.args);
-		this.activeToolStepIds.set(event.toolCallId, stepId);
-		this.options.appendEvent("agent_step_started", {
-			agentId: this.options.agentId,
-			stepId,
-			label,
-			kind: "tool",
-			toolName: event.toolName,
-			detail: detail ?? previewWorkflowValue(event.args)
-		});
-	}
-	completeToolStep(event) {
-		const stepId = this.activeToolStepIds.get(event.toolCallId);
-		if (!stepId) return;
-		this.activeToolStepIds.delete(event.toolCallId);
-		this.options.appendEvent("agent_step_completed", {
-			agentId: this.options.agentId,
-			stepId,
-			status: event.isError ? "error" : "done",
-			resultPreview: event.resultPreview,
-			error: event.error
-		});
-	}
-	replaceSingletonStep(slot, label, kind) {
-		this.completeSingletonStep(slot, "done");
-		this.ensureSingletonStep(slot, label, kind);
-	}
-	ensureSingletonStep(slot, label, kind) {
-		if (this.getSingletonStepId(slot)) return;
-		const stepId = this.nextStepId(slot);
-		this.setSingletonStepId(slot, stepId);
-		this.options.appendEvent("agent_step_started", {
-			agentId: this.options.agentId,
-			stepId,
-			label,
-			kind
-		});
-	}
-	completeSingletonStep(slot, status) {
-		const stepId = this.getSingletonStepId(slot);
-		if (!stepId) return;
-		this.setSingletonStepId(slot, null);
-		this.options.appendEvent("agent_step_completed", {
-			agentId: this.options.agentId,
-			stepId,
-			status
-		});
-	}
-	getSingletonStepId(slot) {
-		if (slot === "iteration") return this.activeIterationStepId;
-		if (slot === "thinking") return this.activeThinkingStepId;
-		return this.activeLlmStepId;
-	}
-	setSingletonStepId(slot, stepId) {
-		if (slot === "iteration") {
-			this.activeIterationStepId = stepId;
-			return;
-		}
-		if (slot === "thinking") {
-			this.activeThinkingStepId = stepId;
-			return;
-		}
-		this.activeLlmStepId = stepId;
-	}
-	buildIterationLabel(count, max) {
-		if (max > 0) return `Iteration ${count}/${max}`;
-		return `Iteration ${count}`;
-	}
-	nextStepId(kind) {
-		this.sequence += 1;
-		return `${this.options.agentId}-${kind}-${this.sequence}`;
-	}
-};
-function buildPhaseTitleToId(definition) {
-	const phaseTitleToId = /* @__PURE__ */ new Map();
-	for (const phase of definition.phases) phaseTitleToId.set(phase.title, phase.id);
-	return phaseTitleToId;
-}
-function normalizePhaseId(title) {
-	return title.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "phase";
-}
-function withWorkflowTimeout(promise, timeoutSec) {
-	if (typeof timeoutSec !== "number" || !Number.isFinite(timeoutSec) || timeoutSec <= 0) return promise;
-	let timeout;
-	const timeoutPromise = new Promise((_resolve, reject) => {
-		timeout = setTimeout(() => {
-			reject(/* @__PURE__ */ new Error(`workflow timed out after ${timeoutSec}s`));
-		}, timeoutSec * 1e3);
-	});
-	return Promise.race([promise, timeoutPromise]).finally(() => {
-		if (timeout) clearTimeout(timeout);
-	});
-}
-function throwIfSignalAborted(signal) {
-	if (!signal?.aborted) return;
-	const reason = signal.reason;
-	if (reason instanceof Error) throw reason;
-	if (reason) throw new Error(String(reason));
-	throw new Error("workflow aborted");
-}
-function groupReplayTargetsByPhase(targets) {
-	const groups = [];
-	for (const target of targets) {
-		const key = target.phaseId ?? "";
-		let group = groups.find((item) => item.key === key);
-		if (!group) {
-			group = {
-				key,
-				phaseId: target.phaseId,
-				phaseTitle: target.phaseTitle,
-				targets: []
-			};
-			groups.push(group);
-		}
-		group.targets.push(target);
-	}
-	return groups.map(({ key: _key, ...group }) => group);
-}
-function buildReplayResultEnvelope(options, results) {
-	return {
-		summary: `Replay completed for ${results.filter((item) => item.status === "done").length}/${results.length} target${results.length === 1 ? "" : "s"}.`,
-		data: { replay: {
-			sourceRunId: options.sourceRunId,
-			scope: options.replayScope,
-			targets: results
-		} }
-	};
-}
-function normalizeReplayInvocation(target) {
-	return {
-		prompt: target.invocation?.prompt ?? target.prompt,
-		label: target.invocation?.label ?? target.label,
-		phase: target.invocation?.phase ?? target.phaseTitle,
-		modelRef: target.invocation?.modelRef,
-		resolvedModelRef: target.invocation?.resolvedModelRef,
-		schema: target.invocation?.schema,
-		toolset: target.invocation?.toolset ? [...target.invocation.toolset] : void 0,
-		maxIterations: target.invocation?.maxIterations
-	};
-}
-function resolveReplayModel(invocation, resolveModelId) {
-	const modelRef = invocation.resolvedModelRef ?? invocation.modelRef;
-	if (!modelRef) return void 0;
-	if (!resolveModelId) throw new Error(`workflow replay missing resolveModelId; cannot resolve model '${modelRef}'`);
-	return resolveModelId(modelRef);
-}
-function formatRuntimeAgentId(id) {
-	return `agent-${id}`;
-}
-function normalizeCompletedAgentStatus(status) {
-	if (status === "done" || status === "error" || status === "skipped") return status;
-	return "error";
-}
-function previewWorkflowValue(value) {
-	if (value === null || value === void 0) return;
-	if (typeof value === "string") return truncate(value, 300);
-	if (isWorkflowResultEnvelope(value)) return truncate(value.summary, 1200);
-	try {
-		return truncate(JSON.stringify(value), 300);
-	} catch {
-		return truncate(String(value), 300);
-	}
-}
-function truncate(value, maxLength) {
-	const trimmed = value.trim();
-	if (trimmed.length <= maxLength) return trimmed;
-	return `${trimmed.slice(0, maxLength - 1)}…`;
-}
-function assertWorkflowOutput(definition, value) {
-	const validation = validateWorkflowJsonSchema(definition.outputSchema, value);
-	if (validation.ok) return;
-	throw new WorkflowEngineRunError("result_validation_failed", validation.message ?? "Workflow result did not match output schema", false, JSON.stringify(validation.errors ?? []));
-}
-function isWorkflowResultEnvelope(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	return typeof value.summary === "string";
-}
-function requireWorkflowResultEnvelope(value) {
-	if (isWorkflowResultEnvelope(value)) return value;
-	throw new WorkflowEngineRunError("result_validation_failed", "Workflow output node must return a result envelope with summary.", false);
-}
-function toWorkflowRunError(err, wasAborted, abortReason) {
-	if (err instanceof WorkflowEngineRunError) return {
-		code: err.code,
-		message: err.message,
-		detail: err.detail,
-		recoverable: err.recoverable
-	};
-	const message = (abortReason instanceof Error ? abortReason.message : abortReason ? String(abortReason) : "") || (err instanceof Error ? err.message : String(err));
-	if (/timeout|timed out/i.test(message)) return {
-		code: "timeout",
-		message,
-		recoverable: true
-	};
-	if (wasAborted || /aborted|cancelled/i.test(message)) return {
-		code: "cancelled",
-		message: message || "Workflow run cancelled",
-		recoverable: true
-	};
-	if (/quota/i.test(message)) return {
-		code: "agent_quota_exceeded",
-		message,
-		recoverable: true
-	};
-	return {
-		code: "runtime_error",
-		message,
-		recoverable: false
-	};
-}
-//#endregion
-export { WorkflowEngine };