@providerkit/core 0.9.0 → 0.10.1

package/src/fallback.ts

@@ -6,16 +6,17 @@ import { createPresetProvider, type PresetProviderConfig } from "./providers/fac
 
 /** Retry intervals when the server supplies no deadline, not estimates of when
  *  it will recover. A server deadline always wins over these defaults. */
-export const DEFAULT_FALLBACK_COOLDOWNS: Readonly<Partial<Record<ErrorKind, number>>> = Object.freeze({
-  rate: 60_000,
-  quota: 3_600_000,
-  timeout: 30_000,
-  network: 30_000,
-  overload: 30_000,
-  auth: 3_600_000,
-  entitlement: 3_600_000,
-  model: 3_600_000,
-});
+export const DEFAULT_FALLBACK_COOLDOWNS: Readonly<Partial<Record<ErrorKind, number>>> =
+  Object.freeze({
+    rate: 60_000,
+    quota: 3_600_000,
+    timeout: 30_000,
+    network: 30_000,
+    overload: 30_000,
+    auth: 3_600_000,
+    entitlement: 3_600_000,
+    model: 3_600_000,
+  });
 
 export interface FallbackOptions<T> {
   /** Per-kind intervals in ms; null stops fallback for that kind. Adding a kind
@@ -89,10 +90,15 @@ export class NoAvailableProviderError extends ProviderError {
   readonly retryAtMs: number;
 
   constructor(retryAtMs: number, now: number) {
-    super("fallback", "rate", "All configured providers are unavailable. Retry after the cooldown.", {
-      resetAtMs: retryAtMs,
-      retryAfterMs: Math.max(0, retryAtMs - now),
-    });
+    super(
+      "fallback",
+      "rate",
+      "All configured providers are unavailable. Retry after the cooldown.",
+      {
+        resetAtMs: retryAtMs,
+        retryAfterMs: Math.max(0, retryAtMs - now),
+      },
+    );
     this.name = "NoAvailableProviderError";
     this.retryAtMs = retryAtMs;
   }
@@ -107,14 +113,20 @@ export class FallbackPool<T> {
   private readonly cooldowns = new Map<T, Cooldown>();
   private readonly now: () => number;
 
-  constructor(candidates: readonly T[], private readonly options: FallbackOptions<T> = {}) {
-    if (candidates.length === 0) throw new Error("providerkit: supply a primary before its backups");
+  constructor(
+    candidates: readonly T[],
+    private readonly options: FallbackOptions<T> = {},
+  ) {
+    if (candidates.length === 0)
+      throw new Error("providerkit: supply a primary before its backups");
     if (new Set(candidates).size !== candidates.length) {
       throw new Error("providerkit: each fallback candidate must appear only once");
     }
     for (const value of Object.values(options.cooldownMs ?? {})) {
       if (value !== null && value !== undefined && (!Number.isFinite(value) || value < 0)) {
-        throw new Error("providerkit: fallback cooldowns must be finite, non-negative milliseconds");
+        throw new Error(
+          "providerkit: fallback cooldowns must be finite, non-negative milliseconds",
+        );
       }
     }
     this.candidates = [...candidates];
@@ -128,7 +140,13 @@ export class FallbackPool<T> {
     else this.cooldowns.delete(selection[0]);
   }
 
-  status(): Array<{ candidate: T; retryAtMs: number; probing: boolean; kind?: ErrorKind; window?: RateLimitWindow }> {
+  status(): Array<{
+    candidate: T;
+    retryAtMs: number;
+    probing: boolean;
+    kind?: ErrorKind;
+    window?: RateLimitWindow;
+  }> {
     return this.candidates.map((candidate) => ({
       candidate,
       retryAtMs: 0,
@@ -138,10 +156,14 @@ export class FallbackPool<T> {
   }
 
   /** Buffered calls only: do not wrap an agent turn that has run side effects. */
-  async with<R>(attempt: (candidate: T, signal: AbortSignal) => Promise<R>, signal?: AbortSignal): Promise<R> {
+  async with<R>(
+    attempt: (candidate: T, signal: AbortSignal) => Promise<R>,
+    signal?: AbortSignal,
+  ): Promise<R> {
     for await (const result of this.stream(async function* (candidate, inner) {
       yield await attempt(candidate, inner);
-    }, signal)) return result;
+    }, signal))
+      return result;
     throw new Error("providerkit: fallback attempt ended without a result");
   }
 
