claudish 7.15.0 → 7.17.0

package/dist/index.js

@@ -581,7 +581,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.15.0";
+var VERSION = "7.17.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -4306,7 +4306,7 @@ function computeHasOpSources() {
   if (argv.some((a) => a === "--op" || a.startsWith("--op=") || a === "--op-env" || a.startsWith("--op-env="))) {
     return true;
   }
-  if (readAllOnepasswordEnvironments().length > 0)
+  if (configEnvironmentIds().length > 0)
     return true;
   const cfg = readConfigRaw();
   if (cfg.apiKeys) {
@@ -4351,6 +4351,31 @@ function runOpExclusive(op, label = "op:resolve", meta) {
   });
   return run;
 }
+function flagEnvironmentIds() {
+  const argv = process.argv.slice(2);
+  const ids = [];
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--op-env") {
+      const v = argv[i + 1];
+      if (v && !v.startsWith("-"))
+        ids.push(v);
+    } else if (a.startsWith("--op-env=")) {
+      const v = a.slice("--op-env=".length);
+      if (v)
+        ids.push(v);
+    }
+  }
+  return ids;
+}
+function configEnvironmentIds() {
+  if (testSeams?.config)
+    return testSeams.config.onepasswordEnvironments ?? [];
+  return readAllOnepasswordEnvironments();
+}
+function registeredEnvironmentIds() {
+  return [...new Set([...configEnvironmentIds(), ...flagEnvironmentIds()])];
+}
 function maskGlobForTrace(globPath) {
   const body = globPath.startsWith("op://") ? globPath.slice("op://".length) : globPath;
   const segments = body.split("/");
@@ -4387,10 +4412,34 @@ async function resolveGlobShared(globPath, auth) {
   });
   return { resolved: await promise, cacheHit: false };
 }
+async function resolveEnvironmentShared(envId, auth) {
+  const existing = environmentResolutions.get(envId);
+  if (existing)
+    return { resolved: await existing, cacheHit: true };
+  const spanName = `op:env-resolve(${envId})`;
+  const promise = (async () => {
+    const { readEnvironment: readEnvironment2, recordOpHydratedVars: recordOpHydratedVars2 } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
+    const resolved = await traceSpan(spanName, () => readEnvironment2(envId, { auth, sdkFactory: testSeams?.sdkFactory }));
+    addSpanMeta(spanName, { vars: Object.keys(resolved).length });
+    for (const [k, v] of Object.entries(resolved)) {
+      resolvedCache.set(k, v);
+      globResolvedVars.add(k);
+    }
+    recordOpHydratedVars2(Object.keys(resolved));
+    return resolved;
+  })();
+  environmentResolutions.set(envId, promise);
+  promise.catch(() => {
+    if (environmentResolutions.get(envId) === promise)
+      environmentResolutions.delete(envId);
+  });
+  return { resolved: await promise, cacheHit: false };
+}
 function invalidateOpResolutionCache() {
   resolvedCache.clear();
   globResolutions.clear();
   globResolvedVars.clear();
+  environmentResolutions.clear();
   sniffed = undefined;
 }
 async function resolveOpKeyForEnvVars(wanted, opts = {}) {
@@ -4514,6 +4563,28 @@ async function resolveOpKeyForEnvVarsInner(wanted, opts = {}, span) {
         Object.assign(out, resolved);
       }
     }
