llm-sdk-js 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1391 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/errors.ts
+var BadRequest = class extends Error {
+  constructor(message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "BadRequest";
+  }
+};
+var AllProvidersFailed = class extends Error {
+  attempts;
+  constructor(attempts, message = "All providers failed") {
+    super(message);
+    this.name = "AllProvidersFailed";
+    this.attempts = attempts;
+  }
+};
+var ProviderError = class extends Error {
+  kind;
+  provider;
+  retryable;
+  status;
+  retryAfterMs;
+  constructor(message, options) {
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "ProviderError";
+    this.kind = options.kind;
+    this.provider = options.provider;
+    this.retryable = options.retryable ?? (options.kind === "rate_limit" || options.kind === "timeout" || options.kind === "overloaded" || options.kind === "server_error" || options.kind === "network");
+    if (options.status !== void 0) this.status = options.status;
+    if (options.retryAfterMs !== void 0) this.retryAfterMs = options.retryAfterMs;
+  }
+};
+function classify(status) {
+  if (status === 429) return "rate_limit";
+  if (status === 408 || status === 504) return "timeout";
+  if (status === 401 || status === 403) return "auth";
+  if (status === 529) return "overloaded";
+  if (status === 400 || status === 404 || status === 422) return "bad_request";
+  if (status >= 500) return "server_error";
+  return "unknown";
+}
+function providerErrorFromHttp(provider, status, body, retryAfterHeader) {
+  const kind = classify(status);
+  const retryAfterMs = parseRetryAfterHeader(retryAfterHeader);
+  return new ProviderError(`Request failed (${status}): ${body}`, {
+    kind,
+    provider,
+    status,
+    retryable: kind === "rate_limit" || kind === "timeout" || kind === "server_error" || kind === "overloaded",
+    ...retryAfterMs !== void 0 ? { retryAfterMs } : {}
+  });
+}
+function parseRetryAfterHeader(header) {
+  if (!header) return void 0;
+  const asInt = Number(header);
+  if (!Number.isNaN(asInt)) return asInt * 1e3;
+  const date = Date.parse(header);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+
+// src/router/options.ts
+function assertNoConflictingModelFields(o, where) {
+  if (o.model !== void 0 && o.primary !== void 0) {
+    throw new BadRequest(
+      `Both "model" and "primary" are set in the same ${where} \u2014 "model" always takes precedence, so "primary" would be silently ignored. Set only one.`
+    );
+  }
+}
+function mergeOptions(global, route, call) {
+  const out = {
+    ...pickShared(global),
+    ...pickShared(route ?? {}),
+    ...pickShared(call ?? {})
+  };
+  const retry = { ...global.retry, ...route?.retry, ...call?.retry };
+  if (Object.keys(retry).length > 0) out.retry = retry;
+  if (call?.cache !== void 0) out.cache = call.cache;
+  else if (route?.cache !== void 0) out.cache = route.cache;
+  else if (global.cache !== void 0) out.cache = global.cache;
+  const fallbacks = call?.fallbacks ?? route?.fallbacks ?? global.fallbacks;
+  if (fallbacks !== void 0) out.fallbacks = fallbacks;
+  const raw = { ...global.raw, ...route?.raw, ...call?.raw };
+  if (Object.keys(raw).length > 0) out.raw = raw;
+  return out;
+}
+function pickShared(o) {
+  const out = {};
+  if (o.model !== void 0) out.model = o.model;
+  if (o.primary !== void 0) out.primary = o.primary;
+  if (o.fallbacks !== void 0) out.fallbacks = o.fallbacks;
+  if (o.retry !== void 0) out.retry = o.retry;
+  if (o.timeout !== void 0) out.timeout = o.timeout;
+  if (o.cache !== void 0) out.cache = o.cache;
+  if (o.temperature !== void 0) out.temperature = o.temperature;
+  if (o.maxTokens !== void 0) out.maxTokens = o.maxTokens;
+  if (o.system !== void 0) out.system = o.system;
+  if (o.messages !== void 0) out.messages = o.messages;
+  if (o.raw !== void 0) out.raw = o.raw;
+  if (o.tools !== void 0) out.tools = o.tools;
+  if (o.allowContentFilterFailover !== void 0) {
+    out.allowContentFilterFailover = o.allowContentFilterFailover;
+  }
+  return out;
+}
+function resolveModelChain(options) {
+  if (options.model) return [options.model, ...options.fallbacks ?? []];
+  if (!options.primary) return options.fallbacks ?? [];
+  return [options.primary, ...options.fallbacks ?? []];
+}
+
+// src/cache/memory.ts
+var DEFAULT_MAX_ENTRIES = 1e3;
+var MemoryCache = class {
+  constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+    this.maxEntries = maxEntries;
+  }
+  maxEntries;
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    this.store.delete(key);
+    this.store.set(key, { value, expiresAt: Date.now() + ttlMs });
+    if (this.store.size > this.maxEntries) {
+      const oldest = this.store.keys().next().value;
+      if (oldest !== void 0) this.store.delete(oldest);
+    }
+  }
+};
+
+// src/adapters/zod-schema.ts
+function zodInfo(schema) {
+  const s = schema;
+  if (s?._def && typeof s._def.typeName === "string") {
+    return { kind: s._def.typeName.replace(/^Zod/, "").toLowerCase(), def: s._def, legacy: true };
+  }
+  if (s?.def && typeof s.def.type === "string") {
+    return { kind: s.def.type.toLowerCase(), def: s.def, legacy: false };
+  }
+  return void 0;
+}
+function isZodLike(schema) {
+  return zodInfo(schema) !== void 0;
+}
+function withDescription(schema, description) {
+  return description ? { ...schema, description } : schema;
+}
+function isOptionalField(field) {
+  const info = zodInfo(field);
+  return info?.kind === "optional" || info?.kind === "default";
+}
+function zodToJsonSchema(schema) {
+  const s = schema;
+  const info = zodInfo(schema);
+  if (!info) return withDescription({}, s?.description);
+  const { kind, def, legacy } = info;
+  switch (kind) {
+    case "string":
+      return withDescription({ type: "string" }, s.description);
+    case "number":
+      return withDescription({ type: "number" }, s.description);
+    case "boolean":
+      return withDescription({ type: "boolean" }, s.description);
+    case "bigint":
+    case "int":
+      return withDescription({ type: "integer" }, s.description);
+    case "date":
+      return withDescription({ type: "string", format: "date-time" }, s.description);
+    case "literal": {
+      const value = legacy ? def.value : def.values?.[0];
+      return withDescription({ const: value }, s.description);
+    }
+    case "enum": {
+      const raw = legacy ? def.values : def.entries ?? def.options;
+      const list = Array.isArray(raw) ? raw : Object.values(raw ?? {});
+      return withDescription({ enum: list }, s.description);
+    }
+    case "array": {
+      const item = legacy ? def.type : def.element;
+      return withDescription({ type: "array", items: zodToJsonSchema(item) }, s.description);
+    }
+    case "object": {
+      const shape = s.shape ?? {};
+      const properties = {};
+      const required = [];
+      for (const [key, field] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(field);
+        if (!isOptionalField(field)) required.push(key);
+      }
+      return withDescription(
+        { type: "object", properties, ...required.length > 0 ? { required } : {} },
+        s.description
+      );
+    }
+    case "optional":
+    case "nullable":
+    case "default":
+    case "catch":
+      return zodToJsonSchema(def.innerType);
+    default:
+      return withDescription({}, s.description);
+  }
+}
+function toJsonSchema(schema) {
+  if (schema === void 0) return { type: "object", properties: {} };
+  return isZodLike(schema) ? zodToJsonSchema(schema) : schema;
+}
+
+// src/cache/key.ts
+function normalize(value) {
+  if (Array.isArray(value)) return value.map(normalize);
+  if (value !== null && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = normalize(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function cacheKey(modelChain, messages, opts = {}) {
+  const payload = JSON.stringify(
+    normalize({
+      models: modelChain,
+      messages,
+      temperature: opts.temperature ?? null,
+      maxTokens: opts.maxTokens ?? null,
+      tools: opts.tools ? opts.tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? null,
+        schema: toJsonSchema(t.schema)
+      })) : null,
+      raw: opts.raw ?? null
+    })
+  );
+  return crypto.createHash("sha256").update(payload).digest("hex");
+}
+
+// src/cache/index.ts
+function parseTtl(ttl) {
+  if (typeof ttl === "number") return ttl;
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/i.exec(ttl.trim());
+  if (!match) {
+    throw new Error(`Invalid TTL "${ttl}". Use e.g. "30m", "1h", or milliseconds.`);
+  }
+  const n = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  switch (unit) {
+    case "ms":
+      return n;
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 36e5;
+    case "d":
+      return n * 864e5;
+    default:
+      return n;
+  }
+}
+
+// src/extract.ts
+function zodFieldKind(field) {
+  const f = field;
+  const name = f._def?.typeName ?? f.def?.type;
+  return name ? String(name).replace(/^Zod/, "").toLowerCase() : void 0;
+}
+function describeSchema(schema) {
+  const s = schema;
+  if (!s || typeof s !== "object" || !s.shape || typeof s.shape !== "object") return void 0;
+  const fields = Object.entries(s.shape).map(([key, field]) => {
+    const kind = zodFieldKind(field);
+    return kind ? `${key}: ${kind}` : key;
+  });
+  return fields.length > 0 ? `{ ${fields.join(", ")} }` : void 0;
+}
+async function extractWithSchema(complete, input, call = {}) {
+  const schema = input.schema;
+  if (!schema || typeof schema.parse !== "function" && typeof schema.safeParse !== "function") {
+    throw new BadRequest("extract() requires a Zod schema (or compatible parse/safeParse)");
+  }
+  const shape = input.schemaDescription ?? describeSchema(input.schema);
+  const instruction = shape ? `Respond with JSON only matching this shape: ${shape}. No markdown.` : "Respond with JSON only that matches the requested schema. No markdown.";
+  const basePrompt = [input.prompt, "", instruction].join("\n");
+  const maxSchemaRetries = 2;
+  let lastErr;
+  for (let i = 0; i < maxSchemaRetries; i++) {
+    const prompt = i === 0 ? basePrompt : `${basePrompt}
+
+Previous JSON was invalid:
+${String(lastErr)}
+
+Fix it.`;
+    const completeInput = {
+      prompt,
+      ...input.system !== void 0 ? { system: input.system } : {}
+    };
+    const res = await complete(completeInput, {
+      ...call,
+      temperature: call.temperature ?? 0
+    });
+    try {
+      const jsonText = stripJsonFence(res.text);
+      const parsed = JSON.parse(jsonText);
+      const data = typeof schema.parse === "function" ? schema.parse(parsed) : (() => {
+        const r = schema.safeParse(parsed);
+        if (!r.success) throw r.error;
+        return r.data;
+      })();
+      return {
+        data,
+        text: res.text,
+        provider: res.provider,
+        model: res.model,
+        usage: res.usage,
+        cost: res.cost,
+        unknownModel: res.unknownModel,
+        cached: res.cached,
+        latencyMs: res.latencyMs,
+        attempts: res.attempts
+      };
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  throw new BadRequest(`extract() failed to produce valid data: ${String(lastErr)}`);
+}
+function stripJsonFence(text) {
+  const trimmed = text.trim();
+  const fence = /^```(?:json)?\s*([\s\S]*?)```$/i.exec(trimmed);
+  return fence?.[1]?.trim() ?? trimmed;
+}
+
+// src/policy/cache.ts
+function cacheAllowed(cache, temperature) {
+  if (!cache) return false;
+  if (temperature !== void 0 && temperature > 0 && !cache.includeNonDeterministic) return false;
+  return true;
+}
+
+// src/policy/fallback.ts
+function errorLabel(error) {
+  if (error instanceof ProviderError) return error.kind;
+  if (error instanceof Error) return error.message;
+  return "unknown";
+}
+function reclassifyFatal(err, options, attempts) {
+  if (err instanceof BadRequest) throw err;
+  if (err instanceof ProviderError && err.kind === "bad_request") {
+    throw new BadRequest(err.message, { cause: err });
+  }
+  if (err instanceof ProviderError && err.kind === "content_filter" && !options.allowContentFilterFailover) {
+    throw new AllProvidersFailed(attempts, "Content was filtered by the provider");
+  }
+}
+function skipsSameProviderRetry(err) {
+  return err instanceof ProviderError && (err.kind === "overloaded" || err.kind === "content_filter" || err.kind === "auth" || err.kind === "unknown");
+}
+
+// src/policy/retry.ts
+function computeBackoff(attemptIndex, options = {}, retryAfterMs) {
+  if (retryAfterMs !== void 0 && retryAfterMs > 0) {
+    return Math.min(options.maxDelay ?? 1e4, retryAfterMs);
+  }
+  const base = options.baseDelay ?? 500;
+  const max = options.maxDelay ?? 1e4;
+  const exp = Math.min(max, base * 2 ** attemptIndex);
+  return Math.floor(Math.random() * exp);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new ProviderError("Timed out", { kind: "timeout", provider: "router" }));
+      return;
+    }
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        reject(new ProviderError("Timed out", { kind: "timeout", provider: "router" }));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/policy/timeout.ts
+var TimeoutBudget = class {
+  deadline;
+  constructor(totalMs) {
+    this.deadline = Date.now() + totalMs;
+  }
+  remaining() {
+    return Math.max(0, this.deadline - Date.now());
+  }
+  exhausted() {
+    return this.remaining() <= 0;
+  }
+  /** AbortSignal that fires when the remaining budget elapses. */
+  signalForAttempt() {
+    const controller = new AbortController();
+    const remaining = this.remaining();
+    if (remaining <= 0) {
+      controller.abort();
+      return { signal: controller.signal, clear: () => void 0 };
+    }
+    const timer = setTimeout(() => controller.abort(), remaining);
+    return {
+      signal: controller.signal,
+      clear: () => clearTimeout(timer)
+    };
+  }
+};
+
+// src/pricing/prices.json
+var prices_default = {
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "claude-sonnet-4-5": { input: 3, output: 15 },
+  "claude-haiku-4-5": { input: 1, output: 5 },
+  "llama-3.3-70b": { input: 0.59, output: 0.79 },
+  "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 }
+};
+
+// src/pricing/index.ts
+var PRICES = prices_default;
+function isKnownModel(model) {
+  return Object.hasOwn(PRICES, model);
+}
+var warnedModels = /* @__PURE__ */ new Set();
+function cost(usage, model) {
+  const row = PRICES[model];
+  if (!row) {
+    if (!warnedModels.has(model)) {
+      warnedModels.add(model);
+      console.warn(
+        `[llm-sdk] No pricing data for model "${model}" \u2014 cost will report as 0, which means "unpriced," not "free." Extend PRICES or check CompleteResult.unknownModel.`
+      );
+    }
+    return 0;
+  }
+  return usage.input / 1e6 * row.input + usage.output / 1e6 * row.output;
+}
+function estimateCost(model, usage) {
+  return cost(usage, model);
+}
+
+// src/router/messages.ts
+function toMessages(input, options) {
+  const messages = [];
+  const system = typeof input === "object" ? input.system ?? options.system : options.system;
+  if (system) messages.push({ role: "system", content: system });
+  if (typeof input === "string") {
+    messages.push({ role: "user", content: input });
+    return messages;
+  }
+  if (input.messages?.length) messages.push(...input.messages);
+  else if (input.prompt) messages.push({ role: "user", content: input.prompt });
+  if (messages.filter((m) => m.role !== "system").length === 0) {
+    throw new BadRequest("complete() requires a string prompt or messages");
+  }
+  return messages;
+}
+
+// src/router/model-ref.ts
+function parseModelRef(ref) {
+  const slash = ref.indexOf("/");
+  if (slash <= 0 || slash === ref.length - 1) {
+    throw new BadRequest(`Invalid model ref "${ref}". Expected "provider/model".`);
+  }
+  return {
+    provider: ref.slice(0, slash),
+    model: ref.slice(slash + 1),
+    ref
+  };
+}
+
+// src/router/request.ts
+function buildAdapterRequest(parsed, prepared, signal) {
+  return {
+    model: parsed.model,
+    messages: prepared.messages,
+    ...prepared.temperature !== void 0 ? { temperature: prepared.temperature } : {},
+    ...prepared.maxTokens !== void 0 ? { maxTokens: prepared.maxTokens } : {},
+    ...prepared.tools !== void 0 ? { tools: prepared.tools } : {},
+    ...prepared.options.raw?.[parsed.provider] ? { raw: prepared.options.raw[parsed.provider] } : {},
+    signal
+  };
+}
+
+// src/router/router-impl.ts
+var STREAM_BUFFER_CHARS = 40;
+function replayFromCache(hit) {
+  async function* run() {
+    if (hit.text) yield { text: hit.text };
+    yield { text: "", done: true };
+  }
+  const iterator = run();
+  const result = { ...hit, cached: true, latencyMs: 0, attempts: [] };
+  return {
+    [Symbol.asyncIterator]: () => iterator,
+    async result() {
+      for await (const _ of iterator) {
+      }
+      return result;
+    }
+  };
+}
+var RouterImpl = class _RouterImpl {
+  constructor(state, routeName) {
+    this.state = state;
+    this.routeName = routeName;
+  }
+  state;
+  routeName;
+  get config() {
+    return this.state.config;
+  }
+  route(name) {
+    if (!this.config.routes?.[name]) {
+      throw new BadRequest(`Unknown route "${name}"`);
+    }
+    return new _RouterImpl(this.state, name);
+  }
+  prepareCall(input, call) {
+    assertNoConflictingModelFields(call, "call options");
+    const routeConfig = this.activeRoute();
+    const options = mergeOptions(this.config, routeConfig, call);
+    const modelChain = resolveModelChain(options);
+    if (modelChain.length === 0) {
+      throw new BadRequest("No primary model configured");
+    }
+    const messages = toMessages(input, options);
+    const temperature = call.temperature ?? (typeof input === "object" ? input.temperature : void 0) ?? options.temperature;
+    const maxTokens = call.maxTokens ?? (typeof input === "object" ? input.maxTokens : void 0) ?? options.maxTokens;
+    const tools = call.tools ?? (typeof input === "object" ? input.tools : void 0) ?? options.tools;
+    return {
+      options,
+      modelChain,
+      messages,
+      ...temperature !== void 0 ? { temperature } : {},
+      ...maxTokens !== void 0 ? { maxTokens } : {},
+      ...tools !== void 0 ? { tools } : {}
+    };
+  }
+  async complete(input, call = {}) {
+    const prepared = this.prepareCall(input, call);
+    const { options, modelChain, messages, temperature, maxTokens, tools } = prepared;
+    const keyOpts = {
+      ...temperature !== void 0 ? { temperature } : {},
+      ...maxTokens !== void 0 ? { maxTokens } : {},
+      ...tools !== void 0 ? { tools } : {},
+      ...options.raw !== void 0 ? { raw: options.raw } : {}
+    };
+    const cacheEnabled = cacheAllowed(options.cache, temperature);
+    if (cacheEnabled) {
+      const hit = this.state.cache.get(cacheKey(modelChain, messages, keyOpts));
+      if (hit) {
+        return { ...hit, cached: true, latencyMs: 0, attempts: [] };
+      }
+    }
+    const budget = new TimeoutBudget(options.timeout ?? 6e4);
+    const attempts = [];
+    const retries = options.retry?.attempts ?? 1;
+    for (let i = 0; i < modelChain.length; i++) {
+      const ref = modelChain[i];
+      const parsed = parseModelRef(ref);
+      const adapter = this.state.getAdapter(parsed.provider);
+      for (let retry = 0; retry < retries; retry++) {
+        if (budget.exhausted()) {
+          attempts.push({
+            provider: parsed.provider,
+            model: parsed.model,
+            error: "timeout",
+            ms: 0
+          });
+          break;
+        }
+        const started = Date.now();
+        const { signal, clear } = budget.signalForAttempt();
+        try {
+          const response = await adapter.complete(buildAdapterRequest(parsed, prepared, signal));
+          clear();
+          const ms = Date.now() - started;
+          attempts.push({ provider: parsed.provider, model: parsed.model, ms });
+          const estimated = cost(response.usage, parsed.model);
+          const result = {
+            text: response.text,
+            provider: parsed.provider,
+            model: parsed.model,
+            usage: response.usage,
+            cost: estimated,
+            unknownModel: !isKnownModel(parsed.model),
+            cached: false,
+            latencyMs: ms,
+            attempts,
+            toolCalls: response.toolCalls
+          };
+          if (cacheEnabled && options.cache) {
+            const entry = {
+              text: result.text,
+              provider: result.provider,
+              model: result.model,
+              usage: result.usage,
+              cost: result.cost,
+              unknownModel: result.unknownModel,
+              toolCalls: result.toolCalls
+            };
+            this.state.cache.set(
+              cacheKey(modelChain, messages, keyOpts),
+              entry,
+              parseTtl(options.cache.ttl ?? "1h")
+            );
+          }
+          return result;
+        } catch (err) {
+          clear();
+          const ms = Date.now() - started;
+          attempts.push({
+            provider: parsed.provider,
+            model: parsed.model,
+            error: errorLabel(err),
+            ms
+          });
+          reclassifyFatal(err, options, attempts);
+          const nextRef = modelChain[i + 1];
+          const isLastRetry = skipsSameProviderRetry(err) || retry >= retries - 1;
+          if (isLastRetry) {
+            if (nextRef) this.config.onFallback?.(ref, nextRef, err);
+            break;
+          }
+          const retryAfterMs = err instanceof ProviderError ? err.retryAfterMs : void 0;
+          const delay = computeBackoff(retry, options.retry ?? {}, retryAfterMs);
+          const wait = Math.min(delay, budget.remaining());
+          if (wait > 0) {
+            await sleep(wait, AbortSignal.timeout(budget.remaining()));
+          }
+        }
+      }
+    }
+    throw new AllProvidersFailed(attempts);
+  }
+  extract(input, call = {}) {
+    return extractWithSchema((i, o) => this.complete(i, o), input, call);
+  }
+  // No retry.attempts loop here, unlike complete() — once a chunk has been yielded to the
+  // caller, retrying the same provider would mean sending conflicting text for the same
+  // span, so a mid-stream failure fails over (pre-flush) or ends the stream (post-flush)
+  // rather than retrying in place. See "Streaming vs complete()" in the fallback guide.
+  stream(input, call = {}) {
+    const prepared = this.prepareCall(input, call);
+    const { options, modelChain, messages, temperature, maxTokens, tools } = prepared;
+    const keyOpts = {
+      ...temperature !== void 0 ? { temperature } : {},
+      ...maxTokens !== void 0 ? { maxTokens } : {},
+      ...tools !== void 0 ? { tools } : {},
+      ...options.raw !== void 0 ? { raw: options.raw } : {}
+    };
+    const cacheEnabled = cacheAllowed(options.cache, temperature);
+    if (cacheEnabled) {
+      const hit = this.state.cache.get(cacheKey(modelChain, messages, keyOpts));
+      if (hit) return replayFromCache(hit);
+    }
+    const budget = new TimeoutBudget(options.timeout ?? 6e4);
+    const attempts = [];
+    let finalResult;
+    let finalError;
+    const config = this.config;
+    const state = this.state;
+    async function* run() {
+      try {
+        for (let i = 0; i < modelChain.length; i++) {
+          const ref = modelChain[i];
+          const parsed = parseModelRef(ref);
+          const adapter = state.getAdapter(parsed.provider);
+          const started = Date.now();
+          const { signal, clear } = budget.signalForAttempt();
+          let fullText = "";
+          let buffer = "";
+          let flushed = false;
+          let usage = { input: 0, output: 0 };
+          let toolCalls = [];
+          try {
+            for await (const evt of adapter.stream(buildAdapterRequest(parsed, prepared, signal))) {
+              if (evt.type === "delta") {
+                fullText += evt.text;
+                if (!flushed) {
+                  buffer += evt.text;
+                  if (buffer.length >= STREAM_BUFFER_CHARS) {
+                    flushed = true;
+                    yield { text: buffer };
+                    buffer = "";
+                  }
+                } else {
+                  yield { text: evt.text };
+                }
+              } else {
+                usage = evt.usage;
+                toolCalls = evt.toolCalls;
+              }
+            }
+            clear();
+            const ms = Date.now() - started;
+            attempts.push({ provider: parsed.provider, model: parsed.model, ms });
+            if (buffer.length > 0) yield { text: buffer };
+            yield { text: "", done: true };
+            const estimated = cost(usage, parsed.model);
+            const unknownModel = !isKnownModel(parsed.model);
+            if (cacheEnabled && options.cache) {
+              const entry = {
+                text: fullText,
+                provider: parsed.provider,
+                model: parsed.model,
+                usage,
+                cost: estimated,
+                unknownModel,
+                toolCalls
+              };
+              state.cache.set(cacheKey(modelChain, messages, keyOpts), entry, parseTtl(options.cache.ttl ?? "1h"));
+            }
+            finalResult = {
+              text: fullText,
+              provider: parsed.provider,
+              model: parsed.model,
+              usage,
+              cost: estimated,
+              unknownModel,
+              cached: false,
+              latencyMs: ms,
+              attempts,
+              toolCalls
+            };
+            return;
+          } catch (err) {
+            clear();
+            const ms = Date.now() - started;
+            attempts.push({ provider: parsed.provider, model: parsed.model, error: errorLabel(err), ms });
+            reclassifyFatal(err, options, attempts);
+            if (flushed) {
+              throw err;
+            }
+            const nextRef = modelChain[i + 1];
+            if (nextRef) {
+              config.onFallback?.(ref, nextRef, err);
+              continue;
+            }
+            throw new AllProvidersFailed(attempts);
+          }
+        }
+        throw new AllProvidersFailed(attempts);
+      } catch (err) {
+        finalError = err;
+        throw err;
+      }
+    }
+    const iterator = run();
+    return {
+      [Symbol.asyncIterator]: () => iterator,
+      async result() {
+        for await (const _ of iterator) {
+        }
+        if (finalResult) return finalResult;
+        throw finalError ?? new Error("stream ended without a result");
+      }
+    };
+  }
+  activeRoute() {
+    if (this.routeName) return this.config.routes?.[this.routeName];
+    if (this.config.default && this.config.routes?.[this.config.default]) {
+      return this.config.routes[this.config.default];
+    }
+    return void 0;
+  }
+};
+
+// src/adapters/sse.ts
+async function* readSseEvents(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep;
+      while ((sep = buffer.indexOf("\n\n")) !== -1) {
+        const rawEvent = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        yield parseFrame(rawEvent);
+      }
+    }
+    if (buffer.trim().length > 0) yield parseFrame(buffer);
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseFrame(raw) {
+  let event;
+  const dataLines = [];
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+  }
+  return { ...event !== void 0 ? { event } : {}, data: dataLines.join("\n") };
+}
+
+// src/adapters/openai-compatible.ts
+function envKey(name) {
+  return typeof process !== "undefined" ? process.env[name] : void 0;
+}
+async function postJson(adapter, path, body, signal) {
+  const url = `${adapter.baseUrl.replace(/\/$/, "")}${path}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${adapter.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      ...signal ? { signal } : {}
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new ProviderError("Timed out", { kind: "timeout", provider: adapter.name, cause: err });
+    }
+    throw new ProviderError("Network error", {
+      kind: "network",
+      provider: adapter.name,
+      cause: err
+    });
+  }
+  if (!response.ok) {
+    const responseBody = await response.text().catch(() => "");
+    throw providerErrorFromHttp(
+      adapter.name,
+      response.status,
+      responseBody,
+      response.headers.get("retry-after")
+    );
+  }
+  return response;
+}
+function toOpenAiMessages(messages) {
+  return messages.map((m) => {
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      return {
+        role: "assistant",
+        content: m.content || null,
+        tool_calls: m.toolCalls.map((c) => ({
+          id: c.id,
+          type: "function",
+          function: { name: c.name, arguments: JSON.stringify(c.args) }
+        }))
+      };
+    }
+    if (m.role === "tool") {
+      return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
+    }
+    return { role: m.role, content: m.content, ...m.name ? { name: m.name } : {} };
+  });
+}
+function toOpenAiTools(request) {
+  if (!request.tools?.length) return void 0;
+  return request.tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: toJsonSchema(t.schema)
+    }
+  }));
+}
+function parseOpenAiToolCalls(raw) {
+  if (!raw?.length) return [];
+  return raw.map((c, i) => {
+    const name = c.function?.name ?? "";
+    const argsText = c.function?.arguments ?? "{}";
+    let args;
+    try {
+      args = JSON.parse(argsText);
+    } catch {
+      args = argsText;
+    }
+    return { id: c.id ?? `call_${i}`, name, args };
+  });
+}
+async function openAiCompatibleComplete(adapter, request) {
+  const response = await postJson(
+    adapter,
+    "/chat/completions",
+    {
+      model: request.model,
+      messages: toOpenAiMessages(request.messages),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      tools: toOpenAiTools(request),
+      ...request.raw
+    },
+    request.signal
+  );
+  const data = await response.json();
+  const choice = data.choices?.[0];
+  if (choice?.finish_reason === "content_filter") {
+    throw new ProviderError("Content was filtered by the provider", {
+      kind: "content_filter",
+      provider: adapter.name,
+      retryable: false
+    });
+  }
+  return {
+    text: choice?.message?.content ?? "",
+    usage: {
+      input: data.usage?.prompt_tokens ?? 0,
+      output: data.usage?.completion_tokens ?? 0
+    },
+    toolCalls: parseOpenAiToolCalls(choice?.message?.tool_calls),
+    ...choice?.finish_reason ? { finishReason: choice.finish_reason } : {}
+  };
+}
+function accumulateToolCallDelta(acc, deltas) {
+  for (const d of deltas) {
+    const index = d.index ?? 0;
+    const entry = acc.get(index) ?? { args: "" };
+    if (d.id) entry.id = d.id;
+    if (d.function?.name) entry.name = d.function.name;
+    if (d.function?.arguments) entry.args += d.function.arguments;
+    acc.set(index, entry);
+  }
+}
+function finalizeToolCalls(acc) {
+  return [...acc.entries()].sort(([a], [b]) => a - b).map(([, c], i) => {
+    let args;
+    try {
+      args = c.args ? JSON.parse(c.args) : {};
+    } catch {
+      args = c.args;
+    }
+    return { id: c.id ?? `call_${i}`, name: c.name ?? "", args };
+  });
+}
+async function* openAiCompatibleStream(adapter, request) {
+  const response = await postJson(
+    adapter,
+    "/chat/completions",
+    {
+      model: request.model,
+      messages: toOpenAiMessages(request.messages),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      tools: toOpenAiTools(request),
+      stream: true,
+      stream_options: { include_usage: true },
+      ...request.raw
+    },
+    request.signal
+  );
+  if (!response.body) {
+    throw new ProviderError("Empty stream body", { kind: "network", provider: adapter.name });
+  }
+  let usage = { input: 0, output: 0 };
+  let finishReason;
+  const toolCallAcc = /* @__PURE__ */ new Map();
+  try {
+    for await (const evt of readSseEvents(response.body)) {
+      if (!evt.data || evt.data === "[DONE]") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(evt.data);
+      } catch {
+        continue;
+      }
+      const choice = parsed.choices?.[0];
+      if (typeof choice?.delta?.content === "string" && choice.delta.content.length > 0) {
+        yield { type: "delta", text: choice.delta.content };
+      }
+      if (choice?.delta?.tool_calls?.length) {
+        accumulateToolCallDelta(toolCallAcc, choice.delta.tool_calls);
+      }
+      if (choice?.finish_reason) finishReason = choice.finish_reason;
+      if (parsed.usage) {
+        usage = {
+          input: parsed.usage.prompt_tokens ?? 0,
+          output: parsed.usage.completion_tokens ?? 0
+        };
+      }
+    }
+  } catch (err) {
+    if (err instanceof ProviderError) throw err;
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new ProviderError("Timed out", { kind: "timeout", provider: adapter.name, cause: err });
+    }
+    throw new ProviderError("Network error", { kind: "network", provider: adapter.name, cause: err });
+  }
+  if (finishReason === "content_filter") {
+    throw new ProviderError("Content was filtered by the provider", {
+      kind: "content_filter",
+      provider: adapter.name,
+      retryable: false
+    });
+  }
+  yield {
+    type: "done",
+    usage,
+    toolCalls: finalizeToolCalls(toolCallAcc),
+    ...finishReason ? { finishReason } : {}
+  };
+}
+function requireApiKey(provider, envName, explicit) {
+  const key = explicit ?? envKey(envName);
+  if (!key) {
+    throw new ProviderError(`Missing API key (${envName})`, {
+      kind: "auth",
+      provider,
+      retryable: false
+    });
+  }
+  return key;
+}
+
+// src/adapters/anthropic.ts
+function toAnthropicTools(request) {
+  if (!request.tools?.length) return void 0;
+  return request.tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: toJsonSchema(t.schema)
+  }));
+}
+function parseAnthropicToolCalls(content) {
+  if (!content?.length) return [];
+  return content.filter((c) => c.type === "tool_use").map((c, i) => ({ id: c.id ?? `call_${i}`, name: c.name ?? "", args: c.input }));
+}
+function isToolResultMessage(m) {
+  return Array.isArray(m.content) && m.content.every((b) => b.type === "tool_result");
+}
+function toAnthropicMessages(messages) {
+  const system = messages.filter((m) => m.role === "system").map((m) => m.content).join("\n");
+  const rest = [];
+  for (const m of messages) {
+    if (m.role === "system") continue;
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      const blocks = [];
+      if (m.content) blocks.push({ type: "text", text: m.content });
+      for (const call of m.toolCalls) {
+        blocks.push({ type: "tool_use", id: call.id, name: call.name, input: call.args });
+      }
+      rest.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    if (m.role === "tool") {
+      const block = {
+        type: "tool_result",
+        tool_use_id: m.toolCallId ?? "",
+        content: m.content
+      };
+      const prev = rest.at(-1);
+      if (prev?.role === "user" && isToolResultMessage(prev)) {
+        prev.content.push(block);
+      } else {
+        rest.push({ role: "user", content: [block] });
+      }
+      continue;
+    }
+    rest.push({ role: m.role === "assistant" ? "assistant" : "user", content: m.content });
+  }
+  return { system, messages: rest };
+}
+function classifyAnthropicErrorType(type) {
+  switch (type) {
+    case "rate_limit_error":
+      return "rate_limit";
+    case "overloaded_error":
+      return "overloaded";
+    case "authentication_error":
+    case "permission_error":
+      return "auth";
+    case "invalid_request_error":
+    case "not_found_error":
+      return "bad_request";
+    case "timeout_error":
+      return "timeout";
+    case "api_error":
+      return "server_error";
+    default:
+      return "unknown";
+  }
+}
+var AnthropicAdapter = class {
+  constructor(ctx = {}) {
+    this.ctx = ctx;
+  }
+  ctx;
+  name = "anthropic";
+  headers() {
+    return {
+      "x-api-key": requireApiKey(this.name, "ANTHROPIC_API_KEY", this.ctx.apiKey),
+      "anthropic-version": "2023-06-01",
+      "Content-Type": "application/json"
+    };
+  }
+  url() {
+    return `${(this.ctx.baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "")}/v1/messages`;
+  }
+  async post(request, extra = {}) {
+    const { system, messages } = toAnthropicMessages(request.messages);
+    const headers = this.headers();
+    let response;
+    try {
+      response = await fetch(this.url(), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: request.model,
+          max_tokens: request.maxTokens ?? 1024,
+          temperature: request.temperature,
+          system: system || void 0,
+          messages,
+          tools: toAnthropicTools(request),
+          ...extra,
+          ...request.raw
+        }),
+        ...request.signal ? { signal: request.signal } : {}
+      });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new ProviderError("Timed out", { kind: "timeout", provider: this.name, cause: err });
+      }
+      throw new ProviderError("Network error", { kind: "network", provider: this.name, cause: err });
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw providerErrorFromHttp(
+        this.name,
+        response.status,
+        body,
+        response.headers.get("retry-after")
+      );
+    }
+    return response;
+  }
+  async complete(request) {
+    const response = await this.post(request);
+    const data = await response.json();
+    if (data.stop_reason === "refusal") {
+      throw new ProviderError("Content was filtered by the provider", {
+        kind: "content_filter",
+        provider: this.name,
+        retryable: false
+      });
+    }
+    const text = data.content?.filter((c) => c.type === "text").map((c) => c.text ?? "").join("") ?? "";
+    return {
+      text,
+      usage: {
+        input: data.usage?.input_tokens ?? 0,
+        output: data.usage?.output_tokens ?? 0
+      },
+      toolCalls: parseAnthropicToolCalls(data.content),
+      ...data.stop_reason ? { finishReason: data.stop_reason } : {}
+    };
+  }
+  /** Streaming accumulates `tool_use` blocks from `input_json_delta` events; surfaced on `done`. */
+  async *stream(request) {
+    const response = await this.post(request, { stream: true });
+    if (!response.body) {
+      throw new ProviderError("Empty stream body", { kind: "network", provider: this.name });
+    }
+    let usage = { input: 0, output: 0 };
+    let stopReason;
+    const toolBlocks = /* @__PURE__ */ new Map();
+    try {
+      for await (const evt of readSseEvents(response.body)) {
+        if (!evt.data) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(evt.data);
+        } catch {
+          continue;
+        }
+        if (evt.event === "message_start") {
+          usage.input = parsed.message?.usage?.input_tokens ?? 0;
+        } else if (evt.event === "content_block_start" && parsed.content_block?.type === "tool_use") {
+          toolBlocks.set(parsed.index ?? 0, {
+            ...parsed.content_block.id ? { id: parsed.content_block.id } : {},
+            ...parsed.content_block.name ? { name: parsed.content_block.name } : {},
+            json: ""
+          });
+        } else if (evt.event === "content_block_delta" && parsed.delta?.type === "text_delta") {
+          if (parsed.delta.text) yield { type: "delta", text: parsed.delta.text };
+        } else if (evt.event === "content_block_delta" && parsed.delta?.type === "input_json_delta") {
+          const block = toolBlocks.get(parsed.index ?? 0);
+          if (block && parsed.delta.partial_json) block.json += parsed.delta.partial_json;
+        } else if (evt.event === "message_delta") {
+          if (parsed.usage?.output_tokens !== void 0) usage.output = parsed.usage.output_tokens;
+          if (parsed.delta?.stop_reason) stopReason = parsed.delta.stop_reason;
+        } else if (evt.event === "error") {
+          throw new ProviderError(parsed.error?.message ?? "Anthropic stream error", {
+            kind: classifyAnthropicErrorType(parsed.error?.type),
+            provider: this.name
+          });
+        }
+      }
+    } catch (err) {
+      if (err instanceof ProviderError) throw err;
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new ProviderError("Timed out", { kind: "timeout", provider: this.name, cause: err });
+      }
+      throw new ProviderError("Network error", { kind: "network", provider: this.name, cause: err });
+    }
+    if (stopReason === "refusal") {
+      throw new ProviderError("Content was filtered by the provider", {
+        kind: "content_filter",
+        provider: this.name,
+        retryable: false
+      });
+    }
+    const toolCalls = [...toolBlocks.entries()].sort(([a], [b]) => a - b).map(([, b], i) => {
+      let args;
+      try {
+        args = b.json ? JSON.parse(b.json) : {};
+      } catch {
+        args = b.json;
+      }
+      return { id: b.id ?? `call_${i}`, name: b.name ?? "", args };
+    });
+    yield { type: "done", usage, toolCalls, ...stopReason ? { finishReason: stopReason } : {} };
+  }
+};
+
+// src/adapters/groq.ts
+var GroqAdapter = class {
+  constructor(ctx = {}) {
+    this.ctx = ctx;
+  }
+  ctx;
+  name = "groq";
+  target() {
+    return {
+      name: this.name,
+      baseUrl: this.ctx.baseUrl ?? "https://api.groq.com/openai/v1",
+      apiKey: requireApiKey(this.name, "GROQ_API_KEY", this.ctx.apiKey)
+    };
+  }
+  async complete(request) {
+    return openAiCompatibleComplete(this.target(), request);
+  }
+  stream(request) {
+    return openAiCompatibleStream(this.target(), request);
+  }
+};
+
+// src/adapters/ollama.ts
+var OllamaAdapter = class {
+  constructor(ctx = {}, name = "ollama") {
+    this.ctx = ctx;
+    this.name = name;
+  }
+  ctx;
+  name;
+  target() {
+    return {
+      name: this.name,
+      baseUrl: this.ctx.baseUrl ?? "http://127.0.0.1:11434/v1",
+      apiKey: this.ctx.apiKey ?? envKey("LOCAL_API_KEY") ?? envKey("OLLAMA_API_KEY") ?? "ollama"
+    };
+  }
+  async complete(request) {
+    return openAiCompatibleComplete(this.target(), request);
+  }
+  stream(request) {
+    return openAiCompatibleStream(this.target(), request);
+  }
+};
+
+// src/adapters/openai.ts
+var OpenAIAdapter = class {
+  constructor(ctx = {}) {
+    this.ctx = ctx;
+  }
+  ctx;
+  name = "openai";
+  target() {
+    return {
+      name: this.name,
+      baseUrl: this.ctx.baseUrl ?? "https://api.openai.com/v1",
+      apiKey: requireApiKey(this.name, "OPENAI_API_KEY", this.ctx.apiKey)
+    };
+  }
+  async complete(request) {
+    return openAiCompatibleComplete(this.target(), request);
+  }
+  stream(request) {
+    return openAiCompatibleStream(this.target(), request);
+  }
+};
+
+// src/adapters/index.ts
+function createAdapter(provider, ctx = {}) {
+  const override = ctx.providers?.[provider];
+  const adapterCtx = {
+    ...override?.apiKey !== void 0 ? { apiKey: override.apiKey } : {},
+    ...override?.baseUrl !== void 0 ? { baseUrl: override.baseUrl } : {},
+    ...override?.timeoutMs !== void 0 ? { timeoutMs: override.timeoutMs } : {},
+    ...ctx.apiKey !== void 0 ? { apiKey: ctx.apiKey } : {},
+    ...ctx.baseUrl !== void 0 ? { baseUrl: ctx.baseUrl } : {}
+  };
+  switch (provider) {
+    case "openai":
+      return new OpenAIAdapter(adapterCtx);
+    case "anthropic":
+      return new AnthropicAdapter(adapterCtx);
+    case "groq":
+      return new GroqAdapter(adapterCtx);
+    case "ollama":
+      return new OllamaAdapter(adapterCtx, "ollama");
+    case "local":
+      return new OllamaAdapter(adapterCtx, "local");
+    default:
+      throw new Error(
+        `Unknown provider "${provider}". Register a custom Adapter for it via createRouter({ adapters: { "${provider}": ... } }).`
+      );
+  }
+}
+
+// src/router/state.ts
+var RouterState = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  cache = new MemoryCache();
+  adapters = /* @__PURE__ */ new Map();
+  getAdapter(provider) {
+    let adapter = this.adapters.get(provider);
+    if (!adapter) {
+      adapter = this.config.adapters?.[provider] ?? createAdapter(provider, {
+        ...this.config.providers !== void 0 ? { providers: this.config.providers } : {}
+      });
+      this.adapters.set(provider, adapter);
+    }
+    return adapter;
+  }
+};
+
+// src/router/create-router.ts
+function createRouter(config) {
+  if (!config.primary && !config.routes) {
+    throw new BadRequest("createRouter() requires primary or routes");
+  }
+  assertNoConflictingModelFields(config, "createRouter() config");
+  for (const [name, route] of Object.entries(config.routes ?? {})) {
+    assertNoConflictingModelFields(route, `route "${name}"`);
+  }
+  const state = new RouterState(config);
+  const router = new RouterImpl(state);
+  if (config.default && config.routes) {
+    return router.route(config.default);
+  }
+  return router;
+}
+
+exports.AllProvidersFailed = AllProvidersFailed;
+exports.BadRequest = BadRequest;
+exports.PRICES = PRICES;
+exports.PRICING = PRICES;
+exports.ProviderError = ProviderError;
+exports.cost = cost;
+exports.createRouter = createRouter;
+exports.estimateCost = estimateCost;
+exports.isKnownModel = isKnownModel;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map