agent-worker 0.18.0 → 0.19.0

package/dist/backends-D7DT0uox.mjs

@@ -1,1484 +0,0 @@
-import { gateway, generateText } from "ai";
-import { execa } from "execa";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-
-//#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 SDK, caching the result.
-* Only caches standard providers (no custom baseURL/apiKey).
-*/
-async function loadProvider(name, packageName, exportName) {
-	if (name in providerCache) return providerCache[name] ?? null;
-	try {
-		const exportedProvider = (await import(packageName))[exportName];
-		providerCache[name] = exportedProvider;
-		return exportedProvider;
-	} catch {
-		providerCache[name] = null;
-		return null;
-	}
-}
-/**
-* 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(`Failed to load ${pkg.package} for provider "${provider}". Try reinstalling agent-worker.`);
-		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(`Failed to load ${pkg.package} for provider "${name}". Try reinstalling agent-worker.`);
-		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:
-*
-* 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("/")) {
-		if (process.env.AI_GATEWAY_API_KEY) return gateway(modelId);
-		const slashIndex = modelId.indexOf("/");
-		const provider = modelId.slice(0, slashIndex);
-		const modelName = modelId.slice(slashIndex + 1);
-		if (provider in providerCache && providerCache[provider]) return providerCache[provider](modelName);
-		throw new Error(`Provider '${provider}' not loaded. Call createModelAsync() first or set AI_GATEWAY_API_KEY for gateway access.`);
-	}
-	if (!modelId.includes(":")) {
-		const provider = modelId;
-		if (provider in FRONTIER_MODELS) {
-			const defaultModel = FRONTIER_MODELS[provider][0];
-			if (process.env.AI_GATEWAY_API_KEY) return gateway(`${provider}/${defaultModel}`);
-			if (provider in providerCache && providerCache[provider]) return providerCache[provider](defaultModel);
-			throw new Error(`Provider '${provider}' not loaded. Call createModelAsync() first or set AI_GATEWAY_API_KEY for gateway access.`);
-		}
-		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. Call createModelAsync() first or set AI_GATEWAY_API_KEY for gateway 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("/")) {
-		if (process.env.AI_GATEWAY_API_KEY) return gateway(modelId);
-		const slashIndex = modelId.indexOf("/");
-		return loadProviderModel(modelId.slice(0, slashIndex), modelId.slice(slashIndex + 1));
-	}
-	if (!modelId.includes(":")) {
-		const provider = modelId;
-		if (provider in FRONTIER_MODELS) {
-			const defaultModel = FRONTIER_MODELS[provider][0];
-			if (process.env.AI_GATEWAY_API_KEY) return gateway(`${provider}/${defaultModel}`);
-			return loadProviderModel(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.`);
-	return loadProviderModel(provider, modelName);
-}
-/**
-* Load a provider SDK and create a model instance.
-* Used as fallback when AI Gateway is not available.
-*/
-async function loadProviderModel(provider, modelName) {
-	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(`Failed to load ${config.package} for provider "${provider}". Try reinstalling agent-worker.`);
-	return providerFn(modelName);
-}
-/**
-* List of supported providers for direct access
-*/
-const SUPPORTED_PROVIDERS = [
-	"anthropic",
-	"openai",
-	"deepseek",
-	"google",
-	"groq",
-	"mistral",
-	"xai"
-];
-/**
-* 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"]
-};
-/**
-* Environment variable that each provider uses for authentication.
-* Ordered by priority — first match wins during auto-discovery.
-*
-* Gateway is first because it supports all providers via a single key.
-*/
-const PROVIDER_ENV_KEYS = {
-	gateway: "AI_GATEWAY_API_KEY",
-	anthropic: "ANTHROPIC_API_KEY",
-	openai: "OPENAI_API_KEY",
-	deepseek: "DEEPSEEK_API_KEY",
-	google: "GOOGLE_GENERATIVE_AI_API_KEY",
-	groq: "GROQ_API_KEY",
-	mistral: "MISTRAL_API_KEY",
-	xai: "XAI_API_KEY"
-};
-/** Provider discovery priority order */
-const DISCOVERY_ORDER = [
-	"gateway",
-	"anthropic",
-	"openai",
-	"deepseek",
-	"google",
-	"groq",
-	"mistral",
-	"xai"
-];
-/**
-* Reverse map: model name → provider name.
-* Built from FRONTIER_MODELS so "deepseek-chat" → "deepseek", etc.
-*/
-const MODEL_TO_PROVIDER = {};
-for (const [provider, models] of Object.entries(FRONTIER_MODELS)) for (const model of models) {
-	const shortName = model.includes("/") ? model.split("/").pop() : model;
-	MODEL_TO_PROVIDER[model] = provider;
-	if (shortName !== model) MODEL_TO_PROVIDER[shortName] = provider;
-}
-/**
-* Discover the best available provider by scanning environment variables.
-*
-* Note: This function does NOT read AGENT_MODEL — that's handled by
-* resolveModelFallback() which supports comma-separated fallback chains.
-*
-* @param options.preferredModel - If set, prefer the provider that owns this model.
-*   E.g. "deepseek-chat" → prefer "deepseek" if DEEPSEEK_API_KEY is set.
-* @param options.env - Environment to scan (defaults to process.env).
-* @returns The discovered provider and model, or null if none available.
-*/
-function discoverProvider(options) {
-	const env = options?.env ?? process.env;
-	const preferredModel = options?.preferredModel;
-	if (preferredModel && preferredModel !== "auto") {
-		const ownerProvider = MODEL_TO_PROVIDER[preferredModel];
-		if (ownerProvider) {
-			const envKey = PROVIDER_ENV_KEYS[ownerProvider];
-			if (envKey && env[envKey]) return {
-				provider: ownerProvider,
-				model: preferredModel.includes("/") ? preferredModel : `${ownerProvider}/${preferredModel}`
-			};
-		}
-	}
-	for (const provider of DISCOVERY_ORDER) {
-		if (!env[PROVIDER_ENV_KEYS[provider]]) continue;
-		if (provider === "gateway") {
-			if (preferredModel && preferredModel !== "auto") return {
-				provider: "gateway",
-				model: `${MODEL_TO_PROVIDER[preferredModel] || "anthropic"}/${preferredModel}`
-			};
-			return {
-				provider: "gateway",
-				model: getDefaultModel()
-			};
-		}
-		const defaultModel = FRONTIER_MODELS[provider]?.[0];
-		return {
-			provider,
-			model: defaultModel ? defaultModel.includes("/") ? defaultModel : `${provider}/${defaultModel}` : provider
-		};
-	}
-	return null;
-}
-/**
-* Check if a value is the "auto" sentinel.
-*/
-function isAutoProvider(value) {
-	return value === "auto";
-}
-/**
-* Check if a model's provider has a valid API key in the environment.
-*/
-function isModelAvailable(model, env) {
-	if (model === "auto") return true;
-	let provider;
-	provider = MODEL_TO_PROVIDER[model];
-	if (!provider && model.includes("/")) provider = model.split("/")[0];
-	if (!provider && model.includes(":")) provider = model.split(":")[0];
-	if (!provider) return false;
-	if (env[PROVIDER_ENV_KEYS["gateway"]]) return true;
-	const envKey = PROVIDER_ENV_KEYS[provider];
-	return !!envKey && !!env[envKey];
-}
-/**
-* Resolve a model to a single concrete value, supporting fallback chains.
-*
-* Resolution order:
-*   1. AGENT_DEFAULT_MODELS env var — comma-separated preference list
-*      (e.g. "deepseek-chat, anthropic/claude-sonnet-4-5")
-*   2. Workflow YAML model field (single string, or "auto")
-*   3. Full auto-discovery — scan all provider API keys
-*
-* The preference list does NOT contain "auto" — the env var itself IS
-* the auto configuration. After exhausting the explicit list, the system
-* implicitly falls back to full provider discovery.
-*
-* Example:
-*   AGENT_DEFAULT_MODELS="deepseek-chat, anthropic/claude-sonnet-4-5"
-*   → try deepseek-chat (need DEEPSEEK_API_KEY)
-*   → try claude-sonnet-4-5 (need ANTHROPIC_API_KEY)
-*   → implicit fallback: discover any available provider
-*
-* @returns Resolved { model, provider } — never contains "auto".
-* @throws if nothing is available (no explicit candidate and no provider key).
-*/
-function resolveModelFallback(config) {
-	const env = config.env ?? process.env;
-	const isProviderAuto = config.provider === "auto";
-	const autoModel = env.AGENT_DEFAULT_MODELS;
-	if (!isProviderAuto && config.model && config.model !== "auto" && !autoModel) return {
-		model: config.model,
-		provider: config.provider
-	};
-	const preferences = autoModel ? autoModel.split(",").map((s) => s.trim()).filter(Boolean) : [];
-	for (const candidate of preferences) if (isModelAvailable(candidate, env)) return {
-		model: candidate,
-		provider: isProviderAuto ? void 0 : config.provider
-	};
-	if (isProviderAuto && config.model && config.model !== "auto") {
-		const model = config.model;
-		if (isModelAvailable(model, env)) {
-			const ownerProvider = MODEL_TO_PROVIDER[model];
-			if (ownerProvider && !model.includes("/") && !model.includes(":")) return {
-				model: `${ownerProvider}/${model}`,
-				provider: void 0
-			};
-			return {
-				model,
-				provider: void 0
-			};
-		}
-	}
-	const discovered = discoverProvider({ env });
-	if (discovered) return {
-		model: discovered.model,
-		provider: void 0
-	};
-	const envVars = Object.values(PROVIDER_ENV_KEYS).join(", ");
-	const hint = preferences.length > 0 ? `Tried: ${preferences.join(", ")}. ` : "";
-	throw new Error(`No provider available for auto model resolution. ${hint}Set one of: ${envVars}`);
-}
-
-//#endregion
-//#region src/backends/model-maps.ts
-/** Normalize backend type, mapping deprecated "sdk" to "default" */
-function normalizeBackendType(type) {
-	if (type === "sdk") return "default";
-	return type;
-}
-/** Default model per backend */
-const BACKEND_DEFAULT_MODELS = {
-	mock: "mock-model",
-	default: "claude-sonnet-4-5",
-	claude: "sonnet",
-	cursor: "sonnet-4.5",
-	codex: "gpt-5.2-codex",
-	opencode: "deepseek/deepseek-chat"
-};
-/**
-* Model aliases for SDK (Anthropic format)
-*/
-const SDK_MODEL_ALIASES = {
-	sonnet: "claude-sonnet-4-5-20250514",
-	opus: "claude-opus-4-20250514",
-	haiku: "claude-haiku-3-5-20250514",
-	"claude-sonnet-4-5": "claude-sonnet-4-5-20250514",
-	"claude-opus-4": "claude-opus-4-20250514",
-	"claude-haiku-3-5": "claude-haiku-3-5-20250514"
-};
-/**
-* Model translation for Cursor backend
-* Cursor uses its own naming convention
-*/
-const CURSOR_MODEL_MAP = {
-	sonnet: "sonnet-4.5",
-	opus: "opus-4.5",
-	"sonnet-4.5": "sonnet-4.5",
-	"opus-4.5": "opus-4.5",
-	"opus-4.6": "opus-4.6",
-	"claude-sonnet-4-5": "sonnet-4.5",
-	"claude-opus-4-5": "opus-4.5",
-	"anthropic/claude-sonnet-4-5": "sonnet-4.5",
-	"anthropic/claude-opus-4-5": "opus-4.5",
-	"sonnet-4.5-thinking": "sonnet-4.5-thinking",
-	"opus-4.5-thinking": "opus-4.5-thinking",
-	"opus-4.6-thinking": "opus-4.6-thinking",
-	"gpt-5.2": "gpt-5.2",
-	"gpt-5.1": "gpt-5.1-high",
-	"gpt-4": "gpt-5.2",
-	"gemini-pro": "gemini-3-pro",
-	"gemini-flash": "gemini-3-flash",
-	auto: "auto"
-};
-/**
-* Model translation for Claude CLI backend
-* Claude CLI uses short model names
-*/
-const CLAUDE_MODEL_MAP = {
-	sonnet: "sonnet",
-	opus: "opus",
-	haiku: "haiku",
-	"sonnet-4.5": "sonnet",
-	"opus-4.5": "opus",
-	"claude-sonnet-4-5": "sonnet",
-	"claude-opus-4": "opus",
-	"claude-haiku-3-5": "haiku",
-	"anthropic/claude-sonnet-4-5": "sonnet",
-	"anthropic/claude-opus-4": "opus"
-};
-/**
-* Model translation for Codex CLI backend
-*/
-const CODEX_MODEL_MAP = {
-	"gpt-5.2-codex": "gpt-5.2-codex",
-	"gpt-5.2": "gpt-5.2-codex",
-	o3: "o3",
-	"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
-*/
-function getModelForBackend(model, backend) {
-	if (!model) return BACKEND_DEFAULT_MODELS[backend];
-	const normalizedModel = model.includes("/") ? model.split("/").pop() : model;
-	switch (backend) {
-		case "default": return SDK_MODEL_ALIASES[normalizedModel] || model;
-		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;
-	}
-}
-/**
-* Parse model string to provider and version (legacy, for SDK backend)
-* Format: provider/model-name or just model-name (defaults to anthropic)
-*/
-function parseModel(model) {
-	const parts = model.split("/");
-	if (parts.length === 2) return {
-		provider: parts[0],
-		model: SDK_MODEL_ALIASES[parts[1]] || parts[1]
-	};
-	return {
-		provider: "anthropic",
-		model: SDK_MODEL_ALIASES[model] || model
-	};
-}
-
-//#endregion
-//#region src/backends/types.ts
-/**
-* Default idle timeout for CLI backends (10 minutes).
-* Timeout resets on any stdout activity, so this is an inactivity threshold.
-*/
-const DEFAULT_IDLE_TIMEOUT = 6e5;
-
-//#endregion
-//#region src/backends/idle-timeout.ts
-/**
-* Idle timeout for CLI subprocess execution
-*
-* Unlike a hard timeout (kill after N ms total), an idle timeout only fires
-* when the process produces no stdout/stderr output for the configured duration.
-* This allows long-running agent tasks to continue as long as they're actively
-* 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;
-/** Minimum idle timeout to prevent accidental instant kills */
-const MIN_TIMEOUT_MS = 1e3;
-/**
-* Core implementation shared by both sync and abortable variants.
-* Returns the promise, an abort function, and the subprocess handle.
-*/
-function execWithIdleTimeoutInternal(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 = "";
-	let isAborted = false;
-	const subprocess = execa(command, args, {
-		cwd,
-		stdin: "ignore",
-		buffer: false
-	});
-	const resetTimer = () => {
-		clearTimeout(timer);
-		timer = setTimeout(() => {
-			idleTimedOut = true;
-			subprocess.kill();
-		}, timeout);
-	};
-	subprocess.stdout?.on("data", (chunk) => {
-		const text = chunk.toString();
-		stdout += text;
-		hasReceivedOutput = true;
-		resetTimer();
-		if (onStdout) try {
-			onStdout(text);
-		} catch (err) {
-			console.error("onStdout callback error:", err);
-		}
-	});
-	subprocess.stderr?.on("data", (chunk) => {
-		stderr += chunk.toString();
-		hasReceivedOutput = true;
-		resetTimer();
-	});
-	if (startupTimeout > 0) timer = setTimeout(() => {
-		if (!hasReceivedOutput) {
-			idleTimedOut = true;
-			subprocess.kill();
-		}
-	}, startupTimeout);
-	else resetTimer();
-	const abort = () => {
-		if (!isAborted) {
-			isAborted = true;
-			clearTimeout(timer);
-			subprocess.kill("SIGTERM");
-			setTimeout(() => {
-				if (!subprocess.killed) subprocess.kill("SIGKILL");
-			}, 1e3);
-		}
-	};
-	return {
-		promise: (async () => {
-			try {
-				await subprocess;
-				clearTimeout(timer);
-				return {
-					stdout: stdout.trimEnd(),
-					stderr: stderr.trimEnd()
-				};
-			} catch (error) {
-				clearTimeout(timer);
-				if (isAborted) throw new Error("Process aborted by user");
-				if (idleTimedOut) throw new IdleTimeoutError(hasReceivedOutput ? timeout : startupTimeout, stdout, stderr);
-				throw error;
-			}
-		})(),
-		abort
-	};
-}
-/**
-* Execute a command with idle timeout.
-*
-* The timeout resets every time the process writes to stdout or stderr.
-* If the process goes silent for longer than `timeout` ms, it's killed.
-*/
-async function execWithIdleTimeout(options) {
-	const { promise } = execWithIdleTimeoutInternal(options);
-	return promise;
-}
-/**
-* Execute a command with idle timeout and return abort handle.
-* This version returns both the promise and an abort function for external control.
-*/
-function execWithIdleTimeoutAbortable(options) {
-	return execWithIdleTimeoutInternal(options);
-}
-/**
-* Error thrown when a process is killed due to idle timeout
-*/
-var IdleTimeoutError = class extends Error {
-	timeout;
-	stdout;
-	stderr;
-	constructor(timeout, stdout, stderr) {
-		super(`Process idle timed out after ${timeout}ms of inactivity`);
-		this.name = "IdleTimeoutError";
-		this.timeout = timeout;
-		this.stdout = stdout;
-		this.stderr = stderr;
-	}
-};
-
-//#endregion
-//#region src/backends/cli-helpers.ts
-/**
-* Shared helpers for CLI backends
-*
-* Eliminates duplicated error handling and availability check patterns
-* across claude-code, codex, cursor, and opencode backends.
-*/
-/**
-* Handle errors from CLI backend execution.
-*
-* Standardizes the error handling pattern shared by all CLI backends:
-* 1. IdleTimeoutError → human-readable timeout message
-* 2. Process exit error → include exit code and stderr
-* 3. Everything else → re-throw
-*/
-function handleCliBackendError(error, backendName, timeout) {
-	if (error instanceof IdleTimeoutError) throw new Error(`${backendName} timed out after ${timeout}ms of inactivity`);
-	if (error && typeof error === "object" && "exitCode" in error) {
-		const execError = error;
-		throw new Error(`${backendName} failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
-	}
-	throw error;
-}
-/**
-* Check if a CLI command is available by running `command --version`.
-*/
-async function checkCliAvailable(command, args = ["--version"], timeout = 5e3) {
-	try {
-		await execa(command, args, {
-			stdin: "ignore",
-			timeout
-		});
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-//#region src/backends/stream-json.ts
-/**
-* Format a standard StreamEvent into a human-readable progress message.
-* Returns null if the event doesn't need display.
-*
-* This function only knows about StreamEvent — it never touches
-* backend-specific raw JSON. Format-specific conversion is handled
-* by the EventAdapter.
-*/
-function formatEvent(event, backendName) {
-	switch (event.kind) {
-		case "init": {
-			const details = [];
-			if (event.model) details.push(`model: ${event.model}`);
-			if (event.sessionId) details.push(`session: ${event.sessionId}`);
-			return `${backendName} initialized${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
-		}
-		case "tool_call_started": {
-			const callIdSuffix = event.callId ? ` [${event.callId.slice(0, 8)}]` : "";
-			return `STARTING ${event.name}${callIdSuffix}`;
-		}
-		case "tool_call": {
-			const truncated = event.args.length > 100 ? event.args.slice(0, 100) + "..." : event.args;
-			return `CALL ${event.name}(${truncated})`;
-		}
-		case "completed": {
-			const parts = [backendName, "completed"];
-			const details = [];
-			if (event.durationMs) details.push(`${(event.durationMs / 1e3).toFixed(1)}s`);
-			if (event.costUsd) details.push(`$${event.costUsd.toFixed(4)}`);
-			if (event.usage) details.push(`${event.usage.input} in, ${event.usage.output} out`);
-			if (details.length > 0) parts.push(`(${details.join(", ")})`);
-			return parts.join(" ");
-		}
-		case "user_message": return `User: ${event.text.length > 80 ? event.text.slice(0, 80) + "..." : event.text}`;
-		case "assistant_message": return `Assistant: ${event.text.length > 80 ? event.text.slice(0, 80) + "..." : event.text}`;
-		case "skip": return null;
-		case "unknown": {
-			const preview = JSON.stringify(event.raw).slice(0, 100);
-			return `[DEBUG] ${backendName} unknown event type="${event.type}": ${preview}...`;
-		}
-	}
-}
-/**
-* Adapter for Claude/Cursor stream-json format.
-*
-* Events:
-*   { type: "system", subtype: "init", model: "..." }
-*   { type: "assistant", message: { content: [{ type: "tool_use", name, input }] } }
-*   { type: "result", duration_ms: N, total_cost_usd: N }
-*/
-const claudeAdapter = (raw) => {
-	const event = raw;
-	if (event.type === "system" && event.subtype === "init") return {
-		kind: "init",
-		model: event.model,
-		sessionId: event.session_id
-	};
-	if (event.type === "user") {
-		const textContent = event.message.content.find((c) => c.type === "text");
-		if (textContent && "text" in textContent) return {
-			kind: "user_message",
-			text: textContent.text
-		};
-		return { kind: "skip" };
-	}
-	if (event.type === "assistant") {
-		const toolCalls = event.message.content.filter((c) => c.type === "tool_use");
-		if (toolCalls.length > 0) {
-			const tc = toolCalls[0];
-			return {
-				kind: "tool_call",
-				name: tc.name,
-				args: formatToolInput(tc.input)
-			};
-		}
-		return { kind: "skip" };
-	}
-	if (event.type === "result") return {
-		kind: "completed",
-		durationMs: event.duration_ms,
-		costUsd: event.total_cost_usd
-	};
-	return null;
-};
-/**
-* Extract final result from Claude/Cursor stream-json output.
-*
-* Priority:
-* 1. type=result with result field
-* 2. Last assistant message with text content
-* 3. Raw stdout fallback
-*/
-function extractClaudeResult(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 === "result" && event.result) return { content: event.result };
-	} catch {}
-	for (let i = lines.length - 1; i >= 0; i--) try {
-		const event = JSON.parse(lines[i]);
-		if (event.type === "assistant" && event.message?.content) {
-			const textParts = event.message.content.filter((c) => c.type === "text").map((c) => c.text);
-			if (textParts.length > 0) return { content: textParts.join("\n") };
-		}
-	} catch {}
-	return { content: stdout.trim() };
-}
-/**
-* Adapter for Cursor stream-json format.
-*
-* Events:
-*   { type: "system", subtype: "init", model: "..." }
-*   { type: "tool_call", subtype: "started", call_id: "...", tool_call: { shellToolCall: {...} } }
-*   { type: "tool_call", subtype: "completed", call_id: "..." }
-*   { type: "result", duration_ms: N }
-*/
-const cursorAdapter = (raw) => {
-	const event = raw;
-	if (event.type === "system" && event.subtype === "init") return {
-		kind: "init",
-		model: event.model,
-		sessionId: event.session_id
-	};
-	if (event.type === "user") return {
-		kind: "user_message",
-		text: event.message.content.map((c) => c.text).join("\n")
-	};
-	if (event.type === "assistant") return {
-		kind: "assistant_message",
-		text: event.message.content.map((c) => c.text).join("\n")
-	};
-	if (event.type === "tool_call") {
-		if (event.subtype === "started" && event.tool_call) {
-			if (event.tool_call.shellToolCall) return {
-				kind: "tool_call_started",
-				name: "bash",
-				callId: event.call_id
-			};
-			return {
-				kind: "tool_call_started",
-				name: "tool",
-				callId: event.call_id
-			};
-		}
-		return { kind: "skip" };
-	}
-	if (event.type === "result") return {
-		kind: "completed",
-		durationMs: event.duration_ms
-	};
-	return null;
-};
-/**
-* Adapter for Codex --json format.
-*
-* Events:
-*   { type: "thread.started", thread_id: "..." }
-*   { type: "item.completed", item: { type: "function_call", name, arguments } }
-*   { type: "item.completed", item: { type: "agent_message", text } }  → skipped (result only)
-*   { type: "turn.completed", usage: { input_tokens, output_tokens } }
-*/
-const codexAdapter = (raw) => {
-	const event = raw;
-	if (event.type === "thread.started") return {
-		kind: "init",
-		sessionId: `${event.thread_id.slice(0, 8)}...`
-	};
-	if (event.type === "item.completed") {
-		if (event.item.type === "function_call") return {
-			kind: "tool_call",
-			name: event.item.name,
-			args: event.item.arguments
-		};
-		return { kind: "skip" };
-	}
-	if (event.type === "turn.completed") return {
-		kind: "completed",
-		usage: {
-			input: event.usage.input_tokens,
-			output: event.usage.output_tokens
-		}
-	};
-	return null;
-};
-/**
-* Extract final result from Codex --json output.
-*
-* Priority:
-* 1. Last item.completed with item.type=agent_message
-* 2. Raw stdout fallback
-*/
-function extractCodexResult(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 === "item.completed" && event.item?.type === "agent_message" && event.item?.text) return { content: event.item.text };
-	} catch {}
-	return { content: stdout.trim() };
-}
-/**
-* Create a line-buffered stream parser.
-*
-* Accumulates stdout chunks, parses each line through the given adapter,
-* and emits structured events via callbacks.
-*
-* Tool call dedup: if a tool_call event's name is in mcpToolNames,
-* it's skipped (MCP server already logged it with source="mcp").
-*
-* @param callbacks - Structured output callbacks
-* @param backendName - Display name (e.g., "Cursor", "Claude", "Codex")
-* @param adapter - Format-specific adapter to convert raw JSON → StreamEvent
-*/
-function createStreamParser(callbacks, backendName, adapter) {
-	const { debugLog, outputLog, toolCallLog, mcpToolNames } = callbacks;
-	let lineBuf = "";
-	return (chunk) => {
-		lineBuf += chunk;
-		const lines = lineBuf.split("\n");
-		lineBuf = lines.pop() ?? "";
-		for (const line of lines) {
-			if (!line.trim()) continue;
-			try {
-				const raw = JSON.parse(line);
-				let event = adapter(raw);
-				if (!event && raw.type) event = {
-					kind: "unknown",
-					type: raw.type,
-					raw
-				};
-				if (!event) continue;
-				if (event.kind === "tool_call" || event.kind === "tool_call_started") {
-					if (mcpToolNames?.has(event.name)) continue;
-					if (toolCallLog && event.kind === "tool_call") {
-						toolCallLog(event.name, event.args);
-						continue;
-					}
-				}
-				const progress = formatEvent(event, backendName);
-				if (progress) ((event.kind === "tool_call" || event.kind === "tool_call_started" || event.kind === "user_message" || event.kind === "assistant_message") && outputLog ? outputLog : debugLog)(progress);
-			} catch {}
-		}
-	};
-}
-/**
-* Format tool call input for display (truncated JSON string)
-*/
-function formatToolInput(input) {
-	if (!input || typeof input !== "object") return "";
-	try {
-		const str = JSON.stringify(input);
-		return str.length > 100 ? str.slice(0, 100) + "..." : str;
-	} catch {
-		return "";
-	}
-}
-
-//#endregion
-//#region src/backends/claude-code.ts
-/**
-* Claude Code CLI backend
-* Uses `claude -p` for non-interactive mode
-*
-* MCP Configuration:
-* Claude supports per-invocation MCP config via --mcp-config flag.
-* The loop writes mcp-config.json to the workspace; this backend
-* auto-discovers it when workspace is set.
-*
-* @see https://docs.anthropic.com/en/docs/claude-code
-*/
-var ClaudeCodeBackend = class {
-	type = "claude";
-	options;
-	currentAbort;
-	constructor(options = {}) {
-		this.options = {
-			timeout: DEFAULT_IDLE_TIMEOUT,
-			...options
-		};
-	}
-	async send(message, options) {
-		const args = this.buildArgs(message, options);
-		const cwd = this.options.workspace || this.options.cwd;
-		const outputFormat = this.options.outputFormat ?? "stream-json";
-		const timeout = this.options.timeout ?? DEFAULT_IDLE_TIMEOUT;
-		try {
-			const { promise, abort } = execWithIdleTimeoutAbortable({
-				command: "claude",
-				args,
-				cwd,
-				timeout,
-				onStdout: outputFormat === "stream-json" && this.options.streamCallbacks ? createStreamParser(this.options.streamCallbacks, "Claude", claudeAdapter) : void 0
-			});
-			this.currentAbort = abort;
-			const { stdout } = await promise;
-			this.currentAbort = void 0;
-			if (outputFormat === "stream-json") return extractClaudeResult(stdout);
-			if (outputFormat === "json") try {
-				const parsed = JSON.parse(stdout);
-				return {
-					content: parsed.content || parsed.result || stdout,
-					toolCalls: parsed.toolCalls,
-					usage: parsed.usage
-				};
-			} catch {
-				return { content: stdout.trim() };
-			}
-			return { content: stdout.trim() };
-		} catch (error) {
-			this.currentAbort = void 0;
-			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}`);
-			}
-			throw error;
-		}
-	}
-	async isAvailable() {
-		return checkCliAvailable("claude");
-	}
-	getInfo() {
-		return {
-			name: "Claude Code CLI",
-			model: this.options.model
-		};
-	}
-	buildArgs(message, options) {
-		const args = [
-			"-p",
-			"--dangerously-skip-permissions",
-			message
-		];
-		if (this.options.model) args.push("--model", this.options.model);
-		if (options?.system || this.options.appendSystemPrompt) {
-			const system = options?.system || this.options.appendSystemPrompt;
-			args.push("--append-system-prompt", system);
-		}
-		if (this.options.allowedTools?.length) args.push("--allowed-tools", this.options.allowedTools.join(","));
-		const outputFormat = this.options.outputFormat ?? "stream-json";
-		args.push("--output-format", outputFormat);
-		if (outputFormat === "stream-json") args.push("--verbose");
-		if (this.options.continue) args.push("--continue");
-		if (this.options.resume) args.push("--resume", this.options.resume);
-		const mcpConfigPath = this.options.mcpConfigPath ?? (this.options.workspace ? (() => {
-			const p = join(this.options.workspace, "mcp-config.json");
-			return existsSync(p) ? p : void 0;
-		})() : void 0);
-		if (mcpConfigPath) args.push("--mcp-config", mcpConfigPath);
-		return args;
-	}
-	/**
-	* Abort any running claude process
-	*/
-	abort() {
-		if (this.currentAbort) {
-			this.currentAbort();
-			this.currentAbort = void 0;
-		}
-	}
-};
-
-//#endregion
-//#region src/backends/codex.ts
-var CodexBackend = class {
-	type = "codex";
-	options;
-	constructor(options = {}) {
-		this.options = {
-			timeout: DEFAULT_IDLE_TIMEOUT,
-			...options
-		};
-	}
-	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: "codex",
-				args,
-				cwd,
-				timeout,
-				onStdout: this.options.streamCallbacks ? createStreamParser(this.options.streamCallbacks, "Codex", codexAdapter) : void 0
-			});
-			return extractCodexResult(stdout);
-		} catch (error) {
-			handleCliBackendError(error, "codex", timeout);
-		}
-	}
-	async isAvailable() {
-		return checkCliAvailable("codex");
-	}
-	getInfo() {
-		return {
-			name: "OpenAI Codex CLI",
-			model: this.options.model
-		};
-	}
-	buildArgs(message) {
-		const args = [
-			"exec",
-			"--full-auto",
-			"--json",
-			"--skip-git-repo-check",
-			message
-		];
-		if (this.options.model) args.push("--model", this.options.model);
-		if (this.options.resume) args.push("--resume", this.options.resume);
-		return args;
-	}
-};
-
-//#endregion
-//#region src/backends/cursor.ts
-var CursorBackend = class {
-	type = "cursor";
-	options;
-	/**
-	* 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,
-			...options
-		};
-	}
-	async send(message, _options) {
-		const { command, args } = await this.buildCommand(message);
-		const cwd = this.options.workspace || this.options.cwd;
-		const timeout = this.options.timeout ?? DEFAULT_IDLE_TIMEOUT;
-		try {
-			const { stdout } = await execWithIdleTimeout({
-				command,
-				args,
-				cwd,
-				timeout,
-				onStdout: this.options.streamCallbacks ? createStreamParser(this.options.streamCallbacks, "Cursor", cursorAdapter) : void 0
-			});
-			return extractClaudeResult(stdout);
-		} catch (error) {
-			handleCliBackendError(error, "cursor agent", timeout);
-		}
-	}
-	async isAvailable() {
-		return await this.resolveStyle() !== null;
-	}
-	getInfo() {
-		return {
-			name: "Cursor Agent CLI",
-			model: this.options.model
-		};
-	}
-	/**
-	* 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 resolveStyle() {
-		if (this.resolvedStyle !== null) return this.resolvedStyle;
-		if (await checkCliAvailable("cursor", ["agent", "--version"], 2e3)) {
-			this.resolvedStyle = "subcommand";
-			return "subcommand";
-		}
-		if (await checkCliAvailable("agent", ["--version"], 2e3)) {
-			this.resolvedStyle = "direct";
-			return "direct";
-		}
-		return null;
-	}
-	async buildCommand(message) {
-		const style = await this.resolveStyle();
-		const agentArgs = [
-			"-p",
-			"--force",
-			"--approve-mcps",
-			"--output-format=stream-json",
-			message
-		];
-		if (this.options.model) agentArgs.push("--model", this.options.model);
-		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
-var OpenCodeBackend = class {
-	type = "opencode";
-	options;
-	constructor(options = {}) {
-		this.options = {
-			timeout: DEFAULT_IDLE_TIMEOUT,
-			...options
-		};
-	}
-	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) {
-			handleCliBackendError(error, "opencode", timeout);
-		}
-	}
-	async isAvailable() {
-		return checkCliAvailable("opencode");
-	}
-	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 {
-			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
-/**
-* Vercel AI SDK backend
-* Uses the AI SDK for direct API access
-*/
-var SdkBackend = class {
-	type = "default";
-	modelId;
-	model = null;
-	maxTokens;
-	provider;
-	constructor(options) {
-		this.modelId = options.model;
-		this.maxTokens = options.maxTokens ?? 4096;
-		this.provider = options.provider;
-		if (!this.provider) try {
-			this.model = createModel(this.modelId);
-		} catch {}
-	}
-	async send(message, options) {
-		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,
-			prompt: message,
-			maxOutputTokens: this.maxTokens
-		});
-		return {
-			content: result.text,
-			usage: {
-				input: result.usage.inputTokens ?? 0,
-				output: result.usage.outputTokens ?? 0,
-				total: result.usage.totalTokens ?? 0
-			}
-		};
-	}
-	async isAvailable() {
-		try {
-			if (!this.model) this.model = this.provider ? await createModelWithProvider(this.modelId, this.provider) : await createModelAsync(this.modelId);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	getInfo() {
-		return {
-			name: "Vercel AI SDK",
-			model: this.modelId
-		};
-	}
-};
-
-//#endregion
-//#region src/backends/mock.ts
-/**
-* Mock AI Backend for testing
-*
-* In single-agent mode, provides a simple echo send().
-* In workflow mode, the loop handles MCP tool orchestration
-* via the mock runner strategy (loop/mock-runner.ts).
-*/
-var MockAIBackend = class {
-	type = "mock";
-	constructor(debugLog) {
-		this.debugLog = debugLog;
-	}
-	async send(message, _options) {
-		(this.debugLog || (() => {}))(`[mock] Received message (${message.length} chars)`);
-		return { content: `[mock] Processed: ${message.slice(0, 200)}` };
-	}
-};
-/**
-* Create a mock AI backend
-*/
-function createMockBackend(debugLog) {
-	return new MockAIBackend(debugLog);
-}
-
-//#endregion
-//#region src/backends/index.ts
-/**
-* Create a backend instance
-* Model names are automatically translated to backend-specific format
-* Accepts "sdk" as deprecated alias for "default"
-*
-* Examples:
-* - "sonnet" → cursor: "sonnet-4.5", claude: "sonnet", default: "claude-sonnet-4-5-20250514"
-* - "anthropic/claude-sonnet-4-5" → cursor: "sonnet-4.5", claude: "sonnet"
-*/
-function createBackend(config) {
-	const normalized = {
-		...config,
-		type: normalizeBackendType(config.type)
-	};
-	const model = getModelForBackend(normalized.model, normalized.type);
-	switch (normalized.type) {
-		case "default": {
-			const provider = normalized.provider;
-			return new SdkBackend({
-				model,
-				maxTokens: normalized.maxTokens,
-				provider
-			});
-		}
-		case "claude": return new ClaudeCodeBackend({
-			...normalized.options,
-			model
-		});
-		case "codex": return new CodexBackend({
-			...normalized.options,
-			model
-		});
-		case "cursor": return new CursorBackend({
-			...normalized.options,
-			model
-		});
-		case "opencode": return new OpenCodeBackend({
-			...normalized.options,
-			model
-		});
-		default: throw new Error(`Unknown backend type: ${normalized.type}`);
-	}
-}
-/** Check availability with a timeout to avoid hanging when CLIs are missing */
-function withTimeout(promise, ms) {
-	return Promise.race([promise, new Promise((resolve) => setTimeout(() => resolve(false), ms))]);
-}
-/**
-* Check which backends are available
-*/
-async function checkBackends() {
-	const claude = new ClaudeCodeBackend();
-	const codex = new CodexBackend();
-	const cursor = new CursorBackend();
-	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(opencode.isAvailable(), 3e3)
-	]);
-	return {
-		default: true,
-		claude: claudeAvailable,
-		codex: codexAvailable,
-		cursor: cursorAvailable,
-		opencode: opencodeAvailable,
-		mock: true
-	};
-}
-/**
-* List available backends with info
-*/
-async function listBackends() {
-	const availability = await checkBackends();
-	return [
-		{
-			type: "default",
-			available: availability.default,
-			name: "Vercel AI SDK"
-		},
-		{
-			type: "claude",
-			available: availability.claude,
-			name: "Claude Code CLI"
-		},
-		{
-			type: "codex",
-			available: availability.codex,
-			name: "OpenAI Codex CLI"
-		},
-		{
-			type: "cursor",
-			available: availability.cursor,
-			name: "Cursor Agent CLI"
-		},
-		{
-			type: "opencode",
-			available: availability.opencode,
-			name: "OpenCode CLI"
-		}
-	];
-}
-
-//#endregion
-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, isAutoProvider as L, SUPPORTED_PROVIDERS as M, createModel as N, getModelForBackend as O, createModelAsync as P, resolveModelFallback as R, 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 };