llm-retry-kit 0.2.1 → 0.4.0

package/README.md

@@ -9,8 +9,9 @@
 
 Small resilience layer for production LLM calls. `llm-retry-kit` gives you
 provider-aware retries, fallback chains, jittered exponential backoff,
-`Retry-After` handling, budget tracking, cancellation, timeouts, and
-observability hooks without runtime dependencies.
+`Retry-After` handling, streaming retries, circuit breakers, adaptive hedged
+requests, rolling budget windows, cancellation, timeouts, and observability
+hooks without runtime dependencies.
 
 ```bash
 npm install llm-retry-kit
@@ -42,6 +43,15 @@ and `llm-retry-kit` manages the reliability policy around it.
   `shouldFallback`.
 - Track token usage and estimated cost.
 - Use custom input/output token pricing through `costCalculator`.
+- Wrap streaming responses with retry-before-first-chunk safety.
+- Track partial stream token usage from provider events.
+- Skip unhealthy providers with `CircuitBreaker`.
+- Set timeout budgets per provider/model.
+- Start hedged requests to reduce tail latency.
+- Adapt hedge delays from recent provider latency with `AdaptiveHedgeDelay`.
+- Enforce rolling cost windows with `GlobalBudgetTracker`.
+- Await async stream chunk hooks while protecting the stream from hook errors.
+- Pass request `meta` and `payload` through every context for logging.
 - Abort long calls and retry sleeps with `AbortSignal` or `timeoutMs`.
 - Observe attempts, retries, success, failure, and budget events.
 - Strict TypeScript types.
@@ -169,6 +179,193 @@ console.log({
 })
 ```
 
