@bman654/clodex 0.1.0 → 1.0.0

package/dist/cli.js

@@ -11,10 +11,11 @@ import {
   getServerFavoritesOnly,
   getServerListenMode,
   getServerMaskGatewayIds,
+  isDiscoveryDisabled,
   launchClaude,
   loadPreferences,
   recordLaunchSelection,
-  removeServerRuntimeState,
+  registerServerRuntimeState,
   resolveBridgeMode,
   savePreferences,
   setSavedServerPassword,
@@ -22,8 +23,8 @@ import {
   setServerFavoritesOnly,
   setServerListenMode,
   setServerMaskGatewayIds,
-  writeServerRuntimeState
-} from "./chunk-C7N2JI7Z.js";
+  unregisterServerRuntimeState
+} from "./chunk-3XM6UZWP.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -201,7 +202,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "0.1.0",
+  version: "1.0.0",
   publishConfig: {
     access: "public"
   },
@@ -6259,6 +6260,146 @@ function sendJson(res, status, body) {
   res.end(json);
 }
 
+// src/catalog.ts
+function localModelToRoute(lp, model) {
+  if (model.modelFormat === "anthropic" && !model.baseUrl) return null;
+  if (model.modelFormat === "openai" && !isSdkMigratedNpm(model.npm) && !model.completionsUrl) return null;
+  const upstreamUrl = model.modelFormat === "anthropic" ? model.baseUrl : model.completionsUrl;
+  return {
+    aliasId: claudeCodeClientModelId(aliasModelId(model.id, lp.id), model.contextWindow),
+    realModelId: model.upstreamModelId,
+    displayName: `${model.name || model.id} (${lp.name})`,
+    upstreamUrl: upstreamUrl ?? "",
+    apiKey: lp.apiKey,
+    modelFormat: model.modelFormat,
+    contextWindow: model.contextWindow,
+    npm: model.npm,
+    baseURL: model.apiBaseUrl,
+    providerId: lp.id,
+    authType: lp.authType,
+    oauthAccountId: lp.oauthAccountId,
+    providerData: lp.providerData,
+    headers: lp.headers,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField,
+    useResponsesLite: model.useResponsesLite,
+    preferWebSockets: model.preferWebSockets
+  };
+}
+function makeRouteResolver(localProviders) {
+  return (providerId, modelId) => {
+    const provider = localProviders?.find((lp) => lp.id === providerId);
+    const model = provider?.models.find((m) => m.id === modelId);
+    return provider && model ? localModelToRoute(provider, model) ?? void 0 : void 0;
+  };
+}
+function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MODEL_CATALOG) {
+  const droppedFavorites = [];
+  const tail = favorites.map((fav) => {
+    const route = resolveRoute(fav.providerId, fav.modelId);
+    if (!route) droppedFavorites.push(fav);
+    return route;
+  }).filter((route) => route !== void 0);
+  const routes = [
+    startingRoute,
+    ...tail.filter((route) => route.aliasId !== startingRoute.aliasId)
+  ].slice(0, max);
+  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) {
+  return `${HTTP_PROXY_MODEL_PREFIX}${providerId}:${modelId}`;
+}
+function httpProxyDisplayName(model, providerName) {
+  return `${formatModelLabel(model)} (${providerName})`;
+}
+function buildHttpProxyRoutes(providers, favorites, modelAliases = [], max = MAX_MODEL_CATALOG) {
+  const routes = [];
+  const unavailable = [];
+  const unsupported = [];
+  const seen = /* @__PURE__ */ new Set();
+  const routesByFavorite = /* @__PURE__ */ new Map();
+  for (const favorite of favorites) {
+    if (routes.length >= max) break;
+    const provider = providers.find((item) => item.id === favorite.providerId);
+    const model = provider?.models.find((item) => item.id === favorite.modelId);
+    if (!provider || !model) {
+      unavailable.push(favorite);
+      continue;
+    }
+    if (model.modelFormat !== "openai" || !isSdkMigratedNpm(model.npm)) {
+      unsupported.push(favorite);
+      continue;
+    }
+    const route = localModelToRoute(provider, model);
+    if (!route || !route.apiKey.trim()) {
+      unavailable.push(favorite);
+      continue;
+    }
+    const aliasId = claudeCodeClientModelId(
+      httpProxyModelId(provider.id, model.id),
+      model.contextWindow
+    );
+    if (seen.has(aliasId)) continue;
+    seen.add(aliasId);
+    const proxyRoute = {
+      ...route,
+      aliasId,
+      displayName: httpProxyDisplayName(model, provider.name)
+    };
+    routes.push(proxyRoute);
+    routesByFavorite.set(`${favorite.providerId}:${favorite.modelId}`, proxyRoute);
+  }
+  const aliases = [];
+  const unavailableAliases = [];
+  const seenAliases = /* @__PURE__ */ new Set();
+  for (const alias of modelAliases) {
+    const route = routesByFavorite.get(`${alias.providerId}:${alias.modelId}`);
+    if (!isValidModelAlias(alias.name) || seenAliases.has(alias.name) || !route) {
+      unavailableAliases.push(alias);
+      continue;
+    }
+    seenAliases.add(alias.name);
+    aliases.push({ name: alias.name, routeId: route.aliasId, displayName: route.displayName });
+  }
+  return { routes, unavailable, unsupported, aliases, unavailableAliases };
+}
+
 // src/server/vendor-mask.ts
 function reverseSegment(value) {
   return [...value].reverse().join("");
@@ -6320,7 +6461,7 @@ function formatGatewayAnthropicModels(models, opts) {
     }))
   );
 }
