@bman654/clodex 2.0.0 → 2.1.1

package/dist/cli.js

@@ -20,6 +20,7 @@ import {
   loadRegistryStrict,
   recordLaunchSelection,
   registerServerRuntimeState,
+  removeAnthropicProxyBypass,
   resolveBridgeMode,
   savePreferences,
   saveRegistry,
@@ -32,7 +33,7 @@ import {
   withCredentialMutationLock,
   withRegistryWriteLock,
   withRegistryWriteLockSync
-} from "./chunk-ZYGZ5GDI.js";
+} from "./chunk-QLGIKUKC.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -210,7 +211,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.0.0",
+  version: "2.1.1",
   publishConfig: {
     access: "public"
   },
@@ -544,6 +545,10 @@ var ONE_M_CONTEXT_WINDOW = 1e6;
 function stripOneMContextSuffix(modelId) {
   return modelId.replace(/\[1m\]$/i, "");
 }
+function normalizeRouteLookupId(id) {
+  const bare = stripOneMContextSuffix(id);
+  return bare.startsWith("models/") ? bare.slice("models/".length) : bare;
+}
 function claudeCodeClientModelId(modelId, contextWindow) {
   const bare = stripOneMContextSuffix(modelId);
   const window = resolveContextWindow(bare, contextWindow);
@@ -552,19 +557,6 @@ function claudeCodeClientModelId(modelId, contextWindow) {
   }
   return bare;
 }
-function routeLookupIds(id) {
-  const bare = stripOneMContextSuffix(id);
-  const googleBare = bare.startsWith("models/") ? bare.slice("models/".length) : bare;
-  return [.../* @__PURE__ */ new Set([
-    id,
-    bare,
-    `${bare}${ONE_M_CONTEXT_SUFFIX}`,
-    googleBare,
-    `${googleBare}${ONE_M_CONTEXT_SUFFIX}`,
-    `models/${googleBare}`,
-    `models/${bare}`
-  ])];
-}
 
 // src/oauth/types.ts
 function oauthCredentialToKeychainJson(cred) {
@@ -830,24 +822,7 @@ function buildHttpProxyChildEnv(proxyPort, caCertPath) {
   env["https_proxy"] = proxyUrl;
   env["http_proxy"] = proxyUrl;
   env["NODE_EXTRA_CA_CERTS"] = caCertPath;
-  const noProxy = env["NO_PROXY"] ?? env["no_proxy"];
-  if (noProxy !== void 0) {
-    const filtered = noProxy.split(",").map((value) => value.trim()).filter(Boolean).filter((value) => {
-      const entry = value.toLowerCase().replace(/^https?:\/\//, "");
-      const host = entry.replace(/:\d+$/, "");
-      if (host === "*") return false;
-      const suffix = host.startsWith("*.") ? host.slice(1) : host;
-      const bypassesAnthropic = suffix.startsWith(".") ? "api.anthropic.com".endsWith(suffix) : "api.anthropic.com" === suffix || "api.anthropic.com".endsWith(`.${suffix}`);
-      return !bypassesAnthropic;
-    }).join(",");
-    if (filtered) {
-      env["NO_PROXY"] = filtered;
-      env["no_proxy"] = filtered;
-    } else {
-      delete env["NO_PROXY"];
-      delete env["no_proxy"];
-    }
-  }
+  removeAnthropicProxyBypass(env);
   return env;
 }
 function classifyKeyringError(err) {
@@ -2562,6 +2537,12 @@ function numericRetryAfterSeconds(inner) {
   }
   return void 0;
 }
+function boundedTransportCode(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const error = data.error;
+  if (!error || typeof error !== "object") return void 0;
+  return error.code === "websocket_transport_error" ? "websocket_transport_error" : void 0;
+}
 function sdkUpstreamErrorDetails(err) {
   const retry = RetryError.isInstance(err) ? err : void 0;
   const inner = retry?.lastError ?? err;
@@ -2580,7 +2561,8 @@ function sdkUpstreamErrorDetails(err) {
     errorContent: errorContent || inner.message,
     isRetryable: inner.isRetryable,
     attemptCount: retry?.errors.length ?? 1,
-    ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {}
+    ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {},
+    transportCode: boundedTransportCode(inner.data)
   };
 }
 function isContextLengthExceededError(err, formattedMessage = "") {
@@ -5062,6 +5044,7 @@ function nonNegativeInteger(value) {
   return value !== void 0 && Number.isFinite(value) ? Math.max(0, Math.round(value)) : void 0;
 }
 function writeInferenceResponseLifecycleLog(path, entry) {
+  const claudeSessionId = safeClaudeSessionId(entry.claudeSessionId);
   const statusCode = nonNegativeInteger(entry.statusCode);
   const durationMs = nonNegativeInteger(entry.durationMs);
   const timeToFirstByteMs = nonNegativeInteger(entry.timeToFirstByteMs);
@@ -5081,6 +5064,7 @@ function writeInferenceResponseLifecycleLog(path, entry) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     event: entry.event,
     requestId: compactLogValue(entry.requestId, 100),
+    ...claudeSessionId ? { claudeSessionId } : {},
     modelId: compactLogValue(entry.modelId),
     provider: compactLogValue(entry.provider, 200),
     route: entry.route,
@@ -5103,7 +5087,10 @@ function writeInferenceResponseLifecycleLog(path, entry) {
     ...cacheReadInputTokens !== void 0 ? { cacheReadInputTokens } : {},
     ...entry.lastPartType ? { lastPartType: compactLogValue(entry.lastPartType, 100) } : {},
     ...entry.errorType ? { errorType: compactLogValue(entry.errorType, 200) } : {},
-    ...entry.errorSignature ? { errorSignature: compactLogValue(entry.errorSignature, 100) } : {}
+    ...entry.errorCode ? { errorCode: compactLogValue(entry.errorCode, 100) } : {},
+    ...entry.errorSignature ? { errorSignature: compactLogValue(entry.errorSignature, 100) } : {},
+    ...entry.failureSource ? { failureSource: entry.failureSource } : {},
+    ...entry.terminationSource ? { terminationSource: entry.terminationSource } : {}
   }));
 }
 function writeProxyLifecycleLog(path, entry) {
@@ -5154,6 +5141,15 @@ function writeInferenceResponseErrorLog(path, entry) {
     ...includeContent ? { errorContent: compactLogValueWithMarker(entry.errorContent, RESPONSE_ERROR_MAX) } : {}
   }));
 }