+## Streaming
+
+OpenAI and Anthropic both expose streaming APIs, but their event formats and
+resume behavior are provider-specific. `llm-retry-kit` therefore keeps the
+stream wrapper provider-agnostic and conservative:
+
+- By default, it retries only if the stream fails before the first chunk.
+- After a chunk has been yielded, retrying could duplicate output, so it stops
+  unless you explicitly set `retryMode: 'always'`.
+- Token usage can be tracked from stream events with `getChunkUsage`.
+- Use `chunkUsageMode: 'cumulative'` for providers that send cumulative usage
+  snapshots during a stream.
+
+```ts
+import { llmRetryStream } from 'llm-retry-kit'
+
+const result = llmRetryStream({
+  stream: async ({ signal }) => {
+    const stream = await openai.responses.create({
+      model: 'gpt-4o-mini',
+      input: 'Write a short incident summary.',
+      stream: true,
+    }, { signal })
+
+    return stream
+  },
+  retryMode: 'before-first-chunk',
+  getChunkUsage: (event) => {
+    if (!('usage' in event) || !event.usage) return undefined
+
+    return {
+      promptTokens: event.usage.input_tokens ?? 0,
+      completionTokens: event.usage.output_tokens ?? 0,
+      totalTokens: event.usage.total_tokens ?? 0,
+    }
+  },
+  chunkUsageMode: 'cumulative',
+})
+
+for await (const event of result.stream) {
+  // Send provider events to your UI, parser, or SSE response.
+}
+
+console.log(result.getStats())
+```
+
+## Advanced Production Controls
+
+### Circuit Breaker
+
+Keep one `CircuitBreaker` instance per provider/model at application scope. Do
+not create the breaker inline inside a request handler; its state must survive
+between calls. If the failure threshold is reached inside the time window,
+later calls skip that provider until the cooldown expires.
+
+```ts
+import { CircuitBreaker, llmRetry } from 'llm-retry-kit'
+
+const openaiBreaker = new CircuitBreaker({
+  failureThreshold: 5,
+  windowMs: 60_000,
+  cooldownMs: 120_000,
+})
+
+await llmRetry({
+  providers: [
+    {
+      name: 'openai:gpt-4o-mini',
+      fn: callOpenAI,
+      circuitBreaker: openaiBreaker,
+    },
+    {
+      name: 'anthropic:claude-sonnet',
+      fn: callAnthropic,
+    },
+  ],
+})
+```
+
+### Per-Provider Timeout
+
+Use global `timeoutMs` for the whole workflow and provider `timeoutMs` for a
+single attempt.
+
+```ts
+await llmRetry({
+  providers: [
+    { name: 'openai:fast', fn: callOpenAI, timeoutMs: 3_000, maxRetries: 1 },
+    { name: 'anthropic:steady', fn: callAnthropic, timeoutMs: 10_000 },
+  ],
+  timeoutMs: 30_000,
+})
+```
+
+### Hedged Requests
+
+Hedging starts the next provider in parallel if the current provider has not
+answered after `hedgeDelayMs`. The first successful response wins and the
+slower request is aborted through the context signal.
+
+```ts
+await llmRetry({
+  providers: [
+    { name: 'primary', fn: callPrimary },
+    { name: 'hedge', fn: callBackup },
+  ],
+  hedgeDelayMs: 750,
+})
+```
+
+Hedging is best for latency-sensitive read paths. It can increase provider
+traffic, so pair it with budget tracking and conservative delay values.
+
+### Adaptive Hedging
+
+Use `AdaptiveHedgeDelay` when fixed hedge delays are too brittle. It records
+recent latency samples per provider and uses the configured percentile as the
+next hedge delay. Keep the instance at application scope so the latency history
+survives between requests.
+
+```ts
+import { AdaptiveHedgeDelay, llmRetry } from 'llm-retry-kit'
+
+const adaptiveHedge = new AdaptiveHedgeDelay({
+  sampleSize: 100,
+  percentile: 0.95,
+  minSamples: 10,
+  minDelayMs: 250,
+  maxDelayMs: 5_000,
+})
+
+await llmRetry({
+  providers: [
+    { name: 'openai:gpt-4o-mini', fn: callOpenAI },
+    { name: 'anthropic:claude-sonnet', fn: callAnthropic },
+  ],
+  hedgeDelayStrategy: adaptiveHedge,
+})
+```
+
+If there are not enough samples yet, no hedge is fired unless you set
+`defaultDelayMs`.
+
+### Rolling Global Budget
+
+`maxCostUSD` limits a single retry workflow. `GlobalBudgetTracker` limits the
+total spend across many calls inside a rolling time window. Keep one instance at
+application scope.
+
+```ts
+import { GlobalBudgetTracker, llmRetry } from 'llm-retry-kit'
+
+const globalBudget = new GlobalBudgetTracker({
+  maxCostUSD: 5,
+  windowMs: 60_000,
+})
+
+await llmRetry({
+  fn: callModel,
+  globalBudget,
+  costCalculator: calculateRealProviderCost,
+})
+```
+
+When the rolling window is exhausted, new attempts fail before the provider is
+called. In-flight non-streaming calls can still finish because final usage is
+known only after the provider returns. Streaming calls are checked as chunk
+usage is reported.
+
+### Metadata And Payload Tracking
+
+Attach request metadata once and it flows into provider calls and hooks.
+
+```ts
+await llmRetry({
+  fn: callModel,
+  meta: { requestId: 'req_123', tenant: 'acme' },
+  payload: { prompt: 'Classify this ticket', userId: 'user_42' },
+  onAttempt: (context) => {
+    console.log(context.meta, context.payload)
+  },
+  onFailure: (error, context) => {
+    console.error(context.meta, error)
+  },
+})
+```
+
 ## Simple Fallback API
 
 For smaller apps, `fn` plus `fallback` is still supported.
