agent-worker 0.13.0 → 0.15.0

package/dist/workflow-DQ6Eju4n.mjs

@@ -0,0 +1,664 @@
+import "./backends-C7pQwuAx.mjs";
+import "./create-tool-gcUuI1FD.mjs";
+import { a as getBackendByType, b as resolveContextDir, c as createAgentLoop, d as generateWorkflowMCPConfig, f as writeBackendMcpConfig, h as LOOP_DEFAULTS, i as createSilentLogger, k as CONTEXT_DEFAULTS, l as runSdkAgent, m as formatInbox, n as createWiredLoop, o as getBackendForModel, p as buildAgentPrompt, r as createChannelLogger, s as checkWorkflowIdle, t as createMinimalRuntime, u as runMockAgent } from "./cli/index.mjs";
+import "./memory-provider-ZLOKyCxA.mjs";
+import { createWorkflowProvider, initWorkflow, n as interpolate, runWorkflowWithLoops, shutdownLoops, t as createContext } from "./runner-DB-b57iZ.mjs";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { parse } from "yaml";
+import { homedir } from "node:os";
+import { execFileSync } from "node:child_process";
+import { parseArgs } from "node:util";
+
+//#region src/workflow/source.ts
+/**
+* Workflow source resolver — supports local files and remote GitHub references.
+*
+* Formats:
+*   Local:  ./review.yml, /path/to/review.yml, review.yml
+*
+*   Remote (full path):
+*     github:owner/repo@ref/path/file.yml    (pinned to ref)
+*     github:owner/repo/path/file.yml         (default branch: main)
+*
+*   Remote (shorthand — resolves to workflows/<name>.yml):
+*     github:owner/repo@ref#name
+*     github:owner/repo#name
+*
+* The @ref is always on the repo segment (format D), keeping repo+version
+* as a single semantic unit.
+*
+* Remote sources are cloned (shallow) to a local cache directory:
+*   ~/.cache/agent-worker/sources/{owner}/{repo}/{ref}/
+*
+* The `sourceDir` field exposes the repo root, accessible in workflows
+* as ${{ source.dir }}.
+*/
+const GITHUB_PREFIX = "github:";
+const DEFAULT_REF = "main";
+const CACHE_BASE = join(homedir(), ".cache", "agent-worker", "sources");
+/** Check if the input is a remote source reference */
+function isRemoteSource(input) {
+	return input.startsWith(GITHUB_PREFIX);
+}
+/**
+* Resolve a workflow source — local file or remote GitHub reference.
+* Returns a WorkflowSource that can read the YAML and resolve relative files.
+*/
+async function resolveSource(input) {
+	if (isRemoteSource(input)) return resolveGitHubSource(input);
+	return resolveLocalSource(input);
+}
+function resolveLocalSource(filePath) {
+	const absolutePath = resolve(filePath);
+	if (!existsSync(absolutePath)) throw new Error(`Workflow file not found: ${absolutePath}`);
+	const content = readFileSync(absolutePath, "utf-8");
+	const workflowDir = dirname(absolutePath);
+	return {
+		content,
+		displayPath: absolutePath,
+		inferredName: basename(absolutePath, ".yml").replace(".yaml", ""),
+		sourceDir: workflowDir,
+		readRelativeFile: async (relativePath) => {
+			const fullPath = relativePath.startsWith("/") ? relativePath : join(workflowDir, relativePath);
+			if (existsSync(fullPath)) return readFileSync(fullPath, "utf-8");
+			return null;
+		}
+	};
+}
+/**
+* Parse a github: reference string into its components.
+*
+* Supports two formats:
+*   Full path:  github:owner/repo[@ref]/path/to/file.yml
+*   Shorthand:  github:owner/repo[@ref]#name  -> workflows/name.yml
+*/
+function parseGitHubRef(input) {
+	if (!input.startsWith(GITHUB_PREFIX)) throw new Error(`Not a GitHub reference: "${input}"`);
+	const rest = input.slice(7);
+	const hashIdx = rest.indexOf("#");
+	if (hashIdx !== -1) {
+		const repoStr = rest.slice(0, hashIdx);
+		const name = rest.slice(hashIdx + 1);
+		if (!name) throw new Error(`Missing workflow name after '#' in: "${input}"`);
+		const { owner, repo, ref } = parseRepoSegment(repoStr);
+		return {
+			owner,
+			repo,
+			ref,
+			path: `workflows/${name}.yml`
+		};
+	}
+	const firstSlash = rest.indexOf("/");
+	const secondSlash = firstSlash === -1 ? -1 : rest.indexOf("/", firstSlash + 1);
+	if (firstSlash === -1 || secondSlash === -1) throw new Error(`Invalid GitHub reference: "${input}". Expected: github:owner/repo/path or github:owner/repo#name`);
+	const repoStr = rest.slice(0, secondSlash);
+	const path = rest.slice(secondSlash + 1);
+	if (!path) throw new Error(`Missing file path in: "${input}"`);
+	const { owner, repo, ref } = parseRepoSegment(repoStr);
+	return {
+		owner,
+		repo,
+		ref,
+		path
+	};
+}
+/**
+* Validate a git ref (branch, tag, or SHA) to prevent injection.
+* Allows alphanumeric, hyphens, dots, underscores, slashes — the standard git ref charset.
+*/
+function validateGitRef(ref) {
+	if (!/^[a-zA-Z0-9._\-/]+$/.test(ref)) throw new Error(`Invalid git ref: "${ref}". Only alphanumeric, hyphens, dots, underscores, and slashes are allowed.`);
+}
+/** Parse "owner/repo" or "owner/repo@ref" */
+function parseRepoSegment(repoStr) {
+	let ref = DEFAULT_REF;
+	const atIdx = repoStr.indexOf("@");
+	let cleanStr = repoStr;
+	if (atIdx !== -1) {
+		ref = repoStr.slice(atIdx + 1);
+		cleanStr = repoStr.slice(0, atIdx);
+		if (!ref) throw new Error(`Empty ref after '@' in: "${repoStr}"`);
+	}
+	const parts = cleanStr.split("/");
+	if (parts.length !== 2 || !parts[0] || !parts[1]) throw new Error(`Invalid repository format: "${repoStr}". Expected "owner/repo"`);
+	validateGitRef(ref);
+	return {
+		owner: parts[0],
+		repo: parts[1],
+		ref
+	};
+}
+/**
+* Get cache directory for a repo+ref combination.
+*/
+function getCacheDir(ref) {
+	return join(CACHE_BASE, ref.owner, ref.repo, ref.ref);
+}
+/**
+* Build the clone URL. Uses HTTPS; GITHUB_TOKEN auth via git credential helper
+* or the GIT_ASKPASS/GIT_AUTH mechanism handled by git itself.
+*/
+function getCloneUrl(ref) {
+	const token = process.env.GITHUB_TOKEN;
+	if (token) return `https://${token}@github.com/${ref.owner}/${ref.repo}.git`;
+	return `https://github.com/${ref.owner}/${ref.repo}.git`;
+}
+/**
+* Check if a ref looks like a branch/tag name (mutable) vs a commit SHA (immutable).
+* Commit SHAs are 7-40 hex chars.
+*/
+function isImmutableRef(ref) {
+	return /^[0-9a-f]{7,40}$/.test(ref);
+}
+/**
+* Clone or update a remote repo to the cache directory.
+*
+* Strategy:
+* - If cache exists and ref is immutable (SHA): skip, use cached
+* - If cache exists and ref is mutable (branch/tag): git fetch + reset
+* - If cache doesn't exist: shallow clone
+*
+* @returns Absolute path to the cache directory (repo root)
+*/
+function ensureClone(ref) {
+	const cacheDir = getCacheDir(ref);
+	if (existsSync(join(cacheDir, ".git"))) {
+		if (isImmutableRef(ref.ref)) return cacheDir;
+		try {
+			execFileSync("git", [
+				"fetch",
+				"origin",
+				ref.ref,
+				"--depth",
+				"1"
+			], {
+				cwd: cacheDir,
+				stdio: "pipe",
+				timeout: 3e4
+			});
+			execFileSync("git", [
+				"reset",
+				"--hard",
+				"FETCH_HEAD"
+			], {
+				cwd: cacheDir,
+				stdio: "pipe",
+				timeout: 1e4
+			});
+			return cacheDir;
+		} catch {}
+	}
+	mkdirSync(dirname(cacheDir), { recursive: true });
+	if (existsSync(cacheDir)) rmSync(cacheDir, {
+		recursive: true,
+		force: true
+	});
+	const url = getCloneUrl(ref);
+	execFileSync("git", [
+		"clone",
+		"--depth",
+		"1",
+		"--single-branch",
+		"--branch",
+		ref.ref,
+		url,
+		cacheDir
+	], {
+		stdio: "pipe",
+		timeout: 6e4
+	});
+	return cacheDir;
+}
+/** Resolve a github: reference to a WorkflowSource */
+async function resolveGitHubSource(input) {
+	const ref = parseGitHubRef(input);
+	const repoDir = ensureClone(ref);
+	const workflowPath = join(repoDir, ref.path);
+	if (!existsSync(workflowPath)) throw new Error(`Remote workflow not found: ${ref.path}\n  Source: ${input}\n  Parsed: ${ref.owner}/${ref.repo}@${ref.ref} -> ${ref.path}\n  Clone: ${repoDir}`);
+	const content = readFileSync(workflowPath, "utf-8");
+	const workflowDir = dirname(workflowPath);
+	const inferredName = basename(ref.path, ".yml").replace(".yaml", "");
+	return {
+		content,
+		displayPath: `${GITHUB_PREFIX}${ref.owner}/${ref.repo}@${ref.ref}/${ref.path}`,
+		inferredName,
+		sourceDir: repoDir,
+		readRelativeFile: async (relativePath) => {
+			const fullPath = relativePath.startsWith("/") ? relativePath : join(workflowDir, relativePath);
+			if (existsSync(fullPath)) return readFileSync(fullPath, "utf-8");
+			return null;
+		}
+	};
+}
+
+//#endregion
+//#region src/workflow/parser.ts
+/**
+* Workflow file parser
+*/
+/**
+* Parse a workflow file (local or remote).
+*
+* Supports:
+*   Local:  review.yml, ./path/to/review.yml
+*   Remote: github:owner/repo@ref/path/file.yml
+*           github:owner/repo#name[@ref]
+*/
+async function parseWorkflowFile(filePath, options) {
+	const workflow = options?.workflow ?? "global";
+	const tag = options?.tag ?? "main";
+	const source = await resolveSource(filePath);
+	const contextBaseDir = isRemoteSource(filePath) ? process.cwd() : dirname(resolve(filePath));
+	let raw;
+	try {
+		raw = parse(source.content);
+	} catch (error) {
+		throw new Error(`Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const validation = validateWorkflow(raw);
+	if (!validation.valid) {
+		const messages = validation.errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n");
+		throw new Error(`Invalid workflow file:\n${messages}`);
+	}
+	const name = raw.name || source.inferredName;
+	const agents = {};
+	for (const [agentName, agentDef] of Object.entries(raw.agents)) agents[agentName] = await resolveAgent(agentDef, source.readRelativeFile);
+	const context = resolveContext(raw.context, contextBaseDir, name, workflow, tag);
+	return {
+		name,
+		filePath: source.displayPath,
+		sourceDir: source.sourceDir,
+		agents,
+		context,
+		params: raw.params,
+		setup: raw.setup || [],
+		kickoff: raw.kickoff
+	};
+}
+/**
+* Resolve context configuration
+*
+* - undefined (not set): default file provider enabled
+* - null: default file provider enabled (YAML `context:` syntax)
+* - false: explicitly disabled
+* - { provider: 'file', config?: { dir | bind } }: file provider (ephemeral or persistent)
+* - { provider: 'memory' }: memory provider (for testing)
+*/
+function resolveContext(config, workflowDir, workflowName, workflow, tag) {
+	const resolve = (template) => resolveContextDir(template, {
+		workflowName,
+		workflow,
+		tag,
+		baseDir: workflowDir
+	});
+	if (config === false) return;
+	if (config === void 0 || config === null) return {
+		provider: "file",
+		dir: resolve(CONTEXT_DEFAULTS.dir)
+	};
+	if (config.provider === "memory") return {
+		provider: "memory",
+		documentOwner: config.documentOwner
+	};
+	const bindPath = config.config?.bind;
+	if (bindPath) return {
+		provider: "file",
+		dir: resolve(bindPath),
+		persistent: true,
+		documentOwner: config.documentOwner
+	};
+	return {
+		provider: "file",
+		dir: resolve(config.config?.dir || CONTEXT_DEFAULTS.dir),
+		documentOwner: config.documentOwner
+	};
+}
+/**
+* Resolve agent definition (load system prompt from file if needed).
+*
+* Uses a `readRelativeFile` function to abstract local vs remote file access.
+* Also transforms `wakeup` and `wakeup_prompt` fields into a `ScheduleConfig`
+* object, which is the format expected by the daemon and loop layers
+* for setting up periodic wakeup timers.
+*/
+async function resolveAgent(agent, readRelativeFile) {
+	let resolvedSystemPrompt = agent.system_prompt;
+	if (resolvedSystemPrompt?.endsWith(".txt") || resolvedSystemPrompt?.endsWith(".md")) {
+		const content = await readRelativeFile(resolvedSystemPrompt);
+		if (content !== null) resolvedSystemPrompt = content;
+	}
+	let schedule;
+	if (agent.wakeup !== void 0) {
+		schedule = { wakeup: agent.wakeup };
+		if (agent.wakeup_prompt) schedule.prompt = agent.wakeup_prompt;
+	}
+	return {
+		...agent,
+		resolvedSystemPrompt,
+		schedule
+	};
+}
+/**
+* Validate workflow structure
+*/
+function validateWorkflow(workflow) {
+	const errors = [];
+	if (!workflow || typeof workflow !== "object") {
+		errors.push({
+			path: "",
+			message: "Workflow must be an object"
+		});
+		return {
+			valid: false,
+			errors
+		};
+	}
+	const w = workflow;
+	if (!w.agents || typeof w.agents !== "object") errors.push({
+		path: "agents",
+		message: "Required field \"agents\" must be an object"
+	});
+	else {
+		const agents = w.agents;
+		for (const [name, agent] of Object.entries(agents)) validateAgent(name, agent, errors);
+	}
+	if (w.context !== void 0 && w.context !== null && w.context !== false) validateContext(w.context, errors);
+	if (w.params !== void 0) if (!Array.isArray(w.params)) errors.push({
+		path: "params",
+		message: "Params must be an array"
+	});
+	else {
+		const names = /* @__PURE__ */ new Set();
+		const shorts = /* @__PURE__ */ new Set();
+		for (let i = 0; i < w.params.length; i++) validateParam(`params[${i}]`, w.params[i], errors, names, shorts);
+	}
+	if (w.setup !== void 0) if (!Array.isArray(w.setup)) errors.push({
+		path: "setup",
+		message: "Setup must be an array"
+	});
+	else for (let i = 0; i < w.setup.length; i++) validateSetupTask(`setup[${i}]`, w.setup[i], errors);
+	if (w.kickoff !== void 0 && typeof w.kickoff !== "string") errors.push({
+		path: "kickoff",
+		message: "Kickoff must be a string"
+	});
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+function validateContext(context, errors) {
+	if (typeof context !== "object" || context === null) {
+		errors.push({
+			path: "context",
+			message: "Context must be an object or false"
+		});
+		return;
+	}
+	const c = context;
+	if (!c.provider || typeof c.provider !== "string") {
+		errors.push({
+			path: "context.provider",
+			message: "Context requires \"provider\" field (file or memory)"
+		});
+		return;
+	}
+	if (c.provider !== "file" && c.provider !== "memory") {
+		errors.push({
+			path: "context.provider",
+			message: "Context provider must be \"file\" or \"memory\""
+		});
+		return;
+	}
+	if (c.documentOwner !== void 0 && typeof c.documentOwner !== "string") errors.push({
+		path: "context.documentOwner",
+		message: "Context documentOwner must be a string"
+	});
+	if (c.provider === "file" && c.config !== void 0) {
+		if (typeof c.config !== "object" || c.config === null) {
+			errors.push({
+				path: "context.config",
+				message: "Context config must be an object"
+			});
+			return;
+		}
+		const cfg = c.config;
+		if (cfg.dir !== void 0 && cfg.bind !== void 0) {
+			errors.push({
+				path: "context.config",
+				message: "\"dir\" and \"bind\" are mutually exclusive — use one or the other"
+			});
+			return;
+		}
+		if (cfg.dir !== void 0 && typeof cfg.dir !== "string") errors.push({
+			path: "context.config.dir",
+			message: "Context config dir must be a string"
+		});
+		if (cfg.bind !== void 0 && typeof cfg.bind !== "string") errors.push({
+			path: "context.config.bind",
+			message: "Context config bind must be a string path"
+		});
+	}
+}
+const RESERVED_NAMESPACES = [
+	"env",
+	"workflow",
+	"params",
+	"source"
+];
+const VALID_PARAM_TYPES = [
+	"string",
+	"number",
+	"boolean"
+];
+function validateSetupTask(path, task, errors) {
+	if (!task || typeof task !== "object") {
+		errors.push({
+			path,
+			message: "Setup task must be an object"
+		});
+		return;
+	}
+	const t = task;
+	if (!t.shell || typeof t.shell !== "string") errors.push({
+		path: `${path}.shell`,
+		message: "Setup task requires \"shell\" field as string"
+	});
+	if (t.as !== void 0 && typeof t.as !== "string") errors.push({
+		path: `${path}.as`,
+		message: "Setup task \"as\" field must be a string"
+	});
+	if (typeof t.as === "string" && RESERVED_NAMESPACES.includes(t.as)) errors.push({
+		path: `${path}.as`,
+		message: `"${t.as}" is a reserved namespace and cannot be used as a variable name`
+	});
+}
+function validateParam(path, param, errors, names, shorts) {
+	if (!param || typeof param !== "object") {
+		errors.push({
+			path,
+			message: "Param must be an object"
+		});
+		return;
+	}
+	const p = param;
+	if (!p.name || typeof p.name !== "string") {
+		errors.push({
+			path: `${path}.name`,
+			message: "Param requires \"name\" field as string"
+		});
+		return;
+	}
+	if (names.has(p.name)) errors.push({
+		path: `${path}.name`,
+		message: `Duplicate param name: "${p.name}"`
+	});
+	names.add(p.name);
+	if (p.description !== void 0 && typeof p.description !== "string") errors.push({
+		path: `${path}.description`,
+		message: "Param description must be a string"
+	});
+	if (p.type !== void 0) {
+		if (typeof p.type !== "string" || !VALID_PARAM_TYPES.includes(p.type)) errors.push({
+			path: `${path}.type`,
+			message: `Param type must be one of: ${VALID_PARAM_TYPES.join(", ")}`
+		});
+	}
+	if (p.short !== void 0) if (typeof p.short !== "string" || p.short.length !== 1) errors.push({
+		path: `${path}.short`,
+		message: "Param short must be a single character"
+	});
+	else {
+		if (shorts.has(p.short)) errors.push({
+			path: `${path}.short`,
+			message: `Duplicate param short flag: "-${p.short}"`
+		});
+		shorts.add(p.short);
+	}
+	if (p.required !== void 0 && typeof p.required !== "boolean") errors.push({
+		path: `${path}.required`,
+		message: "Param required must be a boolean"
+	});
+}
+/** Backends that don't require an explicit model field */
+const CLI_BACKENDS = [
+	"claude",
+	"cursor",
+	"codex",
+	"opencode",
+	"mock"
+];
+function validateAgent(name, agent, errors) {
+	const path = `agents.${name}`;
+	if (!agent || typeof agent !== "object") {
+		errors.push({
+			path,
+			message: "Agent must be an object"
+		});
+		return;
+	}
+	const a = agent;
+	const backend = typeof a.backend === "string" ? a.backend : "default";
+	if (a.model !== void 0 && typeof a.model !== "string") errors.push({
+		path: `${path}.model`,
+		message: "Field \"model\" must be a string"
+	});
+	else if (!a.model && !CLI_BACKENDS.includes(backend)) errors.push({
+		path: `${path}.model`,
+		message: "Required field \"model\" must be a string (required for default backend)"
+	});
+	if (a.system_prompt !== void 0 && typeof a.system_prompt !== "string") errors.push({
+		path: `${path}.system_prompt`,
+		message: "Optional field \"system_prompt\" must be a string"
+	});
+	if (a.tools !== void 0 && !Array.isArray(a.tools)) errors.push({
+		path: `${path}.tools`,
+		message: "Optional field \"tools\" must be an array"
+	});
+	if (a.wakeup !== void 0) {
+		if (typeof a.wakeup !== "string" && typeof a.wakeup !== "number") errors.push({
+			path: `${path}.wakeup`,
+			message: "Field \"wakeup\" must be a string (duration or cron) or number (ms)"
+		});
+		else if (typeof a.wakeup === "number" && a.wakeup <= 0) errors.push({
+			path: `${path}.wakeup`,
+			message: "Field \"wakeup\" must be a positive number when specified as ms"
+		});
+	}
+	if (a.wakeup_prompt !== void 0) {
+		if (typeof a.wakeup_prompt !== "string") errors.push({
+			path: `${path}.wakeup_prompt`,
+			message: "Field \"wakeup_prompt\" must be a string"
+		});
+		if (a.wakeup === void 0) errors.push({
+			path: `${path}.wakeup_prompt`,
+			message: "Field \"wakeup_prompt\" can only be used when \"wakeup\" is also specified"
+		});
+	}
+	if (a.provider !== void 0) {
+		if (typeof a.provider === "string") {} else if (typeof a.provider === "object" && a.provider !== null && !Array.isArray(a.provider)) {
+			const p = a.provider;
+			if (!p.name || typeof p.name !== "string") errors.push({
+				path: `${path}.provider.name`,
+				message: "Field \"provider.name\" is required and must be a string"
+			});
+			if (p.base_url !== void 0 && typeof p.base_url !== "string") errors.push({
+				path: `${path}.provider.base_url`,
+				message: "Field \"provider.base_url\" must be a string"
+			});
+			if (p.api_key !== void 0 && typeof p.api_key !== "string") errors.push({
+				path: `${path}.provider.api_key`,
+				message: "Field \"provider.api_key\" must be a string"
+			});
+		} else errors.push({
+			path: `${path}.provider`,
+			message: "Field \"provider\" must be a string or object with { name, base_url?, api_key? }"
+		});
+		if (CLI_BACKENDS.includes(backend) && backend !== "mock") errors.push({
+			path: `${path}.provider`,
+			message: `Field "provider" is ignored for CLI backend "${backend}" (only works with default backend)`
+		});
+	}
+}
+/**
+* Parse CLI arguments against workflow param definitions.
+* Uses Node's built-in util.parseArgs().
+*
+* @param defs  Param definitions from workflow YAML
+* @param argv  Raw CLI arguments (everything after the workflow file)
+* @returns     Resolved param values as string map
+* @throws      Error if required params are missing or types are invalid
+*/
+function parseWorkflowParams(defs, argv) {
+	if (defs.length === 0) return {};
+	const options = {};
+	for (const def of defs) {
+		const opt = { type: def.type === "boolean" ? "boolean" : "string" };
+		if (def.short) opt.short = def.short;
+		options[def.name] = opt;
+	}
+	const { values } = parseArgs({
+		args: argv,
+		options,
+		strict: true
+	});
+	const result = {};
+	const missing = [];
+	for (const def of defs) {
+		let raw = values[def.name];
+		if (raw === void 0 && def.default !== void 0) raw = String(def.default);
+		if (raw === void 0) {
+			if (def.required) {
+				const flag = def.short ? `-${def.short}/--${def.name}` : `--${def.name}`;
+				missing.push(flag);
+			}
+			continue;
+		}
+		if (def.type === "number") {
+			const num = Number(raw);
+			if (isNaN(num)) throw new Error(`Parameter --${def.name} must be a number, got: "${raw}"`);
+			result[def.name] = String(num);
+		} else result[def.name] = String(raw);
+	}
+	if (missing.length > 0) throw new Error(`Missing required parameter(s): ${missing.join(", ")}`);
+	return result;
+}
+/**
+* Format parameter help text for workflow params
+*/
+function formatParamHelp(defs) {
+	if (defs.length === 0) return "";
+	const lines = ["", "Workflow parameters:"];
+	for (const def of defs) {
+		const flags = def.short ? `-${def.short}, --${def.name}` : `    --${def.name}`;
+		const type = def.type || "string";
+		const req = def.required ? " (required)" : "";
+		const dflt = def.default !== void 0 ? ` [default: ${def.default}]` : "";
+		const desc = def.description || "";
+		lines.push(`  ${flags} <${type}>  ${desc}${req}${dflt}`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+export { formatParamHelp, parseWorkflowFile, parseWorkflowParams, runWorkflowWithLoops, shutdownLoops };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-worker",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "SDK and CLI for creating and testing agent workers with Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -33,13 +33,13 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
+    "@hono/node-server": "^1.19.9",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ai": "^6.0.69",
     "bash-tool": "^1.3.12",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "execa": "^9.6.1",
-    "@hono/node-server": "^1.19.9",
     "hono": "^4.11.9",
     "just-bash": "^2.8.0",
     "nanoid": "^5.1.6",
@@ -47,7 +47,7 @@
     "string-width": "^8.1.1",
     "wrap-ansi": "^9.0.2",
     "yaml": "^2.7.0",
-    "zod": "^3.24.1"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
@@ -58,6 +58,7 @@
     "@ai-sdk/openai": "^3.0.0",
     "@ai-sdk/xai": "^1.0.0",
     "@types/bun": "latest",
+    "@types/node": ">=22",
     "@typescript/native-preview": "^7.0.0-dev.20260203.1",
     "oxfmt": "^0.28.0",
     "oxlint": "^1.43.0",

package/dist/context-BqEyt2SF.mjs

@@ -1,4 +0,0 @@
-import { C as formatToolParams, S as formatInbox, T as EventLog, _ as shouldUseResource, a as FileStorage, b as formatProposalList, c as CONTEXT_DEFAULTS, d as RESOURCE_PREFIX, f as RESOURCE_SCHEME, g as generateResourceId, h as extractMentions, i as resolveContextDir, l as MENTION_PATTERN, m as createResourceRef, n as createFileContextProvider, o as MemoryStorage, p as calculatePriority, r as getDefaultContextDir, s as ContextProviderImpl, t as FileContextProvider, u as MESSAGE_LENGTH_THRESHOLD, v as createContextMCPServer, w as getAgentId, x as createLogTool, y as formatProposal } from "./cli/index.mjs";
-import { n as createMemoryContextProvider, t as MemoryContextProvider } from "./memory-provider-BtLYtdQH.mjs";
-
-export { createFileContextProvider };