claude-ai-switcher 1.1.4

package/src/models.ts

@@ -0,0 +1,366 @@
+export interface Model {
+  id: string;
+  name: string;
+  contextWindow: number; // in tokens
+  capabilities: string[];
+  description: string;
+}
+
+export interface Provider {
+  id: string;
+  name: string;
+  endpoint?: string;
+  models: Model[];
+}
+
+export interface ModelTierMap {
+  opus: string;
+  sonnet: string;
+  haiku: string;
+}
+
+// Default GLM tier map per Z.AI docs (https://docs.z.ai/devpack/latest-model)
+// GLM-5.2 with 1M context leads opus, with the fast turbo models filling sonnet/haiku
+export const GLM_DEFAULT_TIER_MAP: ModelTierMap = {
+  opus: "glm-5.2[1m]",
+  sonnet: "glm-5-turbo",
+  haiku: "glm-5v-turbo"
+};
+
+// Default OpenRouter tier map
+export const OPENROUTER_DEFAULT_TIER_MAP: ModelTierMap = {
+  opus: "qwen/qwen3.6-plus:free",
+  sonnet: "openrouter/free",
+  haiku: "openrouter/free"
+};
+
+// Default Ollama tier map (via LiteLLM proxy on port 4000)
+export const OLLAMA_DEFAULT_TIER_MAP: ModelTierMap = {
+  opus: "deepseek-r1:latest",
+  sonnet: "qwen2.5-coder:latest",
+  haiku: "llama3.1:latest"
+};
+
+// Default Gemini tier map (via LiteLLM proxy on port 4001)
+export const GEMINI_DEFAULT_TIER_MAP: ModelTierMap = {
+  opus: "gemini-2.5-pro",
+  sonnet: "gemini-2.5-flash",
+  haiku: "gemini-2.5-flash-lite"
+};
+
+// For Alibaba: tier mapping based on model capabilities
+// Default mapping when no specific model chosen: Opus = qwen3.7-plus, Sonnet = qwen3.6-plus, Haiku = kimi-k2.5
+// When specific model selected: Opus = selected model, Sonnet = qwen3.7-plus, Haiku = qwen3.6-plus
+export function getAlibabaTierMap(model: string): ModelTierMap {
+  // Use custom defaults when using the default model
+  if (model === "qwen3.7-plus") {
+    return {
+      opus: "qwen3.7-plus",
+      sonnet: "qwen3.6-plus",
+      haiku: "kimi-k2.5"
+    };
+  } else {
+    // For other specific models, use the selected model as opus
+    return {
+      opus: model,
+      sonnet: "qwen3.7-plus",
+      haiku: "qwen3.6-plus"
+    };
+  }
+}
+
+// Format context window for display
+export function formatContext(tokens: number): string {
+  if (tokens >= 1000000) {
+    return `${(tokens / 1000000).toFixed(0)}M tokens`;
+  } else if (tokens >= 1000) {
+    return `${(tokens / 1000).toFixed(0)}K tokens`;
+  }
+  return `${tokens} tokens`;
+}
+
+// Alibaba Coding Plan Models
+export const alibabaModels: Model[] = [
+  {
+    id: "qwen3.7-plus",
+    name: "Qwen3.7-Plus",
+    contextWindow: 1000000,
+    capabilities: ["Text Generation", "Deep Thinking", "Visual Understanding"],
+    description: "Most capable Qwen model with balanced performance, speed, and cost. Supports thinking/non-thinking modes, visual understanding, and a 1M context window."
+  },
+  {
+    id: "qwen3.6-plus",
+    name: "Qwen3.6-Plus",
+    contextWindow: 1000000,
+    capabilities: ["Text Generation", "Deep Thinking", "Visual Understanding"],
+    description: "Balanced performance, speed, and cost. Supports thinking/non-thinking modes with 1M context window."
+  },
+  {
+    id: "qwen3-max-2026-01-23",
+    name: "Qwen3-Max (2026-01-23)",
+    contextWindow: 262144,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "Most capable model for complex, multi-step tasks with enhanced reasoning."
+  },
+  {
+    id: "qwen3-coder-next",
+    name: "Qwen3-Coder-Next",
+    contextWindow: 262144,
+    capabilities: ["Text Generation", "Coding Agent"],
+    description: "Next-generation coding model with advanced Coding Agent capabilities, tool calling, and autonomous programming."
+  },
+  {
+    id: "qwen3-coder-plus",
+    name: "Qwen3-Coder-Plus",
+    contextWindow: 1000000,
+    capabilities: ["Text Generation", "Coding"],
+    description: "Latest code generation model with Coding Agent support, tool calling, and autonomous programming capabilities. 1M context for large codebases."
+  },
+  {
+    id: "glm-5",
+    name: "GLM-5",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "Zhipu's flagship model with enhanced reasoning and deep thinking capabilities."
+  },
+  {
+    id: "glm-4.7",
+    name: "GLM-4.7",
+    contextWindow: 256000,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "Zhipu's balanced model with strong reasoning and code understanding."
+  },
+  {
+    id: "glm-4.7-flash",
+    name: "GLM-4.7-Flash",
+    contextWindow: 256000,
+    capabilities: ["Text Generation", "Fast Inference"],
+    description: "Zhipu's fast inference model optimized for speed while maintaining quality."
+  },
+  {
+    id: "kimi-k2.5",
+    name: "Kimi K2.5",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Deep Thinking", "Visual Understanding"],
+    description: "Moonshot AI's Kimi model with 200K context and multimodal capabilities."
+  },
+  {
+    id: "MiniMax-M2.5",
+    name: "MiniMax-M2.5",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "MiniMax's advanced model with strong reasoning and generation capabilities."
+  }
+];
+
+// GLM/Z.AI Models (via coding-helper)
+export const glmModels: Model[] = [
+  {
+    id: "glm-5.2[1m]",
+    name: "GLM-5.2 (1M Context)",
+    contextWindow: 1000000,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "Zhipu's latest flagship model with state-of-the-art reasoning and a 1M context window. Recommended by Z.AI for the opus tier."
+  },
+  {
+    id: "glm-5v-turbo",
+    name: "GLM-5V-Turbo",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Deep Thinking", "Visual Understanding", "Visual Programming"],
+    description: "Zhipu's first multimodal coding foundation model. Natively understands images, videos, design drafts, and screenshots for visual programming."
+  },
+  {
+    id: "glm-5-turbo",
+    name: "GLM-5-Turbo",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Deep Thinking", "Fast Responses"],
+    description: "Zhipu's fast turbo model combining strong reasoning with low latency."
+  },
+  {
+    id: "glm-5.1",
+    name: "GLM-5.1",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "Zhipu's GLM-5.1 model with enhanced reasoning and deep thinking capabilities."
+  },
+  {
+    id: "glm-4.7",
+    name: "GLM-4.7",
+    contextWindow: 256000,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "Zhipu's balanced model with strong reasoning and code understanding."
+  },
+  {
+    id: "glm-4.7-flash",
+    name: "GLM-4.7-Flash",
+    contextWindow: 256000,
+    capabilities: ["Text Generation", "Fast Inference"],
+    description: "Zhipu's fast inference model optimized for speed while maintaining quality."
+  }
+];
+
+// OpenRouter Models
+export const openrouterModels: Model[] = [
+  {
+    id: "qwen/qwen3.6-plus:free",
+    name: "Qwen3.6 Plus (Free)",
+    contextWindow: 131072,
+    capabilities: ["Text Generation", "Deep Thinking"],
+    description: "Free Qwen3.6 Plus model via OpenRouter with strong reasoning capabilities."
+  },
+  {
+    id: "openrouter/free",
+    name: "OpenRouter Free",
+    contextWindow: 131072,
+    capabilities: ["Text Generation"],
+    description: "OpenRouter's free tier model for basic usage."
+  }
+];
+
+// Ollama Models (local, via LiteLLM proxy)
+export const ollamaModels: Model[] = [
+  {
+    id: "deepseek-r1:latest",
+    name: "DeepSeek R1",
+    contextWindow: 128000,
+    capabilities: ["Text Generation", "Deep Thinking", "Reasoning"],
+    description: "DeepSeek's reasoning model with deep thinking capabilities for complex problem-solving."
+  },
+  {
+    id: "qwen2.5-coder:latest",
+    name: "Qwen 2.5 Coder",
+    contextWindow: 128000,
+    capabilities: ["Text Generation", "Coding", "Tool Calling"],
+    description: "Alibaba's code-specialized model with strong coding and tool calling capabilities."
+  },
+  {
+    id: "llama3.1:latest",
+    name: "Llama 3.1",
+    contextWindow: 128000,
+    capabilities: ["Text Generation", "Code", "Vision"],
+    description: "Meta's Llama 3.1 with strong general performance, code generation, and vision support."
+  },
+  {
+    id: "codellama:latest",
+    name: "Code Llama",
+    contextWindow: 100000,
+    capabilities: ["Text Generation", "Coding"],
+    description: "Meta's code-specialized Llama model optimized for code generation and understanding."
+  }
+];
+
+// Gemini Models (via LiteLLM proxy)
+export const geminiModels: Model[] = [
+  {
+    id: "gemini-2.5-pro",
+    name: "Gemini 2.5 Pro",
+    contextWindow: 1000000,
+    capabilities: ["Text Generation", "Deep Thinking", "Code", "Vision"],
+    description: "Google's most capable Gemini model with deep thinking, 1M context, and multimodal support."
+  },
+  {
+    id: "gemini-2.5-flash",
+    name: "Gemini 2.5 Flash",
+    contextWindow: 1000000,
+    capabilities: ["Text Generation", "Fast Responses", "Code"],
+    description: "Google's fast Gemini model with 1M context, optimized for speed while maintaining quality."
+  },
+  {
+    id: "gemini-2.5-flash-lite",
+    name: "Gemini 2.5 Flash Lite",
+    contextWindow: 1000000,
+    capabilities: ["Text Generation", "Cost-optimized"],
+    description: "Google's cost-optimized Gemini model with 1M context for budget-conscious usage."
+  }
+];
+
+// Anthropic Models (default)
+export const anthropicModels: Model[] = [
+  {
+    id: "claude-opus-4-6-20250205",
+    name: "Claude Opus 4.6",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Code", "Vision", "Complex Reasoning"],
+    description: "Anthropic's most powerful model for complex tasks requiring deep expertise."
+  },
+  {
+    id: "claude-opus-4-5-20251101",
+    name: "Claude Opus 4.5",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Code", "Vision", "Complex Reasoning"],
+    description: "Previous generation Opus model with excellent performance."
+  },
+  {
+    id: "claude-sonnet-4-6-20250219",
+    name: "Claude Sonnet 4.6",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Code", "Vision"],
+    description: "Balanced model offering great performance at lower cost."
+  },
+  {
+    id: "claude-sonnet-4-5-20250814",
+    name: "Claude Sonnet 4.5",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Code", "Vision"],
+    description: "Previous generation Sonnet model with strong capabilities."
+  },
+  {
+    id: "claude-haiku-4-5-20251015",
+    name: "Claude Haiku 4.5",
+    contextWindow: 200000,
+    capabilities: ["Text Generation", "Fast Responses"],
+    description: "Anthropic's fastest model for quick, simple tasks."
+  }
+];
+
+// Provider definitions
+export const providers: Record<string, Provider> = {
+  anthropic: {
+    id: "anthropic",
+    name: "Anthropic (Default)",
+    models: anthropicModels
+  },
+  alibaba: {
+    id: "alibaba",
+    name: "Alibaba Coding Plan",
+    endpoint: "https://coding-intl.dashscope.aliyuncs.com/apps/anthropic",
+    models: alibabaModels
+  },
+  glm: {
+    id: "glm",
+    name: "GLM/Z.AI",
+    models: glmModels
+  },
+  openrouter: {
+    id: "openrouter",
+    name: "OpenRouter",
+    endpoint: "https://openrouter.ai/api/v1",
+    models: openrouterModels
+  },
+  ollama: {
+    id: "ollama",
+    name: "Ollama (Local)",
+    endpoint: "http://localhost:4000",
+    models: ollamaModels
+  },
+  gemini: {
+    id: "gemini",
+    name: "Gemini (Google)",
+    endpoint: "http://localhost:4001",
+    models: geminiModels
+  }
+};
+
+// Get model by ID from a provider
+export function getModel(providerId: string, modelId: string): Model | undefined {
+  const provider = providers[providerId];
+  if (!provider) return undefined;
+  return provider.models.find(m => m.id === modelId);
+}
+
+// Get all models for a provider
+export function getModels(providerId: string): Model[] {
+  const provider = providers[providerId];
+  if (!provider) return [];
+  return provider.models;
+}

