agent-worker 0.1.0

package/dist/models-FOOpWB91.mjs

@@ -0,0 +1,182 @@
+import { gateway } from "ai";
+
+//#region src/models.ts
+const providerCache = {};
+/**
+* Lazy load a provider, caching the result
+* Supports custom baseURL and apiKey for providers using compatible APIs (e.g., MiniMax using Claude API)
+*/
+async function loadProvider(name, packageName, exportName, options) {
+	if (name in providerCache) return providerCache[name];
+	try {
+		const module = await import(packageName);
+		if (options?.baseURL || options?.apiKeyEnvVar) {
+			const createProvider = module[`create${exportName.charAt(0).toUpperCase() + exportName.slice(1)}`];
+			if (createProvider) {
+				const providerOptions = {};
+				if (options.baseURL) providerOptions.baseURL = options.baseURL;
+				if (options.apiKeyEnvVar) providerOptions.apiKey = process.env[options.apiKeyEnvVar];
+				providerCache[name] = createProvider(providerOptions);
+				return providerCache[name];
+			}
+		}
+		providerCache[name] = module[exportName];
+		return providerCache[name];
+	} catch {
+		providerCache[name] = null;
+		return null;
+	}
+}
+/**
+* Parse model identifier and return the appropriate provider model
+*
+* Supports three formats:
+*
+* 1. Provider-only format: provider
+*    Uses first model from FRONTIER_MODELS via gateway
+*    Examples: anthropic → anthropic/claude-sonnet-4-5, openai → openai/gpt-5.2
+*
+* 2. Gateway format: provider/model-name
+*    Uses Vercel AI Gateway (requires AI_GATEWAY_API_KEY)
+*    Examples: anthropic/claude-sonnet-4-5, openai/gpt-5.2, deepseek/deepseek-chat
+*
+* 3. Direct provider format: provider:model-name
+*    Requires installing the specific @ai-sdk/provider package
+*    Examples: anthropic:claude-sonnet-4-5, openai:gpt-5.2, deepseek:deepseek-chat
+*/
+function createModel(modelId) {
+	if (modelId.includes("/")) return gateway(modelId);
+	if (!modelId.includes(":")) {
+		const provider = modelId;
+		if (provider in FRONTIER_MODELS) {
+			const defaultModel = FRONTIER_MODELS[provider][0];
+			return gateway(`${provider}/${defaultModel}`);
+		}
+		throw new Error(`Unknown provider: ${modelId}. Supported: ${Object.keys(FRONTIER_MODELS).join(", ")}`);
+	}
+	const colonIndex = modelId.indexOf(":");
+	const provider = modelId.slice(0, colonIndex);
+	const modelName = modelId.slice(colonIndex + 1);
+	if (!modelName) throw new Error(`Invalid model identifier: ${modelId}. Model name is required.`);
+	if (provider in providerCache && providerCache[provider]) return providerCache[provider](modelName);
+	throw new Error(`Provider '${provider}' not loaded. Use gateway format (${provider}/${modelName}) or call createModelAsync() for direct provider access.`);
+}
+/**
+* Async version of createModel - supports lazy loading of direct providers
+* Use this when you need direct provider access (provider:model format)
+*/
+async function createModelAsync(modelId) {
+	if (modelId.includes("/")) return gateway(modelId);
+	if (!modelId.includes(":")) {
+		const provider = modelId;
+		if (provider in FRONTIER_MODELS) {
+			const defaultModel = FRONTIER_MODELS[provider][0];
+			return gateway(`${provider}/${defaultModel}`);
+		}
+		throw new Error(`Unknown provider: ${modelId}. Supported: ${Object.keys(FRONTIER_MODELS).join(", ")}`);
+	}
+	const colonIndex = modelId.indexOf(":");
+	const provider = modelId.slice(0, colonIndex);
+	const modelName = modelId.slice(colonIndex + 1);
+	if (!modelName) throw new Error(`Invalid model identifier: ${modelId}. Model name is required.`);
+	const providerConfigs = {
+		anthropic: {
+			package: "@ai-sdk/anthropic",
+			export: "anthropic"
+		},
+		openai: {
+			package: "@ai-sdk/openai",
+			export: "openai"
+		},
+		deepseek: {
+			package: "@ai-sdk/deepseek",
+			export: "deepseek"
+		},
+		google: {
+			package: "@ai-sdk/google",
+			export: "google"
+		},
+		groq: {
+			package: "@ai-sdk/groq",
+			export: "groq"
+		},
+		mistral: {
+			package: "@ai-sdk/mistral",
+			export: "mistral"
+		},
+		xai: {
+			package: "@ai-sdk/xai",
+			export: "xai"
+		},
+		minimax: {
+			package: "@ai-sdk/anthropic",
+			export: "anthropic",
+			options: {
+				baseURL: "https://api.minimax.chat/v1",
+				apiKeyEnvVar: "MINIMAX_API_KEY"
+			}
+		}
+	};
+	const config = providerConfigs[provider];
+	if (!config) throw new Error(`Unknown provider: ${provider}. Supported: ${Object.keys(providerConfigs).join(", ")}. Or use gateway format: provider/model (e.g., openai/gpt-5.2)`);
+	const providerFn = await loadProvider(provider, config.package, config.export, config.options);
+	if (!providerFn) throw new Error(`Install ${config.package} to use ${provider} models directly`);
+	return providerFn(modelName);
+}
+/**
+* List of supported providers for direct access
+* Note: minimax uses Claude-compatible API via @ai-sdk/anthropic with custom baseURL
+*/
+const SUPPORTED_PROVIDERS = [
+	"anthropic",
+	"openai",
+	"deepseek",
+	"google",
+	"groq",
+	"mistral",
+	"xai",
+	"minimax"
+];
+/**
+* Default provider when none specified
+*/
+const DEFAULT_PROVIDER = "anthropic";
+/**
+* Get the default model identifier (provider/model format)
+* Uses the first model from the default provider
+*/
+function getDefaultModel() {
+	return `${DEFAULT_PROVIDER}/${FRONTIER_MODELS[DEFAULT_PROVIDER][0]}`;
+}
+/**
+* Frontier models for each provider (as of 2026-02)
+* Only includes the latest/best models, no legacy versions
+*
+* Note: Some models may be placeholders for testing or future releases.
+* Always verify model availability with the provider before production use.
+*/
+const FRONTIER_MODELS = {
+	anthropic: [
+		"claude-sonnet-4-5",
+		"claude-haiku-4-5",
+		"claude-opus-4-5"
+	],
+	openai: ["gpt-5.2", "gpt-5.2-codex"],
+	google: [
+		"gemini-3-pro-preview",
+		"gemini-2.5-flash",
+		"gemini-2.5-pro"
+	],
+	deepseek: ["deepseek-chat", "deepseek-reasoner"],
+	groq: ["meta-llama/llama-4-scout-17b-16e-instruct", "deepseek-r1-distill-llama-70b"],
+	mistral: [
+		"mistral-large-latest",
+		"pixtral-large-latest",
+		"magistral-medium-2506"
+	],
+	xai: ["grok-4", "grok-4-fast-reasoning"],
+	minimax: ["MiniMax-M2"]
+};
+
+//#endregion
+export { getDefaultModel as a, createModelAsync as i, SUPPORTED_PROVIDERS as n, createModel as r, FRONTIER_MODELS as t };