-function createGatewayModelCatalog(models, opts) {
+function createGatewayModelCatalog(models, opts, modelAliases) {
   const byId = /* @__PURE__ */ new Map();
   for (const model of models) {
     byId.set(model.id, model);
@@ -6331,6 +6472,17 @@ function createGatewayModelCatalog(models, opts) {
       if (rawAlias !== alias) byId.set(rawAlias, model);
     }
   }
+  for (const model of models) {
+    const canonicalId = httpProxyModelId(gatewayProviderId(model), model.id);
+    if (!byId.has(canonicalId)) byId.set(canonicalId, model);
+  }
+  for (const alias of modelAliases ?? []) {
+    if (byId.has(alias.name)) continue;
+    const target = models.find(
+      (model) => gatewayProviderId(model) === alias.providerId && model.id === alias.modelId
+    );
+    if (target) byId.set(alias.name, target);
+  }
   return {
     get: (id) => byId.get(id),
     list: () => [...models]
@@ -7898,54 +8050,6 @@ function startProxy(completionsUrl, modelId, debug = false, contextWindow, sdk,
   }], clientModelId, debug);
 }
 
-// src/catalog.ts
-function localModelToRoute(lp, model) {
-  if (model.modelFormat === "anthropic" && !model.baseUrl) return null;
-  if (model.modelFormat === "openai" && !isSdkMigratedNpm(model.npm) && !model.completionsUrl) return null;
-  const upstreamUrl = model.modelFormat === "anthropic" ? model.baseUrl : model.completionsUrl;
-  return {
-    aliasId: claudeCodeClientModelId(aliasModelId(model.id, lp.id), model.contextWindow),
-    realModelId: model.upstreamModelId,
-    displayName: `${model.name || model.id} (${lp.name})`,
-    upstreamUrl: upstreamUrl ?? "",
-    apiKey: lp.apiKey,
-    modelFormat: model.modelFormat,
-    contextWindow: model.contextWindow,
-    npm: model.npm,
-    baseURL: model.apiBaseUrl,
-    providerId: lp.id,
-    authType: lp.authType,
-    oauthAccountId: lp.oauthAccountId,
-    providerData: lp.providerData,
-    headers: lp.headers,
-    supportedParameters: model.supportedParameters,
-    reasoning: model.reasoning,
-    interleavedReasoningField: model.interleavedReasoningField,
-    useResponsesLite: model.useResponsesLite,
-    preferWebSockets: model.preferWebSockets
-  };
-}
-function makeRouteResolver(localProviders) {
-  return (providerId, modelId) => {
-    const provider = localProviders?.find((lp) => lp.id === providerId);
-    const model = provider?.models.find((m) => m.id === modelId);
-    return provider && model ? localModelToRoute(provider, model) ?? void 0 : void 0;
-  };
-}
-function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MODEL_CATALOG) {
-  const droppedFavorites = [];
-  const tail = favorites.map((fav) => {
-    const route = resolveRoute(fav.providerId, fav.modelId);
-    if (!route) droppedFavorites.push(fav);
-    return route;
-  }).filter((route) => route !== void 0);
-  const routes = [
-    startingRoute,
-    ...tail.filter((route) => route.aliasId !== startingRoute.aliasId)
-  ].slice(0, max);
-  return { routes, droppedFavorites };
-}
-
 // src/server/index.ts
 import pc10 from "picocolors";
 import { networkInterfaces } from "os";
