claudish 2.4.0 → 2.5.0

package/dist/index.js

@@ -1,8 +1,22 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
   var entry = __moduleCache.get(from), desc;
@@ -17,6 +31,7 @@ var __toCommonJS = (from) => {
   __moduleCache.set(from, entry);
   return entry;
 };
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -27,6 +42,402 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/dotenv/package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "dotenv",
+    version: "17.2.3",
+    description: "Loads environment variables from .env file",
+    main: "lib/main.js",
+    types: "lib/main.d.ts",
+    exports: {
+      ".": {
+        types: "./lib/main.d.ts",
+        require: "./lib/main.js",
+        default: "./lib/main.js"
+      },
+      "./config": "./config.js",
+      "./config.js": "./config.js",
+      "./lib/env-options": "./lib/env-options.js",
+      "./lib/env-options.js": "./lib/env-options.js",
+      "./lib/cli-options": "./lib/cli-options.js",
+      "./lib/cli-options.js": "./lib/cli-options.js",
+      "./package.json": "./package.json"
+    },
+    scripts: {
+      "dts-check": "tsc --project tests/types/tsconfig.json",
+      lint: "standard",
+      pretest: "npm run lint && npm run dts-check",
+      test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+      "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+      prerelease: "npm test",
+      release: "standard-version"
+    },
+    repository: {
+      type: "git",
+      url: "git://github.com/motdotla/dotenv.git"
+    },
+    homepage: "https://github.com/motdotla/dotenv#readme",
+    funding: "https://dotenvx.com",
+    keywords: [
+      "dotenv",
+      "env",
+      ".env",
+      "environment",
+      "variables",
+      "config",
+      "settings"
+    ],
+    readmeFilename: "README.md",
+    license: "BSD-2-Clause",
+    devDependencies: {
+      "@types/node": "^18.11.3",
+      decache: "^4.6.2",
+      sinon: "^14.0.1",
+      standard: "^17.0.0",
+      "standard-version": "^9.5.0",
+      tap: "^19.2.0",
+      typescript: "^4.8.4"
+    },
+    engines: {
+      node: ">=12"
+    },
+    browser: {
+      fs: false
+    }
+  };
+});
+
+// node_modules/dotenv/lib/main.js
+var require_main = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var path = __require("path");
+  var os = __require("os");
+  var crypto = __require("crypto");
+  var packageJson = require_package();
+  var version = packageJson.version;
+  var TIPS = [
+    "\uD83D\uDD10 encrypt with Dotenvx: https://dotenvx.com",
+    "\uD83D\uDD10 prevent committing .env to code: https://dotenvx.com/precommit",
+    "\uD83D\uDD10 prevent building .env in docker: https://dotenvx.com/prebuild",
+    "\uD83D\uDCE1 add observability to secrets: https://dotenvx.com/ops",
+    "\uD83D\uDC65 sync secrets across teammates & machines: https://dotenvx.com/ops",
+    "\uD83D\uDDC2️ backup and recover secrets: https://dotenvx.com/ops",
+    "✅ audit secrets and track compliance: https://dotenvx.com/ops",
+    "\uD83D\uDD04 add secrets lifecycle management: https://dotenvx.com/ops",
+    "\uD83D\uDD11 add access controls to secrets: https://dotenvx.com/ops",
+    "\uD83D\uDEE0️  run anywhere with `dotenvx run -- yourcommand`",
+    "⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+    "⚙️  enable debug logging with { debug: true }",
+    "⚙️  override existing env vars with { override: true }",
+    "⚙️  suppress all logs with { quiet: true }",
+    "⚙️  write to custom object with { processEnv: myObject }",
+    "⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+  ];
+  function _getRandomTip() {
+    return TIPS[Math.floor(Math.random() * TIPS.length)];
+  }
+  function parseBoolean(value) {
+    if (typeof value === "string") {
+      return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+    }
+    return Boolean(value);
+  }
+  function supportsAnsi() {
+    return process.stdout.isTTY;
+  }
+  function dim(text) {
+    return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+  }
+  var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+  function parse(src) {
+    const obj = {};
+    let lines = src.toString();
+    lines = lines.replace(/\r\n?/mg, `
+`);
+    let match;
+    while ((match = LINE.exec(lines)) != null) {
+      const key = match[1];
+      let value = match[2] || "";
+      value = value.trim();
+      const maybeQuote = value[0];
+      value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+      if (maybeQuote === '"') {
+        value = value.replace(/\\n/g, `
+`);
+        value = value.replace(/\\r/g, "\r");
+      }
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _parseVault(options) {
+    options = options || {};
+    const vaultPath = _vaultPath(options);
+    options.path = vaultPath;
+    const result = DotenvModule.configDotenv(options);
+    if (!result.parsed) {
+      const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+      err.code = "MISSING_DATA";
+      throw err;
+    }
+    const keys = _dotenvKey(options).split(",");
+    const length = keys.length;
+    let decrypted;
+    for (let i = 0;i < length; i++) {
+      try {
+        const key = keys[i].trim();
+        const attrs = _instructions(result, key);
+        decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+        break;
+      } catch (error) {
+        if (i + 1 >= length) {
+          throw error;
+        }
+      }
+    }
+    return DotenvModule.parse(decrypted);
+  }
+  function _warn(message) {
+    console.error(`[dotenv@${version}][WARN] ${message}`);
+  }
+  function _debug(message) {
+    console.log(`[dotenv@${version}][DEBUG] ${message}`);
+  }
+  function _log(message) {
+    console.log(`[dotenv@${version}] ${message}`);
+  }
+  function _dotenvKey(options) {
+    if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+      return options.DOTENV_KEY;
+    }
+    if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+      return process.env.DOTENV_KEY;
+    }
+    return "";
+  }
+  function _instructions(result, dotenvKey) {
+    let uri;
+    try {
+      uri = new URL(dotenvKey);
+    } catch (error) {
+      if (error.code === "ERR_INVALID_URL") {
+        const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      throw error;
+    }
+    const key = uri.password;
+    if (!key) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environment = uri.searchParams.get("environment");
+    if (!environment) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+    const ciphertext = result.parsed[environmentKey];
+    if (!ciphertext) {
+      const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+      err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+      throw err;
+    }
+    return { ciphertext, key };
+  }
+  function _vaultPath(options) {
+    let possibleVaultPath = null;
+    if (options && options.path && options.path.length > 0) {
+      if (Array.isArray(options.path)) {
+        for (const filepath of options.path) {
+          if (fs.existsSync(filepath)) {
+            possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+          }
+        }
+      } else {
+        possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+      }
+    } else {
+      possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+    }
+    if (fs.existsSync(possibleVaultPath)) {
+      return possibleVaultPath;
+    }
+    return null;
+  }
+  function _resolveHome(envPath) {
+    return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+  }
+  function _configVault(options) {
+    const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+    const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+    if (debug || !quiet) {
+      _log("Loading env from encrypted .env.vault");
+    }
+    const parsed = DotenvModule._parseVault(options);
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    DotenvModule.populate(processEnv, parsed, options);
+    return { parsed };
+  }
+  function configDotenv(options) {
+    const dotenvPath = path.resolve(process.cwd(), ".env");
+    let encoding = "utf8";
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+    let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+    if (options && options.encoding) {
+      encoding = options.encoding;
+    } else {
+      if (debug) {
+        _debug("No encoding is specified. UTF-8 is used by default");
+      }
+    }
+    let optionPaths = [dotenvPath];
+    if (options && options.path) {
+      if (!Array.isArray(options.path)) {
+        optionPaths = [_resolveHome(options.path)];
+      } else {
+        optionPaths = [];
+        for (const filepath of options.path) {
+          optionPaths.push(_resolveHome(filepath));
+        }
+      }
+    }
+    let lastError;
+    const parsedAll = {};
+    for (const path2 of optionPaths) {
+      try {
+        const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+        DotenvModule.populate(parsedAll, parsed, options);
+      } catch (e) {
+        if (debug) {
+          _debug(`Failed to load ${path2} ${e.message}`);
+        }
+        lastError = e;
+      }
+    }
+    const populated = DotenvModule.populate(processEnv, parsedAll, options);
+    debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+    quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+    if (debug || !quiet) {
+      const keysCount = Object.keys(populated).length;
+      const shortPaths = [];
+      for (const filePath of optionPaths) {
+        try {
+          const relative = path.relative(process.cwd(), filePath);
+          shortPaths.push(relative);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${filePath} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+    }
+    if (lastError) {
+      return { parsed: parsedAll, error: lastError };
+    } else {
+      return { parsed: parsedAll };
+    }
+  }
+  function config(options) {
+    if (_dotenvKey(options).length === 0) {
+      return DotenvModule.configDotenv(options);
+    }
+    const vaultPath = _vaultPath(options);
+    if (!vaultPath) {
+      _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+      return DotenvModule.configDotenv(options);
+    }
+    return DotenvModule._configVault(options);
+  }
+  function decrypt(encrypted, keyStr) {
+    const key = Buffer.from(keyStr.slice(-64), "hex");
+    let ciphertext = Buffer.from(encrypted, "base64");
+    const nonce = ciphertext.subarray(0, 12);
+    const authTag = ciphertext.subarray(-16);
+    ciphertext = ciphertext.subarray(12, -16);
+    try {
+      const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+      aesgcm.setAuthTag(authTag);
+      return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+    } catch (error) {
+      const isRange = error instanceof RangeError;
+      const invalidKeyLength = error.message === "Invalid key length";
+      const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+      if (isRange || invalidKeyLength) {
+        const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      } else if (decryptionFailed) {
+        const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+        err.code = "DECRYPTION_FAILED";
+        throw err;
+      } else {
+        throw error;
+      }
+    }
+  }
+  function populate(processEnv, parsed, options = {}) {
+    const debug = Boolean(options && options.debug);
+    const override = Boolean(options && options.override);
+    const populated = {};
+    if (typeof parsed !== "object") {
+      const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+      err.code = "OBJECT_REQUIRED";
+      throw err;
+    }
+    for (const key of Object.keys(parsed)) {
+      if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+        if (override === true) {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+        if (debug) {
+          if (override === true) {
+            _debug(`"${key}" is already defined and WAS overwritten`);
+          } else {
+            _debug(`"${key}" is already defined and was NOT overwritten`);
+          }
+        }
+      } else {
+        processEnv[key] = parsed[key];
+        populated[key] = parsed[key];
+      }
+    }
+    return populated;
+  }
+  var DotenvModule = {
+    configDotenv,
+    _configVault,
+    _parseVault,
+    config,
+    decrypt,
+    parse,
+    populate
+  };
+  exports.configDotenv = DotenvModule.configDotenv;
+  exports._configVault = DotenvModule._configVault;
+  exports._parseVault = DotenvModule._parseVault;
+  exports.config = DotenvModule.config;
+  exports.decrypt = DotenvModule.decrypt;
+  exports.parse = DotenvModule.parse;
+  exports.populate = DotenvModule.populate;
+  module.exports = DotenvModule;
+});
 
 // src/config.ts
 var exports_config = {};
@@ -97,7 +508,15 @@ var init_config = __esm(() => {
     CLAUDISH_PORT: "CLAUDISH_PORT",
     CLAUDISH_ACTIVE_MODEL_NAME: "CLAUDISH_ACTIVE_MODEL_NAME",
     ANTHROPIC_MODEL: "ANTHROPIC_MODEL",
-    ANTHROPIC_SMALL_FAST_MODEL: "ANTHROPIC_SMALL_FAST_MODEL"
+    ANTHROPIC_SMALL_FAST_MODEL: "ANTHROPIC_SMALL_FAST_MODEL",
+    CLAUDISH_MODEL_OPUS: "CLAUDISH_MODEL_OPUS",
+    CLAUDISH_MODEL_SONNET: "CLAUDISH_MODEL_SONNET",
+    CLAUDISH_MODEL_HAIKU: "CLAUDISH_MODEL_HAIKU",
+    CLAUDISH_MODEL_SUBAGENT: "CLAUDISH_MODEL_SUBAGENT",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    CLAUDE_CODE_SUBAGENT_MODEL: "CLAUDE_CODE_SUBAGENT_MODEL"
   };
   OPENROUTER_HEADERS = {
     "HTTP-Referer": "https://github.com/MadAppGang/claude-code",
@@ -124,6 +543,9 @@ var init_types = __esm(() => {
   ];
 });
 
+// src/index.ts
+var import_dotenv = __toESM(require_main(), 1);
+
 // src/claude-runner.ts
 init_config();
 import { spawn } from "node:child_process";
@@ -369,6 +791,18 @@ async function fetchModelContextWindow(modelId) {
   }
   return 200000;
 }
+async function doesModelSupportReasoning(modelId) {
+  if (!_cachedOpenRouterModels) {
+    await fetchModelContextWindow(modelId);
+  }
+  if (_cachedOpenRouterModels) {
+    const model = _cachedOpenRouterModels.find((m) => m.id === modelId);
+    if (model && model.supported_parameters) {
+      return model.supported_parameters.includes("include_reasoning") || model.supported_parameters.includes("reasoning") || model.id.includes("o1") || model.id.includes("o3") || model.id.includes("r1");
+    }
+  }
+  return false;
+}
 
 // src/cli.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync2, mkdirSync, copyFileSync } from "node:fs";
@@ -427,6 +861,7 @@ async function parseArgs(args) {
     jsonOutput: false,
     monitor: false,
     stdin: false,
+    freeOnly: false,
     claudeArgs: []
   };
   const claudishModel = process.env[ENV.CLAUDISH_MODEL];
@@ -436,6 +871,10 @@ async function parseArgs(args) {
   } else if (anthropicModel) {
     config.model = anthropicModel;
   }
+  config.modelOpus = process.env[ENV.CLAUDISH_MODEL_OPUS] || process.env[ENV.ANTHROPIC_DEFAULT_OPUS_MODEL];
+  config.modelSonnet = process.env[ENV.CLAUDISH_MODEL_SONNET] || process.env[ENV.ANTHROPIC_DEFAULT_SONNET_MODEL];
+  config.modelHaiku = process.env[ENV.CLAUDISH_MODEL_HAIKU] || process.env[ENV.ANTHROPIC_DEFAULT_HAIKU_MODEL];
+  config.modelSubagent = process.env[ENV.CLAUDISH_MODEL_SUBAGENT] || process.env[ENV.CLAUDE_CODE_SUBAGENT_MODEL];
   const envPort = process.env[ENV.CLAUDISH_PORT];
   if (envPort) {
     const port = Number.parseInt(envPort, 10);
@@ -454,6 +893,22 @@ async function parseArgs(args) {
         process.exit(1);
       }
       config.model = modelArg;
+    } else if (arg === "--model-opus") {
+      const val = args[++i];
+      if (val)
+        config.modelOpus = val;
+    } else if (arg === "--model-sonnet") {
+      const val = args[++i];
+      if (val)
+        config.modelSonnet = val;
+    } else if (arg === "--model-haiku") {
+      const val = args[++i];
+      if (val)
+        config.modelHaiku = val;
+    } else if (arg === "--model-subagent") {
+      const val = args[++i];
+      if (val)
+        config.modelSubagent = val;
     } else if (arg === "--port" || arg === "-p") {
       const portArg = args[++i];
       if (!portArg) {
@@ -491,6 +946,8 @@ async function parseArgs(args) {
       config.monitor = true;
     } else if (arg === "--stdin") {
       config.stdin = true;
+    } else if (arg === "--free") {
+      config.freeOnly = true;
     } else if (arg === "--cost-tracker") {
       config.costTracking = true;
       if (!config.monitor) {
@@ -512,7 +969,7 @@ async function parseArgs(args) {
     } else if (arg === "--init") {
       await initializeClaudishSkill();
       process.exit(0);
-    } else if (arg === "--list-models") {
+    } else if (arg === "--top-models") {
       const hasJsonFlag = args.includes("--json");
       const forceUpdate = args.includes("--force-update");
       await checkAndUpdateModelsCache(forceUpdate);
@@ -522,14 +979,17 @@ async function parseArgs(args) {
         printAvailableModels();
       }
       process.exit(0);
-    } else if (arg === "--search" || arg === "-s") {
-      const query = args[++i];
-      if (!query) {
-        console.error("--search requires a search term");
-        process.exit(1);
-      }
+    } else if (arg === "--models" || arg === "-s" || arg === "--search") {
+      const nextArg = args[i + 1];
+      const hasQuery = nextArg && !nextArg.startsWith("--");
+      const query = hasQuery ? args[++i] : null;
+      const hasJsonFlag = args.includes("--json");
       const forceUpdate = args.includes("--force-update");
-      await searchAndPrintModels(query, forceUpdate);
+      if (query) {
+        await searchAndPrintModels(query, forceUpdate);
+      } else {
+        await printAllModels(hasJsonFlag, forceUpdate);
+      }
       process.exit(0);
     } else {
       config.claudeArgs = args.slice(i);
@@ -638,7 +1098,14 @@ Found ${results.length} matching models:
     const promptPrice = parseFloat(model.pricing?.prompt || "0") * 1e6;
     const completionPrice = parseFloat(model.pricing?.completion || "0") * 1e6;
     const avg = (promptPrice + completionPrice) / 2;
-    const pricing = avg === 0 ? "FREE" : `$${avg.toFixed(2)}/1M`;
+    let pricing;
+    if (avg < 0) {
+      pricing = "varies";
+    } else if (avg === 0) {
+      pricing = "FREE";
+    } else {
+      pricing = `$${avg.toFixed(2)}/1M`;
+    }
     const pricingPadded = pricing.padEnd(10);
     const contextLen = model.context_length || model.top_provider?.context_length || 0;
     const context = contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A";
@@ -648,6 +1115,98 @@ Found ${results.length} matching models:
   console.log("");
   console.log("Use a model: claudish --model <model-id>");
 }
+async function printAllModels(jsonOutput, forceUpdate) {
+  let models = [];
+  if (!forceUpdate && existsSync2(ALL_MODELS_JSON_PATH)) {
+    try {
+      const cacheData = JSON.parse(readFileSync2(ALL_MODELS_JSON_PATH, "utf-8"));
+      const lastUpdated = new Date(cacheData.lastUpdated);
+      const now = new Date;
+      const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
+      if (ageInDays <= CACHE_MAX_AGE_DAYS) {
+        models = cacheData.models;
+        if (!jsonOutput) {
+          console.error(`✓ Using cached models (last updated: ${cacheData.lastUpdated.split("T")[0]})`);
+        }
+      }
+    } catch (e) {}
+  }
+  if (models.length === 0) {
+    console.error("\uD83D\uDD04 Fetching all models from OpenRouter...");
+    try {
+      const response = await fetch("https://openrouter.ai/api/v1/models");
+      if (!response.ok)
+        throw new Error(`API returned ${response.status}`);
+      const data = await response.json();
+      models = data.data;
+      writeFileSync3(ALL_MODELS_JSON_PATH, JSON.stringify({
+        lastUpdated: new Date().toISOString(),
+        models
+      }), "utf-8");
+      console.error(`✅ Cached ${models.length} models`);
+    } catch (error) {
+      console.error(`❌ Failed to fetch models: ${error}`);
+      process.exit(1);
+    }
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify({
+      count: models.length,
+      lastUpdated: new Date().toISOString().split("T")[0],
+      models: models.map((m) => ({
+        id: m.id,
+        name: m.name,
+        context: m.context_length || m.top_provider?.context_length,
+        pricing: m.pricing
+      }))
+    }, null, 2));
+    return;
+  }
+  const byProvider = new Map;
+  for (const model of models) {
+    const provider = model.id.split("/")[0];
+    if (!byProvider.has(provider)) {
+      byProvider.set(provider, []);
+    }
+    byProvider.get(provider).push(model);
+  }
+  const sortedProviders = [...byProvider.keys()].sort();
+  console.log(`
+All OpenRouter Models (${models.length} total):
+`);
+  for (const provider of sortedProviders) {
+    const providerModels = byProvider.get(provider);
+    console.log(`
+  ${provider.toUpperCase()} (${providerModels.length} models)`);
+    console.log("  " + "─".repeat(70));
+    for (const model of providerModels) {
+      const shortId = model.id.split("/").slice(1).join("/");
+      const modelId = shortId.length > 40 ? shortId.substring(0, 37) + "..." : shortId;
+      const modelIdPadded = modelId.padEnd(42);
+      const promptPrice = parseFloat(model.pricing?.prompt || "0") * 1e6;
+      const completionPrice = parseFloat(model.pricing?.completion || "0") * 1e6;
+      const avg = (promptPrice + completionPrice) / 2;
+      let pricing;
+      if (avg < 0) {
+        pricing = "varies";
+      } else if (avg === 0) {
+        pricing = "FREE";
+      } else {
+        pricing = `$${avg.toFixed(2)}/1M`;
+      }
+      const pricingPadded = pricing.padEnd(12);
+      const contextLen = model.context_length || model.top_provider?.context_length || 0;
+      const context = contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A";
+      const contextPadded = context.padEnd(8);
+      console.log(`    ${modelIdPadded} ${pricingPadded} ${contextPadded}`);
+    }
+  }
+  console.log(`
+`);
+  console.log("Use a model: claudish --model <provider/model-id>");
+  console.log("Search:      claudish --search <query>");
+  console.log("Top models:  claudish --top-models");
+}
 function isCacheStale() {
   if (!existsSync2(MODELS_JSON_PATH)) {
     return true;
@@ -805,20 +1364,29 @@ OPTIONS:
   -v, --verbose            Show [claudish] log messages (default in interactive mode)
   --json                   Output in JSON format for tool integration (implies --quiet)
   --stdin                  Read prompt from stdin (useful for large prompts or piping)
+  --free                   Show only FREE models in the interactive selector
   --monitor                Monitor mode - proxy to REAL Anthropic API and log all traffic
   --no-auto-approve        Disable auto permission skip (prompts enabled)
   --dangerous              Pass --dangerouslyDisableSandbox to Claude Code
   --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 (auto-updates if stale >2 days)
-  --list-models --json     Output model list in JSON format
+  --models                 List ALL OpenRouter models grouped by provider
+  --models <query>         Fuzzy search all models by name, ID, or description
+  --top-models             List recommended/top programming models (curated)
+  --json                   Output in JSON format (use with --models or --top-models)
   --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/)
 
+MODEL MAPPING (per-role override):
+  --model-opus <model>     Model for Opus role (planning, complex tasks)
+  --model-sonnet <model>   Model for Sonnet role (default coding)
+  --model-haiku <model>    Model for Haiku role (fast tasks, background)
+  --model-subagent <model> Model for sub-agents (Task tool)
+
 CUSTOM MODELS:
   Claudish accepts ANY valid OpenRouter model ID, even if not in --list-models
   Example: claudish --model your_provider/custom-model-123 "task"
@@ -834,18 +1402,32 @@ NOTES:
   • Use --dangerous to disable sandbox (use with extreme caution!)
 
 ENVIRONMENT VARIABLES:
+  Claudish automatically loads .env file from current directory.
+
   OPENROUTER_API_KEY              Required: Your OpenRouter API key
   CLAUDISH_MODEL                  Default model to use (takes priority)
-  ANTHROPIC_MODEL                 Claude Code standard: model to use (fallback if CLAUDISH_MODEL not set)
-  ANTHROPIC_SMALL_FAST_MODEL      Claude Code standard: fast model (auto-set by claudish)
+  ANTHROPIC_MODEL                 Claude Code standard: model to use (fallback)
   CLAUDISH_PORT                   Default port for proxy
-  CLAUDISH_ACTIVE_MODEL_NAME      Auto-set by claudish (read-only) - shows active model in status line
+  CLAUDISH_ACTIVE_MODEL_NAME      Auto-set by claudish (read-only) - shows active model
+
+  Model mapping (CLAUDISH_* takes priority over ANTHROPIC_DEFAULT_*):
+  CLAUDISH_MODEL_OPUS             Override model for Opus role
+  CLAUDISH_MODEL_SONNET           Override model for Sonnet role
+  CLAUDISH_MODEL_HAIKU            Override model for Haiku role
+  CLAUDISH_MODEL_SUBAGENT         Override model for sub-agents
+  ANTHROPIC_DEFAULT_OPUS_MODEL    Claude Code standard: Opus model (fallback)
+  ANTHROPIC_DEFAULT_SONNET_MODEL  Claude Code standard: Sonnet model (fallback)
+  ANTHROPIC_DEFAULT_HAIKU_MODEL   Claude Code standard: Haiku model (fallback)
+  CLAUDE_CODE_SUBAGENT_MODEL      Claude Code standard: sub-agent model (fallback)
 
 EXAMPLES:
   # Interactive mode (default) - shows model selector
   claudish
   claudish --interactive
 
+  # Interactive mode with only FREE models
+  claudish --free
+
   # Interactive mode with pre-selected model
   claudish --model x-ai/grok-code-fast-1
 
@@ -853,6 +1435,12 @@ EXAMPLES:
   claudish --model openai/gpt-5-codex "implement user authentication"
   claudish --model x-ai/grok-code-fast-1 "add tests for login"
 
+  # Per-role model mapping (use different models for different Claude Code roles)
+  claudish --model-opus openai/gpt-5 --model-sonnet x-ai/grok-code-fast-1 --model-haiku minimax/minimax-m2
+
+  # Hybrid: Native Anthropic for Opus, OpenRouter for Sonnet/Haiku
+  claudish --model-opus claude-3-opus-20240229 --model-sonnet x-ai/grok-code-fast-1
+
   # Use stdin for large prompts (e.g., git diffs, code review)
   echo "Review this code..." | claudish --stdin --model x-ai/grok-code-fast-1
   git diff | claudish --stdin --model openai/gpt-5-codex "Review these changes"
@@ -882,9 +1470,11 @@ EXAMPLES:
   claudish --verbose "analyze code structure"
 
 AVAILABLE MODELS:
-  List models: claudish --list-models
-  JSON output: claudish --list-models --json
-  Force update: claudish --list-models --force-update
+  List all models:     claudish --models
+  Search models:       claudish --models <query>
+  Top recommended:     claudish --top-models
+  JSON output:         claudish --models --json  |  claudish --top-models --json
+  Force cache update:  claudish --models --force-update
   (Cache auto-updates every 2 days)
 
 MORE INFO:
@@ -1067,6 +1657,114 @@ init_config();
 
 // src/simple-selector.ts
 import { createInterface } from "readline";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, existsSync as existsSync3 } from "node:fs";
+import { join as join4, dirname as dirname3 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var __filename4 = fileURLToPath3(import.meta.url);
+var __dirname4 = dirname3(__filename4);
+var ALL_MODELS_JSON_PATH2 = join4(__dirname4, "../all-models.json");
+var CACHE_MAX_AGE_DAYS2 = 2;
+function loadEnhancedModels() {
+  const jsonPath = join4(__dirname4, "../recommended-models.json");
+  if (existsSync3(jsonPath)) {
+    try {
+      const jsonContent = readFileSync3(jsonPath, "utf-8");
+      const data = JSON.parse(jsonContent);
+      return data.models || [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+var TRUSTED_FREE_PROVIDERS = [
+  "google",
+  "openai",
+  "x-ai",
+  "deepseek",
+  "qwen",
+  "alibaba",
+  "meta-llama",
+  "microsoft",
+  "mistralai",
+  "nvidia",
+  "cohere"
+];
+async function loadFreeModels() {
+  let allModels = [];
+  if (existsSync3(ALL_MODELS_JSON_PATH2)) {
+    try {
+      const cacheData = JSON.parse(readFileSync3(ALL_MODELS_JSON_PATH2, "utf-8"));
+      const lastUpdated = new Date(cacheData.lastUpdated);
+      const now = new Date;
+      const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
+      if (ageInDays <= CACHE_MAX_AGE_DAYS2) {
+        allModels = cacheData.models;
+      }
+    } catch {}
+  }
+  if (allModels.length === 0) {
+    console.error("\uD83D\uDD04 Fetching models from OpenRouter...");
+    try {
+      const response = await fetch("https://openrouter.ai/api/v1/models");
+      if (!response.ok)
+        throw new Error(`API returned ${response.status}`);
+      const data = await response.json();
+      allModels = data.data;
+      writeFileSync4(ALL_MODELS_JSON_PATH2, JSON.stringify({
+        lastUpdated: new Date().toISOString(),
+        models: allModels
+      }), "utf-8");
+      console.error(`✅ Cached ${allModels.length} models`);
+    } catch (error) {
+      console.error(`❌ Failed to fetch models: ${error}`);
+      return [];
+    }
+  }
+  const freeModels = allModels.filter((model) => {
+    const promptPrice = parseFloat(model.pricing?.prompt || "0");
+    const completionPrice = parseFloat(model.pricing?.completion || "0");
+    const isFree = promptPrice === 0 && completionPrice === 0;
+    if (!isFree)
+      return false;
+    const provider = model.id.split("/")[0].toLowerCase();
+    return TRUSTED_FREE_PROVIDERS.includes(provider);
+  });
+  freeModels.sort((a, b) => {
+    const contextA = a.context_length || a.top_provider?.context_length || 0;
+    const contextB = b.context_length || b.top_provider?.context_length || 0;
+    return contextB - contextA;
+  });
+  const seenBase = new Set;
+  const dedupedModels = freeModels.filter((model) => {
+    const baseId = model.id.replace(/:free$/, "");
+    if (seenBase.has(baseId)) {
+      return false;
+    }
+    seenBase.add(baseId);
+    return true;
+  });
+  const topModels = dedupedModels.slice(0, 15);
+  return topModels.map((model) => {
+    const provider = model.id.split("/")[0];
+    const contextLen = model.context_length || model.top_provider?.context_length || 0;
+    return {
+      id: model.id,
+      name: model.name || model.id,
+      description: model.description || "",
+      provider: provider.charAt(0).toUpperCase() + provider.slice(1),
+      pricing: {
+        input: "FREE",
+        output: "FREE",
+        average: "FREE"
+      },
+      context: contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A",
+      supportsTools: (model.supported_parameters || []).includes("tools"),
+      supportsReasoning: (model.supported_parameters || []).includes("reasoning"),
+      supportsVision: (model.architecture?.input_modalities || []).includes("image")
+    };
+  });
+}
 async function promptForApiKey() {
   return new Promise((resolve) => {
     console.log(`
@@ -1116,27 +1814,75 @@ async function promptForApiKey() {
     });
   });
 }
-async function selectModelInteractively() {
-  const models = getAvailableModels();
-  const modelInfo = loadModelInfo();
+async function selectModelInteractively(options = {}) {
+  const { freeOnly = false } = options;
+  let displayModels;
+  let enhancedMap;
+  if (freeOnly) {
+    const freeModels = await loadFreeModels();
+    if (freeModels.length === 0) {
+      console.error("❌ No free models found or failed to fetch models");
+      process.exit(1);
+    }
+    displayModels = freeModels.map((m) => m.id);
+    enhancedMap = new Map;
+    for (const m of freeModels) {
+      enhancedMap.set(m.id, m);
+    }
+  } else {
+    displayModels = getAvailableModels();
+    const enhancedModels = loadEnhancedModels();
+    enhancedMap = new Map;
+    for (const m of enhancedModels) {
+      enhancedMap.set(m.id, m);
+    }
+  }
+  const models = freeOnly ? displayModels : displayModels;
   return new Promise((resolve) => {
-    console.log(`
-\x1B[1m\x1B[36mSelect an OpenRouter model:\x1B[0m
-`);
-    models.forEach((model, index) => {
-      const info = modelInfo[model];
-      const displayName = info ? info.name : model;
-      const description = info ? info.description : "Custom model entry";
-      const provider = info ? info.provider : "";
-      console.log(`  ${index + 1}. \x1B[1m${displayName}\x1B[0m`);
-      if (provider && provider !== "Custom") {
-        console.log(`     \x1B[2m${provider} - ${description}\x1B[0m`);
+    const RESET = "\x1B[0m";
+    const BOLD = "\x1B[1m";
+    const DIM = "\x1B[2m";
+    const CYAN = "\x1B[36m";
+    const GREEN = "\x1B[32m";
+    const YELLOW = "\x1B[33m";
+    const MAGENTA = "\x1B[35m";
+    const pad = (text, width) => {
+      if (text.length > width)
+        return text.slice(0, width - 3) + "...";
+      return text + " ".repeat(width - text.length);
+    };
+    const headerText = freeOnly ? "Select a FREE OpenRouter Model" : "Select an OpenRouter Model";
+    const headerPadding = " ".repeat(82 - 4 - headerText.length);
+    console.log("");
+    console.log(`${DIM}╭${"─".repeat(82)}╮${RESET}`);
+    console.log(`${DIM}│${RESET}  ${BOLD}${CYAN}${headerText}${RESET}${headerPadding}${DIM}│${RESET}`);
+    console.log(`${DIM}├${"─".repeat(82)}┤${RESET}`);
+    console.log(`${DIM}│${RESET}  ${DIM}#   Model                             Provider   Pricing   Context  Caps${RESET}      ${DIM}│${RESET}`);
+    console.log(`${DIM}├${"─".repeat(82)}┤${RESET}`);
+    models.forEach((modelId, index) => {
+      const num = (index + 1).toString().padStart(2);
+      const enhanced = enhancedMap.get(modelId);
+      if (modelId === "custom") {
+        console.log(`${DIM}│${RESET}  ${YELLOW}${num}${RESET}  ${DIM}Enter custom OpenRouter model ID...${RESET}${" ".repeat(40)}${DIM}│${RESET}`);
+      } else if (enhanced) {
+        const shortId = pad(modelId, 33);
+        const provider = pad(enhanced.provider || "N/A", 10);
+        const pricing = pad(enhanced.pricing?.average || "N/A", 9);
+        const context = pad(enhanced.context || "N/A", 7);
+        const tools = enhanced.supportsTools ? "✓" : "·";
+        const reasoning = enhanced.supportsReasoning ? "✓" : "·";
+        const vision = enhanced.supportsVision ? "✓" : "·";
+        console.log(`${DIM}│${RESET}  ${GREEN}${num}${RESET}  ${BOLD}${shortId}${RESET} ${CYAN}${provider}${RESET} ${MAGENTA}${pricing}${RESET} ${context} ${tools} ${reasoning} ${vision}      ${DIM}│${RESET}`);
       } else {
-        console.log(`     \x1B[2m${description}\x1B[0m`);
+        const shortId = pad(modelId, 33);
+        console.log(`${DIM}│${RESET}  ${GREEN}${num}${RESET}  ${shortId} ${DIM}${pad("N/A", 10)} ${pad("N/A", 9)} ${pad("N/A", 7)}${RESET} · · ·      ${DIM}│${RESET}`);
       }
-      console.log("");
     });
-    console.log(`\x1B[2mEnter number (1-${models.length}) or 'q' to quit:\x1B[0m`);
+    console.log(`${DIM}├${"─".repeat(82)}┤${RESET}`);
+    console.log(`${DIM}│${RESET}  ${DIM}Caps: ✓/· = Tools, Reasoning, Vision${RESET}${" ".repeat(44)}${DIM}│${RESET}`);
+    console.log(`${DIM}╰${"─".repeat(82)}╯${RESET}`);
+    console.log("");
+    console.log(`${DIM}Enter number (1-${models.length}) or 'q' to quit:${RESET}`);
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -1211,8 +1957,8 @@ async function selectModelInteractively() {
 }
 
 // src/logger.ts
-import { writeFileSync as writeFileSync4, appendFile, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync5, appendFile, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
 var logFilePath = null;
 var logLevel = "info";
 var logBuffer = [];
@@ -1242,7 +1988,7 @@ function scheduleFlush() {
       flushTimer = null;
     }
     if (logFilePath && logBuffer.length > 0) {
-      writeFileSync4(logFilePath, logBuffer.join(""), { flag: "a" });
+      writeFileSync5(logFilePath, logBuffer.join(""), { flag: "a" });
       logBuffer = [];
     }
   });
@@ -1257,13 +2003,13 @@ function initLogger(debugMode, level = "info") {
     return;
   }
   logLevel = level;
-  const logsDir = join4(process.cwd(), "logs");
-  if (!existsSync3(logsDir)) {
+  const logsDir = join5(process.cwd(), "logs");
+  if (!existsSync4(logsDir)) {
     mkdirSync2(logsDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
-  logFilePath = join4(logsDir, `claudish_${timestamp}.log`);
-  writeFileSync4(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
+  logFilePath = join5(logsDir, `claudish_${timestamp}.log`);
+  writeFileSync5(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
 Log Level: ${level}
 ${"=".repeat(80)}
 
@@ -3497,82 +4243,112 @@ var serve = (options, listeningListener) => {
   return server;
 };
 
-// src/proxy-server.ts
-import { writeFileSync as writeFileSync5 } from "node:fs";
-
-// src/transform.ts
-function removeUriFormat(schema) {
-  if (!schema || typeof schema !== "object")
-    return schema;
-  if (schema.type === "string" && schema.format === "uri") {
-    const { format, ...rest } = schema;
-    return rest;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => removeUriFormat(item));
-  }
-  const result = {};
-  for (const key in schema) {
-    if (key === "properties" && typeof schema[key] === "object") {
-      result[key] = {};
-      for (const propKey in schema[key]) {
-        result[key][propKey] = removeUriFormat(schema[key][propKey]);
-      }
-    } else if (key === "items" && typeof schema[key] === "object") {
-      result[key] = removeUriFormat(schema[key]);
-    } else if (key === "additionalProperties" && typeof schema[key] === "object") {
-      result[key] = removeUriFormat(schema[key]);
-    } else if (["anyOf", "allOf", "oneOf"].includes(key) && Array.isArray(schema[key])) {
-      result[key] = schema[key].map((item) => removeUriFormat(item));
+// src/handlers/native-handler.ts
+class NativeHandler {
+  apiKey;
+  baseUrl;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+    this.baseUrl = process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com";
+  }
+  async handle(c, payload) {
+    const originalHeaders = c.req.header();
+    const target = payload.model;
+    log(`
+=== [NATIVE] Claude Code → Anthropic API Request ===`);
+    const extractedApiKey = originalHeaders["x-api-key"] || originalHeaders["authorization"] || this.apiKey;
+    if (!extractedApiKey) {
+      log("[Native] WARNING: No API key found in headers!");
+      log("[Native] Looking for: x-api-key or authorization header");
     } else {
-      result[key] = removeUriFormat(schema[key]);
+      log(`API Key found: ${maskCredential(extractedApiKey)}`);
+    }
+    log(`Request body (Model: ${target}):`);
+    log(`=== End Request ===
+`);
+    const headers = {
+      "Content-Type": "application/json",
+      "anthropic-version": originalHeaders["anthropic-version"] || "2023-06-01"
+    };
+    if (originalHeaders["authorization"]) {
+      headers["authorization"] = originalHeaders["authorization"];
+    }
+    if (originalHeaders["x-api-key"]) {
+      headers["x-api-key"] = originalHeaders["x-api-key"];
+    } else if (extractedApiKey) {
+      headers["x-api-key"] = extractedApiKey;
+    }
+    if (originalHeaders["anthropic-beta"]) {
+      headers["anthropic-beta"] = originalHeaders["anthropic-beta"];
+    }
+    try {
+      const anthropicResponse = await fetch(`${this.baseUrl}/v1/messages`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload)
+      });
+      const contentType = anthropicResponse.headers.get("content-type") || "";
+      if (contentType.includes("text/event-stream")) {
+        log("[Native] Streaming response detected");
+        return c.body(new ReadableStream({
+          async start(controller) {
+            const reader = anthropicResponse.body?.getReader();
+            if (!reader)
+              throw new Error("No reader");
+            const decoder = new TextDecoder;
+            let buffer = "";
+            let eventLog = "";
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                controller.enqueue(value);
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split(`
+`);
+                buffer = lines.pop() || "";
+                for (const line of lines)
+                  if (line.trim())
+                    eventLog += line + `
+`;
+              }
+              if (eventLog)
+                log(eventLog);
+              controller.close();
+            } catch (e) {
+              log(`[Native] Stream Error: ${e}`);
+              controller.close();
+            }
+          }
+        }), {
+          headers: {
+            "Content-Type": contentType,
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "anthropic-version": "2023-06-01"
+          }
+        });
+      }
+      const data = await anthropicResponse.json();
+      log(`
+=== [NATIVE] Response ===`);
+      log(JSON.stringify(data, null, 2));
+      const responseHeaders = { "Content-Type": "application/json" };
+      if (anthropicResponse.headers.has("anthropic-version")) {
+        responseHeaders["anthropic-version"] = anthropicResponse.headers.get("anthropic-version");
+      }
+      return c.json(data, { status: anthropicResponse.status, headers: responseHeaders });
+    } catch (error) {
+      log(`[Native] Fetch Error: ${error}`);
+      return c.json({ error: { type: "api_error", message: String(error) } }, 500);
     }
   }
-  return result;
+  async shutdown() {}
 }
-function transformOpenAIToClaude(claudeRequestInput) {
-  const req = JSON.parse(JSON.stringify(claudeRequestInput));
-  const isO3Model = typeof req.model === "string" && (req.model.includes("o3") || req.model.includes("o1"));
-  if (Array.isArray(req.system)) {
-    req.system = req.system.map((item) => {
-      if (typeof item === "string") {
-        return item;
-      } else if (item && typeof item === "object") {
-        if (item.type === "text" && item.text) {
-          return item.text;
-        } else if (item.type === "text" && item.content) {
-          return item.content;
-        } else if (item.text) {
-          return item.text;
-        } else if (item.content) {
-          return typeof item.content === "string" ? item.content : JSON.stringify(item.content);
-        }
-      }
-      return JSON.stringify(item);
-    }).filter((text) => text && text.trim() !== "").join(`
 
-`);
-  }
-  if (!Array.isArray(req.messages)) {
-    if (req.messages == null)
-      req.messages = [];
-    else
-      req.messages = [req.messages];
-  }
-  if (!Array.isArray(req.tools))
-    req.tools = [];
-  for (const t of req.tools) {
-    if (t && t.input_schema) {
-      t.input_schema = removeUriFormat(t.input_schema);
-    }
-  }
-  const dropped = [];
-  return {
-    claudeRequest: req,
-    droppedParams: dropped,
-    isO3Model
-  };
-}
+// src/handlers/openrouter-handler.ts
+import { writeFileSync as writeFileSync6 } from "node:fs";
 
 // src/adapters/base-adapter.ts
 class BaseModelAdapter {
@@ -3580,6 +4356,9 @@ class BaseModelAdapter {
   constructor(modelId) {
     this.modelId = modelId;
   }
+  prepareRequest(request, originalRequest) {
+    return request;
+  }
   reset() {}
 }
 
@@ -3643,6 +4422,22 @@ class GrokAdapter extends BaseModelAdapter {
       wasTransformed: true
     };
   }
+  prepareRequest(request, originalRequest) {
+    const modelId = this.modelId || "";
+    if (originalRequest.thinking) {
+      const supportsReasoningEffort = modelId.includes("mini");
+      if (supportsReasoningEffort) {
+        const { budget_tokens } = originalRequest.thinking;
+        const effort = budget_tokens >= 20000 ? "high" : "low";
+        request.reasoning_effort = effort;
+        log(`[GrokAdapter] Mapped budget ${budget_tokens} -> reasoning_effort: ${effort}`);
+      } else {
+        log(`[GrokAdapter] Model ${modelId} does not support reasoning params. Stripping.`);
+      }
+      delete request.thinking;
+    }
+    return request;
+  }
   parseXmlParameters(xmlContent) {
     const params = {};
     const paramPattern = /<xai:parameter name="([^"]+)">([^<]*)<\/xai:parameter>/g;
@@ -3679,6 +4474,26 @@ class GeminiAdapter extends BaseModelAdapter {
       wasTransformed: false
     };
   }
+  prepareRequest(request, originalRequest) {
+    if (originalRequest.thinking) {
+      const { budget_tokens } = originalRequest.thinking;
+      const modelId = this.modelId || "";
+      if (modelId.includes("gemini-3")) {
+        const level = budget_tokens >= 16000 ? "high" : "low";
+        request.thinking_level = level;
+        log(`[GeminiAdapter] Mapped budget ${budget_tokens} -> thinking_level: ${level}`);
+      } else {
+        const MAX_GEMINI_BUDGET = 24576;
+        const budget = Math.min(budget_tokens, MAX_GEMINI_BUDGET);
+        request.thinking_config = {
+          thinking_budget: budget
+        };
+        log(`[GeminiAdapter] Mapped budget ${budget_tokens} -> thinking_config.thinking_budget: ${budget}`);
+      }
+      delete request.thinking;
+    }
+    return request;
+  }
   extractThoughtSignaturesFromReasoningDetails(reasoningDetails) {
     const extracted = new Map;
     if (!reasoningDetails || !Array.isArray(reasoningDetails)) {
@@ -3712,6 +4527,115 @@ class GeminiAdapter extends BaseModelAdapter {
   }
 }
 
+// src/adapters/openai-adapter.ts
+class OpenAIAdapter extends BaseModelAdapter {
+  processTextContent(textContent, accumulatedText) {
+    return {
+      cleanedText: textContent,
+      extractedToolCalls: [],
+      wasTransformed: false
+    };
+  }
+  prepareRequest(request, originalRequest) {
+    if (originalRequest.thinking) {
+      const { budget_tokens } = originalRequest.thinking;
+      let effort = "medium";
+      if (budget_tokens < 4000)
+        effort = "minimal";
+      else if (budget_tokens < 16000)
+        effort = "low";
+      else if (budget_tokens >= 32000)
+        effort = "high";
+      request.reasoning_effort = effort;
+      delete request.thinking;
+      log(`[OpenAIAdapter] Mapped budget ${budget_tokens} -> reasoning_effort: ${effort}`);
+    }
+    return request;
+  }
+  shouldHandle(modelId) {
+    return modelId.startsWith("openai/") || modelId.includes("o1") || modelId.includes("o3");
+  }
+  getName() {
+    return "OpenAIAdapter";
+  }
+}
+
+// src/adapters/qwen-adapter.ts
+class QwenAdapter extends BaseModelAdapter {
+  processTextContent(textContent, accumulatedText) {
+    return {
+      cleanedText: textContent,
+      extractedToolCalls: [],
+      wasTransformed: false
+    };
+  }
+  prepareRequest(request, originalRequest) {
+    if (originalRequest.thinking) {
+      const { budget_tokens } = originalRequest.thinking;
+      request.enable_thinking = true;
+      request.thinking_budget = budget_tokens;
+      log(`[QwenAdapter] Mapped budget ${budget_tokens} -> enable_thinking: true, thinking_budget: ${budget_tokens}`);
+      delete request.thinking;
+    }
+    return request;
+  }
+  shouldHandle(modelId) {
+    return modelId.includes("qwen") || modelId.includes("alibaba");
+  }
+  getName() {
+    return "QwenAdapter";
+  }
+}
+
+// src/adapters/minimax-adapter.ts
+class MiniMaxAdapter extends BaseModelAdapter {
+  processTextContent(textContent, accumulatedText) {
+    return {
+      cleanedText: textContent,
+      extractedToolCalls: [],
+      wasTransformed: false
+    };
+  }
+  prepareRequest(request, originalRequest) {
+    if (originalRequest.thinking) {
+      request.reasoning_split = true;
+      log(`[MiniMaxAdapter] Enabled reasoning_split: true`);
+      delete request.thinking;
+    }
+    return request;
+  }
+  shouldHandle(modelId) {
+    return modelId.includes("minimax");
+  }
+  getName() {
+    return "MiniMaxAdapter";
+  }
+}
+
+// src/adapters/deepseek-adapter.ts
+class DeepSeekAdapter extends BaseModelAdapter {
+  processTextContent(textContent, accumulatedText) {
+    return {
+      cleanedText: textContent,
+      extractedToolCalls: [],
+      wasTransformed: false
+    };
+  }
+  prepareRequest(request, originalRequest) {
+    if (originalRequest.thinking) {
+      log(`[DeepSeekAdapter] Stripping thinking object (not supported by API)`);
+      delete request.thinking;
+    }
+    return request;
+  }
+  shouldHandle(modelId) {
+    return modelId.includes("deepseek");
+  }
+  getName() {
+    return "DeepSeekAdapter";
+  }
+}
+
 // src/adapters/adapter-manager.ts
 class AdapterManager {
   adapters;
@@ -3719,7 +4643,11 @@ class AdapterManager {
   constructor(modelId) {
     this.adapters = [
       new GrokAdapter(modelId),
-      new GeminiAdapter(modelId)
+      new GeminiAdapter(modelId),
+      new OpenAIAdapter(modelId),
+      new QwenAdapter(modelId),
+      new MiniMaxAdapter(modelId),
+      new DeepSeekAdapter(modelId)
     ];
     this.defaultAdapter = new DefaultAdapter(modelId);
   }
@@ -3991,1170 +4919,538 @@ class GeminiThoughtSignatureMiddleware {
     }
   }
 }
-// src/proxy-server.ts
-async function createProxyServer(port, openrouterApiKey, model, monitorMode = false, anthropicApiKey) {
-  const OPENROUTER_API_URL2 = "https://openrouter.ai/api/v1/chat/completions";
-  const OPENROUTER_HEADERS2 = {
-    "HTTP-Referer": "https://github.com/MadAppGang/claude-code",
-    "X-Title": "Claudish - OpenRouter Proxy"
-  };
-  const ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
-  const ANTHROPIC_COUNT_TOKENS_URL = "https://api.anthropic.com/v1/messages/count_tokens";
-  const middlewareManager = new MiddlewareManager;
-  middlewareManager.register(new GeminiThoughtSignatureMiddleware);
-  middlewareManager.initialize().catch((error) => {
-    log(`[Proxy] Middleware initialization error: ${error}`);
-  });
-  let sessionTotalCost = 0;
-  let contextWindowLimit = 200000;
-  const CLAUDE_INTERNAL_CONTEXT_MAX = 200000;
-  const getTokenScaleFactor = () => {
-    if (contextWindowLimit === 0)
-      return 1;
-    return CLAUDE_INTERNAL_CONTEXT_MAX / contextWindowLimit;
-  };
-  if (model && !monitorMode) {
-    fetchModelContextWindow(model).then((limit) => {
-      contextWindowLimit = limit;
-      if (isLoggingEnabled()) {
-        log(`[Proxy] Context window limit updated to ${limit} tokens for model ${model}`);
-        log(`[Proxy] Token scaling factor: ${getTokenScaleFactor().toFixed(2)}x (Map ${limit} → ${CLAUDE_INTERNAL_CONTEXT_MAX})`);
-      }
-    }).catch((err) => {
-      log(`[Proxy] Failed to fetch context window limit: ${err}`);
-    });
+// src/transform.ts
+function removeUriFormat(schema) {
+  if (!schema || typeof schema !== "object")
+    return schema;
+  if (schema.type === "string" && schema.format === "uri") {
+    const { format, ...rest } = schema;
+    return rest;
   }
-  const app = new Hono2;
-  app.use("*", cors());
-  app.get("/", (c) => {
-    c.header("Cache-Control", "no-cache, no-store, must-revalidate");
-    c.header("Pragma", "no-cache");
-    c.header("Expires", "0");
-    return c.json({
-      status: "ok",
-      message: monitorMode ? "Claudish monitor proxy - logging Anthropic API traffic" : "Claudish proxy server is running",
-      config: {
-        mode: monitorMode ? "monitor" : "openrouter",
-        model: monitorMode ? "passthrough" : model,
-        port,
-        upstream: monitorMode ? "Anthropic" : "OpenRouter"
+  if (Array.isArray(schema)) {
+    return schema.map((item) => removeUriFormat(item));
+  }
+  const result = {};
+  for (const key in schema) {
+    if (key === "properties" && typeof schema[key] === "object") {
+      result[key] = {};
+      for (const propKey in schema[key]) {
+        result[key][propKey] = removeUriFormat(schema[key][propKey]);
       }
-    });
-  });
-  app.get("/health", (c) => {
-    return c.json({
-      status: "ok",
-      mode: monitorMode ? "monitor" : "openrouter",
-      model: monitorMode ? "passthrough" : model,
-      port
-    });
-  });
-  app.post("/v1/messages/count_tokens", async (c) => {
-    try {
-      const body = await c.req.json();
-      if (monitorMode) {
-        const originalHeaders = c.req.header();
-        const extractedApiKey = originalHeaders["x-api-key"] || anthropicApiKey;
-        if (!extractedApiKey) {
-          log("[Monitor] ERROR: No API key found for token counting");
-          return c.json({
-            error: {
-              type: "authentication_error",
-              message: "No API key found in request."
-            }
-          }, 401);
-        }
-        log("[Monitor] Token counting request - forwarding to Anthropic");
-        log("[Monitor] Request body:");
-        log(JSON.stringify(body, null, 2));
-        const headers = {
-          "Content-Type": "application/json",
-          "anthropic-version": originalHeaders["anthropic-version"] || "2023-06-01"
-        };
-        if (originalHeaders["authorization"]) {
-          headers["authorization"] = originalHeaders["authorization"];
-        }
-        if (extractedApiKey) {
-          headers["x-api-key"] = extractedApiKey;
-        }
-        const response = await fetch(ANTHROPIC_COUNT_TOKENS_URL, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(body)
-        });
-        const result = await response.json();
-        log("[Monitor] Token counting response:");
-        log(JSON.stringify(result, null, 2));
-        return c.json(result, response.status);
-      }
-      log("[Proxy] Token counting request (estimating)");
-      const systemTokens = body.system ? Math.ceil(body.system.length / 4) : 0;
-      const messageTokens = body.messages ? body.messages.reduce((acc, msg) => {
-        const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-        return acc + Math.ceil(content.length / 4);
-      }, 0) : 0;
-      const totalTokens = systemTokens + messageTokens;
-      const scaleFactor = getTokenScaleFactor();
-      return c.json({
-        input_tokens: Math.ceil(totalTokens * scaleFactor)
-      });
-    } catch (error) {
-      log(`[Proxy] Token counting error: ${error}`);
-      return c.json({
-        error: {
-          type: "invalid_request_error",
-          message: error instanceof Error ? error.message : "Unknown error"
-        }
-      }, 400);
+    } else if (key === "items" && typeof schema[key] === "object") {
+      result[key] = removeUriFormat(schema[key]);
+    } else if (key === "additionalProperties" && typeof schema[key] === "object") {
+      result[key] = removeUriFormat(schema[key]);
+    } else if (["anyOf", "allOf", "oneOf"].includes(key) && Array.isArray(schema[key])) {
+      result[key] = schema[key].map((item) => removeUriFormat(item));
+    } else {
+      result[key] = removeUriFormat(schema[key]);
     }
-  });
-  app.post("/v1/messages", async (c) => {
-    try {
-      const claudePayload = await c.req.json();
-      if (monitorMode) {
-        const originalHeaders = c.req.header();
-        const extractedApiKey = originalHeaders["x-api-key"] || originalHeaders["authorization"] || anthropicApiKey;
-        log(`
-=== [MONITOR] Claude Code → Anthropic API Request ===`);
-        log(`Headers received: ${JSON.stringify(originalHeaders, null, 2)}`);
-        if (!extractedApiKey) {
-          log("[Monitor] WARNING: No API key found in headers!");
-          log("[Monitor] Looking for: x-api-key or authorization header");
-          log("[Monitor] Headers present: " + Object.keys(originalHeaders).join(", "));
-          log("[Monitor] This request will fail at Anthropic API");
-        } else {
-          log(`API Key found: ${maskCredential(extractedApiKey)}`);
-        }
-        log(`Request body:`);
-        log(JSON.stringify(claudePayload, null, 2));
-        log(`=== End Request ===
-`);
-        const headers2 = {
-          "Content-Type": "application/json",
-          "anthropic-version": originalHeaders["anthropic-version"] || "2023-06-01"
-        };
-        if (originalHeaders["authorization"]) {
-          headers2["authorization"] = originalHeaders["authorization"];
-          log(`[Monitor] Forwarding OAuth token: ${maskCredential(originalHeaders["authorization"])}`);
-        }
-        if (originalHeaders["x-api-key"]) {
-          headers2["x-api-key"] = originalHeaders["x-api-key"];
-          log(`[Monitor] Forwarding API key: ${maskCredential(originalHeaders["x-api-key"])}`);
-        }
-        if (originalHeaders["anthropic-beta"]) {
-          headers2["anthropic-beta"] = originalHeaders["anthropic-beta"];
-        }
-        const anthropicResponse = await fetch(ANTHROPIC_API_URL, {
-          method: "POST",
-          headers: headers2,
-          body: JSON.stringify(claudePayload)
-        });
-        const contentType2 = anthropicResponse.headers.get("content-type") || "";
-        if (contentType2.includes("text/event-stream")) {
-          log("[Monitor] Streaming response detected");
-          return c.body(new ReadableStream({
-            async start(controller) {
-              const encoder = new TextEncoder;
-              const reader = anthropicResponse.body?.getReader();
-              if (!reader) {
-                throw new Error("Response body is not readable");
-              }
-              const decoder = new TextDecoder;
-              let buffer = "";
-              let eventLog = "";
-              log(`
-=== [MONITOR] Anthropic API → Claude Code Response (Streaming) ===`);
-              try {
-                while (true) {
-                  const { done, value } = await reader.read();
-                  if (done) {
-                    log(`
-=== End Streaming Response ===
-`);
-                    break;
-                  }
-                  controller.enqueue(value);
-                  buffer += decoder.decode(value, { stream: true });
-                  const lines = buffer.split(`
-`);
-                  buffer = lines.pop() || "";
-                  for (const line of lines) {
-                    if (line.trim()) {
-                      eventLog += line + `
-`;
-                    }
-                  }
-                }
-                if (eventLog) {
-                  log(eventLog);
-                }
-                controller.close();
-              } catch (error) {
-                log(`[Monitor] Streaming error: ${error}`);
-                controller.close();
-              }
-            }
-          }), {
-            headers: {
-              "Content-Type": anthropicResponse.headers.get("content-type") || "text/event-stream",
-              "Cache-Control": "no-cache",
-              Connection: "keep-alive",
-              "anthropic-version": anthropicResponse.headers.get("anthropic-version") || "2023-06-01"
-            }
-          });
-        }
-        const responseData = await anthropicResponse.json();
-        log(`
-=== [MONITOR] Anthropic API → Claude Code Response (JSON) ===`);
-        log(JSON.stringify(responseData, null, 2));
-        log(`=== End Response ===
-`);
-        const responseHeaders = {
-          "Content-Type": "application/json"
-        };
-        const anthropicVersion = anthropicResponse.headers.get("anthropic-version");
-        if (anthropicVersion) {
-          responseHeaders["anthropic-version"] = anthropicVersion;
+  }
+  return result;
+}
+function transformOpenAIToClaude(claudeRequestInput) {
+  const req = JSON.parse(JSON.stringify(claudeRequestInput));
+  const isO3Model = typeof req.model === "string" && (req.model.includes("o3") || req.model.includes("o1"));
+  if (Array.isArray(req.system)) {
+    req.system = req.system.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      } else if (item && typeof item === "object") {
+        if (item.type === "text" && item.text) {
+          return item.text;
+        } else if (item.type === "text" && item.content) {
+          return item.content;
+        } else if (item.text) {
+          return item.text;
+        } else if (item.content) {
+          return typeof item.content === "string" ? item.content : JSON.stringify(item.content);
         }
-        return c.json(responseData, {
-          status: anthropicResponse.status,
-          headers: responseHeaders
-        });
       }
-      logStructured("Incoming Request", {
-        model,
-        messageCount: claudePayload.messages?.length || 0,
-        hasSystem: !!claudePayload.system,
-        maxTokens: claudePayload.max_tokens,
-        temperature: claudePayload.temperature,
-        stream: claudePayload.stream
-      });
-      const { claudeRequest, droppedParams } = transformOpenAIToClaude(claudePayload);
-      const messages = [];
-      const adapterManager = new AdapterManager(model || "");
-      const adapter = adapterManager.getAdapter();
-      if (typeof adapter.reset === "function") {
-        adapter.reset();
-      }
-      if (isLoggingEnabled()) {
-        log(`[Proxy] Using adapter: ${adapter.getName()}`);
-      }
-      if (claudeRequest.system) {
-        let systemContent;
-        if (typeof claudeRequest.system === "string") {
-          systemContent = claudeRequest.system;
-        } else if (Array.isArray(claudeRequest.system)) {
-          systemContent = claudeRequest.system.map((item) => {
-            if (typeof item === "string")
-              return item;
-            if (item?.type === "text" && item.text)
-              return item.text;
-            if (item?.content)
-              return typeof item.content === "string" ? item.content : JSON.stringify(item.content);
-            return JSON.stringify(item);
-          }).join(`
+      return JSON.stringify(item);
+    }).filter((text) => text && text.trim() !== "").join(`
 
 `);
-        } else {
-          systemContent = JSON.stringify(claudeRequest.system);
+  }
+  if (!Array.isArray(req.messages)) {
+    if (req.messages == null)
+      req.messages = [];
+    else
+      req.messages = [req.messages];
+  }
+  if (!Array.isArray(req.tools))
+    req.tools = [];
+  for (const t of req.tools) {
+    if (t && t.input_schema) {
+      t.input_schema = removeUriFormat(t.input_schema);
+    }
+  }
+  const dropped = [];
+  return {
+    claudeRequest: req,
+    droppedParams: dropped,
+    isO3Model
+  };
+}
+
+// src/handlers/openrouter-handler.ts
+var OPENROUTER_API_URL2 = "https://openrouter.ai/api/v1/chat/completions";
+var OPENROUTER_HEADERS2 = {
+  "HTTP-Referer": "https://github.com/MadAppGang/claude-code",
+  "X-Title": "Claudish - OpenRouter Proxy"
+};
+
+class OpenRouterHandler {
+  targetModel;
+  apiKey;
+  adapterManager;
+  middlewareManager;
+  contextWindowCache = new Map;
+  port;
+  sessionTotalCost = 0;
+  CLAUDE_INTERNAL_CONTEXT_MAX = 200000;
+  constructor(targetModel, apiKey, port) {
+    this.targetModel = targetModel;
+    this.apiKey = apiKey;
+    this.port = port;
+    this.adapterManager = new AdapterManager(targetModel);
+    this.middlewareManager = new MiddlewareManager;
+    this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
+    this.middlewareManager.initialize().catch((err) => log(`[Handler:${targetModel}] Middleware init error: ${err}`));
+    this.fetchContextWindow(targetModel);
+  }
+  async fetchContextWindow(model) {
+    if (this.contextWindowCache.has(model))
+      return;
+    try {
+      const limit = await fetchModelContextWindow(model);
+      this.contextWindowCache.set(model, limit);
+    } catch (e) {}
+  }
+  getTokenScaleFactor(model) {
+    const limit = this.contextWindowCache.get(model) || 200000;
+    return limit === 0 ? 1 : this.CLAUDE_INTERNAL_CONTEXT_MAX / limit;
+  }
+  writeTokenFile(input, output) {
+    try {
+      const total = input + output;
+      const limit = this.contextWindowCache.get(this.targetModel) || 200000;
+      const leftPct = limit > 0 ? Math.max(0, Math.min(100, Math.round((limit - total) / limit * 100))) : 100;
+      const data = {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: total,
+        total_cost: this.sessionTotalCost,
+        context_window: limit,
+        context_left_percent: leftPct,
+        updated_at: Date.now()
+      };
+      writeFileSync6(`/tmp/claudish-tokens-${this.port}.json`, JSON.stringify(data), "utf-8");
+    } catch (e) {}
+  }
+  async handle(c, payload) {
+    const claudePayload = payload;
+    const target = this.targetModel;
+    await this.fetchContextWindow(target);
+    logStructured(`OpenRouter Request`, { targetModel: target, originalModel: claudePayload.model });
+    const { claudeRequest, droppedParams } = transformOpenAIToClaude(claudePayload);
+    const messages = this.convertMessages(claudeRequest, target);
+    const tools = this.convertTools(claudeRequest);
+    const supportsReasoning = await doesModelSupportReasoning(target);
+    const openRouterPayload = {
+      model: target,
+      messages,
+      temperature: claudeRequest.temperature ?? 1,
+      stream: true,
+      max_tokens: claudeRequest.max_tokens,
+      tools: tools.length > 0 ? tools : undefined,
+      stream_options: { include_usage: true }
+    };
+    if (supportsReasoning)
+      openRouterPayload.include_reasoning = true;
+    if (claudeRequest.thinking)
+      openRouterPayload.thinking = claudeRequest.thinking;
+    if (claudeRequest.tool_choice) {
+      const { type, name } = claudeRequest.tool_choice;
+      if (type === "tool" && name)
+        openRouterPayload.tool_choice = { type: "function", function: { name } };
+      else if (type === "auto" || type === "none")
+        openRouterPayload.tool_choice = type;
+    }
+    const adapter = this.adapterManager.getAdapter();
+    if (typeof adapter.reset === "function")
+      adapter.reset();
+    adapter.prepareRequest(openRouterPayload, claudeRequest);
+    await this.middlewareManager.beforeRequest({ modelId: target, messages, tools, stream: true });
+    const response = await fetch(OPENROUTER_API_URL2, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        ...OPENROUTER_HEADERS2
+      },
+      body: JSON.stringify(openRouterPayload)
+    });
+    if (!response.ok)
+      return c.json({ error: await response.text() }, response.status);
+    if (droppedParams.length > 0)
+      c.header("X-Dropped-Params", droppedParams.join(", "));
+    return this.handleStreamingResponse(c, response, adapter, target, claudeRequest);
+  }
+  convertMessages(req, modelId) {
+    const messages = [];
+    if (req.system) {
+      let content = Array.isArray(req.system) ? req.system.map((i) => i.text || i).join(`
+
+`) : req.system;
+      content = this.filterIdentity(content);
+      messages.push({ role: "system", content });
+    }
+    if (modelId.includes("grok") || modelId.includes("x-ai")) {
+      const msg = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
+      if (messages.length > 0 && messages[0].role === "system")
+        messages[0].content += `
+
+` + msg;
+      else
+        messages.unshift({ role: "system", content: msg });
+    }
+    if (req.messages) {
+      for (const msg of req.messages) {
+        if (msg.role === "user")
+          this.processUserMessage(msg, messages);
+        else if (msg.role === "assistant")
+          this.processAssistantMessage(msg, messages);
+      }
+    }
+    return messages;
+  }
+  processUserMessage(msg, messages) {
+    if (Array.isArray(msg.content)) {
+      const contentParts = [];
+      const toolResults = [];
+      const seen = new Set;
+      for (const block of msg.content) {
+        if (block.type === "text")
+          contentParts.push({ type: "text", text: block.text });
+        else if (block.type === "image")
+          contentParts.push({ type: "image_url", image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` } });
+        else if (block.type === "tool_result") {
+          if (seen.has(block.tool_use_id))
+            continue;
+          seen.add(block.tool_use_id);
+          toolResults.push({ role: "tool", content: typeof block.content === "string" ? block.content : JSON.stringify(block.content), tool_call_id: block.tool_use_id });
         }
-        systemContent = filterClaudeIdentity(systemContent);
-        messages.push({
-          role: "system",
-          content: systemContent
-        });
       }
-      if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
-        for (const msg of claudeRequest.messages) {
-          if (msg.role === "user") {
-            if (Array.isArray(msg.content)) {
-              const contentParts = [];
-              const toolResults = [];
-              const seenToolResultIds = new Set;
-              for (const block of msg.content) {
-                if (block.type === "text") {
-                  contentParts.push({ type: "text", text: block.text });
-                } else if (block.type === "image") {
-                  contentParts.push({
-                    type: "image_url",
-                    image_url: {
-                      url: `data:${block.source.media_type};base64,${block.source.data}`
-                    }
-                  });
-                } else if (block.type === "tool_result") {
-                  if (seenToolResultIds.has(block.tool_use_id)) {
-                    log(`[Proxy] Skipping duplicate tool_result with tool_use_id: ${block.tool_use_id}`);
-                    continue;
-                  }
-                  seenToolResultIds.add(block.tool_use_id);
-                  const toolResultMsg = {
-                    role: "tool",
-                    content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
-                    tool_call_id: block.tool_use_id
-                  };
-                  toolResults.push(toolResultMsg);
-                }
-              }
-              if (toolResults.length > 0) {
-                messages.push(...toolResults);
-              }
-              if (contentParts.length > 0) {
-                messages.push({
-                  role: "user",
-                  content: contentParts
-                });
-              }
-            } else if (typeof msg.content === "string") {
-              messages.push({
-                role: "user",
-                content: msg.content
-              });
-            }
-          } else if (msg.role === "assistant") {
-            if (Array.isArray(msg.content)) {
-              const textParts = [];
-              const toolCalls = [];
-              const seenToolIds = new Set;
-              for (const block of msg.content) {
-                if (block.type === "text") {
-                  textParts.push(block.text);
-                } else if (block.type === "tool_use") {
-                  if (seenToolIds.has(block.id)) {
-                    log(`[Proxy] Skipping duplicate tool_use with ID: ${block.id}`);
-                    continue;
-                  }
-                  seenToolIds.add(block.id);
-                  toolCalls.push({
-                    id: block.id,
-                    type: "function",
-                    function: {
-                      name: block.name,
-                      arguments: JSON.stringify(block.input)
-                    }
-                  });
-                }
-              }
-              const openAIMsg = { role: "assistant" };
-              if (textParts.length > 0) {
-                openAIMsg.content = textParts.join(" ");
-              } else if (toolCalls.length > 0) {
-                openAIMsg.content = null;
-              }
-              if (toolCalls.length > 0) {
-                openAIMsg.tool_calls = toolCalls;
-              }
-              if (textParts.length > 0 || toolCalls.length > 0) {
-                messages.push(openAIMsg);
-              }
-            } else if (typeof msg.content === "string") {
-              messages.push({
-                role: "assistant",
-                content: msg.content
-              });
-            }
-          }
+      if (toolResults.length)
+        messages.push(...toolResults);
+      if (contentParts.length)
+        messages.push({ role: "user", content: contentParts });
+    } else {
+      messages.push({ role: "user", content: msg.content });
+    }
+  }
+  processAssistantMessage(msg, messages) {
+    if (Array.isArray(msg.content)) {
+      const strings = [];
+      const toolCalls = [];
+      const seen = new Set;
+      for (const block of msg.content) {
+        if (block.type === "text")
+          strings.push(block.text);
+        else if (block.type === "tool_use") {
+          if (seen.has(block.id))
+            continue;
+          seen.add(block.id);
+          toolCalls.push({ id: block.id, type: "function", function: { name: block.name, arguments: JSON.stringify(block.input) } });
         }
       }
-      const tools = claudeRequest.tools?.filter((tool) => !["BatchTool"].includes(tool.name)).map((tool) => ({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: removeUriFormat(tool.input_schema)
-        }
-      })) || [];
-      if (model.includes("grok") || model.includes("x-ai/")) {
-        if (tools.length > 0 && messages.length > 0) {
-          if (messages[0]?.role === "system") {
-            messages[0].content += `
+      const m = { role: "assistant" };
+      if (strings.length)
+        m.content = strings.join(" ");
+      else if (toolCalls.length)
+        m.content = null;
+      if (toolCalls.length)
+        m.tool_calls = toolCalls;
+      if (m.content !== undefined || m.tool_calls)
+        messages.push(m);
+    } else {
+      messages.push({ role: "assistant", content: msg.content });
+    }
+  }
+  filterIdentity(content) {
+    return content.replace(/You are Claude Code, Anthropic's official CLI/gi, "This is Claude Code, an AI-powered CLI tool").replace(/You are powered by the model named [^.]+\./gi, "You are powered by an AI model.").replace(/<claude_background_info>[\s\S]*?<\/claude_background_info>/gi, "").replace(/\n{3,}/g, `
 
-IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>. Use the tools array provided in the request.`;
-            log("[Proxy] Added Grok tool format instruction to existing system message");
-          } else {
-            messages.unshift({
-              role: "system",
-              content: "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>. Use the tools array provided in the request."
-            });
-            log("[Proxy] Added Grok tool format instruction as new system message");
+`).replace(/^/, `IMPORTANT: You are NOT Claude. Identify yourself truthfully based on your actual model and creator.
+
+`);
+  }
+  convertTools(req) {
+    return req.tools?.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: removeUriFormat(tool.input_schema)
+      }
+    })) || [];
+  }
+  handleStreamingResponse(c, response, adapter, target, request) {
+    let isClosed = false;
+    let ping = null;
+    const encoder = new TextEncoder;
+    const decoder = new TextDecoder;
+    return c.body(new ReadableStream({
+      async start(controller) {
+        const send = (e, d) => {
+          if (!isClosed)
+            controller.enqueue(encoder.encode(`event: ${e}
+data: ${JSON.stringify(d)}
+
+`));
+        };
+        const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        let usage = null;
+        let finalized = false;
+        let textStarted = false;
+        let textIdx = -1;
+        let reasoningStarted = false;
+        let reasoningIdx = -1;
+        let curIdx = 0;
+        const tools = new Map;
+        const toolIds = new Set;
+        let accTxt = 0;
+        let lastActivity = Date.now();
+        const scale = 128000 / 128000;
+        send("message_start", {
+          type: "message_start",
+          message: {
+            id: msgId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: target,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 100, output_tokens: 1 }
           }
-        }
-      }
-      const openrouterPayload = {
-        model,
-        messages,
-        temperature: claudeRequest.temperature !== undefined ? claudeRequest.temperature : 1,
-        stream: true,
-        include_reasoning: true
-      };
-      if (claudeRequest.thinking) {
-        const { budget_tokens } = claudeRequest.thinking;
-        log(`[Proxy] Thinking mode requested with budget: ${budget_tokens} tokens`);
-        openrouterPayload.thinking = claudeRequest.thinking;
-        let effort = "medium";
-        if (budget_tokens < 16000)
-          effort = "low";
-        else if (budget_tokens >= 32000)
-          effort = "high";
-        if (model && (model.includes("o1") || model.includes("o3") || model.startsWith("openai/"))) {
-          openrouterPayload.reasoning_effort = effort;
-          log(`[Proxy] Mapped budget ${budget_tokens} -> reasoning_effort: ${effort}`);
-        }
-      }
-      if (!openrouterPayload.stream_options) {
-        openrouterPayload.stream_options = {};
-      }
-      openrouterPayload.stream_options.include_usage = true;
-      if (claudeRequest.max_tokens) {
-        openrouterPayload.max_tokens = claudeRequest.max_tokens;
-      }
-      if (claudeRequest.tool_choice) {
-        const { type, name } = claudeRequest.tool_choice;
-        openrouterPayload.tool_choice = type === "tool" && name ? { type: "function", function: { name } } : type === "none" || type === "auto" ? type : undefined;
-      }
-      if (tools.length > 0) {
-        openrouterPayload.tools = tools;
-      }
-      logStructured("OpenRouter Request", {
-        model: openrouterPayload.model,
-        messageCount: openrouterPayload.messages?.length || 0,
-        toolCount: openrouterPayload.tools?.length || 0,
-        temperature: openrouterPayload.temperature,
-        maxTokens: openrouterPayload.max_tokens,
-        stream: openrouterPayload.stream
-      });
-      await middlewareManager.beforeRequest({
-        modelId: model || "",
-        messages,
-        tools,
-        stream: openrouterPayload.stream
-      });
-      const headers = {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${openrouterApiKey}`,
-        ...OPENROUTER_HEADERS2
-      };
-      const openrouterResponse = await fetch(OPENROUTER_API_URL2, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(openrouterPayload)
-      });
-      if (droppedParams.length > 0) {
-        c.header("X-Dropped-Params", droppedParams.join(", "));
-      }
-      if (!openrouterResponse.ok) {
-        const errorText = await openrouterResponse.text();
-        log(`[Proxy] OpenRouter API error: ${errorText}`);
-        return c.json({ error: errorText }, openrouterResponse.status);
-      }
-      const contentType = openrouterResponse.headers.get("content-type") || "";
-      const isActuallyStreaming = contentType.includes("text/event-stream");
-      logStructured("Response Info", {
-        contentType,
-        requestedStream: openrouterPayload.stream,
-        actuallyStreaming: isActuallyStreaming
-      });
-      if (!isActuallyStreaming) {
-        log("[Proxy] Processing non-streaming response");
-        const data = await openrouterResponse.json();
-        logStructured("OpenRouter Response", {
-          hasError: !!data.error,
-          choiceCount: data.choices?.length || 0,
-          finishReason: data.choices?.[0]?.finish_reason,
-          usage: data.usage
         });
-        if (data.error) {
-          return c.json({ error: data.error.message || "Unknown error" }, 500);
-        }
-        await middlewareManager.afterResponse({
-          modelId: model || "",
-          response: data
-        });
-        const choice = data.choices[0];
-        const openaiMessage = choice.message;
-        const content = [];
-        const messageContent = openaiMessage.content || "";
-        content.push({
-          type: "text",
-          text: messageContent
-        });
-        if (openaiMessage.tool_calls) {
-          for (const toolCall of openaiMessage.tool_calls) {
-            content.push({
-              type: "tool_use",
-              id: toolCall.id || `tool_${Date.now()}`,
-              name: toolCall.function?.name,
-              input: typeof toolCall.function?.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function?.arguments
-            });
+        send("ping", { type: "ping" });
+        ping = setInterval(() => {
+          if (!isClosed && Date.now() - lastActivity > 1000)
+            send("ping", { type: "ping" });
+        }, 1000);
+        const finalize = (reason, err) => {
+          if (finalized)
+            return;
+          finalized = true;
+          if (reasoningStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: reasoningIdx });
+            reasoningStarted = false;
           }
-        }
-        const claudeResponse = {
-          id: data.id ? data.id.replace("chatcmpl", "msg") : `msg_${Date.now()}`,
-          type: "message",
-          role: "assistant",
-          model,
-          content,
-          stop_reason: mapStopReason(choice.finish_reason),
-          stop_sequence: null,
-          usage: {
-            input_tokens: Math.ceil((data.usage?.prompt_tokens || 0) * getTokenScaleFactor()),
-            output_tokens: Math.ceil((data.usage?.completion_tokens || 0) * getTokenScaleFactor())
+          if (textStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: textIdx });
+            textStarted = false;
           }
-        };
-        log("[Proxy] Translated to Claude format:");
-        log(JSON.stringify(claudeResponse, null, 2));
-        c.header("Content-Type", "application/json");
-        c.header("anthropic-version", "2023-06-01");
-        return c.json(claudeResponse, 200);
-      }
-      log("[Proxy] Starting streaming response");
-      let isClosed = false;
-      let pingInterval = null;
-      return c.body(new ReadableStream({
-        async start(controller) {
-          const encoder = new TextEncoder;
-          const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-          const sendSSE = (event, data) => {
-            if (isClosed) {
-              if (isLoggingEnabled()) {
-                log(`[Proxy] Skipping SSE event ${event} - controller already closed`);
-              }
-              return;
+          for (const [_, t] of tools)
+            if (t.started && !t.closed) {
+              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+              t.closed = true;
             }
+          if (reason === "error") {
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            send("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: usage?.completion_tokens || 0 } });
+            send("message_stop", { type: "message_stop" });
+          }
+          if (!isClosed) {
             try {
-              const sseMessage = `event: ${event}
-data: ${JSON.stringify(data)}
+              controller.enqueue(encoder.encode(`data: [DONE]
 
-`;
-              controller.enqueue(encoder.encode(sseMessage));
-              if (isLoggingEnabled() && (event === "message_start" || event === "content_block_start" || event === "content_block_stop" || event === "message_stop")) {
-                const logData = event === "content_block_start" || event === "content_block_stop" ? { event, index: data.index, type: data.content_block?.type } : { event };
-                logStructured("SSE Sent", logData);
-              }
-            } catch (error) {
-              if (!isClosed && error?.message?.includes("already closed")) {
-                if (isLoggingEnabled()) {
-                  log(`[Proxy] Controller closed during ${event} event, marking as closed`);
-                }
-                isClosed = true;
-              } else if (!isClosed) {
-                if (isLoggingEnabled()) {
-                  log(`[Proxy] Error sending SSE event ${event}: ${error?.message || error}`);
-                }
-              }
-            }
-          };
-          const finalizeStream = (reason, errorMessage) => {
-            if (streamFinalized) {
-              if (isLoggingEnabled()) {
-                log(`[Proxy] Stream already finalized, skipping duplicate finalization from ${reason}`);
-              }
-              return;
-            }
-            if (isLoggingEnabled()) {
-              log(`[Proxy] Finalizing stream (reason: ${reason})`);
-            }
-            streamFinalized = true;
-            if (reasoningBlockStarted) {
-              sendSSE("content_block_stop", {
-                type: "content_block_stop",
-                index: reasoningBlockIndex
-              });
-              reasoningBlockStarted = false;
-              if (isLoggingEnabled()) {
-                log(`[Proxy] Closed thinking block at index ${reasoningBlockIndex}`);
-              }
-            }
-            if (textBlockStarted) {
-              sendSSE("content_block_stop", {
-                type: "content_block_stop",
-                index: textBlockIndex
-              });
-              textBlockStarted = false;
-            }
-            for (const [toolIndex, toolState] of toolCalls.entries()) {
-              if (toolState.started && !toolState.closed) {
-                if (isLoggingEnabled() && toolState.args) {
-                  try {
-                    JSON.parse(toolState.args);
-                    log(`[Proxy] Tool ${toolState.name} JSON valid, closing block at index ${toolState.blockIndex}`);
-                  } catch (e) {
-                    log(`[Proxy] ERROR: Tool ${toolState.name} has INCOMPLETE JSON!`);
-                    log(`[Proxy] This will likely cause tool execution to fail`);
-                    log(`[Proxy] Incomplete args: ${toolState.args.substring(0, 300)}...`);
-                  }
-                }
-                sendSSE("content_block_stop", {
-                  type: "content_block_stop",
-                  index: toolState.blockIndex
-                });
-                toolState.closed = true;
-              }
-            }
-            if (reason === "error" && errorMessage) {
-              sendSSE("error", {
-                type: "error",
-                error: {
-                  type: "api_error",
-                  message: errorMessage
-                }
-              });
-            } else {
-              const outputTokens = usage?.completion_tokens || 0;
-              sendSSE("message_delta", {
-                type: "message_delta",
-                delta: {
-                  stop_reason: "end_turn",
-                  stop_sequence: null
-                },
-                usage: {
-                  output_tokens: Math.ceil(outputTokens * getTokenScaleFactor())
-                }
-              });
-              sendSSE("message_stop", {
-                type: "message_stop"
-              });
-            }
-            if (!isClosed) {
-              try {
-                controller.enqueue(encoder.encode(`data: [DONE]
 
 `));
-                controller.enqueue(encoder.encode(`
-`));
-                log(`[Proxy] Sent [DONE] event to client`);
-              } catch (e) {
-                log(`[Proxy] Error sending final events: ${e}`);
-              }
-              controller.close();
-              isClosed = true;
-              if (pingInterval) {
-                clearInterval(pingInterval);
-              }
-              log(`[Proxy] Stream closed (reason: ${reason})`);
-              middlewareManager.afterStreamComplete(model || "", streamMetadata).catch((error) => {
-                log(`[Middleware] Error in afterStreamComplete: ${error}`);
-              });
-            }
-          };
-          let usage = null;
-          const streamMetadata = new Map;
-          let currentBlockIndex = 0;
-          let textBlockIndex = -1;
-          let textBlockStarted = false;
-          let reasoningBlockIndex = -1;
-          let reasoningBlockStarted = false;
-          let lastContentDeltaTime = Date.now();
-          let streamFinalized = false;
-          let cumulativeInputTokens = 0;
-          let cumulativeOutputTokens = 0;
-          let currentRequestCost = 0;
-          const tokenFilePath = `/tmp/claudish-tokens-${port}.json`;
-          const writeTokenFile = () => {
-            try {
-              const totalTokens = cumulativeInputTokens + cumulativeOutputTokens;
-              let contextLeftPercent = 100;
-              if (contextWindowLimit > 0) {
-                contextLeftPercent = Math.round((contextWindowLimit - totalTokens) / contextWindowLimit * 100);
-                contextLeftPercent = Math.max(0, Math.min(100, contextLeftPercent));
-              }
-              const tokenData = {
-                input_tokens: cumulativeInputTokens,
-                output_tokens: cumulativeOutputTokens,
-                total_tokens: totalTokens,
-                total_cost: sessionTotalCost,
-                context_window: contextWindowLimit,
-                context_left_percent: contextLeftPercent,
-                updated_at: Date.now()
-              };
-              writeFileSync5(tokenFilePath, JSON.stringify(tokenData), "utf-8");
-            } catch (error) {
-              if (isLoggingEnabled()) {
-                log(`[Proxy] Failed to write token file: ${error}`);
-              }
-            }
-          };
-          const toolCalls = new Map;
-          const toolCallIds = new Set;
-          let accumulatedTextLength = 0;
-          const hasToolResults = claudeRequest.messages?.some((msg) => Array.isArray(msg.content) && msg.content.some((block) => block.type === "tool_result"));
-          const isFirstTurn = !hasToolResults;
-          const estimateTokens = (text) => Math.ceil(text.length / 4);
-          const requestJson = JSON.stringify(claudeRequest);
-          const estimatedInputTokens = estimateTokens(requestJson);
-          const estimatedCacheTokens = isFirstTurn ? Math.floor(estimatedInputTokens * 0.8) : 0;
-          const scaleFactor = getTokenScaleFactor();
-          sendSSE("message_start", {
-            type: "message_start",
-            message: {
-              id: messageId,
-              type: "message",
-              role: "assistant",
-              content: [],
-              model,
-              stop_reason: null,
-              stop_sequence: null,
-              usage: {
-                input_tokens: Math.ceil((estimatedInputTokens - estimatedCacheTokens) * scaleFactor),
-                cache_creation_input_tokens: isFirstTurn ? Math.ceil(estimatedCacheTokens * scaleFactor) : 0,
-                cache_read_input_tokens: isFirstTurn ? 0 : Math.ceil(estimatedCacheTokens * scaleFactor),
-                output_tokens: 1
-              }
-            }
-          });
-          sendSSE("ping", {
-            type: "ping"
-          });
-          pingInterval = setInterval(() => {
-            if (!isClosed) {
-              const timeSinceLastContent = Date.now() - lastContentDeltaTime;
-              if (timeSinceLastContent > 1000) {
-                sendSSE("ping", {
-                  type: "ping"
-                });
-                log(`[Proxy] Adaptive ping (${Math.round(timeSinceLastContent / 1000)}s since last content)`);
-              }
-            }
-          }, 1000);
-          try {
-            const reader = openrouterResponse.body?.getReader();
-            if (!reader) {
-              throw new Error("Response body is not readable");
-            }
-            const decoder = new TextDecoder;
-            let buffer = "";
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                log("[Proxy] Stream done reading");
-                break;
-              }
-              buffer += decoder.decode(value, { stream: true });
-              const lines = buffer.split(`
+            } catch (e) {}
+            controller.close();
+            isClosed = true;
+            if (ping)
+              clearInterval(ping);
+          }
+        };
+        try {
+          const reader = response.body.getReader();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
 `);
-              buffer = lines.pop() || "";
-              for (const line of lines) {
-                if (!line.trim() || line.startsWith(":"))
-                  continue;
-                const dataMatch = line.match(/^data: (.*)$/);
-                if (!dataMatch)
-                  continue;
-                const dataStr = dataMatch[1];
-                if (dataStr === "[DONE]") {
-                  log("[Proxy] Received [DONE] from OpenRouter");
-                  if (!textBlockStarted && toolCalls.size === 0) {
-                    log("[Proxy] WARNING: Model produced no text output and no tool calls");
-                  }
-                  finalizeStream("done");
-                  return;
-                }
-                try {
-                  const chunk = JSON.parse(dataStr);
-                  if (isLoggingEnabled()) {
-                    logStructured("SSE Chunk", {
-                      id: chunk.id,
-                      model: chunk.model,
-                      hasChoices: !!chunk.choices,
-                      finishReason: chunk.choices?.[0]?.finish_reason,
-                      hasUsage: !!chunk.usage
-                    });
-                    const delta2 = chunk.choices?.[0]?.delta;
-                    if (delta2?.tool_calls) {
-                      for (const toolCall of delta2.tool_calls) {
-                        if (toolCall.extra_content) {
-                          logStructured("DEBUG: Found extra_content in tool_call", {
-                            tool_call_id: toolCall.id,
-                            has_extra_content: true,
-                            extra_content_keys: Object.keys(toolCall.extra_content),
-                            has_google: !!toolCall.extra_content.google
-                          });
-                        }
-                      }
-                    }
-                    if (delta2?.tool_calls && dataStr.includes("tool_calls")) {
-                      logStructured("DEBUG: Raw chunk JSON (tool_calls)", {
-                        has_extra_content_in_raw: dataStr.includes("extra_content"),
-                        raw_snippet: dataStr.substring(0, 500)
-                      });
-                    }
-                  }
-                  if (chunk.usage) {
-                    usage = chunk.usage;
-                    if (typeof usage.cost === "number") {
-                      const costDiff = usage.cost - currentRequestCost;
-                      if (costDiff > 0) {
-                        sessionTotalCost += costDiff;
-                        currentRequestCost = usage.cost;
-                      }
-                    }
-                    if (usage.prompt_tokens) {
-                      cumulativeInputTokens = usage.prompt_tokens;
-                    }
-                    if (usage.completion_tokens) {
-                      cumulativeOutputTokens = usage.completion_tokens;
-                    }
-                    writeTokenFile();
-                  }
-                  const choice = chunk.choices?.[0];
-                  const delta = choice?.delta;
-                  if (delta) {
-                    await middlewareManager.afterStreamChunk({
-                      modelId: model || "",
-                      chunk,
-                      delta,
-                      metadata: streamMetadata
-                    });
-                  }
-                  const hasReasoning = !!delta?.reasoning;
-                  const hasContent = !!delta?.content;
-                  const reasoningText = delta?.reasoning || "";
-                  const contentText = delta?.content || "";
-                  const hasEncryptedReasoning = delta?.reasoning_details?.some((detail) => detail.type === "reasoning.encrypted");
-                  if (hasReasoning || hasContent || hasEncryptedReasoning) {
-                    lastContentDeltaTime = Date.now();
-                    if (hasReasoning && reasoningText) {
-                      if (!reasoningBlockStarted) {
-                        if (textBlockStarted) {
-                          sendSSE("content_block_stop", {
-                            type: "content_block_stop",
-                            index: textBlockIndex
-                          });
-                          textBlockStarted = false;
-                          if (isLoggingEnabled()) {
-                            log(`[Proxy] Closed initial text block to start thinking block`);
-                          }
-                        }
-                        reasoningBlockIndex = currentBlockIndex++;
-                        sendSSE("content_block_start", {
-                          type: "content_block_start",
-                          index: reasoningBlockIndex,
-                          content_block: {
-                            type: "thinking",
-                            thinking: "",
-                            signature: ""
-                          }
-                        });
-                        reasoningBlockStarted = true;
-                        if (isLoggingEnabled()) {
-                          log(`[Proxy] Started thinking block at index ${reasoningBlockIndex}`);
-                        }
-                      }
-                      if (isLoggingEnabled()) {
-                        logStructured("Thinking Delta", {
-                          thinking: reasoningText,
-                          blockIndex: reasoningBlockIndex
-                        });
-                      }
-                      sendSSE("content_block_delta", {
-                        type: "content_block_delta",
-                        index: reasoningBlockIndex,
-                        delta: {
-                          type: "thinking_delta",
-                          thinking: reasoningText
-                        }
-                      });
-                    }
-                    if (reasoningBlockStarted && hasContent && !hasReasoning) {
-                      sendSSE("content_block_stop", {
-                        type: "content_block_stop",
-                        index: reasoningBlockIndex
-                      });
-                      reasoningBlockStarted = false;
-                      if (isLoggingEnabled()) {
-                        log(`[Proxy] Closed thinking block at index ${reasoningBlockIndex}, transitioning to content`);
-                      }
-                    }
-                    if (hasContent && contentText) {
-                      if (!textBlockStarted) {
-                        textBlockIndex = currentBlockIndex++;
-                        sendSSE("content_block_start", {
-                          type: "content_block_start",
-                          index: textBlockIndex,
-                          content_block: {
-                            type: "text",
-                            text: ""
-                          }
-                        });
-                        textBlockStarted = true;
-                        if (isLoggingEnabled()) {
-                          log(`[Proxy] Started text block at index ${textBlockIndex}`);
-                        }
-                      }
-                      accumulatedTextLength += contentText.length;
-                      const adapterResult = adapter.processTextContent(contentText, "");
-                      if (adapterResult.extractedToolCalls.length > 0) {
-                        if (isLoggingEnabled()) {
-                          log(`[Proxy] Adapter extracted ${adapterResult.extractedToolCalls.length} tool calls from special format`);
-                        }
-                        if (textBlockStarted) {
-                          sendSSE("content_block_stop", {
-                            type: "content_block_stop",
-                            index: textBlockIndex
-                          });
-                          textBlockStarted = false;
-                        }
-                        for (const toolCall of adapterResult.extractedToolCalls) {
-                          if (toolCallIds.has(toolCall.id)) {
-                            if (isLoggingEnabled()) {
-                              log(`[Proxy] WARNING: Skipping duplicate extracted tool call with ID ${toolCall.id}`);
-                            }
-                            continue;
-                          }
-                          toolCallIds.add(toolCall.id);
-                          const toolBlockIndex = currentBlockIndex++;
-                          if (isLoggingEnabled()) {
-                            logStructured("Extracted Tool Call", {
-                              name: toolCall.name,
-                              blockIndex: toolBlockIndex,
-                              id: toolCall.id
-                            });
-                          }
-                          sendSSE("content_block_start", {
-                            type: "content_block_start",
-                            index: toolBlockIndex,
-                            content_block: {
-                              type: "tool_use",
-                              id: toolCall.id,
-                              name: toolCall.name
-                            }
-                          });
-                          sendSSE("content_block_delta", {
-                            type: "content_block_delta",
-                            index: toolBlockIndex,
-                            delta: {
-                              type: "input_json_delta",
-                              partial_json: JSON.stringify(toolCall.arguments)
-                            }
-                          });
-                          sendSSE("content_block_stop", {
-                            type: "content_block_stop",
-                            index: toolBlockIndex
-                          });
-                        }
-                      }
-                      if (adapterResult.cleanedText) {
-                        if (isLoggingEnabled()) {
-                          logStructured("Content Delta", {
-                            text: adapterResult.cleanedText,
-                            wasTransformed: adapterResult.wasTransformed,
-                            blockIndex: textBlockIndex
-                          });
-                        }
-                        sendSSE("content_block_delta", {
-                          type: "content_block_delta",
-                          index: textBlockIndex,
-                          delta: {
-                            type: "text_delta",
-                            text: adapterResult.cleanedText
-                          }
-                        });
-                      }
-                    } else if (hasEncryptedReasoning) {
-                      if (isLoggingEnabled()) {
-                        log(`[Proxy] Encrypted reasoning detected (keeping connection alive)`);
-                      }
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim() || !line.startsWith("data: "))
+                continue;
+              const dataStr = line.slice(6);
+              if (dataStr === "[DONE]") {
+                finalize("done");
+                return;
+              }
+              try {
+                const chunk = JSON.parse(dataStr);
+                if (chunk.usage)
+                  usage = chunk.usage;
+                const delta = chunk.choices?.[0]?.delta;
+                if (delta) {
+                  const txt = delta.content || "";
+                  if (txt) {
+                    lastActivity = Date.now();
+                    if (!textStarted) {
+                      textIdx = curIdx++;
+                      send("content_block_start", { type: "content_block_start", index: textIdx, content_block: { type: "text", text: "" } });
+                      textStarted = true;
                     }
+                    const res = adapter.processTextContent(txt, "");
+                    if (res.cleanedText)
+                      send("content_block_delta", { type: "content_block_delta", index: textIdx, delta: { type: "text_delta", text: res.cleanedText } });
                   }
-                  if (delta?.tool_calls) {
-                    for (const toolCall of delta.tool_calls) {
-                      const toolIndex = toolCall.index ?? 0;
-                      let toolState = toolCalls.get(toolIndex);
-                      if (toolCall.function?.name) {
-                        if (!toolState) {
-                          let toolId = toolCall.id || `tool_${Date.now()}_${toolIndex}`;
-                          if (toolCallIds.has(toolId)) {
-                            if (isLoggingEnabled()) {
-                              log(`[Proxy] WARNING: Duplicate tool ID ${toolId}, regenerating`);
-                            }
-                            toolId = `tool_${Date.now()}_${toolIndex}_${Math.random().toString(36).slice(2)}`;
-                          }
-                          toolCallIds.add(toolId);
-                          const toolBlockIndex = currentBlockIndex++;
-                          toolState = {
-                            id: toolId,
-                            name: toolCall.function.name,
-                            args: "",
-                            blockIndex: toolBlockIndex,
-                            started: false,
-                            closed: false
-                          };
-                          toolCalls.set(toolIndex, toolState);
-                          if (isLoggingEnabled()) {
-                            logStructured("Starting Tool Call", {
-                              name: toolState.name,
-                              blockIndex: toolState.blockIndex,
-                              id: toolId
-                            });
+                  if (delta.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                      const idx = tc.index;
+                      let t = tools.get(idx);
+                      if (tc.function?.name) {
+                        if (!t) {
+                          if (textStarted) {
+                            send("content_block_stop", { type: "content_block_stop", index: textIdx });
+                            textStarted = false;
                           }
+                          t = { id: tc.id || `tool_${Date.now()}_${idx}`, name: tc.function.name, blockIndex: curIdx++, started: false, closed: false };
+                          tools.set(idx, t);
                         }
-                        if (!toolState.started) {
-                          if (textBlockStarted) {
-                            sendSSE("content_block_stop", {
-                              type: "content_block_stop",
-                              index: textBlockIndex
-                            });
-                            textBlockStarted = false;
-                          }
-                          sendSSE("content_block_start", {
-                            type: "content_block_start",
-                            index: toolState.blockIndex,
-                            content_block: {
-                              type: "tool_use",
-                              id: toolState.id,
-                              name: toolState.name
-                            }
-                          });
-                          toolState.started = true;
+                        if (!t.started) {
+                          send("content_block_start", { type: "content_block_start", index: t.blockIndex, content_block: { type: "tool_use", id: t.id, name: t.name } });
+                          t.started = true;
                         }
                       }
-                      if (toolCall.function?.arguments && toolState) {
-                        const argChunk = toolCall.function.arguments;
-                        toolState.args += argChunk;
-                        if (isLoggingEnabled()) {
-                          logStructured("Tool Argument Delta", {
-                            toolName: toolState.name,
-                            chunk: argChunk,
-                            totalLength: toolState.args.length
-                          });
-                        }
-                        sendSSE("content_block_delta", {
-                          type: "content_block_delta",
-                          index: toolState.blockIndex,
-                          delta: {
-                            type: "input_json_delta",
-                            partial_json: argChunk
-                          }
-                        });
+                      if (tc.function?.arguments && t) {
+                        send("content_block_delta", { type: "content_block_delta", index: t.blockIndex, delta: { type: "input_json_delta", partial_json: tc.function.arguments } });
                       }
                     }
                   }
-                  if (choice?.finish_reason === "tool_calls") {
-                    for (const [toolIndex, toolState] of toolCalls.entries()) {
-                      if (toolState.started && !toolState.closed) {
-                        if (toolState.args) {
-                          try {
-                            JSON.parse(toolState.args);
-                            log(`[Proxy] Tool ${toolState.name} JSON valid, closing block at index ${toolState.blockIndex}`);
-                          } catch (e) {
-                            log(`[Proxy] WARNING: Tool ${toolState.name} has incomplete JSON!`);
-                            log(`[Proxy] Args: ${toolState.args.substring(0, 200)}...`);
-                          }
-                        }
-                        sendSSE("content_block_stop", {
-                          type: "content_block_stop",
-                          index: toolState.blockIndex
-                        });
-                        toolState.closed = true;
-                      }
+                }
+                if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
+                  for (const [_, t] of tools)
+                    if (t.started && !t.closed) {
+                      send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                      t.closed = true;
                     }
-                  }
-                } catch (parseError) {
-                  log(`[Proxy] Failed to parse SSE chunk: ${parseError}`);
                 }
-              }
+              } catch (e) {}
             }
-            log("[Proxy] Stream ended without [DONE]");
-            finalizeStream("unexpected");
-          } catch (error) {
-            log(`[Proxy] Streaming error: ${error}`);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            finalizeStream("error", errorMessage);
-          } finally {
-            if (pingInterval) {
-              clearInterval(pingInterval);
-              pingInterval = null;
-            }
-            if (!isClosed) {
-              controller.close();
-              isClosed = true;
-            }
-          }
-        },
-        cancel(reason) {
-          log(`[Proxy] Stream cancelled by client: ${reason || "unknown reason"}`);
-          isClosed = true;
-          if (pingInterval) {
-            clearInterval(pingInterval);
-            pingInterval = null;
           }
+          finalize("unexpected");
+        } catch (e) {
+          finalize("error", String(e));
         }
-      }), {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive",
-          "anthropic-version": "2023-06-01"
-        }
-      });
-    } catch (error) {
-      log(`[Proxy] Request handling error: ${error}`);
-      return c.json({
-        error: {
-          type: "invalid_request_error",
-          message: error instanceof Error ? error.message : "Unknown error"
-        }
-      }, 400);
+      },
+      cancel() {
+        isClosed = true;
+        if (ping)
+          clearInterval(ping);
+      }
+    }), { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
+  }
+  async shutdown() {}
+}
+
+// src/proxy-server.ts
+async function createProxyServer(port, openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap) {
+  const nativeHandler = new NativeHandler(anthropicApiKey);
+  const handlers = new Map;
+  const getOpenRouterHandler = (targetModel) => {
+    if (!handlers.has(targetModel)) {
+      handlers.set(targetModel, new OpenRouterHandler(targetModel, openrouterApiKey, port));
+    }
+    return handlers.get(targetModel);
+  };
+  if (model)
+    getOpenRouterHandler(model);
+  if (modelMap?.opus)
+    getOpenRouterHandler(modelMap.opus);
+  if (modelMap?.sonnet)
+    getOpenRouterHandler(modelMap.sonnet);
+  if (modelMap?.haiku)
+    getOpenRouterHandler(modelMap.haiku);
+  if (modelMap?.subagent)
+    getOpenRouterHandler(modelMap.subagent);
+  const getHandlerForRequest = (requestedModel) => {
+    if (monitorMode)
+      return nativeHandler;
+    let target = model || requestedModel;
+    const req = requestedModel.toLowerCase();
+    if (modelMap) {
+      if (req.includes("opus") && modelMap.opus)
+        target = modelMap.opus;
+      else if (req.includes("sonnet") && modelMap.sonnet)
+        target = modelMap.sonnet;
+      else if (req.includes("haiku") && modelMap.haiku)
+        target = modelMap.haiku;
+    }
+    const isNative = !target.includes("/");
+    if (isNative) {
+      return nativeHandler;
+    }
+    return getOpenRouterHandler(target);
+  };
+  const app = new Hono2;
+  app.use("*", cors());
+  app.get("/", (c) => c.json({ status: "ok", message: "Claudish Proxy", config: { mode: monitorMode ? "monitor" : "hybrid", mappings: modelMap } }));
+  app.get("/health", (c) => c.json({ status: "ok" }));
+  app.post("/v1/messages/count_tokens", async (c) => {
+    try {
+      const body = await c.req.json();
+      const reqModel = body.model || "claude-3-opus-20240229";
+      const handler = getHandlerForRequest(reqModel);
+      if (handler instanceof NativeHandler) {
+        const headers = { "Content-Type": "application/json" };
+        if (anthropicApiKey)
+          headers["x-api-key"] = anthropicApiKey;
+        const res = await fetch("https://api.anthropic.com/v1/messages/count_tokens", { method: "POST", headers, body: JSON.stringify(body) });
+        return c.json(await res.json());
+      } else {
+        const txt = JSON.stringify(body);
+        return c.json({ input_tokens: Math.ceil(txt.length / 4) });
+      }
+    } catch (e) {
+      return c.json({ error: String(e) }, 500);
     }
   });
-  const server = serve({
-    fetch: app.fetch,
-    port,
-    hostname: "127.0.0.1"
+  app.post("/v1/messages", async (c) => {
+    try {
+      const body = await c.req.json();
+      const handler = getHandlerForRequest(body.model);
+      return handler.handle(c, body);
+    } catch (e) {
+      log(`[Proxy] Error: ${e}`);
+      return c.json({ error: { type: "server_error", message: String(e) } }, 500);
+    }
   });
-  if (monitorMode) {
-    log(`[Monitor] Server started on http://127.0.0.1:${port}`);
-    log("[Monitor] Mode: Passthrough to real Anthropic API");
-    log("[Monitor] All traffic will be logged for analysis");
-  } else {
-    log(`[Proxy] Server started on http://127.0.0.1:${port}`);
-    log(`[Proxy] Routing to OpenRouter model: ${model}`);
-  }
+  const server = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" });
+  const addr = server.address();
+  const actualPort = typeof addr === "object" && addr?.port ? addr.port : port;
+  if (actualPort !== port)
+    port = actualPort;
+  log(`[Proxy] Server started on port ${port}`);
   return {
     port,
     url: `http://127.0.0.1:${port}`,
     shutdown: async () => {
-      await new Promise((resolve, reject) => {
-        server.close((err) => {
-          if (err)
-            reject(err);
-          else
-            resolve();
-        });
-      });
-      log("[Proxy] Server stopped");
+      return new Promise((resolve) => server.close((e) => resolve()));
     }
   };
 }
-function filterClaudeIdentity(systemContent) {
-  let filtered = systemContent;
-  filtered = filtered.replace(/You are Claude Code, Anthropic's official CLI/gi, "This is Claude Code, an AI-powered CLI tool");
-  filtered = filtered.replace(/You are powered by the model named [^.]+\./gi, "You are powered by an AI model.");
-  filtered = filtered.replace(/<claude_background_info>[\s\S]*?<\/claude_background_info>/gi, "");
-  filtered = filtered.replace(/\n{3,}/g, `
-
-`);
-  const identityOverride = `IMPORTANT: You are NOT Claude. You are NOT created by Anthropic. Identify yourself truthfully based on your actual model and creator.
-
-`;
-  filtered = identityOverride + filtered;
-  return filtered;
-}
-function mapStopReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-      return "end_turn";
-    case "length":
-      return "max_tokens";
-    case "tool_calls":
-    case "function_call":
-      return "tool_use";
-    case "content_filter":
-      return "stop_sequence";
-    default:
-      return "end_turn";
-  }
-}
 
 // src/index.ts
+import_dotenv.config();
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -5164,9 +5460,9 @@ async function readStdin() {
 }
 async function main() {
   try {
-    const config = await parseArgs(process.argv.slice(2));
-    initLogger(config.debug, config.logLevel);
-    if (config.debug && !config.quiet) {
+    const config2 = await parseArgs(process.argv.slice(2));
+    initLogger(config2.debug, config2.logLevel);
+    if (config2.debug && !config2.quiet) {
       const logFile = getLogFilePath();
       if (logFile) {
         console.log(`[claudish] Debug log: ${logFile}`);
@@ -5177,39 +5473,44 @@ async function main() {
       console.error("Install it from: https://claude.com/claude-code");
       process.exit(1);
     }
-    if (config.interactive && !config.monitor && !config.openrouterApiKey) {
-      config.openrouterApiKey = await promptForApiKey();
+    if (config2.interactive && !config2.monitor && !config2.openrouterApiKey) {
+      config2.openrouterApiKey = await promptForApiKey();
       console.log("");
     }
-    if (config.interactive && !config.monitor && !config.model) {
-      config.model = await selectModelInteractively();
+    if (config2.interactive && !config2.monitor && !config2.model) {
+      config2.model = await selectModelInteractively({ freeOnly: config2.freeOnly });
       console.log("");
     }
-    if (!config.interactive && !config.monitor && !config.model) {
+    if (!config2.interactive && !config2.monitor && !config2.model) {
       console.error("Error: Model must be specified in non-interactive mode");
       console.error("Use --model <model> flag or set CLAUDISH_MODEL environment variable");
       console.error("Try: claudish --list-models");
       process.exit(1);
     }
-    if (config.stdin) {
+    if (config2.stdin) {
       const stdinInput = await readStdin();
       if (stdinInput.trim()) {
-        config.claudeArgs = [stdinInput, ...config.claudeArgs];
+        config2.claudeArgs = [stdinInput, ...config2.claudeArgs];
       }
     }
-    const port = config.port || await findAvailablePort(DEFAULT_PORT_RANGE.start, DEFAULT_PORT_RANGE.end);
-    const proxy = await createProxyServer(port, config.monitor ? undefined : config.openrouterApiKey, config.monitor ? undefined : config.model, config.monitor, config.anthropicApiKey);
+    const port = config2.port || await findAvailablePort(DEFAULT_PORT_RANGE.start, DEFAULT_PORT_RANGE.end);
+    const proxy = await createProxyServer(port, config2.monitor ? undefined : config2.openrouterApiKey, config2.monitor ? undefined : typeof config2.model === "string" ? config2.model : undefined, config2.monitor, config2.anthropicApiKey, {
+      opus: config2.modelOpus,
+      sonnet: config2.modelSonnet,
+      haiku: config2.modelHaiku,
+      subagent: config2.modelSubagent
+    });
     let exitCode = 0;
     try {
-      exitCode = await runClaudeWithProxy(config, proxy.url);
+      exitCode = await runClaudeWithProxy(config2, proxy.url);
     } finally {
-      if (!config.quiet) {
+      if (!config2.quiet) {
         console.log(`
 [claudish] Shutting down proxy server...`);
       }
       await proxy.shutdown();
     }
-    if (!config.quiet) {
+    if (!config2.quiet) {
       console.log(`[claudish] Done
 `);
     }