agent-worker 0.13.0 → 0.15.0

package/dist/index.mjs

@@ -1,15 +1,459 @@
-import { M as SUPPORTED_PROVIDERS, N as createModel, P as createModelAsync, a as createMockBackend, d as CodexBackend, f as ClaudeCodeBackend, i as MockAIBackend, j as FRONTIER_MODELS, n as createBackend, o as SdkBackend, r as listBackends, t as checkBackends, u as CursorBackend } from "./backends-CziIqKRg.mjs";
-import { t as AgentWorker } from "./worker-DBJ8136Q.mjs";
-import { jsonSchema, tool } from "ai";
+import { F as createModelWithProvider, M as SUPPORTED_PROVIDERS, N as createModel, P as createModelAsync, a as createMockBackend, d as CodexBackend, f as ClaudeCodeBackend, i as MockAIBackend, j as FRONTIER_MODELS, n as createBackend, o as SdkBackend, r as listBackends, t as checkBackends, u as CursorBackend } from "./backends-C7pQwuAx.mjs";
+import { t as createTool } from "./create-tool-gcUuI1FD.mjs";
+import { ToolLoopAgent, stepCountIs } from "ai";
 import { createBashTool } from "bash-tool";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, normalize } from "node:path";
-import { parse } from "yaml";
 import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import { parse } from "yaml";
 import { z } from "zod";
 import { tmpdir } from "node:os";
 import { spawn } from "node:child_process";
 
