@bman654/clodex 2.12.1 → 2.13.0

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.12.1",
+  version: "2.13.0",
   publishConfig: {
     access: "public"
   },
@@ -3895,8 +3895,8 @@ import {
   statSync as statSync8,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync6,
-  openSync as openSync7,
-  closeSync as closeSync7,
+  openSync as openSync8,
+  closeSync as closeSync8,
   realpathSync as realpathSync2
 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -4821,16 +4821,19 @@ var pricing_cache_default = {
   ]
 };
 
+// src/data/opencode-go-models.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
 // src/data/opencode-go-models.json
 var opencode_go_models_default = [
   {
     id: "deepseek-v4-flash",
-    name: "DeepSeek V4 Flash (2x usage)",
+    name: "DeepSeek V4 Flash",
     contextWindow: 1e6,
     cost: {
-      input: 0.07,
-      output: 0.14,
-      cache_read: 14e-4
+      input: 0.15,
+      output: 0.6,
+      cache_read: 3e-3
     },
     modelFormat: "openai",
     npm: "@ai-sdk/openai-compatible",
@@ -4858,12 +4861,12 @@ var opencode_go_models_default = [
   },
   {
     id: "deepseek-v4-pro",
-    name: "DeepSeek V4 Pro",
+    name: "DeepSeek V4 Pro (New)",
     contextWindow: 1e6,
     cost: {
-      input: 0.435,
-      output: 0.87,
-      cache_read: 3625e-6
+      input: 0.66,
+      output: 1.98,
+      cache_read: 0.022
     },
     modelFormat: "openai",
     npm: "@ai-sdk/openai-compatible",
@@ -4889,6 +4892,30 @@ var opencode_go_models_default = [
     upstreamModelId: "deepseek-v4-pro",
     family: "deepseek"
   },
+  {
+    id: "deepseek-v4.1-flash",
+    name: "DeepSeek V4.1 Flash",
+    contextWindow: 1e6,
+    cost: {
+      input: 0.15,
+      output: 0.6,
+      cache_read: 3e-3
+    },
+    modelFormat: "anthropic",
+    npm: "@ai-sdk/anthropic",
+    apiUrl: "https://opencode.ai/zen/go",
+    reasoning: true,
+    modalities: [
+      "text",
+      "image"
+    ],
+    compatibility: {
+      supportsCountTokens: false,
+      supportsReasoningEffort: false
+    },
+    upstreamModelId: "deepseek-v4.1-flash",
+    family: "deepseek"
+  },
   {
     id: "glm-5.1",
     name: "GLM-5.1",
@@ -4906,10 +4933,10 @@ var opencode_go_models_default = [
       "text"
     ],
     compatibility: {
+      supportsReasoningEffort: false,
       supportsStore: false,
       supportsDeveloperRole: false,
-      maxTokensField: "max_tokens",
-      supportsReasoningEffort: false
+      maxTokensField: "max_tokens"
     },
     upstreamModelId: "glm-5.1",
     family: "glm"
@@ -4949,13 +4976,13 @@ var opencode_go_models_default = [
   },
   {
     id: "gpt-5.6-luna",
-    name: "GPT-5.6 Luna (2x usage)",
+    name: "GPT-5.6 Luna",
     contextWindow: 105e4,
     cost: {
-      input: 0.1,
-      output: 0.6,
-      cache_read: 0.01,
-      cache_write: 0.125
+      input: 0.2,
+      output: 1.2,
+      cache_read: 0.02,
+      cache_write: 0.25
     },
     modelFormat: "openai",
     npm: "@ai-sdk/openai-compatible",
@@ -4965,8 +4992,6 @@ var opencode_go_models_default = [
       "text",
       "image"
     ],
-    upstreamModelId: "gpt-5.6-luna",
-    family: "gpt",
     compatibility: {
       reasoningEffortMap: {
         off: "none",
@@ -4980,7 +5005,9 @@ var opencode_go_models_default = [
       supportsStore: false,
       supportsDeveloperRole: false,
       maxTokensField: "max_tokens"
-    }
+    },
+    upstreamModelId: "gpt-5.6-luna",
+    family: "gpt"
   },
   {
     id: "hy3",
@@ -5066,10 +5093,10 @@ var opencode_go_models_default = [
       "image"
     ],
     compatibility: {
+      supportsReasoningEffort: false,
       supportsStore: false,
       supportsDeveloperRole: false,
-      maxTokensField: "max_tokens",
-      supportsReasoningEffort: false
+      maxTokensField: "max_tokens"
     },
     upstreamModelId: "kimi-k2.7-code",
     family: "kimi"
@@ -5126,10 +5153,10 @@ var opencode_go_models_default = [
       "image"
     ],
     compatibility: {
+      supportsReasoningEffort: false,
       supportsStore: false,
       supportsDeveloperRole: false,
-      maxTokensField: "max_tokens",
-      supportsReasoningEffort: false
+      maxTokensField: "max_tokens"
     },
     upstreamModelId: "mimo-v2.5",
     family: "mimo"
@@ -5151,10 +5178,10 @@ var opencode_go_models_default = [
       "text"
     ],
     compatibility: {
+      supportsReasoningEffort: false,
       supportsStore: false,
       supportsDeveloperRole: false,
-      maxTokensField: "max_tokens",
-      supportsReasoningEffort: false
+      maxTokensField: "max_tokens"
     },
     upstreamModelId: "mimo-v2.5-pro",
     family: "mimo"
@@ -5176,10 +5203,10 @@ var opencode_go_models_default = [
       "text"
     ],
     compatibility: {
+      supportsReasoningEffort: false,
       supportsStore: false,
       supportsDeveloperRole: false,
-      maxTokensField: "max_tokens",
-      supportsReasoningEffort: false
+      maxTokensField: "max_tokens"
     },
     upstreamModelId: "minimax-m2.7",
     family: "minimax"
@@ -5201,12 +5228,12 @@ var opencode_go_models_default = [
       "text",
       "image"
     ],
-    upstreamModelId: "minimax-m3",
-    family: "minimax",
     compatibility: {
       supportsCountTokens: false,
       supportsReasoningEffort: false
-    }
+    },
+    upstreamModelId: "minimax-m3",
+    family: "minimax"
   },
   {
     id: "qwen3.6-plus",
@@ -5227,10 +5254,6 @@ var opencode_go_models_default = [
       "image"
     ],
     compatibility: {
-      supportsStore: false,
-      supportsDeveloperRole: false,
-      thinkingFormat: "qwen",
-      maxTokensField: "max_tokens",
       reasoningEffortMap: {
         low: "low",
         medium: "medium",
@@ -5239,7 +5262,11 @@ var opencode_go_models_default = [
         max: "max",
         minimal: null,
         off: null
-      }
+      },
+      supportsStore: false,
+      supportsDeveloperRole: false,
+      thinkingFormat: "qwen",
+      maxTokensField: "max_tokens"
     },
     upstreamModelId: "qwen3.6-plus",
     family: "qwen3.6"
@@ -5261,12 +5288,12 @@ var opencode_go_models_default = [
     modalities: [
       "text"
     ],
-    upstreamModelId: "qwen3.7-max",
-    family: "qwen3.7",
     compatibility: {
       supportsCountTokens: false,
       supportsReasoningEffort: false
-    }
+    },
+    upstreamModelId: "qwen3.7-max",
+    family: "qwen3.7"
   },
   {
     id: "qwen3.7-plus",
@@ -5286,12 +5313,12 @@ var opencode_go_models_default = [
       "text",
       "image"
     ],
-    upstreamModelId: "qwen3.7-plus",
-    family: "qwen3.7",
     compatibility: {
       supportsCountTokens: false,
       supportsReasoningEffort: false
-    }
+    },
+    upstreamModelId: "qwen3.7-plus",
+    family: "qwen3.7"
   },
   {
     id: "qwen3.8-max",
@@ -5311,12 +5338,12 @@ var opencode_go_models_default = [
       "text",
       "image"
     ],
-    upstreamModelId: "qwen3.8-max",
-    family: "qwen3.8",
     compatibility: {
       supportsCountTokens: false,
       supportsReasoningEffort: false
-    }
+    },
+    upstreamModelId: "qwen3.8-max",
+    family: "qwen3.8"
   }
 ];
 
@@ -5328,6 +5355,13 @@ var OPENCODE_GO_ANTHROPIC_BASE_URL = "https://opencode.ai/zen/go";
 function buildOpenCodeGoModels() {
   return structuredClone(opencode_go_models_default);
 }
+var OPENCODE_GO_FALLBACK_SESSION_ID = randomUUID2();
+function openCodeGoSessionHeaders(model, claudeSessionId) {
+  const url = String(model.apiBaseUrl ?? model.baseUrl ?? model.apiUrl ?? "");
+  const isGo = model.providerId === OPENCODE_GO_PROVIDER_ID || /^https:\/\/opencode\.ai\/zen\/go(\/|$)/.test(url);
+  if (!isGo) return void 0;
+  return { "x-opencode-session": claudeSessionId ?? OPENCODE_GO_FALLBACK_SESSION_ID };
+}
 
 // src/provider-templates.ts
 async function verifyOpenCodeGoCredential(apiKey) {
@@ -5338,7 +5372,12 @@ async function verifyOpenCodeGoCredential(apiKey) {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+        Authorization: `Bearer ${apiKey}`,
+        // Go answers `MissingSessionID` to any request without a session header,
+        // and whether it validates the key BEFORE that check is not something we
+        // have observed. Sending the header removes the question: the probe then
+        // cannot mistake a missing-session rejection for a verdict on the key.
+        ...openCodeGoSessionHeaders({ providerId: OPENCODE_GO_PROVIDER_ID }, void 0)
       },
       body: JSON.stringify({ model: model.upstreamModelId ?? model.id }),
       // This is the FIRST thing a user hits after pasting a key, and it runs
@@ -8081,6 +8120,8 @@ import { wrapLanguageModel, extractReasoningMiddleware } from "ai";
 
 // src/oauth/responses-websocket.ts
 import { createHash as createHash6 } from "crypto";
+import { closeSync as closeSync6, openSync as openSync6 } from "fs";
+import { devNull } from "os";
 import { AsyncLocalStorage } from "async_hooks";
 
 // src/outbound-proxy.ts
@@ -8847,8 +8888,8 @@ var FAILURE_EVENT_TYPES = /* @__PURE__ */ new Set(["error", "response.failed", "
 var RESPONSES_WS_HARD_TTL_MS = 55 * 6e4;
 var RESPONSES_WS_IDLE_TTL_MS = 30 * 6e4;
 var RESPONSES_WS_NURSERY_IDLE_TTL_MS = 5 * 6e4;
-var RESPONSES_WS_MAX_CONNECTIONS = 64;
-var RESPONSES_WS_MAX_NURSERY_CONNECTIONS = 48;
+var RESPONSES_WS_MAX_CONNECTIONS = Number.POSITIVE_INFINITY;
+var RESPONSES_WS_MAX_NURSERY_CONNECTIONS = Number.POSITIVE_INFINITY;
 var diagnosticContext = new AsyncLocalStorage();
 function withResponsesWebSocketDiagnosticContext(context, fn) {
   return diagnosticContext.run(context, fn);
@@ -8998,16 +9039,64 @@ function responsesWebSocketPartitionKey(wsUrl, payload, options = {}, authorizat
 function inputArray(payload) {
   return Array.isArray(payload.input) ? payload.input : [];
 }
-function normalizeToolCallJson(value) {
-  if (Array.isArray(value)) return value.map(normalizeToolCallJson);
+function toolSchemaDefaults(payload) {
+  const defaults = /* @__PURE__ */ new Map();
+  const add = (tool3) => {
+    if (!tool3 || typeof tool3 !== "object") return;
+    const record = tool3;
+    if (record.type === "namespace" && Array.isArray(record.tools)) {
+      for (const nested of record.tools) add(nested);
+      return;
+    }
+    if (record.type !== "function" || typeof record.name !== "string") return;
+    const parameters = record.parameters;
+    const properties = parameters && typeof parameters === "object" ? parameters.properties : void 0;
+    if (!properties || typeof properties !== "object") return;
+    const perTool = /* @__PURE__ */ new Map();
+    for (const [prop, schema] of Object.entries(properties)) {
+      if (schema && typeof schema === "object" && "default" in schema) {
+        perTool.set(prop, canonicalJson(schema.default));
+      }
+    }
+    if (perTool.size) defaults.set(record.name, perTool);
+  };
+  if (Array.isArray(payload.tools)) for (const tool3 of payload.tools) add(tool3);
+  return defaults;
+}
+function toolSchemaDefaultsFingerprint(defaults) {
+  if (!defaults.size) return "none";
+  const tuples = [...defaults.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, perTool]) => [
+    name,
+    [...perTool.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+  ]);
+  return createHash6("sha256").update(JSON.stringify(tuples)).digest("hex").slice(0, 16);
+}
+function stripSchemaDefaults(name, args, defaults) {
+  if (!defaults) return args;
+  if (typeof name !== "string" || !args || typeof args !== "object" || Array.isArray(args)) return args;
+  const perTool = defaults.get(name);
+  if (!perTool) return args;
+  const out = {};
+  for (const [key, value] of Object.entries(args)) {
+    const expected = perTool.get(key);
+    if (expected !== void 0 && canonicalJson(value) === expected) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function normalizeToolCallJson(value, defaults) {
+  if (Array.isArray(value)) return value.map((item) => normalizeToolCallJson(item, defaults));
   if (!value || typeof value !== "object") return value;
   const record = value;
   const out = {};
-  for (const [key, child] of Object.entries(record)) out[key] = normalizeToolCallJson(child);
+  for (const [key, child] of Object.entries(record)) out[key] = normalizeToolCallJson(child, defaults);
   const jsonField = record.type === "function_call" ? "arguments" : record.type === "custom_tool_call" ? "input" : void 0;
   if (jsonField && typeof record[jsonField] === "string") {
     try {
-      out[jsonField] = canonicalJson(JSON.parse(record[jsonField]));
+      const parsed = JSON.parse(record[jsonField]);
+      out[jsonField] = canonicalJson(
+        jsonField === "arguments" ? stripSchemaDefaults(record.name, parsed, defaults) : parsed
+      );
     } catch {
     }
   }
@@ -9018,8 +9107,8 @@ function normalizeToolCallJson(value) {
   }
   return out;
 }
-function arraysEqual(left, right) {
-  return canonicalJson(normalizeToolCallJson(left)) === canonicalJson(normalizeToolCallJson(right));
+function arraysEqual(left, right, defaults) {
+  return canonicalJson(normalizeToolCallJson(left, defaults)) === canonicalJson(normalizeToolCallJson(right, defaults));
 }
 function conversationItemKind(value) {
   if (!value || typeof value !== "object") return typeof value;
@@ -9028,17 +9117,17 @@ function conversationItemKind(value) {
   if (typeof record.role === "string") return record.role;
   return "object";
 }
-function conversationItemHash(value) {
-  return createHash6("sha256").update(canonicalJson(normalizeToolCallJson(value))).digest("hex").slice(0, 16);
+function conversationItemHash(value, defaults) {
+  return createHash6("sha256").update(canonicalJson(normalizeToolCallJson(value, defaults))).digest("hex").slice(0, 16);
 }
-function reasoningNormalizationGap(expected, actual) {
+function reasoningNormalizationGap(expected, actual, defaults) {
   if (conversationItemKind(expected) !== "reasoning" || conversationItemKind(actual) !== "reasoning") return void 0;
   const left = expected;
   const right = actual;
   const blob = left.encrypted_content;
   if (typeof blob !== "string" || !blob || blob !== right.encrypted_content) return void 0;
-  const normalizedLeft = normalizeToolCallJson(left);
-  const normalizedRight = normalizeToolCallJson(right);
+  const normalizedLeft = normalizeToolCallJson(left, defaults);
+  const normalizedRight = normalizeToolCallJson(right, defaults);
   const fields = [.../* @__PURE__ */ new Set([...Object.keys(normalizedLeft), ...Object.keys(normalizedRight)])].sort().filter((key) => canonicalJson(normalizedLeft[key]) !== canonicalJson(normalizedRight[key]));
   return fields.length ? fields : void 0;
 }
@@ -9086,7 +9175,7 @@ function warnReasoningNormalizationGap(fields, log12) {
     emitParentNotice("clodex: warning: further reasoning-normalization warnings suppressed.");
   }
 }
-function toolArgumentNormalizationGap(expected, actual, requiredProps) {
+function toolArgumentNormalizationGap(expected, actual, defaults, requiredProps) {
   if (conversationItemKind(expected) !== "function_call") return void 0;
   if (conversationItemKind(actual) !== "function_call") return void 0;
   const left = expected;
@@ -9094,7 +9183,7 @@ function toolArgumentNormalizationGap(expected, actual, requiredProps) {
   const callId = left.call_id;
   if (typeof callId !== "string" || !callId || callId !== right.call_id) return void 0;
   if (typeof left.name !== "string" || left.name !== right.name) return void 0;
-  if (canonicalJson(normalizeToolCallJson(left)) === canonicalJson(normalizeToolCallJson(right))) {
+  if (canonicalJson(normalizeToolCallJson(left, defaults)) === canonicalJson(normalizeToolCallJson(right, defaults))) {
     return void 0;
   }
   const required = requiredProps().get(left.name);
@@ -9105,8 +9194,8 @@ function toolArgumentNormalizationGap(expected, actual, requiredProps) {
       const parsed = raw === "" ? {} : JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
       return canonicalJson({
-        ...normalizeToolCallJson(item),
-        arguments: canonicalJson(sanitizeToolInput(parsed, required))
+        ...normalizeToolCallJson(item, defaults),
+        arguments: canonicalJson(stripSchemaDefaults(item.name, sanitizeToolInput(parsed, required), defaults))
       });
     } catch {
       return void 0;
@@ -9137,7 +9226,7 @@ function warnToolArgumentNormalizationGap(gap, log12) {
     emitParentNotice("clodex: warning: further tool-argument normalization warnings suppressed.");
   }
 }
-function continuationMismatchDetails(entry, payload, log12, warnOnGap = false, deferWarnings) {
+function continuationMismatchDetails(entry, payload, defaults, log12, warnOnGap = false, deferWarnings) {
   const raise = (warn) => {
     if (deferWarnings) deferWarnings.push(warn);
     else warn();
@@ -9147,14 +9236,14 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false, d
   const comparable = Math.min(full.length, prefix.length);
   let mismatch = comparable;
   for (let index = 0; index < comparable; index += 1) {
-    if (!arraysEqual([full[index]], [prefix[index]])) {
+    if (!arraysEqual([full[index]], [prefix[index]], defaults)) {
       mismatch = index;
       break;
     }
   }
   const expected = mismatch < prefix.length ? prefix[mismatch] : void 0;
   const actual = mismatch < full.length ? full[mismatch] : void 0;
-  const reasoningGap = reasoningNormalizationGap(expected, actual);
+  const reasoningGap = reasoningNormalizationGap(expected, actual, defaults);
   if (reasoningGap && warnOnGap) raise(() => warnReasoningNormalizationGap(reasoningGap, log12));
   let gapExpected = expected;
   if (conversationItemKind(expected) === "reasoning" && conversationItemKind(actual) === "function_call") {
@@ -9170,6 +9259,7 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false, d
     toolArgumentGap = toolArgumentNormalizationGap(
       gapExpected,
       actual,
+      defaults,
       // The head's own schema when it has one; the current turn's tools are only a
       // fallback for a head that predates the snapshot (see headRequiredToolProps).
       () => entry.headRequiredToolProps ?? requiredToolProps(payload)
@@ -9191,8 +9281,8 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false, d
     firstMismatch: mismatch,
     expectedKind: expected === void 0 ? "none" : conversationItemKind(expected),
     actualKind: actual === void 0 ? "none" : conversationItemKind(actual),
-    ...expected !== void 0 ? { expectedHash: conversationItemHash(expected) } : {},
-    ...actual !== void 0 ? { actualHash: conversationItemHash(actual) } : {},
+    ...expected !== void 0 ? { expectedHash: conversationItemHash(expected, defaults) } : {},
+    ...actual !== void 0 ? { actualHash: conversationItemHash(actual, defaults) } : {},
     ...reasoningGap ? {
       reasoningNormalizationGap: reasoningGap,
       reasoningGapShape: reasoningGapShape(
@@ -9206,8 +9296,8 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false, d
     ...toolArgumentGap ? { toolArgumentNormalizationGap: toolArgumentGap } : {}
   };
 }
-function continuationMismatchSummary(entry, payload, log12, mismatchDump = false, precomputedDetails) {
-  const details = precomputedDetails ?? continuationMismatchDetails(entry, payload, log12, true);
+function continuationMismatchSummary(entry, payload, defaults, log12, mismatchDump = false, precomputedDetails) {
+  const details = precomputedDetails ?? continuationMismatchDetails(entry, payload, defaults, log12, true);
   let summary = `full_items=${details.fullItems} expected_prefix_items=${details.expectedPrefixItems} first_mismatch=${details.firstMismatch} expected=${details.expectedKind} actual=${details.actualKind}`;
   if (details.expectedHash || details.actualHash) {
     summary += ` expected_hash=${details.expectedHash ?? "none"} actual_hash=${details.actualHash ?? "none"}`;
@@ -9215,21 +9305,21 @@ function continuationMismatchSummary(entry, payload, log12, mismatchDump = false
       const full = inputArray(payload);
       const prefix = [...entry.requestInput ?? [], ...entry.expectedAssistant ?? []];
       const index = details.firstMismatch;
-      log12(`mismatch dump expected[${index}]: ${mismatchDumpLine(prefix, index)}`);
-      log12(`mismatch dump actual[${index}]: ${mismatchDumpLine(full, index)}`);
+      log12(`mismatch dump expected[${index}]: ${mismatchDumpLine(prefix, index, defaults)}`);
+      log12(`mismatch dump actual[${index}]: ${mismatchDumpLine(full, index, defaults)}`);
     }
   }
   return summary;
 }
-function mismatchDumpLine(items, index) {
+function mismatchDumpLine(items, index, defaults) {
   if (index >= items.length) return "(absent)";
-  const line = canonicalJson(normalizeToolCallJson(items[index]));
+  const line = canonicalJson(normalizeToolCallJson(items[index], defaults));
   const max = 2e3;
   const marker = " [truncated]";
   return line.length <= max ? line : line.slice(0, max - marker.length) + marker;
 }
-function canonicalItemStrings(items) {
-  return items.map((item) => canonicalJson(normalizeToolCallJson([item])));
+function canonicalItemStrings(items, defaults) {
+  return items.map((item) => canonicalJson(normalizeToolCallJson([item], defaults)));
 }
 function isPrefixOrEqual(head, client) {
   if (client.length < head.length) return false;
@@ -9241,16 +9331,24 @@ function isPrefixOrEqual(head, client) {
 function isStrictPrefix(head, client) {
   return client.length > head.length && isPrefixOrEqual(head, client);
 }
-function continuationMatch(entry, payload, clientItems) {
+function continuationMatch(entry, payload, clientItems, defaults, defaultsId) {
   if (!entry.responseId || !entry.requestInput || !entry.expectedAssistant) return void 0;
   const full = inputArray(payload);
-  entry.canonicalPrefix ??= canonicalItemStrings([...entry.requestInput, ...entry.expectedAssistant]);
+  if (entry.canonicalToolDefaultsId !== defaultsId) {
+    entry.canonicalPrefix = void 0;
+    entry.canonicalEchoablePrefix = void 0;
+    entry.canonicalToolDefaultsId = defaultsId;
+  }
+  entry.canonicalPrefix ??= canonicalItemStrings(
+    [...entry.requestInput, ...entry.expectedAssistant],
+    defaults
+  );
   if (isStrictPrefix(entry.canonicalPrefix, clientItems)) {
     return { delta: full.slice(entry.canonicalPrefix.length), mode: "exact" };
   }
   const echoedAssistant = entry.expectedAssistant.filter((item) => conversationItemKind(item) !== "reasoning");
   if (echoedAssistant.length === entry.expectedAssistant.length) return void 0;
-  entry.canonicalEchoablePrefix ??= canonicalItemStrings([...entry.requestInput, ...echoedAssistant]);
+  entry.canonicalEchoablePrefix ??= canonicalItemStrings([...entry.requestInput, ...echoedAssistant], defaults);
   if (!isStrictPrefix(entry.canonicalEchoablePrefix, clientItems)) return void 0;
   return { delta: full.slice(entry.canonicalEchoablePrefix.length), mode: "omitted_reasoning" };
 }
@@ -9749,6 +9847,64 @@ function evictOldestIdleGeneration(generation, maxConnections, reason) {
   }
   return evictions;
 }
+var DESCRIPTOR_EXHAUSTION_CODES = /* @__PURE__ */ new Set(["EMFILE", "ENFILE"]);
+function isDescriptorExhaustion(code) {
+  return typeof code === "string" && DESCRIPTOR_EXHAUSTION_CODES.has(code);
+}
+function descriptorExhaustionCode(error) {
+  const code = error.code;
+  if (isDescriptorExhaustion(code)) return code;
+  try {
+    closeSync6(openSync6(devNull, "r"));
+    return void 0;
+  } catch (probe) {
+    const probeCode = probe.code;
+    return isDescriptorExhaustion(probeCode) ? probeCode : void 0;
+  }
+}
+var descriptorExhaustionNoticed = false;
+function shedIdleConnectionsForDescriptors(failing, ctx, code, socketErrorCode) {
+  const registered = connectionEntries().filter((entry) => entry !== failing);
+  const idle = registered.filter((entry) => !entry.inFlight && entry.generation !== "isolated").sort((left, right) => left.lastUsedAt - right.lastUsedAt);
+  for (const victim of idle) {
+    const idleMs = Math.max(0, victim.options.now() - victim.lastUsedAt);
+    victim.debug(
+      `shedding idle ${victim.generation} connection after ${code}: connection=${victim.debugId} idle_ms=${idleMs} reason=descriptor_exhaustion`
+    );
+    victim.inFlight = false;
+    victim.current = void 0;
+    unregisterEntry(victim);
+    try {
+      victim.socket.terminate();
+    } catch {
+    }
+  }
+  failing.debug(
+    `${code} opening connection=${failing.debugId}: registered=${registered.length} shed=${idle.length}` + (socketErrorCode && socketErrorCode !== code ? ` reported_as=${socketErrorCode}` : "")
+  );
+  emitContextDiagnostic(failing, ctx, {
+    event: "ws_descriptor_exhaustion",
+    code,
+    detectedBy: socketErrorCode === code ? "error_code" : "descriptor_probe",
+    socketErrorCode: boundedDiagnosticIdentifier(socketErrorCode),
+    heldConnections: registered.length,
+    shedConnections: idle.length
+  });
+  if (descriptorExhaustionNoticed) return;
+  descriptorExhaustionNoticed = true;
+  emitParentNotice(
+    `clodex: warning: ${descriptorLimitName(code)} was reached (${code}) while opening a ChatGPT connection. clodex had ${registered.length} pooled connection(s) registered and closed ${idle.length} idle one(s) to recover; each parallel conversation keeps one open. ${descriptorLimitRemedy(code)} Further open-file warnings suppressed.`
+  );
+}
+function descriptorLimitName(code) {
+  return code === "ENFILE" ? "the system-wide open-file limit" : "this process's open-file limit";
+}
+function descriptorLimitRemedy(code) {
+  return code === "ENFILE" ? "Close other programs holding many files, or raise the system-wide file limit, if this recurs." : "Raise it with `ulimit -n` in the shell that starts clodex (or the service limit for a launchd/systemd-managed server) if this recurs.";
+}
+function descriptorExhaustionMessage(code, registered) {
+  return `${descriptorLimitName(code)} was reached (${code}) while opening a ChatGPT connection with ${registered} pooled connection(s) registered; ${descriptorLimitRemedy(code)}`;
+}
 function isModelDataEvent(type) {
   return Boolean(type && (type.includes(".delta") || type === "response.output_item.added" || type === "response.output_item.done"));
 }
@@ -10081,13 +10237,21 @@ function createConnection(WebSocket, wsUrl, headers, persistent, key, options, d
   socket.on("error", (error) => {
     const ctx = entry.current;
     if (ctx) {
+      const socketErrorCode = error.code;
       const details = {
         source: "socket_error",
         socketErrorName: boundedDiagnosticIdentifier(error.name),
-        socketErrorCode: boundedDiagnosticIdentifier(error.code),
+        socketErrorCode: boundedDiagnosticIdentifier(socketErrorCode),
         ...diagnosticTextFingerprint("errorMessage", error.message)
       };
-      handleTransportFailure(entry, ctx, error.message, details);
+      let message = error.message;
+      const exhaustion = entry.open ? void 0 : descriptorExhaustionCode(error);
+      if (exhaustion) {
+        const registered = connectionEntries().filter((other) => other !== entry).length;
+        message = descriptorExhaustionMessage(exhaustion, registered);
+        shedIdleConnectionsForDescriptors(entry, ctx, exhaustion, socketErrorCode);
+      }
+      handleTransportFailure(entry, ctx, message, details);
     } else deleteEntry(entry);
   });
   socket.on("close", (code, reason) => {
@@ -10108,13 +10272,16 @@ function createConnection(WebSocket, wsUrl, headers, persistent, key, options, d
   });
   return entry;
 }
+function diagnosticCap(cap) {
+  return Number.isFinite(cap) ? cap : null;
+}
 function envConnectionCap(name, log12) {
   const raw = process.env[name];
   if (raw === void 0 || raw.trim() === "") return void 0;
   const value = Number(raw.trim());
-  if (!Number.isInteger(value) || value < 1 || value > 1024) {
+  if (!Number.isInteger(value) || value < 1) {
     try {
-      log12?.(`ws: ignoring ${name}=${raw} (expected an integer between 1 and 1024)`);
+      log12?.(`ws: ignoring ${name}=${raw} (expected a positive integer)`);
     } catch {
     }
     return void 0;
@@ -10159,13 +10326,15 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       authorizationFingerprint,
       claudeAgentId
     );
+    const requestToolDefaults = toolSchemaDefaults(payload);
+    const requestToolDefaultsId = toolSchemaDefaultsFingerprint(requestToolDefaults);
     const promptFingerprint = responsesWebSocketPromptFingerprint(payload);
     const promptFieldHashes = responsesWebSocketPromptFieldHashes(payload);
     const instructionsSnapshot = instructionsFromPayload(payload);
     let now = resolvedOptions.now();
     const evictions = cleanupExpiredConnections(now);
     let canonicalClientItems;
-    const clientItems = () => canonicalClientItems ??= canonicalItemStrings(inputArray(payload));
+    const clientItems = () => canonicalClientItems ??= canonicalItemStrings(inputArray(payload), requestToolDefaults);
     const scanForHeads = () => {
       const scanned = partitionKey ? connectionEntries(partitionKey) : [];
       const idle = scanned.filter((entry) => !entry.inFlight);
@@ -10173,16 +10342,32 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       return {
         candidates: scanned,
         idleCandidates: idle,
-        matches: idle.map((entry) => ({ entry, match: continuationMatch(entry, payload, canonical) })).filter((candidate) => candidate.match !== void 0).sort((left, right) => left.match.delta.length - right.match.delta.length || (left.match.mode === right.match.mode ? 0 : left.match.mode === "exact" ? -1 : 1))
+        matches: idle.map((entry) => ({
+          entry,
+          match: continuationMatch(entry, payload, canonical, requestToolDefaults, requestToolDefaultsId)
+        })).filter((candidate) => candidate.match !== void 0).sort((left, right) => left.match.delta.length - right.match.delta.length || (left.match.mode === right.match.mode ? 0 : left.match.mode === "exact" ? -1 : 1))
       };
     };
     const couldPrecedeThisRequest = (entry) => {
       if (entry.responseId && entry.requestInput && entry.expectedAssistant) {
-        return continuationMatch(entry, payload, clientItems()) !== void 0;
+        return continuationMatch(
+          entry,
+          payload,
+          clientItems(),
+          requestToolDefaults,
+          requestToolDefaultsId
+        ) !== void 0;
       }
       const streaming = entry.current;
       if (!streaming) return true;
-      streaming.canonicalInput ??= canonicalItemStrings(inputArray(streaming.originalPayload));
+      if (streaming.canonicalInputToolDefaultsId !== requestToolDefaultsId) {
+        streaming.canonicalInput = void 0;
+        streaming.canonicalInputToolDefaultsId = requestToolDefaultsId;
+      }
+      streaming.canonicalInput ??= canonicalItemStrings(
+        inputArray(streaming.originalPayload),
+        requestToolDefaults
+      );
       return isPrefixOrEqual(streaming.canonicalInput, clientItems());
     };
     const blockingHead = (entries) => entries.find((entry) => entry.inFlight && couldPrecedeThisRequest(entry));
@@ -10240,6 +10425,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       const diagnosticMismatch = continuationMismatchDetails(
         diagnosticEntry,
         payload,
+        requestToolDefaults,
         debug,
         true,
         deferredMismatchWarnings
@@ -10249,13 +10435,21 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
         if (candidate === diagnosticEntry) continue;
         candidateMismatchDetails.set(
           candidate,
-          continuationMismatchDetails(candidate, payload, debug, true, deferredMismatchWarnings)
+          continuationMismatchDetails(
+            candidate,
+            payload,
+            requestToolDefaults,
+            debug,
+            true,
+            deferredMismatchWarnings
+          )
         );
       }
       debug(
         `history mismatch starting an additional chain; retained ${candidates.length} existing head(s) (${continuationMismatchSummary(
           diagnosticEntry,
           payload,
+          requestToolDefaults,
           debug,
           mismatchDump,
           diagnosticMismatch
@@ -10379,7 +10573,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       input: {
         count: requestInput.length,
         kinds: requestInput.map(conversationItemKind),
-        hashes: requestInput.map(conversationItemHash)
+        hashes: requestInput.map((item) => conversationItemHash(item, requestToolDefaults))
       },
       candidateCount: candidates.length,
       idleCandidateCount: idleCandidates.length,
@@ -10387,8 +10581,10 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       activeConnectionCount: connectionCount(),
       nurseryConnectionCount: connectionCountByGeneration("nursery"),
       establishedConnectionCount: connectionCountByGeneration("established"),
-      maxConnections: resolvedOptions.maxConnections,
-      maxNurseryConnections: resolvedOptions.maxNurseryConnections,
+      // `null` is unbounded, the shipped default. A number is a finite cap on
+      // the idle pool from an env or programmatic override.
+      maxConnections: diagnosticCap(resolvedOptions.maxConnections),
+      maxNurseryConnections: diagnosticCap(resolvedOptions.maxNurseryConnections),
       selectedConnectionId: selected?.debugId,
       selectedGeneration: selected?.generation,
       continuationMatchMode: selectedMatch?.mode,
@@ -10412,7 +10608,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
         ttlPausedMs: entry.ttlPausedMs,
         idleMs: Math.max(0, now - entry.lastUsedAt),
         promptChanges: changedPromptFields(entry.promptFieldHashes, promptFieldHashes),
-        mismatch: candidateMismatchDetails?.get(entry) ?? continuationMismatchDetails(entry, payload, debug)
+        mismatch: candidateMismatchDetails?.get(entry) ?? continuationMismatchDetails(entry, payload, requestToolDefaults, debug)
       })),
       evictions
     }, diagnosticCorrelation);
@@ -10492,7 +10688,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
 }
 
 // src/oauth/claude-identity.ts
-import { createHash as createHash7, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
 var CLAUDE_CODE_CLI_VERSION = "2.1.195";
 var CLAUDE_CODE_USER_AGENT = `claude-cli/${CLAUDE_CODE_CLI_VERSION} (external, cli)`;
 var CLAUDE_CODE_ENTRYPOINT = process.env.CLAUDE_CODE_ENTRYPOINT ?? "cli";
@@ -10501,7 +10697,7 @@ var sessionCache = /* @__PURE__ */ new Map();
 function getOrCreateSessionId(seed) {
   let id = sessionCache.get(seed);
   if (!id) {
-    id = randomUUID2();
+    id = randomUUID3();
     sessionCache.set(seed, id);
   }
   return id;
@@ -11425,7 +11621,7 @@ function thinkingProviderOptions(npm) {
 
 // src/proxy.ts
 import { createServer } from "http";
-import { appendFileSync as appendFileSync2, openSync as openSync6, writeSync as writeSync5, closeSync as closeSync6 } from "fs";
+import { appendFileSync as appendFileSync2, openSync as openSync7, writeSync as writeSync5, closeSync as closeSync7 } from "fs";
 
 // src/http-utils.ts
 import * as zlib from "zlib";
@@ -11849,7 +12045,7 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
 }
 
 // src/proxy.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/sdk-adapter.ts
 import { createHash as createHash8 } from "crypto";
@@ -13223,12 +13419,12 @@ function createTranslationLifecycle(logPath, requestId, claudeSessionId, modelId
 function appendSecureLog(logPath, line) {
   const redacted = redactTraceLine(line);
   try {
-    const fd = openSync6(logPath, "a", 384);
+    const fd = openSync7(logPath, "a", 384);
     try {
       writeSync5(fd, `${(/* @__PURE__ */ new Date()).toISOString()} ${redacted}
 `);
     } finally {
-      closeSync6(fd);
+      closeSync7(fd);
     }
   } catch {
     try {
@@ -13275,7 +13471,7 @@ function configuredAliasLookupNames(alias) {
   }))].map(normalizeRouteLookupId);
 }
 async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenceLogPath, debugLogPath, webSocketDiagnosticsLogPath, modelAliases) {
-  const proxyToken = randomUUID3();
+  const proxyToken = randomUUID4();
   silenceSdkWarnings();
   if (routes.length === 0) {
     throw new Error("Proxy catalog requires at least one route");
@@ -13439,6 +13635,14 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
         const isOAuth = routeAuthType === "oauth";
         let effectiveBeta = inboundBeta;
         let claudeCodeSessionId;
+        const inboundSessionRaw = req.headers["x-claude-code-session-id"];
+        const goSessionHeaders = openCodeGoSessionHeaders(
+          { providerId: route.providerId, baseUrl: upstreamUrl },
+          extractClaudeSessionId(
+            anthropicBody,
+            Array.isArray(inboundSessionRaw) ? inboundSessionRaw[0] : inboundSessionRaw
+          )
+        );
         if (isOAuth) {
           const seed = route.providerId ?? route.realModelId;
           const identity = injectClaudeIdentity(forwardBody, route.providerData, seed);
@@ -13456,7 +13660,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
             authType: routeAuthType,
             log: (message) => plog(message),
             claudeCodeSessionId,
-            extraHeaders: route.headers,
+            extraHeaders: { ...route.headers, ...goSessionHeaders },
             refreshToken: route.refreshToken,
             onTokenRefreshed: (refreshed) => {
               route.apiKey = refreshed;
@@ -13516,6 +13720,11 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
               upstreamModelId: route.realModelId
             }
           });
+          const goSdkSessionHeaders = openCodeGoSessionHeaders(
+            { providerId: route.providerId, baseUrl: route.baseURL },
+            claudeSessionId
+          );
+          if (goSdkSessionHeaders) params.headers = { ...params.headers, ...goSdkSessionHeaders };
           plog(
             () => `sdk: npm=${route.npm} model=${route.realModelId}, stream=${clientWantsStream}, tools=${anthropicBody.tools?.length ?? 0}, msgs=${params.messages.length}`
           );
@@ -13675,7 +13884,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
               res,
               upstreamStatus === 500 ? 502 : upstreamStatus,
               clientMessage,
-              contextLengthExceeded ? relayRequestId ?? randomUUID3() : void 0
+              contextLengthExceeded ? relayRequestId ?? randomUUID4() : void 0
             );
           } else {
             const errorType = anthropicErrorType(upstreamStatus, details?.transportCode);
@@ -13683,7 +13892,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
 data: ${JSON.stringify({
               type: "error",
               error: { type: errorType, message: clientMessage },
-              ...contextLengthExceeded ? { request_id: relayRequestId ?? randomUUID3() } : {}
+              ...contextLengthExceeded ? { request_id: relayRequestId ?? randomUUID4() } : {}
             })}
 
 `);
@@ -14086,10 +14295,10 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
   mkdirSync5(join8(lockPath, ".."), { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = openSync7(lockPath, "wx");
+      const fd = openSync8(lockPath, "wx");
       const content = { pid: process.pid, startedAt: now };
       writeFileSync6(fd, JSON.stringify(content));
-      closeSync7(fd);
+      closeSync8(fd);
       return () => {
         try {
           unlinkSync3(lockPath);
@@ -15019,15 +15228,15 @@ function localProvidersToServerModels(localProviders) {
 }
 
 // src/registry/credential-cleanup-journal.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import {
-  closeSync as closeSync8,
+  closeSync as closeSync9,
   existsSync as existsSync6,
   fstatSync as fstatSync3,
   fsyncSync as fsyncSync2,
   lstatSync,
   mkdirSync as mkdirSync6,
-  openSync as openSync8,
+  openSync as openSync9,
   readFileSync as readFileSync11,
   renameSync as renameSync4,
   unlinkSync as unlinkSync4,
@@ -15119,7 +15328,7 @@ function readJournalUnlocked(path) {
     if (before.isSymbolicLink() || !before.isFile()) {
       throw new Error("Credential cleanup journal must be a regular file.");
     }
-    fd = openSync8(path, "r");
+    fd = openSync9(path, "r");
     const opened = fstatSync3(fd);
     if (before.dev !== opened.dev || before.ino !== opened.ino) {
       throw new Error("Credential cleanup journal changed while opening.");
@@ -15140,39 +15349,39 @@ function readJournalUnlocked(path) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Could not read credential cleanup journal: ${message}`);
   } finally {
-    if (fd !== void 0) closeSync8(fd);
+    if (fd !== void 0) closeSync9(fd);
   }
 }
 function syncParentDirectory(path) {
   let fd;
   try {
-    fd = openSync8(dirname6(path), "r");
+    fd = openSync9(dirname6(path), "r");
     fsyncSync2(fd);
   } catch (error) {
     const code = error.code;
     if (code !== "EINVAL" && code !== "ENOTSUP" && code !== "EPERM") throw error;
   } finally {
-    if (fd !== void 0) closeSync8(fd);
+    if (fd !== void 0) closeSync9(fd);
   }
 }
 function writeJournalUnlocked(journal, path) {
   assertRegistryWriteOwnership(path);
   ensureSecureAppHome();
   mkdirSync6(dirname6(path), { recursive: true, mode: DIR_MODE2 });
-  const tmp = `${path}.${process.pid}.${randomUUID4()}.tmp`;
+  const tmp = `${path}.${process.pid}.${randomUUID5()}.tmp`;
   let fd;
   try {
-    fd = openSync8(tmp, "wx", FILE_MODE4);
+    fd = openSync9(tmp, "wx", FILE_MODE4);
     writeFileSync7(fd, `${JSON.stringify(journal, null, 2)}
 `);
     fsyncSync2(fd);
-    closeSync8(fd);
+    closeSync9(fd);
     fd = void 0;
     assertRegistryWriteOwnership(path);
     renameSync4(tmp, path);
     syncParentDirectory(path);
   } finally {
-    if (fd !== void 0) closeSync8(fd);
+    if (fd !== void 0) closeSync9(fd);
     try {
       unlinkSync4(tmp);
     } catch (error) {
@@ -18052,7 +18261,7 @@ async function askSaveServerPassword() {
 
 // src/server/router.ts
 import { createServer as createServer2 } from "http";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/openai-adapter.ts
 import { tool as tool2, jsonSchema as jsonSchema2, streamText as streamText2, generateText as generateText2 } from "ai";
@@ -18468,7 +18677,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
     plog(`model not found: ${body.model}`);
     return;
   }
-  const requestId = randomUUID5();
+  const requestId = randomUUID6();
   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(body, claudeSessionIdHeader);
   const claudeAgentIds = extractClaudeAgentIds(req.headers);
@@ -18508,6 +18717,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
     const forwardBody = { ...body, model: upstreamModelId(model) };
     const authType = model.authType ?? "api";
     const isOAuth = authType === "oauth";
+    const goSessionHeaders = openCodeGoSessionHeaders(model, claudeSessionId);
     auditInference(options, {
       requestId,
       modelId: body.model,
@@ -18538,7 +18748,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
         authType,
         log: (message) => plog(message),
         claudeCodeSessionId,
-        extraHeaders: model.headers,
+        extraHeaders: { ...model.headers, ...goSessionHeaders },
         refreshToken,
         onTokenRefreshed: (refreshed) => {
           model.apiKey = refreshed;
@@ -18610,6 +18820,8 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
       maxTools: npmMaxTools,
       log: plog
     });
+    const goSdkSessionHeaders = openCodeGoSessionHeaders(model, claudeSessionId);
+    if (goSdkSessionHeaders) params.headers = { ...params.headers, ...goSdkSessionHeaders };
     const clientWantsStream = Boolean(body.stream);
     const responseModelId = getResponseModelId(body.model, model, options);
     plog(() => `sdk npm=${model.npm} upstream=${upstreamModelId(model)} responseModel=${responseModelId} stream=${clientWantsStream}`);
@@ -18801,6 +19013,8 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
   }
   const model = lookupModel(res, options.catalog, body.model);
   if (!model) return;
+  const openAiSessionIdHeader = 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 goSessionHeaders = openCodeGoSessionHeaders(model, openAiSessionIdHeader);
   if (supportsDirectOpenAIChatCompletions(model)) {
     if (model.completionsUrl && !/^https?:\/\//i.test(model.completionsUrl)) {
       sendJson(res, 400, { error: { message: `Invalid provider completionsUrl: must be http:// or https://` } });
@@ -18837,7 +19051,7 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
     try {
       await relayAnthropicMessages(res, completionsUrl, forwardBody, apiKey2, Boolean(body.stream), {
         authType: model.authType ?? "api",
-        extraHeaders: model.headers,
+        extraHeaders: { ...model.headers, ...goSessionHeaders },
         refreshToken,
         onTokenRefreshed: (refreshed) => {
           model.apiKey = refreshed;
@@ -18882,6 +19096,7 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
   const baseURL = model.modelFormat === "anthropic" ? model.baseUrl : model.apiBaseUrl;
   const openAiOAuth = isOpenAiOAuthRoute(model);
   const params = translateOpenAiRequest(body, { openAiOAuth });
+  if (goSessionHeaders) params.headers = { ...params.headers, ...goSessionHeaders };
   const clientWantsStream = Boolean(body.stream);
   const responseModelId = getResponseModelId(body.model, model, options);
   plog(() => `sdk-openai npm=${npm} upstream=${upstreamModelId(model)} responseModel=${responseModelId} stream=${clientWantsStream}`);
@@ -19136,7 +19351,7 @@ import * as http2 from "http";
 import * as https from "https";
 import * as net from "net";
 import { PassThrough } from "stream";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { URL as URL2 } from "url";
 import { createBrotliDecompress, createGunzip, createInflate } from "zlib";
 
@@ -19994,7 +20209,7 @@ async function startHttpProxy(options) {
     }
     const messagesEndpoint = anthropicMessagesEndpoint(req.url);
     if (req.method === "POST" && messagesEndpoint) {
-      const requestId = randomUUID6();
+      const requestId = randomUUID7();
       let parsed = null;
       let route;
       let adapterBody = rawBody;