agent-worker 0.3.0 → 0.4.0

package/dist/backends-DenGdkrj.mjs

@@ -0,0 +1,735 @@
+import { gateway, generateText } from "ai";
+import { ExecaError, execa } from "execa";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { stringify } from "yaml";
+
+//#region src/agent/models.ts
+const providerCache = {};
+/**
+* Lazy load a provider, caching the result
+* Supports custom baseURL and apiKey for providers using compatible APIs (e.g., MiniMax using Claude API)
+*/
+async function loadProvider(name, packageName, exportName, options) {
+	if (name in providerCache) return providerCache[name] ?? 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];
+		providerCache[name] = exportedProvider;
+		return exportedProvider;
+	} catch {
+		providerCache[name] = null;
+		return null;
+	}
+}
+/**
+* Parse model identifier and return the appropriate provider model
+*
+* Supports three formats:
+*
+* 1. Provider-only format: provider
+*    Uses first model from FRONTIER_MODELS via gateway
+*    Examples: anthropic → anthropic/claude-sonnet-4-5, openai → openai/gpt-5.2
+*
+* 2. Gateway format: provider/model-name
+*    Uses Vercel AI Gateway (requires AI_GATEWAY_API_KEY)
+*    Examples: anthropic/claude-sonnet-4-5, openai/gpt-5.2, deepseek/deepseek-chat
+*
+* 3. Direct provider format: provider:model-name
+*    Requires installing the specific @ai-sdk/provider package
+*    Examples: anthropic:claude-sonnet-4-5, openai:gpt-5.2, deepseek:deepseek-chat
+*/
+function createModel(modelId) {
+	if (modelId.includes("/")) return gateway(modelId);
+	if (!modelId.includes(":")) {
+		const provider = modelId;
+		if (provider in FRONTIER_MODELS) {
+			const defaultModel = FRONTIER_MODELS[provider][0];
+			return gateway(`${provider}/${defaultModel}`);
+		}
+		throw new Error(`Unknown provider: ${modelId}. Supported: ${Object.keys(FRONTIER_MODELS).join(", ")}`);
+	}
+	const colonIndex = modelId.indexOf(":");
+	const provider = modelId.slice(0, colonIndex);
+	const modelName = modelId.slice(colonIndex + 1);
+	if (!modelName) throw new Error(`Invalid model identifier: ${modelId}. Model name is required.`);
+	if (provider in providerCache && providerCache[provider]) return providerCache[provider](modelName);
+	throw new Error(`Provider '${provider}' not loaded. Use gateway format (${provider}/${modelName}) or call createModelAsync() for direct provider access.`);
+}
+/**
+* Async version of createModel - supports lazy loading of direct providers
+* Use this when you need direct provider access (provider:model format)
+*/
+async function createModelAsync(modelId) {
+	if (modelId.includes("/")) return gateway(modelId);
+	if (!modelId.includes(":")) {
+		const provider = modelId;
+		if (provider in FRONTIER_MODELS) {
+			const defaultModel = FRONTIER_MODELS[provider][0];
+			return gateway(`${provider}/${defaultModel}`);
+		}
+		throw new Error(`Unknown provider: ${modelId}. Supported: ${Object.keys(FRONTIER_MODELS).join(", ")}`);
+	}
+	const colonIndex = modelId.indexOf(":");
+	const provider = modelId.slice(0, colonIndex);
+	const modelName = modelId.slice(colonIndex + 1);
+	if (!modelName) throw new Error(`Invalid model identifier: ${modelId}. Model name is required.`);
+	const providerConfigs = {
+		anthropic: {
+			package: "@ai-sdk/anthropic",
+			export: "anthropic"
+		},
+		openai: {
+			package: "@ai-sdk/openai",
+			export: "openai"
+		},
+		deepseek: {
+			package: "@ai-sdk/deepseek",
+			export: "deepseek"
+		},
+		google: {
+			package: "@ai-sdk/google",
+			export: "google"
+		},
+		groq: {
+			package: "@ai-sdk/groq",
+			export: "groq"
+		},
+		mistral: {
+			package: "@ai-sdk/mistral",
+			export: "mistral"
+		},
+		xai: {
+			package: "@ai-sdk/xai",
+			export: "xai"
+		},
+		minimax: {
+			package: "@ai-sdk/anthropic",
+			export: "anthropic",
+			options: {
+				baseURL: "https://api.minimax.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);
+	if (!providerFn) throw new Error(`Install ${config.package} to use ${provider} models directly`);
+	return providerFn(modelName);
+}
+/**
+* List of supported providers for direct access
+* Note: minimax uses Claude-compatible API via @ai-sdk/anthropic with custom baseURL
+*/
+const SUPPORTED_PROVIDERS = [
+	"anthropic",
+	"openai",
+	"deepseek",
+	"google",
+	"groq",
+	"mistral",
+	"xai",
+	"minimax"
+];
+/**
+* Default provider when none specified
+*/
+const DEFAULT_PROVIDER = "anthropic";
+/**
+* Get the default model identifier (provider/model format)
+* Uses the first model from the default provider
+*/
+function getDefaultModel() {
+	return `${DEFAULT_PROVIDER}/${FRONTIER_MODELS[DEFAULT_PROVIDER][0]}`;
+}
+/**
+* Frontier models for each provider (as of 2026-02)
+* Only includes the latest/best models, no legacy versions
+*
+* Note: Some models may be placeholders for testing or future releases.
+* Always verify model availability with the provider before production use.
+*/
+const FRONTIER_MODELS = {
+	anthropic: [
+		"claude-sonnet-4-5",
+		"claude-haiku-4-5",
+		"claude-opus-4-5"
+	],
+	openai: ["gpt-5.2", "gpt-5.2-codex"],
+	google: [
+		"gemini-3-pro-preview",
+		"gemini-2.5-flash",
+		"gemini-2.5-pro"
+	],
+	deepseek: ["deepseek-chat", "deepseek-reasoner"],
+	groq: ["meta-llama/llama-4-scout-17b-16e-instruct", "deepseek-r1-distill-llama-70b"],
+	mistral: [
+		"mistral-large-latest",
+		"pixtral-large-latest",
+		"magistral-medium-2506"
+	],
+	xai: ["grok-4", "grok-4-fast-reasoning"],
+	minimax: ["MiniMax-M2"]
+};
+
+//#endregion
+//#region src/backends/model-maps.ts
+/** Default model per backend */
+const BACKEND_DEFAULT_MODELS = {
+	mock: "mock-model",
+	sdk: "claude-sonnet-4-5",
+	claude: "sonnet",
+	cursor: "sonnet-4.5",
+	codex: "gpt-5.2-codex"
+};
+/**
+* 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"
+};
+/**
+* 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 "sdk": 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;
+		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/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.
+* Use setWorkspace() for workspace isolation, or setMcpConfigPath() directly.
+*
+* @see https://docs.anthropic.com/en/docs/claude-code
+*/
+var ClaudeCodeBackend = class {
+	type = "claude";
+	options;
+	constructor(options = {}) {
+		this.options = {
+			timeout: 3e5,
+			...options
+		};
+	}
+	/**
+	* Set up workspace directory with MCP config
+	* Claude uses --mcp-config flag, so we just write the config file
+	*/
+	setWorkspace(workspaceDir, mcpConfig) {
+		this.options.workspace = workspaceDir;
+		if (!existsSync(workspaceDir)) mkdirSync(workspaceDir, { recursive: true });
+		const mcpConfigPath = join(workspaceDir, "mcp-config.json");
+		writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+		this.options.mcpConfigPath = mcpConfigPath;
+	}
+	async send(message, options) {
+		const args = this.buildArgs(message, options);
+		const cwd = this.options.workspace || this.options.cwd;
+		try {
+			const { stdout } = await execa("claude", args, {
+				cwd,
+				stdin: "ignore",
+				timeout: this.options.timeout
+			});
+			if (this.options.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) {
+			if (error instanceof ExecaError) throw new Error(`claude failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			throw error;
+		}
+	}
+	async isAvailable() {
+		try {
+			await execa("claude", ["--version"], {
+				stdin: "ignore",
+				timeout: 5e3
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	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(","));
+		if (this.options.outputFormat) args.push("--output-format", this.options.outputFormat);
+		if (this.options.continue) args.push("--continue");
+		if (this.options.resume) args.push("--resume", this.options.resume);
+		if (this.options.mcpConfigPath) args.push("--mcp-config", this.options.mcpConfigPath);
+		return args;
+	}
+	/**
+	* Set MCP config path (for workflow integration)
+	*/
+	setMcpConfigPath(path) {
+		this.options.mcpConfigPath = path;
+	}
+};
+
+//#endregion
+//#region src/backends/codex.ts
+/**
+* OpenAI Codex CLI backend
+* Uses `codex exec` for non-interactive mode
+*
+* MCP Configuration:
+* Codex uses project-level MCP config. Use setWorkspace() to set up
+* a dedicated workspace directory with .codex/config.yaml for MCP settings.
+*
+* @see https://github.com/openai/codex
+*/
+var CodexBackend = class {
+	type = "codex";
+	options;
+	constructor(options = {}) {
+		this.options = {
+			timeout: 3e5,
+			...options
+		};
+	}
+	/**
+	* Set up workspace directory with MCP config
+	* Creates .codex/config.yaml in the workspace with MCP server config
+	*/
+	setWorkspace(workspaceDir, mcpConfig) {
+		this.options.workspace = workspaceDir;
+		const codexDir = join(workspaceDir, ".codex");
+		if (!existsSync(codexDir)) mkdirSync(codexDir, { recursive: true });
+		const codexConfig = { mcp_servers: mcpConfig.mcpServers };
+		writeFileSync(join(codexDir, "config.yaml"), stringify(codexConfig));
+	}
+	async send(message, _options) {
+		const args = this.buildArgs(message);
+		const cwd = this.options.workspace || this.options.cwd;
+		try {
+			const { stdout } = await execa("codex", args, {
+				cwd,
+				stdin: "ignore",
+				timeout: this.options.timeout
+			});
+			if (this.options.json) try {
+				const lines = stdout.trim().split("\n");
+				const lastLine = lines[lines.length - 1];
+				if (!lastLine) return { content: stdout.trim() };
+				const lastEvent = JSON.parse(lastLine);
+				return {
+					content: lastEvent.message || lastEvent.content || stdout,
+					toolCalls: lastEvent.toolCalls,
+					usage: lastEvent.usage
+				};
+			} catch {
+				return { content: stdout.trim() };
+			}
+			return { content: stdout.trim() };
+		} catch (error) {
+			if (error instanceof ExecaError) throw new Error(`codex failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			throw error;
+		}
+	}
+	async isAvailable() {
+		try {
+			await execa("codex", ["--version"], {
+				stdin: "ignore",
+				timeout: 5e3
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	getInfo() {
+		return {
+			name: "OpenAI Codex CLI",
+			model: this.options.model
+		};
+	}
+	buildArgs(message) {
+		const args = [
+			"exec",
+			"--dangerously-bypass-approvals-and-sandbox",
+			message
+		];
+		if (this.options.model) args.push("--model", this.options.model);
+		if (this.options.json) args.push("--json");
+		if (this.options.skipGitRepoCheck) args.push("--skip-git-repo-check");
+		if (this.options.approvalMode) args.push("--approval-mode", this.options.approvalMode);
+		if (this.options.resume) args.push("--resume", this.options.resume);
+		return args;
+	}
+};
+
+//#endregion
+//#region src/backends/cursor.ts
+/**
+* Cursor CLI backend
+* Uses `cursor-agent -p` for non-interactive mode
+*
+* MCP Configuration:
+* Cursor uses project-level MCP config via .cursor/mcp.json in the workspace.
+* Use setWorkspace() to set up a dedicated workspace with MCP config.
+*
+* @see https://docs.cursor.com/context/model-context-protocol
+*/
+var CursorBackend = class {
+	type = "cursor";
+	options;
+	constructor(options = {}) {
+		this.options = {
+			timeout: 12e4,
+			...options
+		};
+	}
+	/**
+	* Set up workspace directory with MCP config
+	* Creates .cursor/mcp.json in the workspace
+	*/
+	setWorkspace(workspaceDir, mcpConfig) {
+		this.options.workspace = workspaceDir;
+		const cursorDir = join(workspaceDir, ".cursor");
+		if (!existsSync(cursorDir)) mkdirSync(cursorDir, { recursive: true });
+		writeFileSync(join(cursorDir, "mcp.json"), JSON.stringify(mcpConfig, null, 2));
+	}
+	async send(message, _options) {
+		const { command, args } = this.buildCommand(message);
+		const cwd = this.options.workspace || this.options.cwd;
+		try {
+			const { stdout } = await execa(command, args, {
+				cwd,
+				stdin: "ignore",
+				timeout: this.options.timeout
+			});
+			return { content: stdout.trim() };
+		} catch (error) {
+			if (error instanceof ExecaError) {
+				if (error.timedOut) throw new Error(`cursor-agent timed out after ${this.options.timeout}ms`);
+				throw new Error(`cursor-agent failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			}
+			throw error;
+		}
+	}
+	async isAvailable() {
+		for (const cmd of ["cursor-agent", "agent"]) try {
+			await execa(cmd, ["--version"], {
+				stdin: "ignore",
+				timeout: 2e3
+			});
+			return true;
+		} catch {}
+		return false;
+	}
+	getInfo() {
+		return {
+			name: "Cursor Agent CLI",
+			model: this.options.model
+		};
+	}
+	buildCommand(message) {
+		const args = [
+			"-p",
+			"--force",
+			"--approve-mcps",
+			message
+		];
+		if (this.options.model) args.push("--model", this.options.model);
+		return {
+			command: "cursor-agent",
+			args
+		};
+	}
+};
+
+//#endregion
+//#region src/backends/sdk.ts
+/**
+* Vercel AI SDK backend
+* Uses the AI SDK for direct API access
+*/
+var SdkBackend = class {
+	type = "sdk";
+	modelId;
+	model = null;
+	maxTokens;
+	constructor(options) {
+		this.modelId = options.model;
+		this.maxTokens = options.maxTokens ?? 4096;
+		try {
+			this.model = createModel(this.modelId);
+		} catch {}
+	}
+	async send(message, options) {
+		if (!this.model) this.model = 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 = 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 controller handles MCP tool orchestration
+* via the mock runner strategy (controller/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
+*
+* Examples:
+* - "sonnet" → cursor: "sonnet-4.5", claude: "sonnet", sdk: "claude-sonnet-4-5-20250514"
+* - "anthropic/claude-sonnet-4-5" → cursor: "sonnet-4.5", claude: "sonnet"
+*/
+function createBackend(config) {
+	const model = getModelForBackend(config.model, config.type);
+	switch (config.type) {
+		case "sdk": return new SdkBackend({
+			model,
+			maxTokens: config.maxTokens
+		});
+		case "claude": return new ClaudeCodeBackend({
+			...config.options,
+			model
+		});
+		case "codex": return new CodexBackend({
+			...config.options,
+			model
+		});
+		case "cursor": return new CursorBackend({
+			...config.options,
+			model
+		});
+		default: throw new Error(`Unknown backend type: ${config.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 [claudeAvailable, codexAvailable, cursorAvailable] = await Promise.all([
+		withTimeout(claude.isAvailable(), 3e3),
+		withTimeout(codex.isAvailable(), 3e3),
+		withTimeout(cursor.isAvailable(), 3e3)
+	]);
+	return {
+		sdk: true,
+		claude: claudeAvailable,
+		codex: codexAvailable,
+		cursor: cursorAvailable,
+		mock: true
+	};
+}
+/**
+* List available backends with info
+*/
+async function listBackends() {
+	const availability = await checkBackends();
+	return [
+		{
+			type: "sdk",
+			available: availability.sdk,
+			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"
+		}
+	];
+}
+
+//#endregion
+export { FRONTIER_MODELS as _, createMockBackend as a, createModelAsync as b, CodexBackend as c, CLAUDE_MODEL_MAP as d, CODEX_MODEL_MAP as f, parseModel as g, getModelForBackend as h, MockAIBackend as i, ClaudeCodeBackend as l, SDK_MODEL_ALIASES as m, createBackend as n, SdkBackend as o, CURSOR_MODEL_MAP as p, listBackends as r, CursorBackend as s, checkBackends as t, BACKEND_DEFAULT_MODELS as u, SUPPORTED_PROVIDERS as v, getDefaultModel as x, createModel as y };