agent-worker 0.12.0 → 0.14.0

package/dist/{backends-DLaP0rMW.mjs → backends-C6WBIn9H.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;
 	}
 }
@@ -321,6 +354,12 @@ const DEFAULT_IDLE_TIMEOUT = 6e5;
 * producing output (tool calls, analysis, etc.).
 */
 /**
+* Default startup timeout (30 seconds).
+* If the process produces zero output within this window, it's killed.
+* This catches unresponsive backends (e.g., nested `claude -p` inside Claude Code).
+*/
+const DEFAULT_STARTUP_TIMEOUT = 3e4;
+/**
 * Execute a command with idle timeout.
 *
 * The timeout resets every time the process writes to stdout or stderr.
@@ -331,7 +370,10 @@ const MIN_TIMEOUT_MS = 1e3;
 async function execWithIdleTimeout(options) {
 	const { command, args, cwd, onStdout } = options;
 	const timeout = Math.max(options.timeout, MIN_TIMEOUT_MS);
+	const rawStartup = options.startupTimeout !== void 0 ? options.startupTimeout : DEFAULT_STARTUP_TIMEOUT;
+	const startupTimeout = rawStartup > 0 ? Math.min(rawStartup, timeout) : 0;
 	let idleTimedOut = false;
+	let hasReceivedOutput = false;
 	let timer;
 	let stdout = "";
 	let stderr = "";
@@ -350,6 +392,7 @@ async function execWithIdleTimeout(options) {
 	subprocess.stdout?.on("data", (chunk) => {
 		const text = chunk.toString();
 		stdout += text;
+		hasReceivedOutput = true;
 		resetTimer();
 		if (onStdout) try {
 			onStdout(text);
@@ -359,9 +402,16 @@ async function execWithIdleTimeout(options) {
 	});
 	subprocess.stderr?.on("data", (chunk) => {
 		stderr += chunk.toString();
+		hasReceivedOutput = true;
 		resetTimer();
 	});
-	resetTimer();
+	if (startupTimeout > 0) timer = setTimeout(() => {
+		if (!hasReceivedOutput) {
+			idleTimedOut = true;
+			subprocess.kill();
+		}
+	}, startupTimeout);
+	else resetTimer();
 	try {
 		await subprocess;
 		clearTimeout(timer);
@@ -371,7 +421,7 @@ async function execWithIdleTimeout(options) {
 		};
 	} catch (error) {
 		clearTimeout(timer);
-		if (idleTimedOut) throw new IdleTimeoutError(timeout, stdout, stderr);
+		if (idleTimedOut) throw new IdleTimeoutError(hasReceivedOutput ? timeout : startupTimeout, stdout, stderr);
 		throw error;
 	}
 }
@@ -382,7 +432,10 @@ async function execWithIdleTimeout(options) {
 function execWithIdleTimeoutAbortable(options) {
 	const { command, args, cwd, onStdout } = options;
 	const timeout = Math.max(options.timeout, MIN_TIMEOUT_MS);
+	const rawStartup = options.startupTimeout !== void 0 ? options.startupTimeout : DEFAULT_STARTUP_TIMEOUT;
+	const startupTimeout = rawStartup > 0 ? Math.min(rawStartup, timeout) : 0;
 	let idleTimedOut = false;
+	let hasReceivedOutput = false;
 	let timer;
 	let stdout = "";
 	let stderr = "";
@@ -402,6 +455,7 @@ function execWithIdleTimeoutAbortable(options) {
 	subprocess.stdout?.on("data", (chunk) => {
 		const text = chunk.toString();
 		stdout += text;
+		hasReceivedOutput = true;
 		resetTimer();
 		if (onStdout) try {
 			onStdout(text);
@@ -411,9 +465,16 @@ function execWithIdleTimeoutAbortable(options) {
 	});
 	subprocess.stderr?.on("data", (chunk) => {
 		stderr += chunk.toString();
+		hasReceivedOutput = true;
 		resetTimer();
 	});
-	resetTimer();
+	if (startupTimeout > 0) timer = setTimeout(() => {
+		if (!hasReceivedOutput) {
+			idleTimedOut = true;
+			subprocess.kill();
+		}
+	}, startupTimeout);
+	else resetTimer();
 	const abort = () => {
 		if (!isAborted) {
 			isAborted = true;
@@ -436,7 +497,7 @@ function execWithIdleTimeoutAbortable(options) {
 			} catch (error) {
 				clearTimeout(timer);
 				if (isAborted) throw new Error("Process aborted by user");
-				if (idleTimedOut) throw new IdleTimeoutError(timeout, stdout, stderr);
+				if (idleTimedOut) throw new IdleTimeoutError(hasReceivedOutput ? timeout : startupTimeout, stdout, stderr);
 				throw error;
 			}
 		})(),
@@ -780,7 +841,10 @@ var ClaudeCodeBackend = class {
 			return { content: stdout.trim() };
 		} catch (error) {
 			this.currentAbort = void 0;
-			if (error instanceof IdleTimeoutError) throw new Error(`claude timed out after ${timeout}ms of inactivity`);
+			if (error instanceof IdleTimeoutError) {
+				if (error.stdout === "" && error.stderr === "") throw new Error(`claude produced no output within ${error.timeout}ms. This often happens when running nested 'claude -p' inside an existing Claude Code session. Consider using the SDK backend (model: "anthropic/claude-sonnet-4-5") instead.`);
+				throw new Error(`claude timed out after ${timeout}ms of inactivity`);
+			}
 			if (error && typeof error === "object" && "exitCode" in error) {
 				const execError = error;
 				throw new Error(`claude failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
@@ -931,8 +995,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,8 +1006,13 @@ var CodexBackend = class {
 var CursorBackend = class {
 	type = "cursor";
 	options;
-	/** Resolved command: "cursor" (subcommand style) or "cursor-agent" (standalone) */
-	resolvedCommand = null;
+	/**
+	* Resolved command style:
+	* - "subcommand": `cursor agent -p ...` (IDE-bundled CLI)
+	* - "direct": `agent -p ...` (standalone install via cursor.com/install)
+	* - null: not yet resolved
+	*/
+	resolvedStyle = null;
 	constructor(options = {}) {
 		this.options = {
 			timeout: DEFAULT_IDLE_TIMEOUT,
@@ -984,7 +1052,7 @@ var CursorBackend = class {
 		}
 	}
 	async isAvailable() {
-		return await this.resolveCommand() !== null;
+		return await this.resolveStyle() !== null;
 	}
 	getInfo() {
 		return {
@@ -993,32 +1061,34 @@ var CursorBackend = class {
 		};
 	}
 	/**
-	* Resolve which cursor command is available.
-	* Prefers `cursor agent` (subcommand), falls back to `cursor-agent` (standalone).
+	* Resolve which cursor command style is available.
+	* Tries in order:
+	*   1. `cursor agent --version` — IDE-bundled CLI (subcommand style)
+	*   2. `agent --version` — standalone install via cursor.com/install (direct style)
 	* Result is cached after first resolution.
 	*/
-	async resolveCommand() {
-		if (this.resolvedCommand !== null) return this.resolvedCommand;
+	async resolveStyle() {
+		if (this.resolvedStyle !== null) return this.resolvedStyle;
 		try {
 			await execa("cursor", ["agent", "--version"], {
 				stdin: "ignore",
 				timeout: 2e3
 			});
-			this.resolvedCommand = "cursor";
-			return "cursor";
+			this.resolvedStyle = "subcommand";
+			return "subcommand";
 		} catch {}
 		try {
-			await execa("cursor-agent", ["--version"], {
+			await execa("agent", ["--version"], {
 				stdin: "ignore",
 				timeout: 2e3
 			});
-			this.resolvedCommand = "cursor-agent";
-			return "cursor-agent";
+			this.resolvedStyle = "direct";
+			return "direct";
 		} catch {}
 		return null;
 	}
 	async buildCommand(message) {
-		const cmd = await this.resolveCommand();
+		const style = await this.resolveStyle();
 		const agentArgs = [
 			"-p",
 			"--force",
@@ -1027,16 +1097,165 @@ var CursorBackend = class {
 			message
 		];
 		if (this.options.model) agentArgs.push("--model", this.options.model);
-		if (cmd === "cursor") return {
+		if (!style) throw new Error("cursor agent CLI not found. Install via: curl -fsS https://cursor.com/install | bash");
+		if (style === "direct") return {
+			command: "agent",
+			args: agentArgs
+		};
+		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 {
-			command: "cursor-agent",
-			args: agentArgs
+			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 {
+			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 +1268,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 +1296,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 +1354,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 +1374,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 +1392,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 +1433,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 };