claudish 5.3.0 → 5.4.0

package/dist/index.js

@@ -27484,6 +27484,7 @@ __export(exports_logger, {
   setLogLevel: () => setLogLevel,
   maskCredential: () => maskCredential,
   logStructured: () => logStructured,
+  logStderr: () => logStderr,
   log: () => log,
   isLoggingEnabled: () => isLoggingEnabled,
   initLogger: () => initLogger,
@@ -27557,6 +27558,11 @@ function log(message, forceConsole = false) {
     console.log(message);
   }
 }
+function logStderr(message) {
+  process.stderr.write(`[claudish] ${message}
+`);
+  log(message);
+}
 function getLogFilePath() {
   return logFilePath;
 }
@@ -28463,11 +28469,15 @@ function loadConfig() {
   try {
     const content = readFileSync4(CONFIG_FILE, "utf-8");
     const config3 = JSON.parse(content);
-    return {
+    const merged = {
       version: config3.version || DEFAULT_CONFIG.version,
       defaultProfile: config3.defaultProfile || DEFAULT_CONFIG.defaultProfile,
       profiles: config3.profiles || DEFAULT_CONFIG.profiles
     };
+    if (config3.telemetry !== undefined) {
+      merged.telemetry = config3.telemetry;
+    }
+    return merged;
   } catch (error46) {
     console.error(`Warning: Failed to load config, using defaults: ${error46}`);
     return { ...DEFAULT_CONFIG };
@@ -32635,6 +32645,433 @@ var init_profile_commands = __esm(() => {
   init_dist8();
 });
 
+// src/telemetry.ts
+var exports_telemetry = {};
+__export(exports_telemetry, {
+  sanitizeMessage: () => sanitizeMessage,
+  runConsentPrompt: () => runConsentPrompt,
+  reportError: () => reportError,
+  initTelemetry: () => initTelemetry,
+  handleTelemetryCommand: () => handleTelemetryCommand,
+  enforceReportSize: () => enforceReportSize,
+  detectRuntime: () => detectRuntime,
+  detectInstallMethod: () => detectInstallMethod,
+  classifyError: () => classifyError,
+  buildReport: () => buildReport
+});
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { createRequire as createRequire2 } from "node:module";
+function getVersion() {
+  try {
+    const require2 = createRequire2(import.meta.url);
+    const pkg = require2("../package.json");
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function detectRuntime() {
+  if (process.versions.bun) {
+    const major2 = process.versions.bun.split(".").slice(0, 2).join(".");
+    return `bun-${major2}`;
+  }
+  const major = process.versions.node?.split(".")[0] ?? "unknown";
+  return `node-${major}`;
+}
+function detectInstallMethod() {
+  const scriptPath = process.argv[1] || "";
+  if (scriptPath.includes("/.bun/"))
+    return "bun";
+  if (scriptPath.includes("/Cellar/") || scriptPath.includes("/homebrew/"))
+    return "homebrew";
+  if (scriptPath.includes("/node_modules/") || scriptPath.includes("/.nvm/") || scriptPath.includes("/npm/"))
+    return "npm";
+  return "binary";
+}
+function sanitizeMessage(msg) {
+  if (typeof msg !== "string")
+    return "<non-string>";
+  let s = msg;
+  s = s.replace(/\?[^\s"'`]*/g, "?<redacted>");
+  s = s.replace(/\/(?:home|Users)\/[^\s"'`]+/g, "<path>");
+  s = s.replace(/[A-Za-z]:\\[Uu]sers\\[^\s"'`]+/g, "<path>");
+  s = s.replace(/\/(?:var|tmp|private|opt|etc)\/[^\s"'`]+/g, "<path>");
+  s = s.replace(/~\/[^\s]*/g, "<path>");
+  s = s.replace(/localhost:(\d+)/g, "localhost:<port>");
+  s = s.replace(/127\.0\.0\.1:(\d+)/g, "localhost:<port>");
+  s = s.replace(/\b(?!127\.0\.0\.1)(\d{1,3}\.){3}\d{1,3}\b/g, "<host>");
+  s = s.replace(/\[[0-9a-fA-F:]{4,}\]/g, "<host>");
+  s = s.replace(/https?:\/\/([a-zA-Z0-9.-]+)(:\d+)?/g, (match, host) => {
+    const lowerHost = host.toLowerCase();
+    for (const pub of KNOWN_PUBLIC_HOSTS) {
+      if (lowerHost === pub || lowerHost.endsWith("." + pub)) {
+        return match;
+      }
+    }
+    return "https://<host>";
+  });
+  s = s.replace(/Bearer\s+[^\s"']+/gi, "Bearer <credential>");
+  s = s.replace(/[Aa]uthorization:\s*[^\s"']+/g, "Authorization: <credential>");
+  s = s.replace(/\beyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g, "<credential>");
+  s = s.replace(/\bsk-[a-zA-Z0-9_\-]{10,}/g, "<credential>");
+  s = s.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, "<email>");
+  s = s.replace(/[a-zA-Z0-9+\-_]{20,}={0,2}/g, "<credential>");
+  if (s.length > 500) {
+    s = s.slice(0, 497) + "...";
+  }
+  return s;
+}
+function sanitizeModelId(modelId, providerName) {
+  if (PUBLIC_PROVIDERS.has(providerName)) {
+    return modelId;
+  }
+  const atIdx = modelId.indexOf("@");
+  if (atIdx !== -1) {
+    return modelId.slice(0, atIdx + 1) + "<custom>";
+  }
+  return "<local-model>";
+}
+function classifyError(error46, httpStatus, errorText) {
+  if (error46 && typeof error46 === "object") {
+    const code = error46.code ?? error46.cause?.code;
+    if (code === "ECONNREFUSED")
+      return { error_class: "connection", error_code: "econnrefused" };
+    if (code === "ECONNRESET")
+      return { error_class: "connection", error_code: "econnreset" };
+    if (code === "ETIMEDOUT")
+      return { error_class: "connection", error_code: "timeout" };
+  }
+  if (error46 instanceof Error && error46.name === "AbortError") {
+    return { error_class: "connection", error_code: "timeout" };
+  }
+  if (httpStatus !== undefined) {
+    if (httpStatus === 400) {
+      const lower = errorText?.toLowerCase() ?? "";
+      if (lower.includes("context") || lower.includes("too long") || lower.includes("token")) {
+        return { error_class: "http_error", error_code: "context_length_exceeded" };
+      }
+      if (lower.includes("unsupported content type") || lower.includes("unsupported_content_type")) {
+        return { error_class: "http_error", error_code: "unsupported_content_type" };
+      }
+      return { error_class: "http_error", error_code: "bad_request_400" };
+    }
+    if (httpStatus === 401)
+      return { error_class: "auth", error_code: "unauthorized_401" };
+    if (httpStatus === 403)
+      return { error_class: "auth", error_code: "forbidden_403" };
+    if (httpStatus === 404)
+      return { error_class: "http_error", error_code: "not_found_404" };
+    if (httpStatus === 429)
+      return { error_class: "rate_limit", error_code: "rate_limited_429" };
+    if (httpStatus === 503)
+      return { error_class: "overload", error_code: "service_unavailable_503" };
+    if (httpStatus >= 500)
+      return { error_class: "http_error", error_code: "server_error_5xx" };
+    if (httpStatus >= 400)
+      return { error_class: "http_error", error_code: `http_error_${httpStatus}` };
+  }
+  const msg = error46 instanceof Error ? error46.message.toLowerCase() : "";
+  if (msg.includes("oauth") || msg.includes("token expired") || msg.includes("invalid token") || msg.includes("refresh token") || msg.includes("auth")) {
+    return { error_class: "auth", error_code: "oauth_refresh_failed" };
+  }
+  if (msg.includes("json") || msg.includes("parse")) {
+    return { error_class: "stream", error_code: "json_parse_error" };
+  }
+  if (msg.includes("stream")) {
+    return { error_class: "stream", error_code: "stream_parse_error" };
+  }
+  if (msg.includes("config") || msg.includes("missing") || msg.includes("api key")) {
+    return { error_class: "config", error_code: "config_error" };
+  }
+  return { error_class: "unknown", error_code: "unknown_error" };
+}
+function buildReport(ctx) {
+  const { error_class, error_code } = classifyError(ctx.error, ctx.httpStatus, ctx.error instanceof Error ? ctx.error.message : String(ctx.error));
+  let rawMessage;
+  if (ctx.error instanceof Error) {
+    rawMessage = ctx.error.message;
+  } else if (typeof ctx.error === "string") {
+    rawMessage = ctx.error;
+  } else {
+    rawMessage = String(ctx.error);
+  }
+  const report = {
+    schema_version: 1,
+    claudish_version: claudishVersion,
+    install_method: installMethod,
+    error_class,
+    error_code,
+    error_message_template: sanitizeMessage(rawMessage),
+    provider_name: ctx.providerName,
+    model_id: sanitizeModelId(ctx.modelId, ctx.providerName),
+    stream_format: ctx.streamFormat,
+    http_status: ctx.httpStatus ?? null,
+    is_streaming: ctx.isStreaming,
+    retry_attempted: ctx.retryAttempted,
+    session_id: sessionId,
+    timestamp: new Date().toISOString(),
+    platform: process.platform,
+    node_runtime: detectRuntime()
+  };
+  if (ctx.modelMappingRole !== undefined)
+    report.model_mapping_role = ctx.modelMappingRole;
+  if (ctx.concurrency !== undefined)
+    report.concurrency = ctx.concurrency;
+  if (ctx.adapterName !== undefined)
+    report.adapter_name = ctx.adapterName;
+  if (ctx.authType !== undefined)
+    report.auth_type = ctx.authType;
+  if (ctx.contextWindow !== undefined)
+    report.context_window = ctx.contextWindow;
+  if (ctx.providerErrorType !== undefined)
+    report.provider_error_type = ctx.providerErrorType;
+  return report;
+}
+function enforceReportSize(report) {
+  let serialized = JSON.stringify(report);
+  if (serialized.length <= MAX_REPORT_BYTES)
+    return serialized;
+  let msg = report.error_message_template;
+  while (serialized.length > MAX_REPORT_BYTES && msg.length > 0) {
+    msg = msg.slice(0, Math.max(0, msg.length - 50));
+    const trimmed = { ...report, error_message_template: msg + "..." };
+    serialized = JSON.stringify(trimmed);
+  }
+  return serialized.length <= MAX_REPORT_BYTES ? serialized : null;
+}
+async function sendReport(report) {
+  try {
+    const serialized = enforceReportSize(report);
+    if (serialized === null)
+      return;
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    try {
+      await fetch(TELEMETRY_ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: serialized,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch {
+    log("[Telemetry] Failed to send report (silently discarded)");
+  }
+}
+function showConsentPromptAsync(ctx) {
+  if (consentPromptActive)
+    return;
+  try {
+    const profileConfig = loadConfig();
+    if (profileConfig.telemetry?.askedAt !== undefined)
+      return;
+  } catch {
+    return;
+  }
+  consentPromptActive = true;
+  runConsentPrompt(ctx).catch(() => {
+    consentPromptActive = false;
+  });
+}
+async function runConsentPrompt(ctx) {
+  const { createInterface: createInterface2 } = await import("node:readline");
+  const errorSummary = classifyError(ctx.error, ctx.httpStatus);
+  process.stderr.write(`
+[claudish] An error occurred: ` + errorSummary.error_code + `
+`);
+  process.stderr.write(`Help improve claudish by sending an anonymous error report?
+  Sends: version, error type, provider, model, platform.
+  Does NOT send: prompts, paths, API keys, or credentials.
+  Disable anytime: claudish telemetry off
+`);
+  const answer = await new Promise((resolve) => {
+    const rl = createInterface2({ input: process.stdin, output: process.stderr });
+    rl.question("Send anonymous error report? [y/N] ", (ans) => {
+      rl.close();
+      resolve(ans.trim().toLowerCase());
+    });
+  });
+  const accepted = answer === "y" || answer === "yes";
+  try {
+    const profileConfig = loadConfig();
+    profileConfig.telemetry = {
+      enabled: accepted,
+      askedAt: new Date().toISOString(),
+      promptedVersion: claudishVersion
+    };
+    saveConfig(profileConfig);
+    consentEnabled = accepted;
+  } catch {}
+  if (accepted) {
+    process.stderr.write(`[claudish] Error reporting enabled. Thank you!
+`);
+    try {
+      const report = buildReport(ctx);
+      sendReport(report);
+    } catch {}
+  } else {
+    process.stderr.write(`[claudish] Error reporting disabled. You can enable it later: claudish telemetry on
+`);
+  }
+  consentPromptActive = false;
+}
+function initTelemetry(config3) {
+  if (initialized)
+    return;
+  initialized = true;
+  const envOverride = process.env.CLAUDISH_TELEMETRY;
+  if (envOverride === "0" || envOverride === "false" || envOverride === "off") {
+    consentEnabled = false;
+    return;
+  }
+  try {
+    const profileConfig = loadConfig();
+    consentEnabled = profileConfig.telemetry?.enabled ?? false;
+  } catch {
+    consentEnabled = false;
+  }
+  sessionId = randomBytes3(8).toString("hex");
+  claudishVersion = getVersion();
+  installMethod = detectInstallMethod();
+}
+function reportError(ctx) {
+  if (!initialized || !consentEnabled) {
+    if (initialized && !consentEnabled && ctx.isInteractive && process.stderr.isTTY) {
+      showConsentPromptAsync(ctx);
+    }
+    return;
+  }
+  const envOverride = process.env.CLAUDISH_TELEMETRY;
+  if (envOverride === "0" || envOverride === "false" || envOverride === "off") {
+    return;
+  }
+  try {
+    const report = buildReport(ctx);
+    sendReport(report);
+  } catch {
+    log("[Telemetry] Error building report (silently discarded)");
+  }
+}
+async function handleTelemetryCommand(subcommand) {
+  switch (subcommand) {
+    case "on": {
+      const cfg = loadConfig();
+      cfg.telemetry = {
+        ...cfg.telemetry ?? {},
+        enabled: true,
+        askedAt: cfg.telemetry?.askedAt ?? new Date().toISOString(),
+        promptedVersion: claudishVersion || getVersion()
+      };
+      saveConfig(cfg);
+      process.stderr.write(`[claudish] Telemetry enabled. Anonymous error reports will be sent.
+`);
+      process.exit(0);
+    }
+    case "off": {
+      const cfg = loadConfig();
+      cfg.telemetry = {
+        ...cfg.telemetry ?? {},
+        enabled: false,
+        askedAt: cfg.telemetry?.askedAt ?? new Date().toISOString()
+      };
+      saveConfig(cfg);
+      process.stderr.write(`[claudish] Telemetry disabled. No error reports will be sent.
+`);
+      process.exit(0);
+    }
+    case "status": {
+      const cfg = loadConfig();
+      const t = cfg.telemetry;
+      const envOverride = process.env.CLAUDISH_TELEMETRY;
+      const envDisabled = envOverride === "0" || envOverride === "false" || envOverride === "off";
+      if (envDisabled) {
+        process.stderr.write(`[claudish] Telemetry: DISABLED (CLAUDISH_TELEMETRY env var override)
+`);
+      } else if (!t) {
+        process.stderr.write(`[claudish] Telemetry: NOT YET CONFIGURED (will prompt on first error)
+`);
+      } else {
+        const state = t.enabled ? "ENABLED" : "DISABLED";
+        const asked = t.askedAt ? `(configured ${t.askedAt})` : "(never prompted)";
+        process.stderr.write(`[claudish] Telemetry: ${state} ${asked}
+`);
+      }
+      process.stderr.write(`
+Data collected when enabled:
+`);
+      process.stderr.write(`  - Claudish version, error type, provider name, model ID
+`);
+      process.stderr.write(`  - Platform (darwin/linux/win32), runtime, install method
+`);
+      process.stderr.write(`  - Sanitized error message (no paths, no credentials)
+`);
+      process.stderr.write(`  - Ephemeral session ID (not stored, not correlatable)
+`);
+      process.stderr.write(`
+Data NEVER collected:
+`);
+      process.stderr.write(`  - Prompt content, AI responses, tool names
+`);
+      process.stderr.write(`  - API keys, credentials, file paths, hostnames
+`);
+      process.stderr.write(`  - Your name, email, or IP address
+`);
+      process.stderr.write(`
+Manage: claudish telemetry on|off|reset
+`);
+      process.exit(0);
+    }
+    case "reset": {
+      const cfg = loadConfig();
+      if (cfg.telemetry) {
+        delete cfg.telemetry.askedAt;
+        cfg.telemetry.enabled = false;
+        saveConfig(cfg);
+      }
+      process.stderr.write(`[claudish] Telemetry consent reset. You will be asked again on the next error.
+`);
+      process.exit(0);
+    }
+    default:
+      process.stderr.write(`[claudish] Unknown telemetry subcommand: "${subcommand}"
+Usage: claudish telemetry on|off|status|reset
+`);
+      process.exit(1);
+  }
+}
+var TELEMETRY_ENDPOINT = "https://claudish.com/v1/report", MAX_REPORT_BYTES = 4096, KNOWN_PUBLIC_HOSTS, PUBLIC_PROVIDERS, consentEnabled = false, sessionId = "", initialized = false, claudishVersion = "", installMethod = "unknown", consentPromptActive = false;
+var init_telemetry = __esm(() => {
+  init_profile_config();
+  init_logger();
+  KNOWN_PUBLIC_HOSTS = new Set([
+    "api.openai.com",
+    "openrouter.ai",
+    "generativelanguage.googleapis.com",
+    "api.anthropic.com",
+    "aip.googleapis.com",
+    "api.mistral.ai",
+    "api.cohere.ai"
+  ]);
+  PUBLIC_PROVIDERS = new Set([
+    "openrouter",
+    "gemini",
+    "gemini-codeassist",
+    "openai",
+    "vertex",
+    "ollamacloud",
+    "anthropic",
+    "minimax",
+    "kimi",
+    "glm",
+    "zai",
+    "minimax-coding",
+    "kimi-coding",
+    "glm-coding"
+  ]);
+});
+
 // src/config.ts
 var exports_config = {};
 __export(exports_config, {
@@ -34033,7 +34470,7 @@ __export(exports_cli, {
   requiresOpenRouterKey: () => requiresOpenRouterKey,
   parseArgs: () => parseArgs,
   isLocalModel: () => isLocalModel,
-  getVersion: () => getVersion,
+  getVersion: () => getVersion2,
   getMissingKeysError: () => getMissingKeysError,
   getMissingKeyResolutions: () => getMissingKeyResolutions,
   getMissingKeyError: () => getMissingKeyError
@@ -34042,7 +34479,7 @@ import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsS
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { dirname as dirname4, join as join11 } from "node:path";
 import { homedir as homedir10 } from "node:os";
-function getVersion() {
+function getVersion2() {
   return VERSION;
 }
 function clearAllModelCaches() {
@@ -35387,7 +35824,7 @@ async function fetchGLMCodingModels2() {
     return [];
   }
 }
-var __filename5, __dirname5, VERSION = "5.3.0", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2;
+var __filename5, __dirname5, VERSION = "5.4.0", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2;
 var init_cli = __esm(() => {
   init_config();
   init_model_loader();
@@ -63117,21 +63554,30 @@ class ComposedHandler {
   provider;
   adapterManager;
   explicitAdapter;
+  modelAdapter;
   middlewareManager;
   tokenTracker;
   targetModel;
   options;
+  isInteractive;
   constructor(provider, targetModel, modelName, port, options = {}) {
     this.provider = provider;
     this.targetModel = targetModel;
     this.options = options;
     this.explicitAdapter = options.adapter;
+    this.isInteractive = options.isInteractive ?? false;
     this.adapterManager = new AdapterManager(targetModel);
+    const resolvedModelAdapter = this.adapterManager.getAdapter();
+    if (resolvedModelAdapter.getName() !== "DefaultAdapter") {
+      this.modelAdapter = resolvedModelAdapter;
+    }
     this.middlewareManager = new MiddlewareManager;
-    this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
+    if (targetModel.includes("gemini") || targetModel.includes("google/")) {
+      this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
+    }
     this.middlewareManager.initialize().catch((err) => log(`[ComposedHandler:${targetModel}] Middleware init error: ${err}`));
     this.tokenTracker = new TokenTracker(port, {
-      contextWindow: this.getAdapter().getContextWindow(),
+      contextWindow: this.getModelContextWindow(),
       providerName: provider.name,
       modelName,
       providerDisplayName: provider.displayName
@@ -63140,6 +63586,12 @@ class ComposedHandler {
   getAdapter() {
     return this.explicitAdapter || this.adapterManager.getAdapter();
   }
+  getModelContextWindow() {
+    return this.modelAdapter?.getContextWindow() ?? this.getAdapter().getContextWindow();
+  }
+  getModelSupportsVision() {
+    return this.modelAdapter?.supportsVision() ?? this.getAdapter().supportsVision();
+  }
   async handle(c, payload) {
     const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
     const adapter = this.getAdapter();
@@ -63147,7 +63599,7 @@ class ComposedHandler {
       adapter.reset();
     const messages = adapter.convertMessages(claudeRequest, filterIdentity);
     const tools = adapter.convertTools(claudeRequest, this.options.summarizeTools);
-    if (!adapter.supportsVision()) {
+    if (!this.getModelSupportsVision()) {
       const imageBlocks = [];
       for (let msgIdx = 0;msgIdx < messages.length; msgIdx++) {
         const msg = messages[msgIdx];
@@ -63214,12 +63666,28 @@ class ComposedHandler {
       Object.assign(requestPayload, extraFields);
     }
     adapter.prepareRequest(requestPayload, claudeRequest);
+    if (this.modelAdapter && this.modelAdapter !== adapter) {
+      this.modelAdapter.prepareRequest(requestPayload, claudeRequest);
+    }
     const toolNameMap = adapter.getToolNameMap();
     if (this.provider.refreshAuth) {
       try {
         await this.provider.refreshAuth();
       } catch (err) {
         log(`[${this.provider.displayName}] Auth/health check failed: ${err.message}`);
+        logStderr(`Error [${this.provider.displayName}]: Auth/health check failed — ${err.message}. Check credentials and server.`);
+        reportError({
+          error: err,
+          providerName: this.provider.name,
+          providerDisplayName: this.provider.displayName,
+          streamFormat: this.provider.streamFormat,
+          modelId: this.targetModel,
+          httpStatus: undefined,
+          isStreaming: false,
+          retryAttempted: false,
+          isInteractive: this.isInteractive,
+          authType: "oauth"
+        });
         return c.json({ error: { type: "connection_error", message: err.message } }, 503);
       }
       if (this.provider.getContextWindow) {
@@ -63253,6 +63721,18 @@ class ComposedHandler {
       if (error46.code === "ECONNREFUSED" || error46.cause?.code === "ECONNREFUSED") {
         const msg = `Cannot connect to ${this.provider.displayName} at ${endpoint}. Make sure the server is running.`;
         log(`[${this.provider.displayName}] ${msg}`);
+        logStderr(`Error: ${msg} Check the server is running.`);
+        reportError({
+          error: error46,
+          providerName: this.provider.name,
+          providerDisplayName: this.provider.displayName,
+          streamFormat: this.provider.streamFormat,
+          modelId: this.targetModel,
+          httpStatus: undefined,
+          isStreaming: false,
+          retryAttempted: false,
+          isInteractive: this.isInteractive
+        });
         return c.json({ error: { type: "connection_error", message: msg } }, 503);
       }
       throw error46;
@@ -63277,15 +63757,63 @@ class ComposedHandler {
           } else {
             const errorText = await retryResp.text();
             log(`[${this.provider.displayName}] Retry failed: ${errorText}`);
+            logStderr(`Error [${this.provider.displayName}]: HTTP ${retryResp.status} after auth retry. Check API key.`);
+            reportError({
+              error: new Error(errorText),
+              providerName: this.provider.name,
+              providerDisplayName: this.provider.displayName,
+              streamFormat: this.provider.streamFormat,
+              modelId: this.targetModel,
+              httpStatus: retryResp.status,
+              isStreaming: false,
+              retryAttempted: true,
+              isInteractive: this.isInteractive,
+              authType: "oauth"
+            });
             return c.json({ error: errorText }, retryResp.status);
           }
         } catch (err) {
           log(`[${this.provider.displayName}] Auth refresh failed: ${err.message}`);
+          logStderr(`Error [${this.provider.displayName}]: Authentication failed — ${err.message}. Check API key.`);
+          reportError({
+            error: err,
+            providerName: this.provider.name,
+            providerDisplayName: this.provider.displayName,
+            streamFormat: this.provider.streamFormat,
+            modelId: this.targetModel,
+            httpStatus: 401,
+            isStreaming: false,
+            retryAttempted: true,
+            isInteractive: this.isInteractive,
+            authType: "oauth"
+          });
           return c.json({ error: { type: "authentication_error", message: err.message } }, 401);
         }
       } else {
         const errorText = await response.text();
         log(`[${this.provider.displayName}] Error: ${errorText}`);
+        const hint = getRecoveryHint(response.status, errorText, this.provider.displayName);
+        logStderr(`Error [${this.provider.displayName}]: HTTP ${response.status}. ${hint}`);
+        let providerErrorType;
+        try {
+          const parsed = JSON.parse(errorText);
+          providerErrorType = parsed?.error?.type || parsed?.type || parsed?.code || undefined;
+          if (typeof providerErrorType === "string" && providerErrorType.length > 50) {
+            providerErrorType = undefined;
+          }
+        } catch {}
+        reportError({
+          error: new Error(errorText),
+          providerName: this.provider.name,
+          providerDisplayName: this.provider.displayName,
+          streamFormat: this.provider.streamFormat,
+          modelId: this.targetModel,
+          httpStatus: response.status,
+          isStreaming: false,
+          retryAttempted: false,
+          isInteractive: this.isInteractive,
+          providerErrorType
+        });
         return c.json({ error: errorText }, response.status);
       }
     }
@@ -63360,6 +63888,34 @@ class ComposedHandler {
     }
   }
 }
+function getRecoveryHint(status, errorText, providerName) {
+  const lower = errorText.toLowerCase();
+  if (status === 503 || lower.includes("overloaded")) {
+    return "Provider overloaded. Retry or use a different model.";
+  }
+  if (status === 429 || lower.includes("rate limit")) {
+    return "Rate limited. Wait, reduce concurrency, or check plan limits.";
+  }
+  if (status === 401 || status === 403) {
+    return "Check API key / OAuth credentials.";
+  }
+  if (status === 404) {
+    return "Verify model name is correct.";
+  }
+  if (status === 400) {
+    if (lower.includes("unsupported content type") || lower.includes("unsupported_content_type")) {
+      return "Model doesn't support this content format. Try a different model.";
+    }
+    if (lower.includes("context") || lower.includes("too long") || lower.includes("token")) {
+      return "Input too large. Reduce message history or use a larger-context model.";
+    }
+    return "Request format may be incompatible with provider.";
+  }
+  if (status >= 500) {
+    return "Server error — retry after a brief wait.";
+  }
+  return `Unexpected HTTP ${status} from ${providerName}.`;
+}
 var init_composed_handler = __esm(() => {
   init_adapter_manager();
   init_middleware();
@@ -63373,6 +63929,7 @@ var init_composed_handler = __esm(() => {
   init_gemini_sse();
   init_logger();
   init_vision_proxy();
+  init_telemetry();
 });
 
 // src/providers/transport/litellm.ts
@@ -64028,7 +64585,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     if (!openRouterHandlers.has(modelId)) {
       const orProvider = new OpenRouterProvider(openrouterApiKey || "");
       const orAdapter = new OpenRouterAdapter(modelId);
-      openRouterHandlers.set(modelId, new ComposedHandler(orProvider, modelId, modelId, port, { adapter: orAdapter }));
+      openRouterHandlers.set(modelId, new ComposedHandler(orProvider, modelId, modelId, port, { adapter: orAdapter, isInteractive: options.isInteractive }));
     }
     return openRouterHandlers.get(modelId);
   };
@@ -64041,7 +64598,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     const modelId = targetModel.replace(/^poe:/, "");
     if (!poeHandlers.has(modelId)) {
       const poeTransport = new PoeProvider(poeApiKey);
-      poeHandlers.set(modelId, new ComposedHandler(poeTransport, modelId, modelId, port));
+      poeHandlers.set(modelId, new ComposedHandler(poeTransport, modelId, modelId, port, { isInteractive: options.isInteractive }));
     }
     return poeHandlers.get(modelId);
   };
@@ -64061,7 +64618,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
       const handler = new ComposedHandler(provider, resolved.modelName, resolved.modelName, port, {
         adapter,
         tokenStrategy: "local",
-        summarizeTools: options.summarizeTools
+        summarizeTools: options.summarizeTools,
+        isInteractive: options.isInteractive
       });
       localProviderHandlers.set(targetModel, handler);
       log(`[Proxy] Created local provider handler: ${resolved.provider.name}/${resolved.modelName}${resolved.concurrency !== undefined ? ` (concurrency: ${resolved.concurrency})` : ""}`);
@@ -64075,7 +64633,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
       const handler = new ComposedHandler(provider, urlParsed.modelName, urlParsed.modelName, port, {
         adapter,
         tokenStrategy: "local",
-        summarizeTools: options.summarizeTools
+        summarizeTools: options.summarizeTools,
+        isInteractive: options.isInteractive
       });
       localProviderHandlers.set(targetModel, handler);
       log(`[Proxy] Created URL-based local provider handler: ${urlParsed.baseUrl}/${urlParsed.modelName}`);
@@ -64089,7 +64648,10 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     }
     const resolution = resolveModelProvider(targetModel);
     if (resolution.wasAutoRouted && resolution.autoRouteMessage) {
-      console.error(`[Auto-route] ${resolution.autoRouteMessage}`);
+      if (!options.quiet) {
+        console.error(`[Auto-route] ${resolution.autoRouteMessage}`);
+      }
+      log(`[Auto-route] ${resolution.autoRouteMessage}`);
     }
     if (resolution.category === "openrouter") {
       if (resolution.wasAutoRouted && resolution.fullModelId) {
@@ -64111,7 +64673,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         const gemProvider = new GeminiApiKeyProvider(resolved.provider, resolved.modelName, apiKey);
         const gemAdapter = new GeminiAdapter(resolved.modelName);
         handler = new ComposedHandler(gemProvider, targetModel, resolved.modelName, port, {
-          adapter: gemAdapter
+          adapter: gemAdapter,
+          isInteractive: options.isInteractive
         });
         log(`[Proxy] Created Gemini handler (composed): ${resolved.modelName}`);
       } else if (resolved.provider.name === "gemini-codeassist") {
@@ -64119,7 +64682,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         const gcaAdapter = new GeminiAdapter(resolved.modelName);
         handler = new ComposedHandler(gcaProvider, targetModel, resolved.modelName, port, {
           adapter: gcaAdapter,
-          unwrapGeminiResponse: true
+          unwrapGeminiResponse: true,
+          isInteractive: options.isInteractive
         });
         log(`[Proxy] Created Gemini Code Assist handler (composed): ${resolved.modelName}`);
       } else if (resolved.provider.name === "openai") {
@@ -64127,14 +64691,16 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         const oaiAdapter = new OpenAIAdapter(resolved.modelName, resolved.provider.capabilities);
         handler = new ComposedHandler(oaiProvider, targetModel, resolved.modelName, port, {
           adapter: oaiAdapter,
-          tokenStrategy: "delta-aware"
+          tokenStrategy: "delta-aware",
+          isInteractive: options.isInteractive
         });
         log(`[Proxy] Created OpenAI handler (composed): ${resolved.modelName}`);
       } else if (resolved.provider.name === "minimax" || resolved.provider.name === "minimax-coding" || resolved.provider.name === "kimi" || resolved.provider.name === "kimi-coding" || resolved.provider.name === "zai") {
         const acProvider = new AnthropicCompatProvider(resolved.provider, apiKey);
         const acAdapter = new AnthropicPassthroughAdapter(resolved.modelName, resolved.provider.name);
         handler = new ComposedHandler(acProvider, targetModel, resolved.modelName, port, {
-          adapter: acAdapter
+          adapter: acAdapter,
+          isInteractive: options.isInteractive
         });
         log(`[Proxy] Created ${resolved.provider.name} handler (composed): ${resolved.modelName}`);
       } else if (resolved.provider.name === "glm" || resolved.provider.name === "glm-coding") {
@@ -64142,7 +64708,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         const glmAdapter = new OpenAIAdapter(resolved.modelName, resolved.provider.capabilities);
         handler = new ComposedHandler(glmProvider, targetModel, resolved.modelName, port, {
           adapter: glmAdapter,
-          tokenStrategy: "delta-aware"
+          tokenStrategy: "delta-aware",
+          isInteractive: options.isInteractive
         });
         log(`[Proxy] Created ${resolved.provider.name} handler (composed): ${resolved.modelName}`);
       } else if (resolved.provider.name === "opencode-zen") {
@@ -64150,7 +64717,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
           const zenAcProvider = new AnthropicCompatProvider(resolved.provider, apiKey);
           const zenAcAdapter = new AnthropicPassthroughAdapter(resolved.modelName, resolved.provider.name);
           handler = new ComposedHandler(zenAcProvider, targetModel, resolved.modelName, port, {
-            adapter: zenAcAdapter
+            adapter: zenAcAdapter,
+            isInteractive: options.isInteractive
           });
           log(`[Proxy] Created OpenCode Zen (Anthropic composed): ${resolved.modelName}`);
         } else {
@@ -64158,7 +64726,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
           const zenAdapter = new OpenAIAdapter(resolved.modelName, resolved.provider.capabilities);
           handler = new ComposedHandler(zenProvider, targetModel, resolved.modelName, port, {
             adapter: zenAdapter,
-            tokenStrategy: "delta-aware"
+            tokenStrategy: "delta-aware",
+            isInteractive: options.isInteractive
           });
           log(`[Proxy] Created OpenCode Zen (composed): ${resolved.modelName}`);
         }
@@ -64167,19 +64736,23 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         const ocAdapter = new OllamaCloudAdapter(resolved.modelName);
         handler = new ComposedHandler(ocProvider, targetModel, resolved.modelName, port, {
           adapter: ocAdapter,
-          tokenStrategy: "accumulate-both"
+          tokenStrategy: "accumulate-both",
+          isInteractive: options.isInteractive
         });
         log(`[Proxy] Created OllamaCloud handler (composed): ${resolved.modelName}`);
       } else if (resolved.provider.name === "litellm") {
         if (!resolved.provider.baseUrl) {
-          console.error("Error: LITELLM_BASE_URL or --litellm-url is required for LiteLLM provider.");
-          console.error("Set it with: export LITELLM_BASE_URL='https://your-litellm-instance.com'");
-          console.error("Or use: claudish --litellm-url https://your-instance.com --model litellm@model 'task'");
+          logStderr("Error: LITELLM_BASE_URL or --litellm-url is required for LiteLLM provider.");
+          logStderr("Set it with: export LITELLM_BASE_URL='https://your-litellm-instance.com'");
+          logStderr("Or use: claudish --litellm-url https://your-instance.com --model litellm@model 'task'");
           return null;
         }
         const provider = new LiteLLMProvider(resolved.provider.baseUrl, apiKey, resolved.modelName);
         const adapter = new LiteLLMAdapter(resolved.modelName, resolved.provider.baseUrl);
-        handler = new ComposedHandler(provider, targetModel, resolved.modelName, port, { adapter });
+        handler = new ComposedHandler(provider, targetModel, resolved.modelName, port, {
+          adapter,
+          isInteractive: options.isInteractive
+        });
         log(`[Proxy] Created LiteLLM handler (composed): ${resolved.modelName} (${resolved.provider.baseUrl})`);
       } else if (resolved.provider.name === "vertex") {
         const hasApiKey = !!process.env.VERTEX_API_KEY;
@@ -64190,7 +64763,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
           const vxGemProvider = new GeminiApiKeyProvider(expressProvider, resolved.modelName, process.env.VERTEX_API_KEY);
           const vxGemAdapter = new GeminiAdapter(resolved.modelName);
           handler = new ComposedHandler(vxGemProvider, targetModel, resolved.modelName, port, {
-            adapter: vxGemAdapter
+            adapter: vxGemAdapter,
+            isInteractive: options.isInteractive
           });
           log(`[Proxy] Created Vertex AI Express handler (composed): ${resolved.modelName}`);
         } else if (vertexConfig) {
@@ -64213,7 +64787,8 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
           }
           handler = new ComposedHandler(vxProvider, targetModel, resolved.modelName, port, {
             adapter: vxAdapter,
-            ...handlerOpts
+            ...handlerOpts,
+            isInteractive: options.isInteractive
           });
           log(`[Proxy] Created Vertex AI OAuth handler (composed): ${resolved.modelName} [${parsed.publisher}] (project: ${vertexConfig.projectId})`);
         } else {
@@ -64570,6 +65145,7 @@ var isKimiLogout = args.includes("--kimi-logout");
 var isUpdateCommand = args.includes("update");
 var isInitCommand = args[0] === "init" || args.includes("init");
 var isProfileCommand = args[0] === "profile" || args.some((a, i) => a === "profile" && (i === 0 || !args[i - 1]?.startsWith("-")));
+var isTelemetryCommand = args[0] === "telemetry";
 if (isMcpMode) {
   Promise.resolve().then(() => (init_mcp_server(), exports_mcp_server)).then((mcp) => mcp.startMcpServer());
 } else if (isGeminiLogin) {
@@ -64634,10 +65210,16 @@ if (isMcpMode) {
 } else if (isProfileCommand) {
   const profileArgIndex = args.findIndex((a) => a === "profile");
   Promise.resolve().then(() => (init_profile_commands(), exports_profile_commands)).then((pc) => pc.profileCommand(args.slice(profileArgIndex + 1)).catch(handlePromptExit));
+} else if (isTelemetryCommand) {
+  const subcommand = args[1] ?? "status";
+  Promise.resolve().then(() => (init_telemetry(), exports_telemetry)).then((tel) => {
+    tel.initTelemetry({ interactive: true });
+    return tel.handleTelemetryCommand(subcommand);
+  });
 } else {
   runCli();
 }
-function detectInstallMethod() {
+function detectInstallMethod2() {
   const scriptPath = process.argv[1] || "";
   if (scriptPath.includes("/.bun/")) {
     return "bun";
@@ -64662,13 +65244,13 @@ function getUpdateCommand2(method) {
   }
 }
 async function runSelfUpdate() {
-  const { getVersion: getVersion2 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
+  const { getVersion: getVersion3 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
   const { execSync: execSync2 } = await import("node:child_process");
   const { createInterface: createInterface3 } = await import("node:readline");
-  const currentVersion = getVersion2();
-  const installMethod = detectInstallMethod();
+  const currentVersion = getVersion3();
+  const installMethod2 = detectInstallMethod2();
   console.log(`claudish v${currentVersion}`);
-  console.log(`Installation: ${installMethod}`);
+  console.log(`Installation: ${installMethod2}`);
   console.log(`
 Checking for updates...
 `);
@@ -64686,7 +65268,7 @@ Checking for updates...
       console.log(`✓ claudish is up to date (v${currentVersion})`);
       process.exit(0);
     }
-    const updateCmd = getUpdateCommand2(installMethod);
+    const updateCmd = getUpdateCommand2(installMethod2);
     console.log(`New version available: v${currentVersion} → v${latestVersion}
 `);
     const shouldUpdate = await new Promise((resolve) => {
@@ -64727,7 +65309,7 @@ Update failed. Try manually:
 }
 async function runCli() {
   const { checkClaudeInstalled: checkClaudeInstalled2, runClaudeWithProxy: runClaudeWithProxy2 } = await Promise.resolve().then(() => (init_claude_runner(), exports_claude_runner));
-  const { parseArgs: parseArgs2, getVersion: getVersion2 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
+  const { parseArgs: parseArgs2, getVersion: getVersion3 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
   const { DEFAULT_PORT_RANGE: DEFAULT_PORT_RANGE2 } = await Promise.resolve().then(() => (init_config(), exports_config));
   const { selectModel: selectModel2, promptForApiKey: promptForApiKey2 } = await Promise.resolve().then(() => (init_model_selector(), exports_model_selector));
   const {
@@ -64750,6 +65332,8 @@ async function runCli() {
   try {
     const cliConfig = await parseArgs2(process.argv.slice(2));
     initLogger2(cliConfig.debug, cliConfig.logLevel);
+    const { initTelemetry: initTelemetry2 } = await Promise.resolve().then(() => (init_telemetry(), exports_telemetry));
+    initTelemetry2(cliConfig);
     if (cliConfig.debug && !cliConfig.quiet) {
       const logFile = getLogFilePath2();
       if (logFile) {
@@ -64757,7 +65341,7 @@ async function runCli() {
       }
     }
     if (cliConfig.interactive && !cliConfig.jsonOutput) {
-      const shouldExit = await checkForUpdates2(getVersion2(), {
+      const shouldExit = await checkForUpdates2(getVersion3(), {
         quiet: cliConfig.quiet,
         skipPrompt: false
       });
@@ -64845,7 +65429,9 @@ async function runCli() {
       subagent: cliConfig.modelSubagent
     };
     const proxy = await createProxyServer2(port, cliConfig.monitor ? undefined : cliConfig.openrouterApiKey, cliConfig.monitor ? undefined : explicitModel, cliConfig.monitor, cliConfig.anthropicApiKey, modelMap, {
-      summarizeTools: cliConfig.summarizeTools
+      summarizeTools: cliConfig.summarizeTools,
+      quiet: cliConfig.quiet,
+      isInteractive: cliConfig.interactive
     });
     let exitCode = 0;
     try {

package/package.json

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

package/recommended-models.json

@@ -1,6 +1,6 @@
 {
   "version": "1.2.0",
-  "lastUpdated": "2026-03-02",
+  "lastUpdated": "2026-03-03",
   "source": "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
   "models": [
     {
@@ -121,7 +121,7 @@
         "average": "$0.32/1M"
       },
       "context": "163K",
-      "maxOutputTokens": 163840,
+      "maxOutputTokens": 65536,
       "modality": "text->text",
       "supportsTools": true,
       "supportsReasoning": true,