package/dist/session-DQQAmPf-.mjs

@@ -0,0 +1,419 @@
+import { i as createModelAsync } from "./models-FOOpWB91.mjs";
+import { ToolLoopAgent, jsonSchema, stepCountIs, tool } from "ai";
+
+//#region src/tools.ts
+/**
+* Convert ToolDefinition array to AI SDK tools object
+* Uses tool() with jsonSchema() for runtime-defined mock tools
+*/
+function createTools(definitions) {
+	const tools = {};
+	for (const def of definitions) {
+		const schema = jsonSchema(def.parameters);
+		tools[def.name] = tool({
+			description: def.description,
+			inputSchema: schema,
+			execute: async (input) => {
+				if (def.execute) return def.execute(input);
+				return { error: "No mock implementation provided" };
+			}
+		});
+	}
+	return tools;
+}
+
+//#endregion
+//#region src/session.ts
+/**
+* AgentSession - Stateful session for controlled agent testing
+*
+* 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.
+*/
+var AgentSession = class {
+	id;
+	model;
+	system;
+	createdAt;
+	tools;
+	maxTokens;
+	maxSteps;
+	messages = [];
+	totalUsage = {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+	pendingApprovals = [];
+	cachedAgent = null;
+	toolsChanged = false;
+	/**
+	* 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 ?? [];
+		this.maxTokens = config.maxTokens ?? 4096;
+		this.maxSteps = config.maxSteps ?? 10;
+	}
+	/**
+	* Check if a tool needs approval for given arguments
+	*/
+	toolNeedsApproval(tool, args) {
+		if (!tool.needsApproval) return false;
+		if (typeof tool.needsApproval === "function") return tool.needsApproval(args);
+		return tool.needsApproval;
+	}
+	/**
+	* Build tools with approval handling
+	*/
+	buildTools(autoApprove) {
+		if (this.tools.length === 0) return void 0;
+		return createTools(this.tools.map((tool) => ({
+			...tool,
+			execute: async (args) => {
+				if (!autoApprove && this.toolNeedsApproval(tool, args)) {
+					const approval = {
+						id: crypto.randomUUID(),
+						toolName: tool.name,
+						toolCallId: crypto.randomUUID(),
+						arguments: args,
+						requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+						status: "pending"
+					};
+					this.pendingApprovals.push(approval);
+					return {
+						__approvalRequired: true,
+						approvalId: approval.id
+					};
+				}
+				if (tool.execute) return tool.execute(args);
+				if (tool.mockResponse !== void 0) return tool.mockResponse;
+				return { error: "No mock implementation provided" };
+			}
+		})));
+	}
+	/**
+	* 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 and get the agent's response
+	* Conversation state is maintained across calls
+	*
+	* @param content - The message to send
+	* @param options - Send options (autoApprove, onStepFinish, etc.)
+	*/
+	async send(content, options = {}) {
+		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;
+		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
+	* Returns an async iterable of text chunks
+	*
+	* @param content - The message to send
+	* @param options - Send options (autoApprove, onStepFinish, etc.)
+	*/
+	async *sendStream(content, options = {}) {
+		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 a tool definition with mock implementation
+	*/
+	addTool(tool) {
+		this.tools.push(tool);
+		this.toolsChanged = true;
+		this.cachedAgent = null;
+	}
+	/**
+	* Set mock response for an existing tool
+	*/
+	mockTool(name, mockFn) {
+		const tool = this.tools.find((t) => t.name === name);
+		if (tool) {
+			tool.execute = mockFn;
+			this.toolsChanged = true;
+			this.cachedAgent = null;
+		} else throw new Error(`Tool not found: ${name}`);
+	}
+	/**
+	* Get current tool definitions (without execute functions)
+	*/
+	getTools() {
+		return this.tools.map((t) => ({
+			name: t.name,
+			description: t.description,
+			parameters: t.parameters,
+			needsApproval: t.needsApproval,
+			mockResponse: t.mockResponse
+		}));
+	}
+	/**
+	* Set a static mock response for an existing tool (JSON-serializable)
+	*/
+	setMockResponse(name, response) {
+		const tool = this.tools.find((t) => t.name === name);
+		if (tool) {
+			tool.mockResponse = response;
+			this.toolsChanged = true;
+			this.cachedAgent = null;
+		} else throw new Error(`Tool not found: ${name}`);
+	}
+	/**
+	* Get conversation history with status information
+	* Messages with status 'responding' are still being generated
+	*/
+	history() {
+		return [...this.messages];
+	}
+	/**
+	* Get session statistics
+	*/
+	stats() {
+		return {
+			messageCount: this.messages.length,
+			usage: { ...this.totalUsage }
+		};
+	}
+	/**
+	* Export full transcript for analysis
+	*/
+	export() {
+		return {
+			sessionId: this.id,
+			model: this.model,
+			system: this.system,
+			messages: [...this.messages],
+			totalUsage: { ...this.totalUsage },
+			createdAt: this.createdAt
+		};
+	}
+	/**
+	* Get session state for persistence
+	*/
+	getState() {
+		return {
+			id: this.id,
+			createdAt: this.createdAt,
+			messages: [...this.messages],
+			totalUsage: { ...this.totalUsage },
+			pendingApprovals: [...this.pendingApprovals]
+		};
+	}
+	/**
+	* Get all pending approvals
+	*/
+	getPendingApprovals() {
+		return this.pendingApprovals.filter((p) => p.status === "pending");
+	}
+	/**
+	* Approve a pending tool call and execute it
+	* @returns The tool execution result
+	*/
+	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 tool = this.tools.find((t) => t.name === approval.toolName);
+		if (!tool) throw new Error(`Tool not found: ${approval.toolName}`);
+		let result;
+		if (tool.execute) result = await tool.execute(approval.arguments);
+		else result = { error: "No mock implementation provided" };
+		approval.status = "approved";
+		return result;
+	}
+	/**
+	* Deny a pending tool call
+	* @param approvalId - The approval ID to deny
+	* @param reason - Optional reason for denial
+	*/
+	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 conversation history (keep system prompt and tools)
+	*/
+	clear() {
+		this.messages = [];
+		this.totalUsage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		this.pendingApprovals = [];
+	}
+};
+
+//#endregion
+export { createTools as n, AgentSession as t };

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "agent-worker",
+  "version": "0.1.0",
+  "description": "SDK and CLI for creating and testing agent workers with Vercel AI SDK",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "agent-worker": "./dist/cli/index.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "bun test",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint src --fix",
+    "format": "oxfmt src",
+    "format:check": "oxfmt src --check",
+    "typecheck": "tsgo",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "ai": "^6.0.69",
+    "bash-tool": "^1.3.12",
+    "commander": "^14.0.3",
+    "just-bash": "^2.8.0"
+  },
+  "devDependencies": {
+    "@ai-sdk/anthropic": "^3.0.0",
+    "@ai-sdk/deepseek": "^1.0.0",
+    "@ai-sdk/google": "^1.0.0",
+    "@ai-sdk/groq": "^1.0.0",
+    "@ai-sdk/mistral": "^1.0.0",
+    "@ai-sdk/openai": "^3.0.0",
+    "@ai-sdk/xai": "^1.0.0",
+    "@types/bun": "latest",
+    "@typescript/native-preview": "^7.0.0-dev.20260203.1",
+    "oxfmt": "^0.28.0",
+    "oxlint": "^1.43.0",
+    "tsdown": "^0.20.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5",
+    "@ai-sdk/anthropic": "^3.0.0",
+    "@ai-sdk/openai": "^3.0.0",
+    "@ai-sdk/deepseek": "^1.0.0",
+    "@ai-sdk/google": "^1.0.0",
+    "@ai-sdk/groq": "^1.0.0",
+    "@ai-sdk/mistral": "^1.0.0",
+    "@ai-sdk/xai": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@ai-sdk/anthropic": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@ai-sdk/deepseek": {
+      "optional": true
+    },
+    "@ai-sdk/google": {
+      "optional": true
+    },
+    "@ai-sdk/groq": {
+      "optional": true
+    },
+    "@ai-sdk/mistral": {
+      "optional": true
+    },
+    "@ai-sdk/xai": {
+      "optional": true
+    }
+  }
+}