@bman654/clodex 2.1.5 → 2.1.7

package/dist/cli.js

@@ -217,7 +217,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.1.5",
+  version: "2.1.7",
   publishConfig: {
     access: "public"
   },
@@ -4007,6 +4007,11 @@ function clampRetryAfterSeconds(value) {
   }
   return Math.min(Math.round(value), MAX_RETRY_AFTER_SECONDS);
 }
+function retryAfterFromText(message) {
+  if (typeof message !== "string") return void 0;
+  const match = /retry after (\d+)s\b/i.exec(message);
+  return match ? Number(match[1]) : void 0;
+}
 function numericRetryAfterSeconds(inner) {
   const data = inner.data;
   const fromBody = data?.error?.retry_after_seconds;
@@ -4014,12 +4019,84 @@ function numericRetryAfterSeconds(inner) {
   const fromHeader = inner.responseHeaders?.["retry-after"];
   if (typeof fromHeader === "string" && /^\d+$/.test(fromHeader.trim())) return Number(fromHeader.trim());
   for (const message of [data?.error?.message, inner.message]) {
-    if (typeof message !== "string") continue;
-    const match = /retry after (\d+)s\b/i.exec(message);
-    if (match) return Number(match[1]);
+    const fromText = retryAfterFromText(message);
+    if (fromText !== void 0) return fromText;
   }
   return void 0;
 }
+var MAX_CLIENT_MESSAGE_CHARS = 240;
+var CHUNK_DISCRIMINATOR_TYPES = /* @__PURE__ */ new Set(["error", "response.failed"]);
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function nonEmptyString(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function errorCodeValue(record) {
+  const value = record.code;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function frameStatusCode(code, discriminator) {
+  if (code !== void 0 && /^\d{3}$/.test(code)) {
+    const numeric = Number(code);
+    if (numeric >= 400 && numeric <= 599) return numeric;
+  }
+  if (/insufficient_quota|rate_limit/.test(discriminator)) return 429;
+  if (discriminator.includes("authentication")) return 401;
+  if (discriminator.includes("permission")) return 403;
+  if (discriminator.includes("not_found")) return 404;
+  if (/invalid|bad_request|context_length/.test(discriminator)) return 400;
+  if (discriminator.includes("overload")) return 503;
+  if (discriminator.includes("timeout")) return 504;
+  return 500;
+}
+function frameIsContextLengthExceeded(discriminator, message) {
+  if (/context_length|context_window/.test(discriminator)) return true;
+  return /context_length_exceeded|maximum context length|prompt is too long/i.test(message);
+}
+function frameIsRetryable(frame) {
+  if (frame.transportCode !== void 0) return true;
+  const { statusCode } = frame;
+  return statusCode === 408 || statusCode === 409 || statusCode === 429 || statusCode >= 500;
+}
+function providerErrorFrame(err) {
+  const outer = asRecord(err);
+  if (!outer) return void 0;
+  const nested = asRecord(outer.error) ?? asRecord(asRecord(outer.response)?.error);
+  const unwrapped = !(err instanceof Error) && (typeof outer.type === "string" || Object.hasOwn(outer, "code") || Object.hasOwn(outer, "param")) ? outer : void 0;
+  const payload = nested ?? unwrapped;
+  if (!payload) return void 0;
+  const rawMessage = payload.message;
+  if (typeof rawMessage !== "string") return void 0;
+  const message = rawMessage.trim() !== "" ? rawMessage : "Provider returned an error";
+  const code = errorCodeValue(payload);
+  const rawType = nonEmptyString(payload, "type");
+  const type = rawType !== void 0 && CHUNK_DISCRIMINATOR_TYPES.has(rawType) ? void 0 : rawType;
+  const discriminator = [code, type].filter((value) => value !== void 0).join(" ").toLowerCase();
+  const statusCode = frameStatusCode(code, discriminator);
+  const rawRetryAfter = statusCode === 429 ? typeof payload.retry_after_seconds === "number" && Number.isFinite(payload.retry_after_seconds) && payload.retry_after_seconds >= 0 ? payload.retry_after_seconds : retryAfterFromText(message) : void 0;
+  let serialized;
+  try {
+    serialized = JSON.stringify(payload) ?? message;
+  } catch {
+    serialized = message;
+  }
+  return {
+    message,
+    statusCode,
+    contextLengthExceeded: frameIsContextLengthExceeded(discriminator, message),
+    ...rawRetryAfter !== void 0 ? { retryAfterSeconds: clampRetryAfterSeconds(rawRetryAfter) } : {},
+    ...code === "websocket_transport_error" ? { transportCode: "websocket_transport_error" } : {},
+    serialized
+  };
+}
+function frameFromError(err) {
+  const retry = RetryError.isInstance(err) ? err : void 0;
+  const frame = providerErrorFrame(retry?.lastError ?? err);
+  return frame ? { frame, attemptCount: retry?.errors.length ?? 1 } : void 0;
+}
 function boundedTransportCode(data) {
   if (!data || typeof data !== "object") return void 0;
   const error = data.error;
@@ -4029,7 +4106,19 @@ function boundedTransportCode(data) {
 function sdkUpstreamErrorDetails(err) {
   const retry = RetryError.isInstance(err) ? err : void 0;
   const inner = retry?.lastError ?? err;
-  if (!APICallError.isInstance(inner)) return void 0;
+  if (!APICallError.isInstance(inner)) {
+    const recovered = frameFromError(err);
+    if (!recovered) return void 0;
+    const { frame, attemptCount } = recovered;
+    return {
+      statusCode: frame.statusCode,
+      errorContent: frame.serialized,
+      isRetryable: frameIsRetryable(frame),
+      attemptCount,
+      ...frame.retryAfterSeconds !== void 0 ? { retryAfterSeconds: frame.retryAfterSeconds } : {},
+      ...frame.transportCode !== void 0 ? { transportCode: frame.transportCode } : {}
+    };
+  }
   let errorContent = inner.responseBody;
   if (!errorContent && inner.data !== void 0) {
     try {
@@ -4050,6 +4139,8 @@ function sdkUpstreamErrorDetails(err) {
   };
 }
 function isContextLengthExceededError(err, formattedMessage = "") {
+  const frame = frameFromError(err)?.frame;
+  if (frame) return frame.contextLengthExceeded;
   const details = sdkUpstreamErrorDetails(err);
   const rec = err && typeof err === "object" ? err : void 0;
   const candidates = [
@@ -4068,6 +4159,11 @@ function isContextLengthExceededError(err, formattedMessage = "") {
 function formatUpstreamError(err) {
   if (!err || typeof err !== "object") return "Upstream model request failed.";
   const rec = err;
+  const frame = frameFromError(err)?.frame;
+  if (frame) {
+    const short = truncateForClient(sanitizeMessage(frame.message)) || "Upstream model request failed.";
+    return `${short} (HTTP ${frame.statusCode})`;
+  }
   if (rec.data?.error?.message) {
     const short = sanitizeMessage(rec.data.error.message);
     return rec.statusCode ? `${short} (HTTP ${rec.statusCode})` : short;
@@ -4106,6 +4202,8 @@ function upstreamHttpStatus(err, message) {
     const code = err.statusCode;
     if (typeof code === "number" && code >= 400 && code <= 599) return code;
   }
+  const frameStatus = frameFromError(err)?.frame.statusCode;
+  if (frameStatus !== void 0) return frameStatus;
   if (message.includes("HTTP 429") || message.includes("429")) return 429;
   if (message.includes("HTTP 400")) return 400;
   return 500;
@@ -4126,6 +4224,10 @@ function anthropicErrorType(status) {
       return "api_error";
   }
 }
+function truncateForClient(message) {
+  if (message.length <= MAX_CLIENT_MESSAGE_CHARS) return message;
+  return `${[...message].slice(0, MAX_CLIENT_MESSAGE_CHARS - 1).join("")}\u2026`;
+}
 function sanitizeMessage(message) {
   const line = message.split("\n")[0]?.trim() ?? message;
   if (line.startsWith("RetryError") || line.includes("AI_RetryError")) {
@@ -4304,6 +4406,9 @@ function normalizeToolCallJson(value) {
     } catch {
     }
   }
+  if (record.type === "reasoning" && Array.isArray(record.content) && record.content.length === 0) {
+    delete out.content;
+  }
   return out;
 }
 function arraysEqual(left, right) {
@@ -4319,7 +4424,37 @@ function conversationItemKind(value) {
 function conversationItemHash(value) {
   return createHash3("sha256").update(canonicalJson(normalizeToolCallJson(value))).digest("hex").slice(0, 16);
 }
-function continuationMismatchDetails(entry, payload) {
+function reasoningNormalizationGap(expected, actual) {
+  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 fields = [.../* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])].sort().filter((key) => canonicalJson(normalizeToolCallJson(left[key])) !== canonicalJson(normalizeToolCallJson(right[key])));
+  return fields.length ? fields : void 0;
+}
+var warnedReasoningGaps = /* @__PURE__ */ new Set();
+var MAX_REASONING_GAP_WARNINGS = 3;
+function warnReasoningNormalizationGap(fields, log12) {
+  const signature = fields.join(",");
+  const message = `clodex: warning: a reasoning item with identical encrypted_content failed the continuation match on field(s): ${signature}. Prompt caching is degraded for this turn \u2014 this is a clodex normalization gap, please report it at https://github.com/bman654/clodex/issues`;
+  try {
+    log12?.(`reasoning normalization gap: ${signature}`);
+  } catch {
+  }
+  if (warnedReasoningGaps.has(signature)) return;
+  if (warnedReasoningGaps.size >= MAX_REASONING_GAP_WARNINGS) return;
+  warnedReasoningGaps.add(signature);
+  try {
+    process.stderr.write(`${message}
+`);
+    if (warnedReasoningGaps.size === MAX_REASONING_GAP_WARNINGS) {
+      process.stderr.write("clodex: warning: further reasoning-normalization warnings suppressed.\n");
+    }
+  } catch {
+  }
+}
+function continuationMismatchDetails(entry, payload, log12) {
   const full = inputArray(payload);
   const prefix = [...entry.requestInput ?? [], ...entry.expectedAssistant ?? []];
   const comparable = Math.min(full.length, prefix.length);
@@ -4332,6 +4467,8 @@ function continuationMismatchDetails(entry, payload) {
   }
   const expected = mismatch < prefix.length ? prefix[mismatch] : void 0;
   const actual = mismatch < full.length ? full[mismatch] : void 0;
+  const reasoningGap = reasoningNormalizationGap(expected, actual);
+  if (reasoningGap) warnReasoningNormalizationGap(reasoningGap, log12);
   return {
     fullItems: full.length,
     expectedPrefixItems: prefix.length,
@@ -4339,11 +4476,12 @@ function continuationMismatchDetails(entry, payload) {
     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) } : {}
+    ...actual !== void 0 ? { actualHash: conversationItemHash(actual) } : {},
+    ...reasoningGap ? { reasoningNormalizationGap: reasoningGap } : {}
   };
 }
-function continuationMismatchSummary(entry, payload) {
-  const details = continuationMismatchDetails(entry, payload);
+function continuationMismatchSummary(entry, payload, log12) {
+  const details = continuationMismatchDetails(entry, payload, log12);
   return `full_items=${details.fullItems} expected_prefix_items=${details.expectedPrefixItems} first_mismatch=${details.firstMismatch} expected=${details.expectedKind} actual=${details.actualKind}`;
 }
 function continuationMatch(entry, payload) {
@@ -4374,6 +4512,15 @@ function responseErrorCode(event) {
   const responseError = response?.error && typeof response.error === "object" ? response.error : void 0;
   return typeof responseError?.code === "string" ? responseError.code : void 0;
 }
+function responseErrorType(event) {
+  if (!event || typeof event !== "object") return void 0;
+  const record = event;
+  const error = record.error && typeof record.error === "object" ? record.error : void 0;
+  if (typeof error?.type === "string") return error.type;
+  const response = record.response && typeof record.response === "object" ? record.response : void 0;
+  const responseError = response?.error && typeof response.error === "object" ? response.error : void 0;
+  return typeof responseError?.type === "string" ? responseError.type : void 0;
+}
 function responseRetryAfterSeconds(event) {
   if (!event || typeof event !== "object") return void 0;
   const record = event;
@@ -4388,6 +4535,27 @@ function responseRetryAfterSeconds(event) {
   }
   return void 0;
 }
+function responseErrorStatus(event) {
+  if (!event || typeof event !== "object") return void 0;
+  const record = event;
+  for (const candidate of [record.status, record.error?.status]) {
+    if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 400 && candidate <= 599) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function responseErrorMessage(event) {
+  if (!event || typeof event !== "object") return void 0;
+  const record = event;
+  const response = record.response && typeof record.response === "object" ? record.response : void 0;
+  for (const candidate of [record.error, response?.error, record]) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const message = candidate.message;
+    if (typeof message === "string" && message.trim()) return message.trim();
+  }
+  return void 0;
+}
 function boundedDiagnosticIdentifier(value) {
   if (typeof value !== "string") return void 0;
   const normalized = value.trim();
@@ -4894,7 +5062,8 @@ function handleSocketMessage(entry, data) {
     );
     return;
   }
-  if (FAILURE_EVENT_TYPES.has(type ?? "")) {
+  const errorStatus = type === "error" && !ctx.emittedModelData ? responseErrorStatus(event) : void 0;
+  if (FAILURE_EVENT_TYPES.has(type ?? "") && (errorStatus === void 0 || willRetry)) {
     emitResponseErrorDiagnostic(entry, ctx, {
       source: "response_event",
       upstreamEventType: type,
@@ -4911,6 +5080,32 @@ function handleSocketMessage(entry, data) {
     dispatchContext(replacement, ctx);
     return;
   }
+  if (errorStatus !== void 0) {
+    const statedRetryAfter = errorStatus === 429 ? responseRetryAfterSeconds(event) : void 0;
+    const retryAfterSeconds = statedRetryAfter === void 0 ? void 0 : clampRetryAfterSeconds(statedRetryAfter);
+    const reason = responseErrorMessage(event) ?? `OpenAI rejected the request (HTTP ${errorStatus})`;
+    failContext(
+      entry,
+      ctx,
+      retryAfterSeconds === void 0 ? reason : `${reason}; retry after ${retryAfterSeconds}s`,
+      {
+        source: "error_frame",
+        // Names the failure. Without it this record — now the ONLY one for a
+        // rejection — can carry no indication of what failed, since a bare
+        // error frame often has no `code` at all.
+        errorType: boundedDiagnosticIdentifier(responseErrorType(event)),
+        // Upstream-controlled, so bounded like every other identifier in this
+        // file's diagnostics. The connection-limit branch can pass its code raw
+        // only because it has just been compared `===` to a known constant.
+        errorCode: boundedDiagnosticIdentifier(errorCode),
+        mappedStatusCode: errorStatus,
+        ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {}
+      },
+      errorStatus,
+      retryAfterSeconds
+    );
+    return;
+  }
   ctx.pendingEvents.push(event);
   if (isModelDataEvent(type)) flushPending(ctx);
   if (TERMINAL_EVENT_TYPES.has(type ?? "") || type === "error") {
@@ -5113,7 +5308,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       debug("parallel request using an isolated socket");
     } else if (diagnosticEntry) {
       debug(
-        `history mismatch starting an additional chain; retained ${candidates.length} existing head(s) (${continuationMismatchSummary(diagnosticEntry, payload)})`
+        `history mismatch starting an additional chain; retained ${candidates.length} existing head(s) (${continuationMismatchSummary(diagnosticEntry, payload, debug)})`
       );
       decision = "history_mismatch_new_head";
     } else if (partitionKey) {
@@ -5173,7 +5368,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)
+        mismatch: continuationMismatchDetails(entry, payload, debug)
       })),
       evictions
     }, diagnosticCorrelation);
@@ -5706,6 +5901,9 @@ function mapCodexEffortToAnthropic(effort) {
 function isGpt56Model(modelId) {
   return /^gpt-5\.6(?:-|$)/i.test(modelId);
 }
+function isReasoningSummaryUnsupportedModel(modelId) {
+  return /codex-spark(?:-|$)/i.test(modelId);
+}
 function mapCodexEffortToOpenAI(effort, modelId) {
   if (modelId && isGpt56Model(modelId) && GPT_56_EFFORT_LEVELS.includes(effort)) {
     return effort;
@@ -5942,7 +6140,8 @@ function effortProviderOptions(npm, effort, modelId, metadata) {
   if (npm === "@ai-sdk/openai" || npm === "@ai-sdk/azure") {
     if (!modelId || !modelPrefersResponsesApi(modelId)) return void 0;
     const reasoningEffort = mapCodexEffortToOpenAI(effort, modelId);
-    return reasoningEffort ? { openai: { reasoningEffort } } : void 0;
+    if (!reasoningEffort) return void 0;
+    return isReasoningSummaryUnsupportedModel(modelId) ? { openai: { reasoningEffort, reasoningSummary: null } } : { openai: { reasoningEffort } };
   }
   if (npm === "@ai-sdk/xai") {
     if (!modelId || !isXaiReasoningEffortModel(modelId)) return void 0;