claudish 7.12.7 → 7.14.0

package/AI_AGENT_GUIDE.md

@@ -266,7 +266,7 @@ for (const model of models) {
 | `--default-provider <name>` | Override default provider for bare model routing (v7.0.0+) | Auto-detected |
 | `--quiet` / `-q` | Suppress logs | Enabled in single-shot |
 | `--verbose` / `-v` | Show logs | Enabled in interactive |
-| `--log-debug` / `-d` | Debug logging to file | Disabled |
+| `--debug-claudish` / `-d` | Debug logging to file | Disabled |
 | `--no-auto-approve` | Require prompts | Auto-approve enabled |
 
 ### Claude Code Flag Passthrough

package/dist/index.js

@@ -581,7 +581,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.12.7";
+var VERSION = "7.14.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -31354,6 +31354,28 @@ var init_base_api_format = __esm(() => {
   };
 });
 
+// src/adapters/reasoning-cache.ts
+function rememberReasoningForCall(callId, items) {
+  if (!callId || items.length === 0)
+    return;
+  if (cache.has(callId))
+    cache.delete(callId);
+  cache.set(callId, items);
+  while (cache.size > MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+  }
+}
+function reasoningForCall(callId) {
+  return cache.get(callId);
+}
+var MAX_ENTRIES = 500, cache;
+var init_reasoning_cache = __esm(() => {
+  cache = new Map;
+});
+
 // src/adapters/codex-api-format.ts
 function normalizeCodexModel(modelId) {
   if (!modelId)
@@ -31365,6 +31387,7 @@ var CodexAPIFormat;
 var init_codex_api_format = __esm(() => {
   init_logger();
   init_base_api_format();
+  init_reasoning_cache();
   CodexAPIFormat = class CodexAPIFormat extends BaseAPIFormat {
     processTextContent(textContent, _accumulatedText) {
       return {
@@ -31387,6 +31410,10 @@ var init_codex_api_format = __esm(() => {
     }
     buildPayload(claudeRequest, messages, tools) {
       const convertedMessages = this.convertMessagesToResponsesAPI(messages);
+      const replayedReasoning = convertedMessages.filter((i) => i.type === "reasoning").length;
+      if (replayedReasoning > 0) {
+        log(`[CodexAPIFormat] replaying ${replayedReasoning} cached reasoning item(s)`);
+      }
       const normalizedModel = normalizeCodexModel(this.modelId);
       const strippedMessages = convertedMessages.map((item) => {
         const { id, ...rest } = item;
@@ -31491,6 +31518,9 @@ var init_codex_api_format = __esm(() => {
           }
           for (const toolCall of msg.tool_calls) {
             if (toolCall.type === "function") {
+              const reasoning = reasoningForCall(toolCall.id);
+              if (reasoning?.length)
+                result.push(...reasoning);
               result.push({
                 type: "function_call",
                 call_id: toolCall.id,
@@ -36157,10 +36187,10 @@ function getCachedEntries() {
   if (mtimeMs === _memoMtimeMs && _memoEntries !== null) {
     return _memoEntries;
   }
-  const cache = readAllModelsCache();
-  if (!cache)
+  const cache2 = readAllModelsCache();
+  if (!cache2)
     return null;
-  _memoEntries = cache.entries;
+  _memoEntries = cache2.entries;
   _memoMtimeMs = mtimeMs;
   return _memoEntries;
 }
@@ -38150,6 +38180,7 @@ function createResponsesStreamHandler(c, response, opts) {
   let reasoningIdx = -1;
   let lastSummaryIndex = -1;
   let incompleteReason = null;
+  let pendingReasoning = [];
   let inputTokens = 0;
   let outputTokens = 0;
   let hasToolUse = false;
@@ -38266,6 +38297,10 @@ data: ${JSON.stringify(data)}
                     functionCalls.set(itemId, fnCallData);
                   }
                   openToolBlocks.add(fnCallData);
+                  if (pendingReasoning.length > 0) {
+                    rememberReasoningForCall(callId, pendingReasoning);
+                    pendingReasoning = [];
+                  }
                   send("content_block_start", {
                     type: "content_block_start",
                     index: fnCallData.index,
@@ -38311,6 +38346,14 @@ data: ${JSON.stringify(data)}
                   });
                 }
               } else if (event.type === "response.output_item.done") {
+                if (event.item?.type === "reasoning" && event.item.encrypted_content) {
+                  pendingReasoning.push({
+                    type: "reasoning",
+                    content: event.item.content ?? [],
+                    encrypted_content: event.item.encrypted_content,
+                    summary: event.item.summary ?? []
+                  });
+                }
                 if (event.item?.type === "function_call") {
                   const callId = event.item.call_id || event.item.id;
                   const fnCall = functionCalls.get(callId) || functionCalls.get(event.item.id);
@@ -38449,6 +38492,7 @@ data: ${JSON.stringify(data)}
   });
 }
 var init_openai_responses_sse = __esm(() => {
+  init_reasoning_cache();
   init_logger();
 });
 
@@ -39446,15 +39490,15 @@ class OpenRouterCatalogResolver {
   _getEntries() {
     if (_memCache)
       return _memCache;
-    const cache = readAllModelsCache();
-    if (!cache)
+    const cache2 = readAllModelsCache();
+    if (!cache2)
       return null;
-    if (cache.entries.length > 0) {
-      _memCache = cache.entries;
+    if (cache2.entries.length > 0) {
+      _memCache = cache2.entries;
       return _memCache;
     }
-    if (cache.models.length > 0) {
-      _memCache = cache.models.map((m) => ({
+    if (cache2.models.length > 0) {
+      _memCache = cache2.models.map((m) => ({
         modelId: m.id.includes("/") ? m.id.split("/").slice(1).join("/") : m.id,
         aliases: [],
         sources: { "openrouter-api": { externalId: m.id } }
@@ -58397,8 +58441,8 @@ async function codexQuotaHandler() {
   try {
     const modelsPath = join22(homedir21(), ".codex", "models_cache.json");
     if (existsSync20(modelsPath)) {
-      const cache = JSON.parse(readFileSync18(modelsPath, "utf-8"));
-      modelSlugs = (cache.models || []).map((m) => m.slug || m.id).filter(Boolean);
+      const cache2 = JSON.parse(readFileSync18(modelsPath, "utf-8"));
+      modelSlugs = (cache2.models || []).map((m) => m.slug || m.id).filter(Boolean);
     }
   } catch {}
   const W = 58;
@@ -58636,13 +58680,13 @@ function slimEntryToCatalogModel(entry) {
   };
 }
 function readSlimCacheWithFreshness(reader) {
-  const cache = reader();
-  if (!cache)
+  const cache2 = reader();
+  if (!cache2)
     return { entries: [], stale: true };
-  const lastUpdatedMs = new Date(cache.lastUpdated).getTime();
+  const lastUpdatedMs = new Date(cache2.lastUpdated).getTime();
   const ageMs = Date.now() - lastUpdatedMs;
   const stale = !Number.isFinite(lastUpdatedMs) || ageMs > FIREBASE_CACHE_TTL_MS;
-  return { entries: cache.entries ?? [], stale };
+  return { entries: cache2.entries ?? [], stale };
 }
 function createCatalogClient(deps = {}) {
   const _getModelsByProvider = deps.getModelsByProvider ?? getModelsByProvider;
@@ -62424,11 +62468,14 @@ async function parseArgs(args) {
       config3.dangerous = true;
     } else if (arg === "--interactive" || arg === "-i") {
       config3.interactive = true;
-    } else if (arg === "--log-debug" || arg === "-d") {
+    } else if (arg === "--debug-claudish" || arg === "-d") {
       config3.debug = true;
       if (config3.logLevel === "info") {
         config3.logLevel = "debug";
       }
+    } else if (arg === "--log-debug") {
+      console.error("--log-debug was renamed to --debug-claudish (it enables claudish's own debug log, not Claude Code's --debug).");
+      process.exit(1);
     } else if (arg === "--log-level") {
       const levelArg = args[++i];
       if (!levelArg || !["debug", "info", "minimal"].includes(levelArg)) {
@@ -62649,7 +62696,7 @@ Usage:  claudish --models --provider <slug>`);
     if (!config3.quiet) {
       console.log("[claudish] Monitor mode enabled - proxying to real Anthropic API");
       console.log("[claudish] Using Claude Code's native authentication");
-      console.log("[claudish] Tip: Run with --log-debug to see request/response details");
+      console.log("[claudish] Tip: Run with --debug-claudish to see request/response details");
     }
   }
   config3.openrouterApiKey = process.env[ENV.OPENROUTER_API_KEY];
@@ -63530,7 +63577,7 @@ ${h("OPTIONS")}
   ${green("--op")} ${yellow("<glob>")} ${green("--list")}      Preview which fields the glob would import (names only, no values)
   ${green("--op-env")} ${yellow("<id>")}            Load env vars from a 1Password Environment (highest priority)
   ${green("--port")} ${yellow("<port>")}            Proxy server port (default: random)
-  ${green("-d, --log-debug")}          Enable debug logging to file (logs/claudish_*.log)
+  ${green("-d, --debug-claudish")}     Enable claudish debug logging to file (logs/claudish_*.log)
   ${green("--log-off")}                Disable always-on structural logging (~/.claudish/logs/)
   ${green("--log-diag")} ${yellow("<mode>")}        Diagnostic output: auto (default), logfile, off
                            ${dim('Also: CLAUDISH_DIAG_MODE env var or "diagMode" in config.json')}
@@ -63913,8 +63960,8 @@ function writeCache(latestVersion) {
     writeFileSync15(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
-function isCacheValid(cache) {
-  const age = Date.now() - cache.lastCheck;
+function isCacheValid(cache2) {
+  const age = Date.now() - cache2.lastCheck;
   return age < CACHE_MAX_AGE_MS;
 }
 function clearCache() {
@@ -63978,9 +64025,9 @@ async function fetchLatestVersion(options = {}) {
 async function checkForUpdates(currentVersion, options = {}) {
   const { quiet = false } = options;
   let latestVersion = null;
-  const cache = readCache();
-  if (cache && isCacheValid(cache)) {
-    latestVersion = cache.latestVersion;
+  const cache2 = readCache();
+  if (cache2 && isCacheValid(cache2)) {
+    latestVersion = cache2.latestVersion;
   } else {
     latestVersion = await fetchLatestVersion();
     writeCache(latestVersion);
@@ -64891,10 +64938,10 @@ async function forceRefreshProbeModels() {
   }
 }
 function getProbeModel(claudishSlug) {
-  const cache = readProbeModelsCache();
-  if (!cache)
+  const cache2 = readProbeModelsCache();
+  if (!cache2)
     return null;
-  const entry = cache.providers[claudishSlug];
+  const entry = cache2.providers[claudishSlug];
   return typeof entry === "string" && entry.length > 0 ? entry : null;
 }
 async function discoverProbeModelFromEndpoint(proxyUrl, providerSlug, exclude) {
@@ -71760,12 +71807,12 @@ function shouldWarmCatalog(args) {
   }
   return true;
 }
-function classifyCatalogState(cache, ttlHours, now) {
-  if (cache === null)
+function classifyCatalogState(cache2, ttlHours, now) {
+  if (cache2 === null)
     return "missing";
-  if (cache.entries.length === 0 && cache.models.length === 0)
+  if (cache2.entries.length === 0 && cache2.models.length === 0)
     return "missing";
-  const lastUpdatedMs = Date.parse(cache.lastUpdated);
+  const lastUpdatedMs = Date.parse(cache2.lastUpdated);
   if (Number.isNaN(lastUpdatedMs))
     return "missing";
   const ageMs = now.getTime() - lastUpdatedMs;
@@ -71826,8 +71873,8 @@ async function warmCatalogIfNeeded(config3, opts) {
   const ttlHoursRaw = opts?.ttlHours ?? Number.parseFloat(process.env.CLAUDISH_CATALOG_TTL_HOURS ?? "24");
   const ttlHours = Number.isFinite(ttlHoursRaw) && ttlHoursRaw > 0 ? ttlHoursRaw : 24;
   const now = opts?.now ?? new Date;
-  const cache = readAllModelsCache();
-  const state = classifyCatalogState(cache, ttlHours, now);
+  const cache2 = readAllModelsCache();
+  const state = classifyCatalogState(cache2, ttlHours, now);
   if (state === "fresh" && !config3.forceUpdate) {
     return "ok";
   }
@@ -71854,14 +71901,14 @@ async function warmCatalogIfNeeded(config3, opts) {
     return "ok";
   }
   if (state === "stale") {
-    const ageMs = now.getTime() - Date.parse(cache.lastUpdated);
+    const ageMs = now.getTime() - Date.parse(cache2.lastUpdated);
     const ageStr = humanizeAge(ageMs);
     process.stderr.write(`WARNING: Catalog stale (${ageStr}). Using cached version. Run \`claudish --models-refresh\` to retry.
 `);
     return "warned";
   }
   if (state === "fresh") {
-    const ageMs = now.getTime() - Date.parse(cache.lastUpdated);
+    const ageMs = now.getTime() - Date.parse(cache2.lastUpdated);
     const ageStr = humanizeAge(ageMs);
     process.stderr.write(`WARNING: Catalog refresh failed (cache age ${ageStr}). Using cached version.
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "7.12.7",
+  "version": "7.14.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,10 +60,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "7.12.7",
-    "@claudish/magmux-darwin-x64": "7.12.7",
-    "@claudish/magmux-linux-arm64": "7.12.7",
-    "@claudish/magmux-linux-x64": "7.12.7"
+    "@claudish/magmux-darwin-arm64": "7.14.0",
+    "@claudish/magmux-darwin-x64": "7.14.0",
+    "@claudish/magmux-linux-arm64": "7.14.0",
+    "@claudish/magmux-linux-x64": "7.14.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",