agent-worker 0.12.0 → 0.13.0

package/dist/backends-BWzhErjT.mjs

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

package/dist/{backends-DLaP0rMW.mjs → backends-CziIqKRg.mjs}

@@ -6,30 +6,45 @@ import { stringify } from "yaml";
 
 //#region src/agent/models.ts
 const providerCache = {};
+/** Provider SDK package mapping */
+const PROVIDER_PACKAGES = {
+	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"
+	}
+};
 /**
-* Lazy load a provider, caching the result
-* Supports custom baseURL and apiKey for providers using compatible APIs (e.g., MiniMax using Claude API)
+* Lazy load a provider SDK, caching the result.
+* Only caches standard providers (no custom baseURL/apiKey).
 */
-async function loadProvider(name, packageName, exportName, options) {
+async function loadProvider(name, packageName, exportName) {
 	if (name in providerCache) return providerCache[name] ?? null;
 	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) {
-					const apiKey = process.env[options.apiKeyEnvVar];
-					if (!apiKey) throw new Error(`Environment variable ${options.apiKeyEnvVar} is not set (required for ${name} provider)`);
-					providerOptions.apiKey = apiKey;
-				}
-				const provider = createProvider(providerOptions);
-				providerCache[name] = provider;
-				return provider;
-			}
-		}
-		const exportedProvider = module[exportName];
+		const exportedProvider = (await import(packageName))[exportName];
 		providerCache[name] = exportedProvider;
 		return exportedProvider;
 	} catch {
@@ -38,6 +53,55 @@ async function loadProvider(name, packageName, exportName, options) {
 	}
 }
 /**
+* Create a provider instance with custom baseURL and/or apiKey.
+* Not cached — each call creates a fresh instance.
+*/
+async function createCustomProvider(packageName, exportName, options) {
+	const createFn = (await import(packageName))[`create${exportName.charAt(0).toUpperCase() + exportName.slice(1)}`];
+	if (!createFn) throw new Error(`Package ${packageName} does not export create${exportName.charAt(0).toUpperCase() + exportName.slice(1)}`);
+	return createFn(options);
+}
+/**
+* Resolve api_key field: '$ENV_VAR' → process.env.ENV_VAR, literal → as-is
+*/
+function resolveApiKey(apiKey) {
+	if (apiKey.startsWith("$")) {
+		const envVar = apiKey.slice(1);
+		const value = process.env[envVar];
+		if (!value) throw new Error(`Environment variable ${envVar} is not set`);
+		return value;
+	}
+	return apiKey;
+}
+/**
+* Create a model using explicit provider configuration.
+* Use this when provider details (base_url, api_key) are specified separately from the model name.
+*
+* Example:
+*   createModelWithProvider("MiniMax-M2.5", { name: "anthropic", base_url: "https://api.minimax.io/anthropic/v1", api_key: "$MINIMAX_API_KEY" })
+*/
+async function createModelWithProvider(modelName, provider) {
+	if (typeof provider === "string") {
+		const pkg = PROVIDER_PACKAGES[provider];
+		if (!pkg) throw new Error(`Unknown provider: ${provider}. Supported: ${Object.keys(PROVIDER_PACKAGES).join(", ")}`);
+		const providerFn = await loadProvider(provider, pkg.package, pkg.export);
+		if (!providerFn) throw new Error(`Install ${pkg.package} to use ${provider} models directly`);
+		return providerFn(modelName);
+	}
+	const { name, base_url, api_key } = provider;
+	const pkg = PROVIDER_PACKAGES[name];
+	if (!pkg) throw new Error(`Unknown provider: ${name}. Supported: ${Object.keys(PROVIDER_PACKAGES).join(", ")}`);
+	if (!base_url && !api_key) {
+		const providerFn = await loadProvider(name, pkg.package, pkg.export);
+		if (!providerFn) throw new Error(`Install ${pkg.package} to use ${name} models directly`);
+		return providerFn(modelName);
+	}
+	const opts = {};
+	if (base_url) opts.baseURL = base_url;
+	if (api_key) opts.apiKey = resolveApiKey(api_key);
+	return (await createCustomProvider(pkg.package, pkg.export, opts))(modelName);
+}
+/**
 * Parse model identifier and return the appropriate provider model
 *
 * Supports three formats:
@@ -89,61 +153,14 @@ async function createModelAsync(modelId) {
 	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.io/anthropic/v1",
-				apiKeyEnvVar: "MINIMAX_API_KEY"
-			}
-		},
-		minimax_cn: {
-			package: "@ai-sdk/anthropic",
-			export: "anthropic",
-			options: {
-				baseURL: "https://api.minimaxi.com/anthropic/v1",
-				apiKeyEnvVar: "MINIMAX_CN_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);
+	const config = PROVIDER_PACKAGES[provider];
+	if (!config) throw new Error(`Unknown provider: ${provider}. Supported: ${Object.keys(PROVIDER_PACKAGES).join(", ")}. Or use gateway format: provider/model (e.g., openai/gpt-5.2)`);
+	const providerFn = await loadProvider(provider, config.package, config.export);
 	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",
@@ -152,8 +169,7 @@ const SUPPORTED_PROVIDERS = [
 	"google",
 	"groq",
 	"mistral",
-	"xai",
-	"minimax"
+	"xai"
 ];
 /**
 * Default provider when none specified
@@ -192,8 +208,7 @@ const FRONTIER_MODELS = {
 		"pixtral-large-latest",
 		"magistral-medium-2506"
 	],
-	xai: ["grok-4", "grok-4-fast-reasoning"],
-	minimax: ["MiniMax-M2"]
+	xai: ["grok-4", "grok-4-fast-reasoning"]
 };
 
 //#endregion
@@ -209,7 +224,8 @@ const BACKEND_DEFAULT_MODELS = {
 	default: "claude-sonnet-4-5",
 	claude: "sonnet",
 	cursor: "sonnet-4.5",
-	codex: "gpt-5.2-codex"
+	codex: "gpt-5.2-codex",
+	opencode: "deepseek/deepseek-chat"
 };
 /**
 * Model aliases for SDK (Anthropic format)
@@ -272,6 +288,22 @@ const CODEX_MODEL_MAP = {
 	"o3-mini": "o3-mini"
 };
 /**
+* Model translation for OpenCode CLI backend
+* OpenCode uses provider/model format natively
+*/
+const OPENCODE_MODEL_MAP = {
+	"deepseek-chat": "deepseek/deepseek-chat",
+	"deepseek-reasoner": "deepseek/deepseek-reasoner",
+	"deepseek/deepseek-chat": "deepseek/deepseek-chat",
+	"deepseek/deepseek-reasoner": "deepseek/deepseek-reasoner",
+	sonnet: "anthropic/claude-sonnet-4-5-20250514",
+	opus: "anthropic/claude-opus-4-20250514",
+	"claude-sonnet-4-5": "anthropic/claude-sonnet-4-5-20250514",
+	"claude-opus-4": "anthropic/claude-opus-4-20250514",
+	"gpt-5.2": "openai/gpt-5.2",
+	o3: "openai/o3"
+};
+/**
 * Get the model name for a specific backend
 * Translates generic model names to backend-specific format
 */
