@bman654/clodex 2.2.2 → 2.3.0

package/README.md

@@ -275,6 +275,15 @@ clodex --version    # version
 - Proxied routes forward configured provider headers for API-key and OAuth authentication. Anonymous routes preserve non-credential headers while removing authorization, API-key, cookie, token, secret, and credential-bearing header names before dispatch.
 - `CLODEX_CLAUDE_PATH` overrides Claude Code binary discovery.
 - **Outbound proxy:** when `HTTP_PROXY`/`HTTPS_PROXY` (and optionally `NO_PROXY`) are set in clodex's environment, all clodex-originated network calls honor them — OAuth sign-in and token refresh, model-list and models.dev refreshes, upstream OpenAI API calls, and the ChatGPT/Codex OAuth WebSocket transport (tunneled via HTTP CONNECT).
+- **Upstream retries:** set `CLODEX_UPSTREAM_MAX_RETRIES` to an integer from
+  `0` through `5` to override the SDK's default of two retries for retryable
+  provider failures. `0` disables retries. The SDK honors valid
+  `retry-after`/`retry-after-ms` headers and otherwise uses exponential
+  backoff. Larger integers clamp to `5` with a one-time warning because a sixth
+  retry cannot complete before the translated streaming paths' 120-second
+  no-data timeout. Unset, empty, or malformed values preserve the default. A
+  stream that fails after output begins cannot be replayed safely and still
+  terminates the request.
 
 ## Known limitations
 

package/dist/cli.js

@@ -218,7 +218,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.2.2",
+  version: "2.3.0",
   publishConfig: {
     access: "public"
   },
@@ -4496,6 +4496,61 @@ function warnReasoningNormalizationGap(fields, log12) {
   } catch {
   }
 }
+function toolArgumentNormalizationGap(expected, actual, requiredProps) {
+  if (conversationItemKind(expected) !== "function_call") return void 0;
+  if (conversationItemKind(actual) !== "function_call") return void 0;
+  const left = expected;
+  const right = actual;
+  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))) {
+    return void 0;
+  }
+  const required = requiredProps().get(left.name);
+  const stripped = (item) => {
+    if (typeof item.arguments !== "string") return void 0;
+    const raw = item.arguments.trim();
+    try {
+      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))
+      });
+    } catch {
+      return void 0;
+    }
+  };
+  const leftStripped = stripped(left);
+  const rightStripped = stripped(right);
+  return {
+    tool: left.name,
+    equalAfterStrip: leftStripped !== void 0 && leftStripped === rightStripped
+  };
+}
+var warnedToolArgumentGaps = /* @__PURE__ */ new Set();
+var MAX_TOOL_ARGUMENT_GAP_WARNINGS = 3;
+function warnToolArgumentNormalizationGap(gap, log12) {
+  const tool3 = typeof gap.tool === "string" ? gap.tool : "unknown";
+  const signature = `${tool3}:filler`;
+  const message = `clodex: warning: tool call "${tool3}" failed the continuation match, but both sides are identical once clodex's filler-strip rule is applied, so the head should have matched. Prompt caching is degraded for this turn \u2014 please report it, with the adapter debug log from --trace if you can, at https://github.com/bman654/clodex/issues`;
+  try {
+    log12?.(`tool argument normalization gap: ${signature}`);
+  } catch {
+  }
+  if (warnedToolArgumentGaps.has(signature)) return;
+  if (warnedToolArgumentGaps.size >= MAX_TOOL_ARGUMENT_GAP_WARNINGS) return;
+  warnedToolArgumentGaps.add(signature);
+  try {
+    process.stderr.write(`${message}
+`);
+    if (warnedToolArgumentGaps.size === MAX_TOOL_ARGUMENT_GAP_WARNINGS) {
+      process.stderr.write("clodex: warning: further tool-argument normalization warnings suppressed.\n");
+    }
+  } catch {
+  }
+}
 function continuationMismatchDetails(entry, payload, log12, warnOnGap = false) {
   const full = inputArray(payload);
   const prefix = [...entry.requestInput ?? [], ...entry.expectedAssistant ?? []];
@@ -4511,6 +4566,34 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false) {
   const actual = mismatch < full.length ? full[mismatch] : void 0;
   const reasoningGap = reasoningNormalizationGap(expected, actual);
   if (reasoningGap && warnOnGap) warnReasoningNormalizationGap(reasoningGap, log12);
+  let gapExpected = expected;
+  if (conversationItemKind(expected) === "reasoning" && conversationItemKind(actual) === "function_call") {
+    for (let index = mismatch; index < prefix.length; index += 1) {
+      if (conversationItemKind(prefix[index]) !== "reasoning") {
+        gapExpected = prefix[index];
+        break;
+      }
+    }
+  }
+  let toolArgumentGap;
+  try {
+    toolArgumentGap = toolArgumentNormalizationGap(
+      gapExpected,
+      actual,
+      // 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)
+    );
+  } catch {
+  }
+  if (toolArgumentGap?.equalAfterStrip === true) {
+    if (warnOnGap) warnToolArgumentNormalizationGap(toolArgumentGap, log12);
+  } else if (toolArgumentGap && warnOnGap) {
+    try {
+      log12?.(`tool argument mismatch beyond the strip rule: ${String(toolArgumentGap.tool)}`);
+    } catch {
+    }
+  }
   return {
     fullItems: full.length,
     expectedPrefixItems: prefix.length,
@@ -4528,11 +4611,12 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false) {
         entry.expectedAssistant ?? [],
         mismatch
       )
-    } : {}
+    } : {},
+    ...toolArgumentGap ? { toolArgumentNormalizationGap: toolArgumentGap } : {}
   };
 }
