agent-worker 0.17.0 → 0.19.0

package/dist/runner-BmT0Y8MD.mjs

@@ -1,690 +0,0 @@
-import "./backends-D7DT0uox.mjs";
-import "./create-tool-gcUuI1FD.mjs";
-import { D as FileContextProvider, E as runWithHttp, O as createFileContextProvider, Y as createContextMCPServer, i as createSilentLogger, n as createWiredLoop, nt as EventLog, r as createChannelLogger, s as checkWorkflowIdle } from "./cli/index.mjs";
-import { n as createMemoryContextProvider } from "./memory-provider-Z9D8NdwS.mjs";
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import stringWidth from "string-width";
-import chalk from "chalk";
-import wrapAnsi from "wrap-ansi";
-
-//#region src/workflow/interpolate.ts
-const VARIABLE_PATTERN = /\$\{\{\s*([^}]+)\s*\}\}/g;
-/**
-* Interpolate variables in a template string
-* @param warn Optional callback for unresolved variables
-*/
-function interpolate(template, context, warn) {
-	return template.replace(VARIABLE_PATTERN, (match, expression) => {
-		const value = resolveExpression(expression.trim(), context);
-		if (value === void 0 && warn) warn("Unresolved variable: ${{ " + expression.trim() + " }} — no setup task defines it");
-		return value ?? match;
-	});
-}
-/**
-* Resolve a variable expression
-*/
-function resolveExpression(expression, context) {
-	if (expression.startsWith("env.")) {
-		const varName = expression.slice(4);
-		return context.env?.[varName] ?? process.env[varName];
-	}
-	if (expression.startsWith("params.")) {
-		const paramName = expression.slice(7);
-		return context.params?.[paramName];
-	}
-	if (expression.startsWith("workflow.")) {
-		const field = expression.slice(9);
-		if (field === "name") return context.workflow?.name;
-		if (field === "tag") return context.workflow?.tag;
-		return;
-	}
-	if (expression.startsWith("source.")) {
-		if (expression.slice(7) === "dir") return context.source?.dir;
-		return;
-	}
-	const value = context[expression];
-	return typeof value === "string" ? value : void 0;
-}
-/**
-* Create a context from workflow metadata
-*/
-function createContext(workflowName, tag, taskOutputs = {}, params, sourceDir) {
-	return {
-		...taskOutputs,
-		env: process.env,
-		workflow: {
-			name: workflowName,
-			tag
-		},
-		params,
-		source: sourceDir ? { dir: sourceDir } : void 0
-	};
-}
-
-//#endregion
-//#region src/workflow/layout.ts
-/**
-* Adaptive Terminal Layout System
-*
-* Best practices implementation:
-* - Terminal-aware: Auto-detect width and adapt layout
-* - Smart wrapping: Preserve readability on long messages
-* - Background-agnostic: Colors work on any terminal theme
-* - Human-first: Optimize for visual clarity and scanning
-*
-* References:
-* - https://clig.dev/
-* - https://relay.sh/blog/command-line-ux-in-2020/
-*/
-/**
-* Calculate optimal layout based on terminal size and agent names
-*
-* Layout structure: TIME NAME SEP CONTENT
-* Example: "47:08 student │ Message here"
-*          └──┬─┘ └───┬──┘ │ └─────┬──────┘
-*             5      8     3     remaining
-*/
-function calculateLayout(options) {
-	const { agentNames, compact = false } = options;
-	const terminalWidth = options.terminalWidth ?? process.stdout.columns ?? 80;
-	const compactTime = compact || isShortSession();
-	const timeWidth = compactTime ? 5 : 8;
-	const longestName = Math.max(...agentNames.map((n) => stringWidth(n)), 6);
-	const nameWidth = Math.min(longestName + 1, 20);
-	const separatorWidth = 3;
-	const availableWidth = terminalWidth - (timeWidth + 1 + nameWidth + 1 + separatorWidth);
-	const requestedMaxContent = options.maxContentWidth ?? 80;
-	return {
-		terminalWidth,
-		timeWidth,
-		nameWidth,
-		maxContentWidth: Math.max(Math.min(requestedMaxContent, availableWidth), 40),
-		compactTime,
-		separatorWidth
-	};
-}
-/**
-* Detect if session is likely short (< 1 hour) based on current time
-* Heuristic: if it's early in the day, likely a short session
-*/
-function isShortSession() {
-	return false;
-}
-let lastTimestamp = null;
-/**
-* Format timestamp according to layout config
-*/
-function formatTime(timestamp, layout) {
-	const date = new Date(timestamp);
-	const current = {
-		hour: date.getHours(),
-		minute: date.getMinutes(),
-		second: date.getSeconds()
-	};
-	const last = lastTimestamp ? {
-		hour: lastTimestamp.getHours(),
-		minute: lastTimestamp.getMinutes()
-	} : null;
-	const hourChanged = !last || last.hour !== current.hour;
-	const minuteChanged = !last || last.minute !== current.minute;
-	lastTimestamp = date;
-	return {
-		formatted: layout.compactTime ? `${pad(current.minute)}:${pad(current.second)}` : `${pad(current.hour)}:${pad(current.minute)}:${pad(current.second)}`,
-		hourChanged,
-		minuteChanged
-	};
-}
-/**
-* Reset time tracking (call when starting new workflow)
-*/
-function resetTimeTracking() {
-	lastTimestamp = null;
-}
-function pad(num) {
-	return num.toString().padStart(2, "0");
-}
-function createGroupingState() {
-	return {
-		lastAgent: null,
-		lastMinute: null,
-		messageCount: 0
-	};
-}
-/**
-* Check if message should be grouped with previous one
-* Groups consecutive messages from same agent within same minute
-*/
-function shouldGroup(agent, timestamp, state, enableGrouping) {
-	if (!enableGrouping) return false;
-	const date = new Date(timestamp);
-	const minute = date.getHours() * 60 + date.getMinutes();
-	const isSameAgent = agent === state.lastAgent;
-	const isSameMinute = minute === state.lastMinute;
-	state.lastAgent = agent;
-	state.lastMinute = minute;
-	state.messageCount++;
-	return isSameAgent && isSameMinute && state.messageCount > 1;
-}
-
-//#endregion
-//#region src/workflow/layout-log.ts
-/**
-* Log-oriented layout strategies
-*
-* Optimized for workflow logs where readability > strict alignment
-* Provides alternative formatting styles for different use cases
-*/
-/**
-* Timeline style: Time with colored dot indicator for each agent
-*
-* Example:
-* 01:17:13 ● workflow
-*          │ Running workflow: test-simple with a very long message
-*          │ that wraps to the next line automatically
-* 01:17:20 ● alice
-*          │ @bob What are AI agents?
-* 01:17:25 ● bob
-*          │ @alice AI agents are autonomous software entities
-*/
-function formatTimelineLog(entry, layout, showTime = true) {
-	const time = formatTime(entry.timestamp, layout).formatted;
-	const timeStr = showTime ? chalk.dim(time) : " ".repeat(layout.timeWidth);
-	const agentColors = [
-		chalk.cyan,
-		chalk.yellow,
-		chalk.magenta,
-		chalk.green,
-		chalk.blue,
-		chalk.redBright
-	];
-	let dotColor;
-	if (entry.from === "workflow" || entry.from === "system") dotColor = agentColors[0];
-	else dotColor = agentColors[entry.from.split("").reduce((acc, c) => acc + c.charCodeAt(0), 0) % (agentColors.length - 1) + 1];
-	const dot = dotColor("●");
-	const separator = chalk.dim("│");
-	const prefixWidth = layout.timeWidth + 3;
-	const contentWidth = Math.min(layout.terminalWidth - prefixWidth - 3, 80);
-	const wrappedLines = wrapAnsi(entry.content, contentWidth, {
-		hard: true,
-		trim: false
-	}).split("\n");
-	const result = [];
-	result.push(`${timeStr} ${dot} ${chalk.bold(entry.from)}`);
-	const indent = " ".repeat(layout.timeWidth + 1) + `${separator} `;
-	result.push(...wrappedLines.map((line) => indent + line));
-	return result.join("\n");
-}
-/**
-* Standard log format: Minimal colors for TTY, plain text for pipes
-*
-* Format: TIMESTAMP SOURCE: MESSAGE
-* Example: 2026-02-09T01:17:13Z workflow: Running workflow: test
-*
-* TTY Mode (terminal):
-* - Dim timestamps for less visual weight
-* - Cyan source names for quick scanning
-* - Yellow [WARN] for warnings
-* - Red [ERROR] for errors
-*
-* Pipe Mode (file/grep):
-* - No colors (chalk auto-detects non-TTY)
-* - Pure text for maximum compatibility
-*
-* Designed for --debug mode, CI/CD logs, and piping to other tools
-*/
-function formatStandardLog(entry, includeMillis = false) {
-	const timestamp = includeMillis ? entry.timestamp : entry.timestamp.split(".")[0] + "Z";
-	const lines = entry.content.split("\n");
-	const isWarn = entry.content.includes("[WARN]");
-	const isError = entry.content.includes("[ERROR]");
-	let contentColor = (s) => s;
-	if (isWarn) contentColor = chalk.yellow;
-	if (isError) contentColor = chalk.red;
-	const result = [`${chalk.dim(timestamp)} ${chalk.cyan(entry.from)}: ${contentColor(lines[0])}`];
-	if (lines.length > 1) {
-		const indent = " ".repeat(timestamp.length + 1 + entry.from.length + 2);
-		result.push(...lines.slice(1).map((line) => indent + contentColor(line)));
-	}
-	return result.join("\n");
-}
-
-//#endregion
-//#region src/workflow/display.ts
-/**
-* Create display context for a workflow
-*/
-function createDisplayContext(agentNames, options) {
-	return {
-		layout: calculateLayout({ agentNames }),
-		grouping: createGroupingState(),
-		agentNames,
-		enableGrouping: options?.enableGrouping ?? true,
-		debugMode: options?.debugMode ?? false
-	};
-}
-function sleep$1(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
-* Format a channel entry for display
-*
-* Two modes:
-* - Normal mode: Timeline-style layout for visual clarity
-* - Debug mode: Standard log format (timestamp source: message)
-*/
-function formatChannelEntry(entry, context) {
-	if (context.debugMode) return formatStandardLog(entry, false);
-	const isFirstMessage = !shouldGroup(entry.from, entry.timestamp, context.grouping, false);
-	return formatTimelineLog(entry, context.layout, isFirstMessage);
-}
-/**
-* Start watching channel and displaying new entries
-* with adaptive layout and smart formatting
-*/
-function startChannelWatcher(config) {
-	const { contextProvider, agentNames, log, showDebug = false, pollInterval = 500, enableGrouping = true } = config;
-	resetTimeTracking();
-	const context = createDisplayContext(agentNames, {
-		enableGrouping: !showDebug && enableGrouping,
-		debugMode: showDebug
-	});
-	let cursor = config.initialCursor ?? 0;
-	let running = true;
-	const poll = async () => {
-		while (running) {
-			try {
-				const tail = await contextProvider.tailChannel(cursor);
-				for (const entry of tail.entries) {
-					if (entry.kind === "debug" && !showDebug) continue;
-					log(formatChannelEntry(entry, context));
-				}
-				cursor = tail.cursor;
-			} catch {}
-			await sleep$1(pollInterval);
-		}
-	};
-	poll();
-	return { stop: () => {
-		running = false;
-	} };
-}
-
-//#endregion
-//#region src/workflow/runner.ts
-/**
-* Workflow Runner
-*
-* All output flows through the channel:
-* - Operational events (init, setup, connect) → kind="system" (always visible)
-* - Debug details (MCP traces, idle checks) → kind="debug" (visible with --debug)
-* - Agent messages → kind="message" or undefined (always visible)
-* - Tool calls → kind="tool_call" with structured metadata
-* - Backend text output → kind="output" (always visible)
-*
-* The display layer (display.ts) handles filtering and formatting.
-*/
-const execAsync = promisify(exec);
-/**
-* Create context provider and resolve context directory from workflow config.
-* Extracted so the channel logger can be created before full init.
-*/
-function createWorkflowProvider(workflow, _workflowName, tag) {
-	const agentNames = Object.keys(workflow.agents);
-	if (!workflow.context) throw new Error("Workflow context is disabled. Remove \"context: false\" to enable agent collaboration.");
-	const resolvedContext = workflow.context;
-	if (resolvedContext.provider === "memory") return {
-		contextProvider: createMemoryContextProvider(agentNames),
-		contextDir: join(tmpdir(), `agent-worker-${workflow.name}-${tag}`),
-		persistent: false
-	};
-	const fileContext = resolvedContext;
-	const contextDir = fileContext.dir;
-	const persistent = fileContext.persistent === true;
-	if (!existsSync(contextDir)) mkdirSync(contextDir, { recursive: true });
-	const fileProvider = createFileContextProvider(contextDir, agentNames);
-	fileProvider.acquireLock();
-	return {
-		contextProvider: fileProvider,
-		contextDir,
-		persistent
-	};
-}
-/**
-* Initialize workflow runtime
-*
-* This sets up:
-* 1. Context provider (file or memory) — or uses pre-created one
-* 2. Context directory (for file provider)
-* 3. MCP server (HTTP)
-* 4. Runs setup commands
-*/
-async function initWorkflow(config) {
-	const { workflow, workflowName: workflowNameParam, tag: tagParam, onMention, debugLog, feedback: feedbackEnabled, params: paramValues } = config;
-	const workflowName = workflowNameParam ?? "global";
-	const tag = tagParam ?? "main";
-	const logger = config.logger ?? createSilentLogger();
-	const startTime = Date.now();
-	const agentNames = Object.keys(workflow.agents);
-	let contextProvider;
-	let contextDir;
-	let isPersistent = false;
-	if (config.contextProvider && config.contextDir) {
-		contextProvider = config.contextProvider;
-		contextDir = config.contextDir;
-		isPersistent = config.persistent ?? false;
-		logger.debug("Using pre-created context provider");
-	} else {
-		const created = createWorkflowProvider(workflow, workflowName, tag);
-		contextProvider = created.contextProvider;
-		contextDir = created.contextDir;
-		isPersistent = created.persistent;
-		const mode = isPersistent ? "persistent (bind)" : "ephemeral";
-		logger.debug(`Context directory: ${contextDir} [${mode}]`);
-		await contextProvider.markRunStart();
-	}
-	const projectDir = process.cwd();
-	let mcpGetFeedback;
-	let mcpToolNames = /* @__PURE__ */ new Set();
-	const eventLog = new EventLog(contextProvider);
-	const createMCPServerInstance = () => {
-		const mcp = createContextMCPServer({
-			provider: contextProvider,
-			validAgents: agentNames,
-			name: `${workflow.name}-context`,
-			version: "1.0.0",
-			onMention,
-			feedback: feedbackEnabled,
-			debugLog
-		});
-		mcpGetFeedback = mcp.getFeedback;
-		mcpToolNames = mcp.mcpToolNames;
-		return mcp.server;
-	};
-	const httpMcpServer = await runWithHttp({
-		createServerInstance: createMCPServerInstance,
-		port: 0,
-		onConnect: (agentId, sessionId) => {
-			logger.debug(`Agent connected: ${agentId} (${sessionId.slice(0, 8)})`);
-		},
-		onDisconnect: (agentId, sessionId) => {
-			logger.debug(`Agent disconnected: ${agentId} (${sessionId.slice(0, 8)})`);
-		}
-	});
-	logger.debug(`MCP server: ${httpMcpServer.url}`);
-	const setupResults = {};
-	const context = createContext(workflow.name, tag, setupResults, paramValues, workflow.sourceDir);
-	if (workflow.setup && workflow.setup.length > 0) {
-		logger.info("Running setup...");
-		for (const task of workflow.setup) try {
-			const result = await runSetupTask(task, context, logger);
-			if (task.as) {
-				setupResults[task.as] = result;
-				context[task.as] = result;
-			}
-		} catch (error) {
-			if (contextProvider instanceof FileContextProvider) contextProvider.releaseLock();
-			await httpMcpServer.close();
-			throw new Error(`Setup failed: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	const interpolatedKickoff = workflow.kickoff ? interpolate(workflow.kickoff, context, (msg) => logger.warn(msg)) : void 0;
-	const runtime = {
-		name: workflow.name,
-		contextDir,
-		projectDir,
-		contextProvider,
-		eventLog,
-		httpMcpServer,
-		mcpUrl: httpMcpServer.url,
-		agentNames,
-		mcpToolNames,
-		setupResults,
-		async sendKickoff() {
-			if (!interpolatedKickoff) {
-				logger.debug("No kickoff message configured");
-				return;
-			}
-			logger.debug(`Kickoff: ${interpolatedKickoff.slice(0, 100)}...`);
-			await contextProvider.smartSend("system", interpolatedKickoff);
-		},
-		async shutdown() {
-			logger.debug("Shutting down...");
-			if (isPersistent) {
-				if (contextProvider instanceof FileContextProvider) contextProvider.releaseLock();
-			} else await contextProvider.destroy();
-			await httpMcpServer.close();
-		},
-		getFeedback: mcpGetFeedback
-	};
-	logger.debug(`Workflow initialized in ${Date.now() - startTime}ms`);
-	logger.debug(`Agents: ${agentNames.join(", ")}`);
-	return runtime;
-}
-/**
-* Run a setup task
-*/
-async function runSetupTask(task, context, logger) {
-	const command = interpolate(task.shell, context);
-	const displayCmd = command.length > 60 ? command.slice(0, 60) + "..." : command;
-	logger.debug(`  $ ${displayCmd}`);
-	try {
-		const { stdout, stderr } = await execAsync(command);
-		const result = stdout.trim();
-		if (stderr && stderr.trim()) logger.debug(`  stderr: ${stderr.trim().slice(0, 100)}${stderr.length > 100 ? "..." : ""}`);
-		if (task.as) {
-			const displayResult = result.length > 60 ? result.slice(0, 60) + "..." : result;
-			logger.debug(`  ${task.as} = ${displayResult}`);
-		}
-		return result;
-	} catch (error) {
-		throw new Error(`Command failed: ${command}\n${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-/**
-* Run a workflow with agent loops
-*
-* All output flows through the channel. The channel watcher (display layer)
-* filters what to show: --debug includes kind="debug" entries.
-*/
-async function runWorkflowWithLoops(config) {
-	const { workflow, workflowName: workflowNameParam, tag: tagParam, debug = false, log = console.log, mode = "run", pollInterval = 5e3, createBackend, feedback: feedbackEnabled, params: paramValues } = config;
-	const startTime = Date.now();
-	const workflowName = workflowNameParam ?? "global";
-	const tag = tagParam ?? "main";
-	try {
-		const { contextProvider, contextDir, persistent } = createWorkflowProvider(workflow, workflowName, tag);
-		const { cursor: channelStart } = await contextProvider.tailChannel(0);
-		await contextProvider.markRunStart();
-		const logger = createChannelLogger({
-			provider: contextProvider,
-			from: "workflow"
-		});
-		logger.info(`Running workflow: ${workflow.name}`);
-		logger.info(`Agents: ${Object.keys(workflow.agents).join(", ")}`);
-		logger.debug("Starting workflow with loops", {
-			mode,
-			pollInterval
-		});
-		const loops = /* @__PURE__ */ new Map();
-		logger.debug("Initializing workflow runtime...");
-		const runtime = await initWorkflow({
-			workflow,
-			startAgent: async () => {},
-			logger,
-			contextProvider,
-			contextDir,
-			persistent,
-			onMention: (from, target, entry) => {
-				const loop = loops.get(target);
-				if (loop) {
-					const preview = entry.content.length > 80 ? entry.content.slice(0, 80) + "..." : entry.content;
-					logger.debug(`@mention: ${from} → @${target} (state=${loop.state}): ${preview}`);
-					loop.wake();
-				} else logger.debug(`@mention: ${from} → @${target} (no loop found!)`);
-			},
-			debugLog: (msg) => {
-				logger.debug(msg);
-			},
-			feedback: feedbackEnabled,
-			params: paramValues
-		});
-		logger.debug("Runtime initialized", {
-			agentNames: runtime.agentNames,
-			mcpUrl: runtime.mcpUrl
-		});
-		logger.info("Starting agents...");
-		for (const agentName of runtime.agentNames) {
-			const agentDef = workflow.agents[agentName];
-			logger.debug(`Creating loop for ${agentName}`, {
-				backend: agentDef.backend,
-				model: agentDef.model
-			});
-			const { loop, backend } = createWiredLoop({
-				name: agentName,
-				agent: agentDef,
-				runtime,
-				pollInterval,
-				feedback: feedbackEnabled,
-				createBackend,
-				logger: logger.child(agentName)
-			});
-			logger.debug(`Using backend: ${backend.type} for ${agentName}`);
-			loops.set(agentName, loop);
-			await loop.start();
-			logger.debug(`Loop started: ${agentName}`);
-		}
-		logger.debug("Sending kickoff message...");
-		await runtime.sendKickoff();
-		logger.debug("Kickoff sent");
-		let channelWatcher;
-		if (!config.headless) if (config.prettyDisplay) {
-			const { startPrettyDisplay } = await import("./display-pretty-Kyd40DEF.mjs");
-			channelWatcher = startPrettyDisplay({
-				contextProvider: runtime.contextProvider,
-				agentNames: runtime.agentNames,
-				workflowName,
-				tag,
-				workflowPath: config.workflowPath,
-				initialCursor: channelStart,
-				pollInterval: 250
-			});
-		} else channelWatcher = startChannelWatcher({
-			contextProvider: runtime.contextProvider,
-			agentNames: runtime.agentNames,
-			log,
-			showDebug: debug,
-			initialCursor: channelStart,
-			pollInterval: 250
-		});
-		if (mode === "run") {
-			logger.debug("Running in \"run\" mode, waiting for completion...");
-			let idleCheckCount = 0;
-			while (true) {
-				const isIdle = await checkWorkflowIdle(loops, runtime.contextProvider);
-				idleCheckCount++;
-				if (idleCheckCount % 10 === 0) {
-					const states = [...loops.entries()].map(([n, c]) => `${n}=${c.state}`).join(", ");
-					logger.debug(`Idle check #${idleCheckCount}: ${states}`);
-					for (const [agentName] of loops) {
-						const inbox = await runtime.contextProvider.getInbox(agentName);
-						if (inbox.length > 0) {
-							const unseenCount = inbox.filter((m) => !m.seen).length;
-							const seenCount = inbox.filter((m) => m.seen).length;
-							const parts = [];
-							if (seenCount > 0) parts.push(`${seenCount} processing`);
-							if (unseenCount > 0) parts.push(`${unseenCount} unread`);
-							logger.debug(`  ${agentName} inbox: ${parts.join(", ")} from [${inbox.map((m) => m.entry.from).join(", ")}]`);
-						}
-					}
-				}
-				if (isIdle) {
-					const failedAgents = [...loops.entries()].filter(([, loop]) => loop.hasFailures).map(([agentName, loop]) => ({
-						name: agentName,
-						error: loop.lastError
-					}));
-					if (failedAgents.length > 0) {
-						const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
-						const details = failedAgents.map((a) => `${a.name}: ${a.error}`).join("; ");
-						logger.info(`Workflow failed (${elapsed}s): ${details}`);
-						channelWatcher?.stop();
-						await shutdownLoops(loops, logger);
-						await runtime.shutdown();
-						return {
-							success: false,
-							error: details,
-							setupResults: runtime.setupResults,
-							duration: Date.now() - startTime,
-							contextProvider: runtime.contextProvider,
-							feedback: runtime.getFeedback?.()
-						};
-					}
-					const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
-					logger.info(`Workflow complete (${elapsed}s)`);
-					break;
-				}
-				await sleep(1e3);
-			}
-			channelWatcher?.stop();
-			await shutdownLoops(loops, logger);
-			await runtime.shutdown();
-			logger.debug(`Workflow finished in ${Date.now() - startTime}ms`);
-			return {
-				success: true,
-				setupResults: runtime.setupResults,
-				duration: Date.now() - startTime,
-				mcpUrl: runtime.mcpUrl,
-				contextProvider: runtime.contextProvider,
-				feedback: runtime.getFeedback?.()
-			};
-		}
-		logger.debug("Running in \"start\" mode, returning control to caller");
-		return {
-			success: true,
-			setupResults: runtime.setupResults,
-			duration: Date.now() - startTime,
-			mcpUrl: runtime.mcpUrl,
-			contextProvider: runtime.contextProvider,
-			loops,
-			shutdown: async () => {
-				channelWatcher?.stop();
-				await shutdownLoops(loops, logger);
-				await runtime.shutdown();
-			},
-			getFeedback: runtime.getFeedback
-		};
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : String(error);
-		log(`Error: ${errorMsg}`);
-		return {
-			success: false,
-			error: errorMsg,
-			setupResults: {},
-			duration: Date.now() - startTime
-		};
-	}
-}
-/**
-* Gracefully shutdown all loops
-*/
-async function shutdownLoops(loops, logger) {
-	logger.debug("Stopping loops...");
-	const stopPromises = [...loops.values()].map(async (loop) => {
-		await loop.stop();
-		logger.debug(`Stopped loop: ${loop.name}`);
-	});
-	await Promise.all(stopPromises);
-	logger.debug("All loops stopped");
-}
-/**
-* Sleep helper
-*/
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-//#endregion
-export { createWorkflowProvider, initWorkflow, interpolate as n, runWorkflowWithLoops, shutdownLoops, createContext as t };