@@ -283,6 +315,7 @@ function getModelForBackend(model, backend) {
 		case "cursor": return CURSOR_MODEL_MAP[model] || CURSOR_MODEL_MAP[normalizedModel] || normalizedModel;
 		case "claude": return CLAUDE_MODEL_MAP[model] || CLAUDE_MODEL_MAP[normalizedModel] || normalizedModel;
 		case "codex": return CODEX_MODEL_MAP[model] || CODEX_MODEL_MAP[normalizedModel] || normalizedModel;
+		case "opencode": return OPENCODE_MODEL_MAP[model] || OPENCODE_MODEL_MAP[normalizedModel] || model;
 		default: return normalizedModel;
 	}
 }
@@ -931,8 +964,7 @@ var CodexBackend = class {
 //#region src/backends/cursor.ts
 /**
 * Cursor CLI backend
-* Uses `cursor agent -p` (preferred) or `cursor-agent -p` (fallback)
-* for non-interactive mode with stream-json output
+* Uses `cursor agent -p` for non-interactive mode with stream-json output
 *
 * MCP Configuration:
 * Cursor uses project-level MCP config via .cursor/mcp.json in the workspace.
@@ -943,7 +975,7 @@ var CodexBackend = class {
 var CursorBackend = class {
 	type = "cursor";
 	options;
-	/** Resolved command: "cursor" (subcommand style) or "cursor-agent" (standalone) */
+	/** Resolved command: "cursor" (subcommand style) */
 	resolvedCommand = null;
 	constructor(options = {}) {
 		this.options = {
@@ -994,7 +1026,7 @@ var CursorBackend = class {
 	}
 	/**
 	* Resolve which cursor command is available.
-	* Prefers `cursor agent` (subcommand), falls back to `cursor-agent` (standalone).
+	* Checks `cursor agent --version` (subcommand style).
 	* Result is cached after first resolution.
 	*/
 	async resolveCommand() {
@@ -1007,14 +1039,6 @@ var CursorBackend = class {
 			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) {
@@ -1027,16 +1051,161 @@ var CursorBackend = class {
 			message
 		];
 		if (this.options.model) agentArgs.push("--model", this.options.model);
-		if (cmd === "cursor") return {
+		if (!cmd) throw new Error("cursor agent CLI not found");
+		return {
 			command: "cursor",
 			args: ["agent", ...agentArgs]
 		};
+	}
+};
+
+//#endregion
+//#region src/backends/opencode.ts
+/**
+* OpenCode CLI backend
+* Uses `opencode run` for non-interactive mode with JSON event output
+*
+* MCP Configuration:
+* OpenCode uses project-level MCP config via opencode.json in the workspace.
+* Use setWorkspace() to set up a dedicated workspace with MCP config.
+*
+* @see https://opencode.ai/docs/
+*/
+var OpenCodeBackend = class {
+	type = "opencode";
+	options;
+	constructor(options = {}) {
+		this.options = {
+			timeout: DEFAULT_IDLE_TIMEOUT,
+			...options
+		};
+	}
+	/**
+	* Set up workspace directory with MCP config
+	* Creates opencode.json in the workspace with MCP server config
+	*/
+	setWorkspace(workspaceDir, mcpConfig) {
+		this.options.workspace = workspaceDir;
+		if (!existsSync(workspaceDir)) mkdirSync(workspaceDir, { recursive: true });
+		const opencodeMcp = {};
+		for (const [name, config] of Object.entries(mcpConfig.mcpServers)) {
+			const serverConfig = config;
+			opencodeMcp[name] = {
+				type: "local",
+				command: [serverConfig.command, ...serverConfig.args || []],
+				enabled: true,
+				...serverConfig.env ? { environment: serverConfig.env } : {}
+			};
+		}
+		const opencodeConfig = {
+			$schema: "https://opencode.ai/config.json",
+			mcp: opencodeMcp
+		};
+		writeFileSync(join(workspaceDir, "opencode.json"), JSON.stringify(opencodeConfig, null, 2));
+	}
+	async send(message, _options) {
+		const args = this.buildArgs(message);
+		const cwd = this.options.workspace || this.options.cwd;
+		const timeout = this.options.timeout ?? DEFAULT_IDLE_TIMEOUT;
+		try {
+			const { stdout } = await execWithIdleTimeout({
+				command: "opencode",
+				args,
+				cwd,
+				timeout,
+				onStdout: this.options.streamCallbacks ? createStreamParser(this.options.streamCallbacks, "OpenCode", opencodeAdapter) : void 0
+			});
+			return extractOpenCodeResult(stdout);
+		} catch (error) {
+			if (error instanceof IdleTimeoutError) throw new Error(`opencode timed out after ${timeout}ms of inactivity`);
+			if (error && typeof error === "object" && "exitCode" in error) {
+				const execError = error;
+				throw new Error(`opencode failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
+			}
+			throw error;
+		}
+	}
+	async isAvailable() {
+		try {
+			await execa("opencode", ["--version"], {
+				stdin: "ignore",
+				timeout: 5e3
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	getInfo() {
+		return {
+			name: "OpenCode CLI",
+			model: this.options.model
+		};
+	}
+	buildArgs(message) {
+		const args = [
+			"run",
+			"--format",
+			"json",
+			message
+		];
+		if (this.options.model) args.push("--model", this.options.model);
+		return args;
+	}
+};
+/**
+* Adapter for OpenCode --format json output.
+*
+* Events:
+*   { type: "step_start", sessionID: "..." }
+*   { type: "tool_use", part: { tool: "bash", state: { input: {...} } } }
+*   { type: "text", part: { text: "..." } }            → skipped (result only)
+*   { type: "step_finish", part: { cost, tokens } }
+*/
+const opencodeAdapter = (raw) => {
+	const event = raw;
+	if (event.type === "step_start") return {
+		kind: "init",
+		sessionId: event.sessionID
+	};
+	if (event.type === "tool_use") {
+		const { tool, state } = event.part;
+		const args = state.input ? JSON.stringify(state.input) : "";
 		return {
-			command: "cursor-agent",
-			args: agentArgs
+			kind: "tool_call",
+			name: tool,
+			args: args.length > 100 ? args.slice(0, 100) + "..." : args
+		};
+	}
+	if (event.type === "text") return { kind: "skip" };
+	if (event.type === "step_finish") {
+		const { cost, tokens } = event.part;
+		return {
+			kind: "completed",
+			costUsd: cost,
+			usage: tokens ? {
+				input: tokens.input,
+				output: tokens.output
+			} : void 0
 		};
 	}
+	return null;
 };
+/**
+* Extract final result from OpenCode --format json output.
+*
+* Priority:
+* 1. Last text event
+* 2. Raw stdout fallback
+*/
+function extractOpenCodeResult(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 === "text" && event.part?.text) return { content: event.part.text };
+	} catch {}
+	return { content: stdout.trim() };
+}
 
 //#endregion
 //#region src/backends/sdk.ts
@@ -1049,15 +1218,17 @@ var SdkBackend = class {
 	modelId;
 	model = null;
 	maxTokens;
+	provider;
 	constructor(options) {
 		this.modelId = options.model;
 		this.maxTokens = options.maxTokens ?? 4096;
-		try {
+		this.provider = options.provider;
+		if (!this.provider) try {
 			this.model = createModel(this.modelId);
 		} catch {}
 	}
 	async send(message, options) {
-		if (!this.model) this.model = await createModelAsync(this.modelId);
+		if (!this.model) this.model = this.provider ? await createModelWithProvider(this.modelId, this.provider) : await createModelAsync(this.modelId);
 		const result = await generateText({
 			model: this.model,
 			system: options?.system,
@@ -1075,7 +1246,7 @@ var SdkBackend = class {
 	}
 	async isAvailable() {
 		try {
-			if (!this.model) this.model = await createModelAsync(this.modelId);
+			if (!this.model) this.model = this.provider ? await createModelWithProvider(this.modelId, this.provider) : await createModelAsync(this.modelId);
 			return true;
 		} catch {
 			return false;
@@ -1133,10 +1304,14 @@ function createBackend(config) {
 	};
 	const model = getModelForBackend(normalized.model, normalized.type);
 	switch (normalized.type) {
-		case "default": return new SdkBackend({
-			model,
-			maxTokens: normalized.maxTokens
-		});
+		case "default": {
+			const provider = normalized.provider;
+			return new SdkBackend({
+				model,
+				maxTokens: normalized.maxTokens,
+				provider
+			});
+		}
 		case "claude": return new ClaudeCodeBackend({
 			...normalized.options,
 			model
@@ -1149,6 +1324,10 @@ function createBackend(config) {
 			...normalized.options,
 			model
 		});
+		case "opencode": return new OpenCodeBackend({
+			...normalized.options,
+			model
+		});
 		default: throw new Error(`Unknown backend type: ${normalized.type}`);
 	}
 }
@@ -1163,16 +1342,19 @@ async function checkBackends() {
 	const claude = new ClaudeCodeBackend();
 	const codex = new CodexBackend();
 	const cursor = new CursorBackend();
-	const [claudeAvailable, codexAvailable, cursorAvailable] = await Promise.all([
+	const opencode = new OpenCodeBackend();
+	const [claudeAvailable, codexAvailable, cursorAvailable, opencodeAvailable] = await Promise.all([
 		withTimeout(claude.isAvailable(), 3e3),
 		withTimeout(codex.isAvailable(), 3e3),
-		withTimeout(cursor.isAvailable(), 3e3)
+		withTimeout(cursor.isAvailable(), 3e3),
+		withTimeout(opencode.isAvailable(), 3e3)
 	]);
 	return {
 		default: true,
 		claude: claudeAvailable,
 		codex: codexAvailable,
 		cursor: cursorAvailable,
+		opencode: opencodeAvailable,
 		mock: true
 	};
 }
@@ -1201,9 +1383,14 @@ async function listBackends() {
 			type: "cursor",
 			available: availability.cursor,
 			name: "Cursor Agent CLI"
+		},
+		{
+			type: "opencode",
+			available: availability.opencode,
+			name: "OpenCode CLI"
 		}
 	];
 }
 
 //#endregion
-export { createModelAsync as A, SDK_MODEL_ALIASES as C, FRONTIER_MODELS as D, parseModel as E, SUPPORTED_PROVIDERS as O, CURSOR_MODEL_MAP as S, normalizeBackendType as T, execWithIdleTimeout as _, createMockBackend as a, CLAUDE_MODEL_MAP as b, CodexBackend as c, codexAdapter as d, createStreamParser as f, IdleTimeoutError as g, formatEvent as h, MockAIBackend as i, getDefaultModel as j, createModel 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, DEFAULT_IDLE_TIMEOUT as v, getModelForBackend as w, CODEX_MODEL_MAP as x, BACKEND_DEFAULT_MODELS as y };
+export { parseModel as A, CLAUDE_MODEL_MAP as C, SDK_MODEL_ALIASES as D, OPENCODE_MODEL_MAP as E, createModelWithProvider as F, getDefaultModel as I, SUPPORTED_PROVIDERS as M, createModel as N, getModelForBackend as O, createModelAsync as P, BACKEND_DEFAULT_MODELS as S, CURSOR_MODEL_MAP as T, extractCodexResult as _, createMockBackend as a, execWithIdleTimeout as b, extractOpenCodeResult as c, CodexBackend as d, ClaudeCodeBackend as f, extractClaudeResult as g, createStreamParser as h, MockAIBackend as i, FRONTIER_MODELS as j, normalizeBackendType as k, opencodeAdapter as l, codexAdapter as m, createBackend as n, SdkBackend as o, claudeAdapter as p, listBackends as r, OpenCodeBackend as s, checkBackends as t, CursorBackend as u, formatEvent as v, CODEX_MODEL_MAP as w, DEFAULT_IDLE_TIMEOUT as x, IdleTimeoutError as y };

package/dist/cli/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { D as FRONTIER_MODELS, T as normalizeBackendType, j as getDefaultModel, n as createBackend } from "../backends-DLaP0rMW.mjs";
-import { t as AgentWorker } from "../worker-CJ5_b2_q.mjs";
+import { I as getDefaultModel, j as FRONTIER_MODELS, k as normalizeBackendType, n as createBackend } from "../backends-CziIqKRg.mjs";
+import { t as AgentWorker } from "../worker-DBJ8136Q.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { appendFile, mkdir, open, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
@@ -97,7 +97,8 @@ var LocalWorker = class {
 			model: config.model,
 			system: config.system,
 			tools: {},
-			backend
+			backend,
+			provider: config.provider
 		}, restore);
 	}
 	send(input, options) {
@@ -1545,7 +1546,7 @@ function createDaemonApp(optionsOrGetState) {
 		if (!s) return c.json({ error: "Not ready" }, 503);
 		const body = await parseJsonBody(c);
 		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
-		const { name, model, system, backend = "default", workflow = "global", tag = "main" } = body;
+		const { name, model, system, backend = "default", provider, workflow = "global", tag = "main" } = body;
 		if (!name || !model || !system) return c.json({ error: "name, model, system required" }, 400);
 		if (s.configs.has(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
 		const agentConfig = {
@@ -1553,6 +1554,7 @@ function createDaemonApp(optionsOrGetState) {
 			model,
 			system,
 			backend,
+			provider,
 			workflow,
 			tag,
 			createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -1718,7 +1720,7 @@ function createDaemonApp(optionsOrGetState) {
 		const key = `${workflowName}:${tag}`;
 		if (s.workflows.has(key)) return c.json({ error: `Workflow already running: ${key}` }, 409);
 		try {
-			const { runWorkflowWithControllers } = await import("../runner-CQJYnM7D.mjs");
+			const { runWorkflowWithControllers } = await import("../runner-CnxROIev.mjs");
 			const result = await runWorkflowWithControllers({
 				workflow,
 				workflowName,
@@ -2069,23 +2071,33 @@ function registerAgentCommands(program) {
 		"claude",
 		"codex",
 		"cursor",
+		"opencode",
 		"mock"
-	]).default("default")).option("-s, --system <prompt>", "System prompt", "You are a helpful assistant.").option("-f, --system-file <file>", "Read system prompt from file").option("--workflow <name>", "Workflow name (default: global)").option("--tag <tag>", "Workflow instance tag (default: main)").option("--port <port>", `Daemon port if starting new daemon (default: ${DEFAULT_PORT})`).option("--host <host>", "Daemon host (default: 127.0.0.1)").option("--json", "Output as JSON").addHelpText("after", `
+	]).default("default")).option("--provider <name>", "Provider SDK name (e.g., anthropic, openai)").option("--base-url <url>", "Override provider base URL").option("--api-key <ref>", "API key env var (e.g., $MINIMAX_API_KEY)").option("-s, --system <prompt>", "System prompt", "You are a helpful assistant.").option("-f, --system-file <file>", "Read system prompt from file").option("--workflow <name>", "Workflow name (default: global)").option("--tag <tag>", "Workflow instance tag (default: main)").option("--port <port>", `Daemon port if starting new daemon (default: ${DEFAULT_PORT})`).option("--host <host>", "Daemon host (default: 127.0.0.1)").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
   $ agent-worker new alice -m anthropic/claude-sonnet-4-5
   $ agent-worker new bot -b mock
   $ agent-worker new reviewer --workflow review --tag pr-123
+  $ agent-worker new coder -m MiniMax-M2.5 --provider anthropic --base-url https://api.minimax.io/anthropic/v1 --api-key '$MINIMAX_API_KEY'
       `).action(async (name, options) => {
 		let system = options.system;
 		if (options.systemFile) system = readFileSync(options.systemFile, "utf-8");
 		const backend = normalizeBackendType(options.backend ?? "default");
 		const model = options.model || getDefaultModel();
+		let provider;
+		if (options.provider) if (options.baseUrl || options.apiKey) provider = {
+			name: options.provider,
+			base_url: options.baseUrl,
+			api_key: options.apiKey
+		};
+		else provider = options.provider;
 		await ensureDaemon(options.port ? parseInt(options.port, 10) : void 0, options.host);
 		const res = await createAgent({
 			name,
 			model,
 			system,
 			backend,
+			provider,
 			workflow: options.workflow,
 			tag: options.tag
 		});
@@ -2339,7 +2351,7 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CNlUyGit.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CIE3WPNx.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
@@ -2350,7 +2362,7 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 			isCleaningUp = true;
 			console.log("\nInterrupted, cleaning up...");
 			if (controllers) {
-				const { shutdownControllers } = await import("../workflow-CNlUyGit.mjs");
+				const { shutdownControllers } = await import("../workflow-CIE3WPNx.mjs");
 				const { createSilentLogger } = await import("../logger-Bfdo83xL.mjs");
 				await shutdownControllers(controllers, createSilentLogger());
 			}
@@ -2423,7 +2435,7 @@ Workflow runs inside the daemon. Use ls/stop to manage:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile } = await import("../workflow-CNlUyGit.mjs");
+		const { parseWorkflowFile } = await import("../workflow-CIE3WPNx.mjs");
 		const { ensureDaemon } = await Promise.resolve().then(() => agent_exports);
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
@@ -2574,10 +2586,6 @@ const PROVIDER_API_KEYS = {
 	xai: {
 		envVar: "XAI_API_KEY",
 		description: "xAI Grok"
-	},
-	minimax: {
-		envVar: "MINIMAX_API_KEY",
-		description: "MiniMax"
 	}
 };
 function registerInfoCommands(program) {
@@ -2598,10 +2606,11 @@ function registerInfoCommands(program) {
 		console.log(`  Provider only:   provider         (e.g., openai → ${gatewayExample})`);
 		console.log(`  Gateway format:  provider/model   (e.g., ${gatewayExample})`);
 		console.log(`  Direct format:   provider:model   (e.g., ${directExample})`);
+		console.log(`  Custom endpoint: --provider anthropic --base-url <url> --api-key '$KEY'`);
 		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-DG5igQii.mjs");
+		const { listBackends } = await import("../backends-BWzhErjT.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -2681,7 +2690,7 @@ async function resolveDir(targetInput) {
 
 //#endregion
 //#region package.json
-var version = "0.12.0";
+var version = "0.13.0";
 
 //#endregion
 //#region src/cli/index.ts

package/dist/index.d.mts

@@ -1,6 +1,27 @@
 import { LanguageModel } from "ai";
 import { BashToolkit, CreateBashToolOptions, createBashTool } from "bash-tool";
 
+//#region src/workflow/types.d.ts
+/**
+ * Custom provider configuration for API endpoint overrides.
+ * Allows pointing any compatible SDK at a different base URL.
+ *
+ * Examples:
+ *   provider: anthropic                    # string → built-in provider
+ *   provider:                              # object → custom endpoint
+ *     name: anthropic
+ *     base_url: https://api.minimax.io/anthropic/v1
+ *     api_key: $MINIMAX_API_KEY
+ */
+interface ProviderConfig {
+  /** Provider SDK name (e.g., 'anthropic', 'openai') */
+  name: string;
+  /** Override base URL for the provider */
+  base_url?: string;
+  /** API key — env var reference with '$' prefix (e.g., '$MINIMAX_API_KEY') or literal value */
+  api_key?: string;
+}
+//#endregion
 //#region src/agent/types.d.ts
 /**
  * Message status for streaming/response tracking
@@ -132,7 +153,7 @@ interface Transcript {
  * Both `backends/types.ts` and `workflow/controller/types.ts` re-export from this module.
  */
 /** Backend type (union of all supported backends) */
-type BackendType = "default" | "claude" | "cursor" | "codex" | "mock";
+type BackendType = "default" | "claude" | "cursor" | "codex" | "opencode" | "mock";
 //#endregion
 //#region src/backends/types.d.ts
 interface BackendConfig {
@@ -188,6 +209,8 @@ interface Backend {
 interface AgentWorkerConfig extends SessionConfig {
   /** CLI backend - when provided, send() delegates to this backend */
   backend?: Backend;
+  /** Provider configuration — when set, model is resolved via createModelWithProvider */
+  provider?: string | ProviderConfig;
 }
 /**
  * Step finish callback info
@@ -230,6 +253,7 @@ declare class AgentWorker {
   private totalUsage;
   private pendingApprovals;
   private backend;
+  private provider;
   private cachedAgent;
   private toolsChanged;
   /**
@@ -325,9 +349,8 @@ declare function createModel(modelId: string): LanguageModel;
 declare function createModelAsync(modelId: string): Promise<LanguageModel>;
 /**
  * List of supported providers for direct access
- * Note: minimax uses Claude-compatible API via @ai-sdk/anthropic with custom baseURL
  */
-declare const SUPPORTED_PROVIDERS: readonly ["anthropic", "openai", "deepseek", "google", "groq", "mistral", "xai", "minimax"];
+declare const SUPPORTED_PROVIDERS: readonly ["anthropic", "openai", "deepseek", "google", "groq", "mistral", "xai"];
 type SupportedProvider = (typeof SUPPORTED_PROVIDERS)[number];
 /**
  * Frontier models for each provider (as of 2026-02)
@@ -344,7 +367,6 @@ declare const FRONTIER_MODELS: {
   readonly groq: readonly ["meta-llama/llama-4-scout-17b-16e-instruct", "deepseek-r1-distill-llama-70b"];
   readonly mistral: readonly ["mistral-large-latest", "pixtral-large-latest", "magistral-medium-2506"];
   readonly xai: readonly ["grok-4", "grok-4-fast-reasoning"];
-  readonly minimax: readonly ["MiniMax-M2"];
 };
 //#endregion
 //#region src/agent/tools/bash.d.ts
@@ -575,7 +597,7 @@ interface CursorOptions {
 declare class CursorBackend implements Backend {
   readonly type: "cursor";
   private options;
-  /** Resolved command: "cursor" (subcommand style) or "cursor-agent" (standalone) */
+  /** Resolved command: "cursor" (subcommand style) */
   private resolvedCommand;
   constructor(options?: CursorOptions);
   /**
@@ -596,7 +618,7 @@ declare class CursorBackend implements Backend {
   };
   /**
    * Resolve which cursor command is available.
-   * Prefers `cursor agent` (subcommand), falls back to `cursor-agent` (standalone).
+   * Checks `cursor agent --version` (subcommand style).
    * Result is cached after first resolution.
    */
   private resolveCommand;
@@ -606,18 +628,35 @@ declare class CursorBackend implements Backend {
   }>;
 }
 //#endregion
+//#region src/backends/opencode.d.ts
+interface OpenCodeOptions {
+  /** Model to use in provider/model format (e.g., 'deepseek/deepseek-chat') */
+  model?: string;
+  /** Working directory (defaults to workspace if set) */
+  cwd?: string;
+  /** Workspace directory for agent isolation */
+  workspace?: string;
+  /** Idle timeout in milliseconds — kills process if no output for this duration */
+  timeout?: number;
+  /** Stream parser callbacks (structured event output) */
+  streamCallbacks?: StreamParserCallbacks;
+}
+//#endregion
 //#region src/backends/sdk.d.ts
 interface SdkBackendOptions {
-  /** Model identifier (e.g., 'openai/gpt-5.2' or 'anthropic:claude-sonnet-4-5') */
+  /** Model identifier (e.g., 'openai/gpt-5.2' or 'anthropic:claude-sonnet-4-5' or just 'MiniMax-M2.5' with provider) */
   model: string;
   /** Maximum tokens to generate */
   maxTokens?: number;
+  /** Provider configuration — when set, model is a plain name resolved via the provider */
+  provider?: string | ProviderConfig;
 }
 declare class SdkBackend implements Backend {
   readonly type: "default";
   private modelId;
   private model;
   private maxTokens;
+  private provider;
   constructor(options: SdkBackendOptions);
   send(message: string, options?: {
     system?: string;
@@ -656,6 +695,7 @@ type BackendOptions = {
   type: "default";
   model?: string;
   maxTokens?: number;
+  provider?: string | ProviderConfig;
 } | {
   type: "claude";
   model?: string;
@@ -668,6 +708,10 @@ type BackendOptions = {
   type: "cursor";
   model?: string;
   options?: Omit<CursorOptions, "model">;
+} | {
+  type: "opencode";
+  model?: string;
+  options?: Omit<OpenCodeOptions, "model">;
 };
 /**
  * Create a backend instance

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { A as createModelAsync, D as FRONTIER_MODELS, O as SUPPORTED_PROVIDERS, a as createMockBackend, c as CodexBackend, i as MockAIBackend, k as createModel, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends } from "./backends-DLaP0rMW.mjs";
-import { t as AgentWorker } from "./worker-CJ5_b2_q.mjs";
+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 { createBashTool } from "bash-tool";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";

package/dist/{runner-CQJYnM7D.mjs → runner-CnxROIev.mjs}

@@ -1,4 +1,4 @@
-import { A as createModelAsync, E as parseModel, a as createMockBackend, n as createBackend } from "./backends-DLaP0rMW.mjs";
+import { A as parseModel, P as createModelAsync, a as createMockBackend, n as createBackend } from "./backends-CziIqKRg.mjs";
 import { T as EventLog, n as createFileContextProvider, t as FileContextProvider, v as createContextMCPServer } from "./cli/index.mjs";
 import { n as createMemoryContextProvider } from "./memory-provider-BtLYtdQH.mjs";
 import { createChannelLogger, createSilentLogger } from "./logger-Bfdo83xL.mjs";
@@ -825,6 +825,7 @@ function getBackendByType(backendType, options) {
 	return createBackend({
 		type: backendType,
 		model: options?.model,
+		...backendType === "default" && options?.provider ? { provider: options.provider } : {},
 		...Object.keys(backendOptions).length > 0 ? { options: backendOptions } : {}
 	});
 }
@@ -835,6 +836,10 @@ function getBackendByType(backendType, options) {
 * Prefer using getBackendByType with explicit backend field in workflow configs.
 */
 function getBackendForModel(model, options) {
+	if (options?.provider) return getBackendByType("default", {
+		...options,
+		model
+	});
 	const { provider } = parseModel(model);
 	switch (provider) {
 		case "anthropic": return getBackendByType("default", {
@@ -1344,11 +1349,13 @@ async function runWorkflowWithControllers(config) {
 			if (createBackend) backend = createBackend(agentName, agentDef);
 			else if (agentDef.backend) backend = getBackendByType(agentDef.backend, {
 				model: agentDef.model,
+				provider: agentDef.provider,
 				debugLog: (msg) => agentLogger.debug(msg),
 				streamCallbacks,
 				timeout: agentDef.timeout
 			});
 			else if (agentDef.model) backend = getBackendForModel(agentDef.model, {
+				provider: agentDef.provider,
 				debugLog: (msg) => agentLogger.debug(msg),
 				streamCallbacks
 			});

package/dist/{worker-CJ5_b2_q.mjs → worker-DBJ8136Q.mjs}

@@ -1,4 +1,4 @@
-import { A as createModelAsync } from "./backends-DLaP0rMW.mjs";
+import { F as createModelWithProvider, P as createModelAsync } from "./backends-CziIqKRg.mjs";
 import { ToolLoopAgent, stepCountIs } from "ai";
 
 //#region src/agent/worker.ts
@@ -30,6 +30,7 @@ var AgentWorker = class {
 	};
 	pendingApprovals = [];
 	backend;
+	provider;
 	cachedAgent = null;
 	toolsChanged = false;
 	/**
@@ -65,6 +66,7 @@ var AgentWorker = class {
 		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
@@ -117,7 +119,7 @@ var AgentWorker = class {
 	async getAgent(autoApprove) {
 		if (!this.cachedAgent || this.toolsChanged || !autoApprove) {
 			this.cachedAgent = new ToolLoopAgent({
-				model: await createModelAsync(this.model),
+				model: this.provider ? await createModelWithProvider(this.model, this.provider) : await createModelAsync(this.model),
 				instructions: this.system,
 				tools: this.buildTools(autoApprove),
 				maxOutputTokens: this.maxTokens,

package/dist/{workflow-CNlUyGit.mjs → workflow-CIE3WPNx.mjs}

@@ -1,8 +1,8 @@
-import "./backends-DLaP0rMW.mjs";
+import "./backends-CziIqKRg.mjs";
 import { c as CONTEXT_DEFAULTS, i as resolveContextDir } from "./cli/index.mjs";
 import "./memory-provider-BtLYtdQH.mjs";
 import { createChannelLogger, createSilentLogger } from "./logger-Bfdo83xL.mjs";
-import { a as runSdkAgent, c as buildAgentPrompt, createWorkflowProvider, d as createContext, f as interpolate, i as createAgentController, initWorkflow, l as formatInbox, n as getBackendForModel, o as runMockAgent, r as checkWorkflowIdle, runWorkflowWithControllers, s as generateWorkflowMCPConfig, shutdownControllers, t as getBackendByType, u as CONTROLLER_DEFAULTS } from "./runner-CQJYnM7D.mjs";
+import { a as runSdkAgent, c as buildAgentPrompt, createWorkflowProvider, d as createContext, f as interpolate, i as createAgentController, initWorkflow, l as formatInbox, n as getBackendForModel, o as runMockAgent, r as checkWorkflowIdle, runWorkflowWithControllers, s as generateWorkflowMCPConfig, shutdownControllers, t as getBackendByType, u as CONTROLLER_DEFAULTS } from "./runner-CnxROIev.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { parse } from "yaml";
@@ -212,6 +212,7 @@ const CLI_BACKENDS = [
 	"claude",
 	"cursor",
 	"codex",
+	"opencode",
 	"mock"
 ];
 function validateAgent(name, agent, errors) {
@@ -241,6 +242,30 @@ function validateAgent(name, agent, errors) {
 		path: `${path}.tools`,
 		message: "Optional field \"tools\" must be an array"
 	});
+	if (a.provider !== void 0) {
+		if (typeof a.provider === "string") {} else if (typeof a.provider === "object" && a.provider !== null && !Array.isArray(a.provider)) {
+			const p = a.provider;
+			if (!p.name || typeof p.name !== "string") errors.push({
+				path: `${path}.provider.name`,
+				message: "Field \"provider.name\" is required and must be a string"
+			});
+			if (p.base_url !== void 0 && typeof p.base_url !== "string") errors.push({
+				path: `${path}.provider.base_url`,
+				message: "Field \"provider.base_url\" must be a string"
+			});
+			if (p.api_key !== void 0 && typeof p.api_key !== "string") errors.push({
+				path: `${path}.provider.api_key`,
+				message: "Field \"provider.api_key\" must be a string"
+			});
+		} else errors.push({
+			path: `${path}.provider`,
+			message: "Field \"provider\" must be a string or object with { name, base_url?, api_key? }"
+		});
+		if (CLI_BACKENDS.includes(backend) && backend !== "mock") errors.push({
+			path: `${path}.provider`,
+			message: `Field "provider" is ignored for CLI backend "${backend}" (only works with default backend)`
+		});
+	}
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-worker",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "SDK and CLI for creating and testing agent workers with Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -21,7 +21,9 @@
   "scripts": {
     "dev": "tsdown --watch",
     "build": "tsdown",
-    "test": "bun test",
+    "test": "bun test test/*.test.ts test/unit/",
+    "test:e2e": "bun test test/e2e/",
+    "e2e:setup": "bash scripts/e2e-setup.sh",
     "lint": "oxlint src",
     "lint:fix": "oxlint src --fix",
     "format": "oxfmt src",

package/dist/backends-DG5igQii.mjs

@@ -1,3 +0,0 @@
-import { C as SDK_MODEL_ALIASES, S as CURSOR_MODEL_MAP, T as normalizeBackendType, _ 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-DLaP0rMW.mjs";
-
-export { listBackends };