@@ -8587,6 +8691,7 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
     }
     const completionsUrl = model.completionsUrl;
     const apiKey2 = model.apiKey ?? options.apiKey;
+    const forwardBody = body.model === upstreamModelId(model) ? body : { ...body, model: upstreamModelId(model) };
     auditInference(options, {
       modelId: body.model,
       effort: openAiEffort(body),
@@ -8594,7 +8699,7 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
       route: "passthrough",
       requestPreview: getLatestMessagePreview(body.messages, body.system)
     });
-    await relayAnthropicMessages(res, completionsUrl, body, apiKey2, Boolean(body.stream), {
+    await relayAnthropicMessages(res, completionsUrl, forwardBody, apiKey2, Boolean(body.stream), {
       onUpstreamError: options.inferenceLogPath ? (statusCode, errorContent) => writeInferenceResponseErrorLog(options.inferenceLogPath, {
         modelId: body.model,
         provider: inferenceProvider(model),
@@ -8698,6 +8803,7 @@ async function getOrInitLanguageModel(modelCache, model, npm, baseURL, apiKey, w
   return languageModel;
 }
 function getResponseModelId(bodyModel, model, options) {
+  if (typeof bodyModel === "string" && options.aliasNames?.has(bodyModel)) return bodyModel;
   return options.gateway?.maskGatewayIds ? gatewayDisplayName(model, options.gateway) : typeof bodyModel === "string" ? bodyModel : model.id;
 }
 async function readJson(req) {
@@ -8833,95 +8939,6 @@ async function selectServerProviders(available, initial) {
 import pc9 from "picocolors";
 import * as p8 from "@clack/prompts";
 
-// 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) {
-  return `${HTTP_PROXY_MODEL_PREFIX}${providerId}:${modelId}`;
-}
-function buildHttpProxyRoutes(providers, favorites, modelAliases = [], max = MAX_MODEL_CATALOG) {
-  const routes = [];
-  const unavailable = [];
-  const unsupported = [];
-  const seen = /* @__PURE__ */ new Set();
-  const routesByFavorite = /* @__PURE__ */ new Map();
-  for (const favorite of favorites) {
-    if (routes.length >= max) break;
-    const provider = providers.find((item) => item.id === favorite.providerId);
-    const model = provider?.models.find((item) => item.id === favorite.modelId);
-    if (!provider || !model) {
-      unavailable.push(favorite);
-      continue;
-    }
-    if (model.modelFormat !== "openai" || !isSdkMigratedNpm(model.npm)) {
-      unsupported.push(favorite);
-      continue;
-    }
-    const route = localModelToRoute(provider, model);
-    if (!route || !route.apiKey.trim()) {
-      unavailable.push(favorite);
-      continue;
-    }
-    const aliasId = claudeCodeClientModelId(
-      httpProxyModelId(provider.id, model.id),
-      model.contextWindow
-    );
-    if (seen.has(aliasId)) continue;
-    seen.add(aliasId);
-    const proxyRoute = {
-      ...route,
-      aliasId,
-      displayName: `${model.name || model.id} (${provider.name})`
-    };
-    routes.push(proxyRoute);
-    routesByFavorite.set(`${favorite.providerId}:${favorite.modelId}`, proxyRoute);
-  }
-  const aliases = [];
-  const unavailableAliases = [];
-  const seenAliases = /* @__PURE__ */ new Set();
-  for (const alias of modelAliases) {
-    const route = routesByFavorite.get(`${alias.providerId}:${alias.modelId}`);
-    if (!isValidModelAlias(alias.name) || seenAliases.has(alias.name) || !route) {
-      unavailableAliases.push(alias);
-      continue;
-    }
-    seenAliases.add(alias.name);
-    aliases.push({ name: alias.name, routeId: route.aliasId, displayName: route.displayName });
-  }
-  return { routes, unavailable, unsupported, aliases, unavailableAliases };
-}
-
 // src/http-proxy/server.ts
 import * as http from "http";
 import * as https from "https";
@@ -9842,7 +9859,7 @@ function waitForShutdown() {
     process.once("SIGTERM", done);
   });
 }
-async function runHttpProxyServerCommand(debug = false, webSocketDiagnostics = false, port) {
+async function runHttpProxyServerCommand(debug = false, webSocketDiagnostics = false, port, noDiscovery = false) {
   const webSocketDiagnosticsLogPath = webSocketDiagnostics ? getSessionLogPath("server-websocket-diagnostics", "jsonl") : void 0;
   let started;
   try {
@@ -9875,15 +9892,17 @@ async function runHttpProxyServerCommand(debug = false, webSocketDiagnostics = f
   console.log(pc9.dim("Anthropic requests keep Claude Code auth and pass through unchanged."));
   console.log(pc9.dim("Use `/model <listed-name>` for a favorite or saved alias."));
   console.log(pc9.dim("Press Ctrl+C to stop."));
-  writeServerRuntimeState({
-    mode: "proxy",
-    port: handle.port,
-    pid: process.pid,
-    caPath: handle.caCertPath,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  if (!noDiscovery) {
+    registerServerRuntimeState({
+      mode: "proxy",
+      port: handle.port,
+      pid: process.pid,
+      caPath: handle.caCertPath,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
   await waitForShutdown();
-  removeServerRuntimeState();
+  if (!noDiscovery) unregisterServerRuntimeState();
   await handle.close();
   return 0;
 }
@@ -10113,13 +10132,14 @@ async function resolveServerUpstreamApiKey() {
   return null;
 }
 async function runServerCommand(options = {}) {
+  const noDiscovery = isDiscoveryDisabled(options.noDiscovery);
   if (options.httpProxy) {
     const hasGatewayOptions = options.quick || options.listenMode !== void 0 || options.providersMode !== void 0 || options.maskGatewayIds !== void 0 || options.password !== void 0;
     if (hasGatewayOptions) {
       p9.log.error("--proxy is a local-only server mode and cannot be combined with endpoint-mode server options.");
       return 1;
     }
-    return runHttpProxyServerCommand(false, options.wsDiagnostics, options.port);
+    return runHttpProxyServerCommand(false, options.wsDiagnostics, options.port, noDiscovery);
   }
   const apiKey = await resolveServerUpstreamApiKey();
   if (!apiKey) {
@@ -10184,6 +10204,7 @@ async function runServerCommand(options = {}) {
     return 1;
   }
   const gateway = runConfig.maskGatewayIds ? { maskGatewayIds: true } : void 0;
+  const modelAliases = loadPreferences().modelAliases ?? [];
   const inferenceLogPath = getInferenceRequestLogPath();
   const webSocketDiagnosticsLogPath = options.wsDiagnostics ? getSessionLogPath("server-websocket-diagnostics", "jsonl") : void 0;
   const server = await startServer({
@@ -10191,8 +10212,9 @@ async function runServerCommand(options = {}) {
     port: options.port ?? DEFAULT_SERVER_PORT,
     apiKey,
     serverPassword,
-    catalog: createGatewayModelCatalog(models, gateway),
+    catalog: createGatewayModelCatalog(models, gateway, modelAliases),
     gateway,
+    aliasNames: new Set(modelAliases.map((alias) => alias.name)),
     inferenceLogPath,
     webSocketDiagnosticsLogPath
   });
@@ -10231,14 +10253,16 @@ async function runServerCommand(options = {}) {
   console.log("");
   printModelCatalog(models, gateway);
   console.log(pc10.dim("Press Ctrl+C to stop."));
-  writeServerRuntimeState({
-    mode: "endpoint",
-    port: server.port,
-    pid: process.pid,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  if (!noDiscovery) {
+    registerServerRuntimeState({
+      mode: "endpoint",
+      port: server.port,
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
   await waitForShutdown2();
-  removeServerRuntimeState();
+  if (!noDiscovery) unregisterServerRuntimeState();
   await server.close();
   return 0;
 }
@@ -10527,6 +10551,14 @@ const MODEL_CONFIG = {};
 // ---- derive helpers --------------------------------------------------------
 // alias -> model id (only for entries that define an alias)
 const ALIAS_TO_ID = {};
+// The name Claude Code knows a model by: its alias when it has one, else its
+// canonical id. This single value is used for the Agent-tool enum, the
+// known-alias validator, the /model picker value, and the context-window table,
+// so the name the binary validates == the name it sends upstream == the name
+// the proxy echoes back == the key its context window is stored under.
+const IDENTITIES = [];
+// identity -> human label for the /model picker (falls back at use site)
+const DISPLAY_BY_IDENTITY = {};
 // lowercased alias AND id -> context-window tokens (only for models that set it)
 const CONTEXT_BY_KEY = {};
 for (const [id, value] of Object.entries(MODEL_CONFIG)) {
@@ -10537,6 +10569,11 @@ for (const [id, value] of Object.entries(MODEL_CONFIG)) {
       throw new Error('clodex patch: alias "' + spec.alias + '" is not a safe lowercase alias');
     }
     ALIAS_TO_ID[a] = String(id);
+    IDENTITIES.push(a);
+    if (spec.display) DISPLAY_BY_IDENTITY[a] = String(spec.display);
+  } else {
+    IDENTITIES.push(String(id));
+    if (spec.display) DISPLAY_BY_IDENTITY[String(id)] = String(spec.display);
   }
 
   if (spec.context !== undefined) {
@@ -10560,6 +10597,11 @@ const ALIASES = Object.keys(ALIAS_TO_ID);
 const MODELS = Object.keys(MODEL_CONFIG);
 if (MODELS.length === 0) throw new Error("clodex patch: MODEL_CONFIG is empty");
 
+/** Picker/description label for an identity; falls back to the old wording. */
+function displayFor(identity, fallbackId) {
+  return DISPLAY_BY_IDENTITY[identity] || "Custom model (" + fallbackId + ")";
+}
+
 const reEsc = (s) => s.replace(/[.*+?^$\{\}()|[\]\\]/g, "\\$&");
 const q = (s) => JSON.stringify(s); // safe JS string literal
 
@@ -10608,22 +10650,24 @@ function applyOnce(name, regex, fn, { marker, required, noopIsSkip } = {}) {
   log("OK", name);
 }
 
-/** Insert missing ids just before the closing bracket of a JS array literal string. */
+/** Insert missing identities just before the closing bracket of a JS array literal string. */
 function extendAliasArray(arrLiteral) {
-  const toAdd = MODELS.filter((a) => !new RegExp('"' + reEsc(a) + '"').test(arrLiteral));
+  const toAdd = IDENTITIES.filter((a) => !new RegExp('"' + reEsc(a) + '"').test(arrLiteral));
   if (toAdd.length === 0) return arrLiteral; // idempotent
   return arrLiteral.replace(/\]\s*$/, "," + toAdd.map(q).join(",") + "]");
 }
 
-console.error("clodex patch: injecting models [" + MODELS.join(", ") + "]"
-  + (ALIASES.length ? " aliases [" + ALIASES.join(", ") + "]" : ""));
+console.error("clodex patch: injecting model names [" + IDENTITIES.join(", ") + "]");
 
 // ---------------------------------------------------------------------------
 // PATCH 1 — Agent/subagent tool 'model' zod enum.
 // Anchor: .enum([ "sonnet",...,"fable" ]).optional().describe( — the array
 // begins with the built-in aliases and is immediately followed by
-// .optional().describe(. We append our ids inside the enum so the tool
-// accepts them. (This same .describe( is patched by PATCH 4 below.)
+// .optional().describe(. We append our identities (alias when defined, else
+// the canonical id) inside the enum so the tool accepts them — this is the same
+// enum subagent/skill 'model:' frontmatter is validated against, which is why
+// the short alias has to be the value that lands here.
+// (This same .describe( is patched by PATCH 4 below.)
 // ---------------------------------------------------------------------------
 applyOnce(
   "PATCH 1: Agent tool model enum",
@@ -10636,7 +10680,7 @@ applyOnce(
 // PATCH 3 — known-alias validator list (drives "is this a known alias?").
 // Anchor: the master list literal, matched loosely as
 // ["sonnet","opus","haiku","fable", ...anything... ,"opusplan"] so it
-// tolerates new built-ins being added in the middle. Appending our ids
+// tolerates new built-ins being added in the middle. Appending our identities
 // makes them recognized as first-class aliases everywhere the gate runs.
 // ---------------------------------------------------------------------------
 applyOnce(
@@ -10647,16 +10691,26 @@ applyOnce(
 );
 
 // ---------------------------------------------------------------------------
-// PATCH 6 — alias -> model-id resolver switch.
+// PATCH 6 — alias resolver switch (IDENTITY mapping).
 // Anchor: case"best":{ ... } (the case"best":{ is unique). We inject
-// case"<alias>":return"<model-id>"; right after it (before the switch's
-// default:return null) so each alias resolves to its concrete model id.
+// case"<alias>":return"<alias>"; right after it (before the switch's
+// default:return null).
+//
+// The mapping is deliberately an identity, NOT alias -> canonical id: the alias
+// IS the model's identity everywhere else in the patched binary (enum,
+// validator, picker, context table), and the MITM proxy resolves short alias
+// names as request model ids and echoes request bodies unrewritten. Resolving
+// to the canonical id here would make Claude Code send one name and look its
+// context window up under another — the exact mismatch that stopped auto-compact
+// from firing and killed agents with "Prompt is too long". The case still has to
+// EXIST (rather than be skipped) so the resolver returns the name instead of
+// falling through to default:return null.
 // Only aliases not already present are inserted, so a rerun (or a config
 // edit) tops up cleanly rather than duplicating cases.
 // ---------------------------------------------------------------------------
 {
   const missing = ALIASES.filter((a) => !new RegExp("case" + reEsc(q(a)) + ":return").test(js));
-  const cases = missing.map((a) => "case" + q(a) + ":return " + q(ALIAS_TO_ID[a]) + ";").join("");
+  const cases = missing.map((a) => "case" + q(a) + ":return " + q(a) + ";").join("");
   if (ALIASES.length === 0) {
     log("SKIP", "PATCH 6: alias resolver switch", "no aliases configured");
   } else {
@@ -10683,7 +10737,9 @@ applyOnce(
     .map(
       // ASCII only: tweakcc's script->JSON->repack path double-encodes any
       // non-ASCII byte.
-      (a) => "{value:" + q(a) + ",label:" + q(a.charAt(0).toUpperCase() + a.slice(1)) + ",description:" + q("Custom model (" + ALIAS_TO_ID[a] + ")") + "}"
+      // value = the alias (the name the user types and the binary sends);
+      // description = the real model label, e.g. "GPT-5.6 Sol (OpenAI (ChatGPT))".
+      (a) => "{value:" + q(a) + ",label:" + q(a.charAt(0).toUpperCase() + a.slice(1)) + ",description:" + q(displayFor(a, ALIAS_TO_ID[a])) + "}"
     )
     .join(",");
   const inject = missing.length
@@ -10703,18 +10759,24 @@ applyOnce(
 
 // ---------------------------------------------------------------------------
 // PATCH 4 — Agent tool 'model' parameter description text.
-// Append the available model names before the closing backtick so the model
-// knows the aliases exist and can request them. Best-effort (cosmetic).
+// Append the available model names (with their real labels) before the closing
+// backtick so the model knows which extra names it may request and what they
+// actually are. Best-effort (cosmetic). The text is spliced into a backtick
+// template literal, so backticks and interpolation openers are stripped.
 // ---------------------------------------------------------------------------
 {
-  const listing = MODELS.join(", ");
+  const safe = (s) => String(s).replace(/\`/g, "'").replace(/\$\{/g, "(");
+  const listing = IDENTITIES.map(function (i) {
+    const d = DISPLAY_BY_IDENTITY[i];
+    return d ? safe(i) + " = " + safe(d) : safe(i);
+  }).join("; ");
   applyOnce(
     "PATCH 4: Agent tool model description",
     /(describe\(\`Optional model override for this agent[^\`]*?)(\`\))/,
     (_m, body, close) =>
-      body.includes("custom aliases")
+      body.includes("Additional custom models")
         ? body + close
-        : body + " Additional custom aliases: " + listing + "." + close,
+        : body + " Additional custom models: " + listing + "." + close,
     { required: false, noopIsSkip: true }
   );
 }
@@ -10800,28 +10862,30 @@ function writePatchManifest(manifest, path = getPatchManifestPath()) {
   writeFileSync5(path, `${JSON.stringify(manifest, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
-function buildPatchModelConfig(favorites, aliases, contextWindowFor) {
+function buildPatchModelConfig(favorites, aliases, modelMetaFor) {
   const config = {};
   const unknownWindows = [];
   const aliasByFavorite = new Map(aliases.map((a) => [`${a.providerId}:${a.modelId}`, a.name]));
   for (const favorite of favorites) {
     const id = stripOneMContextSuffix(httpProxyModelId(favorite.providerId, favorite.modelId));
     if (config[id]) continue;
-    const context = contextWindowFor(favorite.providerId, favorite.modelId);
+    const meta = modelMetaFor(favorite.providerId, favorite.modelId);
+    const context = meta?.contextWindow;
     const alias = aliasByFavorite.get(`${favorite.providerId}:${favorite.modelId}`);
-    if (context === void 0 || context <= 0 || context === 2e5) {
-      if (context === void 0 || context <= 0) unknownWindows.push(id);
-      config[id] = alias ? { alias } : {};
-    } else {
-      config[id] = alias ? { alias, context } : { context };
-    }
+    const entry = {};
+    if (alias) entry.alias = alias;
+    if (context === void 0 || context <= 0) unknownWindows.push(id);
+    else if (context !== 2e5) entry.context = context;
+    const display = meta?.displayName?.trim();
+    if (display) entry.display = display;
+    config[id] = entry;
   }
   return { config, unknownWindows };
 }
 function computePatchConfigHash(config) {
   const canonical = Object.keys(config).sort().map((key) => {
     const entry = config[key];
-    return [key, entry.alias ?? null, entry.context ?? null];
+    return [key, entry.alias ?? null, entry.context ?? null, entry.display ?? null];
   });
   return createHash5("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
@@ -10830,18 +10894,20 @@ function buildDesiredPatchConfig() {
   const favorites = prefs.favoriteModels ?? [];
   const aliases = prefs.modelAliases ?? [];
   const registry = loadRegistry();
-  const windows = /* @__PURE__ */ new Map();
+  const meta = /* @__PURE__ */ new Map();
   for (const provider of registry.providers) {
     for (const model of provider.modelsCache?.models ?? []) {
-      if (model.contextWindow && model.contextWindow > 0) {
-        windows.set(`${provider.id}:${model.id}`, model.contextWindow);
-      }
+      meta.set(`${provider.id}:${model.id}`, {
+        contextWindow: model.contextWindow && model.contextWindow > 0 ? model.contextWindow : void 0,
+        // Same label `clodex server` prints at startup and `models --list` shows.
+        displayName: httpProxyDisplayName(model, provider.name)
+      });
     }
   }
   return buildPatchModelConfig(
     favorites,
     aliases,
-    (providerId, modelId) => windows.get(`${providerId}:${modelId}`)
+    (providerId, modelId) => meta.get(`${providerId}:${modelId}`)
   );
 }
 function evaluatePatchState(manifest, current) {
@@ -11206,6 +11272,7 @@ function parseArgs(args) {
       else if (consumeBridgeModeFlag(arg, parsed2)) continue;
       else if (arg === "--save-mode") parsed2.saveBridgeMode = true;
       else if (arg === "--ws-diagnostics") parsed2.serverWsDiagnostics = true;
+      else if (arg === "--no-discovery") parsed2.serverNoDiscovery = true;
       else if (arg === "--quick" || arg === "--saved") parsed2.serverQuick = true;
       else if (arg === "--mask-gateway-ids") parsed2.serverMaskGatewayIds = true;
       else if (arg === "--no-mask-gateway-ids") parsed2.serverMaskGatewayIds = false;
@@ -11438,6 +11505,10 @@ ${pc13.bold("Common options (both modes):")}
   --save-mode                  With --endpoint/--proxy: save that mode as the
                                server default
   --port <1-65535>             Listen port (default 17645)
+  --no-discovery               Do not advertise this server in
+                               ~/.clodex/server-runtime.json, so the
+                               clodex-claude wrapper never bridges to it
+                               (CLODEX_NO_DISCOVERY=1 works too)
   --ws-diagnostics             Log sanitized request envelopes and WebSocket
                                head decisions
   --help, --version            Help / version
@@ -12272,7 +12343,8 @@ Error: ${parsed.error}
       maskGatewayIds: parsed.serverMaskGatewayIds,
       password: parsed.serverPassword,
       wsDiagnostics: parsed.serverWsDiagnostics,
-      port: parsed.serverPort
+      port: parsed.serverPort,
+      noDiscovery: parsed.serverNoDiscovery
     });
   }
   if (parsed.command === "models") {