agent-worker 0.4.0 → 0.5.0

package/dist/backends-B8rYTNqn.mjs

@@ -0,0 +1,3 @@
+import { C as getModelForBackend, S as SDK_MODEL_ALIASES, _ as execWithIdleTimeout, a as createMockBackend, b as CODEX_MODEL_MAP, c as CodexBackend, d as codexAdapter, f as createStreamParser, g as IdleTimeoutError, h as formatEvent, i as MockAIBackend, l as ClaudeCodeBackend, m as extractCodexResult, n as createBackend, o as SdkBackend, p as extractClaudeResult, r as listBackends, s as CursorBackend, t as checkBackends, u as claudeAdapter, v as BACKEND_DEFAULT_MODELS, x as CURSOR_MODEL_MAP, y as CLAUDE_MODEL_MAP } from "./backends-CEYiMUgC.mjs";
+
+export { listBackends };

package/dist/{backends-DenGdkrj.mjs → backends-CEYiMUgC.mjs}

@@ -1,5 +1,5 @@
 import { gateway, generateText } from "ai";
-import { ExecaError, execa } from "execa";
+import { execa } from "execa";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { stringify } from "yaml";
@@ -297,6 +297,271 @@ function parseModel(model) {
 	};
 }
 
+//#endregion
+//#region src/backends/idle-timeout.ts
+/**
+* Idle timeout for CLI subprocess execution
+*
+* Unlike a hard timeout (kill after N ms total), an idle timeout only fires
+* when the process produces no stdout/stderr output for the configured duration.
+* This allows long-running agent tasks to continue as long as they're actively
+* producing output (tool calls, analysis, etc.).
+*/
+/**
+* Execute a command with idle timeout.
+*
+* The timeout resets every time the process writes to stdout or stderr.
+* If the process goes silent for longer than `timeout` ms, it's killed.
+*/
+/** Minimum idle timeout to prevent accidental instant kills */
+const MIN_TIMEOUT_MS = 1e3;
+async function execWithIdleTimeout(options) {
+	const { command, args, cwd, onStdout } = options;
+	const timeout = Math.max(options.timeout, MIN_TIMEOUT_MS);
+	let idleTimedOut = false;
+	let timer;
+	let stdout = "";
+	let stderr = "";
+	const subprocess = execa(command, args, {
+		cwd,
+		stdin: "ignore",
+		buffer: false
+	});
+	const resetTimer = () => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			idleTimedOut = true;
+			subprocess.kill();
+		}, timeout);
+	};
+	subprocess.stdout?.on("data", (chunk) => {
+		const text = chunk.toString();
+		stdout += text;
+		if (onStdout) onStdout(text);
+		resetTimer();
+	});
+	subprocess.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+		resetTimer();
+	});
+	resetTimer();
+	try {
+		await subprocess;
+		clearTimeout(timer);
+		return {
+			stdout: stdout.trimEnd(),
+			stderr: stderr.trimEnd()
+		};
+	} catch (error) {
+		clearTimeout(timer);
+		if (idleTimedOut) throw new IdleTimeoutError(timeout, stdout, stderr);
+		throw error;
+	}
+}
+/**
+* Error thrown when a process is killed due to idle timeout
+*/
+var IdleTimeoutError = class extends Error {
+	timeout;
+	stdout;
+	stderr;
+	constructor(timeout, stdout, stderr) {
+		super(`Process idle timed out after ${timeout}ms of inactivity`);
+		this.name = "IdleTimeoutError";
+		this.timeout = timeout;
+		this.stdout = stdout;
+		this.stderr = stderr;
+	}
+};
+
+//#endregion
+//#region src/backends/stream-json.ts
+/**
+* Format a standard StreamEvent into a human-readable progress message.
+* Returns null if the event doesn't need display.
+*
+* This function only knows about StreamEvent — it never touches
+* backend-specific raw JSON. Format-specific conversion is handled
+* by the EventAdapter.
+*/
+function formatEvent(event, backendName) {
+	switch (event.kind) {
+		case "init": {
+			const details = [];
+			if (event.model) details.push(`model: ${event.model}`);
+			if (event.sessionId) details.push(`session: ${event.sessionId}`);
+			return `${backendName} initialized${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
+		}
+		case "tool_call": {
+			const truncated = event.args.length > 100 ? event.args.slice(0, 100) + "..." : event.args;
+			return `CALL ${event.name}(${truncated})`;
+		}
+		case "completed": {
+			const parts = [backendName, "completed"];
+			const details = [];
+			if (event.durationMs) details.push(`${(event.durationMs / 1e3).toFixed(1)}s`);
+			if (event.costUsd) details.push(`$${event.costUsd.toFixed(4)}`);
+			if (event.usage) details.push(`${event.usage.input} in, ${event.usage.output} out`);
+			if (details.length > 0) parts.push(`(${details.join(", ")})`);
+			return parts.join(" ");
+		}
+	}
+}
+/**
+* Adapter for Claude/Cursor stream-json format.
+*
+* Events:
+*   { type: "system", subtype: "init", model: "..." }
+*   { type: "assistant", message: { content: [{ type: "tool_use", name, input }] } }
+*   { type: "result", duration_ms: N, total_cost_usd: N }
+*/
+const claudeAdapter = (raw) => {
+	const type = raw.type;
+	if (type === "system" && raw.subtype === "init") return {
+		kind: "init",
+		model: raw.model || void 0,
+		sessionId: raw.session_id
+	};
+	if (type === "assistant") {
+		const message = raw.message;
+		if (!message?.content) return null;
+		const toolCalls = message.content.filter((c) => c.type === "tool_use");
+		if (toolCalls.length > 0) {
+			const tc = toolCalls[0];
+			return {
+				kind: "tool_call",
+				name: tc.name || "unknown",
+				args: formatToolInput(tc.input)
+			};
+		}
+		return null;
+	}
+	if (type === "result") return {
+		kind: "completed",
+		durationMs: raw.duration_ms,
+		costUsd: raw.total_cost_usd
+	};
+	return null;
+};
+/**
+* Extract final result from Claude/Cursor stream-json output.
+*
+* Priority:
+* 1. type=result with result field
+* 2. Last assistant message with text content
+* 3. Raw stdout fallback
+*/
+function extractClaudeResult(stdout) {
+	const lines = stdout.trim().split("\n");
+	for (let i = lines.length - 1; i >= 0; i--) try {
+		const event = JSON.parse(lines[i]);
+		if (event.type === "result" && event.result) return { content: event.result };
+	} catch {}
+	for (let i = lines.length - 1; i >= 0; i--) try {
+		const event = JSON.parse(lines[i]);
+		if (event.type === "assistant" && event.message?.content) {
+			const textParts = event.message.content.filter((c) => c.type === "text").map((c) => c.text);
+			if (textParts.length > 0) return { content: textParts.join("\n") };
+		}
+	} catch {}
+	return { content: stdout.trim() };
+}
+/**
+* Adapter for Codex --json format.
+*
+* Events:
+*   { type: "thread.started", thread_id: "..." }
+*   { type: "item.completed", item: { type: "function_call", name, arguments } }
+*   { type: "item.completed", item: { type: "agent_message", text } }  → skipped (result only)
+*   { type: "turn.completed", usage: { input_tokens, output_tokens } }
+*/
+const codexAdapter = (raw) => {
+	const type = raw.type;
+	if (type === "thread.started") {
+		const threadId = raw.thread_id;
+		return {
+			kind: "init",
+			sessionId: threadId ? `${threadId.slice(0, 8)}...` : void 0
+		};
+	}
+	if (type === "item.completed") {
+		const item = raw.item;
+		if (!item) return null;
+		if (item.type === "function_call") return {
+			kind: "tool_call",
+			name: item.name || "unknown",
+			args: item.arguments ?? ""
+		};
+		return null;
+	}
+	if (type === "turn.completed") {
+		const usage = raw.usage;
+		return {
+			kind: "completed",
+			usage: usage ? {
+				input: usage.input_tokens ?? 0,
+				output: usage.output_tokens ?? 0
+			} : void 0
+		};
+	}
+	return null;
+};
+/**
+* Extract final result from Codex --json output.
+*
+* Priority:
+* 1. Last item.completed with item.type=agent_message
+* 2. Raw stdout fallback
+*/
+function extractCodexResult(stdout) {
+	const lines = stdout.trim().split("\n");
+	for (let i = lines.length - 1; i >= 0; i--) try {
+		const event = JSON.parse(lines[i]);
+		if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item?.text) return { content: event.item.text };
+	} catch {}
+	return { content: stdout.trim() };
+}
+/**
+* Create a line-buffered stream parser.
+*
+* Accumulates stdout chunks, parses each line through the given adapter,
+* and emits formatted progress messages via debugLog.
+*
+* @param debugLog - Callback for progress messages
+* @param backendName - Display name (e.g., "Cursor", "Claude", "Codex")
+* @param adapter - Format-specific adapter to convert raw JSON → StreamEvent
+*/
+function createStreamParser(debugLog, backendName, adapter) {
+	let lineBuf = "";
+	return (chunk) => {
+		lineBuf += chunk;
+		const lines = lineBuf.split("\n");
+		lineBuf = lines.pop() ?? "";
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			try {
+				const event = adapter(JSON.parse(line));
+				if (event) {
+					const progress = formatEvent(event, backendName);
+					if (progress) debugLog(progress);
+				}
+			} catch {}
+		}
+	};
+}
+/**
+* Format tool call input for display (truncated JSON string)
+*/
+function formatToolInput(input) {
+	if (!input || typeof input !== "object") return "";
+	try {
+		const str = JSON.stringify(input);
+		return str.length > 100 ? str.slice(0, 100) + "..." : str;
+	} catch {
+		return "";
+	}
+}
+
 //#endregion
 //#region src/backends/claude-code.ts
 /**
@@ -332,13 +597,19 @@ var ClaudeCodeBackend = class {
 	async send(message, options) {
 		const args = this.buildArgs(message, options);
 		const cwd = this.options.workspace || this.options.cwd;
+		const debugLog = this.options.debugLog;
+		const outputFormat = this.options.outputFormat ?? "stream-json";
+		const timeout = this.options.timeout ?? 3e5;
 		try {
-			const { stdout } = await execa("claude", args, {
+			const { stdout } = await execWithIdleTimeout({
+				command: "claude",
+				args,
 				cwd,
-				stdin: "ignore",
-				timeout: this.options.timeout
+				timeout,
+				onStdout: outputFormat === "stream-json" && debugLog ? createStreamParser(debugLog, "Claude", claudeAdapter) : void 0
 			});
-			if (this.options.outputFormat === "json") try {
+			if (outputFormat === "stream-json") return extractClaudeResult(stdout);
+			if (outputFormat === "json") try {
 				const parsed = JSON.parse(stdout);
 				return {
 					content: parsed.content || parsed.result || stdout,
@@ -350,7 +621,11 @@ var ClaudeCodeBackend = class {
 			}
 			return { content: stdout.trim() };
 		} catch (error) {
-			if (error instanceof ExecaError) throw new Error(`claude failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			if (error instanceof IdleTimeoutError) throw new Error(`claude timed out after ${timeout}ms of inactivity`);
+			if (error && typeof error === "object" && "exitCode" in error) {
+				const execError = error;
+				throw new Error(`claude failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
+			}
 			throw error;
 		}
 	}
@@ -383,7 +658,8 @@ var ClaudeCodeBackend = class {
 			args.push("--append-system-prompt", system);
 		}
 		if (this.options.allowedTools?.length) args.push("--allowed-tools", this.options.allowedTools.join(","));
-		if (this.options.outputFormat) args.push("--output-format", this.options.outputFormat);
+		const outputFormat = this.options.outputFormat ?? "stream-json";
+		args.push("--output-format", outputFormat);
 		if (this.options.continue) args.push("--continue");
 		if (this.options.resume) args.push("--resume", this.options.resume);
 		if (this.options.mcpConfigPath) args.push("--mcp-config", this.options.mcpConfigPath);
@@ -401,7 +677,7 @@ var ClaudeCodeBackend = class {
 //#region src/backends/codex.ts
 /**
 * OpenAI Codex CLI backend
-* Uses `codex exec` for non-interactive mode
+* Uses `codex exec` for non-interactive mode with JSON event output
 *
 * MCP Configuration:
 * Codex uses project-level MCP config. Use setWorkspace() to set up
@@ -432,28 +708,23 @@ var CodexBackend = class {
 	async send(message, _options) {
 		const args = this.buildArgs(message);
 		const cwd = this.options.workspace || this.options.cwd;
+		const debugLog = this.options.debugLog;
+		const timeout = this.options.timeout ?? 3e5;
 		try {
-			const { stdout } = await execa("codex", args, {
+			const { stdout } = await execWithIdleTimeout({
+				command: "codex",
+				args,
 				cwd,
-				stdin: "ignore",
-				timeout: this.options.timeout
+				timeout,
+				onStdout: debugLog ? createStreamParser(debugLog, "Codex", codexAdapter) : void 0
 			});
-			if (this.options.json) try {
-				const lines = stdout.trim().split("\n");
-				const lastLine = lines[lines.length - 1];
-				if (!lastLine) return { content: stdout.trim() };
-				const lastEvent = JSON.parse(lastLine);
-				return {
-					content: lastEvent.message || lastEvent.content || stdout,
-					toolCalls: lastEvent.toolCalls,
-					usage: lastEvent.usage
-				};
-			} catch {
-				return { content: stdout.trim() };
-			}
-			return { content: stdout.trim() };
+			return extractCodexResult(stdout);
 		} catch (error) {
-			if (error instanceof ExecaError) throw new Error(`codex failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			if (error instanceof IdleTimeoutError) throw new Error(`codex timed out after ${timeout}ms of inactivity`);
+			if (error && typeof error === "object" && "exitCode" in error) {
+				const execError = error;
+				throw new Error(`codex failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
+			}
 			throw error;
 		}
 	}
@@ -477,13 +748,12 @@ var CodexBackend = class {
 	buildArgs(message) {
 		const args = [
 			"exec",
-			"--dangerously-bypass-approvals-and-sandbox",
+			"--full-auto",
+			"--json",
+			"--skip-git-repo-check",
 			message
 		];
 		if (this.options.model) args.push("--model", this.options.model);
-		if (this.options.json) args.push("--json");
-		if (this.options.skipGitRepoCheck) args.push("--skip-git-repo-check");
-		if (this.options.approvalMode) args.push("--approval-mode", this.options.approvalMode);
 		if (this.options.resume) args.push("--resume", this.options.resume);
 		return args;
 	}
@@ -493,7 +763,8 @@ var CodexBackend = class {
 //#region src/backends/cursor.ts
 /**
 * Cursor CLI backend
-* Uses `cursor-agent -p` for non-interactive mode
+* Uses `cursor agent -p` (preferred) or `cursor-agent -p` (fallback)
+* for non-interactive mode with stream-json output
 *
 * MCP Configuration:
 * Cursor uses project-level MCP config via .cursor/mcp.json in the workspace.
@@ -504,9 +775,11 @@ var CodexBackend = class {
 var CursorBackend = class {
 	type = "cursor";
 	options;
+	/** Resolved command: "cursor" (subcommand style) or "cursor-agent" (standalone) */
+	resolvedCommand = null;
 	constructor(options = {}) {
 		this.options = {
-			timeout: 12e4,
+			timeout: 3e5,
 			...options
 		};
 	}
@@ -521,32 +794,30 @@ var CursorBackend = class {
 		writeFileSync(join(cursorDir, "mcp.json"), JSON.stringify(mcpConfig, null, 2));
 	}
 	async send(message, _options) {
-		const { command, args } = this.buildCommand(message);
+		const { command, args } = await this.buildCommand(message);
 		const cwd = this.options.workspace || this.options.cwd;
+		const debugLog = this.options.debugLog;
+		const timeout = this.options.timeout ?? 3e5;
 		try {
-			const { stdout } = await execa(command, args, {
+			const { stdout } = await execWithIdleTimeout({
+				command,
+				args,
 				cwd,
-				stdin: "ignore",
-				timeout: this.options.timeout
+				timeout,
+				onStdout: debugLog ? createStreamParser(debugLog, "Cursor", claudeAdapter) : void 0
 			});
-			return { content: stdout.trim() };
+			return extractClaudeResult(stdout);
 		} catch (error) {
-			if (error instanceof ExecaError) {
-				if (error.timedOut) throw new Error(`cursor-agent timed out after ${this.options.timeout}ms`);
-				throw new Error(`cursor-agent failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			if (error instanceof IdleTimeoutError) throw new Error(`cursor agent timed out after ${timeout}ms of inactivity`);
+			if (error && typeof error === "object" && "exitCode" in error) {
+				const execError = error;
+				throw new Error(`cursor agent failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
 			}
 			throw error;
 		}
 	}
 	async isAvailable() {
-		for (const cmd of ["cursor-agent", "agent"]) try {
-			await execa(cmd, ["--version"], {
-				stdin: "ignore",
-				timeout: 2e3
-			});
-			return true;
-		} catch {}
-		return false;
+		return await this.resolveCommand() !== null;
 	}
 	getInfo() {
 		return {
@@ -554,17 +825,48 @@ var CursorBackend = class {
 			model: this.options.model
 		};
 	}
-	buildCommand(message) {
-		const args = [
+	/**
+	* Resolve which cursor command is available.
+	* Prefers `cursor agent` (subcommand), falls back to `cursor-agent` (standalone).
+	* Result is cached after first resolution.
+	*/
+	async resolveCommand() {
+		if (this.resolvedCommand !== null) return this.resolvedCommand;
+		try {
+			await execa("cursor", ["agent", "--version"], {
+				stdin: "ignore",
+				timeout: 2e3
+			});
+			this.resolvedCommand = "cursor";
+			return "cursor";
+		} catch {}
+		try {
+			await execa("cursor-agent", ["--version"], {
+				stdin: "ignore",
+				timeout: 2e3
+			});
+			this.resolvedCommand = "cursor-agent";
+			return "cursor-agent";
+		} catch {}
+		return null;
+	}
+	async buildCommand(message) {
+		const cmd = await this.resolveCommand();
+		const agentArgs = [
 			"-p",
 			"--force",
 			"--approve-mcps",
+			"--output-format=stream-json",
 			message
 		];
-		if (this.options.model) args.push("--model", this.options.model);
+		if (this.options.model) agentArgs.push("--model", this.options.model);
+		if (cmd === "cursor") return {
+			command: "cursor",
+			args: ["agent", ...agentArgs]
+		};
 		return {
 			command: "cursor-agent",
-			args
+			args: agentArgs
 		};
 	}
 };
@@ -732,4 +1034,4 @@ async function listBackends() {
 }
 
 //#endregion
-export { FRONTIER_MODELS as _, createMockBackend as a, createModelAsync as b, CodexBackend as c, CLAUDE_MODEL_MAP as d, CODEX_MODEL_MAP as f, parseModel as g, getModelForBackend as h, MockAIBackend as i, ClaudeCodeBackend as l, SDK_MODEL_ALIASES as m, createBackend as n, SdkBackend as o, CURSOR_MODEL_MAP as p, listBackends as r, CursorBackend as s, checkBackends as t, BACKEND_DEFAULT_MODELS as u, SUPPORTED_PROVIDERS as v, getDefaultModel as x, createModel as y };
+export { getModelForBackend as C, createModel as D, SUPPORTED_PROVIDERS as E, createModelAsync as O, SDK_MODEL_ALIASES as S, FRONTIER_MODELS as T, execWithIdleTimeout as _, createMockBackend as a, CODEX_MODEL_MAP as b, CodexBackend as c, codexAdapter as d, createStreamParser as f, IdleTimeoutError as g, formatEvent as h, MockAIBackend as i, getDefaultModel as k, ClaudeCodeBackend as l, extractCodexResult as m, createBackend as n, SdkBackend as o, extractClaudeResult as p, listBackends as r, CursorBackend as s, checkBackends as t, claudeAdapter as u, BACKEND_DEFAULT_MODELS as v, parseModel as w, CURSOR_MODEL_MAP as x, CLAUDE_MODEL_MAP as y };

package/dist/cli/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { _ as FRONTIER_MODELS, n as createBackend, x as getDefaultModel } from "../backends-DenGdkrj.mjs";
-import { a as createSkillsTool, c as createFeedbackTool, l as AgentSession, o as SkillsProvider, s as FEEDBACK_PROMPT, t as SkillImporter } from "../skills-VyC7eQyK.mjs";
+import { T as FRONTIER_MODELS, k as getDefaultModel, n as createBackend } from "../backends-CEYiMUgC.mjs";
+import { a as createSkillsTool, c as createFeedbackTool, l as AgentSession, o as SkillsProvider, s as FEEDBACK_PROMPT, t as SkillImporter } from "../skills-iya7NbH7.mjs";
 import { jsonSchema, tool } from "ai";
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
@@ -2094,7 +2094,7 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CaRCNEh6.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-K1Zd655A.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
@@ -2144,7 +2144,7 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CaRCNEh6.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-K1Zd655A.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
@@ -2339,7 +2339,7 @@ function registerInfoCommands(program) {
 		console.log(`\nDefault: ${defaultModel} (when no model specified)`);
 	});
 	program.command("backends").description("Check available backends (SDK, CLI tools)").action(async () => {
-		const { listBackends } = await import("../backends-D3MAlJBX.mjs");
+		const { listBackends } = await import("../backends-B8rYTNqn.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -2489,8 +2489,11 @@ Note: Requires agent to be created with --feedback flag
 //#region src/cli/index.ts
 globalThis.AI_SDK_LOG_WARNINGS = false;
 const originalStderrWrite = process.stderr.write.bind(process.stderr);
-process.stderr.write = function(chunk, ...args) {
-	if (process.argv.includes("--debug") || process.argv.includes("-d")) return originalStderrWrite(typeof chunk === "string" ? chunk : chunk.toString(), ...args);
+process.stderr.write = function(chunk, ...rest) {
+	if (process.argv.includes("--debug") || process.argv.includes("-d")) {
+		const message = typeof chunk === "string" ? chunk : chunk.toString();
+		return originalStderrWrite.call(process.stderr, message, ...rest);
+	}
 	return true;
 };
 const program = new Command();

package/dist/index.d.mts

@@ -467,7 +467,7 @@ interface ClaudeCodeOptions {
   cwd?: string;
   /** Workspace directory for agent isolation */
   workspace?: string;
-  /** Timeout in milliseconds */
+  /** Idle timeout in milliseconds — kills process if no output for this duration */
   timeout?: number;
   /** MCP config file path (for workflow context) */
   mcpConfigPath?: string;
@@ -505,19 +505,13 @@ declare class ClaudeCodeBackend implements Backend {
 interface CodexOptions {
   /** Model to use (e.g., 'gpt-5.2-codex') */
   model?: string;
-  /** Output as JSON events */
-  json?: boolean;
   /** Working directory (defaults to workspace if set) */
   cwd?: string;
   /** Workspace directory for agent isolation */
   workspace?: string;
-  /** Skip git repo check */
-  skipGitRepoCheck?: boolean;
-  /** Approval mode: 'suggest' | 'auto-edit' | 'full-auto' */
-  approvalMode?: "suggest" | "auto-edit" | "full-auto";
   /** Resume a previous session */
   resume?: string;
-  /** Timeout in milliseconds */
+  /** Idle timeout in milliseconds — kills process if no output for this duration */
   timeout?: number;
   /** Debug log function (for workflow diagnostics) */
   debugLog?: (message: string) => void;
@@ -553,7 +547,7 @@ interface CursorOptions {
   cwd?: string;
   /** Workspace directory for agent isolation (contains .cursor/mcp.json) */
   workspace?: string;
-  /** Timeout in milliseconds */
+  /** Idle timeout in milliseconds — kills process if no output for this duration */
   timeout?: number;
   /** Debug log function (for workflow diagnostics) */
   debugLog?: (message: string) => void;
@@ -561,6 +555,8 @@ interface CursorOptions {
 declare class CursorBackend implements Backend {
   readonly type: "cursor";
   private options;
+  /** Resolved command: "cursor" (subcommand style) or "cursor-agent" (standalone) */
+  private resolvedCommand;
   constructor(options?: CursorOptions);
   /**
    * Set up workspace directory with MCP config
@@ -578,10 +574,16 @@ declare class CursorBackend implements Backend {
     version?: string;
     model?: string;
   };
-  protected buildCommand(message: string): {
+  /**
+   * Resolve which cursor command is available.
+   * Prefers `cursor agent` (subcommand), falls back to `cursor-agent` (standalone).
+   * Result is cached after first resolution.
+   */
+  private resolveCommand;
+  protected buildCommand(message: string): Promise<{
     command: string;
     args: string[];
-  };
+  }>;
 }
 //#endregion
 //#region src/backends/sdk.d.ts

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { _ as FRONTIER_MODELS, a as createMockBackend, b as createModelAsync, c as CodexBackend, i as MockAIBackend, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends, v as SUPPORTED_PROVIDERS, y as createModel } from "./backends-DenGdkrj.mjs";
-import { a as createSkillsTool, c as createFeedbackTool, i as parseImportSpec, l as AgentSession, n as buildGitUrl, o as SkillsProvider, r as getSpecDisplayName, s as FEEDBACK_PROMPT, t as SkillImporter } from "./skills-VyC7eQyK.mjs";
+import { D as createModel, E as SUPPORTED_PROVIDERS, O as createModelAsync, T as FRONTIER_MODELS, a as createMockBackend, c as CodexBackend, i as MockAIBackend, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends } from "./backends-CEYiMUgC.mjs";
+import { a as createSkillsTool, c as createFeedbackTool, i as parseImportSpec, l as AgentSession, n as buildGitUrl, o as SkillsProvider, r as getSpecDisplayName, s as FEEDBACK_PROMPT, t as SkillImporter } from "./skills-iya7NbH7.mjs";
 import { jsonSchema, tool } from "ai";
 import { createBashTool } from "bash-tool";
 

package/dist/{skills-VyC7eQyK.mjs → skills-iya7NbH7.mjs}

@@ -1,4 +1,4 @@
-import { b as createModelAsync } from "./backends-DenGdkrj.mjs";
+import { O as createModelAsync } from "./backends-CEYiMUgC.mjs";
 import { ToolLoopAgent, jsonSchema, stepCountIs, tool } from "ai";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, normalize } from "node:path";

package/dist/{workflow-CaRCNEh6.mjs → workflow-K1Zd655A.mjs}

@@ -1,4 +1,4 @@
-import { a as createMockBackend, b as createModelAsync, g as parseModel, n as createBackend } from "./backends-DenGdkrj.mjs";
+import { O as createModelAsync, a as createMockBackend, n as createBackend, w as parseModel } from "./backends-CEYiMUgC.mjs";
 import { c as CONTEXT_DEFAULTS, i as resolveContextDir, n as createFileContextProvider, t as FileContextProvider } from "./cli/index.mjs";
 import { a as createMemoryContextProvider, t as createContextMCPServer } from "./mcp-server-DtIApaBD.mjs";
 import { generateText, jsonSchema, stepCountIs, tool } from "ai";
@@ -860,6 +860,7 @@ function shouldContinue(state) {
 */
 function createAgentController(config) {
 	const { name, agent, contextProvider, mcpUrl, workspaceDir, projectDir, backend, onRunComplete, log = () => {}, feedback } = config;
+	const infoLog = config.infoLog ?? log;
 	const errorLog = config.errorLog ?? log;
 	const pollInterval = config.pollInterval ?? CONTROLLER_DEFAULTS.pollInterval;
 	const retryConfig = {
@@ -895,7 +896,7 @@ function createAgentController(config) {
 				continue;
 			}
 			const senders = inbox.map((m) => m.entry.from);
-			log(`Inbox: ${inbox.length} message(s) from [${senders.join(", ")}]`);
+			infoLog(`Inbox: ${inbox.length} message(s) from [${senders.join(", ")}]`);
 			for (const msg of inbox) {
 				const preview = msg.entry.content.length > 120 ? msg.entry.content.slice(0, 120) + "..." : msg.entry.content;
 				log(`  from @${msg.entry.from}: ${preview}`);
@@ -907,7 +908,7 @@ function createAgentController(config) {
 			while (attempt < retryConfig.maxAttempts && shouldContinue(state)) {
 				attempt++;
 				state = "running";
-				log(`Running (attempt ${attempt}/${retryConfig.maxAttempts})`);
+				infoLog(`Running (attempt ${attempt}/${retryConfig.maxAttempts})`);
 				lastResult = await runAgent(backend, {
 					name,
 					agent,
@@ -922,9 +923,9 @@ function createAgentController(config) {
 					projectDir,
 					retryAttempt: attempt,
 					feedback
-				}, log);
+				}, log, infoLog);
 				if (lastResult.success) {
-					log(`DONE ${lastResult.steps ? `${lastResult.steps} steps, ${lastResult.toolCalls} tool calls, ${lastResult.duration}ms` : `${lastResult.duration}ms`}`);
+					infoLog(`DONE ${lastResult.steps ? `${lastResult.steps} steps, ${lastResult.toolCalls} tool calls, ${lastResult.duration}ms` : `${lastResult.duration}ms`}`);
 					if (lastResult.content) await contextProvider.appendChannel(name, lastResult.content);
 					await contextProvider.ackInbox(name, latestId);
 					break;
@@ -954,7 +955,7 @@ function createAgentController(config) {
 		async start() {
 			if (state !== "stopped") throw new Error(`Controller ${name} is already running`);
 			state = "idle";
-			log(`Starting`);
+			infoLog(`Starting`);
 			runLoop().catch((error) => {
 				errorLog(`ERROR ${error instanceof Error ? error.message : String(error)}`);
 				state = "stopped";
@@ -994,7 +995,8 @@ function createAgentController(config) {
 * SDK and mock backends get special runners with MCP tool bridge + bash,
 * because they can't manage tools on their own (unlike CLI backends).
 */
-async function runAgent(backend, ctx, log) {
+async function runAgent(backend, ctx, log, infoLog) {
+	const info = infoLog ?? log;
 	if (backend.type === "mock") return runMockAgent(ctx, (msg) => log(msg));
 	if (backend.type === "sdk") return runSdkAgent(ctx, (msg) => log(msg));
 	const startTime = Date.now();
@@ -1004,7 +1006,7 @@ async function runAgent(backend, ctx, log) {
 			backend.setWorkspace(ctx.workspaceDir, mcpConfig);
 		}
 		const prompt = buildAgentPrompt(ctx);
-		log(`Prompt (${prompt.length} chars) → ${backend.type} backend`);
+		info(`Prompt (${prompt.length} chars) → ${backend.type} backend`);
 		await backend.send(prompt, { system: ctx.agent.resolvedSystemPrompt });
 		return {
 			success: true,
@@ -1044,9 +1046,13 @@ async function checkWorkflowIdle(controllers, provider, debounceMs = CONTROLLER_
 */
 function getBackendByType(backendType, options) {
 	if (backendType === "mock") return createMockBackend(options?.debugLog);
+	const backendOptions = {};
+	if (options?.timeout) backendOptions.timeout = options.timeout;
+	if (options?.debugLog) backendOptions.debugLog = options.debugLog;
 	return createBackend({
 		type: backendType,
-		model: options?.model
+		model: options?.model,
+		...Object.keys(backendOptions).length > 0 ? { options: backendOptions } : {}
 	});
 }
 /**
@@ -1658,7 +1664,8 @@ async function runWorkflowWithControllers(config) {
 			if (createBackend) backend = createBackend(agentName, agentDef);
 			else if (agentDef.backend) backend = getBackendByType(agentDef.backend, {
 				model: agentDef.model,
-				debugLog: backendDebugLog
+				debugLog: backendDebugLog,
+				timeout: agentDef.timeout
 			});
 			else if (agentDef.model) backend = getBackendForModel(agentDef.model, { debugLog: backendDebugLog });
 			else throw new Error(`Agent "${agentName}" requires either a backend or model field`);
@@ -1676,6 +1683,7 @@ async function runWorkflowWithControllers(config) {
 				backend,
 				pollInterval,
 				log: (msg) => controllerLogger.debug(msg),
+				infoLog: (msg) => controllerLogger.info(msg),
 				errorLog: (msg) => controllerLogger.error(msg),
 				feedback: feedbackEnabled
 			});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-worker",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "SDK and CLI for creating and testing agent workers with Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.mjs",

package/dist/backends-D3MAlJBX.mjs

@@ -1,3 +0,0 @@
-import { a as createMockBackend, c as CodexBackend, d as CLAUDE_MODEL_MAP, f as CODEX_MODEL_MAP, h as getModelForBackend, i as MockAIBackend, l as ClaudeCodeBackend, m as SDK_MODEL_ALIASES, n as createBackend, o as SdkBackend, p as CURSOR_MODEL_MAP, r as listBackends, s as CursorBackend, t as checkBackends, u as BACKEND_DEFAULT_MODELS } from "./backends-DenGdkrj.mjs";
-
-export { listBackends };