+    const stillWantedEnv = new Set([...wanted].filter((w) => !(w in out)));
+    if (stillWantedEnv.size > 0) {
+      for (const envId of registeredEnvironmentIds()) {
+        if (stillWantedEnv.size === 0)
+          break;
+        try {
+          const { resolved, cacheHit } = await resolveEnvironmentShared(envId, auth);
+          if (cacheHit)
+            span?.addMeta({ globCacheHit: true });
+          for (const w of [...stillWantedEnv]) {
+            const v = resolved[w];
+            if (v !== undefined) {
+              out[w] = v;
+              stillWantedEnv.delete(w);
+            }
+          }
+        } catch (envErr) {
+          const m = envErr instanceof Error ? envErr.message : String(envErr);
+          console.error(`[claudish] 1Password environment skipped: ${m}`);
+        }
+      }
+    }
   } catch (err) {
     if (err instanceof OpAuthError && onAuthFailure === "skip") {
       console.error(`[claudish] 1Password resolution skipped: ${err.message}`);
@@ -4528,7 +4599,7 @@ async function resolveOpKeyForEnvVarsInner(wanted, opts = {}, span) {
     recordOpHydratedVars2(Object.keys(out));
   return out;
 }
-var OpAuthError, cachedSdkAuth, sdkAuthResolved = false, authInFlight, testSeams, sniffed, opQueue, resolvedCache, globResolutions, globResolvedVars;
+var OpAuthError, cachedSdkAuth, sdkAuthResolved = false, authInFlight, testSeams, sniffed, opQueue, resolvedCache, globResolutions, globResolvedVars, environmentResolutions;
 var init_op_source = __esm(() => {
   init_onepassword_config();
   init_startup_trace();
@@ -4542,6 +4613,7 @@ var init_op_source = __esm(() => {
   resolvedCache = new Map;
   globResolutions = new Map;
   globResolvedVars = new Set;
+  environmentResolutions = new Map;
 });
 
 // src/onepassword-command.ts
@@ -30832,8 +30904,24 @@ var init_all_models_cache = __esm(() => {
 
 // src/adapters/model-catalog.ts
 function lookupModel(modelId, cachePath) {
+  const entry = findCacheEntry(modelId, cachePath);
+  if (!entry || entry.contextWindow === undefined)
+    return;
+  return {
+    modelId: entry.modelId,
+    contextWindow: entry.contextWindow,
+    supportsVision: entry.supportsVision
+  };
+}
+function lookupModelForProvider(modelId, provider, cachePath) {
+  const entry = findCacheEntry(modelId, cachePath);
+  if (!entry)
+    return;
+  return entry.aggregators?.find((a) => a.provider === provider)?.contextWindow ?? entry.contextWindow;
+}
+function findCacheEntry(modelId, cachePath) {
   if (modelId.includes("@")) {
-    throw new Error(`lookupModel() received provider-routed ID "${modelId}" \u2014 callers must strip the "@" prefix before calling`);
+    throw new Error(`model-catalog lookup received provider-routed ID "${modelId}" \u2014 callers must strip the "@" prefix before calling`);
   }
   const cache = readAllModelsCache(cachePath);
   if (!cache || cache.entries.length === 0)
@@ -30845,13 +30933,7 @@ function lookupModel(modelId, cachePath) {
     const exactMatch = entryId === unprefixed || entryId === lower;
     const aliasMatch = entry.aliases?.some((a) => a.toLowerCase() === unprefixed || a.toLowerCase() === lower);
     if (exactMatch || aliasMatch) {
-      if (entry.contextWindow === undefined)
-        return;
-      return {
-        modelId: entry.modelId,
-        contextWindow: entry.contextWindow,
-        supportsVision: entry.supportsVision
-      };
+      return entry;
     }
   }
   return;
@@ -38385,9 +38467,20 @@ data: ${JSON.stringify(data)}
                 const errMsg = err.message || event.message || "Unknown API error";
                 const errCode = err.code || event.code || "";
                 log(`[ResponsesSSE] API error: ${errCode} - ${errMsg}`);
+                opts.onApiError?.(errCode, errMsg);
                 closeReasoning();
                 closeText();
                 closeTools();
+                const isCtxOverflow = errCode === "context_length_exceeded" || /context (length|window)|exceeds? the context|too long|maximum context/i.test(errMsg);
+                let errorText = `
+
+[API Error: ${errCode} ${errMsg}]`;
+                if (isCtxOverflow) {
+                  const cap = opts.contextWindow && opts.contextWindow > 0 ? ` ~${Math.round(opts.contextWindow / 1000)}K tokens` : "";
+                  errorText = `
+
+[Context limit reached] This model's backend enforces a smaller context window${cap} than its API spec. ` + "Run /clear to start fresh (/compact will also fail \u2014 it re-sends the full conversation), " + `or route the model via \`oai@${opts.modelName}\` to use the full-size window.`;
+                }
                 const errorIdx = curIdx++;
                 send("content_block_start", {
                   type: "content_block_start",
@@ -38397,9 +38490,7 @@ data: ${JSON.stringify(data)}
                 send("content_block_delta", {
                   type: "content_block_delta",
                   index: errorIdx,
-                  delta: { type: "text_delta", text: `
-
-[API Error: ${errCode} ${errMsg}]` }
+                  delta: { type: "text_delta", text: errorText }
                 });
                 send("content_block_stop", { type: "content_block_stop", index: errorIdx });
                 send("message_delta", {
@@ -39078,6 +39169,7 @@ class ComposedHandler {
     }
     latencyMs = Math.round(performance.now() - startTime);
     const httpStatus = response.status;
+    let streamApiError = null;
     const onStreamComplete = () => {
       try {
         const isFreeModel = this.tokenTracker.getTotalCost() === 0;
@@ -39086,7 +39178,7 @@ class ComposedHandler {
           provider_name: this.provider.name,
           stream_format: this.provider.streamFormat,
           latency_ms: latencyMs,
-          success: true,
+          success: streamApiError === null,
           http_status: httpStatus,
           input_tokens: this.tokenTracker.getInputTokens(),
           output_tokens: this.tokenTracker.getOutputTokens(),
@@ -39102,9 +39194,11 @@ class ComposedHandler {
         });
       } catch {}
     };
-    return this.handleStream(c, response, adapter, claudeRequest, toolNameMap, onStreamComplete);
+    return this.handleStream(c, response, adapter, claudeRequest, toolNameMap, onStreamComplete, (code, message) => {
+      streamApiError = { code, message };
+    });
   }
-  handleStream(c, response, adapter, claudeRequest, toolNameMap, onComplete) {
+  handleStream(c, response, adapter, claudeRequest, toolNameMap, onComplete, onApiError) {
     let pendingOnComplete = onComplete;
     const onTokenUpdate = (input, output) => {
       const strategy = this.options.tokenStrategy || "standard";
@@ -39137,7 +39231,9 @@ class ComposedHandler {
         return createResponsesStreamHandler(c, response, {
           modelName: this.bareModelName,
           onTokenUpdate,
-          toolNameMap: adapter.getToolNameMap()
+          toolNameMap: adapter.getToolNameMap(),
+          contextWindow: lookupModelForProvider(this.bareModelName, this.provider.name),
+          onApiError
         });
       case "anthropic-sse":
         return createAnthropicPassthroughStream(c, response, {
@@ -39240,6 +39336,7 @@ var init_composed_handler = __esm(() => {
   init_anthropic_sse();
   init_gemini_sse();
   init_ollama_jsonl();
+  init_model_catalog();
   init_openai_responses_sse();
   init_openai_sse();
   init_token_tracker();
@@ -41875,6 +41972,7 @@ var init_ollamacloud = __esm(() => {
 var OpenAICodexTransport;
 var init_openai_codex = __esm(() => {
   init_codex_api_format();
+  init_model_catalog();
   init_authority();
   init_openai();
   OpenAICodexTransport = class OpenAICodexTransport extends OpenAIProviderTransport {
@@ -41904,6 +42002,9 @@ var init_openai_codex = __esm(() => {
       }
       return this.cachedAuth?.transformPayload?.(normalizedPayload) ?? normalizedPayload;
     }
+    getContextWindow() {
+      return lookupModelForProvider(this.modelName, this.name) ?? 0;
+    }
   };
 });
 
@@ -58594,6 +58695,7 @@ var init_config = __esm(() => {
     ANTHROPIC_DEFAULT_SONNET_MODEL: "ANTHROPIC_DEFAULT_SONNET_MODEL",
     ANTHROPIC_DEFAULT_HAIKU_MODEL: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
     CLAUDE_CODE_SUBAGENT_MODEL: "CLAUDE_CODE_SUBAGENT_MODEL",
+    CLAUDE_CODE_AUTO_COMPACT_WINDOW: "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
     OLLAMA_BASE_URL: "OLLAMA_BASE_URL",
     OLLAMA_HOST: "OLLAMA_HOST",
     LMSTUDIO_BASE_URL: "LMSTUDIO_BASE_URL",
@@ -71279,6 +71381,7 @@ __export(exports_claude_runner, {
   runClaudeWithProxy: () => runClaudeWithProxy,
   managedSettingsForcesClaudeAi: () => managedSettingsForcesClaudeAi,
   isProxyAuthMode: () => isProxyAuthMode,
+  computeMainThreadContextWindow: () => computeMainThreadContextWindow,
   checkClaudeInstalled: () => checkClaudeInstalled,
   buildClaudishSettingsOverlay: () => buildClaudishSettingsOverlay
 });
@@ -71497,6 +71600,29 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine, proxy
   }
   config3.claudeArgs.splice(idx, 2);
 }
+async function computeMainThreadContextWindow(config3, cachePath) {
+  const specs = [config3.model, config3.modelOpus, config3.modelSonnet].filter((s) => typeof s === "string" && s.length > 0);
+  if (specs.length === 0)
+    return 0;
+  let min = Number.POSITIVE_INFINITY;
+  for (const spec of specs) {
+    try {
+      const parsed = parseModelSpec(spec);
+      let provider = parsed.provider;
+      if (!parsed.isExplicitProvider) {
+        const plan = await route(spec);
+        if (plan.kind !== "ok")
+          continue;
+        provider = plan.primary.provider;
+      }
+      const win = lookupModelForProvider(parsed.model, provider, cachePath);
+      if (typeof win === "number" && win > 0) {
+        min = Math.min(min, win);
+      }
+    } catch {}
+  }
+  return Number.isFinite(min) ? min : 0;
+}
 async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
   const hasProfileMappings = config3.modelOpus || config3.modelSonnet || config3.modelHaiku || config3.modelSubagent;
   const modelId = config3.model || (hasProfileMappings || config3.monitor ? undefined : "unknown");
@@ -71561,6 +71687,15 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     if (hasNativeAnthropicMapping(config3)) {} else {
       env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
       env.ANTHROPIC_AUTH_TOKEN = process.env.ANTHROPIC_AUTH_TOKEN || "placeholder-token-not-used-proxy-handles-auth";
+      if (!process.env[ENV.CLAUDE_CODE_AUTO_COMPACT_WINDOW]) {
+        const autoCompactWindow = await computeMainThreadContextWindow(config3);
+        if (autoCompactWindow > 0) {
+          env[ENV.CLAUDE_CODE_AUTO_COMPACT_WINDOW] = String(autoCompactWindow);
+          if (!config3.quiet) {
+            console.error(`[claudish] Auto-compact window: ${autoCompactWindow.toLocaleString()} tokens ` + "(Claude Code compacts before the backend's real limit)");
+          }
+        }
+      }
     }
   }
   const log2 = (message) => {
@@ -71734,8 +71869,10 @@ async function checkClaudeInstalled() {
   return binary !== null;
 }
 var init_claude_runner = __esm(() => {
+  init_model_catalog();
   init_config();
   init_model_parser();
+  init_routing_rules();
   init_telemetry();
 });
 
@@ -72236,7 +72373,6 @@ var init_team_grid = __esm(() => {
 
 // src/index.ts
 init_op_source();
-init_onepassword_config();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
 import { readFileSync as readFileSync23 } from "fs";
@@ -72273,42 +72409,15 @@ process.on("exit", () => {
 });
 async function applyOpEnvironment() {
   const argv = process.argv.slice(2);
-  let flagEnvId;
   for (let i = 0;i < argv.length; i++) {
     const a = argv[i];
-    if (a === "--op-env") {
-      flagEnvId = argv[i + 1];
-      break;
-    }
-    if (a.startsWith("--op-env=")) {
-      flagEnvId = a.slice("--op-env=".length);
-      break;
-    }
-  }
-  if (flagEnvId !== undefined && (flagEnvId === "" || flagEnvId.startsWith("-"))) {
-    console.error("[claudish] --op-env requires a 1Password Environment ID");
-    process.exit(1);
-  }
-  const configEnvIds = readAllOnepasswordEnvironments();
-  const envIds = [...configEnvIds];
-  if (flagEnvId !== undefined && flagEnvId !== "")
-    envIds.push(flagEnvId);
-  if (envIds.length === 0)
-    return;
-  try {
-    const { readEnvironment: readEnvironment2, recordOpHydratedVars: recordOpHydratedVars2 } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
-    const auth = await resolveExplicitFlagAuth();
-    for (const envId of envIds) {
-      const vars = await readEnvironment2(envId, { auth });
-      for (const [key, value] of Object.entries(vars)) {
-        process.env[key] = value;
-      }
-      recordOpHydratedVars2(Object.keys(vars));
+    if (a !== "--op-env" && !a.startsWith("--op-env="))
+      continue;
+    const val = a === "--op-env" ? argv[i + 1] : a.slice("--op-env=".length);
+    if (val === undefined || val === "" || val.startsWith("-")) {
+      console.error("[claudish] --op-env requires a 1Password Environment ID");
+      process.exit(1);
     }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[claudish] 1Password Environment load failed: ${message}`);
-    process.exit(1);
   }
 }
 async function applyOpImport() {

package/package.json

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