@providerkit/core 0.7.0 → 0.8.0

package/src/retry.ts

@@ -13,12 +13,14 @@
 //
 //  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 } from "./errors.ts";
+import { classify, isBackupEligible, isTransient, parseRetryAfterMs, ProviderError } from "./errors.ts";
 
 export interface RetryOptions {
   /** Total attempts including the first. Default 3. */
   maxAttempts?: number;
   baseDelayMs?: number;
+  /** Maximum acceptable wait. A longer server deadline ends retry so an outer
+   *  fallback can switch provider; it is never shortened to retry too early. */
   maxDelayMs?: number;
   /** Aborts the wait as well as the work, so Stop lands promptly. */
   signal?: AbortSignal;
@@ -67,12 +69,17 @@ export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
   });
 }
 
-/** The delay before the next attempt: the provider's own figure when it gave
- *  one, capped, else full-jitter backoff. */
-function delayFor(err: unknown, attempt: number, opts: RetryOptions): number {
+/** null means the server deadline exceeds this call's wait budget. */
+function delayFor(err: unknown, attempt: number, opts: RetryOptions): number | null {
   const asked = parseRetryAfterMs(err);
   const cap = opts.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  if (asked !== undefined) return Math.min(asked, cap);
+  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;
+  }
   return backoffMs(attempt, opts.baseDelayMs ?? DEFAULT_BASE_DELAY_MS, cap);
 }
 
@@ -101,6 +108,7 @@ export async function withRetry<T>(
       if (opts.signal?.aborted) throw err;
       if (attempt >= maxAttempts || !shouldRetry(err, attempt)) throw err;
       const delayMs = delayFor(err, attempt, opts);
+      if (delayMs === null) throw err;
       opts.onRetry?.({ error: err, attempt, delayMs });
       await nap(delayMs, opts.signal);
     }
@@ -149,6 +157,7 @@ export async function* withStreamRetry<T>(
       // Rule 2: past the first chunk there is no going back.
       if (emitted || attempt >= maxAttempts || !shouldRetry(err, attempt)) throw err;
       const delayMs = delayFor(err, attempt, opts);
+      if (delayMs === null) throw err;
       opts.onRetry?.({ error: err, attempt, delayMs });
       await nap(delayMs, opts.signal);
     } finally {

package/src/transport.ts

@@ -4,7 +4,8 @@
 //
 // Adapters keep only their per-event mapping; everything about being an HTTP
 // client lives here once.
-import { classifyHttp, isTransportFailure, ProviderError } from "./errors.ts";
+import { classifyHttp, isTransportFailure, parseRetryAfterMs, ProviderError } from "./errors.ts";
+import { parseRateLimitResponse } from "./rate-limit.ts";
 
 export interface RequestInit_ {
   url: string;
@@ -63,12 +64,14 @@ export function retryAfterFromHeaders(headers: Headers, now = Date.now()): numbe
 async function errorFor(provider: string, res: Response): Promise<ProviderError> {
   const text = await res.text().catch(() => "");
   const kind = classifyHttp(res.status, text);
+  const reset = parseRateLimitResponse(res.headers, text);
   const message = text
     ? `${provider} ${res.status}: ${text.slice(0, 500)}`
     : `${provider} ${res.status} ${res.statusText}`;
   return new ProviderError(provider, kind, message, {
     status: res.status,
-    retryAfterMs: retryAfterFromHeaders(res.headers),
+    ...reset,
+    retryAfterMs: retryAfterFromHeaders(res.headers) ?? parseRetryAfterMs({}, text),
     body: text.slice(0, 2_000) || undefined,
   });
 }

package/src/types.ts

@@ -139,6 +139,9 @@ export const EMPTY_USAGE: TokenUsage = {
 /** Normalized streaming chunk — every provider's shape collapses into this. */
 export interface ProviderChunk {
   type: "delta" | "usage" | "finish";
+  /** The selected endpoint and model when a fallback provider emits this chunk.
+   *  Per-call metadata, never shared mutable state on the provider object. */
+  source?: { provider: string; model: string };
   content?: string;
   reasoning?: string;
   /** OpenRouter's normalized reasoning payload — hand it back on the next
@@ -230,6 +233,8 @@ export interface Provider {
 
 export interface Completion {
   text: string;
+  /** Present when the stream identifies the endpoint that answered. */
+  provider?: string;
   reasoning: string;
   /** Present only where the provider sent one. See ChatMessage.reasoningDetails. */
   reasoningDetails?: unknown[];
@@ -253,7 +258,9 @@ export async function drainStream(
   let reasoningDetails: unknown[] | undefined;
   let usage: TokenUsage = EMPTY_USAGE;
   let finishReason: FinishReason | null = null;
+  let source: ProviderChunk["source"];
   for await (const chunk of stream) {
+    if (chunk.source) source = chunk.source;
     if (chunk.type === "delta") {
       if (chunk.content) text += chunk.content;
       if (chunk.reasoning) reasoning += chunk.reasoning;
@@ -270,7 +277,8 @@ export async function drainStream(
     ...(reasoningDetails ? { reasoningDetails } : {}),
     usage,
     finishReason,
-    model,
+    model: source?.model ?? model,
+    ...(source ? { provider: source.provider } : {}),
   };
 }