package/src/providers/alibaba.ts

@@ -0,0 +1,43 @@
+/**
+ * Alibaba Coding Plan Provider Configuration
+ * 
+ * Configures Claude Code and OpenCode to use Alibaba's Coding Plan
+ * with Qwen, GLM, Kimi, and MiniMax models via Anthropic-compatible API.
+ */
+
+import { providers, alibabaModels } from "../models";
+
+export const ALIBABA_PROVIDER = providers.alibaba;
+
+export interface AlibabaConfig {
+  provider: "alibaba";
+  apiKey: string;
+  model: string;
+  endpoint: string;
+}
+
+export const ALIBABA_ENDPOINT = "https://coding-intl.dashscope.aliyuncs.com/apps/anthropic";
+export const ALIBABA_VERIFY_URL = "https://coding-intl.dashscope.aliyuncs.com/compatible-mode/v1/models";
+
+export function getAlibabaConfig(apiKey: string, model?: string): AlibabaConfig {
+  return {
+    provider: "alibaba",
+    apiKey,
+    model: model || "qwen3.7-plus",
+    endpoint: ALIBABA_ENDPOINT
+  };
+}
+
+/**
+ * Get available Alibaba models
+ */
+export function getAvailableModels() {
+  return alibabaModels;
+}
+
+/**
+ * Find a model by ID
+ */
+export function findModel(modelId: string) {
+  return alibabaModels.find(m => m.id === modelId);
+}

