agent-worker 0.9.0 → 0.11.0

package/dist/worker-CJ5_b2_q.mjs

@@ -0,0 +1,446 @@
+import { A as createModelAsync } from "./backends-DLaP0rMW.mjs";
+import { ToolLoopAgent, stepCountIs } from "ai";
+
+//#region src/agent/worker.ts
+/**
+* AgentWorker - Stateful worker for controlled agent execution
+*
+* Uses ToolLoopAgent internally for multi-step reasoning loops.
+* Maintains conversation state across multiple send() calls,
+* enabling improvisational testing where you observe responses
+* and decide next actions.
+*
+* Tools are AI SDK tool() objects passed as Record<name, tool()>.
+* Approval is configured separately via Record<name, check>.
+*/
+var AgentWorker = class {
+	id;
+	model;
+	system;
+	createdAt;
+	tools;
+	approval;
+	maxTokens;
+	maxSteps;
+	messages = [];
+	totalUsage = {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+	pendingApprovals = [];
+	backend;
+	cachedAgent = null;
+	toolsChanged = false;
+	/**
+	* Whether this session supports tool management (SDK backend only)
+	*/
+	get supportsTools() {
+		return this.backend === null;
+	}
+	/**
+	* Convert AgentMessage[] to ModelMessage[] for AI SDK
+	*/
+	toModelMessages() {
+		return this.messages.filter((m) => m.status !== "responding").map((m) => ({
+			role: m.role,
+			content: m.content
+		}));
+	}
+	constructor(config, restore) {
+		if (restore) {
+			this.id = restore.id;
+			this.createdAt = restore.createdAt;
+			this.messages = [...restore.messages];
+			this.totalUsage = { ...restore.totalUsage };
+			this.pendingApprovals = [...restore.pendingApprovals ?? []];
+		} else {
+			this.id = crypto.randomUUID();
+			this.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+		}
+		this.model = config.model;
+		this.system = config.system;
+		this.tools = config.tools ? { ...config.tools } : {};
+		this.approval = config.approval ? { ...config.approval } : {};
+		this.maxTokens = config.maxTokens ?? 4096;
+		this.maxSteps = config.maxSteps ?? 200;
+		this.backend = config.backend ?? null;
+	}
+	/**
+	* Check if a tool needs approval for given arguments
+	*/
+	checkApproval(name, args) {
+		const check = this.approval[name];
+		if (!check) return false;
+		if (typeof check === "function") return check(args);
+		return check;
+	}
+	/**
+	* Build tools with approval wrapping for ToolLoopAgent
+	*/
+	buildTools(autoApprove) {
+		if (Object.keys(this.tools).length === 0) return void 0;
+		if (autoApprove || Object.keys(this.approval).length === 0) return this.tools;
+		const wrapped = {};
+		for (const [name, t] of Object.entries(this.tools)) {
+			if (!this.approval[name]) {
+				wrapped[name] = t;
+				continue;
+			}
+			wrapped[name] = {
+				...t,
+				execute: async (args, options) => {
+					if (this.checkApproval(name, args)) {
+						const approval = {
+							id: crypto.randomUUID(),
+							toolName: name,
+							toolCallId: crypto.randomUUID(),
+							arguments: args,
+							requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+							status: "pending"
+						};
+						this.pendingApprovals.push(approval);
+						return {
+							__approvalRequired: true,
+							approvalId: approval.id
+						};
+					}
+					return t.execute?.(args, options);
+				}
+			};
+		}
+		return wrapped;
+	}
+	/**
+	* Get or create cached agent, rebuild if tools changed
+	*/
+	async getAgent(autoApprove) {
+		if (!this.cachedAgent || this.toolsChanged || !autoApprove) {
+			this.cachedAgent = new ToolLoopAgent({
+				model: await createModelAsync(this.model),
+				instructions: this.system,
+				tools: this.buildTools(autoApprove),
+				maxOutputTokens: this.maxTokens,
+				stopWhen: stepCountIs(this.maxSteps)
+			});
+			if (autoApprove) this.toolsChanged = false;
+		}
+		return this.cachedAgent;
+	}
+	/**
+	* Send a message via CLI backend (non-SDK path)
+	*/
+	async sendViaBackend(content) {
+		const startTime = performance.now();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		this.messages.push({
+			role: "user",
+			content,
+			status: "complete",
+			timestamp
+		});
+		const result = await this.backend.send(content, { system: this.system });
+		const latency = Math.round(performance.now() - startTime);
+		this.messages.push({
+			role: "assistant",
+			content: result.content,
+			status: "complete",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const usage = {
+			input: result.usage?.input ?? 0,
+			output: result.usage?.output ?? 0,
+			total: result.usage?.total ?? 0
+		};
+		this.totalUsage.input += usage.input;
+		this.totalUsage.output += usage.output;
+		this.totalUsage.total += usage.total;
+		const toolCalls = (result.toolCalls ?? []).map((tc) => ({
+			name: tc.name,
+			arguments: tc.arguments,
+			result: tc.result,
+			timing: 0
+		}));
+		return {
+			content: result.content,
+			toolCalls,
+			pendingApprovals: [],
+			usage,
+			latency
+		};
+	}
+	/**
+	* Send a message and get the agent's response
+	*/
+	async send(content, options = {}) {
+		if (this.backend) return this.sendViaBackend(content);
+		const { autoApprove = true, onStepFinish } = options;
+		const startTime = performance.now();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		this.messages.push({
+			role: "user",
+			content,
+			status: "complete",
+			timestamp
+		});
+		const agent = await this.getAgent(autoApprove);
+		const allToolCalls = [];
+		let stepNumber = 0;
+		const result = await agent.generate({
+			messages: this.toModelMessages(),
+			onStepFinish: async ({ usage, toolCalls, toolResults }) => {
+				stepNumber++;
+				const stepToolCalls = [];
+				if (toolCalls) for (const tc of toolCalls) {
+					const toolResult = toolResults?.find((tr) => tr.toolCallId === tc.toolCallId);
+					const toolCall = {
+						name: tc.toolName,
+						arguments: tc.input,
+						result: toolResult?.output ?? null,
+						timing: 0
+					};
+					stepToolCalls.push(toolCall);
+					allToolCalls.push(toolCall);
+				}
+				if (onStepFinish) {
+					const stepUsage = {
+						input: usage?.inputTokens ?? 0,
+						output: usage?.outputTokens ?? 0,
+						total: (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
+					};
+					await onStepFinish({
+						stepNumber,
+						toolCalls: stepToolCalls,
+						usage: stepUsage
+					});
+				}
+			}
+		});
+		const latency = Math.round(performance.now() - startTime);
+		this.messages.push({
+			role: "assistant",
+			content: result.text,
+			status: "complete",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const usage = {
+			input: result.usage?.inputTokens ?? 0,
+			output: result.usage?.outputTokens ?? 0,
+			total: (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0)
+		};
+		this.totalUsage.input += usage.input;
+		this.totalUsage.output += usage.output;
+		this.totalUsage.total += usage.total;
+		if (this.maxSteps > 0 && stepNumber >= this.maxSteps && allToolCalls.length > 0) console.warn(`⚠️  Agent reached maxSteps limit (${this.maxSteps}) but wanted to continue. Consider increasing maxSteps or removing the limit.`);
+		const currentPending = this.pendingApprovals.filter((p) => p.status === "pending");
+		return {
+			content: result.text,
+			toolCalls: allToolCalls,
+			pendingApprovals: currentPending,
+			usage,
+			latency
+		};
+	}
+	/**
+	* Send a message and stream the response
+	*/
+	async *sendStream(content, options = {}) {
+		if (this.backend) {
+			const response = await this.sendViaBackend(content);
+			yield response.content;
+			return response;
+		}
+		const { autoApprove = true, onStepFinish } = options;
+		const startTime = performance.now();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		this.messages.push({
+			role: "user",
+			content,
+			status: "complete",
+			timestamp
+		});
+		const assistantMsg = {
+			role: "assistant",
+			content: "",
+			status: "responding",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.messages.push(assistantMsg);
+		const agent = await this.getAgent(autoApprove);
+		const allToolCalls = [];
+		let stepNumber = 0;
+		const result = await agent.stream({
+			messages: this.toModelMessages(),
+			onStepFinish: async ({ usage, toolCalls, toolResults }) => {
+				stepNumber++;
+				const stepToolCalls = [];
+				if (toolCalls) for (const tc of toolCalls) {
+					const toolResult = toolResults?.find((tr) => tr.toolCallId === tc.toolCallId);
+					const toolCall = {
+						name: tc.toolName,
+						arguments: tc.input,
+						result: toolResult?.output ?? null,
+						timing: 0
+					};
+					stepToolCalls.push(toolCall);
+					allToolCalls.push(toolCall);
+				}
+				if (onStepFinish) {
+					const stepUsage = {
+						input: usage?.inputTokens ?? 0,
+						output: usage?.outputTokens ?? 0,
+						total: (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
+					};
+					await onStepFinish({
+						stepNumber,
+						toolCalls: stepToolCalls,
+						usage: stepUsage
+					});
+				}
+			}
+		});
+		for await (const chunk of result.textStream) {
+			assistantMsg.content += chunk;
+			yield chunk;
+		}
+		const latency = Math.round(performance.now() - startTime);
+		const text = await result.text;
+		assistantMsg.content = text;
+		assistantMsg.status = "complete";
+		const finalUsage = await result.usage;
+		const usage = {
+			input: finalUsage?.inputTokens ?? 0,
+			output: finalUsage?.outputTokens ?? 0,
+			total: (finalUsage?.inputTokens ?? 0) + (finalUsage?.outputTokens ?? 0)
+		};
+		this.totalUsage.input += usage.input;
+		this.totalUsage.output += usage.output;
+		this.totalUsage.total += usage.total;
+		return {
+			content: text,
+			toolCalls: allToolCalls,
+			pendingApprovals: this.pendingApprovals.filter((p) => p.status === "pending"),
+			usage,
+			latency
+		};
+	}
+	/**
+	* Add an AI SDK tool
+	* Only supported for SDK backends (ToolLoopAgent)
+	*/
+	addTool(name, t) {
+		if (this.backend) throw new Error("Tool management not supported for CLI backends");
+		this.tools[name] = t;
+		this.toolsChanged = true;
+		this.cachedAgent = null;
+	}
+	/**
+	* Set approval requirement for a tool
+	*/
+	setApproval(name, check) {
+		this.approval[name] = check;
+	}
+	/**
+	* Replace a tool's execute function (for testing)
+	*/
+	mockTool(name, mockFn) {
+		if (this.backend) throw new Error("Tool management not supported for CLI backends");
+		const t = this.tools[name];
+		if (!t) throw new Error(`Tool not found: ${name}`);
+		this.tools[name] = {
+			...t,
+			execute: mockFn
+		};
+		this.toolsChanged = true;
+		this.cachedAgent = null;
+	}
+	/**
+	* Set a static mock response for an existing tool
+	*/
+	setMockResponse(name, response) {
+		if (this.backend) throw new Error("Tool management not supported for CLI backends");
+		const t = this.tools[name];
+		if (!t) throw new Error(`Tool not found: ${name}`);
+		this.tools[name] = {
+			...t,
+			execute: () => response
+		};
+		this.toolsChanged = true;
+		this.cachedAgent = null;
+	}
+	/**
+	* Get tool info (names, descriptions, approval status)
+	*/
+	getTools() {
+		return Object.entries(this.tools).map(([name, t]) => {
+			return {
+				name,
+				description: t?.description,
+				needsApproval: !!this.approval[name]
+			};
+		});
+	}
+	history() {
+		return [...this.messages];
+	}
+	stats() {
+		return {
+			messageCount: this.messages.length,
+			usage: { ...this.totalUsage }
+		};
+	}
+	export() {
+		return {
+			sessionId: this.id,
+			model: this.model,
+			system: this.system,
+			messages: [...this.messages],
+			totalUsage: { ...this.totalUsage },
+			createdAt: this.createdAt
+		};
+	}
+	getState() {
+		return {
+			id: this.id,
+			createdAt: this.createdAt,
+			messages: [...this.messages],
+			totalUsage: { ...this.totalUsage },
+			pendingApprovals: [...this.pendingApprovals]
+		};
+	}
+	getPendingApprovals() {
+		return this.pendingApprovals.filter((p) => p.status === "pending");
+	}
+	async approve(approvalId) {
+		const approval = this.pendingApprovals.find((p) => p.id === approvalId);
+		if (!approval) throw new Error(`Approval not found: ${approvalId}`);
+		if (approval.status !== "pending") throw new Error(`Approval already ${approval.status}: ${approvalId}`);
+		const t = this.tools[approval.toolName];
+		if (!t) throw new Error(`Tool not found: ${approval.toolName}`);
+		let result;
+		const tool = t;
+		if (typeof tool.execute === "function") result = await tool.execute(approval.arguments);
+		else result = { error: "No implementation provided" };
+		approval.status = "approved";
+		return result;
+	}
+	deny(approvalId, reason) {
+		const approval = this.pendingApprovals.find((p) => p.id === approvalId);
+		if (!approval) throw new Error(`Approval not found: ${approvalId}`);
+		if (approval.status !== "pending") throw new Error(`Approval already ${approval.status}: ${approvalId}`);
+		approval.status = "denied";
+		approval.denyReason = reason;
+	}
+	clear() {
+		this.messages = [];
+		this.totalUsage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		this.pendingApprovals = [];
+	}
+};
+
+//#endregion
+export { AgentWorker as t };

package/dist/{workflow-CoZnnJ3O.mjs → workflow-CfITD7TN.mjs}

@@ -1,16 +1,16 @@
-import { T as parseModel, a as createMockBackend, k as createModelAsync, n as createBackend } from "./backends-BOAkfYyL.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-BQCQxv2v.mjs";
-import { createChannelLogger, createSilentLogger } from "./logger-C3ekEOzi.mjs";
+import { A as createModelAsync, E as parseModel, a as createMockBackend, n as createBackend } from "./backends-DLaP0rMW.mjs";
+import { T as EventLog, c as CONTEXT_DEFAULTS, i as resolveContextDir, n as createFileContextProvider, t as FileContextProvider, v as createContextMCPServer } from "./cli/index.mjs";
+import { n as createMemoryContextProvider } from "./memory-provider-CBlKMdbJ.mjs";
+import { createChannelLogger, createSilentLogger } from "./logger-CCFaMMV7.mjs";
 import { generateText, jsonSchema, stepCountIs, tool } from "ai";
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { parse } from "yaml";
 import { tmpdir } from "node:os";
 import { exec, execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 import { createServer } from "node:http";
-import { randomUUID } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { MockLanguageModelV3, mockValues } from "ai/test";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -236,14 +236,14 @@ function validateAgent(name, agent, errors) {
 		return;
 	}
 	const a = agent;
-	const backend = typeof a.backend === "string" ? a.backend : "sdk";
+	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 sdk backend)"
+		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`,
@@ -779,7 +779,7 @@ function createBashTool() {
 /**
 * Run an SDK agent with real model + MCP tools + bash.
 *
-* Used by the controller when backend.type === 'sdk'.
+* Used by the controller when backend.type === 'default'.
 * Unlike the simple SdkBackend.send() (text-only), this runner:
 * 1. Connects to MCP server for context tools (channel, document)
 * 2. Adds bash tool for shell access
@@ -813,17 +813,8 @@ async function runSdkAgent(ctx, debugLog) {
 			stopWhen: stepCountIs(ctx.agent.max_steps ?? 200),
 			onStepFinish: (step) => {
 				_stepNum++;
-				if (step.toolCalls?.length) {
-					for (const tc of step.toolCalls) if (tc.toolName === "bash") {
-						const args = formatToolCall(tc);
-						ctx.provider.appendChannel(ctx.name, args, {
-							kind: "tool_call",
-							toolCall: {
-								name: tc.toolName,
-								args
-							}
-						}).catch(() => {});
-					}
+				if (step.toolCalls?.length && ctx.eventLog) {
+					for (const tc of step.toolCalls) if (tc.toolName === "bash") ctx.eventLog.toolCall(ctx.name, tc.toolName, formatToolCall(tc), "sdk");
 				}
 			}
 		});
@@ -832,7 +823,7 @@ async function runSdkAgent(ctx, debugLog) {
 		if (ctx.agent.max_steps && result.steps.length >= ctx.agent.max_steps && (lastStep?.toolCalls?.length ?? 0) > 0) {
 			const warning = `⚠️  Agent reached max_steps limit (${ctx.agent.max_steps}) but wanted to continue. Consider increasing max_steps or removing the limit.`;
 			log(warning);
-			await ctx.provider.appendChannel(ctx.name, warning, { kind: "log" }).catch(() => {});
+			await ctx.provider.appendChannel(ctx.name, warning, { kind: "system" }).catch(() => {});
 		}
 		await mcp.close();
 		return {
@@ -868,7 +859,7 @@ function shouldContinue(state) {
 * 5. Can be woken early via wake()
 */
 function createAgentController(config) {
-	const { name, agent, contextProvider, mcpUrl, workspaceDir, projectDir, backend, onRunComplete, log = () => {}, feedback } = config;
+	const { name, agent, contextProvider, eventLog, 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;
@@ -934,6 +925,7 @@ function createAgentController(config) {
 					projectDir,
 					retryAttempt: attempt,
 					provider: contextProvider,
+					eventLog,
 					feedback
 				}, log, infoLog);
 				if (lastResult.success) {
@@ -1016,7 +1008,7 @@ function createAgentController(config) {
 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));
+	if (backend.type === "default") return runSdkAgent(ctx, (msg) => log(msg));
 	const startTime = Date.now();
 	try {
 		if (backend.setWorkspace) {
@@ -1067,8 +1059,7 @@ 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;
-	if (options?.messageLog) backendOptions.messageLog = options.messageLog;
+	if (options?.streamCallbacks) backendOptions.streamCallbacks = options.streamCallbacks;
 	return createBackend({
 		type: backendType,
 		model: options?.model,
@@ -1084,7 +1075,7 @@ function getBackendByType(backendType, options) {
 function getBackendForModel(model, options) {
 	const { provider } = parseModel(model);
 	switch (provider) {
-		case "anthropic": return getBackendByType("sdk", {
+		case "anthropic": return getBackendByType("default", {
 			...options,
 			model
 		});
@@ -1354,9 +1345,11 @@ function startChannelWatcher(config) {
 * Workflow Runner
 *
 * All output flows through the channel:
-* - Operational events (init, setup, connect) → kind="log" (always visible)
+* - Operational events (init, setup, connect) → kind="system" (always visible)
 * - Debug details (MCP traces, idle checks) → kind="debug" (visible with --debug)
-* - Agent messages → kind=undefined (always visible)
+* - 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.
 */
@@ -1421,6 +1414,8 @@ async function initWorkflow(config) {
 	}
 	const projectDir = process.cwd();
 	let mcpGetFeedback;
+	let mcpToolNames = /* @__PURE__ */ new Set();
+	const eventLog = new EventLog(contextProvider);
 	const createMCPServerInstance = () => {
 		const mcp = createContextMCPServer({
 			provider: contextProvider,
@@ -1432,6 +1427,7 @@ async function initWorkflow(config) {
 			debugLog
 		});
 		mcpGetFeedback = mcp.getFeedback;
+		mcpToolNames = mcp.mcpToolNames;
 		return mcp.server;
 	};
 	const httpMcpServer = await runWithHttp({
@@ -1468,9 +1464,11 @@ async function initWorkflow(config) {
 		contextDir,
 		projectDir,
 		contextProvider,
+		eventLog,
 		httpMcpServer,
 		mcpUrl: httpMcpServer.url,
 		agentNames,
+		mcpToolNames,
 		setupResults,
 		async sendKickoff() {
 			if (!interpolatedKickoff) {
@@ -1574,23 +1572,23 @@ async function runWorkflowWithControllers(config) {
 				model: agentDef.model
 			});
 			const agentLogger = logger.child(agentName);
-			const backendDebugLog = (msg) => {
-				agentLogger.debug(msg);
-			};
-			const backendMessageLog = (msg) => {
-				runtime.contextProvider.appendChannel(agentName, msg, { kind: "stream" }).catch(() => {});
+			const streamCallbacks = {
+				debugLog: (msg) => agentLogger.debug(msg),
+				outputLog: (msg) => runtime.eventLog.output(agentName, msg),
+				toolCallLog: (name, args) => runtime.eventLog.toolCall(agentName, name, args, "backend"),
+				mcpToolNames: runtime.mcpToolNames
 			};
 			let backend;
 			if (createBackend) backend = createBackend(agentName, agentDef);
 			else if (agentDef.backend) backend = getBackendByType(agentDef.backend, {
 				model: agentDef.model,
-				debugLog: backendDebugLog,
-				messageLog: backendMessageLog,
+				debugLog: (msg) => agentLogger.debug(msg),
+				streamCallbacks,
 				timeout: agentDef.timeout
 			});
 			else if (agentDef.model) backend = getBackendForModel(agentDef.model, {
-				debugLog: backendDebugLog,
-				messageLog: backendMessageLog
+				debugLog: (msg) => agentLogger.debug(msg),
+				streamCallbacks
 			});
 			else throw new Error(`Agent "${agentName}" requires either a backend or model field`);
 			logger.debug(`Using backend: ${backend.type} for ${agentName}`);
@@ -1601,6 +1599,7 @@ async function runWorkflowWithControllers(config) {
 				name: agentName,
 				agent: agentDef,
 				contextProvider: runtime.contextProvider,
+				eventLog: runtime.eventLog,
 				mcpUrl: runtime.mcpUrl,
 				workspaceDir,
 				projectDir: runtime.projectDir,
@@ -1620,7 +1619,7 @@ async function runWorkflowWithControllers(config) {
 		logger.debug("Kickoff sent");
 		let channelWatcher;
 		if (config.prettyDisplay) {
-			const { startPrettyDisplay } = await import("./display-pretty-BL9H2ocr.mjs");
+			const { startPrettyDisplay } = await import("./display-pretty-BsCsnPqs.mjs");
 			channelWatcher = startPrettyDisplay({
 				contextProvider: runtime.contextProvider,
 				agentNames: runtime.agentNames,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-worker",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "SDK and CLI for creating and testing agent workers with Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -37,6 +37,8 @@
     "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",
     "picocolors": "^1.1.1",

package/dist/backends-e6gCxRZ9.mjs

@@ -1,3 +0,0 @@
-import { C as SDK_MODEL_ALIASES, S as CURSOR_MODEL_MAP, _ as execWithIdleTimeout, a as createMockBackend, b as CLAUDE_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 DEFAULT_IDLE_TIMEOUT, w as getModelForBackend, x as CODEX_MODEL_MAP, y as BACKEND_DEFAULT_MODELS } from "./backends-BOAkfYyL.mjs";
-
-export { listBackends };

package/dist/context-dgI2YCGG.mjs

@@ -1,4 +0,0 @@
-import { _ as shouldUseResource, a as FileStorage, 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 } from "./cli/index.mjs";
-import { a as createMemoryContextProvider, i as MemoryContextProvider, n as formatProposal, r as formatProposalList, t as createContextMCPServer } from "./mcp-server-BQCQxv2v.mjs";
-
-export { createFileContextProvider };