@@ -298,8 +495,8 @@ await llmRetry({
   onSuccess: (context) => {
     console.log(`Cost so far: $${context.totalCostUSD}`)
   },
-  onFailure: (error) => {
-    console.error(error)
+  onFailure: (error, context) => {
+    console.error(context.meta, error)
   },
 })
 ```
@@ -315,18 +512,23 @@ await llmRetry({
 | `providers` | `RetryProvider<T>[]` | optional | Explicit provider/model chain. |
 | `maxRetries` | `number` | `3` | Retries after the first attempt. |
 | `maxCostUSD` | `number` | optional | Maximum tracked cost before later attempts stop. |
+| `globalBudget` | `GlobalBudgetTracker` | optional | Shared rolling cost budget across calls. |
 | `costPer1kTokens` | `number` | `0.002` | Simple cost estimate. |
 | `costCalculator` | `(usage, context) => number` | optional | Custom cost calculation. |
 | `initialDelayMs` | `number` | `1000` | Initial retry delay. |
 | `maxDelayMs` | `number` | `30000` | Maximum retry delay. |
 | `timeoutMs` | `number` | optional | Abort wrapper after this time. |
+| `hedgeDelayMs` | `number` | optional | Start the next provider after this delay if the current provider is still pending. |
+| `hedgeDelayStrategy` | `AdaptiveHedgeDelay` | optional | Compute hedge delay from recent provider latency. |
 | `signal` | `AbortSignal` | optional | External cancellation signal. |
+| `meta` | `unknown` | optional | User metadata copied into attempt/failure contexts. |
+| `payload` | `unknown` | optional | Request payload copied into attempt/failure contexts. |
 | `shouldRetry` | `(error, context) => boolean \| Promise<boolean>` | optional | Override retry decisions. |
 | `shouldFallback` | `(error, context) => boolean \| Promise<boolean>` | optional | Override provider fallback decisions. |
 | `onAttempt` | `(context) => void` | optional | Called before each attempt. |
 | `onRetry` | `(attempt, error, delayMs, context) => void` | optional | Called before retry wait. |
 | `onSuccess` | `(context) => void` | optional | Called after a successful response. |
-| `onFailure` | `(error) => void` | optional | Called before final failure is thrown. |
+| `onFailure` | `(error, context) => void` | optional | Called before final failure is thrown. |
 | `onBudgetExceeded` | `(spentUSD, limitUSD) => void` | optional | Called when budget is exhausted. |
 
 ### `RetryProvider<T>`
@@ -336,11 +538,76 @@ await llmRetry({
   name: string
   fn: (context: RetryAttemptContext) => Promise<LLMResponse<T>>
   maxRetries?: number
+  timeoutMs?: number
+  hedgeDelayMs?: number
+  hedgeDelayStrategy?: AdaptiveHedgeDelay
+  circuitBreaker?: CircuitBreaker
   costPer1kTokens?: number
   costCalculator?: (usage, context) => number
 }
 ```
 
+### `llmRetryStream(options)`
+
+Returns `{ stream, getStats }`. The request begins when the returned async
+iterable is consumed.
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `stream` | `(context) => AsyncIterable<TChunk> \| Promise<AsyncIterable<TChunk>>` | optional | Primary stream call for the simple API. |
+| `fallbackStream` | `(context) => AsyncIterable<TChunk> \| Promise<AsyncIterable<TChunk>>` | optional | Backup stream call. |
+| `providers` | `StreamRetryProvider<TChunk>[]` | optional | Explicit stream provider chain. |
+| `retryMode` | `'before-first-chunk' \| 'always' \| 'never'` | `'before-first-chunk'` | Controls whether interrupted streams are retried. |
+| `getChunkUsage` | `(chunk, context) => TokenUsage \| undefined` | optional | Extract token usage from stream chunks/events. |
+| `chunkUsageMode` | `'delta' \| 'cumulative'` | `'delta'` | Interpret chunk usage as incremental or cumulative. |
+| `maxRetries` | `number` | `3` | Retries after the first attempt. |
+| `timeoutMs` | `number` | optional | Abort the whole stream workflow after this time. |
+| `globalBudget` | `GlobalBudgetTracker` | optional | Shared rolling cost budget across calls. |
+| `meta` | `unknown` | optional | User metadata copied into contexts. |
+| `payload` | `unknown` | optional | Request payload copied into contexts. |
+| `onChunk` | `(chunk, context) => void \| Promise<void>` | optional | Called for each chunk before it is yielded. |
+| `onChunkError` | `(error, chunk, context) => void \| Promise<void>` | optional | Called when `onChunk` fails. |
+| `onChunkErrorMode` | `'ignore' \| 'throw'` | `'ignore'` | Decide whether `onChunk` failures should break the stream. |
+
+### `CircuitBreaker`
+
+```ts
+new CircuitBreaker({
+  failureThreshold: 5,
+  windowMs: 60_000,
+  cooldownMs: 120_000,
+})
+```
+
+`snapshot()` returns `{ state, failures, openedAt }`, where state is
+`'closed'`, `'open'`, or `'half_open'`.
+
+### `AdaptiveHedgeDelay`
+
+```ts
+new AdaptiveHedgeDelay({
+  sampleSize: 100,
+  percentile: 0.95,
+  minSamples: 5,
+  minDelayMs: 250,
+  maxDelayMs: 5_000,
+  defaultDelayMs: 750,
+})
+```
+
+`snapshot()` returns the current sample count and computed delay per provider.
+
+### `GlobalBudgetTracker`
+
+```ts
+new GlobalBudgetTracker({
+  maxCostUSD: 5,
+  windowMs: 60_000,
+})
+```
+
+`snapshot()` returns `{ spentUSD, limitUSD, windowMs, resetAt, entries }`.
+
 ### `RetryResult<T>`
 
 ```ts
@@ -377,6 +644,8 @@ await llmRetry({
 | `initialDelayMs` | `1000` |
 | `maxDelayMs` | `30000` |
 | `costPer1kTokens` | `0.002` |
+| stream retry mode | `before-first-chunk` |
+| stream chunk hook error mode | `ignore` |
 | fallback on client errors | `false` |
 | fallback on transient errors | `true` |
 | runtime dependencies | none |

package/dist/circuit-breaker.d.ts

@@ -0,0 +1,17 @@
+import type { CircuitBreakerOptions, CircuitBreakerSnapshot } from './types.js';
+export declare class CircuitBreaker {
+    private readonly options;
+    private failureTimestamps;
+    private state;
+    private openedAt;
+    constructor(options: CircuitBreakerOptions);
+    canRequest(): boolean;
+    recordSuccess(): void;
+    recordFailure(): void;
+    snapshot(): CircuitBreakerSnapshot;
+}
+export declare class CircuitBreakerOpenError extends Error {
+    readonly provider: string;
+    constructor(provider: string);
+}
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../src/circuit-breaker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,sBAAsB,EAEvB,MAAM,YAAY,CAAA;AAEnB,qBAAa,cAAc;IAKb,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,iBAAiB,CAAe;IACxC,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,QAAQ,CAAsB;gBAET,OAAO,EAAE,qBAAqB;IAI3D,UAAU,IAAI,OAAO;IAcrB,aAAa,IAAI,IAAI;IAMrB,aAAa,IAAI,IAAI;IAiBrB,QAAQ,IAAI,sBAAsB;CAOnC;AAED,qBAAa,uBAAwB,SAAQ,KAAK;aACpB,QAAQ,EAAE,MAAM;gBAAhB,QAAQ,EAAE,MAAM;CAI7C"}

package/dist/circuit-breaker.js

@@ -0,0 +1,63 @@
+export class CircuitBreaker {
+    options;
+    failureTimestamps = [];
+    state = 'closed';
+    openedAt = null;
+    constructor(options) {
+        this.options = options;
+        validateCircuitBreakerOptions(options);
+    }
+    canRequest() {
+        if (this.state !== 'open') {
+            return true;
+        }
+        const openedAt = this.openedAt ?? 0;
+        if (Date.now() - openedAt >= this.options.cooldownMs) {
+            this.state = 'half_open';
+            return true;
+        }
+        return false;
+    }
+    recordSuccess() {
+        this.failureTimestamps = [];
+        this.state = 'closed';
+        this.openedAt = null;
+    }
+    recordFailure() {
+        const now = Date.now();
+        const windowStart = now - this.options.windowMs;
+        this.failureTimestamps = [...this.failureTimestamps, now].filter((timestamp) => timestamp >= windowStart);
+        if (this.state === 'half_open' ||
+            this.failureTimestamps.length >= this.options.failureThreshold) {
+            this.state = 'open';
+            this.openedAt = now;
+        }
+    }
+    snapshot() {
+        return {
+            state: this.state,
+            failures: this.failureTimestamps.length,
+            openedAt: this.openedAt,
+        };
+    }
+}
+export class CircuitBreakerOpenError extends Error {
+    provider;
+    constructor(provider) {
+        super(`Circuit breaker is open for provider "${provider}"`);
+        this.provider = provider;
+        this.name = 'CircuitBreakerOpenError';
+    }
+}
+function validateCircuitBreakerOptions(options) {
+    if (!Number.isInteger(options.failureThreshold) || options.failureThreshold <= 0) {
+        throw new Error('failureThreshold must be a positive integer');
+    }
+    if (options.windowMs < 0) {
+        throw new Error('windowMs must be greater than or equal to 0');
+    }
+    if (options.cooldownMs < 0) {
+        throw new Error('cooldownMs must be greater than or equal to 0');
+    }
+}
+//# sourceMappingURL=circuit-breaker.js.map

package/dist/circuit-breaker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.js","sourceRoot":"","sources":["../src/circuit-breaker.ts"],"names":[],"mappings":"AAMA,MAAM,OAAO,cAAc;IAKI;IAJrB,iBAAiB,GAAa,EAAE,CAAA;IAChC,KAAK,GAAwB,QAAQ,CAAA;IACrC,QAAQ,GAAkB,IAAI,CAAA;IAEtC,YAA6B,OAA8B;QAA9B,YAAO,GAAP,OAAO,CAAuB;QACzD,6BAA6B,CAAC,OAAO,CAAC,CAAA;IACxC,CAAC;IAED,UAAU;QACR,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAA;QACnC,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YACrD,IAAI,CAAC,KAAK,GAAG,WAAW,CAAA;YACxB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAED,aAAa;QACX,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAA;QAC3B,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAA;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;IACtB,CAAC;IAED,aAAa;QACX,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QACtB,MAAM,WAAW,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAA;QAE/C,IAAI,CAAC,iBAAiB,GAAG,CAAC,GAAG,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC,MAAM,CAC9D,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,IAAI,WAAW,CACxC,CAAA;QAED,IACE,IAAI,CAAC,KAAK,KAAK,WAAW;YAC1B,IAAI,CAAC,iBAAiB,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAC9D,CAAC;YACD,IAAI,CAAC,KAAK,GAAG,MAAM,CAAA;YACnB,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAA;QACrB,CAAC;IACH,CAAC;IAED,QAAQ;QACN,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,MAAM;YACvC,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAA;IACH,CAAC;CACF;AAED,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IACpB;IAA5B,YAA4B,QAAgB;QAC1C,KAAK,CAAC,yCAAyC,QAAQ,GAAG,CAAC,CAAA;QADjC,aAAQ,GAAR,QAAQ,CAAQ;QAE1C,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAA;IACvC,CAAC;CACF;AAED,SAAS,6BAA6B,CAAC,OAA8B;IACnE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,OAAO,CAAC,gBAAgB,IAAI,CAAC,EAAE,CAAC;QACjF,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAA;IAChE,CAAC;IAED,IAAI,OAAO,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAA;IAChE,CAAC;IAED,IAAI,OAAO,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;IAClE,CAAC;AACH,CAAC"}

package/dist/global-budget.d.ts

@@ -0,0 +1,13 @@
+import type { GlobalBudgetOptions, GlobalBudgetSnapshot } from './types.js';
+export declare class GlobalBudgetTracker {
+    private readonly options;
+    private entries;
+    constructor(options: GlobalBudgetOptions);
+    add(costUSD: number): void;
+    isExceeded(): boolean;
+    get spent(): number;
+    get limit(): number;
+    snapshot(): GlobalBudgetSnapshot;
+    private prune;
+}
+//# sourceMappingURL=global-budget.d.ts.map

package/dist/global-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-budget.d.ts","sourceRoot":"","sources":["../src/global-budget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAO3E,qBAAa,mBAAmB;IAGlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,OAAO,CAAoB;gBAEN,OAAO,EAAE,mBAAmB;IAIzD,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAc1B,UAAU,IAAI,OAAO;IAKrB,IAAI,KAAK,IAAI,MAAM,CAGlB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,QAAQ,IAAI,oBAAoB;IAchC,OAAO,CAAC,KAAK;CAId"}

package/dist/global-budget.js

@@ -0,0 +1,54 @@
+export class GlobalBudgetTracker {
+    options;
+    entries = [];
+    constructor(options) {
+        this.options = options;
+        validateGlobalBudgetOptions(options);
+    }
+    add(costUSD) {
+        if (!Number.isFinite(costUSD) || costUSD < 0) {
+            throw new Error('costUSD must be greater than or equal to 0');
+        }
+        this.prune();
+        if (costUSD === 0) {
+            return;
+        }
+        this.entries.push({ timestamp: Date.now(), costUSD });
+    }
+    isExceeded() {
+        this.prune();
+        return this.spent >= this.options.maxCostUSD;
+    }
+    get spent() {
+        this.prune();
+        return this.entries.reduce((total, entry) => total + entry.costUSD, 0);
+    }
+    get limit() {
+        return this.options.maxCostUSD;
+    }
+    snapshot() {
+        this.prune();
+        return {
+            spentUSD: this.spent,
+            limitUSD: this.options.maxCostUSD,
+            windowMs: this.options.windowMs,
+            resetAt: this.entries[0]
+                ? this.entries[0].timestamp + this.options.windowMs
+                : null,
+            entries: this.entries.length,
+        };
+    }
+    prune() {
+        const windowStart = Date.now() - this.options.windowMs;
+        this.entries = this.entries.filter((entry) => entry.timestamp > windowStart);
+    }
+}
+function validateGlobalBudgetOptions(options) {
+    if (options.maxCostUSD < 0) {
+        throw new Error('maxCostUSD must be greater than or equal to 0');
+    }
+    if (!Number.isFinite(options.windowMs) || options.windowMs <= 0) {
+        throw new Error('windowMs must be greater than 0');
+    }
+}
+//# sourceMappingURL=global-budget.js.map

package/dist/global-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-budget.js","sourceRoot":"","sources":["../src/global-budget.ts"],"names":[],"mappings":"AAOA,MAAM,OAAO,mBAAmB;IAGD;IAFrB,OAAO,GAAkB,EAAE,CAAA;IAEnC,YAA6B,OAA4B;QAA5B,YAAO,GAAP,OAAO,CAAqB;QACvD,2BAA2B,CAAC,OAAO,CAAC,CAAA;IACtC,CAAC;IAED,GAAG,CAAC,OAAe;QACjB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAA;QAC/D,CAAC;QAED,IAAI,CAAC,KAAK,EAAE,CAAA;QAEZ,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;YAClB,OAAM;QACR,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,CAAA;IACvD,CAAC;IAED,UAAU;QACR,IAAI,CAAC,KAAK,EAAE,CAAA;QACZ,OAAO,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAA;IAC9C,CAAC;IAED,IAAI,KAAK;QACP,IAAI,CAAC,KAAK,EAAE,CAAA;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IACxE,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAA;IAChC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,KAAK,EAAE,CAAA;QAEZ,OAAO;YACL,QAAQ,EAAE,IAAI,CAAC,KAAK;YACpB,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;YACjC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAC/B,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;gBACtB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ;gBACnD,CAAC,CAAC,IAAI;YACR,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;SAC7B,CAAA;IACH,CAAC;IAEO,KAAK;QACX,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAA;QACtD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,CAAA;IAC9E,CAAC;CACF;AAED,SAAS,2BAA2B,CAAC,OAA4B;IAC/D,IAAI,OAAO,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;IAClE,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;QAChE,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;IACpD,CAAC;AACH,CAAC"}

package/dist/hedging.d.ts

@@ -0,0 +1,17 @@
+import type { AdaptiveHedgeDelayOptions, AdaptiveHedgeDelaySnapshot, HedgeDelayRecord, RetryAttemptContext } from './types.js';
+export declare class AdaptiveHedgeDelay {
+    private readonly samplesByProvider;
+    private readonly sampleSize;
+    private readonly percentile;
+    private readonly minSamples;
+    private readonly minDelayMs;
+    private readonly maxDelayMs;
+    private readonly defaultDelayMs;
+    private readonly recordFailures;
+    constructor(options?: AdaptiveHedgeDelayOptions);
+    getDelayMs(context: RetryAttemptContext): number | null;
+    recordLatency(record: HedgeDelayRecord): void;
+    snapshot(): AdaptiveHedgeDelaySnapshot;
+    private clamp;
+}
+//# sourceMappingURL=hedging.d.ts.map

package/dist/hedging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hedging.d.ts","sourceRoot":"","sources":["../src/hedging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,YAAY,CAAA;AAEnB,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA8B;IAChE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAe;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,OAAO,GAAE,yBAA8B;IAmBnD,UAAU,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,GAAG,IAAI;IASvD,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAmB7C,QAAQ,IAAI,0BAA0B;IAmBtC,OAAO,CAAC,KAAK;CAad"}

package/dist/hedging.js

@@ -0,0 +1,105 @@
+export class AdaptiveHedgeDelay {
+    samplesByProvider = new Map();
+    sampleSize;
+    percentile;
+    minSamples;
+    minDelayMs;
+    maxDelayMs;
+    defaultDelayMs;
+    recordFailures;
+    constructor(options = {}) {
+        this.sampleSize = options.sampleSize ?? 100;
+        this.percentile = options.percentile ?? 0.95;
+        this.minSamples = options.minSamples ?? 5;
+        this.minDelayMs = options.minDelayMs ?? null;
+        this.maxDelayMs = options.maxDelayMs ?? null;
+        this.defaultDelayMs = options.defaultDelayMs ?? null;
+        this.recordFailures = options.recordFailures ?? false;
+        validateAdaptiveHedgeDelay({
+            sampleSize: this.sampleSize,
+            percentile: this.percentile,
+            minSamples: this.minSamples,
+            minDelayMs: this.minDelayMs,
+            maxDelayMs: this.maxDelayMs,
+            defaultDelayMs: this.defaultDelayMs,
+        });
+    }
+    getDelayMs(context) {
+        const samples = this.samplesByProvider.get(context.provider) ?? [];
+        if (samples.length < this.minSamples) {
+            return this.defaultDelayMs;
+        }
+        return this.clamp(percentile(samples, this.percentile));
+    }
+    recordLatency(record) {
+        if (!Number.isFinite(record.latencyMs) || record.latencyMs < 0) {
+            return;
+        }
+        if (record.outcome === 'failure' && !this.recordFailures) {
+            return;
+        }
+        const samples = this.samplesByProvider.get(record.provider) ?? [];
+        samples.push(record.latencyMs);
+        if (samples.length > this.sampleSize) {
+            samples.splice(0, samples.length - this.sampleSize);
+        }
+        this.samplesByProvider.set(record.provider, samples);
+    }
+    snapshot() {
+        const providers = {};
+        for (const [provider, samples] of this.samplesByProvider) {
+            providers[provider] = {
+                samples: samples.length,
+                delayMs: samples.length < this.minSamples
+                    ? this.defaultDelayMs
+                    : this.clamp(percentile(samples, this.percentile)),
+            };
+        }
+        return {
+            sampleSize: this.sampleSize,
+            percentile: this.percentile,
+            providers,
+        };
+    }
+    clamp(delayMs) {
+        let clamped = delayMs;
+        if (this.minDelayMs !== null) {
+            clamped = Math.max(clamped, this.minDelayMs);
+        }
+        if (this.maxDelayMs !== null) {
+            clamped = Math.min(clamped, this.maxDelayMs);
+        }
+        return clamped;
+    }
+}
+function percentile(samples, value) {
+    const sorted = [...samples].sort((a, b) => a - b);
+    const index = Math.ceil(value * sorted.length) - 1;
+    return sorted[Math.min(Math.max(index, 0), sorted.length - 1)] ?? 0;
+}
+function validateAdaptiveHedgeDelay(options) {
+    if (!Number.isInteger(options.sampleSize) || options.sampleSize <= 0) {
+        throw new Error('sampleSize must be a positive integer');
+    }
+    if (options.percentile <= 0 || options.percentile > 1) {
+        throw new Error('percentile must be greater than 0 and less than or equal to 1');
+    }
+    if (!Number.isInteger(options.minSamples) || options.minSamples < 0) {
+        throw new Error('minSamples must be a non-negative integer');
+    }
+    for (const [name, value] of [
+        ['minDelayMs', options.minDelayMs],
+        ['maxDelayMs', options.maxDelayMs],
+        ['defaultDelayMs', options.defaultDelayMs],
+    ]) {
+        if (value !== null && value < 0) {
+            throw new Error(`${name} must be greater than or equal to 0`);
+        }
+    }
+    if (options.minDelayMs !== null &&
+        options.maxDelayMs !== null &&
+        options.maxDelayMs < options.minDelayMs) {
+        throw new Error('maxDelayMs must be greater than or equal to minDelayMs');
+    }
+}
+//# sourceMappingURL=hedging.js.map

package/dist/hedging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hedging.js","sourceRoot":"","sources":["../src/hedging.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,5 +1,9 @@
-export { BudgetExceededError, llmRetry, LLMRetryError } from './retry.js';
+export { CircuitBreaker, CircuitBreakerOpenError } from './circuit-breaker.js';
+export { BudgetExceededError, llmRetry, LLMRetryError, ProviderTimeoutError } from './retry.js';
+export { llmRetryStream } from './stream.js';
 export { BudgetTracker } from './budget.js';
+export { GlobalBudgetTracker } from './global-budget.js';
+export { AdaptiveHedgeDelay } from './hedging.js';
 export { calculateBackoff, extractRetryAfter, isRetryableError } from './backoff.js';
-export type { CostCalculator, FallbackDecisionContext, LLMCall, LLMResponse, RetryAttemptContext, RetryDecisionContext, RetryOptions, RetryProvider, RetryResult, RetrySuccessContext, RetryableError, ShouldFallback, ShouldRetry, TokenUsage, } from './types.js';
+export type { AdaptiveHedgeDelayOptions, AdaptiveHedgeDelaySnapshot, CircuitBreakerLike, CircuitBreakerOptions, CircuitBreakerSnapshot, CircuitBreakerState, CostCalculator, FallbackDecisionContext, GlobalBudgetLike, GlobalBudgetOptions, GlobalBudgetSnapshot, HedgeDelayRecord, HedgeDelayStrategy, LLMCall, LLMResponse, RetryAttemptContext, RetryDecisionContext, RetryFailureContext, RetryOptions, RetryProvider, RetryResult, RetrySuccessContext, RetryableError, ShouldFallback, ShouldRetry, StreamLLMCall, StreamRetryMode, StreamRetryOptions, StreamRetryProvider, StreamRetryResult, StreamRetryStats, StreamUsageExtractor, StreamUsageMode, TokenUsage, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpF,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,OAAO,EACP,WAAW,EACX,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,WAAW,EACX,UAAU,GACX,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAC9E,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAC/F,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpF,YAAY,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,uBAAuB,EACvB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,OAAO,EACP,WAAW,EACX,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,WAAW,EACX,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,UAAU,GACX,MAAM,YAAY,CAAA"}