claudish 9.5.0 → 9.6.1

package/dist/index.js

@@ -715,7 +715,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "9.5.0";
+var VERSION = "9.6.1";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -815,14 +815,17 @@ function redactLogLine(message, timestamp) {
   return `[${timestamp}] ${message}
 `;
 }
+function logFileStamp() {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
+  return `${timestamp}_${process.pid}`;
+}
 function initLogger(debugMode, level = "info", noLogs = false) {
   if (!noLogs) {
     const logsDir = join2(homedir2(), ".claudish", "logs");
     if (!existsSync2(logsDir)) {
       mkdirSync(logsDir, { recursive: true });
     }
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
-    alwaysOnLogPath = join2(logsDir, `claudish_${timestamp}.log`);
+    alwaysOnLogPath = join2(logsDir, `claudish_${logFileStamp()}.log`);
     writeFileSync2(alwaysOnLogPath, `Claudish Session Log - ${new Date().toISOString()}
 Mode: structural (content redacted)
 ${"=".repeat(60)}
@@ -837,8 +840,7 @@ ${"=".repeat(60)}
     if (!existsSync2(logsDir)) {
       mkdirSync(logsDir, { recursive: true });
     }
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
-    logFilePath = join2(logsDir, `claudish_${timestamp}.log`);
+    logFilePath = join2(logsDir, `claudish_${logFileStamp()}.log`);
     writeFileSync2(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
 Log Level: ${level}
 ${"=".repeat(80)}
@@ -18167,6 +18169,12 @@ var init_stdio2 = __esm(() => {
 import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir7 } from "os";
 import { dirname as dirname4, join as join7 } from "path";
+function reasoningStatusOf(entry) {
+  if (entry.reasoningStatus === "known" || entry.reasoningStatus === "unknown") {
+    return entry.reasoningStatus;
+  }
+  return entry.reasoning !== undefined ? "known" : "unknown";
+}
 function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
   if (!existsSync5(path))
     return null;
@@ -18183,12 +18191,14 @@ function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
   const models = Array.isArray(data.models) ? data.models : [];
   const entries = Array.isArray(data.entries) ? data.entries : [];
   const plans = Array.isArray(data.plans) ? data.plans : undefined;
+  const catalogRevision = typeof data.catalogRevision === "string" ? data.catalogRevision : undefined;
   return {
     version: 2,
     lastUpdated,
     entries,
     models,
-    ...plans !== undefined ? { plans } : {}
+    ...plans !== undefined ? { plans } : {},
+    ...catalogRevision !== undefined ? { catalogRevision } : {}
   };
 }
 function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
@@ -18198,7 +18208,8 @@ function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
     lastUpdated: data.lastUpdated ?? new Date().toISOString(),
     entries: data.entries ?? existing?.entries ?? [],
     models: data.models ?? existing?.models ?? [],
-    ...data.plans !== undefined || existing?.plans !== undefined ? { plans: data.plans ?? existing?.plans ?? [] } : {}
+    ...data.plans !== undefined || existing?.plans !== undefined ? { plans: data.plans ?? existing?.plans ?? [] } : {},
+    ...data.catalogRevision !== undefined ? { catalogRevision: data.catalogRevision } : {}
   };
   mkdirSync5(dirname4(path), { recursive: true });
   writeFileSync5(path, JSON.stringify(merged), "utf-8");
@@ -18285,6 +18296,10 @@ function lookupModel(modelId, cachePath) {
 function lookupModelReasoning(modelId, cachePath) {
   return findCacheEntry(modelId, cachePath)?.reasoning;
 }
+function lookupModelReasoningStatus(modelId, cachePath) {
+  const entry = findCacheEntry(modelId, cachePath);
+  return entry ? reasoningStatusOf(entry) : undefined;
+}
 function lookupModelTokenParam(modelId, cachePath) {
   return findCacheEntry(modelId, cachePath)?.tokenParam;
 }
@@ -18398,6 +18413,26 @@ function findCacheEntry(modelId, cachePath) {
       return entry;
     }
   }
+  const canonical = resolvePlanDescribedModelId(modelId, cache.plans);
+  if (!canonical)
+    return;
+  const canonicalLower = canonical.toLowerCase();
+  for (const entry of cache.entries) {
+    if (entry.modelId.toLowerCase() === canonicalLower)
+      return entry;
+    if (entry.aliases?.some((a) => a.toLowerCase() === canonicalLower))
+      return entry;
+  }
+  return;
+}
+function resolvePlanDescribedModelId(wireId, plans) {
+  if (!plans)
+    return;
+  for (const plan of plans) {
+    const described = plan.modelDescriptions?.[wireId];
+    if (described?.status === "described" && described.modelId)
+      return described.modelId;
+  }
   return;
 }
 function classifyCatalogHit(entry, q) {
@@ -19737,6 +19772,29 @@ function matchesModelFamily(modelId, family) {
 function isEffortLevel(value) {
   return typeof value === "string" && EFFORT_ORDER.includes(value);
 }
+function outputCeilingOf(originalRequest, payload) {
+  const candidates = [
+    originalRequest?.max_tokens,
+    payload?.max_tokens,
+    payload?.max_completion_tokens,
+    payload?.max_output_tokens
+  ];
+  for (const value of candidates) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0)
+      return value;
+  }
+  return;
+}
+function clampThinkingBudget(budget, ceiling) {
+  if (budget === undefined)
+    return;
+  if (ceiling === undefined)
+    return budget;
+  const allowed = ceiling - ANSWER_TOKEN_RESERVE;
+  if (allowed < MIN_THINKING_BUDGET)
+    return "no-room";
+  return Math.min(budget, allowed);
+}
 
 class BaseAPIFormat {
   modelId;
@@ -19826,6 +19884,11 @@ class BaseAPIFormat {
     }
   }
   applyAnthropicWireReasoning(request, originalRequest) {
+    const status = this.lookupReasoningStatus();
+    if (status !== "known") {
+      log(`[${this.getName()}] ${this.modelId} reasoning control ${status === "unknown" ? "unknown" : "absent from the catalog"} -> no reasoning parameter emitted`);
+      return request;
+    }
     const reasoning = this.lookupReasoningCapability();
     if (reasoning?.supported === false) {
       request.thinking = { type: "disabled" };
@@ -19836,36 +19899,63 @@ class BaseAPIFormat {
     if (!effort)
       return request;
     if (effort === "none" || effort === "minimal") {
+      if (reasoning?.mandatory) {
+        return this.enableAnthropicEffort(request, effort, reasoning, "mandatory reasoning");
+      }
       request.thinking = { type: "disabled" };
       log(`[${this.getName()}] effort ${effort} -> thinking.type: disabled for ${this.modelId}`);
       return request;
     }
-    if (reasoning && (reasoning.control === "budget" || reasoning.supportsBudgetTokens)) {
-      return this.enableAnthropicThinkingWithBudget(request, effort, "catalog: budget-controlled");
+    const control = reasoning?.control;
+    const advertisesEfforts = (reasoning?.efforts?.length ?? 0) > 0;
+    if (control === "effort" || control === undefined && advertisesEfforts) {
+      return this.enableAnthropicEffort(request, effort, reasoning, "catalog: effort-controlled");
     }
-    const advertised = reasoning?.efforts?.length ? reasoning : undefined;
-    if (advertised) {
-      const level = this.clampToAdvertisedEffort(effort, advertised);
-      request.thinking = { type: "enabled" };
-      if (level) {
-        request.output_config = { ...request.output_config ?? {}, effort: level };
-      }
-      log(`[${this.getName()}] effort ${effort} -> thinking: enabled, output_config.effort: ${level ?? "(none advertised)"} for ${this.modelId} (advertised: ${advertised.efforts?.join("/")})`);
-      return request;
+    if (control === "budget" || control === undefined && reasoning?.supportsBudgetTokens) {
+      return this.enableAnthropicBudget(request, effort, originalRequest, reasoning);
     }
-    if (reasoning) {
-      request.thinking = { type: "enabled" };
-      log(`[${this.getName()}] effort ${effort} -> thinking: enabled (no depth knob; catalog control=${reasoning.control ?? "unknown"}) for ${this.modelId}`);
-      return request;
+    request.thinking = { type: "enabled" };
+    this.stripAnthropicEffortField(request);
+    log(`[${this.getName()}] effort ${effort} -> thinking: enabled (no depth knob; catalog control=${control ?? "unspecified"}) for ${this.modelId}`);
+    return request;
+  }
+  enableAnthropicEffort(request, effort, reasoning, why) {
+    const level = reasoning ? this.clampToAdvertisedEffort(effort, reasoning) : undefined;
+    request.thinking = { type: "enabled" };
+    if (level) {
+      request.output_config = { ...request.output_config ?? {}, effort: level };
     }
-    return this.enableAnthropicThinkingWithBudget(request, effort, "no catalog entry");
+    log(`[${this.getName()}] effort ${effort} -> thinking: enabled, output_config.effort: ${level ?? "(none advertised)"} for ${this.modelId} (${why}; advertised: ${reasoning?.efforts?.join("/") ?? "none"})`);
+    return request;
   }
-  enableAnthropicThinkingWithBudget(request, effort, why) {
-    const budget = this.effortToThinkingTokenBudget(effort);
+  enableAnthropicBudget(request, effort, originalRequest, reasoning) {
+    const requested = this.effortToThinkingTokenBudget(effort);
+    const ceiling = outputCeilingOf(originalRequest, request);
+    const budget = clampThinkingBudget(requested, ceiling);
+    if (budget === "no-room") {
+      if (reasoning?.mandatory) {
+        request.thinking = { type: "enabled" };
+      } else {
+        request.thinking = { type: "disabled" };
+      }
+      this.stripAnthropicEffortField(request);
+      log(`[${this.getName()}] effort ${effort} -> budget ${requested ?? "(model max)"} does not fit under max_tokens ${ceiling}; sent thinking.type: ${request.thinking.type} for ${this.modelId}`);
+      return request;
+    }
     request.thinking = budget === undefined ? { type: "enabled" } : { type: "enabled", budget_tokens: budget };
-    log(`[${this.getName()}] effort ${effort} -> thinking: enabled, budget_tokens: ${budget ?? "(model max)"} for ${this.modelId} (${why})`);
+    this.stripAnthropicEffortField(request);
+    log(`[${this.getName()}] effort ${effort} -> thinking: enabled, budget_tokens: ${budget ?? "(model max)"}${budget !== undefined && budget !== requested ? ` (clamped from ${requested} under max_tokens ${ceiling})` : ""} for ${this.modelId} (catalog: budget-controlled)`);
     return request;
   }
+  stripAnthropicEffortField(request) {
+    if (!request?.output_config || typeof request.output_config !== "object")
+      return;
+    if (request.output_config.effort === undefined)
+      return;
+    delete request.output_config.effort;
+    if (Object.keys(request.output_config).length === 0)
+      delete request.output_config;
+  }
   clampToAdvertisedEffort(requested, reasoning) {
     if (this.pinnedEffort)
       return this.pinnedEffort;
@@ -19894,6 +19984,13 @@ class BaseAPIFormat {
       return;
     }
   }
+  lookupReasoningStatus() {
+    try {
+      return lookupModelReasoningStatus(this.modelId);
+    } catch {
+      return;
+    }
+  }
   effortToThinkingTokenBudget(effort) {
     switch (effort) {
       case "low":
@@ -20024,7 +20121,7 @@ class BaseAPIFormat {
     }
   }
 }
-var OPTIONAL_SAMPLING_PARAMS, OPENAI_TOOL_NAME_LIMIT = 64, EFFORT_ORDER, EFFORT_LEVELS, NON_ANTHROPIC_REASONING_FIELDS, DefaultAPIFormat;
+var OPTIONAL_SAMPLING_PARAMS, OPENAI_TOOL_NAME_LIMIT = 64, EFFORT_ORDER, EFFORT_LEVELS, NON_ANTHROPIC_REASONING_FIELDS, MIN_THINKING_BUDGET = 1024, ANSWER_TOKEN_RESERVE = 1024, DefaultAPIFormat;
 var init_base_api_format = __esm(() => {
   init_remote_provider_types();
   init_logger();
@@ -21103,10 +21200,34 @@ function keepOnlyRealTools(extracted, knownToolNames, decodeToolName) {
   }
   return kept;
 }
+function unwrapToolCallTags(body) {
+  if (!body.startsWith("<tool_call>"))
+    return null;
+  const blocks = [];
+  let cursor = 0;
+  while (cursor < body.length) {
+    TOOL_CALL_OPEN_AT_CURSOR.lastIndex = cursor;
+    if (!TOOL_CALL_OPEN_AT_CURSOR.exec(body))
+      return null;
+    cursor = TOOL_CALL_OPEN_AT_CURSOR.lastIndex;
+    const close = body.indexOf(TOOL_CALL_CLOSE_TAG, cursor);
+    const block = (close === -1 ? body.slice(cursor) : body.slice(cursor, close)).trim();
+    if (!block.startsWith("<function="))
+      return null;
+    blocks.push(block);
+    if (close === -1)
+      break;
+    cursor = close + TOOL_CALL_CLOSE_TAG.length;
+    cursor += /^\s*/.exec(body.slice(cursor))?.[0].length ?? 0;
+  }
+  return blocks.length > 0 ? blocks.join(`
+`) : null;
+}
 function parseFunctionTagEnvelope(text) {
-  const body = text.trim();
-  if (body.length === 0)
+  const trimmed = text.trim();
+  if (trimmed.length === 0)
     return null;
+  const body = unwrapToolCallTags(trimmed) ?? trimmed;
   if (!body.startsWith("<function="))
     return null;
   const calls = [];
@@ -21343,7 +21464,7 @@ function validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent)
   }
   return { valid: false, args, repaired: false, missingParams };
 }
-var FUNCTION_TAG_SOURCE, FUNCTION_TAG_PRESENT, FUNCTION_TAG_AT_CURSOR, PARAMETER_TAG_AT_CURSOR;
+var FUNCTION_TAG_SOURCE, FUNCTION_TAG_PRESENT, FUNCTION_TAG_AT_CURSOR, PARAMETER_TAG_AT_CURSOR, TOOL_CALL_OPEN_AT_CURSOR, TOOL_CALL_CLOSE_TAG = "</tool_call>";
 var init_tool_call_recovery = __esm(() => {
   init_tool_name_utils();
   init_logger();
@@ -21352,6 +21473,7 @@ var init_tool_call_recovery = __esm(() => {
   FUNCTION_TAG_PRESENT = new RegExp(`<function=${TOOL_NAME_SOURCE}>`);
   FUNCTION_TAG_AT_CURSOR = new RegExp(`<function=(${TOOL_NAME_SOURCE})>`, "y");
   PARAMETER_TAG_AT_CURSOR = /<parameter=([^>\s]+)>/y;
+  TOOL_CALL_OPEN_AT_CURSOR = /<tool_call>\s*/y;
 });
 
 // src/handlers/shared/web-search-detector.ts
@@ -21589,6 +21711,31 @@ function formatRawSseLogPayload(dataStr) {
     return dataStr;
   return `${dataStr.substring(0, SSE_LOG_MAX_CHARS)} ${SSE_LOG_TRUNCATION_MARKER} original_chars=${dataStr.length}`;
 }
+function describeInStreamError(chunk) {
+  if (!chunk || typeof chunk !== "object")
+    return;
+  const error = chunk.error;
+  if (!error)
+    return;
+  if (typeof error === "string")
+    return error;
+  if (typeof error !== "object")
+    return String(error);
+  const e = error;
+  const metadata = e.metadata ?? {};
+  const parts = [];
+  const provider = chunk.provider;
+  if (typeof provider === "string" && provider)
+    parts.push(`[${provider}]`);
+  const code = e.code ?? metadata.provider_code;
+  const type = e.type ?? metadata.error_type;
+  const label = [code, type].filter((v) => v !== undefined && v !== null && v !== "").join(" ");
+  if (label)
+    parts.push(label);
+  const message = e.message ?? metadata.raw;
+  parts.push(typeof message === "string" && message.trim() ? message : JSON.stringify(error).slice(0, 500));
+  return parts.join(" ");
+}
 function validateToolArguments(toolName, argsStr, toolSchemas, textContent) {
   const result = validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent);
   if (result.repaired) {
@@ -21865,6 +22012,12 @@ data: ${JSON.stringify(d)}
                 state.usage = chunk.usage;
                 log(`[Streaming] Usage data received: prompt=${chunk.usage.prompt_tokens}, completion=${chunk.usage.completion_tokens}, total=${chunk.usage.total_tokens}`);
               }
+              const inStreamError = describeInStreamError(chunk);
+              if (inStreamError) {
+                log(`[Streaming] Upstream error inside a 200 stream: ${inStreamError}`);
+                await finalize("error", inStreamError);
+                return;
+              }
               const delta = chunk.choices?.[0]?.delta;
               const finishReason = chunk.choices?.[0]?.finish_reason;
               if (finishReason)
@@ -23370,11 +23523,18 @@ var init_qwen_model_dialect = __esm(() => {
         log(`[QwenModelDialect] effort ${effort} -> enable_thinking: false for ${this.modelId}`);
       } else {
         request.enable_thinking = true;
-        const budget = this.effortToThinkingTokenBudget(effort);
-        if (budget !== undefined) {
-          request.thinking_budget = budget;
+        const requested = this.effortToThinkingTokenBudget(effort);
+        const ceiling = outputCeilingOf(originalRequest, request);
+        const budget = clampThinkingBudget(requested, ceiling);
+        if (budget === "no-room") {
+          delete request.thinking_budget;
+          log(`[QwenModelDialect] effort ${effort} -> enable_thinking: true, no thinking_budget (${requested} does not fit under ceiling ${ceiling}) for ${this.modelId}`);
+        } else {
+          if (budget !== undefined) {
+            request.thinking_budget = budget;
+          }
+          log(`[QwenModelDialect] effort ${effort} -> enable_thinking: true, thinking_budget: ${budget ?? "(model max)"}${budget !== undefined && budget !== requested ? ` (clamped from ${requested} under ceiling ${ceiling})` : ""} for ${this.modelId}`);
         }
-        log(`[QwenModelDialect] effort ${effort} -> enable_thinking: true, thinking_budget: ${budget ?? "(model max)"} for ${this.modelId}`);
       }
       if (originalRequest.thinking)
         delete request.thinking;
@@ -37624,6 +37784,12 @@ var init_auto_route = __esm(() => {
 });
 
 // src/providers/catalog-client.ts
+function catalogUrl() {
+  return process.env.CLAUDISH_CATALOG_URL ?? process.env.FIREBASE_CATALOG_URL ?? DEFAULT_CATALOG_URL;
+}
+function plansUrl() {
+  return process.env.CLAUDISH_PLANS_URL ?? derivePlansUrl(catalogUrl());
+}
 function derivePlansUrl(catalogUrl) {
   try {
     const url = new URL(catalogUrl);
@@ -37772,49 +37938,97 @@ function catalogWarmDisabledFor(value) {
 function catalogWarmDisabled() {
   return catalogWarmDisabledFor(process.env.CLAUDISH_DISABLE_CATALOG_WARM);
 }
-async function refreshCatalog(timeoutMs) {
-  if (catalogWarmDisabled()) {
-    return { kind: "fetch_failed", reason: "disabled" };
-  }
-  const plansPromise = fetchSubscriptionPlans(timeoutMs);
+function buildCatalogPageUrl(baseUrl, offset, limit, revision) {
+  const url = new URL(baseUrl);
+  url.searchParams.set("offset", String(offset));
+  url.searchParams.set("limit", String(limit));
+  if (revision)
+    url.searchParams.set("revision", revision);
+  return url.toString();
+}
+async function fetchCatalogPage(url, timeoutMs) {
   let response;
   try {
-    response = await fetch(FIREBASE_CATALOG_URL, { signal: AbortSignal.timeout(timeoutMs) });
+    response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
   } catch (err) {
     const name = err?.name;
     const reason = name === "TimeoutError" || name === "AbortError" ? "timeout" : "network";
-    return { kind: "fetch_failed", reason };
+    return { ok: false, reason };
   }
   if (!response.ok)
-    return { kind: "fetch_failed", reason: "http_error" };
-  let data;
+    return { ok: false, reason: "http_error" };
+  let page;
   try {
-    data = await response.json();
+    page = await response.json();
   } catch {
-    return { kind: "fetch_failed", reason: "network" };
+    return { ok: false, reason: "network" };
   }
-  if (!Array.isArray(data.models) || data.models.length === 0) {
-    return { kind: "fetch_failed", reason: "empty" };
+  const revision = response.headers.get(CATALOG_REVISION_HEADER) ?? undefined;
+  return { ok: true, page, revision };
+}
+async function refreshCatalog(timeoutMs, options = {}) {
+  if (catalogWarmDisabled()) {
+    return { kind: "fetch_failed", reason: "disabled" };
   }
+  const entries = [];
+  let revision;
+  let pages = 0;
+  let offset = 0;
+  for (;; ) {
+    const url = buildCatalogPageUrl(catalogUrl(), offset, CATALOG_PAGE_LIMIT, revision);
+    const result = await fetchCatalogPage(url, timeoutMs);
+    if (!result.ok) {
+      return {
+        kind: "fetch_failed",
+        reason: pages === 0 ? result.reason : "incomplete"
+      };
+    }
+    const { page } = result;
+    if (!Array.isArray(page.models))
+      return { kind: "fetch_failed", reason: "empty" };
+    if (pages === 0) {
+      revision = result.revision;
+      if (page.models.length === 0)
+        return { kind: "fetch_failed", reason: "empty" };
+    } else if (revision && result.revision && result.revision !== revision) {
+      return { kind: "fetch_failed", reason: "revision_mismatch" };
+    }
+    entries.push(...page.models);
+    pages++;
+    if (page.hasMore !== true)
+      break;
+    if (page.models.length === 0)
+      return { kind: "fetch_failed", reason: "incomplete" };
+    offset += page.models.length;
+    if (pages >= MAX_CATALOG_PAGES) {
+      return { kind: "fetch_failed", reason: "incomplete" };
+    }
+  }
+  if (entries.length === 0)
+    return { kind: "fetch_failed", reason: "empty" };
+  const plans = await fetchSubscriptionPlans(timeoutMs, revision);
   const backwardCompatModels = [];
-  for (const entry of data.models) {
+  for (const entry of entries) {
     const id = externalIdFor(entry, "openrouter");
     if (id)
       backwardCompatModels.push({ id });
   }
-  _memCache = data.models;
-  const plans = await plansPromise;
+  _memCache = entries;
   writeAllModelsCache({
-    entries: data.models,
+    entries,
     models: backwardCompatModels,
-    ...plans !== undefined ? { plans } : {}
-  });
+    ...plans !== undefined ? { plans } : {},
+    ...revision !== undefined ? { catalogRevision: revision } : {}
+  }, options.cachePath);
   _warmPromise = Promise.resolve();
-  return { kind: "refreshed", modelCount: data.models.length };
+  return { kind: "refreshed", modelCount: entries.length, catalogRevision: revision, pages };
 }
-async function fetchSubscriptionPlans(timeoutMs) {
+async function fetchSubscriptionPlans(timeoutMs, revision) {
   try {
-    const response = await fetch(FIREBASE_PLANS_URL, {
+    const url = new URL(plansUrl());
+    if (revision)
+      url.searchParams.set("revision", revision);
+    const response = await fetch(url.toString(), {
       signal: AbortSignal.timeout(timeoutMs)
     });
     if (!response.ok)
@@ -37846,11 +38060,9 @@ async function ensureCatalogReady(timeoutMs = 5000) {
     new Promise((resolve) => setTimeout(resolve, timeoutMs))
   ]);
 }
-var FIREBASE_CATALOG_URL, FIREBASE_PLANS_URL, _memCache = null, _catalogEntriesForTest, _warmPromise = null;
+var DEFAULT_CATALOG_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels?status=active&catalog=slim&limit=1000", _memCache = null, _catalogEntriesForTest, _warmPromise = null, CATALOG_REVISION_HEADER = "x-catalog-revision", MAX_CATALOG_PAGES = 40, CATALOG_PAGE_LIMIT = 1000;
 var init_catalog_client = __esm(() => {
   init_all_models_cache();
-  FIREBASE_CATALOG_URL = process.env.CLAUDISH_CATALOG_URL ?? process.env.FIREBASE_CATALOG_URL ?? "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels?status=active&catalog=slim&limit=1000";
-  FIREBASE_PLANS_URL = process.env.CLAUDISH_PLANS_URL ?? derivePlansUrl(FIREBASE_CATALOG_URL);
 });
 
 // src/config-schema.ts
@@ -41049,6 +41261,18 @@ async function shutdownAllTeamRuns() {
     return;
   })));
 }
+function snippetHeadAndTail(text) {
+  if (text.length <= SNIPPET_LIMIT)
+    return text;
+  const head = text.slice(0, SNIPPET_HEAD);
+  const tail = text.slice(-(SNIPPET_LIMIT - SNIPPET_HEAD));
+  const omitted = text.length - head.length - tail.length;
+  return `${head}
+
+\u2026 [${omitted} bytes omitted] \u2026
+
+${tail}`;
+}
 function classifyRunOutput(opts) {
   const {
     outputSize,
@@ -41419,7 +41643,7 @@ async function startModels(sessionPath, opts = {}) {
               reason,
               detail,
               stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
-              stdoutSnippet: stdoutTail ? redactSecrets(stdoutTail).slice(-2000) : undefined,
+              stdoutSnippet: stdoutTail ? snippetHeadAndTail(redactSecrets(stdoutTail)) : undefined,
               errorLogPath,
               upstreamErrorLogPath: existsSync20(upstreamErrorLogPath) ? upstreamErrorLogPath : undefined,
               workDir: sessionPath
@@ -41696,7 +41920,7 @@ function formatVerdict(verdict, sessionPath) {
   }
   return output;
 }
-var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", liveTeamRuns, STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, BENIGN_STDERR_PATTERNS;
+var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", liveTeamRuns, STDOUT_TAIL_LIMIT = 4000, SNIPPET_LIMIT = 2000, SNIPPET_HEAD = 600, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, BENIGN_STDERR_PATTERNS;
 var init_team_orchestrator = __esm(() => {
   init_prehydrate();
   init_stream_json_reducer();
@@ -57743,6 +57967,51 @@ var init_api_key_map = __esm(() => {
   };
 });
 
+// src/providers/provider-slug-resolve.ts
+function sharedPrefixLength(a, b) {
+  let n = 0;
+  while (n < a.length && n < b.length && a[n] === b[n])
+    n++;
+  return n;
+}
+function rankSuggestions(typed, providers) {
+  const needle = typed.toLowerCase();
+  const scored = [];
+  for (const provider of providers) {
+    const slug = provider.slug.toLowerCase();
+    let score = 0;
+    if (slug.includes(needle) || needle.includes(slug)) {
+      score = 2;
+    } else if (sharedPrefixLength(slug, needle) >= MIN_PREFIX_OVERLAP) {
+      score = 1;
+    }
+    if (score > 0)
+      scored.push({ provider, score });
+  }
+  scored.sort((a, b) => b.score - a.score || b.provider.count - a.provider.count);
+  return scored.slice(0, SUGGESTION_LIMIT).map((s) => s.provider);
+}
+function resolveProviderSlug(typed, providers) {
+  const routingOwner = reservedNamespaceOwner(typed) ?? null;
+  if (providers.length === 0) {
+    return { kind: "match", canonical: typed, suggestions: [], routingOwner };
+  }
+  const exact = providers.find((p) => p.slug.toLowerCase() === typed.toLowerCase());
+  if (exact) {
+    return { kind: "match", canonical: exact.slug, suggestions: [], routingOwner };
+  }
+  return {
+    kind: "unknown",
+    canonical: null,
+    suggestions: rankSuggestions(typed, providers),
+    routingOwner
+  };
+}
+var SUGGESTION_LIMIT = 5, MIN_PREFIX_OVERLAP = 3;
+var init_provider_slug_resolve = __esm(() => {
+  init_reserved_namespace();
+});
+
 // src/branding.ts
 function paint(line) {
   const { RESET, BOLD, CYAN, BLUE, DIM } = cliAnsi();
@@ -58313,7 +58582,19 @@ Usage:  claudish --models --provider <slug>`);
       const hasJsonFlag = args.includes("--json");
       const forceUpdate = config.forceUpdate || args.includes("--models-refresh");
       const providerIdx = args.indexOf("--provider");
-      const providerSlug = providerIdx !== -1 && providerIdx + 1 < args.length ? args[providerIdx + 1] : null;
+      const inlineProvider = args.find((a) => a.startsWith("--provider="));
+      let providerSlug = null;
+      if (inlineProvider) {
+        providerSlug = inlineProvider.slice("--provider=".length);
+      } else if (providerIdx !== -1) {
+        const next = args[providerIdx + 1];
+        providerSlug = next && !next.startsWith("--") ? next : "";
+      }
+      if (providerSlug === "") {
+        console.error("--provider needs a slug: claudish --models --provider <slug>");
+        console.error("Run `claudish --providers` for the full list.");
+        process.exit(1);
+      }
       if (forceUpdate)
         clearAllModelCaches();
       if (query && providerSlug) {
@@ -58588,7 +58869,46 @@ Top ${response.total} models from Firebase (pool: ${response.poolSize} eligible)
   console.log("Top recommended:    claudish --models-top");
   console.log("");
 }
-async function printByProvider(providerSlug, jsonOutput) {
+function printUnknownProviderSlug(typedSlug, resolved, catalogSize, jsonOutput) {
+  if (jsonOutput) {
+    console.log(JSON.stringify({
+      error: `"${typedSlug}" is not a provider slug in the model catalog`,
+      provider: typedSlug,
+      suggestions: resolved.suggestions.map((s) => s.slug),
+      routingPrefixOwner: resolved.routingOwner,
+      validSlugs: catalogSize
+    }, null, 2));
+    return;
+  }
+  console.error(`
+\u274C "${typedSlug}" is not a provider slug in the model catalog.`);
+  if (resolved.suggestions.length > 0) {
+    const list = resolved.suggestions.map((s) => `${s.slug} (${s.count} active model${s.count === 1 ? "" : "s"})`).join(", ");
+    console.error(`
+   Did you mean: ${list}`);
+  }
+  if (resolved.routingOwner) {
+    console.error(`
+   "${typedSlug}" IS a claudish routing prefix for the "${resolved.routingOwner}" provider \u2014` + `
+   use it with --model: claudish --model ${typedSlug}@<model-id>` + `
+   Routing prefixes and catalog vendor slugs are different vocabularies.`);
+  }
+  console.error(`
+   claudish --providers    lists all ${catalogSize} catalog slugs`);
+  console.error(`   claudish -s ${typedSlug}${" ".repeat(Math.max(1, 12 - typedSlug.length))}searches model ids instead
+`);
+}
+async function printByProvider(typedSlug, jsonOutput) {
+  let catalogProviders = [];
+  try {
+    catalogProviders = await getProviderList();
+  } catch {}
+  const resolved = resolveProviderSlug(typedSlug, catalogProviders);
+  if (resolved.kind === "unknown") {
+    printUnknownProviderSlug(typedSlug, resolved, catalogProviders.length, jsonOutput);
+    process.exit(1);
+  }
+  const providerSlug = resolved.canonical ?? typedSlug;
   let models;
   try {
     models = await getModelsByProvider(providerSlug, 200);
@@ -58603,8 +58923,8 @@ async function printByProvider(providerSlug, jsonOutput) {
   }
   if (models.length === 0) {
     console.log(`
-No active models found for provider "${providerSlug}". Try \`claudish -s <query>\` to search the full catalog.
-`);
+Provider "${providerSlug}" is in the catalog but has no active models right now.`);
+    console.log("Try `claudish -s <query>` to search the full catalog.\n");
     return;
   }
   console.log(`
@@ -59685,6 +60005,7 @@ var init_cli = __esm(() => {
   init_probe_live();
   init_probe_runner();
   init_provider_definitions();
+  init_provider_slug_resolve();
   init_routing_rules();
   init_ansi();
   init_provider_resolver();
@@ -67784,6 +68105,46 @@ function resolveAdvisorModelArg(config, cwd = process.cwd()) {
     source: "claudish"
   };
 }
+function isSuppressibleChildStderrLine(line) {
+  return CHILD_STDERR_NOISE.some((re) => re.test(line));
+}
+function relayChildStderr(stream) {
+  let buffered = "";
+  const emit = (line) => {
+    if (isSuppressibleChildStderrLine(line)) {
+      log(`[Suppressed] claude-code-stderr: ${line.trimEnd()}`);
+      return;
+    }
+    process.stderr.write(`${line}
+`);
+  };
+  stream.setEncoding("utf8");
+  stream.on("data", (chunk) => {
+    buffered += chunk;
+    const lines = buffered.split(`
+`);
+    buffered = lines.pop() ?? "";
+    for (const line of lines)
+      emit(line);
+  });
+  const flush = () => {
+    if (buffered.length === 0)
+      return;
+    const tail = buffered;
+    buffered = "";
+    if (isSuppressibleChildStderrLine(tail)) {
+      log(`[Suppressed] claude-code-stderr: ${tail}`);
+    } else {
+      process.stderr.write(tail);
+    }
+  };
+  stream.on("end", flush);
+  stream.on("close", flush);
+  stream.on("error", (err) => {
+    flush();
+    logStderr(`child stderr relay ended: ${err}`);
+  });
+}
 async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
   const hasProfileMappings = config.modelOpus || config.modelSonnet || config.modelHaiku || config.modelSubagent;
   const advisorNativeSession = isAdvisorNativeSession(config);
@@ -67858,6 +68219,9 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
   }
   let hidAnthropicApiKey = false;
   delete env.CLAUDECODE;
+  if (!config.interactive && env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC === undefined) {
+    env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+  }
   if (config.monitor || advisorNativeSession) {
     delete env.ANTHROPIC_API_KEY;
     delete env.ANTHROPIC_AUTH_TOKEN;
@@ -67955,12 +68319,16 @@ Or set CLAUDE_PATH to your custom installation:`);
   } else if (config.interactive && !process.stdout.isTTY && !process.stdin.isTTY) {
     console.error("[claudish] An interactive session was requested but no terminal is attached (stdin and stdout are both non-TTY). Pass a prompt argument, or use --stdin / -p for non-interactive mode.");
   }
-  const stdio = ttyFd !== undefined ? [0, ttyFd, ttyFd] : "inherit";
+  const filterChildStderr = !config.interactive && ttyFd === undefined;
+  const stdio = ttyFd !== undefined ? [0, ttyFd, ttyFd] : filterChildStderr ? ["inherit", "inherit", "pipe"] : "inherit";
   const proc = spawn5(spawnCommand, claudeArgs, {
     env,
     stdio,
     shell: needsShell
   });
+  if (filterChildStderr && proc.stderr) {
+    relayChildStderr(proc.stderr);
+  }
   if (config.interactive) {
     restoreTerminal = beginTerminalIsolation((entry) => {
       logStderr(`[Suppressed] ${entry.source}: ${entry.text.trimEnd()}`);
@@ -68098,7 +68466,7 @@ var restoreTerminal = null, macosKeychainAnthropicResult, defaultKeychainAnthrop
     macosKeychainAnthropicResult = false;
   }
   return macosKeychainAnthropicResult;
-}, CLAUDISH_PLACEHOLDER_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx", CLAUDISH_PLACEHOLDER_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth", STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000, ADVISOR_TOOL_ENV_VAR = "CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL", CLAUDISH_CHILD_ADVISOR_MODEL = "sonnet", SIGNAL_EXIT_NUMBERS;
+}, CLAUDISH_PLACEHOLDER_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx", CLAUDISH_PLACEHOLDER_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth", STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000, ADVISOR_TOOL_ENV_VAR = "CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL", CLAUDISH_CHILD_ADVISOR_MODEL = "sonnet", CHILD_STDERR_NOISE, SIGNAL_EXIT_NUMBERS;
 var init_claude_runner = __esm(() => {
   init_model_catalog();
   init_config2();
@@ -68112,6 +68480,7 @@ var init_claude_runner = __esm(() => {
   init_terminal_isolation();
   init_theme_mode();
   STALE_TOKEN_FILE_MS = 7 * 24 * 60 * 60 * 1000;
+  CHILD_STDERR_NOISE = [/^\[claude-code:unrecognized_model\]/];
   SIGNAL_EXIT_NUMBERS = {
     SIGHUP: 1,
     SIGINT: 2,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "9.5.0",
+  "version": "9.6.1",
   "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": "9.5.0",
-    "@claudish/magmux-darwin-x64": "9.5.0",
-    "@claudish/magmux-linux-arm64": "9.5.0",
-    "@claudish/magmux-linux-x64": "9.5.0"
+    "@claudish/magmux-darwin-arm64": "9.6.1",
+    "@claudish/magmux-darwin-x64": "9.6.1",
+    "@claudish/magmux-linux-arm64": "9.6.1",
+    "@claudish/magmux-linux-x64": "9.6.1"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",