package/src/providers/anthropic.ts

@@ -0,0 +1,23 @@
+/**
+ * Anthropic Provider Configuration
+ * 
+ * Sets Claude Code and OpenCode to use native Anthropic models
+ * by removing MCP overrides and using default settings.
+ */
+
+import { providers } from "../models";
+
+export const ANTHROPIC_PROVIDER = providers.anthropic;
+
+export interface AnthropicConfig {
+  provider: "anthropic";
+  apiKey?: string;
+  model?: string;
+}
+
+export function getAnthropicConfig(): AnthropicConfig {
+  return {
+    provider: "anthropic",
+    model: process.env.ANTHROPIC_MODEL || "claude-opus-4-6-20250205"
+  };
+}

package/src/providers/gemini.ts

@@ -0,0 +1,136 @@
+/**
+ * Gemini Provider Configuration
+ *
+ * Uses Google Gemini models via a LiteLLM proxy for Anthropic API compatibility.
+ * Gemini only speaks OpenAI format, so LiteLLM translates Anthropic Messages API
+ * requests into OpenAI Chat Completions format.
+ *
+ * Prerequisites:
+ * - LiteLLM installed (pip install 'litellm[proxy]')
+ * - Google API key from https://aistudio.google.com/apikey
+ * - LiteLLM proxy running on port 4001
+ */
+
+import { providers, geminiModels } from "../models";
+
+export const GEMINI_PROVIDER = providers.gemini;
+
+export interface GeminiConfig {
+  provider: "gemini";
+  apiKey: string;
+  model: string;
+  endpoint: string;
+}
+
+export const GEMINI_ENDPOINT = "http://localhost:4001";
+export const GEMINI_LITELLM_PORT = 4001;
+
+export function getGeminiConfig(apiKey: string, model?: string): GeminiConfig {
+  return {
+    provider: "gemini",
+    apiKey,
+    model: model || "gemini-2.5-pro",
+    endpoint: GEMINI_ENDPOINT
+  };
+}
+
+export function getAvailableModels() {
+  return geminiModels;
+}
+
+export function findModel(modelId: string) {
+  return geminiModels.find(m => m.id === modelId);
+}
+
+/**
+ * Check if litellm is installed
+ */
+export async function isLitellmInstalled(): Promise<boolean> {
+  try {
+    const { platform } = await import("os");
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    const cmd = platform() === "win32" ? "where litellm" : "which litellm";
+    await execAsync(cmd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate a Gemini API key by hitting the models endpoint
+ */
+export async function isGeminiKeyValid(apiKey: string): Promise<boolean> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const resp = await fetch(
+      "https://generativelanguage.googleapis.com/v1beta/models",
+      { signal: controller.signal, headers: { "x-goog-api-key": apiKey } }
+    );
+    clearTimeout(timeout);
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if LiteLLM proxy is running on the Gemini port
+ */
+export async function isLitellmProxyRunning(port: number = GEMINI_LITELLM_PORT): Promise<boolean> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    const resp = await fetch(`http://localhost:${port}/health`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Start LiteLLM proxy for Gemini as a detached background process
+ */
+export async function startGeminiLitellmProxy(
+  apiKey: string,
+  model: string,
+  port: number = GEMINI_LITELLM_PORT
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    // Already running?
+    if (await isLitellmProxyRunning(port)) {
+      return { success: true };
+    }
+
+    const { spawn } = await import("child_process");
+    const child = spawn("litellm", ["--model", `gemini/${model}`, "--port", String(port)], {
+      detached: true,
+      stdio: "ignore",
+      shell: true,
+      env: { ...process.env, GEMINI_API_KEY: apiKey }
+    });
+    child.unref();
+
+    // Poll health endpoint for up to 5 seconds
+    for (let i = 0; i < 10; i++) {
+      await new Promise(resolve => setTimeout(resolve, 500));
+      if (await isLitellmProxyRunning(port)) {
+        return { success: true };
+      }
+    }
+
+    return { success: false, error: "LiteLLM proxy did not start within 5 seconds" };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to start LiteLLM proxy"
+    };
+  }
+}

package/src/providers/glm.ts

@@ -0,0 +1,60 @@
+/**
+ * GLM/Z.AI Provider Configuration
+ *
+ * Uses coding-helper to manage GLM Coding Plan settings.
+ * This provider delegates to the @z_ai/coding-helper package.
+ */
+
+import { platform } from "os";
+import { providers, glmModels } from "../models";
+
+export const GLM_PROVIDER = providers.glm;
+
+export interface GLMConfig {
+  provider: "glm";
+  apiKey?: string;
+  model?: string;
+}
+
+export function getGLMConfig(): GLMConfig {
+  return {
+    provider: "glm",
+    model: process.env.ZHIPUAI_MODEL || process.env.ZAI_MODEL || "glm-5.1"
+  };
+}
+
+/**
+ * Check if coding-helper is installed
+ */
+export async function isCodingHelperInstalled(): Promise<boolean> {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    const checkCommand = platform() === "win32" ? "where coding-helper" : "which coding-helper";
+    await execAsync(checkCommand);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reload GLM configuration into Claude Code using coding-helper
+ */
+export async function reloadGLMConfig(): Promise<{ success: boolean; error?: string }> {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+    
+    await execAsync("coding-helper auth reload claude");
+    return { success: true };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : "Failed to reload GLM config"
+    };
+  }
+}