claudish 3.2.0 → 3.2.1

package/dist/index.js

@@ -61466,41 +61466,59 @@ class GeminiHandler {
     }));
     return [{ functionDeclarations }];
   }
+  normalizeType(type) {
+    if (!type)
+      return "string";
+    if (Array.isArray(type)) {
+      const nonNullTypes = type.filter((t) => t !== "null");
+      return nonNullTypes[0] || "string";
+    }
+    return type;
+  }
   convertJsonSchemaToGemini(schema) {
     if (!schema)
-      return {};
-    const geminiSchema = {
-      type: schema.type || "object"
-    };
-    if (schema.properties) {
-      geminiSchema.properties = {};
-      for (const [key, prop] of Object.entries(schema.properties)) {
-        geminiSchema.properties[key] = this.convertPropertyToGemini(prop);
-      }
+      return { type: "object" };
+    return this.sanitizeSchemaForGemini(schema);
+  }
+  sanitizeSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object") {
+      return schema;
     }
-    if (schema.required) {
-      geminiSchema.required = schema.required;
+    if (Array.isArray(schema)) {
+      return schema.map((item) => this.sanitizeSchemaForGemini(item));
     }
-    return geminiSchema;
-  }
-  convertPropertyToGemini(prop) {
-    const result = {
-      type: prop.type || "string"
-    };
-    if (prop.description)
-      result.description = prop.description;
-    if (prop.enum)
-      result.enum = prop.enum;
-    if (prop.items)
-      result.items = this.convertPropertyToGemini(prop.items);
-    if (prop.properties) {
+    const result = {};
+    const normalizedType = this.normalizeType(schema.type);
+    result.type = normalizedType;
+    if (schema.description && typeof schema.description === "string") {
+      result.description = schema.description;
+    }
+    if (Array.isArray(schema.enum)) {
+      result.enum = schema.enum.filter((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean");
+    }
+    if (Array.isArray(schema.required)) {
+      result.required = schema.required.filter((r) => typeof r === "string");
+    }
+    if (schema.properties && typeof schema.properties === "object") {
       result.properties = {};
-      for (const [k, v] of Object.entries(prop.properties)) {
-        result.properties[k] = this.convertPropertyToGemini(v);
+      for (const [key, value] of Object.entries(schema.properties)) {
+        if (value && typeof value === "object") {
+          result.properties[key] = this.sanitizeSchemaForGemini(value);
+        }
+      }
+    }
+    if (schema.items) {
+      if (typeof schema.items === "object" && !Array.isArray(schema.items)) {
+        result.items = this.sanitizeSchemaForGemini(schema.items);
+      } else if (Array.isArray(schema.items)) {
+        result.items = this.sanitizeSchemaForGemini(schema.items[0]);
       }
     }
     return result;
   }
+  convertPropertyToGemini(prop) {
+    return this.sanitizeSchemaForGemini(prop);
+  }
   buildGeminiPayload(claudeRequest) {
     const contents = this.convertToGeminiMessages(claudeRequest);
     const tools = this.convertToGeminiTools(claudeRequest);
@@ -61803,14 +61821,49 @@ data: ${JSON.stringify(d)}
     });
     const endpoint = this.getApiEndpoint();
     log(`[GeminiHandler] Calling API: ${endpoint}`);
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-goog-api-key": this.apiKey
-      },
-      body: JSON.stringify(geminiPayload)
-    });
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    let response;
+    try {
+      response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": this.apiKey
+        },
+        body: JSON.stringify(geminiPayload),
+        signal: controller.signal
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError.name === "AbortError") {
+        log(`[GeminiHandler] Request timed out after 30s`);
+        return c.json({
+          error: {
+            type: "timeout_error",
+            message: "Request to Gemini API timed out. Check your network connection to generativelanguage.googleapis.com"
+          }
+        }, 504);
+      }
+      if (fetchError.cause?.code === "UND_ERR_CONNECT_TIMEOUT") {
+        log(`[GeminiHandler] Connection timeout: ${fetchError.message}`);
+        return c.json({
+          error: {
+            type: "connection_error",
+            message: `Cannot connect to Gemini API (generativelanguage.googleapis.com). This may be due to: network/firewall blocking, VPN interference, or regional restrictions. Error: ${fetchError.cause?.code}`
+          }
+        }, 503);
+      }
+      log(`[GeminiHandler] Fetch error: ${fetchError.message}`);
+      return c.json({
+        error: {
+          type: "network_error",
+          message: `Failed to connect to Gemini API: ${fetchError.message}`
+        }
+      }, 503);
+    } finally {
+      clearTimeout(timeoutId);
+    }
     log(`[GeminiHandler] Response status: ${response.status}`);
     if (!response.ok) {
       const errorText = await response.text();
@@ -61989,14 +62042,49 @@ class OpenAIHandler {
     });
     const endpoint = this.getApiEndpoint();
     log(`[OpenAIHandler] Calling API: ${endpoint}`);
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(openAIPayload)
-    });
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    let response;
+    try {
+      response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(openAIPayload),
+        signal: controller.signal
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError.name === "AbortError") {
+        log(`[OpenAIHandler] Request timed out after 30s`);
+        return c.json({
+          error: {
+            type: "timeout_error",
+            message: "Request to OpenAI API timed out. Check your network connection to api.openai.com"
+          }
+        }, 504);
+      }
+      if (fetchError.cause?.code === "UND_ERR_CONNECT_TIMEOUT") {
+        log(`[OpenAIHandler] Connection timeout: ${fetchError.message}`);
+        return c.json({
+          error: {
+            type: "connection_error",
+            message: `Cannot connect to OpenAI API (api.openai.com). This may be due to: network/firewall blocking, VPN interference, or regional restrictions. Error: ${fetchError.cause?.code}`
+          }
+        }, 503);
+      }
+      log(`[OpenAIHandler] Fetch error: ${fetchError.message}`);
+      return c.json({
+        error: {
+          type: "network_error",
+          message: `Failed to connect to OpenAI API: ${fetchError.message}`
+        }
+      }, 503);
+    } finally {
+      clearTimeout(timeoutId);
+    }
     log(`[OpenAIHandler] Response status: ${response.status}`);
     if (!response.ok) {
       const errorText = await response.text();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",

package/recommended-models.json

@@ -1,15 +1,78 @@
 {
   "version": "1.1.5",
-  "lastUpdated": "2026-01-04",
+  "lastUpdated": "2026-01-10",
   "source": "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
   "models": [
+    {
+      "id": "x-ai/grok-code-fast-1",
+      "name": "xAI: Grok Code Fast 1",
+      "description": "Grok Code Fast 1 is a speedy and economical reasoning model that excels at agentic coding. With reasoning traces visible in the response, developers can steer Grok Code for high-quality work flows.",
+      "provider": "X-ai",
+      "category": "reasoning",
+      "priority": 1,
+      "pricing": {
+        "input": "$0.20/1M",
+        "output": "$1.50/1M",
+        "average": "$0.85/1M"
+      },
+      "context": "256K",
+      "maxOutputTokens": 10000,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "minimax/minimax-m2.1",
+      "name": "MiniMax: MiniMax M2.1",
+      "description": "MiniMax-M2.1 is a lightweight, state-of-the-art large language model optimized for coding, agentic workflows, and modern application development. With only 10 billion activated parameters, it delivers a major jump in real-world capability while maintaining exceptional latency, scalability, and cost efficiency.\n\nCompared to its predecessor, M2.1 delivers cleaner, more concise outputs and faster perceived response times. It shows leading multilingual coding performance across major systems and application languages, achieving 49.4% on Multi-SWE-Bench and 72.5% on SWE-Bench Multilingual, and serves as a versatile agent “brain” for IDEs, coding tools, and general-purpose assistance.\n\nTo avoid degrading this model's performance, MiniMax highly recommends preserving reasoning between turns. Learn more about using reasoning_details to pass back reasoning in our [docs](https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks).",
+      "provider": "Minimax",
+      "category": "reasoning",
+      "priority": 2,
+      "pricing": {
+        "input": "$0.28/1M",
+        "output": "$1.20/1M",
+        "average": "$0.74/1M"
+      },
+      "context": "196K",
+      "maxOutputTokens": null,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "z-ai/glm-4.7",
+      "name": "Z.AI: GLM 4.7",
+      "description": "GLM-4.7 is Z.AI’s latest flagship model, featuring upgrades in two key areas: enhanced programming capabilities and more stable multi-step reasoning/execution. It demonstrates significant improvements in executing complex agent tasks while delivering more natural conversational experiences and superior front-end aesthetics.",
+      "provider": "Z-ai",
+      "category": "reasoning",
+      "priority": 3,
+      "pricing": {
+        "input": "$0.40/1M",
+        "output": "$1.50/1M",
+        "average": "$0.95/1M"
+      },
+      "context": "202K",
+      "maxOutputTokens": 65535,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    },
     {
       "id": "google/gemini-3-pro-preview",
       "name": "Google: Gemini 3 Pro Preview",
       "description": "Gemini 3 Pro is Google’s flagship frontier model for high-precision multimodal reasoning, combining strong performance across text, image, video, audio, and code with a 1M-token context window. Reasoning Details must be preserved when using multi-turn tool calling, see our docs here: https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks. It delivers state-of-the-art benchmark results in general reasoning, STEM problem solving, factual QA, and multimodal understanding, including leading scores on LMArena, GPQA Diamond, MathArena Apex, MMMU-Pro, and Video-MMMU. Interactions emphasize depth and interpretability: the model is designed to infer intent with minimal prompting and produce direct, insight-focused responses.\n\nBuilt for advanced development and agentic workflows, Gemini 3 Pro provides robust tool-calling, long-horizon planning stability, and strong zero-shot generation for complex UI, visualization, and coding tasks. It excels at agentic coding (SWE-Bench Verified, Terminal-Bench 2.0), multimodal analysis, and structured long-form tasks such as research synthesis, planning, and interactive learning experiences. Suitable applications include autonomous agents, coding assistants, multimodal analytics, scientific reasoning, and high-context information processing.",
       "provider": "Google",
       "category": "vision",
-      "priority": 1,
+      "priority": 4,
       "pricing": {
         "input": "$2.00/1M",
         "output": "$12.00/1M",
@@ -25,16 +88,16 @@
       "recommended": true
     },
     {
-      "id": "openai/gpt-5.1-codex",
-      "name": "OpenAI: GPT-5.1-Codex",
-      "description": "GPT-5.1-Codex is a specialized version of GPT-5.1 optimized for software engineering and coding workflows. It is designed for both interactive development sessions and long, independent execution of complex engineering tasks. The model supports building projects from scratch, feature development, debugging, large-scale refactoring, and code review. Compared to GPT-5.1, Codex is more steerable, adheres closely to developer instructions, and produces cleaner, higher-quality code outputs. Reasoning effort can be adjusted with the `reasoning.effort` parameter. Read the [docs here](https://openrouter.ai/docs/use-cases/reasoning-tokens#reasoning-effort-level)\n\nCodex integrates into developer environments including the CLI, IDE extensions, GitHub, and cloud tasks. It adapts reasoning effort dynamically—providing fast responses for small tasks while sustaining extended multi-hour runs for large projects. The model is trained to perform structured code reviews, catching critical flaws by reasoning over dependencies and validating behavior against tests. It also supports multimodal inputs such as images or screenshots for UI development and integrates tool use for search, dependency installation, and environment setup. Codex is intended specifically for agentic coding applications.",
+      "id": "openai/gpt-5.2",
+      "name": "OpenAI: GPT-5.2",
+      "description": "GPT-5.2 is the latest frontier-grade model in the GPT-5 series, offering stronger agentic and long context perfomance compared to GPT-5.1. It uses adaptive reasoning to allocate computation dynamically, responding quickly to simple queries while spending more depth on complex tasks.\n\nBuilt for broad task coverage, GPT-5.2 delivers consistent gains across math, coding, sciende, and tool calling workloads, with more coherent long-form answers and improved tool-use reliability.",
       "provider": "Openai",
-      "category": "vision",
-      "priority": 2,
+      "category": "reasoning",
+      "priority": 5,
       "pricing": {
-        "input": "$1.25/1M",
-        "output": "$10.00/1M",
-        "average": "$5.63/1M"
+        "input": "$1.75/1M",
+        "output": "$14.00/1M",
+        "average": "$7.88/1M"
       },
       "context": "400K",
       "maxOutputTokens": 128000,
@@ -46,40 +109,19 @@
       "recommended": true
     },
     {
-      "id": "x-ai/grok-code-fast-1",
-      "name": "xAI: Grok Code Fast 1",
-      "description": "Grok Code Fast 1 is a speedy and economical reasoning model that excels at agentic coding. With reasoning traces visible in the response, developers can steer Grok Code for high-quality work flows.",
-      "provider": "X-ai",
+      "id": "moonshotai/kimi-k2-thinking",
+      "name": "MoonshotAI: Kimi K2 Thinking",
+      "description": "Kimi K2 Thinking is Moonshot AI’s most advanced open reasoning model to date, extending the K2 series into agentic, long-horizon reasoning. Built on the trillion-parameter Mixture-of-Experts (MoE) architecture introduced in Kimi K2, it activates 32 billion parameters per forward pass and supports 256 k-token context windows. The model is optimized for persistent step-by-step thought, dynamic tool invocation, and complex reasoning workflows that span hundreds of turns. It interleaves step-by-step reasoning with tool use, enabling autonomous research, coding, and writing that can persist for hundreds of sequential actions without drift.\n\nIt sets new open-source benchmarks on HLE, BrowseComp, SWE-Multilingual, and LiveCodeBench, while maintaining stable multi-agent behavior through 200–300 tool calls. Built on a large-scale MoE architecture with MuonClip optimization, it combines strong reasoning depth with high inference efficiency for demanding agentic and analytical tasks.",
+      "provider": "Moonshotai",
       "category": "reasoning",
-      "priority": 3,
-      "pricing": {
-        "input": "$0.20/1M",
-        "output": "$1.50/1M",
-        "average": "$0.85/1M"
-      },
-      "context": "256K",
-      "maxOutputTokens": 10000,
-      "modality": "text->text",
-      "supportsTools": true,
-      "supportsReasoning": true,
-      "supportsVision": false,
-      "isModerated": false,
-      "recommended": true
-    },
-    {
-      "id": "minimax/minimax-m2",
-      "name": "MiniMax: MiniMax M2",
-      "description": "MiniMax-M2 is a compact, high-efficiency large language model optimized for end-to-end coding and agentic workflows. With 10 billion activated parameters (230 billion total), it delivers near-frontier intelligence across general reasoning, tool use, and multi-step task execution while maintaining low latency and deployment efficiency.\n\nThe model excels in code generation, multi-file editing, compile-run-fix loops, and test-validated repair, showing strong results on SWE-Bench Verified, Multi-SWE-Bench, and Terminal-Bench. It also performs competitively in agentic evaluations such as BrowseComp and GAIA, effectively handling long-horizon planning, retrieval, and recovery from execution errors.\n\nBenchmarked by [Artificial Analysis](https://artificialanalysis.ai/models/minimax-m2), MiniMax-M2 ranks among the top open-source models for composite intelligence, spanning mathematics, science, and instruction-following. Its small activation footprint enables fast inference, high concurrency, and improved unit economics, making it well-suited for large-scale agents, developer assistants, and reasoning-driven applications that require responsiveness and cost efficiency.\n\nTo avoid degrading this model's performance, MiniMax highly recommends preserving reasoning between turns. Learn more about using reasoning_details to pass back reasoning in our [docs](https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks).",
-      "provider": "Minimax",
-      "category": "reasoning",
-      "priority": 4,
+      "priority": 6,
       "pricing": {
-        "input": "$0.20/1M",
-        "output": "$1.00/1M",
-        "average": "$0.60/1M"
+        "input": "$0.40/1M",
+        "output": "$1.75/1M",
+        "average": "$1.07/1M"
       },
-      "context": "196K",
-      "maxOutputTokens": 65536,
+      "context": "262K",
+      "maxOutputTokens": 65535,
       "modality": "text->text",
       "supportsTools": true,
       "supportsReasoning": true,
@@ -88,18 +130,18 @@
       "recommended": true
     },
     {
-      "id": "z-ai/glm-4.6",
-      "name": "Z.AI: GLM 4.6",
-      "description": "Compared with GLM-4.5, this generation brings several key improvements:\n\nLonger context window: The context window has been expanded from 128K to 200K tokens, enabling the model to handle more complex agentic tasks.\nSuperior coding performance: The model achieves higher scores on code benchmarks and demonstrates better real-world performance in applications such as Claude Code、Cline、Roo Code and Kilo Code, including improvements in generating visually polished front-end pages.\nAdvanced reasoning: GLM-4.6 shows a clear improvement in reasoning performance and supports tool use during inference, leading to stronger overall capability.\nMore capable agents: GLM-4.6 exhibits stronger performance in tool using and search-based agents, and integrates more effectively within agent frameworks.\nRefined writing: Better aligns with human preferences in style and readability, and performs more naturally in role-playing scenarios.",
-      "provider": "Z-ai",
+      "id": "deepseek/deepseek-v3.2",
+      "name": "DeepSeek: DeepSeek V3.2",
+      "description": "DeepSeek-V3.2 is a large language model designed to harmonize high computational efficiency with strong reasoning and agentic tool-use performance. It introduces DeepSeek Sparse Attention (DSA), a fine-grained sparse attention mechanism that reduces training and inference cost while preserving quality in long-context scenarios. A scalable reinforcement learning post-training framework further improves reasoning, with reported performance in the GPT-5 class, and the model has demonstrated gold-medal results on the 2025 IMO and IOI. V3.2 also uses a large-scale agentic task synthesis pipeline to better integrate reasoning into tool-use settings, boosting compliance and generalization in interactive environments.\n\nUsers can control the reasoning behaviour with the `reasoning` `enabled` boolean. [Learn more in our docs](https://openrouter.ai/docs/use-cases/reasoning-tokens#enable-reasoning-with-default-config)",
+      "provider": "Deepseek",
       "category": "reasoning",
-      "priority": 5,
+      "priority": 7,
       "pricing": {
-        "input": "$0.35/1M",
-        "output": "$1.50/1M",
-        "average": "$0.93/1M"
+        "input": "$0.25/1M",
+        "output": "$0.38/1M",
+        "average": "$0.32/1M"
       },
-      "context": "202K",
+      "context": "163K",
       "maxOutputTokens": 65536,
       "modality": "text->text",
       "supportsTools": true,
@@ -109,22 +151,22 @@
       "recommended": true
     },
     {
-      "id": "qwen/qwen3-vl-235b-a22b-instruct",
-      "name": "Qwen: Qwen3 VL 235B A22B Instruct",
-      "description": "Qwen3-VL-235B-A22B Instruct is an open-weight multimodal model that unifies strong text generation with visual understanding across images and video. The Instruct model targets general vision-language use (VQA, document parsing, chart/table extraction, multilingual OCR). The series emphasizes robust perception (recognition of diverse real-world and synthetic categories), spatial understanding (2D/3D grounding), and long-form visual comprehension, with competitive results on public multimodal benchmarks for both perception and reasoning.\n\nBeyond analysis, Qwen3-VL supports agentic interaction and tool use: it can follow complex instructions over multi-image, multi-turn dialogues; align text to video timelines for precise temporal queries; and operate GUI elements for automation tasks. The models also enable visual coding workflows—turning sketches or mockups into code and assisting with UI debugging—while maintaining strong text-only performance comparable to the flagship Qwen3 language models. This makes Qwen3-VL suitable for production scenarios spanning document AI, multilingual OCR, software/UI assistance, spatial/embodied tasks, and research on vision-language agents.",
+      "id": "qwen/qwen3-vl-235b-a22b-thinking",
+      "name": "Qwen: Qwen3 VL 235B A22B Thinking",
+      "description": "Qwen3-VL-235B-A22B Thinking is a multimodal model that unifies strong text generation with visual understanding across images and video. The Thinking model is optimized for multimodal reasoning in STEM and math. The series emphasizes robust perception (recognition of diverse real-world and synthetic categories), spatial understanding (2D/3D grounding), and long-form visual comprehension, with competitive results on public multimodal benchmarks for both perception and reasoning.\n\nBeyond analysis, Qwen3-VL supports agentic interaction and tool use: it can follow complex instructions over multi-image, multi-turn dialogues; align text to video timelines for precise temporal queries; and operate GUI elements for automation tasks. The models also enable visual coding workflows, turning sketches or mockups into code and assisting with UI debugging, while maintaining strong text-only performance comparable to the flagship Qwen3 language models. This makes Qwen3-VL suitable for production scenarios spanning document AI, multilingual OCR, software/UI assistance, spatial/embodied tasks, and research on vision-language agents.",
       "provider": "Qwen",
       "category": "vision",
-      "priority": 6,
+      "priority": 8,
       "pricing": {
-        "input": "$0.20/1M",
-        "output": "$1.20/1M",
-        "average": "$0.70/1M"
+        "input": "$0.45/1M",
+        "output": "$3.50/1M",
+        "average": "$1.98/1M"
       },
       "context": "262K",
-      "maxOutputTokens": null,
+      "maxOutputTokens": 262144,
       "modality": "text+image->text",
       "supportsTools": true,
-      "supportsReasoning": false,
+      "supportsReasoning": true,
       "supportsVision": true,
       "isModerated": false,
       "recommended": true

package/scripts/extract-models.ts

@@ -9,94 +9,92 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 interface ModelInfo {
-	name: string;
-	description: string;
-	priority: number;
-	provider: string;
+  name: string;
+  description: string;
+  priority: number;
+  provider: string;
 }
 
 interface ExtractedModels {
-	[key: string]: ModelInfo;
+  [key: string]: ModelInfo;
 }
 
 function extractModels(markdownContent: string): ExtractedModels {
-	const models: ExtractedModels = {};
-	let priority = 1;
-
-	// Extract from Quick Reference section (lines 11-30)
-	const quickRefMatch = markdownContent.match(
-		/## Quick Reference - Model IDs Only\n\n([\s\S]*?)\n---/,
-	);
-	if (!quickRefMatch) {
-		throw new Error("Could not find Quick Reference section");
-	}
-
-	const quickRef = quickRefMatch[1];
-	const lines = quickRef.split("\n");
-
-	for (const line of lines) {
-		// Match pattern: - `model-id` - Description (may contain commas), $price/1M or FREE, contextK/M [⭐]
-		// Use non-greedy match and look for $ or FREE to find the price section
-		const match = line.match(
-			/^- `([^`]+)` - (.+?), (?:\$[\d.]+\/1M|FREE), ([\dKM]+)(?: ⭐)?$/,
-		);
-		if (match) {
-			const [, modelId, description] = match;
-
-			// Determine provider from model ID
-			let provider = "Unknown";
-			if (modelId.startsWith("x-ai/")) provider = "xAI";
-			else if (modelId.startsWith("minimax/")) provider = "MiniMax";
-			else if (modelId.startsWith("z-ai/")) provider = "Zhipu AI";
-			else if (modelId.startsWith("openai/")) provider = "OpenAI";
-			else if (modelId.startsWith("google/")) provider = "Google";
-			else if (modelId.startsWith("qwen/")) provider = "Alibaba";
-			else if (modelId.startsWith("deepseek/")) provider = "DeepSeek";
-			else if (modelId.startsWith("tngtech/")) provider = "TNG Tech";
-			else if (modelId.startsWith("openrouter/")) provider = "OpenRouter";
-			else if (modelId.startsWith("anthropic/")) provider = "Anthropic";
-
-			// Extract short name from description
-			const name = description.trim();
-
-			models[modelId] = {
-				name,
-				description: description.trim(),
-				priority: priority++,
-				provider,
-			};
-		}
-	}
-
-	// Add custom option
-	models.custom = {
-		name: "Custom Model",
-		description: "Enter any OpenRouter model ID manually",
-		priority: 999,
-		provider: "Custom",
-	};
-
-	return models;
+  const models: ExtractedModels = {};
+  let priority = 1;
+
+  // Extract from Quick Reference section (lines 11-30)
+  const quickRefMatch = markdownContent.match(
+    /## Quick Reference - Model IDs Only\n\n([\s\S]*?)\n---/
+  );
+  if (!quickRefMatch) {
+    throw new Error("Could not find Quick Reference section");
+  }
+
+  const quickRef = quickRefMatch[1];
+  const lines = quickRef.split("\n");
+
+  for (const line of lines) {
+    // Match pattern: - `model-id` - Description (may contain commas), $price/1M or FREE, contextK/M [⭐]
+    // Use non-greedy match and look for $ or FREE to find the price section
+    const match = line.match(/^- `([^`]+)` - (.+?), (?:\$[\d.]+\/1M|FREE), ([\dKM]+)(?: ⭐)?$/);
+    if (match) {
+      const [, modelId, description] = match;
+
+      // Determine provider from model ID
+      let provider = "Unknown";
+      if (modelId.startsWith("x-ai/")) provider = "xAI";
+      else if (modelId.startsWith("minimax/")) provider = "MiniMax";
+      else if (modelId.startsWith("z-ai/")) provider = "Zhipu AI";
+      else if (modelId.startsWith("openai/")) provider = "OpenAI";
+      else if (modelId.startsWith("google/")) provider = "Google";
+      else if (modelId.startsWith("qwen/")) provider = "Alibaba";
+      else if (modelId.startsWith("deepseek/")) provider = "DeepSeek";
+      else if (modelId.startsWith("tngtech/")) provider = "TNG Tech";
+      else if (modelId.startsWith("openrouter/")) provider = "OpenRouter";
+      else if (modelId.startsWith("anthropic/")) provider = "Anthropic";
+
+      // Extract short name from description
+      const name = description.trim();
+
+      models[modelId] = {
+        name,
+        description: description.trim(),
+        priority: priority++,
+        provider,
+      };
+    }
+  }
+
+  // Add custom option
+  models.custom = {
+    name: "Custom Model",
+    description: "Enter any OpenRouter model ID manually",
+    priority: 999,
+    provider: "Custom",
+  };
+
+  return models;
 }
 
 function generateTypeScript(models: ExtractedModels): string {
-	const modelIds = Object.keys(models)
-		.filter((id) => id !== "custom")
-		.map((id) => `  | "${id}"`)
-		.join("\n");
-
-	const modelInfo = Object.entries(models)
-		.map(([id, info]) => {
-			return `  "${id}": {
+  const modelIds = Object.keys(models)
+    .filter((id) => id !== "custom")
+    .map((id) => `  | "${id}"`)
+    .join("\n");
+
+  const modelInfo = Object.entries(models)
+    .map(([id, info]) => {
+      return `  "${id}": {
     name: "${info.name}",
     description: "${info.description}",
     priority: ${info.priority},
     provider: "${info.provider}",
   }`;
-		})
-		.join(",\n");
+    })
+    .join(",\n");
 
-	return `// AUTO-GENERATED from shared/recommended-models.md
+  return `// AUTO-GENERATED from shared/recommended-models.md
 // DO NOT EDIT MANUALLY - Run 'bun run extract-models' to regenerate
 
 import type { OpenRouterModel } from "./types.js";
@@ -142,12 +140,12 @@ export const OPENROUTER_HEADERS = {
 }
 
 function generateTypes(models: ExtractedModels): string {
-	const modelIds = Object.keys(models)
-		.filter((id) => id !== "custom")
-		.map((id) => `  "${id}"`)
-		.join(",\n");
+  const modelIds = Object.keys(models)
+    .filter((id) => id !== "custom")
+    .map((id) => `  "${id}"`)
+    .join(",\n");
 
-	return `// AUTO-GENERATED from shared/recommended-models.md
+  return `// AUTO-GENERATED from shared/recommended-models.md
 // DO NOT EDIT MANUALLY - Run 'bun run extract-models' to regenerate
 
 // OpenRouter Models - Top Recommended for Development (Priority Order)
@@ -162,58 +160,55 @@ export type OpenRouterModel = (typeof OPENROUTER_MODELS)[number];
 
 // Main execution
 try {
-	const sharedModelsPath = join(
-		import.meta.dir,
-		"../../../shared/recommended-models.md",
-	);
-	const configPath = join(import.meta.dir, "../src/config.ts");
-	const typesPath = join(import.meta.dir, "../src/types.ts");
-
-	console.log("📖 Reading shared/recommended-models.md...");
-	const markdownContent = readFileSync(sharedModelsPath, "utf-8");
-
-	console.log("🔍 Extracting model information...");
-	const models = extractModels(markdownContent);
-
-	console.log(`✅ Found ${Object.keys(models).length - 1} models + custom option`);
-
-	console.log("📝 Generating config.ts...");
-	const configCode = generateTypeScript(models);
-	writeFileSync(configPath, configCode);
-
-	console.log("📝 Generating types.ts...");
-	const typesCode = generateTypes(models);
-	const existingTypes = readFileSync(typesPath, "utf-8");
-
-	// Replace OPENROUTER_MODELS array and OpenRouterModel type, keep other types
-	// Handle both auto-generated and manual versions
-	let updatedTypes = existingTypes;
-
-	// Try to replace auto-generated section first
-	if (existingTypes.includes("// AUTO-GENERATED")) {
-		updatedTypes = existingTypes.replace(
-			/\/\/ AUTO-GENERATED[\s\S]*?export type OpenRouterModel = \(typeof OPENROUTER_MODELS\)\[number\];/,
-			typesCode.trim(),
-		);
-	} else {
-		// First time - replace manual OPENROUTER_MODELS section
-		updatedTypes = existingTypes.replace(
-			/\/\/ OpenRouter Models[\s\S]*?export type OpenRouterModel = \(typeof OPENROUTER_MODELS\)\[number\];/,
-			typesCode.trim(),
-		);
-	}
-
-	writeFileSync(typesPath, updatedTypes);
-
-	console.log("✅ Successfully generated TypeScript files");
-	console.log("");
-	console.log("Models:");
-	for (const [id, info] of Object.entries(models)) {
-		if (id !== "custom") {
-			console.log(`  • ${id} - ${info.name} (${info.provider})`);
-		}
-	}
+  const sharedModelsPath = join(import.meta.dir, "../../../shared/recommended-models.md");
+  const configPath = join(import.meta.dir, "../src/config.ts");
+  const typesPath = join(import.meta.dir, "../src/types.ts");
+
+  console.log("📖 Reading shared/recommended-models.md...");
+  const markdownContent = readFileSync(sharedModelsPath, "utf-8");
+
+  console.log("🔍 Extracting model information...");
+  const models = extractModels(markdownContent);
+
+  console.log(`✅ Found ${Object.keys(models).length - 1} models + custom option`);
+
+  console.log("📝 Generating config.ts...");
+  const configCode = generateTypeScript(models);
+  writeFileSync(configPath, configCode);
+
+  console.log("📝 Generating types.ts...");
+  const typesCode = generateTypes(models);
+  const existingTypes = readFileSync(typesPath, "utf-8");
+
+  // Replace OPENROUTER_MODELS array and OpenRouterModel type, keep other types
+  // Handle both auto-generated and manual versions
+  let updatedTypes = existingTypes;
+
+  // Try to replace auto-generated section first
+  if (existingTypes.includes("// AUTO-GENERATED")) {
+    updatedTypes = existingTypes.replace(
+      /\/\/ AUTO-GENERATED[\s\S]*?export type OpenRouterModel = \(typeof OPENROUTER_MODELS\)\[number\];/,
+      typesCode.trim()
+    );
+  } else {
+    // First time - replace manual OPENROUTER_MODELS section
+    updatedTypes = existingTypes.replace(
+      /\/\/ OpenRouter Models[\s\S]*?export type OpenRouterModel = \(typeof OPENROUTER_MODELS\)\[number\];/,
+      typesCode.trim()
+    );
+  }
+
+  writeFileSync(typesPath, updatedTypes);
+
+  console.log("✅ Successfully generated TypeScript files");
+  console.log("");
+  console.log("Models:");
+  for (const [id, info] of Object.entries(models)) {
+    if (id !== "custom") {
+      console.log(`  • ${id} - ${info.name} (${info.provider})`);
+    }
+  }
 } catch (error) {
-	console.error("❌ Error:", error);
-	process.exit(1);
+  console.error("❌ Error:", error);
+  process.exit(1);
 }

package/scripts/postinstall.cjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
-console.log('\x1b[32m✓ Claudish installed successfully!\x1b[0m');
-console.log('');
-console.log('\x1b[1mUsage:\x1b[0m');
+console.log("\x1b[32m✓ Claudish installed successfully!\x1b[0m");
+console.log("");
+console.log("\x1b[1mUsage:\x1b[0m");
 console.log('  claudish --model x-ai/grok-code-fast-1 "your prompt"');
-console.log('  claudish --interactive  # Interactive model selection');
-console.log('  claudish --list-models  # List all available models');
-console.log('');
-console.log('\x1b[1mGet started:\x1b[0m');
-console.log('  1. Set OPENROUTER_API_KEY environment variable');
-console.log('  2. Run: claudish --interactive');
-console.log('');
+console.log("  claudish --interactive  # Interactive model selection");
+console.log("  claudish --list-models  # List all available models");
+console.log("");
+console.log("\x1b[1mGet started:\x1b[0m");
+console.log("  1. Set OPENROUTER_API_KEY environment variable");
+console.log("  2. Run: claudish --interactive");
+console.log("");