+//#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;
+	provider;
+	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;
+		this.provider = config.provider;
+	}
+	/**
+	* 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: this.provider ? await createModelWithProvider(this.model, this.provider) : 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
 //#region src/agent/tools/bash.ts
 /**
 * Integration with Vercel's bash-tool for file system operations
@@ -36,41 +480,41 @@ async function createBashTools(options = {}) {
 	const { includeReadFile = true, includeWriteFile = true, ...bashOptions } = options;
 	const toolkit = await createBashTool(bashOptions);
 	const tools = {};
-	tools.bash = tool({
+	tools.bash = createTool({
 		description: "Execute bash commands in a sandboxed environment. Returns stdout, stderr, and exit code.",
-		inputSchema: jsonSchema({
+		schema: {
 			type: "object",
 			properties: { command: {
 				type: "string",
 				description: "The bash command to execute"
 			} },
 			required: ["command"]
-		}),
+		},
 		execute: async (args) => {
 			const bashTool = toolkit.tools.bash;
 			if (!bashTool?.execute) throw new Error("Bash tool not available");
 			return bashTool.execute(args, {});
 		}
 	});
-	if (includeReadFile) tools.readFile = tool({
+	if (includeReadFile) tools.readFile = createTool({
 		description: "Read the contents of a file from the sandbox filesystem.",
-		inputSchema: jsonSchema({
+		schema: {
 			type: "object",
 			properties: { path: {
 				type: "string",
 				description: "The path to the file to read"
 			} },
 			required: ["path"]
-		}),
+		},
 		execute: async (args) => {
 			const readFileTool = toolkit.tools.readFile;
 			if (!readFileTool?.execute) throw new Error("ReadFile tool not available");
 			return readFileTool.execute(args, {});
 		}
 	});
-	if (includeWriteFile) tools.writeFile = tool({
+	if (includeWriteFile) tools.writeFile = createTool({
 		description: "Write content to a file in the sandbox filesystem. Creates parent directories if needed.",
-		inputSchema: jsonSchema({
+		schema: {
 			type: "object",
 			properties: {
 				path: {
@@ -83,7 +527,7 @@ async function createBashTools(options = {}) {
 				}
 			},
 			required: ["path", "content"]
-		}),
+		},
 		execute: async (args) => {
 			const writeFileTool = toolkit.tools.writeFile;
 			if (!writeFileTool?.execute) throw new Error("WriteFile tool not available");
@@ -152,9 +596,9 @@ function createFeedbackTool(options = {}) {
 	const { onFeedback, maxEntries = 50 } = options;
 	const entries = [];
 	return {
-		tool: tool({
+		tool: createTool({
 			description: "Report a workflow improvement need. Use when you hit something inconvenient — a missing tool, an awkward step, or a capability you wished you had.",
-			inputSchema: jsonSchema({
+			schema: {
 				type: "object",
 				properties: {
 					target: {
@@ -184,7 +628,7 @@ function createFeedbackTool(options = {}) {
 					"type",
 					"description"
 				]
-			}),
+			},
 			execute: async (args) => {
 				const validTypes = [
 					"missing",
@@ -220,7 +664,7 @@ const frontmatterSchema = z.object({
 	description: z.string().min(1).max(1024),
 	license: z.string().optional(),
 	compatibility: z.string().max(500).optional(),
-	metadata: z.record(z.string()).optional(),
+	metadata: z.record(z.string(), z.string()).optional(),
 	"allowed-tools": z.string().optional()
 });
 var SkillsProvider = class {
@@ -374,9 +818,9 @@ var SkillsProvider = class {
 * Create a Skills tool as an AI SDK tool() object
 */
 function createSkillsTool(provider) {
-	return tool({
+	return createTool({
 		description: "Interact with available agent skills. Use \"list\" to see all skills with their descriptions, \"view\" to read a complete SKILL.md file, \"readFile\" to read files within a skill directory (e.g., references/, scripts/, assets/).",
-		inputSchema: jsonSchema({
+		schema: {
 			type: "object",
 			properties: {
 				operation: {
@@ -398,7 +842,7 @@ function createSkillsTool(provider) {
 				}
 			},
 			required: ["operation"]
-		}),
+		},
 		execute: async (args) => {
 			const operation = args.operation;
 			const skillName = args.skillName;
@@ -664,4 +1108,4 @@ var SkillImporter = class {
 };
 
 //#endregion
-export { AgentWorker as AgentSession, AgentWorker, ClaudeCodeBackend, CodexBackend, CursorBackend, FEEDBACK_PROMPT, FRONTIER_MODELS, MockAIBackend, SUPPORTED_PROVIDERS, SdkBackend, SkillImporter, SkillsProvider, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createFeedbackTool, createMockBackend, createModel, createModelAsync, createSkillsTool, getSpecDisplayName, listBackends, parseImportSpec };
+export { AgentWorker, ClaudeCodeBackend, CodexBackend, CursorBackend, FEEDBACK_PROMPT, FRONTIER_MODELS, MockAIBackend, SUPPORTED_PROVIDERS, SdkBackend, SkillImporter, SkillsProvider, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createFeedbackTool, createMockBackend, createModel, createModelAsync, createSkillsTool, getSpecDisplayName, listBackends, parseImportSpec };

package/dist/{memory-provider-BtLYtdQH.mjs → memory-provider-ZLOKyCxA.mjs}

@@ -1,16 +1,21 @@
-import { o as MemoryStorage, s as ContextProviderImpl } from "./cli/index.mjs";
+import { C as DefaultDocumentStore, D as MemoryStorage, O as ContextProviderImpl, S as DefaultResourceStore, T as DefaultChannelStore, w as DefaultInboxStore, x as DefaultStatusStore } from "./cli/index.mjs";
 
 //#region src/workflow/context/memory-provider.ts
 /**
 * In-memory ContextProvider for testing.
-* All domain logic is inherited from ContextProviderImpl;
+* All domain logic is in the composed stores;
 * this class adds test helpers for inspection and cleanup.
 */
 var MemoryContextProvider = class extends ContextProviderImpl {
 	memoryStorage;
 	constructor(validAgents) {
 		const storage = new MemoryStorage();
-		super(storage, validAgents);
+		const channel = new DefaultChannelStore(storage, validAgents);
+		const inbox = new DefaultInboxStore(channel, storage);
+		const documents = new DefaultDocumentStore(storage);
+		const resources = new DefaultResourceStore(storage);
+		const status = new DefaultStatusStore(storage);
+		super(channel, inbox, documents, resources, status, validAgents);
 		this.memoryStorage = storage;
 	}
 	/** Get underlying MemoryStorage (for testing) */