+function writeInferenceRouteUnavailableLog(path, entry) {
+  writeSecureLogLine(path, JSON.stringify({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    event: "route_unavailable",
+    requestId: compactLogValue(entry.requestId, 100),
+    modelId: compactLogValue(entry.modelId),
+    statusCode: entry.statusCode
+  }));
+}
 function makeTraceLogger(logPath) {
   resetTraceLog(logPath);
   return (message) => writeSecureLogLine(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}`);
@@ -7309,6 +7305,38 @@ function sendJson(res, status, body) {
   res.end(json);
 }
 
+// src/model-aliases.ts
+var MODEL_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function isValidModelAlias(name) {
+  return MODEL_ALIAS_PATTERN.test(name);
+}
+function parseModelAliasAssignment(value) {
+  const separator = value.indexOf("=");
+  if (separator < 1 || separator === value.length - 1) {
+    return { error: "Alias must use name=clodex:<provider-id>:<model-id>." };
+  }
+  const name = value.slice(0, separator).trim();
+  if (!isValidModelAlias(name)) {
+    return { error: "Alias names must be 1-64 letters, numbers, dots, underscores, or hyphens." };
+  }
+  const rawTarget = value.slice(separator + 1).trim();
+  const target = rawTarget.startsWith("clodex:") ? rawTarget.slice("clodex:".length) : rawTarget;
+  const targetSeparator = target.indexOf(":");
+  if (targetSeparator < 1 || targetSeparator === target.length - 1) {
+    return { error: "Alias target must use clodex:<provider-id>:<model-id>." };
+  }
+  return {
+    name,
+    providerId: target.slice(0, targetSeparator),
+    // `models --list` prints Claude's synthetic context suffix. It is a client
+    // routing hint, not part of the provider catalog id stored in favorites.
+    modelId: stripOneMContextSuffix(target.slice(targetSeparator + 1))
+  };
+}
+function modelAliasTarget(alias) {
+  return `clodex:${alias.providerId}:${alias.modelId}`;
+}
+
 // src/catalog.ts
 function localModelToRoute(lp, model) {
   if (model.modelFormat === "anthropic" && !model.baseUrl) return null;
@@ -7349,6 +7377,12 @@ function makeRouteResolver(localProviders) {
     return provider && model ? localModelToRoute(provider, model) ?? void 0 : void 0;
   };
 }
+function resolveCatalogModelAliases(modelAliases, resolveRoute) {
+  return modelAliases.map((alias) => ({
+    name: alias.name,
+    routeId: resolveRoute(alias.providerId, alias.modelId)?.aliasId ?? modelAliasTarget(alias)
+  }));
+}
 function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MODEL_CATALOG) {
   const droppedFavorites = [];
   const tail = favorites.map((fav) => {
@@ -7363,38 +7397,6 @@ function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MO
   return { routes, droppedFavorites };
 }
 
-// src/model-aliases.ts
-var MODEL_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-function isValidModelAlias(name) {
-  return MODEL_ALIAS_PATTERN.test(name);
-}
-function parseModelAliasAssignment(value) {
-  const separator = value.indexOf("=");
-  if (separator < 1 || separator === value.length - 1) {
-    return { error: "Alias must use name=clodex:<provider-id>:<model-id>." };
-  }
-  const name = value.slice(0, separator).trim();
-  if (!isValidModelAlias(name)) {
-    return { error: "Alias names must be 1-64 letters, numbers, dots, underscores, or hyphens." };
-  }
-  const rawTarget = value.slice(separator + 1).trim();
-  const target = rawTarget.startsWith("clodex:") ? rawTarget.slice("clodex:".length) : rawTarget;
-  const targetSeparator = target.indexOf(":");
-  if (targetSeparator < 1 || targetSeparator === target.length - 1) {
-    return { error: "Alias target must use clodex:<provider-id>:<model-id>." };
-  }
-  return {
-    name,
-    providerId: target.slice(0, targetSeparator),
-    // `models --list` prints Claude's synthetic context suffix. It is a client
-    // routing hint, not part of the provider catalog id stored in favorites.
-    modelId: stripOneMContextSuffix(target.slice(targetSeparator + 1))
-  };
-}
-function modelAliasTarget(alias) {
-  return `clodex:${alias.providerId}:${alias.modelId}`;
-}
-
 // src/http-proxy/routes.ts
 var HTTP_PROXY_MODEL_PREFIX = "clodex:";
 function httpProxyModelId(providerId, modelId) {
@@ -7578,6 +7580,11 @@ function formatOpenAIModels(models) {
   };
 }
 
+// src/route-unavailable.ts
+function routeUnavailableMessage(modelId) {
+  return `Clodex model route '${modelId}' is unavailable. Run \`clodex models --list\` to see available routes, or \`clodex patch\` to refresh saved aliases.`;
+}
+
 // src/upstream-forward.ts
 import { Readable } from "stream";
 