-function continuationMismatchSummary(entry, payload, log12, mismatchDump = false) {
-  const details = continuationMismatchDetails(entry, payload, log12, true);
+function continuationMismatchSummary(entry, payload, log12, mismatchDump = false, precomputedDetails) {
+  const details = precomputedDetails ?? continuationMismatchDetails(entry, payload, 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"}`;
@@ -4668,6 +4752,7 @@ function emitContextDiagnostic(entry, ctx, details) {
     retried: ctx.retried,
     frameCount: ctx.frameCount,
     emittedModelData: ctx.emittedModelData,
+    emittedDownstreamData: ctx.emittedDownstreamData,
     responseIdReceived: Boolean(ctx.responseId),
     inFlightMs: entry.inFlightStartedAt === void 0 ? void 0 : Math.max(0, entry.options.now() - entry.inFlightStartedAt),
     ...details
@@ -4922,6 +5007,7 @@ function expectedAssistantItems(ctx) {
 }
 function encodeSse(ctx, event) {
   if (ctx.closed) return;
+  ctx.emittedDownstreamData = true;
   ctx.controller.enqueue(ctx.encoder.encode(`data: ${JSON.stringify(event)}
 
 `));
@@ -4973,12 +5059,12 @@ function failContext(entry, ctx, message, diagnosticDetails, statusCode, retryAf
   closeContext(ctx);
 }
 function retryTransportFailure(entry, ctx, diagnosticDetails) {
-  if (ctx.closed || entry.current !== ctx || ctx.retried || ctx.frameCount !== 0 || ctx.emittedModelData) {
+  if (ctx.closed || entry.current !== ctx || ctx.retried || !transportReplaySafe(ctx)) {
     return false;
   }
   ctx.retried = true;
   ctx.transportRetryPending = true;
-  entry.debug("transport failed before any response frame; retrying once with full context");
+  entry.debug("transport failed before downstream output; retrying once with full context");
   emitContextDiagnostic(entry, ctx, {
     event: "ws_transport_retry",
     outcome: "started",
@@ -5012,9 +5098,9 @@ function retryTransportFailure(entry, ctx, diagnosticDetails) {
 function handleTransportFailure(entry, ctx, message, diagnosticDetails) {
   if (retryTransportFailure(entry, ctx, diagnosticDetails)) return;
   if (ctx.closed || entry.current !== ctx) return;
-  if (ctx.retried && ctx.frameCount === 0 && !ctx.emittedModelData) {
+  if (ctx.retried && ctx.transportRetryPending && transportReplaySafe(ctx)) {
     ctx.transportRetryPending = false;
-    entry.debug("transport retry exhausted before any response frame");
+    entry.debug("transport retry exhausted before downstream output");
     emitContextDiagnostic(entry, ctx, {
       event: "ws_transport_retry",
       outcome: "exhausted",
@@ -5118,6 +5204,9 @@ function resetContextForRetry(ctx) {
   ctx.recentUpstreamEventTypes = [];
   ctx.emittedProtocolAnomalies.clear();
 }
+function transportReplaySafe(ctx) {
+  return !ctx.emittedDownstreamData && !ctx.emittedModelData && ctx.outputByIndex.size === 0;
+}
 function handleSocketMessage(entry, data) {
   const ctx = entry.current;
   if (!ctx || ctx.closed) return;
@@ -5232,6 +5321,7 @@ function handleSocketMessage(entry, data) {
       entry.responseId = ctx.responseId;
       entry.requestInput = inputArray(ctx.originalPayload);
       entry.expectedAssistant = expectedAssistantItems(ctx);
+      entry.headRequiredToolProps = requiredToolProps(ctx.originalPayload);
       entry.canonicalPrefix = void 0;
       entry.canonicalEchoablePrefix = void 0;
       entry.promptFieldHashes = ctx.promptFieldHashes;
@@ -5417,6 +5507,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
     let persistent = Boolean(partitionKey);
     let promotedConnectionId;
     let decision;
+    let candidateMismatchDetails;
     if (selected && selectedDelta) {
       sendPayload = { ...payload, input: selectedDelta, previous_response_id: selected.responseId };
       continued = true;
@@ -5439,8 +5530,23 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       decision = "parallel_isolated";
       debug("parallel request using an isolated socket");
     } else if (diagnosticEntry) {
+      const diagnosticMismatch = continuationMismatchDetails(diagnosticEntry, payload, debug, true);
+      candidateMismatchDetails = /* @__PURE__ */ new Map([[diagnosticEntry, diagnosticMismatch]]);
+      for (const candidate of candidates) {
+        if (candidate === diagnosticEntry) continue;
+        candidateMismatchDetails.set(
+          candidate,
+          continuationMismatchDetails(candidate, payload, debug, true)
+        );
+      }
       debug(
-        `history mismatch starting an additional chain; retained ${candidates.length} existing head(s) (${continuationMismatchSummary(diagnosticEntry, payload, debug, mismatchDump)})`
+        `history mismatch starting an additional chain; retained ${candidates.length} existing head(s) (${continuationMismatchSummary(
+          diagnosticEntry,
+          payload,
+          debug,
+          mismatchDump,
+          diagnosticMismatch
+        )})`
       );
       decision = "history_mismatch_new_head";
     } else if (partitionKey) {
@@ -5500,7 +5606,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
         ttlPausedMs: entry.ttlPausedMs,
         idleMs: Math.max(0, now - entry.lastUsedAt),
         promptChanges: changedPromptFields(entry.promptFieldHashes, promptFieldHashes),
-        mismatch: continuationMismatchDetails(entry, payload, debug)
+        mismatch: candidateMismatchDetails?.get(entry) ?? continuationMismatchDetails(entry, payload, debug)
       })),
       evictions
     }, diagnosticCorrelation);
@@ -5520,6 +5626,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
           frameCount: 0,
           pendingEvents: [],
           emittedModelData: false,
+          emittedDownstreamData: false,
           transportRetryPending: false,
           outputByIndex: /* @__PURE__ */ new Map(),
           outputIndexByItemId: /* @__PURE__ */ new Map(),
@@ -9882,6 +9989,41 @@ function resolveUpstreamTools(tools, messages) {
   return upstream;
 }
 
+// src/upstream-retry.ts
+var UPSTREAM_MAX_RETRIES_ENV = "CLODEX_UPSTREAM_MAX_RETRIES";
+var MAX_UPSTREAM_MAX_RETRIES = 5;
+var reportedValues = /* @__PURE__ */ new Set();
+function reportOnce(raw, message, warn) {
+  if (reportedValues.has(raw)) return;
+  reportedValues.add(raw);
+  try {
+    warn(message);
+  } catch {
+  }
+}
+function upstreamMaxRetries(env = process.env, warn = (message) => console.error(`clodex: ${message}`)) {
+  const raw = env[UPSTREAM_MAX_RETRIES_ENV]?.trim();
+  if (raw === void 0 || raw === "") return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    reportOnce(
+      raw,
+      `ignoring ${UPSTREAM_MAX_RETRIES_ENV}=${raw} (expected a non-negative integer)`,
+      warn
+    );
+    return void 0;
+  }
+  if (value > MAX_UPSTREAM_MAX_RETRIES) {
+    reportOnce(
+      raw,
+      `clamping ${UPSTREAM_MAX_RETRIES_ENV}=${raw} to ${MAX_UPSTREAM_MAX_RETRIES} (higher values exceed the 120s streaming idle budget)`,
+      warn
+    );
+    return MAX_UPSTREAM_MAX_RETRIES;
+  }
+  return value;
+}
+
 // src/sdk-adapter.ts
 function sdkTranslationErrorSignature(error) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
@@ -9952,10 +10094,12 @@ function openAiCacheBreakpoint(block, enabled) {
 function translateTopLevelSystemForOpenAi(system) {
   if (!system) return [];
   if (typeof system === "string") {
-    return system.trim() ? [{ role: "system", content: system }] : [];
+    const stripped = stripClaudeCodeBillingHeader(system);
+    return stripped?.trim() ? [{ role: "system", content: stripped }] : [];
   }
   return system.flatMap((block) => {
-    const text4 = typeof block === "string" ? block : block.text ?? "";
+    const raw = typeof block === "string" ? block : block.text ?? "";
+    const text4 = stripClaudeCodeBillingHeader(raw) ?? "";
     if (!text4.trim()) return [];
     const cacheControl = typeof block === "string" ? void 0 : block.cache_control;
     return [{
@@ -10141,7 +10285,7 @@ function isClaudeCodeStructuredOutputCompactRequest(body) {
 function translateRequest(body, npm, options) {
   const messages = body.messages ?? [];
   annotateToolNames(messages);
-  const baseSystem = systemToString(body.system, options?.openAiOAuth === true);
+  const baseSystem = systemToString(body.system, true);
   const systemText = baseSystem?.trim() || (options?.openAiOAuth ? "You are a coding assistant." : void 0);
   const compactRequest = isClaudeCodeStructuredOutputCompactRequest(body);
   let upstreamTools = resolveUpstreamTools(
@@ -10432,6 +10576,7 @@ async function streamAnthropicResponse(model, params, modelId, write, log12, obs
   const result = streamText({
     model,
     ...params,
+    maxRetries: upstreamMaxRetries(),
     abortSignal,
     onError: () => {
     }
@@ -10480,6 +10625,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
     const r = streamText({
       model,
       ...params,
+      maxRetries: upstreamMaxRetries(),
       abortSignal,
       onError: () => {
       }
@@ -10536,6 +10682,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       const r = await generateText({
         model,
         ...params,
+        maxRetries: upstreamMaxRetries(),
         abortSignal: generateAbort.signal
       });
       ({ text: text4, toolCalls, finishReason, usage } = r);
@@ -11490,11 +11637,20 @@ async function collectOpenAiStream(stream) {
 async function generateOpenAiResponse(model, params, responseModelId, options) {
   let result;
   if (options?.forceStream) {
-    const { stream } = streamText2({ model, ...params, onError: () => {
-    } });
+    const { stream } = streamText2({
+      model,
+      ...params,
+      maxRetries: upstreamMaxRetries(),
+      onError: () => {
+      }
+    });
     result = await collectOpenAiStream(stream);
   } else {
-    result = await generateText2({ model, ...params });
+    result = await generateText2({
+      model,
+      ...params,
+      maxRetries: upstreamMaxRetries()
+    });
   }
   const message = { role: "assistant", content: result.text || null };
   if (result.toolCalls?.length) {
@@ -11518,7 +11674,11 @@ async function generateOpenAiResponse(model, params, responseModelId, options) {
   };
 }
 async function streamOpenAiResponse(model, params, responseModelId, onChunk) {
-  const { stream } = streamText2({ model, ...params });
+  const { stream } = streamText2({
+    model,
+    ...params,
+    maxRetries: upstreamMaxRetries()
+  });
   const baseData = {
     id: `chatcmpl-${Date.now()}`,
     object: "chat.completion.chunk",