@corbat-tech/coco 2.34.0 → 2.35.0

package/dist/index.js

@@ -44,8 +44,13 @@ import yaml from 'highlight.js/lib/languages/yaml';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -253,6 +258,793 @@ var init_logger = __esm({
     globalLogger = null;
   }
 });
+
+// src/providers/catalog.ts
+function model(entry) {
+  return {
+    ...entry,
+    source: entry.source ?? SOURCES.providerDocs
+  };
+}
+function getProviderCatalogEntry(provider) {
+  return PROVIDER_CATALOG[provider];
+}
+function getCatalogDefaultModel(provider) {
+  return getProviderCatalogEntry(provider).defaultModel;
+}
+function getCatalogModel(provider, modelId) {
+  return getProviderCatalogEntry(provider).models.find((modelEntry) => modelEntry.id === modelId);
+}
+function getCatalogContextWindow(provider, modelId, fallback) {
+  if (!modelId) return fallback;
+  const exact = getCatalogModel(provider, modelId);
+  if (exact) return exact.contextWindow;
+  return fallback;
+}
+function getCatalogModelPricingMap() {
+  const pricing = {};
+  for (const provider of Object.values(PROVIDER_CATALOG)) {
+    for (const modelEntry of provider.models) {
+      if (!modelEntry.pricing) continue;
+      pricing[modelEntry.id] = {
+        ...modelEntry.pricing,
+        contextWindow: modelEntry.contextWindow
+      };
+    }
+  }
+  return pricing;
+}
+var VERIFIED_AT, SOURCES, PROVIDER_CATALOG;
+var init_catalog = __esm({
+  "src/providers/catalog.ts"() {
+    VERIFIED_AT = "2026-06-18";
+    SOURCES = {
+      openaiModels: {
+        name: "OpenAI models",
+        url: "https://developers.openai.com/api/docs/models",
+        verifiedAt: VERIFIED_AT
+      },
+      openaiAllModels: {
+        name: "OpenAI all models",
+        url: "https://developers.openai.com/api/docs/models/all",
+        verifiedAt: VERIFIED_AT
+      },
+      codexModels: {
+        name: "OpenAI Codex models",
+        url: "https://developers.openai.com/codex/models",
+        verifiedAt: VERIFIED_AT
+      },
+      anthropicModels: {
+        name: "Anthropic models overview",
+        url: "https://docs.anthropic.com/en/docs/about-claude/models/overview",
+        verifiedAt: VERIFIED_AT
+      },
+      anthropicDeprecations: {
+        name: "Anthropic model deprecations",
+        url: "https://docs.anthropic.com/en/docs/about-claude/model-deprecations",
+        verifiedAt: VERIFIED_AT
+      },
+      geminiModels: {
+        name: "Gemini API models",
+        url: "https://ai.google.dev/gemini-api/docs/models",
+        verifiedAt: VERIFIED_AT
+      },
+      geminiGuide: {
+        name: "Gemini 3 developer guide",
+        url: "https://ai.google.dev/gemini-api/docs/gemini-3",
+        verifiedAt: VERIFIED_AT
+      },
+      githubCopilotModels: {
+        name: "GitHub Copilot supported models",
+        url: "https://docs.github.com/copilot/reference/ai-models/supported-models",
+        verifiedAt: VERIFIED_AT
+      },
+      githubCopilotComparison: {
+        name: "GitHub Copilot model comparison",
+        url: "https://docs.github.com/en/copilot/reference/ai-models/model-comparison",
+        verifiedAt: VERIFIED_AT
+      },
+      moonshotDocs: {
+        name: "Moonshot AI docs",
+        url: "https://platform.moonshot.ai/docs",
+        verifiedAt: VERIFIED_AT
+      },
+      qwenDocs: {
+        name: "Alibaba Cloud Model Studio docs",
+        url: "https://www.alibabacloud.com/help/en/model-studio/",
+        verifiedAt: VERIFIED_AT
+      },
+      providerDocs: {
+        name: "Provider API documentation",
+        url: "https://github.com/corbat/corbat-coco/blob/main/docs/guides/PROVIDERS.md",
+        verifiedAt: VERIFIED_AT
+      }
+    };
+    PROVIDER_CATALOG = {
+      anthropic: {
+        id: "anthropic",
+        defaultModel: "claude-sonnet-4-6",
+        models: [
+          model({
+            id: "claude-opus-4-8",
+            name: "Claude Opus 4.8",
+            description: "Most capable Opus-tier model for complex agentic work",
+            contextWindow: 2e5,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "adaptive-thinking",
+              "reasoning-effort",
+              "anthropic-messages"
+            ],
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-sonnet-4-6",
+            name: "Claude Sonnet 4.6",
+            description: "Balanced default for coding, tool use, and long-running tasks",
+            contextWindow: 2e5,
+            maxOutputTokens: 128e3,
+            recommended: true,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "adaptive-thinking",
+              "reasoning-effort",
+              "anthropic-messages"
+            ],
+            pricing: { inputPerMillion: 3, outputPerMillion: 15 },
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-opus-4-6",
+            name: "Claude Opus 4.6",
+            description: "Legacy Opus option; prefer Opus 4.8 for new configurations",
+            contextWindow: 2e5,
+            maxOutputTokens: 128e3,
+            status: "legacy",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "adaptive-thinking",
+              "reasoning-effort",
+              "anthropic-messages"
+            ],
+            pricing: { inputPerMillion: 5, outputPerMillion: 25 },
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-haiku-4-5-20251001",
+            name: "Claude Haiku 4.5",
+            description: "Fast low-cost Claude model",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "anthropic-messages"],
+            pricing: { inputPerMillion: 1, outputPerMillion: 5 },
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-sonnet-4-20250514",
+            name: "Claude Sonnet 4",
+            description: "Retired on the Claude API; kept for config migration warnings",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "vision", "thinking-budget", "anthropic-messages"],
+            pricing: { inputPerMillion: 3, outputPerMillion: 15 },
+            source: SOURCES.anthropicDeprecations
+          }),
+          model({
+            id: "claude-opus-4-20250514",
+            name: "Claude Opus 4",
+            description: "Retired on the Claude API; kept for config migration warnings",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "vision", "thinking-budget", "anthropic-messages"],
+            pricing: { inputPerMillion: 15, outputPerMillion: 75 },
+            source: SOURCES.anthropicDeprecations
+          })
+        ]
+      },
+      openai: {
+        id: "openai",
+        defaultModel: "gpt-5.5",
+        models: [
+          model({
+            id: "gpt-5.5",
+            name: "GPT-5.5",
+            description: "Default for complex coding, agentic workflows, and tool-heavy tasks",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "reasoning-effort", "openai-responses"],
+            pricing: { inputPerMillion: 5, outputPerMillion: 30 },
+            source: SOURCES.openaiModels
+          }),
+          model({
+            id: "gpt-5.4",
+            name: "GPT-5.4",
+            description: "Affordable model for coding and professional work",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-5.4-mini",
+            name: "GPT-5.4 mini",
+            description: "Fast model for lighter coding tasks and subagents",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-5.3-codex",
+            name: "GPT-5.3 Codex",
+            description: "Agentic coding model; keep separate from older ChatGPT-only aliases",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-5.2-codex",
+            name: "GPT-5.2 Codex",
+            description: "Deprecated Codex model retained for existing configs",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-4.1",
+            name: "GPT-4.1",
+            description: "Legacy long-context non-reasoning model",
+            contextWindow: 1048576,
+            maxOutputTokens: 32768,
+            status: "legacy",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            pricing: { inputPerMillion: 2, outputPerMillion: 8 },
+            source: SOURCES.openaiAllModels
+          })
+        ]
+      },
+      codex: {
+        id: "codex",
+        defaultModel: "gpt-5.5",
+        models: [
+          model({
+            id: "gpt-5.5",
+            name: "GPT-5.5",
+            description: "Recommended Codex model for complex coding work",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.codexModels
+          }),
+          model({
+            id: "gpt-5.4-mini",
+            name: "GPT-5.4 mini",
+            description: "Faster Codex option for lighter work and subagents",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.codexModels
+          }),
+          model({
+            id: "gpt-5.3-codex-spark",
+            name: "GPT-5.3 Codex Spark",
+            description: "Research preview for near-instant coding iteration",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "experimental",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.codexModels
+          }),
+          model({
+            id: "codex-mini-latest",
+            name: "Codex mini latest",
+            description: "Deprecated fast Codex CLI model retained for existing configs",
+            contextWindow: 128e3,
+            maxOutputTokens: 32e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          })
+        ]
+      },
+      copilot: {
+        id: "copilot",
+        defaultModel: "claude-sonnet-4.6",
+        models: [
+          model({
+            id: "claude-sonnet-4.6",
+            name: "Claude Sonnet 4.6",
+            description: "Reliable Copilot default for coding and review",
+            contextWindow: 168e3,
+            maxOutputTokens: 64e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotComparison
+          }),
+          model({
+            id: "gpt-5.5",
+            name: "GPT-5.5",
+            description: "Copilot model for complex reasoning and technical decisions",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotComparison
+          }),
+          model({
+            id: "gpt-5.4",
+            name: "GPT-5.4",
+            description: "Copilot coding model",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gpt-5.4-mini",
+            name: "GPT-5.4 mini",
+            description: "Fast Copilot model for interactive coding",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gpt-5.3-codex",
+            name: "GPT-5.3 Codex",
+            description: "Copilot agentic coding model",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "claude-opus-4.8",
+            name: "Claude Opus 4.8",
+            description: "Most capable Anthropic model exposed by Copilot when available",
+            contextWindow: 168e3,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gemini-3.1-pro",
+            name: "Gemini 3.1 Pro",
+            description: "Gemini model exposed by Copilot",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gemini-3.5-flash",
+            name: "Gemini 3.5 Flash",
+            description: "Fast Gemini model exposed by Copilot",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          })
+        ]
+      },
+      gemini: {
+        id: "gemini",
+        defaultModel: "gemini-3.1-pro-preview",
+        models: [
+          model({
+            id: "gemini-3.1-pro-preview",
+            name: "Gemini 3.1 Pro Preview",
+            description: "Most capable Gemini 3 model for agentic and coding workflows",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            recommended: true,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-3-flash-preview",
+            name: "Gemini 3 Flash Preview",
+            description: "Fast Gemini 3 preview model",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-2.5-pro",
+            name: "Gemini 2.5 Pro",
+            description: "Stable Gemini Pro model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          }),
+          model({
+            id: "gemini-2.5-flash",
+            name: "Gemini 2.5 Flash",
+            description: "Stable fast Gemini model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          }),
+          model({
+            id: "gemini-2.5-flash-lite",
+            name: "Gemini 2.5 Flash-Lite",
+            description: "Lowest-cost stable Gemini option",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          })
+        ]
+      },
+      vertex: {
+        id: "vertex",
+        defaultModel: "gemini-2.5-pro",
+        models: [
+          model({
+            id: "gemini-2.5-pro",
+            name: "Gemini 2.5 Pro",
+            description: "Stable Vertex model for coding and complex reasoning",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            recommended: true,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          }),
+          model({
+            id: "gemini-3-pro-preview",
+            name: "Gemini 3 Pro Preview",
+            description: "Preview Vertex Gemini 3 model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-3-flash-preview",
+            name: "Gemini 3 Flash Preview",
+            description: "Fast preview Vertex Gemini 3 model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-2.5-flash",
+            name: "Gemini 2.5 Flash",
+            description: "Fast stable Vertex Gemini model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          })
+        ]
+      },
+      kimi: {
+        id: "kimi",
+        defaultModel: "kimi-k2.5",
+        models: [
+          model({
+            id: "kimi-k2.5",
+            name: "Kimi K2.5",
+            description: "Moonshot model for coding and agentic work",
+            contextWindow: 262144,
+            maxOutputTokens: 32e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.moonshotDocs
+          }),
+          model({
+            id: "kimi-k2-thinking",
+            name: "Kimi K2 Thinking",
+            description: "Reasoning variant",
+            contextWindow: 262144,
+            maxOutputTokens: 32e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.moonshotDocs
+          }),
+          model({
+            id: "moonshot-v1-128k",
+            name: "Moonshot v1 128K",
+            description: "Legacy long-context Moonshot model",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            status: "legacy",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            pricing: { inputPerMillion: 6, outputPerMillion: 6 },
+            source: SOURCES.moonshotDocs
+          })
+        ]
+      },
+      "kimi-code": {
+        id: "kimi-code",
+        defaultModel: "kimi-for-coding",
+        models: [
+          model({
+            id: "kimi-for-coding",
+            name: "Kimi for Coding",
+            description: "Anthropic-compatible Kimi coding endpoint",
+            contextWindow: 131072,
+            maxOutputTokens: 32e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "anthropic-messages"],
+            source: SOURCES.moonshotDocs
+          })
+        ]
+      },
+      lmstudio: {
+        id: "lmstudio",
+        defaultModel: "local-model",
+        models: [
+          model({
+            id: "local-model",
+            name: "Local model",
+            description: "Model selected in LM Studio",
+            contextWindow: 32768,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      ollama: {
+        id: "ollama",
+        defaultModel: "llama3.2",
+        models: [
+          model({
+            id: "llama3.2",
+            name: "Llama 3.2",
+            description: "Default local Ollama model",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          }),
+          model({
+            id: "qwen2.5-coder:14b",
+            name: "Qwen2.5 Coder 14B",
+            description: "Local coding model",
+            contextWindow: 32768,
+            maxOutputTokens: 8192,
+            status: "legacy",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      groq: {
+        id: "groq",
+        defaultModel: "llama-3.3-70b-versatile",
+        models: [
+          model({
+            id: "llama-3.3-70b-versatile",
+            name: "Llama 3.3 70B Versatile",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      openrouter: {
+        id: "openrouter",
+        defaultModel: "anthropic/claude-sonnet-4.6",
+        models: [
+          model({
+            id: "anthropic/claude-sonnet-4.6",
+            name: "Claude Sonnet 4.6 via OpenRouter",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"]
+          })
+        ]
+      },
+      mistral: {
+        id: "mistral",
+        defaultModel: "mistral-large-latest",
+        models: [
+          model({
+            id: "mistral-large-latest",
+            name: "Mistral Large latest",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          }),
+          model({
+            id: "codestral-latest",
+            name: "Codestral latest",
+            contextWindow: 32768,
+            maxOutputTokens: 8192,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      deepseek: {
+        id: "deepseek",
+        defaultModel: "deepseek-chat",
+        models: [
+          model({
+            id: "deepseek-chat",
+            name: "DeepSeek Chat",
+            contextWindow: 65536,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          }),
+          model({
+            id: "deepseek-reasoner",
+            name: "DeepSeek Reasoner",
+            contextWindow: 65536,
+            maxOutputTokens: 8192,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      together: {
+        id: "together",
+        defaultModel: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        models: [
+          model({
+            id: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+            name: "Llama 3.3 70B Instruct Turbo",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      huggingface: {
+        id: "huggingface",
+        defaultModel: "meta-llama/Llama-3.1-70B-Instruct",
+        models: [
+          model({
+            id: "meta-llama/Llama-3.1-70B-Instruct",
+            name: "Llama 3.1 70B Instruct",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "legacy",
+            capabilities: ["streaming", "openai-chat"]
+          })
+        ]
+      },
+      qwen: {
+        id: "qwen",
+        defaultModel: "qwen-coder-plus",
+        models: [
+          model({
+            id: "qwen-coder-plus",
+            name: "Qwen Coder Plus",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.qwenDocs
+          }),
+          model({
+            id: "qwen-max",
+            name: "Qwen Max",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.qwenDocs
+          })
+        ]
+      }
+    };
+  }
+});
 async function refreshAccessToken(provider, refreshToken) {
   const config = OAUTH_CONFIGS[provider];
   if (!config) {
@@ -939,6 +1731,7 @@ var init_copilot = __esm({
         this.permanent = permanent;
         this.name = "CopilotAuthError";
       }
+      permanent;
     };
     CopilotCredentialsSchema = z.object({
       githubToken: z.string().min(1),
@@ -1514,8 +2307,8 @@ async function configExists(configPath, scope = "any") {
   }
   return false;
 }
-function getConfigValue(config, path42) {
-  const keys = path42.split(".");
+function getConfigValue(config, path44) {
+  const keys = path44.split(".");
   let current = config;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -1663,41 +2456,41 @@ function getBaseUrl(provider) {
 function getDefaultModel(provider) {
   switch (provider) {
     case "anthropic":
-      return process.env["ANTHROPIC_MODEL"] ?? "claude-opus-4-6";
+      return process.env["ANTHROPIC_MODEL"] ?? getCatalogDefaultModel(provider);
     case "openai":
-      return process.env["OPENAI_MODEL"] ?? "gpt-5.3-codex";
+      return process.env["OPENAI_MODEL"] ?? getCatalogDefaultModel(provider);
     case "gemini":
-      return process.env["GEMINI_MODEL"] ?? "gemini-3.1-pro-preview";
+      return process.env["GEMINI_MODEL"] ?? getCatalogDefaultModel(provider);
     case "vertex":
-      return process.env["VERTEX_MODEL"] ?? "gemini-2.5-pro";
+      return process.env["VERTEX_MODEL"] ?? getCatalogDefaultModel(provider);
     case "kimi":
-      return process.env["KIMI_MODEL"] ?? "kimi-k2.5";
+      return process.env["KIMI_MODEL"] ?? getCatalogDefaultModel(provider);
     case "kimi-code":
-      return process.env["KIMI_CODE_MODEL"] ?? "kimi-for-coding";
+      return process.env["KIMI_CODE_MODEL"] ?? getCatalogDefaultModel(provider);
     case "lmstudio":
-      return process.env["LMSTUDIO_MODEL"] ?? "local-model";
+      return process.env["LMSTUDIO_MODEL"] ?? getCatalogDefaultModel(provider);
     case "ollama":
-      return process.env["OLLAMA_MODEL"] ?? "llama3.2";
+      return process.env["OLLAMA_MODEL"] ?? getCatalogDefaultModel(provider);
     case "codex":
-      return process.env["CODEX_MODEL"] ?? "codex-mini-latest";
+      return process.env["CODEX_MODEL"] ?? getCatalogDefaultModel(provider);
     case "copilot":
-      return process.env["COPILOT_MODEL"] ?? "claude-sonnet-4.6";
+      return process.env["COPILOT_MODEL"] ?? getCatalogDefaultModel(provider);
     case "groq":
-      return process.env["GROQ_MODEL"] ?? "llama-3.3-70b-versatile";
+      return process.env["GROQ_MODEL"] ?? getCatalogDefaultModel(provider);
     case "openrouter":
-      return process.env["OPENROUTER_MODEL"] ?? "anthropic/claude-3.5-sonnet";
+      return process.env["OPENROUTER_MODEL"] ?? getCatalogDefaultModel(provider);
     case "mistral":
-      return process.env["MISTRAL_MODEL"] ?? "mistral-large-latest";
+      return process.env["MISTRAL_MODEL"] ?? getCatalogDefaultModel(provider);
     case "deepseek":
-      return process.env["DEEPSEEK_MODEL"] ?? "deepseek-chat";
+      return process.env["DEEPSEEK_MODEL"] ?? getCatalogDefaultModel(provider);
     case "together":
-      return process.env["TOGETHER_MODEL"] ?? "meta-llama/Llama-3.3-70B-Instruct-Turbo";
+      return process.env["TOGETHER_MODEL"] ?? getCatalogDefaultModel(provider);
     case "huggingface":
-      return process.env["HF_MODEL"] ?? "meta-llama/Llama-3.1-70B-Instruct";
+      return process.env["HF_MODEL"] ?? getCatalogDefaultModel(provider);
     case "qwen":
-      return process.env["QWEN_MODEL"] ?? "qwen-max";
+      return process.env["QWEN_MODEL"] ?? getCatalogDefaultModel(provider);
     default:
-      return "claude-sonnet-4-6";
+      return getCatalogDefaultModel("anthropic");
   }
 }
 function getDefaultProvider() {
@@ -1724,6 +2517,7 @@ var init_env = __esm({
   "src/config/env.ts"() {
     init_loader();
     init_paths();
+    init_catalog();
     loadGlobalCocoEnv();
     VALID_PROVIDERS = [
       "anthropic",
@@ -2060,9 +2854,9 @@ async function migrateGlobalConfig(oldDir, newConfigPath) {
     );
   }
 }
-async function fileExists3(path42) {
+async function fileExists3(path44) {
   try {
-    await access(path42);
+    await access(path44);
     return true;
   } catch {
     return false;
@@ -3095,10 +3889,10 @@ function inferTargetUsers(session) {
     /(?:for|by)\s+(developers?|users?|administrators?|customers?)/gi,
     /(developers?|users?|administrators?|customers?)\s+(?:can|will|should)/gi
   ];
-  const text = session.requirements.map((r) => r.description).join(" ");
+  const text2 = session.requirements.map((r) => r.description).join(" ");
   for (const pattern of userPatterns) {
     let match;
-    while ((match = pattern.exec(text)) !== null) {
+    while ((match = pattern.exec(text2)) !== null) {
       const user = match[1]?.toLowerCase();
       if (user && !users.includes(user)) {
         users.push(user);
@@ -3111,13 +3905,13 @@ function inferTargetUsers(session) {
   return users;
 }
 function inferProjectType(session) {
-  const text = session.initialInput.toLowerCase();
-  if (text.includes("cli") || text.includes("command line")) return "cli";
-  if (text.includes("api") || text.includes("rest") || text.includes("graphql")) return "api";
-  if (text.includes("web app") || text.includes("frontend")) return "web_app";
-  if (text.includes("library") || text.includes("package")) return "library";
-  if (text.includes("service") || text.includes("daemon")) return "service";
-  if (text.includes("full stack") || text.includes("fullstack")) return "full_stack";
+  const text2 = session.initialInput.toLowerCase();
+  if (text2.includes("cli") || text2.includes("command line")) return "cli";
+  if (text2.includes("api") || text2.includes("rest") || text2.includes("graphql")) return "api";
+  if (text2.includes("web app") || text2.includes("frontend")) return "web_app";
+  if (text2.includes("library") || text2.includes("package")) return "library";
+  if (text2.includes("service") || text2.includes("daemon")) return "service";
+  if (text2.includes("full stack") || text2.includes("fullstack")) return "full_stack";
   return "unknown";
 }
 function assessComplexity(session) {
@@ -4663,14 +5457,14 @@ function generateArchitectureMarkdown(doc) {
   if (doc.dataModels.length > 0) {
     sections.push("## Data Models");
     sections.push("");
-    for (const model of doc.dataModels) {
-      sections.push(`### ${model.name}`);
+    for (const model2 of doc.dataModels) {
+      sections.push(`### ${model2.name}`);
       sections.push("");
-      sections.push(model.description);
+      sections.push(model2.description);
       sections.push("");
       sections.push("| Field | Type | Required |");
       sections.push("|-------|------|----------|");
-      for (const field of model.fields) {
+      for (const field of model2.fields) {
         sections.push(`| ${field.name} | ${field.type} | ${field.required ? "Yes" : "No"} |`);
       }
       sections.push("");
@@ -5894,6 +6688,7 @@ var CoverageAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze coverage by running tests with coverage enabled
    */
@@ -6236,6 +7031,7 @@ var SnykSecurityScanner = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Scan project with Snyk (requires authentication)
    */
@@ -6447,6 +7243,8 @@ var ComplexityAnalyzer = class {
     this.projectPath = projectPath;
     this.threshold = threshold;
   }
+  projectPath;
+  threshold;
   /**
    * Analyze complexity of project files
    */
@@ -6532,6 +7330,8 @@ var DuplicationAnalyzer = class {
     this.projectPath = projectPath;
     this.minLines = minLines;
   }
+  projectPath;
+  minLines;
   /**
    * Detect code duplication
    */
@@ -6900,6 +7700,7 @@ var CorrectnessAnalyzer = class {
     this.projectPath = projectPath;
     this.buildVerifier = new BuildVerifier(projectPath);
   }
+  projectPath;
   buildVerifier;
   /**
    * Analyze correctness by running tests and verifying build
@@ -7032,6 +7833,7 @@ var CompletenessAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze project completeness
    */
@@ -7265,6 +8067,7 @@ var RobustnessAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze robustness of project files
    */
@@ -7422,6 +8225,7 @@ var TestQualityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze test quality across the project
    */
@@ -7551,6 +8355,7 @@ var DocumentationAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze documentation quality
    */
@@ -7705,6 +8510,7 @@ var StyleAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze style/linting quality
    */
@@ -7914,6 +8720,7 @@ var ReadabilityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze readability of project files
    */
@@ -8051,6 +8858,7 @@ var MaintainabilityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze maintainability of project files
    */
@@ -8418,6 +9226,7 @@ var JavaComplexityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath);
     if (!javaFiles.length) {
@@ -8557,6 +9366,7 @@ var JavaSecurityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath, { includeTests: false });
     if (!javaFiles.length) {
@@ -8621,6 +9431,7 @@ var JavaStyleAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath);
     if (!javaFiles.length) return { score: 100, violations: [] };
@@ -8719,6 +9530,7 @@ var JavaDocumentationAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath, { srcPattern: "src/main/**/*.java" });
     if (!javaFiles.length) {
@@ -8796,6 +9608,7 @@ var JavaCoverageAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze() {
     for (const reportPath of JACOCO_REPORT_PATHS) {
       try {
@@ -8927,6 +9740,7 @@ var ReactComponentAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const reactFiles = files ?? await findReactFiles(this.projectPath);
     if (!reactFiles.length) return { score: 100, totalComponents: 0, issues: [] };
@@ -9026,6 +9840,7 @@ var ReactA11yAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const reactFiles = files ?? await findReactFiles(this.projectPath);
     if (!reactFiles.length) return { score: 100, violations: [] };
@@ -9118,6 +9933,7 @@ var ReactHookAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const reactFiles = files ?? await findReactFiles(this.projectPath, "**/*.{tsx,jsx,ts,js}");
     if (!reactFiles.length) return { score: 100, violations: [] };
@@ -9531,6 +10347,8 @@ var QualityEvaluator = class {
     this.readabilityAnalyzer = new ReadabilityAnalyzer(projectPath);
     this.maintainabilityAnalyzer = new MaintainabilityAnalyzer(projectPath);
   }
+  projectPath;
+  registry;
   coverageAnalyzer;
   securityScanner;
   complexityAnalyzer;
@@ -10148,12 +10966,12 @@ function humanizeError(message, toolName) {
     return msg;
   }
   if (/ENOENT/i.test(msg)) {
-    const path42 = extractQuotedPath(msg);
-    return path42 ? `File or directory not found: ${path42}` : "File or directory not found";
+    const path44 = extractQuotedPath(msg);
+    return path44 ? `File or directory not found: ${path44}` : "File or directory not found";
   }
   if (/EACCES/i.test(msg)) {
-    const path42 = extractQuotedPath(msg);
-    return path42 ? `Permission denied: ${path42}` : "Permission denied \u2014 check file permissions";
+    const path44 = extractQuotedPath(msg);
+    return path44 ? `Permission denied: ${path44}` : "Permission denied \u2014 check file permissions";
   }
   if (/EISDIR/i.test(msg)) {
     return "Expected a file but found a directory at the specified path";
@@ -11561,8 +12379,8 @@ function createLLMAdapter2(context) {
         type: "done"
       };
     },
-    countTokens(text) {
-      return Math.ceil(text.length / 4);
+    countTokens(text2) {
+      return Math.ceil(text2.length / 4);
     },
     getContextWindow() {
       return 2e5;
@@ -13630,30 +14448,110 @@ var GEMINI_BUDGET = {
   medium: 8e3,
   high: 16e3
 };
-function isAnthropicThinkingModel(model) {
-  const m = model.toLowerCase();
+function isAnthropicThinkingModel(model2) {
+  const m = model2.toLowerCase();
   if (m === "kimi-for-coding") return false;
   return m.includes("claude-3-7") || m.includes("claude-opus-4") || m.includes("claude-sonnet-4") || m.includes("claude-haiku-4-5") || m.includes("claude-4");
 }
-function isOpenAIReasoningModel(model) {
-  const m = model.toLowerCase();
+function isAnthropicAdaptiveThinkingModel(model2) {
+  const m = model2.toLowerCase();
+  return m.includes("claude-opus-4-8") || m.includes("claude-opus-4-7") || m.includes("claude-opus-4-6") || m.includes("claude-sonnet-4-6");
+}
+function isOpenAIReasoningModel(model2) {
+  const m = model2.toLowerCase();
   return m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.startsWith("gpt-5") || m.includes("codex");
 }
-function isGeminiThinkingModel(model) {
-  const m = model.toLowerCase();
-  return m.includes("gemini-2.5-pro") || m.includes("gemini-2.5-flash") || m.includes("gemini-3") && !m.includes("flash-lite") || m.includes("gemini-2.0-flash-thinking");
+function isGeminiThinkingModel(model2) {
+  const m = model2.toLowerCase();
+  return m.includes("gemini-2.5-pro") || m.includes("gemini-2.5-flash") || m.includes("gemini-3") || m.includes("gemini-2.0-flash-thinking");
 }
-function isKimiThinkingModel(model) {
-  const m = model.toLowerCase();
+function isGeminiLevelThinkingModel(model2) {
+  return model2.toLowerCase().includes("gemini-3");
+}
+function isKimiThinkingModel(model2) {
+  const m = model2.toLowerCase();
   return m.includes("kimi-k2") || m === "kimi-latest";
 }
+var UNSUPPORTED = {
+  supported: false,
+  kinds: [],
+  levels: ["off"],
+  defaultMode: "off"
+};
 var ANTHROPIC_CAPABILITY = {
-  budgetRange: { min: 1024, max: 64e3, default: ANTHROPIC_BUDGET.medium }};
+  supported: true,
+  kinds: ["budget"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  budgetRange: { min: 1024, max: 64e3, default: ANTHROPIC_BUDGET.medium },
+  defaultMode: "off"
+};
+var ANTHROPIC_ADAPTIVE_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  defaultMode: "off"
+};
+var OPENAI_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  defaultMode: "medium"
+};
 var GEMINI_CAPABILITY = {
-  budgetRange: { min: 0, max: 32e3}};
-function mapToAnthropic(mode, model) {
+  supported: true,
+  kinds: ["budget"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  budgetRange: { min: 0, max: 32e3, default: GEMINI_BUDGET.medium },
+  defaultMode: "auto"
+};
+var GEMINI_LEVEL_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["auto", "low", "medium", "high"],
+  defaultMode: "auto"
+};
+var KIMI_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["off", "auto"],
+  defaultMode: "off"
+};
+function getThinkingCapability(provider, model2) {
+  switch (provider) {
+    case "anthropic":
+    case "kimi-code":
+      if (isAnthropicAdaptiveThinkingModel(model2)) return ANTHROPIC_ADAPTIVE_CAPABILITY;
+      return isAnthropicThinkingModel(model2) ? ANTHROPIC_CAPABILITY : UNSUPPORTED;
+    case "openai":
+      return isOpenAIReasoningModel(model2) ? OPENAI_CAPABILITY : UNSUPPORTED;
+    case "kimi":
+      return isKimiThinkingModel(model2) ? KIMI_CAPABILITY : UNSUPPORTED;
+    case "gemini":
+    case "vertex":
+      if (isGeminiLevelThinkingModel(model2)) return GEMINI_LEVEL_CAPABILITY;
+      return isGeminiThinkingModel(model2) ? GEMINI_CAPABILITY : UNSUPPORTED;
+    case "copilot":
+    case "groq":
+    case "openrouter":
+    case "mistral":
+    case "deepseek":
+    case "together":
+    case "huggingface":
+    case "qwen":
+    case "lmstudio":
+    case "ollama":
+    case "codex":
+      return UNSUPPORTED;
+    default:
+      return UNSUPPORTED;
+  }
+}
+function mapToAnthropic(mode, model2) {
   if (!mode || mode === "off") return void 0;
-  if (!isAnthropicThinkingModel(model)) return void 0;
+  if (!isAnthropicThinkingModel(model2)) return void 0;
+  if (isAnthropicAdaptiveThinkingModel(model2)) {
+    return { type: "adaptive" };
+  }
   const cap = ANTHROPIC_CAPABILITY;
   const { min, max } = cap.budgetRange;
   if (typeof mode === "object") {
@@ -13669,9 +14567,20 @@ function mapToAnthropic(mode, model) {
   if (budget === void 0) return void 0;
   return { type: "enabled", budget_tokens: budget };
 }
-function mapToOpenAIEffort(mode, model) {
+function mapToAnthropicEffort(mode, model2) {
+  if (!mode || mode === "off" || mode === "auto") return void 0;
+  if (!isAnthropicAdaptiveThinkingModel(model2)) return void 0;
+  if (typeof mode === "object") {
+    if (mode.budget <= 2048) return "low";
+    if (mode.budget <= 8e3) return "medium";
+    return "high";
+  }
+  if (mode === "low" || mode === "medium" || mode === "high") return mode;
+  return void 0;
+}
+function mapToOpenAIEffort(mode, model2) {
   if (!mode || mode === "off") return void 0;
-  if (!isOpenAIReasoningModel(model)) return void 0;
+  if (!isOpenAIReasoningModel(model2)) return void 0;
   if (typeof mode === "object") {
     const { budget } = mode;
     if (budget <= 2048) return "low";
@@ -13682,8 +14591,9 @@ function mapToOpenAIEffort(mode, model) {
   if (mode === "low" || mode === "medium" || mode === "high") return mode;
   return void 0;
 }
-function mapToGeminiBudget(mode, model) {
-  if (!isGeminiThinkingModel(model)) return void 0;
+function mapToGeminiBudget(mode, model2) {
+  if (isGeminiLevelThinkingModel(model2)) return void 0;
+  if (!isGeminiThinkingModel(model2)) return void 0;
   if (!mode) return void 0;
   if (mode === "off") return 0;
   if (mode === "auto") return -1;
@@ -13698,15 +14608,33 @@ function mapToGeminiBudget(mode, model) {
   };
   return budgetMap[mode];
 }
-function mapToKimiExtraBody(mode, model) {
-  if (!isKimiThinkingModel(model)) return void 0;
+function mapToGeminiThinkingConfig(mode, model2) {
+  if (isGeminiLevelThinkingModel(model2)) {
+    if (!mode || mode === "auto") return void 0;
+    if (mode === "off") return { thinkingLevel: "low" };
+    if (mode === "low" || mode === "medium" || mode === "high") {
+      return { thinkingLevel: mode };
+    }
+    if (typeof mode === "object") {
+      if (mode.budget <= 2048) return { thinkingLevel: "low" };
+      if (mode.budget <= 8e3) return { thinkingLevel: "medium" };
+      return { thinkingLevel: "high" };
+    }
+    return void 0;
+  }
+  const thinkingBudget = mapToGeminiBudget(mode, model2);
+  return thinkingBudget !== void 0 ? { thinkingBudget } : void 0;
+}
+function mapToKimiExtraBody(mode, model2) {
+  if (!isKimiThinkingModel(model2)) return void 0;
   const effectiveMode = mode ?? "off";
   const enabled = effectiveMode !== "off";
   return { thinking: { type: enabled ? "enabled" : "disabled" } };
 }
 
 // src/providers/anthropic.ts
-var DEFAULT_MODEL = "claude-opus-4-6";
+init_catalog();
+var DEFAULT_MODEL = getCatalogDefaultModel("anthropic");
 var CONTEXT_WINDOWS = {
   // Kimi Code model (Anthropic-compatible endpoint)
   "kimi-for-coding": 131072,
@@ -13732,6 +14660,20 @@ var CONTEXT_WINDOWS = {
   "claude-3-sonnet-20240229": 2e5,
   "claude-3-haiku-20240307": 2e5
 };
+function getAnthropicMaxTokens(baseMaxTokens, thinkingParam) {
+  if (thinkingParam?.type === "enabled") {
+    return Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024);
+  }
+  return baseMaxTokens;
+}
+function getAnthropicTemperature(thinkingParam, configuredTemperature) {
+  if (thinkingParam?.type === "enabled") return 1;
+  return configuredTemperature;
+}
+function getAnthropicOutputConfig(mode, model2) {
+  const effort = mapToAnthropicEffort(mode, model2);
+  return effort ? { effort } : void 0;
+}
 var AnthropicProvider = class {
   id;
   name;
@@ -13766,19 +14708,22 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-        const thinkingParam = mapToAnthropic(options?.thinking, model);
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+        const thinkingParam = mapToAnthropic(options?.thinking, model2);
+        const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
         const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
         const response = await this.client.messages.create({
-          model,
-          // Anthropic requires max_tokens > budget_tokens
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          // Anthropic requires temperature=1 when thinking is enabled
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
           stop_sequences: options?.stopSequences,
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         });
         return {
           id: response.id,
@@ -13802,18 +14747,23 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-        const thinkingParam = mapToAnthropic(options?.thinking, model);
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+        const thinkingParam = mapToAnthropic(options?.thinking, model2);
+        const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
         const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
         const response = await this.client.messages.create({
-          model,
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
           tools: this.convertTools(options.tools),
           tool_choice: options.toolChoice ? this.convertToolChoice(options.toolChoice) : void 0,
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         });
         const toolCalls = this.extractToolCalls(response.content);
         return {
@@ -13839,17 +14789,22 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-      const thinkingParam = mapToAnthropic(options?.thinking, model);
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+      const thinkingParam = mapToAnthropic(options?.thinking, model2);
+      const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
       const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
       const stream = await this.client.messages.stream(
         {
-          model,
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         },
         { signal: options?.signal }
       );
@@ -13905,19 +14860,24 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-      const thinkingParam = mapToAnthropic(options?.thinking, model);
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+      const thinkingParam = mapToAnthropic(options?.thinking, model2);
+      const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
       const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
       const stream = await this.client.messages.stream(
         {
-          model,
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
           tools: this.convertTools(options.tools),
           tool_choice: options.toolChoice ? this.convertToolChoice(options.toolChoice) : void 0,
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         },
         { signal: options?.signal }
       );
@@ -14042,33 +15002,38 @@ var AnthropicProvider = class {
    *
    * This heuristic analyzes the text to provide a better estimate.
    */
-  countTokens(text) {
-    if (!text) return 0;
+  countTokens(text2) {
+    if (!text2) return 0;
     const codePatterns = /[{}[\]();=<>!&|+\-*/]/g;
     const whitespacePattern = /\s/g;
     const wordPattern = /\b\w+\b/g;
-    const codeChars = (text.match(codePatterns) || []).length;
-    const whitespace = (text.match(whitespacePattern) || []).length;
-    const words = (text.match(wordPattern) || []).length;
-    const isCodeLike = codeChars > text.length * 0.05;
+    const codeChars = (text2.match(codePatterns) || []).length;
+    const whitespace = (text2.match(whitespacePattern) || []).length;
+    const words = (text2.match(wordPattern) || []).length;
+    const isCodeLike = codeChars > text2.length * 0.05;
     let charsPerToken;
     if (isCodeLike) {
       charsPerToken = 3.5;
-    } else if (whitespace > text.length * 0.3) {
+    } else if (whitespace > text2.length * 0.3) {
       charsPerToken = 5;
     } else {
       charsPerToken = 4.5;
     }
     const wordBasedEstimate = words * 1.3;
-    const charBasedEstimate = text.length / charsPerToken;
+    const charBasedEstimate = text2.length / charsPerToken;
     return Math.ceil((wordBasedEstimate + charBasedEstimate) / 2);
   }
   /**
    * Get context window size
    */
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL;
-    return CONTEXT_WINDOWS[model] ?? 2e5;
+    const model2 = this.config.model ?? DEFAULT_MODEL;
+    const provider = this.id === "kimi-code" ? "kimi-code" : "anthropic";
+    const catalogWindow = getCatalogContextWindow(provider, model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS[model2] ?? 2e5;
   }
   /**
    * Check if provider is available
@@ -14109,8 +15074,8 @@ var AnthropicProvider = class {
     const systemMsg = messages.find((m) => m.role === "system");
     if (!systemMsg) return void 0;
     if (typeof systemMsg.content === "string") return systemMsg.content;
-    const text = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    return text || void 0;
+    const text2 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    return text2 || void 0;
   }
   /**
    * Convert messages to Anthropic format
@@ -14318,15 +15283,15 @@ var ChatToolCallAssembler = class {
     if (delta.function?.name) {
       builder.name = delta.function.name;
     }
-    const text = delta.function?.arguments ?? "";
-    if (!text) return { started };
-    builder.arguments += text;
+    const text2 = delta.function?.arguments ?? "";
+    if (!text2) return { started };
+    builder.arguments += text2;
     return {
       started,
       argumentDelta: {
         id: builder.id,
         name: builder.name,
-        text
+        text: text2
       }
     };
   }
@@ -14503,45 +15468,46 @@ var EVAL_TIERS = [
   { prefix: "raptor", tier: "mini" },
   { prefix: "goldeneye", tier: "standard" }
 ];
-function matchTier(model, table) {
-  const lower = model.toLowerCase();
+function matchTier(model2, table) {
+  const lower = model2.toLowerCase();
   const sorted = [...table].sort((a, b) => b.prefix.length - a.prefix.length);
   for (const { prefix, tier } of sorted) {
     if (lower.startsWith(prefix.toLowerCase())) return tier;
   }
   return null;
 }
-function getModelTier(provider, model) {
-  if (!model) return "standard";
+function getModelTier(provider, model2) {
+  if (!model2) return "standard";
   const p5 = provider.toLowerCase();
   if (p5 === "anthropic") {
-    return matchTier(model, ANTHROPIC_TIERS) ?? "standard";
+    return matchTier(model2, ANTHROPIC_TIERS) ?? "standard";
   }
   if (p5 === "kimi-code") {
-    return matchTier(model, KIMI_TIERS) ?? matchTier(model, ANTHROPIC_TIERS) ?? "standard";
+    return matchTier(model2, KIMI_TIERS) ?? matchTier(model2, ANTHROPIC_TIERS) ?? "standard";
   }
   if (p5 === "openai" || p5 === "copilot" || p5 === "codex") {
-    if (model.startsWith("claude-")) {
-      return matchTier(model, ANTHROPIC_TIERS) ?? "standard";
+    if (model2.startsWith("claude-")) {
+      return matchTier(model2, ANTHROPIC_TIERS) ?? "standard";
     }
-    const evalMatch = matchTier(model, EVAL_TIERS);
+    const evalMatch = matchTier(model2, EVAL_TIERS);
     if (evalMatch) return evalMatch;
-    return matchTier(model, OPENAI_TIERS) ?? "standard";
+    return matchTier(model2, OPENAI_TIERS) ?? "standard";
   }
   if (p5 === "gemini" || p5 === "vertex") {
-    return matchTier(model, GEMINI_TIERS) ?? "standard";
+    return matchTier(model2, GEMINI_TIERS) ?? "standard";
   }
   if (p5 === "kimi" || p5 === "moonshot") {
-    return matchTier(model, KIMI_TIERS) ?? "standard";
+    return matchTier(model2, KIMI_TIERS) ?? "standard";
   }
   return "standard";
 }
-function getTierConfig(provider, model) {
-  return TIER_CONFIGS[getModelTier(provider, model)];
+function getTierConfig(provider, model2) {
+  return TIER_CONFIGS[getModelTier(provider, model2)];
 }
 
 // src/providers/openai.ts
-var DEFAULT_MODEL2 = "gpt-5.3-codex";
+init_catalog();
+var DEFAULT_MODEL2 = getCatalogDefaultModel("openai");
 var CONTEXT_WINDOWS2 = {
   // OpenAI models
   "gpt-4o": 128e3,
@@ -14652,14 +15618,14 @@ var LOCAL_MODEL_PATTERNS = [
   "starcoder"
 ];
 var MODELS_WITH_THINKING_MODE = ["kimi-k2.5", "kimi-k2-0324", "kimi-latest"];
-function needsResponsesApi(model) {
-  return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model === "o3";
+function needsResponsesApi(model2) {
+  return model2.includes("codex") || model2.startsWith("gpt-5") || model2.startsWith("o4-") || model2 === "o3";
 }
-function needsMaxCompletionTokens(model) {
-  return model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4") || model.startsWith("gpt-4o") || model.startsWith("gpt-4.1") || model.startsWith("gpt-5") || model.startsWith("chatgpt-4o");
+function needsMaxCompletionTokens(model2) {
+  return model2.startsWith("o1") || model2.startsWith("o3") || model2.startsWith("o4") || model2.startsWith("gpt-4o") || model2.startsWith("gpt-4.1") || model2.startsWith("gpt-5") || model2.startsWith("chatgpt-4o");
 }
-function buildMaxTokensParam(model, maxTokens) {
-  if (needsMaxCompletionTokens(model)) {
+function buildMaxTokensParam(model2, maxTokens) {
+  if (needsMaxCompletionTokens(model2)) {
     return { max_completion_tokens: maxTokens };
   }
   return { max_tokens: maxTokens };
@@ -14701,26 +15667,45 @@ var OpenAIProvider = class {
   /**
    * Check if a model supports temperature parameter
    */
-  supportsTemperature(model) {
-    return !MODELS_WITHOUT_TEMPERATURE.some((m) => model.toLowerCase().includes(m.toLowerCase()));
+  supportsTemperature(model2) {
+    return !MODELS_WITHOUT_TEMPERATURE.some((m) => model2.toLowerCase().includes(m.toLowerCase()));
   }
   /**
    * Whether this provider instance supports the Responses API for the given model.
    * Subclasses (e.g. CopilotProvider) can override to force Chat Completions
    * when their endpoint does not expose /v1/responses.
    */
-  modelNeedsResponsesApi(model) {
-    return needsResponsesApi(model);
+  modelNeedsResponsesApi(model2) {
+    return this.id === "openai" && needsResponsesApi(model2);
+  }
+  /**
+   * Map thinking mode to Chat Completions reasoning_effort.
+   * Subclasses can override when an OpenAI-compatible endpoint exposes GPT-5
+   * models but cannot safely combine reasoning_effort with tool calls.
+   */
+  getChatCompletionsReasoningEffort(model2, thinking, _hasTools) {
+    const capability = getThinkingCapability(this.id, model2);
+    if (!capability.supported || !capability.kinds.includes("effort")) {
+      return void 0;
+    }
+    return mapToOpenAIEffort(thinking, model2);
+  }
+  getResponsesReasoningEffort(model2, thinking) {
+    const capability = getThinkingCapability(this.id, model2);
+    if (!capability.supported || !capability.kinds.includes("effort")) {
+      return void 0;
+    }
+    return mapToOpenAIEffort(thinking, model2);
   }
   /**
    * Get extra body parameters for API calls.
    * Honors the user's ThinkingMode for Kimi models; defaults to disabled
    * (preserving existing behavior) when no mode is specified.
    */
-  getExtraBody(model, thinking) {
-    const kimiBody = mapToKimiExtraBody(thinking, model);
+  getExtraBody(model2, thinking) {
+    const kimiBody = mapToKimiExtraBody(thinking, model2);
     if (kimiBody) return kimiBody;
-    if (MODELS_WITH_THINKING_MODE.some((m) => model.toLowerCase().includes(m.toLowerCase()))) {
+    if (MODELS_WITH_THINKING_MODE.some((m) => model2.toLowerCase().includes(m.toLowerCase()))) {
       return { thinking: { type: "disabled" } };
     }
     return void 0;
@@ -14730,18 +15715,22 @@ var OpenAIProvider = class {
    */
   async chat(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       return this.chatViaResponses(messages, options);
     }
     return withRetry(async () => {
       try {
-        const supportsTemp = this.supportsTemperature(model);
+        const supportsTemp = this.supportsTemperature(model2);
         const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const reasoningEffort = this.getChatCompletionsReasoningEffort(
+          model2,
+          options?.thinking,
+          false
+        );
         const response = await this.client.chat.completions.create({
-          model,
-          ...buildMaxTokensParam(model, maxTokens),
+          model: model2,
+          ...buildMaxTokensParam(model2, maxTokens),
           messages: this.convertMessages(messages, options?.system),
           stop: options?.stopSequences,
           ...supportsTemp && {
@@ -14770,21 +15759,25 @@ var OpenAIProvider = class {
    */
   async chatWithTools(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       return this.chatWithToolsViaResponses(messages, options);
     }
-    const tierCfg = getTierConfig(this.id, model);
+    const tierCfg = getTierConfig(this.id, model2);
     return withRetry(async () => {
       try {
-        const supportsTemp = this.supportsTemperature(model);
-        const extraBody = this.getExtraBody(model, options?.thinking);
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const supportsTemp = this.supportsTemperature(model2);
+        const extraBody = this.getExtraBody(model2, options?.thinking);
+        const reasoningEffort = this.getChatCompletionsReasoningEffort(
+          model2,
+          options?.thinking,
+          true
+        );
         const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
         const tools = this.limitTools(options.tools, tierCfg.maxTools);
         const requestParams = {
-          model,
-          ...buildMaxTokensParam(model, maxTokens),
+          model: model2,
+          ...buildMaxTokensParam(model2, maxTokens),
           messages: this.convertMessages(messages, options?.system),
           tools: this.convertTools(tools),
           tool_choice: this.convertToolChoice(options.toolChoice),
@@ -14825,18 +15818,22 @@ var OpenAIProvider = class {
    */
   async *stream(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       yield* this.streamViaResponses(messages, options);
       return;
     }
     try {
-      const supportsTemp = this.supportsTemperature(model);
+      const supportsTemp = this.supportsTemperature(model2);
       const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const reasoningEffort = this.getChatCompletionsReasoningEffort(
+        model2,
+        options?.thinking,
+        false
+      );
       const stream = await this.client.chat.completions.create({
-        model,
-        ...buildMaxTokensParam(model, maxTokens),
+        model: model2,
+        ...buildMaxTokensParam(model2, maxTokens),
         messages: this.convertMessages(messages, options?.system),
         stream: true,
         ...supportsTemp && { temperature: options?.temperature ?? this.config.temperature ?? 0 },
@@ -14863,22 +15860,26 @@ var OpenAIProvider = class {
    */
   async *streamWithTools(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       yield* this.streamWithToolsViaResponses(messages, options);
       return;
     }
-    const tierCfg = getTierConfig(this.id, model);
+    const tierCfg = getTierConfig(this.id, model2);
     let timeoutTriggered = false;
     try {
-      const supportsTemp = this.supportsTemperature(model);
-      const extraBody = this.getExtraBody(model, options?.thinking);
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const supportsTemp = this.supportsTemperature(model2);
+      const extraBody = this.getExtraBody(model2, options?.thinking);
+      const reasoningEffort = this.getChatCompletionsReasoningEffort(
+        model2,
+        options?.thinking,
+        true
+      );
       const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
       const tools = this.limitTools(options.tools, tierCfg.maxTools);
       const requestParams = {
-        model,
-        ...buildMaxTokensParam(model, maxTokens),
+        model: model2,
+        ...buildMaxTokensParam(model2, maxTokens),
         messages: this.convertMessages(messages, options?.system),
         tools: this.convertTools(tools),
         tool_choice: this.convertToolChoice(options.toolChoice),
@@ -14999,13 +16000,13 @@ var OpenAIProvider = class {
    * Check if current model is a local model (LM Studio, Ollama, etc.)
    */
   isLocalModel() {
-    const model = (this.config.model ?? "").toLowerCase();
+    const model2 = (this.config.model ?? "").toLowerCase();
     const baseUrl = (this.config.baseUrl ?? "").toLowerCase();
     if (baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1") || baseUrl.includes(":1234") || // LM Studio default
     baseUrl.includes(":11434")) {
       return true;
     }
-    return LOCAL_MODEL_PATTERNS.some((pattern) => model.includes(pattern));
+    return LOCAL_MODEL_PATTERNS.some((pattern) => model2.includes(pattern));
   }
   /**
    * Count tokens (improved heuristic for OpenAI and local models)
@@ -15025,23 +16026,23 @@ var OpenAIProvider = class {
    * For accurate counting, use the model's native tokenizer.
    * This heuristic provides a reasonable estimate without dependencies.
    */
-  countTokens(text) {
-    if (!text) return 0;
+  countTokens(text2) {
+    if (!text2) return 0;
     const codePatterns = /[{}[\]();=<>!&|+\-*/]/g;
     const whitespacePattern = /\s/g;
     const wordPattern = /\b\w+\b/g;
     const nonAsciiPattern = /[^\x00-\x7F]/g;
-    const codeChars = (text.match(codePatterns) || []).length;
-    const whitespace = (text.match(whitespacePattern) || []).length;
-    const words = (text.match(wordPattern) || []).length;
-    const nonAscii = (text.match(nonAsciiPattern) || []).length;
-    const isCodeLike = codeChars > text.length * 0.05;
+    const codeChars = (text2.match(codePatterns) || []).length;
+    const whitespace = (text2.match(whitespacePattern) || []).length;
+    const words = (text2.match(wordPattern) || []).length;
+    const nonAscii = (text2.match(nonAsciiPattern) || []).length;
+    const isCodeLike = codeChars > text2.length * 0.05;
     const isLocal = this.isLocalModel();
     let charsPerToken;
     if (isLocal) {
       if (isCodeLike) {
         charsPerToken = 3.2;
-      } else if (nonAscii > text.length * 0.1) {
+      } else if (nonAscii > text2.length * 0.1) {
         charsPerToken = 2;
       } else {
         charsPerToken = 3.5;
@@ -15049,7 +16050,7 @@ var OpenAIProvider = class {
     } else {
       if (isCodeLike) {
         charsPerToken = 3.3;
-      } else if (whitespace > text.length * 0.3) {
+      } else if (whitespace > text2.length * 0.3) {
         charsPerToken = 4.5;
       } else {
         charsPerToken = 4;
@@ -15057,7 +16058,7 @@ var OpenAIProvider = class {
     }
     const tokensPerWord = isLocal ? 1.4 : 1.3;
     const wordBasedEstimate = words * tokensPerWord;
-    const charBasedEstimate = text.length / charsPerToken;
+    const charBasedEstimate = text2.length / charsPerToken;
     const weight = isCodeLike ? 0.7 : 0.5;
     return Math.ceil(charBasedEstimate * weight + wordBasedEstimate * (1 - weight));
   }
@@ -15069,11 +16070,15 @@ var OpenAIProvider = class {
    * conventions (e.g., "qwen3-coder-8b" vs "qwen3-coder-8b-instruct").
    */
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL2;
-    if (CONTEXT_WINDOWS2[model]) {
-      return CONTEXT_WINDOWS2[model];
+    const model2 = this.config.model ?? DEFAULT_MODEL2;
+    if (CONTEXT_WINDOWS2[model2]) {
+      return CONTEXT_WINDOWS2[model2];
+    }
+    const catalogWindow = getCatalogContextWindow(this.id, model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
     }
-    const modelLower = model.toLowerCase();
+    const modelLower = model2.toLowerCase();
     for (const [key, value] of Object.entries(CONTEXT_WINDOWS2)) {
       if (modelLower.includes(key.toLowerCase()) || key.toLowerCase().includes(modelLower)) {
         return value;
@@ -15118,19 +16123,19 @@ var OpenAIProvider = class {
       return true;
     } catch {
       try {
-        const model = this.config.model || DEFAULT_MODEL2;
-        if (this.modelNeedsResponsesApi(model)) {
+        const model2 = this.config.model || DEFAULT_MODEL2;
+        if (this.modelNeedsResponsesApi(model2)) {
           await this.client.responses.create({
-            model,
+            model: model2,
             input: [{ role: "user", content: [{ type: "input_text", text: "Hi" }] }],
             max_output_tokens: 1,
             store: false
           });
         } else {
           await this.client.chat.completions.create({
-            model,
+            model: model2,
             messages: [{ role: "user", content: "Hi" }],
-            ...buildMaxTokensParam(model, 1)
+            ...buildMaxTokensParam(model2, 1)
           });
         }
         return true;
@@ -15367,12 +16372,12 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
         const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-        const supportsTemp = this.supportsTemperature(model);
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const supportsTemp = this.supportsTemperature(model2);
+        const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
         const response = await this.client.responses.create({
-          model,
+          model: model2,
           input,
           instructions: instructions ?? void 0,
           max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
@@ -15405,16 +16410,16 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-        const tierCfg = getTierConfig(this.id, model);
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+        const tierCfg = getTierConfig(this.id, model2);
         const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
         const tools = this.convertToolsForResponses(
           this.limitTools(options.tools, tierCfg.maxTools)
         );
-        const supportsTemp = this.supportsTemperature(model);
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const supportsTemp = this.supportsTemperature(model2);
+        const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
         const response = await this.client.responses.create({
-          model,
+          model: model2,
           input,
           instructions: instructions ?? void 0,
           tools,
@@ -15465,12 +16470,12 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const supportsTemp = this.supportsTemperature(model);
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const supportsTemp = this.supportsTemperature(model2);
+      const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
       const stream = await this.client.responses.create({
-        model,
+        model: model2,
         input,
         instructions: instructions ?? void 0,
         max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
@@ -15529,15 +16534,15 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-      const tierCfg = getTierConfig(this.id, model);
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+      const tierCfg = getTierConfig(this.id, model2);
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
       const limitedTools = this.limitTools(options.tools, tierCfg.maxTools);
       const tools = limitedTools.length > 0 ? this.convertToolsForResponses(limitedTools) : void 0;
-      const supportsTemp = this.supportsTemperature(model);
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const supportsTemp = this.supportsTemperature(model2);
+      const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
       const requestParams = {
-        model,
+        model: model2,
         input,
         instructions: instructions ?? void 0,
         max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
@@ -15792,8 +16797,9 @@ function createKimiProvider(config) {
 // src/providers/codex.ts
 init_errors();
 init_auth();
+init_catalog();
 var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
-var DEFAULT_MODEL3 = "gpt-5.3-codex";
+var DEFAULT_MODEL3 = getCatalogDefaultModel("codex");
 var CONTEXT_WINDOWS3 = {
   "gpt-5.4-codex": 2e5,
   "gpt-5.3-codex": 2e5,
@@ -15860,16 +16866,23 @@ var CodexProvider = class {
   /**
    * Get context window size for a model
    */
-  getContextWindow(model) {
-    const m = model ?? this.config.model ?? DEFAULT_MODEL3;
-    return CONTEXT_WINDOWS3[m] ?? 128e3;
+  getContextWindow(model2) {
+    const m = model2 ?? this.config.model ?? DEFAULT_MODEL3;
+    if (CONTEXT_WINDOWS3[m]) {
+      return CONTEXT_WINDOWS3[m];
+    }
+    const catalogWindow = getCatalogContextWindow("codex", m, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return 128e3;
   }
   /**
    * Count tokens in text (approximate)
    * Uses GPT-4 approximation: ~4 chars per token
    */
-  countTokens(text) {
-    return Math.ceil(text.length / 4);
+  countTokens(text2) {
+    return Math.ceil(text2.length / 4);
   }
   /**
    * Check if provider is available (has valid OAuth tokens)
@@ -15997,9 +17010,9 @@ var CodexProvider = class {
   /**
    * Build the request body for the Codex Responses API
    */
-  buildRequestBody(model, input, instructions, options) {
+  buildRequestBody(model2, input, instructions, options) {
     const body = {
-      model,
+      model: model2,
       input,
       instructions: instructions ?? "You are a helpful coding assistant.",
       store: false,
@@ -16064,9 +17077,9 @@ var CodexProvider = class {
    */
   async chat(messages, options) {
     return withRetry(async () => {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const body = this.buildRequestBody(model, input, instructions, {
+      const body = this.buildRequestBody(model2, input, instructions, {
         maxTokens: options?.maxTokens,
         temperature: options?.temperature
       });
@@ -16097,7 +17110,7 @@ var CodexProvider = class {
         id: responseId,
         content,
         stopReason,
-        model,
+        model: model2,
         usage: { inputTokens, outputTokens }
       };
     }, this.retryConfig);
@@ -16107,9 +17120,9 @@ var CodexProvider = class {
    */
   async chatWithTools(messages, options) {
     return withRetry(async () => {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const body = this.buildRequestBody(model, input, instructions, {
+      const body = this.buildRequestBody(model2, input, instructions, {
         tools: options.tools,
         maxTokens: options?.maxTokens
       });
@@ -16184,7 +17197,7 @@ var CodexProvider = class {
         id: responseId,
         content,
         stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn",
-        model,
+        model: model2,
         usage: { inputTokens, outputTokens },
         toolCalls
       };
@@ -16194,9 +17207,9 @@ var CodexProvider = class {
    * Stream a chat response (no tools)
    */
   async *stream(messages, options) {
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
     const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-    const body = this.buildRequestBody(model, input, instructions, {
+    const body = this.buildRequestBody(model2, input, instructions, {
       maxTokens: options?.maxTokens
     });
     const response = await this.makeRequest(body);
@@ -16256,9 +17269,9 @@ var CodexProvider = class {
    * item_id which references the output item's id field, not call_id.
    */
   async *streamWithTools(messages, options) {
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
     const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-    const body = this.buildRequestBody(model, input, instructions, {
+    const body = this.buildRequestBody(model2, input, instructions, {
       tools: options.tools,
       maxTokens: options?.maxTokens
     });
@@ -16407,6 +17420,7 @@ var CodexProvider = class {
 // src/providers/copilot.ts
 init_errors();
 init_copilot();
+init_catalog();
 var CONTEXT_WINDOWS4 = {
   // Claude models — Copilot API caps these at 168 000 (not 200 000 like Anthropic direct)
   "claude-sonnet-4.6": 168e3,
@@ -16440,10 +17454,10 @@ var CONTEXT_WINDOWS4 = {
   "raptor-mini": 4e5,
   goldeneye: 4e5
 };
-var DEFAULT_MODEL4 = "claude-sonnet-4.6";
-function normalizeModel(model) {
-  if (typeof model !== "string") return void 0;
-  const trimmed = model.trim();
+var DEFAULT_MODEL4 = getCatalogDefaultModel("copilot");
+function normalizeModel(model2) {
+  if (typeof model2 !== "string") return void 0;
+  const trimmed = model2.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
 var COPILOT_HEADERS = {
@@ -16550,16 +17564,31 @@ var CopilotProvider = class extends OpenAIProvider {
   modelNeedsResponsesApi(_model) {
     return false;
   }
-  countTokens(text) {
-    if (!text) return 0;
-    return Math.ceil(text.length / 3.5);
+  /**
+   * Copilot's OpenAI-compatible endpoint currently routes through
+   * Chat Completions. For GPT-5.x models, combining function tools with
+   * reasoning_effort is rejected by the upstream API. Keep tools working by
+   * omitting reasoning_effort on tool calls instead of advertising a broken
+   * combination.
+   */
+  getChatCompletionsReasoningEffort(_model, _thinking, hasTools) {
+    if (hasTools) return void 0;
+    return void 0;
+  }
+  countTokens(text2) {
+    if (!text2) return 0;
+    return Math.ceil(text2.length / 3.5);
   }
   /**
    * Get context window for the current model
    */
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL4;
-    return CONTEXT_WINDOWS4[model] ?? 128e3;
+    const model2 = this.config.model ?? DEFAULT_MODEL4;
+    const catalogWindow = getCatalogContextWindow("copilot", model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS4[model2] ?? 128e3;
   }
   /**
    * Check if Copilot credentials are available
@@ -16576,7 +17605,8 @@ var CopilotProvider = class extends OpenAIProvider {
 
 // src/providers/gemini.ts
 init_errors();
-var DEFAULT_MODEL5 = "gemini-3.1-pro-preview";
+init_catalog();
+var DEFAULT_MODEL5 = getCatalogDefaultModel("gemini");
 var SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
 var CONTEXT_WINDOWS5 = {
   "gemini-3.1-pro-preview": 1e6,
@@ -16640,9 +17670,9 @@ var GeminiProvider = class {
       });
       let streamStopReason = "end_turn";
       for await (const chunk of stream) {
-        const text = chunk.text;
-        if (text) {
-          yield { type: "text", text };
+        const text2 = chunk.text;
+        if (text2) {
+          yield { type: "text", text: text2 };
         }
         const finishReason = chunk.candidates?.[0]?.finishReason;
         if (finishReason) {
@@ -16666,9 +17696,9 @@ var GeminiProvider = class {
       let fallbackToolCounter = 0;
       const emittedToolIds = /* @__PURE__ */ new Set();
       for await (const chunk of stream) {
-        const text = chunk.text;
-        if (text) {
-          yield { type: "text", text };
+        const text2 = chunk.text;
+        if (text2) {
+          yield { type: "text", text: text2 };
         }
         const toolCalls = this.extractToolCalls(chunk, { includeLegacyFunctionCalls: true });
         for (const toolCall of toolCalls) {
@@ -16703,13 +17733,17 @@ var GeminiProvider = class {
       throw this.handleError(error);
     }
   }
-  countTokens(text) {
-    if (!text) return 0;
-    return Math.ceil(text.length / 3.5);
+  countTokens(text2) {
+    if (!text2) return 0;
+    return Math.ceil(text2.length / 3.5);
   }
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL5;
-    return CONTEXT_WINDOWS5[model] ?? 1e6;
+    const model2 = this.config.model ?? DEFAULT_MODEL5;
+    const catalogWindow = getCatalogContextWindow("gemini", model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS5[model2] ?? 1e6;
   }
   async isAvailable() {
     if (!this.client) return false;
@@ -16730,20 +17764,20 @@ var GeminiProvider = class {
       });
     }
   }
-  getModel(model) {
-    return model ?? this.config.model ?? DEFAULT_MODEL5;
+  getModel(model2) {
+    return model2 ?? this.config.model ?? DEFAULT_MODEL5;
   }
   buildConfig(messages, options, tools, toolChoice) {
-    const model = this.getModel(options?.model);
-    const thinkingBudget = mapToGeminiBudget(options?.thinking, model);
+    const model2 = this.getModel(options?.model);
+    const thinkingConfig = mapToGeminiThinkingConfig(options?.thinking, model2);
     const config = {
       maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
       temperature: options?.temperature ?? this.config.temperature ?? 0,
       stopSequences: options?.stopSequences,
       systemInstruction: this.extractSystem(messages, options?.system)
     };
-    if (thinkingBudget !== void 0) {
-      config.thinkingConfig = { thinkingBudget };
+    if (thinkingConfig !== void 0) {
+      config.thinkingConfig = thinkingConfig;
     }
     if (tools && tools.length > 0) {
       config.tools = [{ functionDeclarations: this.convertTools(tools) }];
@@ -16758,8 +17792,8 @@ var GeminiProvider = class {
     const systemMsg = messages.find((m) => m.role === "system");
     if (!systemMsg) return void 0;
     if (typeof systemMsg.content === "string") return systemMsg.content;
-    const text = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    return text || void 0;
+    const text2 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    return text2 || void 0;
   }
   convertContents(messages) {
     const toolNameByUseId = this.buildToolUseNameMap(messages);
@@ -16882,7 +17916,7 @@ var GeminiProvider = class {
       })
     }));
   }
-  parseResponse(response, model) {
+  parseResponse(response, model2) {
     const usage = response.usageMetadata;
     return {
       id: `gemini-${Date.now()}`,
@@ -16892,10 +17926,10 @@ var GeminiProvider = class {
         inputTokens: usage?.promptTokenCount ?? 0,
         outputTokens: usage?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model)
+      model: this.getModel(model2)
     };
   }
-  parseResponseWithTools(response, model) {
+  parseResponseWithTools(response, model2) {
     const usage = response.usageMetadata;
     const toolCalls = this.extractToolCalls(response, { includeLegacyFunctionCalls: true });
     return {
@@ -16906,7 +17940,7 @@ var GeminiProvider = class {
         inputTokens: usage?.promptTokenCount ?? 0,
         outputTokens: usage?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model),
+      model: this.getModel(model2),
       toolCalls
     };
   }
@@ -16945,7 +17979,8 @@ var GeminiProvider = class {
 // src/providers/vertex.ts
 init_errors();
 init_gcloud();
-var DEFAULT_MODEL6 = "gemini-2.5-pro";
+init_catalog();
+var DEFAULT_MODEL6 = getCatalogDefaultModel("vertex");
 var DEFAULT_BASE_URL = "https://aiplatform.googleapis.com/v1";
 var DEFAULT_LOCATION = "global";
 var CONTEXT_WINDOWS6 = {
@@ -17091,11 +18126,16 @@ var VertexProvider = class {
     }
     yield { type: "done", stopReason };
   }
-  countTokens(text) {
-    return Math.ceil(text.length / 4);
+  countTokens(text2) {
+    return Math.ceil(text2.length / 4);
   }
   getContextWindow() {
-    return CONTEXT_WINDOWS6[this.config.model ?? DEFAULT_MODEL6] ?? 1048576;
+    const model2 = this.config.model ?? DEFAULT_MODEL6;
+    const catalogWindow = getCatalogContextWindow("vertex", model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS6[model2] ?? 1048576;
   }
   async isAvailable() {
     try {
@@ -17112,8 +18152,8 @@ var VertexProvider = class {
       });
     }
   }
-  getModel(model) {
-    return model ?? this.config.model ?? DEFAULT_MODEL6;
+  getModel(model2) {
+    return model2 ?? this.config.model ?? DEFAULT_MODEL6;
   }
   getResolvedBaseUrl() {
     if (this.config.baseUrl && this.config.baseUrl.trim()) {
@@ -17124,9 +18164,9 @@ var VertexProvider = class {
     }
     return `https://${encodeURIComponent(this.location)}-aiplatform.googleapis.com/v1`;
   }
-  buildEndpoint(model, stream = false) {
+  buildEndpoint(model2, stream = false) {
     const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
-    return `${this.getResolvedBaseUrl()}/projects/${encodeURIComponent(this.project)}/locations/${encodeURIComponent(this.location)}/publishers/google/models/${encodeURIComponent(this.getModel(model))}:${action}`;
+    return `${this.getResolvedBaseUrl()}/projects/${encodeURIComponent(this.project)}/locations/${encodeURIComponent(this.location)}/publishers/google/models/${encodeURIComponent(this.getModel(model2))}:${action}`;
   }
   async getHeaders() {
     if (this.apiKey?.trim()) {
@@ -17154,8 +18194,8 @@ var VertexProvider = class {
     const systemMsg = messages.find((m) => m.role === "system");
     if (!systemMsg) return void 0;
     if (typeof systemMsg.content === "string") return systemMsg.content;
-    const text = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    return text || void 0;
+    const text2 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    return text2 || void 0;
   }
   buildToolUseNameMap(messages) {
     const map = /* @__PURE__ */ new Map();
@@ -17338,21 +18378,21 @@ var VertexProvider = class {
       }
     }
   }
-  parseResponse(response, model) {
+  parseResponse(response, model2) {
     const candidate = response.candidates?.[0];
-    const text = (candidate?.content?.parts ?? []).filter((part) => part.text).map((part) => part.text).join("");
+    const text2 = (candidate?.content?.parts ?? []).filter((part) => part.text).map((part) => part.text).join("");
     return {
       id: `vertex-${Date.now()}`,
-      content: text,
+      content: text2,
       stopReason: this.mapFinishReason(candidate?.finishReason),
       usage: {
         inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
         outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model)
+      model: this.getModel(model2)
     };
   }
-  parseResponseWithTools(response, model) {
+  parseResponseWithTools(response, model2) {
     const candidate = response.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
     const toolCalls = [];
@@ -17380,7 +18420,7 @@ var VertexProvider = class {
         inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
         outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model),
+      model: this.getModel(model2),
       toolCalls
     };
   }
@@ -17409,6 +18449,10 @@ var VertexProvider = class {
   }
 };
 
+// src/providers/pricing.ts
+init_catalog();
+getCatalogModelPricingMap();
+
 // src/providers/circuit-breaker.ts
 init_errors();
 var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
@@ -17614,8 +18658,8 @@ var ResilientProvider = class {
   async *streamWithTools(messages, options) {
     yield* this.streamWithPolicy(() => this.provider.streamWithTools(messages, options));
   }
-  countTokens(text) {
-    return this.provider.countTokens(text);
+  countTokens(text2) {
+    return this.provider.countTokens(text2);
   }
   getContextWindow() {
     return this.provider.getContextWindow();
@@ -17701,13 +18745,16 @@ function createResilientProvider(provider, config) {
   return new ResilientProvider(provider, getDefaultResilienceConfig(provider.id));
 }
 
+// src/providers/runtime-capabilities.ts
+init_catalog();
+
 // src/providers/index.ts
 init_copilot();
 init_errors();
 init_env();
-function normalizeProviderModel(model) {
-  if (typeof model !== "string") return void 0;
-  const trimmed = model.trim();
+function normalizeProviderModel(model2) {
+  if (typeof model2 !== "string") return void 0;
+  const trimmed = model2.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function normalizeOptional(value) {
@@ -17916,9 +18963,9 @@ function createInitialState(config) {
 }
 async function loadExistingState(projectPath) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const statePath = `${projectPath}/.coco/state/project.json`;
-    const content = await fs39.readFile(statePath, "utf-8");
+    const content = await fs41.readFile(statePath, "utf-8");
     const data = JSON.parse(content);
     data.createdAt = new Date(data.createdAt);
     data.updatedAt = new Date(data.updatedAt);
@@ -17928,13 +18975,13 @@ async function loadExistingState(projectPath) {
   }
 }
 async function saveState(state) {
-  const fs39 = await import('fs/promises');
+  const fs41 = await import('fs/promises');
   const statePath = `${state.path}/.coco/state`;
-  await fs39.mkdir(statePath, { recursive: true });
+  await fs41.mkdir(statePath, { recursive: true });
   const filePath = `${statePath}/project.json`;
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
-  await fs39.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-  await fs39.rename(tmpPath, filePath);
+  await fs41.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs41.rename(tmpPath, filePath);
 }
 function getPhaseExecutor(phase) {
   switch (phase) {
@@ -17993,35 +19040,35 @@ async function createPhaseContext(config, state) {
   };
   const tools = {
     file: {
-      async read(path42) {
-        const fs39 = await import('fs/promises');
-        return fs39.readFile(path42, "utf-8");
+      async read(path44) {
+        const fs41 = await import('fs/promises');
+        return fs41.readFile(path44, "utf-8");
       },
-      async write(path42, content) {
-        const fs39 = await import('fs/promises');
+      async write(path44, content) {
+        const fs41 = await import('fs/promises');
         const nodePath = await import('path');
-        await fs39.mkdir(nodePath.dirname(path42), { recursive: true });
-        await fs39.writeFile(path42, content, "utf-8");
+        await fs41.mkdir(nodePath.dirname(path44), { recursive: true });
+        await fs41.writeFile(path44, content, "utf-8");
       },
-      async exists(path42) {
-        const fs39 = await import('fs/promises');
+      async exists(path44) {
+        const fs41 = await import('fs/promises');
         try {
-          await fs39.access(path42);
+          await fs41.access(path44);
           return true;
         } catch {
           return false;
         }
       },
       async glob(pattern) {
-        const { glob: glob17 } = await import('glob');
-        return glob17(pattern, { cwd: state.path });
+        const { glob: glob18 } = await import('glob');
+        return glob18(pattern, { cwd: state.path });
       }
     },
     bash: {
       async exec(command, options = {}) {
-        const { execa: execa11 } = await import('execa');
+        const { execa: execa12 } = await import('execa');
         try {
-          const result = await execa11(command, {
+          const result = await execa12(command, {
             shell: true,
             cwd: options.cwd || state.path,
             timeout: options.timeout,
@@ -18044,8 +19091,8 @@ async function createPhaseContext(config, state) {
     },
     git: {
       async status() {
-        const { execa: execa11 } = await import('execa');
-        const result = await execa11("git", ["status", "--porcelain", "-b"], { cwd: state.path });
+        const { execa: execa12 } = await import('execa');
+        const result = await execa12("git", ["status", "--porcelain", "-b"], { cwd: state.path });
         const lines = result.stdout.split("\n");
         const branchLine = lines[0] || "";
         const branch = branchLine.replace("## ", "").split("...")[0] || "main";
@@ -18058,24 +19105,24 @@ async function createPhaseContext(config, state) {
         };
       },
       async commit(message, files) {
-        const { execa: execa11 } = await import('execa');
+        const { execa: execa12 } = await import('execa');
         if (files && files.length > 0) {
-          await execa11("git", ["add", ...files], { cwd: state.path });
+          await execa12("git", ["add", ...files], { cwd: state.path });
         }
-        await execa11("git", ["commit", "-m", message], { cwd: state.path });
+        await execa12("git", ["commit", "-m", message], { cwd: state.path });
       },
       async push() {
-        const { execa: execa11 } = await import('execa');
-        await execa11("git", ["push"], { cwd: state.path });
+        const { execa: execa12 } = await import('execa');
+        await execa12("git", ["push"], { cwd: state.path });
       }
     },
     test: {
       async run(pattern) {
-        const { execa: execa11 } = await import('execa');
+        const { execa: execa12 } = await import('execa');
         try {
           const args = ["test", "--reporter=json"];
           if (pattern) args.push(pattern);
-          await execa11("pnpm", args, { cwd: state.path });
+          await execa12("pnpm", args, { cwd: state.path });
           return {
             passed: 0,
             failed: 0,
@@ -18155,9 +19202,9 @@ async function createSnapshot(state) {
 var MAX_CHECKPOINT_VERSIONS = 5;
 async function getCheckpointFiles(state, phase) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const checkpointDir = `${state.path}/.coco/checkpoints`;
-    const files = await fs39.readdir(checkpointDir);
+    const files = await fs41.readdir(checkpointDir);
     const phaseFiles = files.filter((f) => f.startsWith(`snapshot-pre-${phase}-`) && f.endsWith(".json")).sort((a, b) => {
       const tsA = parseInt(a.split("-").pop()?.replace(".json", "") ?? "0", 10);
       const tsB = parseInt(b.split("-").pop()?.replace(".json", "") ?? "0", 10);
@@ -18170,11 +19217,11 @@ async function getCheckpointFiles(state, phase) {
 }
 async function cleanupOldCheckpoints(state, phase) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const files = await getCheckpointFiles(state, phase);
     if (files.length > MAX_CHECKPOINT_VERSIONS) {
       const filesToDelete = files.slice(MAX_CHECKPOINT_VERSIONS);
-      await Promise.all(filesToDelete.map((f) => fs39.unlink(f).catch(() => {
+      await Promise.all(filesToDelete.map((f) => fs41.unlink(f).catch(() => {
       })));
     }
   } catch {
@@ -18182,13 +19229,13 @@ async function cleanupOldCheckpoints(state, phase) {
 }
 async function saveSnapshot(state, snapshotId) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const snapshotPath = `${state.path}/.coco/checkpoints/snapshot-${snapshotId}.json`;
     const snapshotDir = `${state.path}/.coco/checkpoints`;
-    await fs39.mkdir(snapshotDir, { recursive: true });
+    await fs41.mkdir(snapshotDir, { recursive: true });
     const createdAt = state.createdAt instanceof Date ? state.createdAt.toISOString() : String(state.createdAt);
     const updatedAt = state.updatedAt instanceof Date ? state.updatedAt.toISOString() : String(state.updatedAt);
-    await fs39.writeFile(
+    await fs41.writeFile(
       snapshotPath,
       JSON.stringify(
         {
@@ -19395,15 +20442,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -20888,7 +21935,7 @@ Examples:
   }
 });
 async function findSourceFiles(cwd) {
-  const { glob: glob17 } = await import('glob');
+  const { glob: glob18 } = await import('glob');
   let isJava = false;
   try {
     await fs16__default.access(path17__default.join(cwd, "pom.xml"));
@@ -20906,12 +21953,12 @@ async function findSourceFiles(cwd) {
     }
   }
   if (isJava) {
-    return glob17("src/main/java/**/*.java", {
+    return glob18("src/main/java/**/*.java", {
       cwd,
       absolute: true
     });
   }
-  return glob17("src/**/*.{ts,js,tsx,jsx}", {
+  return glob18("src/**/*.{ts,js,tsx,jsx}", {
     cwd,
     absolute: true,
     ignore: ["**/*.test.*", "**/*.spec.*", "**/node_modules/**"]
@@ -21424,15 +22471,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21549,15 +22596,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21651,15 +22698,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21754,15 +22801,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21858,15 +22905,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21945,15 +22992,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -22012,6 +23059,12 @@ z.object({
   "allowed-tools": z.union([z.string(), z.array(z.string())]).optional(),
   "argument-hint": z.string().optional(),
   compatibility: z.string().max(500).optional(),
+  triggers: z.union([z.string(), z.array(z.string())]).optional(),
+  risk: z.enum(["read-only", "write", "network", "destructive", "secrets-sensitive"]).optional(),
+  "supported-agents": z.union([
+    z.enum(["coco", "claude", "codex", "gemini", "opencode"]),
+    z.array(z.enum(["coco", "claude", "codex", "gemini", "opencode"]))
+  ]).optional(),
   model: z.string().optional(),
   context: z.enum(["fork", "agent", "inline"]).optional(),
   // Top-level tags/author (skills.sh style) — also accepted inside metadata
@@ -22814,16 +23867,16 @@ function htmlToMarkdown(html) {
     const prefix = "#".repeat(i);
     const regex = new RegExp(`<h${i}[^>]*>([\\s\\S]*?)<\\/h${i}>`, "gi");
     md = md.replace(regex, (_, content) => {
-      const text = content.replace(/<[^>]*>/g, "").trim();
-      return text ? `
+      const text2 = content.replace(/<[^>]*>/g, "").trim();
+      return text2 ? `
 
-${prefix} ${text}
+${prefix} ${text2}
 
 ` : "";
     });
   }
-  md = md.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text) => {
-    const cleanText = text.replace(/<[^>]*>/g, "").trim();
+  md = md.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text2) => {
+    const cleanText = text2.replace(/<[^>]*>/g, "").trim();
     if (!cleanText) return "";
     if (href.startsWith("#") || href.startsWith("javascript:")) return cleanText;
     return `[${cleanText}](${href})`;
@@ -22850,8 +23903,8 @@ ${decoded.trim()}
   });
   md = md.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_, items) => {
     return "\n" + items.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_2, item) => {
-      const text = item.replace(/<[^>]*>/g, "").trim();
-      return text ? `- ${text}
+      const text2 = item.replace(/<[^>]*>/g, "").trim();
+      return text2 ? `- ${text2}
 ` : "";
     }) + "\n";
   });
@@ -22859,29 +23912,29 @@ ${decoded.trim()}
     let counter = 0;
     return "\n" + items.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_2, item) => {
       counter++;
-      const text = item.replace(/<[^>]*>/g, "").trim();
-      return text ? `${counter}. ${text}
+      const text2 = item.replace(/<[^>]*>/g, "").trim();
+      return text2 ? `${counter}. ${text2}
 ` : "";
     }) + "\n";
   });
   md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => {
-    const text = content.replace(/<[^>]*>/g, "").trim();
-    return text ? "\n" + text.split("\n").map((line) => `> ${line.trim()}`).join("\n") + "\n" : "";
+    const text2 = content.replace(/<[^>]*>/g, "").trim();
+    return text2 ? "\n" + text2.split("\n").map((line) => `> ${line.trim()}`).join("\n") + "\n" : "";
   });
   md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, content) => {
-    const text = content.replace(/<[^>]*>/g, "").trim();
-    return text ? `
+    const text2 = content.replace(/<[^>]*>/g, "").trim();
+    return text2 ? `
 
-${text}
+${text2}
 
 ` : "";
   });
   md = md.replace(/<br\s*\/?>/gi, "\n");
   md = md.replace(
     /<(?:strong|b)[^>]*>([\s\S]*?)<\/(?:strong|b)>/gi,
-    (_, text) => `**${text.trim()}**`
+    (_, text2) => `**${text2.trim()}**`
   );
-  md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, (_, text) => `*${text.trim()}*`);
+  md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, (_, text2) => `*${text2.trim()}*`);
   md = md.replace(/<hr\s*\/?>/gi, "\n---\n");
   md = md.replace(/<table[^>]*>([\s\S]*?)<\/table>/gi, (_, tableContent) => {
     const rows = [];
@@ -23563,9 +24616,9 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function fileExists2(path42) {
+async function fileExists2(path44) {
   try {
-    await access(path42);
+    await access(path44);
     return true;
   } catch {
     return false;
@@ -23655,7 +24708,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs39) => fs39.readFile(join(cwd, "package.json"), "utf-8")
+        (fs41) => fs41.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -24499,9 +25552,10 @@ Examples:
     exclude: z.array(z.string()).optional().describe("Additional patterns to exclude"),
     languages: z.array(z.enum(["typescript", "javascript", "python", "java", "go", "rust"])).optional().describe("Languages to parse (auto-detected if not specified)"),
     maxFiles: z.number().min(1).max(1e3).optional().default(DEFAULT_MAX_FILES).describe("Maximum files to process"),
-    depth: z.enum(["overview", "detailed"]).optional().default("overview").describe("Level of detail")
+    depth: z.enum(["overview", "detailed"]).optional().default("overview").describe("Level of detail"),
+    includeTests: z.boolean().optional().default(false).describe("Include test/spec files in the map")
   }),
-  async execute({ path: rootPath, include, exclude, languages, maxFiles, depth }) {
+  async execute({ path: rootPath, include, exclude, languages, maxFiles, depth, includeTests }) {
     const startTime = performance.now();
     const absPath = path27.resolve(rootPath);
     try {
@@ -24529,7 +25583,12 @@ Examples:
       const allExts = Object.values(LANGUAGE_EXTENSIONS).flat();
       pattern = `**/*{${allExts.join(",")}}`;
     }
-    const excludePatterns = [...DEFAULT_EXCLUDES, ...exclude ?? []];
+    const excludePatterns = [
+      ...DEFAULT_EXCLUDES.filter(
+        (pattern2) => includeTests ? !pattern2.includes("*.test.") && !pattern2.includes("*.spec.") : true
+      ),
+      ...exclude ?? []
+    ];
     const files = await glob14(pattern, {
       cwd: absPath,
       ignore: excludePatterns,
@@ -25027,10 +26086,10 @@ function chunkContent(content, chunkSize) {
   const chunks = [];
   for (let i = 0; i < lines.length; i += chunkSize) {
     const chunkLines = lines.slice(i, Math.min(i + chunkSize, lines.length));
-    const text = chunkLines.join("\n").trim();
-    if (text.length > 10) {
+    const text2 = chunkLines.join("\n").trim();
+    if (text2.length > 10) {
       chunks.push({
-        text,
+        text: text2,
         startLine: i + 1,
         endLine: Math.min(i + chunkSize, lines.length)
       });
@@ -25038,8 +26097,8 @@ function chunkContent(content, chunkSize) {
   }
   return chunks;
 }
-function simpleEmbedding(text) {
-  const words = text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1);
+function simpleEmbedding(text2) {
+  const words = text2.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1);
   const freq = /* @__PURE__ */ new Map();
   for (const word of words) {
     freq.set(word, (freq.get(word) ?? 0) + 1);
@@ -25065,7 +26124,7 @@ function simpleEmbedding(text) {
 }
 var embedFn = null;
 var usingFallbackEmbedding = false;
-async function getEmbedding(text) {
+async function getEmbedding(text2) {
   if (!embedFn) {
     try {
       const transformers = await import('@xenova/transformers');
@@ -25082,7 +26141,7 @@ async function getEmbedding(text) {
       usingFallbackEmbedding = true;
     }
   }
-  return embedFn(text);
+  return embedFn(text2);
 }
 async function loadIndex2(indexDir) {
   try {
@@ -25629,23 +26688,23 @@ Examples:
       const pdfData = await pdfParse.default(dataBuffer, {
         max: maxPages
       });
-      let text = pdfData.text;
+      let text2 = pdfData.text;
       let truncated = false;
       const totalPages = pdfData.numpages;
       if (pages) {
         const range = parsePageRange(pages, totalPages);
-        const pageTexts = text.split(/\f/);
+        const pageTexts = text2.split(/\f/);
         if (pageTexts.length > 1) {
           const selectedPages = pageTexts.slice(range.start - 1, range.end);
-          text = selectedPages.join("\n\n--- Page Break ---\n\n");
+          text2 = selectedPages.join("\n\n--- Page Break ---\n\n");
         }
       }
-      if (text.length > 5e5) {
-        text = text.slice(0, 5e5);
+      if (text2.length > 5e5) {
+        text2 = text2.slice(0, 5e5);
         truncated = true;
       }
       return {
-        text,
+        text: text2,
         pages: totalPages,
         metadata: {
           title: pdfData.info?.Title,
@@ -25744,14 +26803,14 @@ Examples:
     const mimeType = MIME_TYPES[ext] ?? "image/png";
     const selectedProvider = provider ?? "anthropic";
     let description;
-    let model;
+    let model2;
     try {
       if (selectedProvider === "anthropic") {
-        model = "claude-sonnet-4-20250514";
+        model2 = "claude-sonnet-4-20250514";
         const { default: Anthropic2 } = await import('@anthropic-ai/sdk');
         const client = new Anthropic2();
         const response = await client.messages.create({
-          model,
+          model: model2,
           max_tokens: 4096,
           messages: [
             {
@@ -25775,7 +26834,7 @@ Examples:
         });
         description = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n") || "No description generated";
       } else if (selectedProvider === "openai") {
-        model = "gpt-4o";
+        model2 = "gpt-4o";
         const { default: OpenAI3 } = await import('openai');
         const client = new OpenAI3();
         const openaiMessages = [
@@ -25796,13 +26855,13 @@ Examples:
           }
         ];
         const response = await client.chat.completions.create({
-          model,
+          model: model2,
           max_tokens: 4096,
           messages: openaiMessages
         });
         description = response.choices[0]?.message?.content ?? "No description generated";
       } else if (selectedProvider === "gemini") {
-        model = "gemini-2.0-flash";
+        model2 = "gemini-2.0-flash";
         const { GoogleGenAI: GoogleGenAI2 } = await import('@google/genai');
         const apiKey = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
         if (!apiKey) {
@@ -25813,7 +26872,7 @@ Examples:
         }
         const genAI = new GoogleGenAI2({ apiKey });
         const result = await genAI.models.generateContent({
-          model,
+          model: model2,
           contents: [
             {
               role: "user",
@@ -25856,7 +26915,7 @@ Examples:
     return {
       description,
       provider: selectedProvider,
-      model,
+      model: model2,
       duration: performance.now() - startTime,
       imageSize: imageBuffer.length,
       format: ext.slice(1)
@@ -26136,8 +27195,8 @@ async function analyzeFile(filePath, includeAst = false) {
   };
 }
 async function analyzeDirectory(dirPath) {
-  const { glob: glob17 } = await import('glob');
-  const files = await glob17("**/*.{ts,tsx,js,jsx}", {
+  const { glob: glob18 } = await import('glob');
+  const files = await glob18("**/*.{ts,tsx,js,jsx}", {
     cwd: dirPath,
     ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
     absolute: true
@@ -26209,6 +27268,329 @@ var analyzeDirectoryTool = defineTool({
   }
 });
 var codeAnalyzerTools = [analyzeFileTool, analyzeDirectoryTool];
+var SOURCE_GLOBS = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs"];
+var DEFAULT_EXCLUDES3 = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/*.d.ts"
+];
+async function commandAvailable(command) {
+  try {
+    await execa(command, ["--version"], { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getSourceFiles(root, maxFiles) {
+  const files = await glob(SOURCE_GLOBS, {
+    cwd: root,
+    absolute: false,
+    ignore: DEFAULT_EXCLUDES3,
+    nodir: true
+  });
+  return files.slice(0, maxFiles);
+}
+async function getFileSymbols(filePath) {
+  const absolutePath = path17__default.resolve(filePath);
+  const content = await fs16__default.readFile(absolutePath, "utf-8");
+  const language = detectLanguage3(absolutePath);
+  if (language !== "typescript" && language !== "javascript") {
+    return [];
+  }
+  return parseTypeScript(content).definitions.map((definition) => ({
+    file: filePath,
+    name: definition.name,
+    type: definition.type,
+    line: definition.line,
+    exported: definition.exported,
+    signature: definition.signature
+  }));
+}
+var lspStatusTool = defineTool({
+  name: "lsp_status",
+  description: "Check optional language-server availability. Use before LSP-style navigation when you need to know whether Coco is using static fallbacks.",
+  category: "search",
+  parameters: z.object({}),
+  async execute() {
+    return {
+      languageServers: [
+        {
+          name: "typescript-language-server",
+          available: await commandAvailable("typescript-language-server")
+        },
+        { name: "tsserver", available: await commandAvailable("tsserver") }
+      ],
+      fallbackMode: "static-analysis"
+    };
+  }
+});
+var lspDocumentSymbolsTool = defineTool({
+  name: "lsp_document_symbols",
+  description: "Return LSP-style document symbols for a TypeScript/JavaScript file using static analysis fallback.",
+  category: "search",
+  parameters: z.object({
+    file: z.string().describe("File path to inspect")
+  }),
+  async execute({ file }) {
+    return { symbols: await getFileSymbols(file) };
+  }
+});
+var lspWorkspaceSymbolsTool = defineTool({
+  name: "lsp_workspace_symbols",
+  description: "Find LSP-style workspace symbols by name across TypeScript/JavaScript files using static analysis fallback.",
+  category: "search",
+  parameters: z.object({
+    query: z.string().describe("Symbol name or substring to find"),
+    path: z.string().optional().describe("Workspace directory, defaults to cwd"),
+    maxFiles: z.number().optional().default(300),
+    maxResults: z.number().optional().default(100)
+  }),
+  async execute({ query, path: workspacePath, maxFiles = 300, maxResults = 100 }) {
+    const root = path17__default.resolve(workspacePath ?? process.cwd());
+    const files = await getSourceFiles(root, maxFiles);
+    const lowerQuery = query.toLowerCase();
+    const symbols = [];
+    for (const file of files) {
+      const fileSymbols = await getFileSymbols(path17__default.join(root, file));
+      for (const symbol of fileSymbols) {
+        if (!symbol.name.toLowerCase().includes(lowerQuery)) continue;
+        symbols.push({ ...symbol, file });
+        if (symbols.length >= maxResults) {
+          return { symbols, searchedFiles: files.length, truncated: true };
+        }
+      }
+    }
+    return { symbols, searchedFiles: files.length, truncated: false };
+  }
+});
+var lspDefinitionTool = defineTool({
+  name: "lsp_definition",
+  description: "Find the likely definition of a symbol using exported symbols first, then local definitions.",
+  category: "search",
+  parameters: z.object({
+    symbol: z.string().describe("Exact symbol name to locate"),
+    path: z.string().optional().describe("Workspace directory, defaults to cwd"),
+    maxFiles: z.number().optional().default(300)
+  }),
+  async execute({ symbol, path: workspacePath, maxFiles = 300 }) {
+    const root = path17__default.resolve(workspacePath ?? process.cwd());
+    const files = await getSourceFiles(root, maxFiles);
+    const candidates = [];
+    for (const file of files) {
+      const fileSymbols = await getFileSymbols(path17__default.join(root, file));
+      for (const candidate of fileSymbols) {
+        if (candidate.name !== symbol) continue;
+        candidates.push({ ...candidate, file });
+      }
+    }
+    const definition = candidates.find((candidate) => candidate.exported) ?? candidates[0];
+    return { definition, candidates };
+  }
+});
+var lspReferencesTool = defineTool({
+  name: "lsp_references",
+  description: "Find likely references to a symbol across TypeScript/JavaScript files using whole-word text search.",
+  category: "search",
+  parameters: z.object({
+    symbol: z.string().describe("Symbol name to find"),
+    path: z.string().optional().describe("Workspace directory, defaults to cwd"),
+    maxFiles: z.number().optional().default(300),
+    maxResults: z.number().optional().default(100)
+  }),
+  async execute({ symbol, path: workspacePath, maxFiles = 300, maxResults = 100 }) {
+    const root = path17__default.resolve(workspacePath ?? process.cwd());
+    const files = await getSourceFiles(root, maxFiles);
+    const pattern = new RegExp(`\\b${escapeRegExp(symbol)}\\b`);
+    const references = [];
+    for (const file of files) {
+      const absolutePath = path17__default.join(root, file);
+      const content = await fs16__default.readFile(absolutePath, "utf-8");
+      const lines = content.split("\n");
+      for (let index = 0; index < lines.length; index++) {
+        const line = lines[index] ?? "";
+        const match = pattern.exec(line);
+        if (!match) continue;
+        references.push({
+          file,
+          line: index + 1,
+          column: match.index + 1,
+          content: line.trim()
+        });
+        if (references.length >= maxResults) {
+          return { references, searchedFiles: files.length, truncated: true };
+        }
+      }
+    }
+    return { references, searchedFiles: files.length, truncated: false };
+  }
+});
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var lspTools = [
+  lspStatusTool,
+  lspDocumentSymbolsTool,
+  lspWorkspaceSymbolsTool,
+  lspDefinitionTool,
+  lspReferencesTool
+];
+var fs34 = await import('fs/promises');
+var path36 = await import('path');
+function cachePath(root) {
+  return path36.join(root, ".coco", "cache", "repo-index.json");
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9_./:-]+/g, " ");
+}
+function queryTerms(query) {
+  return [
+    ...new Set(
+      normalizeText(query).split(/\s+/).filter((term) => term.length >= 2)
+    )
+  ];
+}
+function importTargetToPath(importTarget) {
+  return importTarget.replace(/^\.\//, "").replace(/\.(js|ts|tsx|jsx|mjs|cjs)$/, "");
+}
+function buildGraph(root, map) {
+  const inbound = /* @__PURE__ */ new Map();
+  const files = new Set(map.files.map((file) => file.path.replace(/\.[^.]+$/, "")));
+  for (const file of map.files) {
+    for (const importTarget of file.imports) {
+      const normalized = importTargetToPath(importTarget);
+      for (const candidate of files) {
+        if (candidate.endsWith(normalized) || normalized.endsWith(candidate)) {
+          inbound.set(candidate, (inbound.get(candidate) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  return {
+    root,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: map.files.map((file) => {
+      const withoutExt = file.path.replace(/\.[^.]+$/, "");
+      return {
+        ...file,
+        inboundImports: inbound.get(withoutExt) ?? 0,
+        testRelated: /(?:^|[/.-])(test|spec|__tests__)(?:[/.-]|$)/i.test(file.path)
+      };
+    }),
+    summary: map.summary
+  };
+}
+async function readCachedGraph(root) {
+  try {
+    const raw = await fs34.readFile(cachePath(root), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCachedGraph(root, graph) {
+  const file = cachePath(root);
+  await fs34.mkdir(path36.dirname(file), { recursive: true });
+  await fs34.writeFile(file, JSON.stringify(graph, null, 2) + "\n", "utf-8");
+}
+async function loadGraph(root, refresh) {
+  if (!refresh) {
+    const cached = await readCachedGraph(root);
+    if (cached) return cached;
+  }
+  const map = await codebaseMapTool.execute({
+    path: root,
+    maxFiles: 500,
+    depth: "detailed",
+    includeTests: true
+  });
+  const graph = buildGraph(root, map);
+  await writeCachedGraph(root, graph);
+  return graph;
+}
+function scoreFile(file, terms, mode, changedFiles) {
+  let score = 0;
+  const reasons = [];
+  const pathText = normalizeText(file.path);
+  const symbolText = normalizeText(file.definitions.map((def) => def.name).join(" "));
+  const importText = normalizeText([...file.imports, ...file.exports].join(" "));
+  for (const term of terms) {
+    if (pathText.includes(term)) {
+      score += 8;
+      reasons.push(`path:${term}`);
+    }
+    if (symbolText.includes(term)) {
+      score += 6;
+      reasons.push(`symbol:${term}`);
+    }
+    if (importText.includes(term)) {
+      score += 3;
+      reasons.push(`import/export:${term}`);
+    }
+  }
+  if (changedFiles.has(file.path)) {
+    score += 10;
+    reasons.push("changed-file");
+  }
+  if (file.inboundImports > 0) {
+    score += Math.min(6, file.inboundImports);
+    reasons.push(`centrality:${file.inboundImports}`);
+  }
+  if ((mode === "debug" || mode === "review") && file.testRelated) {
+    score += 4;
+    reasons.push("test-related");
+  }
+  if (file.exports.length > 0) {
+    score += 1;
+  }
+  return {
+    path: file.path,
+    score,
+    reasons: [...new Set(reasons)],
+    language: file.language,
+    lineCount: file.lineCount,
+    definitions: file.definitions.slice(0, 20),
+    imports: file.imports.slice(0, 20),
+    exports: file.exports.slice(0, 20)
+  };
+}
+async function getRepoContext(request) {
+  const root = path36.resolve(request.path ?? ".");
+  const budget = request.budget ?? 12;
+  const graph = await loadGraph(root, request.refresh ?? false);
+  const terms = queryTerms(request.query);
+  const changedFiles = new Set(request.changedFiles ?? []);
+  const items = graph.files.map((file) => scoreFile(file, terms, request.mode, changedFiles)).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).slice(0, budget);
+  return {
+    graph: {
+      root: graph.root,
+      generatedAt: graph.generatedAt,
+      totalFiles: graph.summary.totalFiles,
+      totalDefinitions: graph.summary.totalDefinitions
+    },
+    query: request.query,
+    budget,
+    items
+  };
+}
+var repoContextTool = defineTool({
+  name: "repo_context",
+  description: "Return ranked, token-efficient repository context for a task using symbols, imports, tests, and centrality.",
+  category: "search",
+  parameters: z.object({
+    path: z.string().optional().default(".").describe("Repository root"),
+    query: z.string().min(1).describe("Task or search query to rank files against"),
+    budget: z.number().min(1).max(50).optional().default(12).describe("Maximum files to return"),
+    mode: z.enum(["ask", "plan", "build", "debug", "review", "architect"]).optional().describe("Agent mode to bias ranking"),
+    changedFiles: z.array(z.string()).optional().describe("Files already changed or selected"),
+    refresh: z.boolean().optional().default(false).describe("Refresh persistent repo index cache")
+  }),
+  execute: getRepoContext
+});
+var repoIntelligenceTools = [repoContextTool];
 var AgentTaskQueue = class {
   tasks = /* @__PURE__ */ new Map();
   completionOrder = [];
@@ -26517,15 +27899,15 @@ ${completed.map((r) => `- ${r.agentId}: Success`).join("\n")}`;
   }
 });
 var agentCoordinatorTools = [createAgentPlanTool, delegateTaskTool, aggregateResultsTool];
-var fs33 = await import('fs/promises');
+var fs35 = await import('fs/promises');
 var SuggestImprovementsSchema = z.object({
   filePath: z.string().describe("File to analyze for improvement suggestions"),
   context: z.string().optional().describe("Additional context about the code")
 });
 async function analyzeAndSuggest(filePath, _context) {
-  let rawContent = await fs33.readFile(filePath, "utf-8");
+  let rawContent = await fs35.readFile(filePath, "utf-8");
   if (typeof rawContent !== "string") {
-    const defaultReadFile = fs33.default?.readFile;
+    const defaultReadFile = fs35.default?.readFile;
     if (typeof defaultReadFile === "function") {
       rawContent = await defaultReadFile(filePath, "utf-8");
     }
@@ -26622,7 +28004,7 @@ async function analyzeAndSuggest(filePath, _context) {
     if (filePath.endsWith(".ts") && !filePath.includes("test") && !filePath.includes(".d.ts") && line.includes("export ")) {
       const testPath = filePath.replace(".ts", ".test.ts");
       try {
-        await fs33.access(testPath);
+        await fs35.access(testPath);
       } catch {
         suggestions.push({
           type: "testing",
@@ -26679,7 +28061,7 @@ var calculateCodeScoreTool = defineTool({
   async execute(input) {
     const { filePath } = input;
     const suggestions = await analyzeAndSuggest(filePath);
-    const content = await fs33.readFile(filePath, "utf-8");
+    const content = await fs35.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const nonEmptyLines = lines.filter((l) => l.trim()).length;
     let score = 100;
@@ -26713,8 +28095,8 @@ var calculateCodeScoreTool = defineTool({
   }
 });
 var smartSuggestionsTools = [suggestImprovementsTool, calculateCodeScoreTool];
-var fs34 = await import('fs/promises');
-var path35 = await import('path');
+var fs36 = await import('fs/promises');
+var path37 = await import('path');
 var ContextMemoryStore = class {
   items = /* @__PURE__ */ new Map();
   learnings = /* @__PURE__ */ new Map();
@@ -26726,7 +28108,7 @@ var ContextMemoryStore = class {
   }
   async load() {
     try {
-      const content = await fs34.readFile(this.storePath, "utf-8");
+      const content = await fs36.readFile(this.storePath, "utf-8");
       const data = JSON.parse(content);
       this.items = new Map(Object.entries(data.items || {}));
       this.learnings = new Map(Object.entries(data.learnings || {}));
@@ -26734,15 +28116,15 @@ var ContextMemoryStore = class {
     }
   }
   async save() {
-    const dir = path35.dirname(this.storePath);
-    await fs34.mkdir(dir, { recursive: true });
+    const dir = path37.dirname(this.storePath);
+    await fs36.mkdir(dir, { recursive: true });
     const data = {
       sessionId: this.sessionId,
       items: Object.fromEntries(this.items),
       learnings: Object.fromEntries(this.learnings),
       savedAt: Date.now()
     };
-    await fs34.writeFile(this.storePath, JSON.stringify(data, null, 2));
+    await fs36.writeFile(this.storePath, JSON.stringify(data, null, 2));
   }
   addContext(id, item) {
     this.items.set(id, item);
@@ -26907,11 +28289,11 @@ var contextEnhancerTools = [
   recordLearningTool,
   getLearnedPatternsTool
 ];
-var fs35 = await import('fs/promises');
-var path36 = await import('path');
+var fs37 = await import('fs/promises');
+var path38 = await import('path');
 async function discoverSkills(skillsDir) {
   try {
-    const files = await fs35.readdir(skillsDir);
+    const files = await fs37.readdir(skillsDir);
     return files.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
   } catch {
     return [];
@@ -26919,12 +28301,12 @@ async function discoverSkills(skillsDir) {
 }
 async function loadSkillMetadata(skillPath) {
   try {
-    const content = await fs35.readFile(skillPath, "utf-8");
+    const content = await fs37.readFile(skillPath, "utf-8");
     const nameMatch = content.match(/@name\s+(\S+)/);
     const descMatch = content.match(/@description\s+(.+)/);
     const versionMatch = content.match(/@version\s+(\S+)/);
     return {
-      name: nameMatch?.[1] || path36.basename(skillPath, path36.extname(skillPath)),
+      name: nameMatch?.[1] || path38.basename(skillPath, path38.extname(skillPath)),
       description: descMatch?.[1] || "No description",
       version: versionMatch?.[1] || "1.0.0",
       dependencies: []
@@ -26968,7 +28350,7 @@ var discoverSkillsTool = defineTool({
     const { skillsDir } = input;
     const skills = await discoverSkills(skillsDir);
     const metadata = await Promise.all(
-      skills.map((s) => loadSkillMetadata(path36.join(skillsDir, s)))
+      skills.map((s) => loadSkillMetadata(path38.join(skillsDir, s)))
     );
     return {
       skillsDir,
@@ -27708,8 +29090,8 @@ var MCPRegistryImpl = class {
   /**
    * Ensure directory exists
    */
-  async ensureDir(path42) {
-    await mkdir(dirname(path42), { recursive: true });
+  async ensureDir(path44) {
+    await mkdir(dirname(path44), { recursive: true });
   }
 };
 
@@ -27725,6 +29107,8 @@ var MCPClientImpl = class {
     this.requestTimeout = requestTimeout;
     this.setupTransportHandlers();
   }
+  transport;
+  requestTimeout;
   requestId = 0;
   pendingRequests = /* @__PURE__ */ new Map();
   initialized = false;
@@ -27896,6 +29280,7 @@ var StdioTransport = class {
   constructor(config) {
     this.config = config;
   }
+  config;
   process = null;
   messageCallback = null;
   errorCallback = null;
@@ -28435,6 +29820,7 @@ var HTTPTransport = class {
     this.config.timeout = config.timeout ?? 6e4;
     this.config.retries = config.retries ?? 3;
   }
+  config;
   messageCallback = null;
   errorCallback = null;
   // Used to report transport errors to the client
@@ -29503,6 +30889,8 @@ function registerAllTools(registry) {
     ...databaseTools,
     ...astValidatorTools,
     ...codeAnalyzerTools,
+    ...lspTools,
+    ...repoIntelligenceTools,
     ...agentCoordinatorTools,
     ...smartSuggestionsTools,
     ...contextEnhancerTools,