@@ -218,7 +240,9 @@ export class FallbackPool<T> {
     if (hasFailed) throw lastError;
     // If all expired candidates are already being probed, the next opportunity
     // is now. Other callers need not wait for those probes or start duplicates.
-    const retryAtMs = Math.min(...this.status().map((entry) => Math.max(this.now(), entry.retryAtMs)));
+    const retryAtMs = Math.min(
+      ...this.status().map((entry) => Math.max(this.now(), entry.retryAtMs)),
+    );
     throw new NoAvailableProviderError(retryAtMs, this.now());
   }
 }
@@ -245,7 +269,11 @@ export function withFallbackProviders(
       return fallbacks.stream(async function* (provider, signal): AsyncGenerator<ProviderChunk> {
         const { model: override, ...rest } = opts;
         const model = provider === primary ? (override ?? provider.model) : provider.model;
-        for await (const chunk of provider.createStream(messages, tools, { ...rest, model, signal })) {
+        for await (const chunk of provider.createStream(messages, tools, {
+          ...rest,
+          model,
+          signal,
+        })) {
           yield { ...chunk, source: chunk.source ?? { provider: provider.id, model } };
         }
       }, opts.signal);

package/src/presets.ts

@@ -111,7 +111,12 @@ export const PROVIDER_PRESETS = {
     baseUrl: "https://openrouter.ai/api",
     auth: "key",
     defaultModel: "deepseek/deepseek-v4.1-flash",
-    models: ["deepseek/deepseek-v4.1-flash", "z-ai/glm-5.3-flash", "x-ai/grok-4.6", "openai/gpt-5.6-luna-pro"],
+    models: [
+      "deepseek/deepseek-v4.1-flash",
+      "z-ai/glm-5.3-flash",
+      "x-ai/grok-4.6",
+      "openai/gpt-5.6-luna-pro",
+    ],
   },
   groq: {
     shape: "openai",
@@ -146,7 +151,10 @@ export const PROVIDER_PRESETS = {
     baseUrl: "https://api.fireworks.ai/inference/v1",
     auth: "key",
     defaultModel: "accounts/fireworks/models/deepseek-v4p1-flash",
-    models: ["accounts/fireworks/models/deepseek-v4p1-flash", "accounts/fireworks/models/glm-5p3-flash"],
+    models: [
+      "accounts/fireworks/models/deepseek-v4p1-flash",
+      "accounts/fireworks/models/glm-5p3-flash",
+    ],
   },
   cerebras: {
     shape: "openai",
@@ -177,6 +185,13 @@ export const PROVIDER_PRESETS = {
     defaultModel: "MiniMax-M3",
     models: ["MiniMax-M3", "MiniMax-M2.7", "MiniMax-M2.5"],
   },
+  "minimax-openai": {
+    shape: "openai",
+    baseUrl: "https://api.minimax.io/v1",
+    auth: "key",
+    defaultModel: "MiniMax-M3",
+    models: ["MiniMax-M3", "MiniMax-M2.7", "MiniMax-M2.5"],
+  },
 
   // ── Popular gateways & cloud providers ──────────────────────────────────
   nvidia: {
@@ -284,6 +299,14 @@ export const PROVIDER_PRESETS = {
     // (`z-ai/glm-5.3-flash`) answers 400 [1211] Unknown Model.
     explicitNone: true,
   },
+  "zai-openai": {
+    shape: "openai",
+    baseUrl: "https://api.z.ai/api/paas/v4",
+    path: "/chat/completions",
+    auth: "key",
+    defaultModel: "glm-5.3-flash",
+    models: ["glm-5.3-flash", "glm-5.3", "glm-5.2"],
+  },
   kimi: {
     shape: "anthropic",
     baseUrl: "https://api.kimi.ai/coding",
@@ -291,6 +314,13 @@ export const PROVIDER_PRESETS = {
     defaultModel: "kimi-for-coding",
     models: ["kimi-for-coding", "kimi-for-coding-highspeed", "k3", "k3-256k"],
   },
+  "kimi-openai": {
+    shape: "openai",
+    baseUrl: "https://api.moonshot.ai/v1",
+    auth: "key",
+    defaultModel: "kimi-k2.7-code",
+    models: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed", "kimi-k3"],
+  },
   /** Alibaba's dashscope coding plan — OpenAI-compatible per its registry. */
   "alibaba-coding-plan": {
     shape: "openai",
@@ -307,6 +337,30 @@ export const PROVIDER_PRESETS = {
     defaultModel: "qwen3.8-max",
     models: ["qwen3.8-max", "qwen3.8-flash", "qwen3.6-flash"],
   },
+  /** QwenCloud's token plan — OpenAI-compatible endpoint. */
+  "qwen-token-plan-openai": {
+    shape: "openai",
+    baseUrl: "https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
+    auth: "bearer",
+    defaultModel: "qwen3.8-max",
+    models: ["qwen3.8-max", "qwen3.8-flash", "qwen3.6-flash"],
+  },
+  /** Alibaba DashScope Platform API — standard pay-as-you-go API key. */
+  alibaba: {
+    shape: "openai",
+    baseUrl: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+    auth: "bearer",
+    defaultModel: "qwen-max",
+    models: ["qwen-max", "qwen-plus", "qwen-turbo", "qwen-flash"],
+  },
+  /** Alias for alibaba (DashScope platform API). */
+  "qwen-api": {
+    shape: "openai",
+    baseUrl: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+    auth: "bearer",
+    defaultModel: "qwen-max",
+    models: ["qwen-max", "qwen-plus", "qwen-turbo", "qwen-flash"],
+  },
 
   // ── Local runtimes ──────────────────────────────────────────────────────
   ollama: {

package/src/providers/anthropic.ts

@@ -1,6 +1,6 @@
 // Anthropic-shape adapter — SSE from POST /v1/messages.
 import { streamError } from "../errors.ts";
-import { schemaPrompt } from "../schema.ts";
+import { schemaPrompt, toAnthropicToolSchema } from "../schema.ts";
 import { parseToolArgs } from "../tool-args.ts";
 import { streamSse, apiUrl } from "../transport.ts";
 import { withConfiguredFallbacks, type ProviderFallbackConfig } from "../fallback.ts";
@@ -249,7 +249,7 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
         request.tools = tools.map((tool) => ({
           name: tool.name,
           description: tool.description,
-          input_schema: tool.inputSchema,
+          input_schema: toAnthropicToolSchema(tool.inputSchema),
         }));
       }
       if (opts.toolChoice && opts.toolChoice !== "auto") {

package/src/providers/gemini.ts

@@ -6,7 +6,7 @@
 // wire rather than @google/genai, because this package ships zero dependencies
 // and the SDK is a Node-shaped one.
 import { streamError } from "../errors.ts";
-import { schemaPrompt } from "../schema.ts";
+import { schemaPrompt, toGeminiToolSchema } from "../schema.ts";
 import { parseToolArgs } from "../tool-args.ts";
 import { streamSse, apiUrl } from "../transport.ts";
 import { withConfiguredFallbacks, type ProviderFallbackConfig } from "../fallback.ts";
@@ -69,6 +69,19 @@ const THINKING_LEVEL: Record<Effort, string> = {
   max: "HIGH",
 };
 
+/**
+ * Gemini 2.x thinking budget dial (tokens).
+ * Gemini 2.5 uses `thinkingBudget` (0 disables thinking), while Gemini 3+ uses
+ * `thinkingLevel` (MINIMAL, LOW, MEDIUM, HIGH).
+ */
+const GEMINI_2_THINKING_BUDGET: Record<Effort, number> = {
+  none: 0,
+  low: 1024,
+  medium: 4096,
+  high: 8192,
+  max: 16384,
+};
+
 /** A turn in Gemini's history. `model` is its word for the assistant. */
 export interface GeminiContent {
   role: "user" | "model";
@@ -261,15 +274,27 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
       const maxTokens = opts.maxTokens ?? config.maxTokens;
       const { system, contents } = toGeminiContents(messages);
 
+      // A model id copied out of Gemini's docs is often already `models/…`, and
+      // the doubled segment 404s as "model not found" — a confusing way to
+      // learn about a prefix.
+      const model = (opts.model ?? config.model).replace(/^models\//, "");
+      const isGemini3 = /gemini-3/i.test(model);
+
       const generationConfig: Record<string, unknown> = {};
       if (maxTokens !== undefined) generationConfig.maxOutputTokens = maxTokens;
       if (opts.temperature !== undefined) generationConfig.temperature = opts.temperature;
       if (opts.topP !== undefined) generationConfig.topP = opts.topP;
       if (opts.stopSequences?.length) generationConfig.stopSequences = opts.stopSequences;
-      // No effort means the model's own dynamic thinking. Sending MINIMAL here
+      // No effort means the model's own dynamic thinking. Sending MINIMAL / 0 here
       // would switch that off for a caller who never asked, which is the whole
       // reason the seam treats an absent effort as "never sent".
-      if (effort) generationConfig.thinkingConfig = { thinkingLevel: THINKING_LEVEL[effort] };
+      // Gemini 3 uses thinkingLevel (MINIMAL..HIGH), while Gemini 2.5 uses
+      // thinkingBudget (0 tokens disables thinking, positive numbers set budget).
+      if (effort) {
+        generationConfig.thinkingConfig = isGemini3
+          ? { thinkingLevel: THINKING_LEVEL[effort] }
+          : { thinkingBudget: GEMINI_2_THINKING_BUDGET[effort] };
+      }
       // A schema that shares its call with tools pins the decoder, and a pinned
       // decoder cannot emit a functionCall — the model narrates the call it
       // could not make and the turn ends, with nothing logged. See
@@ -281,7 +306,7 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
         // `responseJsonSchema` takes JSON Schema as written; `responseSchema`
         // is Gemini's own trimmed dialect and rejects most of what a real
         // schema carries.
-        generationConfig.responseJsonSchema = opts.json.schema;
+        generationConfig.responseJsonSchema = toGeminiToolSchema(opts.json.schema);
       }
 
       const request: Record<string, unknown> = { contents, generationConfig };
@@ -302,7 +327,7 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
               description: tool.description,
               // Same rule as the response schema: `parameters` is the trimmed
               // dialect, `parametersJsonSchema` is the schema we actually wrote.
-              parametersJsonSchema: tool.inputSchema,
+              parametersJsonSchema: toGeminiToolSchema(tool.inputSchema),
             })),
           },
         ];
@@ -312,11 +337,6 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
         if (toolConfig) request.toolConfig = toolConfig;
       }
 
-      // A model id copied out of Gemini's docs is often already `models/…`, and
-      // the doubled segment 404s as "model not found" — a confusing way to
-      // learn about a prefix.
-      const model = (opts.model ?? config.model).replace(/^models\//, "");
-
       // Gemini reports the finish reason on a candidate that can arrive AFTER
       // the chunk carrying the function calls, so a turn's tool use has to be
       // remembered rather than read off the final chunk.

package/src/providers/openai.ts

@@ -83,10 +83,56 @@ export interface OpenAIConfig extends ProviderFallbackConfig {
    * not a lock.
    */
   providerOrder?: string[];
+  /**
+   * Automatically pin OpenRouter calls to the first-party model vendor's host
+   * when hitting openrouter.ai and providerOrder is not passed. Defaults to true.
+   */
+  pinHost?: boolean;
 }
 
 const DEFAULT_BASE_URL = "https://api.openai.com";
 
+/**
+ * Known first-party host slugs on OpenRouter for route pinning.
+ * Pinning keeps consecutive turns on the vendor's own endpoint, preserving
+ * the server-side KV prompt cache across rounds.
+ */
+const OPENROUTER_HOSTS: Record<string, string> = {
+  anthropic: "anthropic",
+  "arcee-ai": "arcee-ai",
+  cohere: "cohere",
+  deepseek: "deepseek",
+  google: "google-ai-studio",
+  meta: "meta",
+  minimax: "minimax",
+  mistralai: "mistral",
+  moonshotai: "moonshotai",
+  morph: "morph",
+  openai: "openai",
+  perplexity: "perplexity",
+  qwen: "alibaba",
+  stepfun: "stepfun",
+  tencent: "tencent",
+  upstage: "upstage",
+  "x-ai": "xai",
+  "z-ai": "z-ai",
+  zai: "z-ai",
+};
+
+export function openRouterHostFor(baseUrl: string, model: string): string | undefined {
+  let host: string;
+  try {
+    host = new URL(baseUrl).hostname;
+  } catch {
+    return undefined;
+  }
+  if (!host.includes("openrouter.ai")) return undefined;
+  const slash = model.indexOf("/");
+  if (slash <= 0) return undefined;
+  const vendor = model.slice(0, slash).toLowerCase();
+  return OPENROUTER_HOSTS[vendor];
+}
+
 /** The spellings of "think this hard" across the dialects that share this
  *  adapter. `off` sends nothing and leaves the model on its own default. */
 export type EffortDialect = "openai" | "openrouter" | "deepseek" | "off";
@@ -96,23 +142,20 @@ export type EffortDialect = "openai" | "openrouter" | "deepseek" | "off";
  *
  * One knob, three incompatible spellings, and the differences are not cosmetic:
  *
- * - **On OpenRouter, a model that must think refuses BOTH off switches.**
- *   `reasoning.enabled: false` is refused by GLM 5.3 Flash with
- *   `400 "Reasoning is mandatory for this endpoint and cannot be disabled."`,
- *   which cost one app its onboarding read, and is why nothing here ever emits
- *   that field. That was then read as "OpenRouter has no off switch" and `none`
- *   was floored to `low` on the strength of it — wrong, because `none` is a
- *   member of OpenRouter's own effort enum and the floor bought a thinking pass
- *   on every turn that asked for none. But the correction over-reached: `none`
- *   is NOT universally safe either. Re-measured 2026-09-09, the same model
- *   answers the same 400 to `effort: "none"`. An unsupported level is mapped to
- *   the nearest only where the model CAN vary its effort; where thinking is
- *   mandatory, `none` is refused outright and the whole call is lost.
- *   The honest way to ask for the least thinking on this dialect is to pass no
- *   effort at all — see `effortParams`, where the numbers live.
+ * - **On OpenRouter, GLM's off switch is the ABSENT field.** Not setting
+ *   `reasoning` at all disables thinking for GLM 5.3 Flash (measured live
+ *   2026-09-14). Naming a level raises it — the accepted values are
+ *   `low`, `high` and `max` (`medium` and `xhigh` are accepted too, but our
+ *   vocabulary has no use for them). `none` is NOT sendable there: the model
+ *   answers
+ *   `400 "Reasoning is mandatory for this endpoint and cannot be disabled."`
+ *   to `reasoning.effort: "none"` exactly as it does to
+ *   `reasoning.enabled: false` — so "do not think" on this dialect is said by
+ *   omitting the field, never by naming a level. See `effortParams`, where the
+ *   numbers live.
  * - **DeepSeek V4 defaults thinking ON**, so `none` has to be an explicit
- *   refusal. That is the case proving OpenRouter's floor is a constraint and
- *   not a preference for always thinking.
+ *   refusal. That is the case proving OpenRouter's absent-field off switch is
+ *   a real dialect fact and not a preference for always thinking.
  * - **OpenAI** takes `reasoning_effort`, and `none` is one of its values — not
  *   the absence of the field. GPT-5.1 both accepted `none` and made it the
  *   default; everything from GPT-5 back still defaults to `medium`. So sending
@@ -122,8 +165,10 @@ export type EffortDialect = "openai" | "openrouter" | "deepseek" | "off";
  *   empty with `finish_reason: "length"`.
  *
  * An absent effort sends nothing on every dialect: the seam's rule is that a
- * knob the caller never touched is a knob the provider still owns. `none` is
- * the caller touching it, and the two must not produce the same request.
+ * knob the caller never touched is a knob the provider still owns. On
+ * OpenRouter that makes `none` and "never asked" the same request — on this
+ * dialect, not thinking IS the default state, so there is no third spelling
+ * to invent.
  */
 export function effortParams(
   dialect: EffortDialect,
@@ -143,31 +188,19 @@ export function effortParams(
         ? { thinking: { type: "enabled" } }
         : { thinking: { type: "enabled" }, reasoning_effort: level };
     case "openrouter":
-      // Its own enum runs xhigh > high > medium > low > minimal > none, so `max`
-      // has a real tier here and clamping it to `high` throws the top one away —
-      // 0.95 of the budget against 0.8.
-      //
-      // CAUTION, measured 2026-09-09 against z-ai/glm-5.3-flash: the claim that
-      // "OpenRouter maps an unsupported level to its nearest rather than
-      // refusing" does NOT hold for `none`. That model answers
-      // `400 "Reasoning is mandatory for this endpoint and cannot be disabled."`
-      // to `reasoning.effort: "none"` exactly as it does to
-      // `reasoning.enabled: false` — so on a model that must think, `none` is a
-      // refusal and not a floor. Callers that mean "as little as possible"
-      // should pass no effort at all rather than `none`, which is why the
-      // absent-effort branch above stays load-bearing.
+      // GLM's off switch here is the ABSENT field (measured live 2026-09-14:
+      // omit `reasoning` → thinking disabled for glm-5.3-flash), so `none`
+      // sends nothing — the same request as a caller who never asked, which on
+      // this dialect is the same state. Naming a level RAISES it: the accepted
+      // values are low, high and max (`medium` and `xhigh` exist on the wire
+      // The refusal that once looked like "OpenRouter cannot be told not to
+      // think" was `reasoning.enabled: false` — a different field, never sent
+      // (pinned by the test below).
       //
-      // Same measurement, same model, one structured-output call three ways:
-      //
-      //   no reasoning field    4,1s   ·    1 reasoning token
-      //   effort "minimal"     46,6s   ·  474 reasoning tokens
-      //   max_tokens 2000      30,3s   ·  484 reasoning tokens
-      //
-      // Its default sat below every level on offer, so naming one RAISED the
-      // thinking — an effort is a request, never a cap. Nearly all of the extra
-      // time was spent before the first token arrived, so it does not show up as
-      // slow streaming; it shows up as a call that looks hung.
-      return { reasoning: { effort: effort === "max" ? "xhigh" : (level ?? "none") } };
+      // `max` rides verbatim here — the enum clamp below is DeepSeek/OpenAI's
+      // shape (DeepSeek auto-bumps past its own top, OpenAI's top IS high);
+      // OpenRouter takes `max` as named (measured live 2026-09-14).
+      return effort === "none" ? {} : { reasoning: { effort } };
     case "openai":
       return { reasoning_effort: level ?? "none" };
     case "off":
@@ -316,10 +349,11 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
       opts: StreamOptions = {},
     ): AsyncIterable<ProviderChunk> {
       const effort = opts.effort ?? config.effort;
+      const model = opts.model ?? config.model;
 
       const body = toOpenAIMessages(messages);
       const request: Record<string, unknown> = {
-        model: opts.model ?? config.model,
+        model,
         messages: body,
         stream: true,
         // Without this the usage record never arrives and every call costs
@@ -398,8 +432,17 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
           body.push({ role: "system", content: schemaPrompt(opts.json.schema) });
         }
       }
-      if (config.providerOrder?.length) {
-        request.provider = { order: config.providerOrder, allow_fallbacks: true };
+      const pinOrder = config.providerOrder?.length
+        ? config.providerOrder
+        : config.pinHost !== false
+          ? (() => {
+              const pinned = openRouterHostFor(baseUrl, model);
+              return pinned ? [pinned] : undefined;
+            })()
+          : undefined;
+
+      if (pinOrder?.length) {
+        request.provider = { order: pinOrder, allow_fallbacks: true };
       }
 
       const defaultPath = /\/v\d+[^/]*$/i.test(baseUrl.replace(/\/+$/, ""))

package/src/retry.ts

@@ -13,7 +13,13 @@
 //
 //  3. Honour the provider's own number. When it says `Retry-After: 30`, a
 //     one-second backoff is three wasted attempts before the same wait.
-import { classify, isBackupEligible, isTransient, parseRetryAfterMs, ProviderError } from "./errors.ts";
+import {
+  classify,
+  isBackupEligible,
+  isRetryable,
+  parseRetryAfterMs,
+  ProviderError,
+} from "./errors.ts";
 
 export interface RetryOptions {
   /** Total attempts including the first. Default 3. */
@@ -73,9 +79,10 @@ export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
 function delayFor(err: unknown, attempt: number, opts: RetryOptions): number | null {
   const asked = parseRetryAfterMs(err);
   const cap = opts.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  const resetWait = err instanceof ProviderError && err.resetAtMs !== undefined
-    ? Math.max(0, err.resetAtMs - Date.now())
-    : undefined;
+  const resetWait =
+    err instanceof ProviderError && err.resetAtMs !== undefined
+      ? Math.max(0, err.resetAtMs - Date.now())
+      : undefined;
   if (asked !== undefined || resetWait !== undefined) {
     const wait = Math.max(asked ?? 0, resetWait ?? 0);
     return wait > cap ? null : wait;
@@ -83,7 +90,7 @@ function delayFor(err: unknown, attempt: number, opts: RetryOptions): number | n
   return backoffMs(attempt, opts.baseDelayMs ?? DEFAULT_BASE_DELAY_MS, cap);
 }
 
-const defaultShouldRetry = (err: unknown): boolean => isTransient(classify(err));
+const defaultShouldRetry = (err: unknown, _attempt: number): boolean => isRetryable(err);
 
 /**
  * Run `fn`, retrying transient failures with backoff. For one-shot calls —