claudish 7.21.0 → 7.22.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.21.0";
+var VERSION = "7.22.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -37465,6 +37465,140 @@ var init_connection_error = __esm(() => {
   BUN_CONNECT_MESSAGE = /unable to connect\. is the computer able to access the url\?/i;
 });
 
+// src/handlers/shared/stream-head-sniffer.ts
+function isRetryableStreamError(code, type, message) {
+  if (RETRYABLE_ERROR_CODES.has(code))
+    return true;
+  if (RETRYABLE_ERROR_TYPES.has(type))
+    return true;
+  return /overloaded|try again later|temporarily unavailable|please retry/i.test(message);
+}
+async function sniffResponsesStreamHead(response, opts = {}) {
+  const budgetMs = opts.budgetMs ?? DEFAULT_SNIFF_BUDGET_MS;
+  const logMsg = opts.log ?? (() => {});
+  if (!response.body)
+    return { kind: "clean", response };
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  const consumed = [];
+  let pending = "";
+  const deadline = Date.now() + budgetMs;
+  const replayResponse = () => {
+    const buffered = consumed.slice();
+    const body = new ReadableStream({
+      start: async (controller) => {
+        try {
+          for (const chunk of buffered)
+            controller.enqueue(chunk);
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            if (value)
+              controller.enqueue(value);
+          }
+          controller.close();
+        } catch (error46) {
+          try {
+            controller.error(error46);
+          } catch {}
+        }
+      },
+      cancel: () => {
+        reader.cancel().catch(() => {});
+      }
+    });
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+  try {
+    while (true) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        logMsg(`[StreamSniff] budget ${budgetMs}ms elapsed with no verdict \u2014 streaming through`);
+        return { kind: "clean", response: replayResponse() };
+      }
+      let timer;
+      const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), remaining);
+      });
+      let result;
+      try {
+        result = await Promise.race([reader.read(), timeout]);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+      }
+      if (result === "timeout") {
+        logMsg(`[StreamSniff] budget ${budgetMs}ms elapsed mid-read \u2014 streaming through`);
+        return { kind: "clean", response: replayResponse() };
+      }
+      if (result.done)
+        return { kind: "clean", response: replayResponse() };
+      if (!result.value)
+        continue;
+      consumed.push(result.value);
+      pending += decoder.decode(result.value, { stream: true });
+      const lines = pending.split(`
+`);
+      pending = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:"))
+          continue;
+        const payload = trimmed.slice(5).trim();
+        if (!payload || payload === "[DONE]")
+          continue;
+        let event;
+        try {
+          event = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+        const type = String(event?.type ?? "");
+        if (PREAMBLE_EVENTS.has(type))
+          continue;
+        if (type === "error" || type === "response.failed") {
+          const err = event.error ?? event.response?.error ?? {};
+          const code = String(err.code ?? event.code ?? "");
+          const errType = String(err.type ?? event.error_type ?? "");
+          const message = String(err.message ?? event.message ?? "Unknown API error");
+          if (isRetryableStreamError(code, errType, message)) {
+            reader.cancel().catch(() => {});
+            return { kind: "retryable", code: code || errType || "unknown", message };
+          }
+          return { kind: "clean", response: replayResponse() };
+        }
+        return { kind: "clean", response: replayResponse() };
+      }
+    }
+  } catch (error46) {
+    logMsg(`[StreamSniff] read failed (${error46}) \u2014 handing stream to parser`);
+    return { kind: "clean", response: replayResponse() };
+  }
+}
+var DEFAULT_SNIFF_BUDGET_MS = 12000, PREAMBLE_EVENTS, RETRYABLE_ERROR_CODES, RETRYABLE_ERROR_TYPES;
+var init_stream_head_sniffer = __esm(() => {
+  PREAMBLE_EVENTS = new Set(["response.created", "response.in_progress"]);
+  RETRYABLE_ERROR_CODES = new Set([
+    "server_is_overloaded",
+    "server_error",
+    "internal_error",
+    "internal_server_error",
+    "rate_limit_exceeded",
+    "overloaded",
+    "slow_down"
+  ]);
+  RETRYABLE_ERROR_TYPES = new Set([
+    "service_unavailable_error",
+    "overloaded_error",
+    "api_error"
+  ]);
+});
+
 // src/handlers/shared/stream-parsers/anthropic-sse.ts
 function createAnthropicPassthroughStream(c, response, opts) {
   const encoder = new TextEncoder;
@@ -38130,6 +38264,11 @@ data: ${JSON.stringify(data)}
 `));
         }
       };
+      const safeClose = () => {
+        try {
+          controller.close();
+        } catch {}
+      };
       const closeReasoning = () => {
         if (reasoningIdx >= 0) {
           send("content_block_stop", { type: "content_block_stop", index: reasoningIdx });
@@ -38352,7 +38491,7 @@ data: ${JSON.stringify(data)}
                 }
                 if (opts.onTokenUpdate)
                   opts.onTokenUpdate(inputTokens, outputTokens);
-                controller.close();
+                safeClose();
                 return;
               }
             } catch (parseError) {
@@ -38380,7 +38519,7 @@ data: ${JSON.stringify(data)}
         isClosed = true;
         if (opts.onTokenUpdate)
           opts.onTokenUpdate(inputTokens, outputTokens);
-        controller.close();
+        safeClose();
       } catch (error46) {
         if (pingInterval) {
           clearInterval(pingInterval);
@@ -38416,9 +38555,7 @@ data: ${JSON.stringify(data)}
           isClosed = true;
           if (opts.onTokenUpdate)
             opts.onTokenUpdate(inputTokens, outputTokens);
-          try {
-            controller.close();
-          } catch {}
+          safeClose();
         }
       }
     },
@@ -39031,6 +39168,35 @@ class ComposedHandler {
     if (droppedParams.length > 0) {
       c.header("X-Dropped-Params", droppedParams.join(", "));
     }
+    if (this.resolveStreamFormat() === "openai-responses-sse") {
+      const settled = await this.settleResponsesStreamHead(response, () => this.provider.enqueueRequest ? this.provider.enqueueRequest(doFetch) : doFetch());
+      if (settled.kind === "exhausted") {
+        const waited = STREAM_RETRY_DELAYS_MS.slice(0, settled.attempts).reduce((sum, ms) => sum + ms, 0);
+        const surfaced = `${this.provider.displayName} is overloaded upstream (${settled.code}): ${settled.message} ` + `claudish retried ${settled.attempts}\xD7 over ${Math.round(waited / 1000)}s without success.`;
+        logStderr(`Error: ${surfaced}`);
+        try {
+          recordStats({
+            model_id: this.targetModel,
+            provider_name: this.provider.name,
+            stream_format: this.provider.streamFormat,
+            latency_ms: Math.round(performance.now() - startTime),
+            success: false,
+            http_status: 503,
+            error_class: "server_error",
+            error_code: settled.code,
+            token_strategy: this.options.tokenStrategy ?? "standard",
+            adapter_name: this.getActiveAdapterName(),
+            middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
+            fallback_used: fallbackMeta !== undefined,
+            fallback_chain: fallbackMeta?.chain,
+            fallback_attempts: fallbackMeta?.attempts,
+            invocation_mode: this.options.invocationMode ?? "auto-route"
+          });
+        } catch {}
+        return c.json(wrapAnthropicError(503, surfaced, "overloaded_error"), 503);
+      }
+      response = settled.response;
+    }
     latencyMs = Math.round(performance.now() - startTime);
     const httpStatus = response.status;
     let streamApiError = null;
@@ -39062,6 +39228,52 @@ class ComposedHandler {
       streamApiError = { code, message };
     });
   }
+  async settleResponsesStreamHead(initial, reissue) {
+    let response = initial;
+    for (let attempt = 0;; attempt++) {
+      const verdict = await sniffResponsesStreamHead(response, { log });
+      if (verdict.kind === "clean")
+        return { kind: "ok", response: verdict.response };
+      const delayMs = STREAM_RETRY_DELAYS_MS[attempt];
+      if (delayMs === undefined) {
+        log(`[${this.provider.displayName}] in-stream ${verdict.code} persisted after ` + `${attempt} retries \u2014 surfacing 503 so the client can retry`);
+        return {
+          kind: "exhausted",
+          code: verdict.code,
+          message: verdict.message,
+          attempts: attempt
+        };
+      }
+      log(`[${this.provider.displayName}] in-stream ${verdict.code} before any output \u2014 ` + `retry ${attempt + 1}/${STREAM_RETRY_DELAYS_MS.length} in ${delayMs / 1000}s`);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      let next;
+      try {
+        next = await reissue();
+      } catch (error46) {
+        log(`[${this.provider.displayName}] retry fetch failed: ${error46}`);
+        return {
+          kind: "exhausted",
+          code: verdict.code,
+          message: `${verdict.message} (retry could not reach the provider: ${error46})`,
+          attempts: attempt + 1
+        };
+      }
+      if (!next.ok) {
+        const body = await next.text().catch(() => "");
+        log(`[${this.provider.displayName}] retry returned HTTP ${next.status}`);
+        return {
+          kind: "exhausted",
+          code: `http_${next.status}`,
+          message: body.slice(0, 500) || `HTTP ${next.status}`,
+          attempts: attempt + 1
+        };
+      }
+      response = next;
+    }
+  }
+  resolveStreamFormat() {
+    return this.provider.overrideStreamFormat?.() ?? this.explicitAdapter?.getStreamFormat() ?? this.modelAdapter?.getStreamFormat() ?? this.getAdapter().getStreamFormat();
+  }
   handleStream(c, response, adapter, claudeRequest, toolNameMap, onComplete, onApiError) {
     let pendingOnComplete = onComplete;
     const onTokenUpdate = (input, output) => {
@@ -39087,7 +39299,7 @@ class ComposedHandler {
         pendingOnComplete = undefined;
       }
     };
-    const streamFormat = this.provider.overrideStreamFormat?.() ?? this.explicitAdapter?.getStreamFormat() ?? this.modelAdapter?.getStreamFormat() ?? this.getAdapter().getStreamFormat();
+    const streamFormat = this.resolveStreamFormat();
     const priorInputTokens = this.tokenTracker.getLastInputTokens();
     switch (streamFormat) {
       case "openai-sse":
@@ -39191,6 +39403,7 @@ function getRecoveryHint(status, errorText, providerName) {
   }
   return `Unexpected HTTP ${status} from ${providerName}.`;
 }
+var STREAM_RETRY_DELAYS_MS;
 var init_composed_handler = __esm(() => {
   init_dialect_manager();
   init_logger();
@@ -39203,6 +39416,7 @@ var init_composed_handler = __esm(() => {
   init_anthropic_error();
   init_connection_error();
   init_openai_compat();
+  init_stream_head_sniffer();
   init_anthropic_sse();
   init_gemini_sse();
   init_ollama_jsonl();
@@ -39210,6 +39424,7 @@ var init_composed_handler = __esm(() => {
   init_openai_responses_sse();
   init_openai_sse();
   init_token_tracker();
+  STREAM_RETRY_DELAYS_MS = [3000, 15000, 30000];
 });
 
 // src/handlers/fallback-handler.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "7.21.0",
+  "version": "7.22.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,10 +60,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "7.21.0",
-    "@claudish/magmux-darwin-x64": "7.21.0",
-    "@claudish/magmux-linux-arm64": "7.21.0",
-    "@claudish/magmux-linux-x64": "7.21.0"
+    "@claudish/magmux-darwin-arm64": "7.22.0",
+    "@claudish/magmux-darwin-x64": "7.22.0",
+    "@claudish/magmux-linux-arm64": "7.22.0",
+    "@claudish/magmux-linux-x64": "7.22.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",