@@ -8678,7 +8685,7 @@ async function listenTcpServer(server, port, host) {
 // src/proxy.ts
 var STREAM_KEEPALIVE_INTERVAL_MS = 2e4;
 var STREAM_KEEPALIVE_PING = 'event: ping\ndata: {"type":"ping"}\n\n';
-function createTranslationLifecycle(logPath, requestId, modelId, provider) {
+function createTranslationLifecycle(logPath, requestId, claudeSessionId, modelId, provider) {
   if (!logPath || !requestId) return void 0;
   const startedAt = Date.now();
   let firstPartAt;
@@ -8693,6 +8700,7 @@ function createTranslationLifecycle(logPath, requestId, modelId, provider) {
   const write = (event, extra = {}) => writeInferenceResponseLifecycleLog(logPath, {
     event,
     requestId,
+    claudeSessionId,
     modelId,
     provider,
     route: "translated",
@@ -8749,11 +8757,16 @@ function createTranslationLifecycle(logPath, requestId, modelId, provider) {
       clearInterval(timer);
       write("translation_cancelled", snapshot(Date.now()));
     },
-    fail(errorType, errorSignature) {
+    fail(errorType, errorSignature, errorCode) {
       if (stopped) return;
       stopped = true;
       clearInterval(timer);
-      write("translation_failed", { ...snapshot(Date.now()), errorType, errorSignature });
+      write("translation_failed", {
+        ...snapshot(Date.now()),
+        errorType,
+        errorSignature,
+        errorCode
+      });
     }
   };
 }
@@ -8798,11 +8811,7 @@ function aliasModelId(realId, providerId) {
   return `anthropic-${sanitized}__${realId}`;
 }
 function lookupRoute(byAlias, id) {
-  for (const key of routeLookupIds(id)) {
-    const route = byAlias.get(key);
-    if (route) return route;
-  }
-  return void 0;
+  return byAlias.get(normalizeRouteLookupId(id));
 }
 async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenceLogPath, debugLogPath, webSocketDiagnosticsLogPath, modelAliases) {
   const proxyToken = randomUUID6();
@@ -8810,12 +8819,16 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
   if (routes.length === 0) {
     throw new Error("Proxy catalog requires at least one route");
   }
-  const byAlias = new Map(routes.map((r) => [r.aliasId, r]));
+  const byAlias = new Map(routes.map((r) => [normalizeRouteLookupId(r.aliasId), r]));
+  const configuredAliasNames = new Set(
+    (modelAliases ?? []).map((alias) => normalizeRouteLookupId(alias.name))
+  );
   for (const alias of modelAliases ?? []) {
-    const route = byAlias.get(alias.routeId);
-    if (route && !byAlias.has(alias.name)) byAlias.set(alias.name, route);
+    const route = lookupRoute(byAlias, alias.routeId);
+    const aliasId = normalizeRouteLookupId(alias.name);
+    if (route && !byAlias.has(aliasId)) byAlias.set(aliasId, route);
   }
-  const defaultRoute = byAlias.get(defaultAliasId) ?? routes[0];
+  const defaultRoute = lookupRoute(byAlias, defaultAliasId) ?? routes[0];
   const plog = makeProxyLog(debug, debugLogPath);
   const onRejection = (reason) => {
     plog(() => `Unhandled Rejection: ${reason instanceof Error ? reason.stack || reason.message : String(reason)}`);
@@ -8882,7 +8895,13 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
       const clientWantsStream = Boolean(anthropicBody.stream);
       const relayRequestIdRaw = req.headers["x-relay-request-id"];
       const relayRequestId = Array.isArray(relayRequestIdRaw) ? relayRequestIdRaw[0] : relayRequestIdRaw;
-      const route = lookupRoute(byAlias, originalModel) ?? defaultRoute;
+      const resolvedRoute = typeof originalModel === "string" ? lookupRoute(byAlias, originalModel) : void 0;
+      const configuredModelUnavailable = typeof originalModel === "string" && (normalizeRouteLookupId(originalModel).startsWith("clodex:") || configuredAliasNames.has(normalizeRouteLookupId(originalModel)));
+      if (!resolvedRoute && configuredModelUnavailable) {
+        anthropicError(res, 400, routeUnavailableMessage(originalModel));
+        return;
+      }
+      const route = resolvedRoute ?? defaultRoute;
       if (messagesEndpoint === "count_tokens" && route.modelFormat !== "anthropic") {
         const inputTokens = estimateAnthropicInputTokens(anthropicBody);
         plog(() => `token-count: local estimate model=${originalModel} input_tokens=${inputTokens}`);
@@ -8994,15 +9013,16 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
       }
       if (usesSdkAdapter) {
         const openAiOAuth = route.npm === "@ai-sdk/openai" && route.authType === "oauth";
+        const claudeSessionIdHeader = Array.isArray(req.headers["x-claude-code-session-id"]) ? req.headers["x-claude-code-session-id"][0] : req.headers["x-claude-code-session-id"];
+        const claudeSessionId = extractClaudeSessionId(anthropicBody, claudeSessionIdHeader);
         const translationLifecycle = createTranslationLifecycle(
           inferenceLogPath,
           relayRequestId,
+          claudeSessionId,
           originalModel,
           route.providerId ?? route.aliasId.split(":")[1] ?? "unknown"
         );
         const runSdkRequest = async () => {
-          const claudeSessionIdHeader = Array.isArray(req.headers["x-claude-code-session-id"]) ? req.headers["x-claude-code-session-id"][0] : req.headers["x-claude-code-session-id"];
-          const claudeSessionId = extractClaudeSessionId(anthropicBody, claudeSessionIdHeader);
           const params = translateRequest(anthropicBody, route.npm, {
             openAiOAuth,
             claudeSessionId,
@@ -9133,7 +9153,8 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
           }
           translationLifecycle?.fail(
             err instanceof Error ? err.name : "UpstreamError",
-            sdkTranslationErrorSignature(err)
+            sdkTranslationErrorSignature(err),
+            details?.transportCode
           );
           const contextLengthExceeded = upstreamStatus === 400 && isContextLengthExceededError(err, message);
           const clientMessage = contextLengthExceeded ? anthropicPromptTooLongMessage(
@@ -10528,7 +10549,7 @@ function requestHeadersWithoutProxyHeaders(req) {
   }
   return headers;
 }
-function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorized, onErrorResponse, onResponseUsage, lifecycle) {
+function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorized, onErrorResponse, onResponseUsage, lifecycle, isLocalShutdown = () => false) {
   return new Promise((resolve2) => {
     const startedAt = Date.now();
     let lastActivityAt = startedAt;
@@ -10546,6 +10567,7 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
       writeInferenceResponseLifecycleLog(lifecycle.logPath, {
         event,
         requestId: lifecycle.requestId,
+        claudeSessionId: lifecycle.claudeSessionId,
         modelId: lifecycle.modelId,
         provider: lifecycle.provider,
         route: "passthrough",
@@ -10628,7 +10650,8 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
           idleMs: now - lastActivityAt,
           bytes,
           chunks,
-          errorType: errorType(err)
+          errorType: errorType(err),
+          terminationSource: "upstream_failure"
         });
         done();
       });
@@ -10657,7 +10680,8 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
         ...firstByteAt !== void 0 ? { timeToFirstByteMs: firstByteAt - startedAt } : {},
         idleMs: now - lastActivityAt,
         bytes,
-        chunks
+        chunks,
+        terminationSource: isLocalShutdown() ? "local_shutdown" : "downstream_client"
       });
       upstream.destroy(new Error("Client disconnected"));
       done();
@@ -10677,7 +10701,8 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
         idleMs: now - lastActivityAt,
         bytes,
         chunks,
-        errorType: errorType(err)
+        errorType: errorType(err),
+        terminationSource: "upstream_failure"
       });
       onErrorResponse?.(502, `Anthropic upstream unreachable: ${err.message}`);
       if (!res.headersSent) res.writeHead(502, { "Content-Type": "text/plain" });
@@ -10687,7 +10712,7 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
     upstream.end(rawBody);
   });
 }
-function forwardToAdapter(req, res, rawBody, adapter, lifecycle) {
+function forwardToAdapter(req, res, rawBody, adapter, adapterRequest = http.request, lifecycle, isLocalShutdown = () => false) {
   return new Promise((resolve2) => {
     const startedAt = Date.now();
     let lastActivityAt = startedAt;
@@ -10706,6 +10731,7 @@ function forwardToAdapter(req, res, rawBody, adapter, lifecycle) {
       writeInferenceResponseLifecycleLog(lifecycle.logPath, {
         event,
         requestId: lifecycle.requestId,
+        claudeSessionId: lifecycle.claudeSessionId,
         modelId: lifecycle.modelId,
         provider: lifecycle.provider,
         route: "translated",
@@ -10757,13 +10783,14 @@ function forwardToAdapter(req, res, rawBody, adapter, lifecycle) {
         ...firstByteAt !== void 0 ? { timeToFirstByteMs: firstByteAt - startedAt } : {},
         idleMs: now - lastActivityAt,
         bytes,
-        chunks
+        chunks,
+        terminationSource: isLocalShutdown() ? "local_shutdown" : "downstream_client"
       });
       adapterResponse?.destroy(new Error("Client disconnected"));
       upstream?.destroy(new Error("Client disconnected"));
       resolve2();
     });
-    const failAdapterRequest = (err) => {
+    const failAdapterRequest = (err, failureSource) => {
       if (clientDisconnected) {
         resolve2();
         return;
@@ -10779,13 +10806,16 @@ function forwardToAdapter(req, res, rawBody, adapter, lifecycle) {
         idleMs: now - lastActivityAt,
         bytes,
         chunks,
-        errorType: err.name
+        errorType: err.name,
+        errorCode: err.code,
+        failureSource,
+        terminationSource: "upstream_failure"
       });
       if (!res.headersSent) res.writeHead(502, { "Content-Type": "text/plain" });
       res.end(`Relay adapter unreachable: ${err.message}`);
       resolve2();
     };
-    upstream = http.request({
+    upstream = adapterRequest({
       hostname: "127.0.0.1",
       port: adapter.port,
       method: "POST",
@@ -10817,7 +10847,7 @@ function forwardToAdapter(req, res, rawBody, adapter, lifecycle) {
         chunks += 1;
       });
       copyResponse(upstreamRes, res, void 0, lifecycle ? (usage) => writeLifecycle("response_usage", usage) : void 0);
-      const failAdapterResponse = (err) => {
+      const failAdapterResponse = (err, failureSource) => {
         if (clientDisconnected) {
           resolve2();
           return;
@@ -10834,7 +10864,10 @@ function forwardToAdapter(req, res, rawBody, adapter, lifecycle) {
           idleMs: now - lastActivityAt,
           bytes,
           chunks,
-          errorType: err.name
+          errorType: err.name,
+          errorCode: err.code,
+          failureSource,
+          terminationSource: "upstream_failure"
         });
         if (!res.writableEnded) res.destroy(err);
         resolve2();
@@ -10844,16 +10877,27 @@ function forwardToAdapter(req, res, rawBody, adapter, lifecycle) {
         lastActivityAt = Date.now();
         resolve2();
       });
-      upstreamRes.once("error", failAdapterResponse);
-      upstreamRes.once("aborted", () => failAdapterResponse(new Error("Relay adapter response aborted")));
+      upstreamRes.once("error", (err) => failAdapterResponse(err, "adapter_response_error"));
+      upstreamRes.once("aborted", () => failAdapterResponse(
+        new Error("Relay adapter response aborted"),
+        "adapter_response_aborted"
+      ));
       upstreamRes.once("close", () => {
-        if (!upstreamRes.complete) failAdapterResponse(new Error("Relay adapter response closed before completion"));
+        if (!upstreamRes.complete) {
+          failAdapterResponse(
+            new Error("Relay adapter response closed before completion"),
+            "adapter_response_close"
+          );
+        }
       });
     });
-    upstream.once("error", failAdapterRequest);
+    upstream.once("error", (err) => failAdapterRequest(err, "adapter_request_error"));
     upstream.once("close", () => {
       if (!headersReceived && !failed) {
-        failAdapterRequest(new Error("Relay adapter connection closed before a response"));
+        failAdapterRequest(
+          new Error("Relay adapter connection closed before a response"),
+          "adapter_request_close"
+        );
       }
     });
     upstream.end(rawBody);
@@ -10886,13 +10930,19 @@ function forwardPlainHttp(req, res) {
 async function startHttpProxy(options) {
   const certificates = ensureHttpProxyCertificates();
   const routesById = /* @__PURE__ */ new Map();
+  const reservedModelIds = /* @__PURE__ */ new Set();
   for (const route of options.routes) {
-    for (const id of routeLookupIds(route.aliasId)) routesById.set(id, route);
+    routesById.set(normalizeRouteLookupId(route.aliasId), route);
   }
   for (const alias of options.modelAliases ?? []) {
-    const route = routesById.get(alias.routeId);
+    const aliasId = normalizeRouteLookupId(alias.name);
+    reservedModelIds.add(aliasId);
+    const route = routesById.get(normalizeRouteLookupId(alias.routeId));
     if (!route) continue;
-    for (const id of routeLookupIds(alias.name)) routesById.set(id, route);
+    routesById.set(aliasId, route);
+  }
+  for (const modelId of options.reservedModelIds ?? []) {
+    reservedModelIds.add(normalizeRouteLookupId(modelId));
   }
   const anthropicOrigin = new URL2(options.anthropicOrigin ?? "https://api.anthropic.com");
   let adapter = options.adapterHandle ?? null;
@@ -10907,6 +10957,7 @@ async function startHttpProxy(options) {
       options.modelAliases
     );
   }
+  let shuttingDown = false;
   const mitmServer = https.createServer({
     key: certificates.serverKey,
     cert: certificates.serverCert,
@@ -10925,13 +10976,49 @@ async function startHttpProxy(options) {
       const requestId = randomUUID8();
       let parsed = null;
       let route;
+      let adapterBody = rawBody;
+      const contentEncoding = (Array.isArray(req.headers["content-encoding"]) ? req.headers["content-encoding"].join(",") : req.headers["content-encoding"] ?? "").trim().toLowerCase();
+      const encodedRequestBody = contentEncoding !== "" && contentEncoding !== "identity";
       try {
-        parsed = JSON.parse(rawBody.toString("utf8"));
-        if (typeof parsed.model === "string") route = routesById.get(parsed.model);
+        const decodedBody = decodeRequestBody(rawBody, req.headers["content-encoding"]);
+        parsed = JSON.parse(decodedBody);
+        if (encodedRequestBody) adapterBody = Buffer.from(decodedBody);
+        if (typeof parsed.model === "string") {
+          route = routesById.get(normalizeRouteLookupId(parsed.model));
+        }
       } catch {
+        if (encodedRequestBody) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            type: "error",
+            error: {
+              type: "invalid_request_error",
+              message: "Unable to inspect compressed request body"
+            }
+          }));
+          return;
+        }
       }
       const claudeSessionIdHeader = Array.isArray(req.headers["x-claude-code-session-id"]) ? req.headers["x-claude-code-session-id"][0] : req.headers["x-claude-code-session-id"];
       const claudeSessionId = parsed ? extractClaudeSessionId(parsed, claudeSessionIdHeader) : void 0;
+      const requestedModel = typeof parsed?.model === "string" ? parsed.model : void 0;
+      const unresolvedRoutedModel = !route && requestedModel !== void 0 && (normalizeRouteLookupId(requestedModel).startsWith(HTTP_PROXY_MODEL_PREFIX) || reservedModelIds.has(normalizeRouteLookupId(requestedModel)));
+      if (unresolvedRoutedModel) {
+        const message = routeUnavailableMessage(requestedModel);
+        if (messagesEndpoint === "messages" && options.inferenceLogPath) {
+          writeInferenceRouteUnavailableLog(options.inferenceLogPath, {
+            requestId,
+            modelId: requestedModel,
+            statusCode: 400
+          });
+        }
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          type: "error",
+          error: { type: "invalid_request_error", message }
+        }));
+        return;
+      }
       if (messagesEndpoint === "messages" && options.inferenceLogPath) {
         const provider = route ? route.providerId ?? route.aliasId.split(":")[1] ?? "unknown" : "anthropic";
         writeInferenceRequestLog(options.inferenceLogPath, {
@@ -10957,13 +11044,22 @@ async function startHttpProxy(options) {
         });
       }
       if (route && adapter) {
-        await forwardToAdapter(req, res, rawBody, adapter, messagesEndpoint === "messages" && options.inferenceLogPath ? {
-          logPath: options.inferenceLogPath,
-          requestId,
-          modelId: typeof parsed?.model === "string" ? parsed.model : "unknown",
-          provider: route.providerId ?? route.aliasId.split(":")[1] ?? "unknown",
-          progressIntervalMs: options.responseProgressIntervalMs ?? INFERENCE_PROGRESS_INTERVAL_MS
-        } : void 0);
+        await forwardToAdapter(
+          req,
+          res,
+          adapterBody,
+          adapter,
+          options.adapterRequest,
+          messagesEndpoint === "messages" && options.inferenceLogPath ? {
+            logPath: options.inferenceLogPath,
+            requestId,
+            claudeSessionId,
+            modelId: typeof parsed?.model === "string" ? parsed.model : "unknown",
+            provider: route.providerId ?? route.aliasId.split(":")[1] ?? "unknown",
+            progressIntervalMs: options.responseProgressIntervalMs ?? INFERENCE_PROGRESS_INTERVAL_MS
+          } : void 0,
+          () => shuttingDown
+        );
         return;
       }
       await forwardRawAnthropicRequest(
@@ -10983,6 +11079,7 @@ async function startHttpProxy(options) {
         messagesEndpoint === "messages" && options.inferenceLogPath ? (usage) => writeInferenceResponseLifecycleLog(options.inferenceLogPath, {
           event: "response_usage",
           requestId,
+          claudeSessionId,
           modelId: typeof parsed?.model === "string" ? parsed.model : "unknown",
           provider: "anthropic",
           route: "passthrough",
@@ -10991,10 +11088,12 @@ async function startHttpProxy(options) {
         messagesEndpoint === "messages" && options.inferenceLogPath ? {
           logPath: options.inferenceLogPath,
           requestId,
+          claudeSessionId,
           modelId: typeof parsed?.model === "string" ? parsed.model : "unknown",
           provider: "anthropic",
           progressIntervalMs: options.responseProgressIntervalMs ?? INFERENCE_PROGRESS_INTERVAL_MS
-        } : void 0
+        } : void 0,
+        () => shuttingDown
       );
       return;
     }
@@ -11072,6 +11171,7 @@ async function startHttpProxy(options) {
     inferenceLogPath: options.inferenceLogPath,
     webSocketDiagnosticsLogPath: options.webSocketDiagnosticsLogPath,
     close: async () => {
+      shuttingDown = true;
       for (const socket of sockets) socket.destroy();
       await new Promise((resolve2) => proxyServer.close(() => resolve2()));
       mitmServer.close();
@@ -11139,18 +11239,40 @@ function reportSkippedHttpProxyFavorites(loaded) {
     );
   }
 }
-async function startConfiguredHttpProxy(port, debug = false, inferenceLogPath = getInferenceRequestLogPath(), debugLogPath, webSocketDiagnosticsLogPath) {
-  const loaded = await loadHttpProxyRoutes();
-  const handle = await startHttpProxy({
+function buildConfiguredHttpProxyOptions(loaded, port, debug = false, inferenceLogPath = getInferenceRequestLogPath(), debugLogPath, webSocketDiagnosticsLogPath) {
+  return {
     host: "127.0.0.1",
     port,
     routes: loaded.routes,
     modelAliases: loaded.aliases,
+    reservedModelIds: loaded.unavailableAliases.map((alias) => alias.name),
     debug,
     debugLogPath,
     inferenceLogPath,
     webSocketDiagnosticsLogPath
-  });
+  };
+}
+function formatHttpProxyEnvironmentLines(handle, baseEnv = process.env) {
+  const env = { ...baseEnv };
+  const hadNoProxy = env["NO_PROXY"] !== void 0 || env["no_proxy"] !== void 0;
+  removeAnthropicProxyBypass(env);
+  return [
+    `  HTTPS_PROXY=http://127.0.0.1:${handle.port}`,
+    `  HTTP_PROXY=http://127.0.0.1:${handle.port}`,
+    `  NODE_EXTRA_CA_CERTS=${handle.caCertPath}`,
+    ...hadNoProxy ? [`  NO_PROXY=${env["NO_PROXY"] ?? ""}`, `  no_proxy=${env["no_proxy"] ?? ""}`] : []
+  ];
+}
+async function startConfiguredHttpProxy(port, debug = false, inferenceLogPath = getInferenceRequestLogPath(), debugLogPath, webSocketDiagnosticsLogPath) {
+  const loaded = await loadHttpProxyRoutes();
+  const handle = await startHttpProxy(buildConfiguredHttpProxyOptions(
+    loaded,
+    port,
+    debug,
+    inferenceLogPath,
+    debugLogPath,
+    webSocketDiagnosticsLogPath
+  ));
   handle.caCertPath = ensureHttpProxyCaBundle(
     handle.caCertPath,
     process.env["NODE_EXTRA_CA_CERTS"]
@@ -11194,9 +11316,7 @@ async function runHttpProxyServerCommand(debug = false, webSocketDiagnostics = f
   });
   console.log("");
   console.log(pc9.bold(pc9.green("clodex proxy-mode server running")));
-  console.log(`  HTTPS_PROXY=http://127.0.0.1:${handle.port}`);
-  console.log(`  HTTP_PROXY=http://127.0.0.1:${handle.port}`);
-  console.log(`  NODE_EXTRA_CA_CERTS=${handle.caCertPath}`);
+  for (const line of formatHttpProxyEnvironmentLines(handle)) console.log(line);
   console.log(`  Request log: ${handle.inferenceLogPath}`);
   if (handle.webSocketDiagnosticsLogPath) {
     console.log(`  WebSocket diagnostics: ${handle.webSocketDiagnosticsLogPath}`);
@@ -12824,10 +12944,18 @@ function printHelp(text4) {
 ${text4}
 `);
 }
-async function launchClaudeViaCatalog(catalogRoutes, startingRoute, contextWindow, trace, claudeArgs) {
+async function launchClaudeViaCatalog(catalogRoutes, startingRoute, modelAliases, contextWindow, trace, claudeArgs) {
   let proxyHandle;
   try {
-    proxyHandle = await startProxyCatalog(catalogRoutes, startingRoute.aliasId, trace);
+    proxyHandle = await startProxyCatalog(
+      catalogRoutes,
+      startingRoute.aliasId,
+      trace,
+      void 0,
+      void 0,
+      void 0,
+      modelAliases
+    );
     p12.log.info(
       `Switch menu active \u2014 proxy on port ${proxyHandle.port} ` + pc13.dim(`(${catalogRoutes.length} model${catalogRoutes.length !== 1 ? "s" : ""} in /model)`)
     );
@@ -13380,6 +13508,7 @@ Error: ${launchPlan.error}
     return launchClaudeViaCatalog(
       catalogRoutes,
       startingRoute,
+      resolveCatalogModelAliases(prefs.modelAliases ?? [], resolveRoute),
       selectedModel.contextWindow,
       trace,
       claudeArgs