@t2000/engine 0.46.4 → 0.46.5

package/dist/index.d.ts

@@ -1598,13 +1598,17 @@ interface AnthropicProviderConfig {
     apiKey: string;
     defaultModel?: string;
     defaultMaxTokens?: number;
+    /** Max retry attempts for retriable errors (overloaded, rate-limited, network). Default 3. */
+    maxRetries?: number;
 }
 declare class AnthropicProvider implements LLMProvider {
     private client;
     private defaultModel;
     private defaultMaxTokens;
+    private maxRetries;
     constructor(config: AnthropicProviderConfig);
     chat(params: ChatParams): AsyncGenerator<ProviderEvent>;
+    private streamOnce;
 }
 
 declare const CANVAS_TEMPLATES: readonly ["activity_heatmap", "portfolio_timeline", "yield_projector", "health_simulator", "dca_planner", "spending_breakdown", "watch_address", "full_portfolio"];

package/dist/index.js

@@ -5729,16 +5729,51 @@ function adaptAllServerTools(manager, serverConfigs) {
 }
 var DEFAULT_MODEL = "claude-sonnet-4-20250514";
 var DEFAULT_MAX_TOKENS2 = 4096;
+var DEFAULT_MAX_RETRIES = 3;
+var RETRY_BASE_DELAY_MS = 1e3;
+var RETRY_MAX_DELAY_MS = 8e3;
 var AnthropicProvider = class {
   client;
   defaultModel;
   defaultMaxTokens;
+  maxRetries;
   constructor(config) {
     this.client = new Anthropic({ apiKey: config.apiKey });
     this.defaultModel = config.defaultModel ?? DEFAULT_MODEL;
     this.defaultMaxTokens = config.defaultMaxTokens ?? DEFAULT_MAX_TOKENS2;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
   }
   async *chat(params) {
+    let attempt = 0;
+    while (true) {
+      let yieldedAnything = false;
+      const inner = this.streamOnce(params);
+      try {
+        for (; ; ) {
+          const next = await inner.next();
+          if (next.done) return;
+          yieldedAnything = true;
+          yield next.value;
+        }
+      } catch (err) {
+        try {
+          await inner.return?.(void 0);
+        } catch {
+        }
+        if (!yieldedAnything && isRetriableError(err) && attempt < this.maxRetries) {
+          attempt++;
+          const delayMs = computeBackoffMs(attempt);
+          console.warn(
+            `[anthropic] retriable error (attempt ${attempt}/${this.maxRetries}, retrying in ${delayMs}ms): ${rawErrorMessage(err)}`
+          );
+          await sleep(delayMs);
+          continue;
+        }
+        throw new Error(friendlyErrorMessage(err));
+      }
+    }
+  }
+  async *streamOnce(params) {
     const messages = sanitizeAnthropicMessages(
       params.messages.map(toAnthropicMessage)
     );
@@ -5895,6 +5930,59 @@ var AnthropicProvider = class {
     }
   }
 };
+function isRetriableError(err) {
+  if (!err) return false;
+  if (err instanceof Anthropic.APIError) {
+    if (err.status === 529 || err.status === 408) return true;
+    if (err.status === 502 || err.status === 503 || err.status === 504) return true;
+    if (err.status === 429) return true;
+    return false;
+  }
+  const msg = rawErrorMessage(err).toLowerCase();
+  if (msg.includes("overloaded_error") || msg.includes('"overloaded"') || msg.includes("rate_limit_error") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("socket hang up") || msg.includes("fetch failed") || msg.includes("network error")) {
+    return true;
+  }
+  return false;
+}
+function rawErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function friendlyErrorMessage(err) {
+  const msg = rawErrorMessage(err).toLowerCase();
+  if (msg.includes("overloaded_error") || msg.includes('"overloaded"') || err instanceof Anthropic.APIError && err.status === 529) {
+    return "Anthropic's servers are over capacity right now. Please try again in 30 seconds.";
+  }
+  if (msg.includes("rate_limit_error") || err instanceof Anthropic.APIError && err.status === 429) {
+    return "Too many requests in a short window. Please wait a moment and try again.";
+  }
+  if (msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("socket hang up") || msg.includes("fetch failed") || msg.includes("network error")) {
+    return "Couldn't reach Anthropic. Check your connection and try again.";
+  }
+  if (err instanceof Anthropic.APIError && err.status === 401) {
+    return "Authentication failed. Please check the Anthropic API key configuration.";
+  }
+  if (err instanceof Anthropic.APIError && err.status === 400) {
+    return "The request was rejected by Anthropic. This is likely a bug \u2014 please retry, and if it persists, contact support.";
+  }
+  if (err instanceof Anthropic.APIError && err.status >= 500) {
+    return "Anthropic returned a server error. Please try again in a moment.";
+  }
+  return "Something went wrong. Please try again.";
+}
+function computeBackoffMs(attempt) {
+  const base = Math.min(RETRY_BASE_DELAY_MS * 2 ** (attempt - 1), RETRY_MAX_DELAY_MS);
+  const jitter = Math.floor(Math.random() * 250);
+  return base + jitter;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function toAnthropicSystem(prompt) {
   if (typeof prompt === "string") return prompt;
   return prompt.map((block) => ({