claudish 1.8.0 → 2.0.0

package/dist/index.js

@@ -331,14 +331,14 @@ function getAvailableModels() {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync, copyFileSync } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { dirname as dirname2, join as join3 } from "node:path";
 var __filename3 = fileURLToPath2(import.meta.url);
 var __dirname3 = dirname2(__filename3);
 var packageJson = JSON.parse(readFileSync2(join3(__dirname3, "../package.json"), "utf-8"));
 var VERSION = packageJson.version;
-function parseArgs(args) {
+async function parseArgs(args) {
   const config = {
     model: undefined,
     autoApprove: true,
@@ -429,8 +429,16 @@ function parseArgs(args) {
     } else if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
+    } else if (arg === "--help-ai") {
+      printAIAgentGuide();
+      process.exit(0);
+    } else if (arg === "--init") {
+      await initializeClaudishSkill();
+      process.exit(0);
     } else if (arg === "--list-models") {
       const hasJsonFlag = args.includes("--json");
+      const forceUpdate = args.includes("--force-update");
+      await checkAndUpdateModelsCache(forceUpdate);
       if (hasJsonFlag) {
         printAvailableModelsJSON();
       } else {
@@ -483,6 +491,164 @@ function parseArgs(args) {
   }
   return config;
 }
+var CACHE_MAX_AGE_DAYS = 2;
+var MODELS_JSON_PATH = join3(__dirname3, "../recommended-models.json");
+function isCacheStale() {
+  if (!existsSync2(MODELS_JSON_PATH)) {
+    return true;
+  }
+  try {
+    const jsonContent = readFileSync2(MODELS_JSON_PATH, "utf-8");
+    const data = JSON.parse(jsonContent);
+    if (!data.lastUpdated) {
+      return true;
+    }
+    const lastUpdated = new Date(data.lastUpdated);
+    const now = new Date;
+    const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
+    return ageInDays > CACHE_MAX_AGE_DAYS;
+  } catch (error) {
+    return true;
+  }
+}
+async function updateModelsFromOpenRouter() {
+  console.error("\uD83D\uDD04 Updating model recommendations from OpenRouter...");
+  try {
+    const topWeeklyProgrammingModels = [
+      "x-ai/grok-code-fast-1",
+      "anthropic/claude-sonnet-4.5",
+      "google/gemini-2.5-flash",
+      "minimax/minimax-m2",
+      "anthropic/claude-sonnet-4",
+      "z-ai/glm-4.6",
+      "anthropic/claude-haiku-4.5",
+      "openai/gpt-5",
+      "qwen/qwen3-vl-235b-a22b-instruct",
+      "openrouter/polaris-alpha"
+    ];
+    const apiResponse = await fetch("https://openrouter.ai/api/v1/models");
+    if (!apiResponse.ok) {
+      throw new Error(`OpenRouter API returned ${apiResponse.status}`);
+    }
+    const openrouterData = await apiResponse.json();
+    const allModels = openrouterData.data;
+    const modelMap = new Map;
+    for (const model of allModels) {
+      modelMap.set(model.id, model);
+    }
+    const recommendations = [];
+    const providers = new Set;
+    for (const modelId of topWeeklyProgrammingModels) {
+      const provider = modelId.split("/")[0];
+      if (provider === "anthropic") {
+        continue;
+      }
+      if (providers.has(provider)) {
+        continue;
+      }
+      const model = modelMap.get(modelId);
+      if (!model) {
+        console.error(`⚠️  Model ${modelId} not found in OpenRouter API (including with limited metadata)`);
+        recommendations.push({
+          id: modelId,
+          name: modelId.split("/")[1].replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()),
+          description: `${modelId} (metadata pending - not yet available in API)`,
+          provider: provider.charAt(0).toUpperCase() + provider.slice(1),
+          category: "programming",
+          priority: recommendations.length + 1,
+          pricing: {
+            input: "N/A",
+            output: "N/A",
+            average: "N/A"
+          },
+          context: "N/A",
+          maxOutputTokens: null,
+          modality: "text->text",
+          supportsTools: false,
+          supportsReasoning: false,
+          supportsVision: false,
+          isModerated: false,
+          recommended: true
+        });
+        providers.add(provider);
+        continue;
+      }
+      const name = model.name || modelId;
+      const description = model.description || `${name} model`;
+      const architecture = model.architecture || {};
+      const topProvider = model.top_provider || {};
+      const supportedParams = model.supported_parameters || [];
+      const promptPrice = parseFloat(model.pricing?.prompt || "0");
+      const completionPrice = parseFloat(model.pricing?.completion || "0");
+      const inputPrice = promptPrice > 0 ? `$${(promptPrice * 1e6).toFixed(2)}/1M` : "FREE";
+      const outputPrice = completionPrice > 0 ? `$${(completionPrice * 1e6).toFixed(2)}/1M` : "FREE";
+      const avgPrice = promptPrice > 0 || completionPrice > 0 ? `$${((promptPrice + completionPrice) / 2 * 1e6).toFixed(2)}/1M` : "FREE";
+      let category = "programming";
+      const lowerDesc = description.toLowerCase() + " " + name.toLowerCase();
+      if (lowerDesc.includes("vision") || lowerDesc.includes("vl-") || lowerDesc.includes("multimodal")) {
+        category = "vision";
+      } else if (lowerDesc.includes("reason")) {
+        category = "reasoning";
+      }
+      recommendations.push({
+        id: modelId,
+        name,
+        description,
+        provider: provider.charAt(0).toUpperCase() + provider.slice(1),
+        category,
+        priority: recommendations.length + 1,
+        pricing: {
+          input: inputPrice,
+          output: outputPrice,
+          average: avgPrice
+        },
+        context: topProvider.context_length ? `${Math.floor(topProvider.context_length / 1000)}K` : "N/A",
+        maxOutputTokens: topProvider.max_completion_tokens || null,
+        modality: architecture.modality || "text->text",
+        supportsTools: supportedParams.includes("tools") || supportedParams.includes("tool_choice"),
+        supportsReasoning: supportedParams.includes("reasoning") || supportedParams.includes("include_reasoning"),
+        supportsVision: (architecture.input_modalities || []).includes("image") || (architecture.input_modalities || []).includes("video"),
+        isModerated: topProvider.is_moderated || false,
+        recommended: true
+      });
+      providers.add(provider);
+    }
+    let version = "1.1.5";
+    if (existsSync2(MODELS_JSON_PATH)) {
+      try {
+        const existing = JSON.parse(readFileSync2(MODELS_JSON_PATH, "utf-8"));
+        version = existing.version || version;
+      } catch {}
+    }
+    const updatedData = {
+      version,
+      lastUpdated: new Date().toISOString().split("T")[0],
+      source: "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
+      models: recommendations
+    };
+    writeFileSync2(MODELS_JSON_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
+    console.error(`✅ Updated ${recommendations.length} models (last updated: ${updatedData.lastUpdated})`);
+  } catch (error) {
+    console.error(`❌ Failed to update models: ${error instanceof Error ? error.message : String(error)}`);
+    console.error("   Using cached models (if available)");
+  }
+}
+async function checkAndUpdateModelsCache(forceUpdate = false) {
+  if (forceUpdate) {
+    console.error("\uD83D\uDD04 Force update requested...");
+    await updateModelsFromOpenRouter();
+    return;
+  }
+  if (isCacheStale()) {
+    console.error("⚠️  Model cache is stale (>2 days old), updating...");
+    await updateModelsFromOpenRouter();
+  } else {
+    try {
+      const data = JSON.parse(readFileSync2(MODELS_JSON_PATH, "utf-8"));
+      console.error(`✓ Using cached models (last updated: ${data.lastUpdated})`);
+    } catch {}
+  }
+}
 function printVersion() {
   console.log(`claudish version ${VERSION}`);
 }
@@ -510,10 +676,13 @@ OPTIONS:
   --cost-tracker           Enable cost tracking for API usage (NB!)
   --audit-costs            Show cost analysis report
   --reset-costs            Reset accumulated cost statistics
-  --list-models            List available OpenRouter models
+  --list-models            List available OpenRouter models (auto-updates if stale >2 days)
   --list-models --json     Output model list in JSON format
+  --force-update           Force refresh model cache from OpenRouter API
   --version                Show version information
   -h, --help               Show this help message
+  --help-ai                Show AI agent usage guide (file-based patterns, sub-agents)
+  --init                   Install Claudish skill in current project (.claude/skills/)
 
 MODES:
   • Interactive mode (default): Shows model selector, starts persistent session
@@ -574,29 +743,156 @@ EXAMPLES:
   claudish --verbose "analyze code structure"
 
 AVAILABLE MODELS:
-  Run: claudish --list-models
+  List models: claudish --list-models
   JSON output: claudish --list-models --json
+  Force update: claudish --list-models --force-update
+  (Cache auto-updates every 2 days)
 
 MORE INFO:
   GitHub: https://github.com/MadAppGang/claude-code
   OpenRouter: https://openrouter.ai
 `);
 }
+function printAIAgentGuide() {
+  try {
+    const guidePath = join3(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync2(guidePath, "utf-8");
+    console.log(guideContent);
+  } catch (error) {
+    console.error("Error reading AI Agent Guide:");
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(`
+The guide should be located at: AI_AGENT_GUIDE.md`);
+    console.error("You can also view it online at:");
+    console.error("https://github.com/MadAppGang/claude-code/blob/main/mcp/claudish/AI_AGENT_GUIDE.md");
+    process.exit(1);
+  }
+}
+async function initializeClaudishSkill() {
+  console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
+`);
+  const cwd = process.cwd();
+  const claudeDir = join3(cwd, ".claude");
+  const skillsDir = join3(claudeDir, "skills");
+  const claudishSkillDir = join3(skillsDir, "claudish-usage");
+  const skillFile = join3(claudishSkillDir, "SKILL.md");
+  if (existsSync2(skillFile)) {
+    console.log("✅ Claudish skill already installed at:");
+    console.log(`   ${skillFile}
+`);
+    console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
+    return;
+  }
+  const sourceSkillPath = join3(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync2(sourceSkillPath)) {
+    console.error("❌ Error: Claudish skill file not found in installation.");
+    console.error(`   Expected at: ${sourceSkillPath}`);
+    console.error(`
+\uD83D\uDCA1 Try reinstalling Claudish:`);
+    console.error("   npm install -g claudish@latest");
+    process.exit(1);
+  }
+  try {
+    if (!existsSync2(claudeDir)) {
+      mkdirSync(claudeDir, { recursive: true });
+      console.log("\uD83D\uDCC1 Created .claude/ directory");
+    }
+    if (!existsSync2(skillsDir)) {
+      mkdirSync(skillsDir, { recursive: true });
+      console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
+    }
+    if (!existsSync2(claudishSkillDir)) {
+      mkdirSync(claudishSkillDir, { recursive: true });
+      console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
+    }
+    copyFileSync(sourceSkillPath, skillFile);
+    console.log("✅ Installed Claudish skill at:");
+    console.log(`   ${skillFile}
+`);
+    console.log("━".repeat(60));
+    console.log(`
+\uD83C\uDF89 Claudish skill installed successfully!
+`);
+    console.log(`\uD83D\uDCCB Next steps:
+`);
+    console.log("1. Reload Claude Code to discover the skill");
+    console.log("   - Restart Claude Code, or");
+    console.log(`   - Re-open your project
+`);
+    console.log("2. Use Claudish with external models:");
+    console.log('   - User: "use Grok to implement feature X"');
+    console.log(`   - Claude will automatically use the skill
+`);
+    console.log("\uD83D\uDCA1 The skill enforces best practices:");
+    console.log("   ✅ Mandatory sub-agent delegation");
+    console.log("   ✅ File-based instruction patterns");
+    console.log(`   ✅ Context window protection
+`);
+    console.log(`\uD83D\uDCD6 For more info: claudish --help-ai
+`);
+    console.log("━".repeat(60));
+  } catch (error) {
+    console.error(`
+❌ Error installing Claudish skill:`);
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(`
+\uD83D\uDCA1 Make sure you have write permissions in the current directory.`);
+    process.exit(1);
+  }
+}
 function printAvailableModels() {
+  let lastUpdated = "unknown";
+  let models = [];
+  try {
+    if (existsSync2(MODELS_JSON_PATH)) {
+      const data = JSON.parse(readFileSync2(MODELS_JSON_PATH, "utf-8"));
+      lastUpdated = data.lastUpdated || "unknown";
+      models = data.models || [];
+    }
+  } catch {
+    const basicModels = getAvailableModels();
+    const modelInfo = loadModelInfo();
+    for (const model of basicModels) {
+      const info = modelInfo[model];
+      console.log(`  ${model}`);
+      console.log(`    ${info.name} - ${info.description}`);
+      console.log("");
+    }
+    return;
+  }
   console.log(`
-Available OpenRouter Models (in priority order):
+Available OpenRouter Models (last updated: ${lastUpdated}):
 `);
-  const models = getAvailableModels();
-  const modelInfo = loadModelInfo();
+  console.log("  Model                          Provider    Pricing     Context  Capabilities");
+  console.log("  " + "─".repeat(86));
   for (const model of models) {
-    const info = modelInfo[model];
-    console.log(`  ${model}`);
-    console.log(`    ${info.name} - ${info.description}`);
-    console.log("");
-  }
+    const modelId = model.id.length > 30 ? model.id.substring(0, 27) + "..." : model.id;
+    const modelIdPadded = modelId.padEnd(30);
+    const provider = model.provider.length > 10 ? model.provider.substring(0, 7) + "..." : model.provider;
+    const providerPadded = provider.padEnd(10);
+    let pricing = model.pricing?.average || "N/A";
+    if (pricing.includes("-1000000")) {
+      pricing = "varies";
+    } else if (pricing === "$0.00/1M" || pricing === "FREE") {
+      pricing = "FREE";
+    }
+    const pricingPadded = pricing.padEnd(10);
+    const context = model.context || "N/A";
+    const contextPadded = context.padEnd(7);
+    const tools = model.supportsTools ? "\uD83D\uDD27" : "  ";
+    const reasoning = model.supportsReasoning ? "\uD83E\uDDE0" : "  ";
+    const vision = model.supportsVision ? "\uD83D\uDC41️ " : "  ";
+    const capabilities = `${tools} ${reasoning} ${vision}`;
+    console.log(`  ${modelIdPadded} ${providerPadded} ${pricingPadded} ${contextPadded} ${capabilities}`);
+  }
+  console.log("");
+  console.log("  Capabilities: \uD83D\uDD27 Tools  \uD83E\uDDE0 Reasoning  \uD83D\uDC41️  Vision");
+  console.log("");
   console.log("Set default with: export CLAUDISH_MODEL=<model>");
   console.log("               or: export ANTHROPIC_MODEL=<model>");
-  console.log(`Or use: claudish --model <model> ...
+  console.log("Or use: claudish --model <model> ...");
+  console.log(`
+Force update: claudish --list-models --force-update
 `);
 }
 function printAvailableModelsJSON() {
@@ -776,7 +1072,7 @@ async function selectModelInteractively() {
 }
 
 // src/logger.ts
-import { writeFileSync as writeFileSync2, appendFile, existsSync as existsSync2, mkdirSync } from "fs";
+import { writeFileSync as writeFileSync3, appendFile, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
 import { join as join4 } from "path";
 var logFilePath = null;
 var logLevel = "info";
@@ -807,7 +1103,7 @@ function scheduleFlush() {
       flushTimer = null;
     }
     if (logFilePath && logBuffer.length > 0) {
-      writeFileSync2(logFilePath, logBuffer.join(""), { flag: "a" });
+      writeFileSync3(logFilePath, logBuffer.join(""), { flag: "a" });
       logBuffer = [];
     }
   });
@@ -823,12 +1119,12 @@ function initLogger(debugMode, level = "info") {
   }
   logLevel = level;
   const logsDir = join4(process.cwd(), "logs");
-  if (!existsSync2(logsDir)) {
-    mkdirSync(logsDir, { recursive: true });
+  if (!existsSync3(logsDir)) {
+    mkdirSync2(logsDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
   logFilePath = join4(logsDir, `claudish_${timestamp}.log`);
-  writeFileSync2(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
+  writeFileSync3(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
 Log Level: ${level}
 ${"=".repeat(80)}
 
@@ -3063,7 +3359,7 @@ var serve = (options, listeningListener) => {
 };
 
 // src/proxy-server.ts
-import { writeFileSync as writeFileSync3 } from "node:fs";
+import { writeFileSync as writeFileSync4 } from "node:fs";
 
 // src/transform.ts
 function removeUriFormat(schema) {
@@ -3851,7 +4147,7 @@ data: ${JSON.stringify(data)}
                 total_tokens: cumulativeInputTokens + cumulativeOutputTokens,
                 updated_at: Date.now()
               };
-              writeFileSync3(tokenFilePath, JSON.stringify(tokenData), "utf-8");
+              writeFileSync4(tokenFilePath, JSON.stringify(tokenData), "utf-8");
             } catch (error) {
               if (isLoggingEnabled()) {
                 log(`[Proxy] Failed to write token file: ${error}`);
@@ -4330,7 +4626,7 @@ async function readStdin() {
 }
 async function main() {
   try {
-    const config = parseArgs(process.argv.slice(2));
+    const config = await parseArgs(process.argv.slice(2));
     initLogger(config.debug, config.logLevel);
     if (config.debug && !config.quiet) {
       const logFile = getLogFilePath();

package/package.json

@@ -1,29 +1,12 @@
 {
   "name": "claudish",
-  "version": "1.8.0",
+  "version": "2.0.0",
   "description": "CLI tool to run Claude Code with any OpenRouter model (Grok, GPT-5, MiniMax, etc.) via local Anthropic API-compatible proxy",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
     "claudish": "dist/index.js"
   },
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "dev:grok": "bun run src/index.ts --interactive --model x-ai/grok-code-fast-1",
-    "dev:grok:debug": "bun run src/index.ts --interactive --debug --log-level info --model x-ai/grok-code-fast-1",
-    "dev:info": "bun run src/index.ts --interactive --monitor",
-    "extract-models": "bun run scripts/extract-models.ts",
-    "build": "bun run extract-models && bun build src/index.ts --outdir dist --target node && chmod +x dist/index.js",
-    "link": "npm link",
-    "unlink": "npm unlink -g claudish",
-    "install-global": "bun run build && npm link",
-    "kill-all": "pkill -f 'bun.*claudish' || pkill -f 'claude.*claudish-settings' || echo 'No claudish processes found'",
-    "test": "bun test ./tests/comprehensive-model-test.ts",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check .",
-    "format": "biome format --write .",
-    "postinstall": "node scripts/postinstall.cjs"
-  },
   "dependencies": {
     "@hono/node-server": "^1.19.6",
     "hono": "^4.10.6"
@@ -35,7 +18,10 @@
   },
   "files": [
     "dist/",
-    "scripts/"
+    "scripts/",
+    "skills/",
+    "AI_AGENT_GUIDE.md",
+    "recommended-models.json"
   ],
   "engines": {
     "node": ">=18.0.0",
@@ -51,5 +37,22 @@
     "ai"
   ],
   "author": "Jack Rudenko <i@madappgang.com>",
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "dev:grok": "bun run src/index.ts --interactive --model x-ai/grok-code-fast-1",
+    "dev:grok:debug": "bun run src/index.ts --interactive --debug --log-level info --model x-ai/grok-code-fast-1",
+    "dev:info": "bun run src/index.ts --interactive --monitor",
+    "extract-models": "bun run scripts/extract-models.ts",
+    "build": "bun run extract-models && bun build src/index.ts --outdir dist --target node && chmod +x dist/index.js",
+    "link": "npm link",
+    "unlink": "npm unlink -g claudish",
+    "install-global": "bun run build && npm link",
+    "kill-all": "pkill -f 'bun.*claudish' || pkill -f 'claude.*claudish-settings' || echo 'No claudish processes found'",
+    "test": "bun test ./tests/comprehensive-model-test.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "postinstall": "node scripts/postinstall.cjs"
+  }
+}

package/recommended-models.json

@@ -0,0 +1,154 @@
+{
+  "version": "1.1.5",
+  "lastUpdated": "2025-11-19",
+  "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": "google/gemini-2.5-flash",
+      "name": "Google: Gemini 2.5 Flash",
+      "description": "Gemini 2.5 Flash is Google's state-of-the-art workhorse model, specifically designed for advanced reasoning, coding, mathematics, and scientific tasks. It includes built-in \"thinking\" capabilities, enabling it to provide responses with greater accuracy and nuanced context handling. \n\nAdditionally, Gemini 2.5 Flash is configurable through the \"max tokens for reasoning\" parameter, as described in the documentation (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning).",
+      "provider": "Google",
+      "category": "reasoning",
+      "priority": 2,
+      "pricing": {
+        "input": "$0.30/1M",
+        "output": "$2.50/1M",
+        "average": "$1.40/1M"
+      },
+      "context": "1048K",
+      "maxOutputTokens": 65535,
+      "modality": "text+image->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": true,
+      "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": 3,
+      "pricing": {
+        "input": "$0.26/1M",
+        "output": "$1.02/1M",
+        "average": "$0.64/1M"
+      },
+      "context": "204K",
+      "maxOutputTokens": 131072,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "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",
+      "category": "reasoning",
+      "priority": 4,
+      "pricing": {
+        "input": "$0.40/1M",
+        "output": "$1.75/1M",
+        "average": "$1.07/1M"
+      },
+      "context": "202K",
+      "maxOutputTokens": 202752,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "openai/gpt-5",
+      "name": "OpenAI: GPT-5",
+      "description": "GPT-5 is OpenAI’s most advanced model, offering major improvements in reasoning, code quality, and user experience. It is optimized for complex tasks that require step-by-step reasoning, instruction following, and accuracy in high-stakes use cases. It supports test-time routing features and advanced prompt understanding, including user-specified intent like \"think hard about this.\" Improvements include reductions in hallucination, sycophancy, and better performance in coding, writing, and health-related tasks.",
+      "provider": "Openai",
+      "category": "reasoning",
+      "priority": 5,
+      "pricing": {
+        "input": "$1.25/1M",
+        "output": "$10.00/1M",
+        "average": "$5.63/1M"
+      },
+      "context": "400K",
+      "maxOutputTokens": 128000,
+      "modality": "text+image->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": true,
+      "isModerated": true,
+      "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.",
+      "provider": "Qwen",
+      "category": "vision",
+      "priority": 6,
+      "pricing": {
+        "input": "$0.21/1M",
+        "output": "$1.90/1M",
+        "average": "$1.06/1M"
+      },
+      "context": "131K",
+      "maxOutputTokens": 32768,
+      "modality": "text+image->text",
+      "supportsTools": true,
+      "supportsReasoning": false,
+      "supportsVision": true,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "openrouter/polaris-alpha",
+      "name": "Polaris Alpha",
+      "description": "openrouter/polaris-alpha (metadata pending - not yet available in API)",
+      "provider": "Openrouter",
+      "category": "programming",
+      "priority": 7,
+      "pricing": {
+        "input": "N/A",
+        "output": "N/A",
+        "average": "N/A"
+      },
+      "context": "N/A",
+      "maxOutputTokens": null,
+      "modality": "text->text",
+      "supportsTools": false,
+      "supportsReasoning": false,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    }
+  ]
+}