@broberg/ai-sdk 0.52.0 → 0.54.0

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
   DEFAULT_TIER_MAP,
   ModelUnavailableError,
+  allEntries,
   assertOverrideProvider,
   listModels,
   providerIds,
@@ -8,17 +9,19 @@ import {
   resolveModel,
   resolveTier,
   setAvailability
-} from "./chunk-XDBN6QJ4.js";
+} from "./chunk-PDGFAD66.js";
 import {
   DEFAULT_CLIP_SEC,
+  MEDIA_PRICING,
   MEDIA_PRICING_CHECKED_AT,
+  PRICING,
   PRICING_STALE_AFTER_DAYS,
   getMediaPrice,
   getPrice,
   listMediaPrices,
   pricingFreshness,
   pricingGeneratedAt
-} from "./chunk-O4LR6X4U.js";
+} from "./chunk-TSNJ5N4F.js";
 
 // src/cost/default-hosts.ts
 var DEFAULT_BASE_URLS = {
@@ -363,7 +366,7 @@ function regionOfProvider(provider) {
 function computeCost(provider, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheCreationTokens = 0) {
   const price = getPrice(provider, model);
   if (!price) return 0;
-  const perToken = (per1M) => per1M / 1e6;
+  const perToken = (per1M2) => per1M2 / 1e6;
   const inRate = perToken(price.inputPer1M);
   const outRate = perToken(price.outputPer1M);
   const cacheReadRate = price.cacheReadPer1M !== void 0 ? perToken(price.cacheReadPer1M) : inRate;
@@ -517,6 +520,7 @@ function anthropicAdapter(config = {}) {
       cacheReadTokens: data.usage?.cache_read_input_tokens ?? 0,
       cacheCreationTokens: data.usage?.cache_creation_input_tokens ?? 0
     });
+    if (typeof data.model === "string" && data.model) usage.servedModel = data.model;
     const result = { text, usage };
     if (toolCalls.length > 0) result.toolCalls = toolCalls;
     return result;
@@ -809,6 +813,7 @@ function makeOpenAICompatibleAdapter(config) {
     if (config.costFromResponseField && typeof data.usage?.cost === "number") {
       usage.costUsd = data.usage.cost;
     }
+    if (typeof data.model === "string" && data.model) usage.servedModel = data.model;
     const result = { text, usage };
     if (toolCalls && toolCalls.length > 0) result.toolCalls = toolCalls;
     return result;
@@ -876,6 +881,7 @@ function makeOpenAICompatibleAdapter(config) {
         if (config.costFromResponseField && typeof chunk.usage.cost === "number") {
           usage.costUsd = chunk.usage.cost;
         }
+        if (typeof chunk.model === "string" && chunk.model) usage.servedModel = chunk.model;
         yield { type: "usage", costUsd: usage.costUsd, model: usage.model, usage };
       }
     }
@@ -3520,8 +3526,8 @@ var aiConfigSchema = z.object({
 import { randomUUID } from "crypto";
 
 // src/version.ts
-var VERSION = "0.52.0";
-var SDK_TAG = "@broberg/ai-sdk@0.52.0";
+var VERSION = "0.54.0";
+var SDK_TAG = "@broberg/ai-sdk@0.54.0";
 
 // src/cost/sinks/upmetrics.ts
 function isRetryableStatus(status) {
@@ -3571,6 +3577,9 @@ function upmetricsSink(config) {
         // capability/transport — no ingest-schema change, and without it the one
         // field built for auditability existed only in memory.
         region: usage.region,
+        // F071.2 — the model that answered (contract with upmetrics F048). Omitted when
+        // the provider did not say, rather than echoing the requested model as a guess.
+        ...usage.servedModel ? { served_model: usage.servedModel } : {},
         // F050: HOW cost_usd was arrived at. upmetrics already distinguishes
         // reported / computed / unpriced — we were sending an assumed number in
         // the same field as a measured one, so their labels could not be right
@@ -3597,6 +3606,36 @@ function upmetricsSink(config) {
     void config.complianceMode;
     return JSON.stringify(body);
   }
+  function buildFailureBody(f) {
+    const endedAt = new Date(new Date(f.ts).getTime()).toISOString();
+    const startedAt = new Date(new Date(f.ts).getTime() - (f.latencyMs || 0)).toISOString();
+    const body = {
+      mode: "record",
+      agent_kind: config.agentKind ?? (f.capability === "embedding" ? "embedding" : "chatbot"),
+      agent_name: config.agentName,
+      provider: f.provider,
+      model: f.model,
+      status: "error",
+      input_tokens: 0,
+      output_tokens: 0,
+      cost_usd: 0,
+      duration_ms: f.latencyMs,
+      started_at: startedAt,
+      ended_at: endedAt,
+      tags: {
+        ...f.labels,
+        capability: f.capability,
+        transport: f.transport,
+        error_code: f.errorCode,
+        error_kind: f.errorKind,
+        sdk: SDK_TAG,
+        idempotencyKey: randomUUID()
+      }
+    };
+    if (f.tier !== void 0) body.tier = f.tier;
+    if (f.purpose !== void 0) body.purpose = f.purpose;
+    return JSON.stringify(body);
+  }
   async function send(body) {
     try {
       const res = await doFetch(url, {
@@ -3690,6 +3729,30 @@ function upmetricsSink(config) {
         config.onError?.(err);
       }
     },
+    async recordFailure(failure) {
+      try {
+        const body = buildFailureBody(failure);
+        const r = await send(body);
+        if (r.kind === "ok") {
+          counts.sent += 1;
+          return;
+        }
+        if (r.kind === "reject") {
+          counts.rejected += 1;
+          config.onError?.(r.err);
+          return;
+        }
+        if (!retry) {
+          lose(r.err);
+          return;
+        }
+        queue.push({ body, attempts: 1 });
+        enforceCap();
+        schedule();
+      } catch (err) {
+        config.onError?.(err);
+      }
+    },
     async flush() {
       if (timer) {
         clearTimeout(timer);
@@ -3745,6 +3808,29 @@ function assertByokProviders(providers) {
   }
 }
 
+// src/cost/failure.ts
+function classifyFailure(err) {
+  const e = err;
+  const name = e?.name ?? "";
+  const message = String(e?.message ?? "");
+  if (name === "AbortError" || name === "TimeoutError" || /timed? ?out/i.test(message.split("\n")[0] ?? "")) {
+    return { errorCode: "timeout", errorKind: "timeout" };
+  }
+  let status = typeof e?.status === "number" ? e.status : void 0;
+  if (status === void 0) {
+    const m = /(?:^|\s)([45]\d{2})(?=[:\s]|$)/.exec(message.split("\n")[0] ?? "");
+    if (m) status = Number(m[1]);
+  }
+  if (status !== void 0) {
+    const kind = status === 401 || status === 403 ? "auth" : status === 404 ? "not_found" : status === 429 ? "rate_limit" : status >= 500 ? "server" : "other";
+    return { errorCode: String(status), errorKind: kind };
+  }
+  if (name === "TypeError" && /fetch failed|network|ECONN|ENOTFOUND/i.test(message + (e?.cause?.code ?? ""))) {
+    return { errorCode: "network", errorKind: "network" };
+  }
+  return { errorCode: "unknown", errorKind: "other" };
+}
+
 // src/client.ts
 var DEFAULT_IMAGE_SPEC = {
   provider: "fal",
@@ -3788,6 +3874,21 @@ var DEFAULT_JUDGE_SPEC = { provider: "typesafe", model: "jev-latest", transport:
 var DEFAULT_PODCAST_SPEC = { provider: "elevenlabs", model: "eleven_v3", transport: "http" };
 var DEFAULT_TTS_SPEC = { provider: "elevenlabs", model: "eleven_multilingual_v2", transport: "http" };
 var DEFAULT_BATCH_SPEC = { provider: "mistral", model: "mistral-small-latest", transport: "http" };
+var ROUTED_SPECS = [
+  DEFAULT_IMAGE_SPEC,
+  DEFAULT_LORA_IMAGE_SPEC,
+  DEFAULT_TRAINSTYLE_SPEC,
+  DEFAULT_ANIMATE_SPEC,
+  DEFAULT_BFL_FINETUNE_SPEC,
+  DEFAULT_BFL_REFERENCE_SPEC,
+  DEFAULT_OCR_SPEC,
+  DEFAULT_MODERATION_SPEC,
+  DEFAULT_JUDGE_SPEC,
+  DEFAULT_PODCAST_SPEC,
+  DEFAULT_TTS_SPEC,
+  DEFAULT_BATCH_SPEC,
+  DEFAULT_TRANSCRIBE_SPEC
+];
 function defaultCostSink() {
   const apiKey = process.env.UPMETRICS_API_KEY;
   if (!apiKey) return void 0;
@@ -3840,6 +3941,13 @@ function createAI(config = {}) {
     if (!usage.ts) usage.ts = (/* @__PURE__ */ new Date()).toISOString();
     return usage;
   }
+  async function reportFailure(f, err) {
+    if (!costSink?.recordFailure) return;
+    try {
+      await costSink.recordFailure({ ...f, ...classifyFailure(err), ts: (/* @__PURE__ */ new Date()).toISOString() });
+    } catch {
+    }
+  }
   async function report(usage) {
     if (!costSink) return;
     try {
@@ -3875,8 +3983,8 @@ function createAI(config = {}) {
     for (let i = 0; i < routes.length; i++) {
       const spec = routes[i];
       await preflight(spec, opts.estIn, opts.estOut);
+      const t0 = performance.now();
       try {
-        const t0 = performance.now();
         const res = await opts.invoke(spec);
         enrich(res.usage, opts.capability, i === 0 ? opts.tier : void 0, opts.purpose, performance.now() - t0, opts.labels);
         await settle(res.usage);
@@ -3884,6 +3992,20 @@ function createAI(config = {}) {
         return res;
       } catch (e) {
         lastErr = e;
+        const labels = { ...cfg.labels, ...opts.labels };
+        await reportFailure(
+          {
+            provider: spec.provider,
+            model: spec.model,
+            transport: spec.transport,
+            capability: opts.capability,
+            ...i === 0 && opts.tier ? { tier: opts.tier } : {},
+            ...opts.purpose ? { purpose: opts.purpose } : {},
+            ...Object.keys(labels).length ? { labels } : {},
+            latencyMs: Math.round(performance.now() - t0)
+          },
+          e
+        );
       }
     }
     throw lastErr;
@@ -3953,6 +4075,19 @@ function createAI(config = {}) {
         return;
       } catch (e) {
         lastErr = e;
+        await reportFailure(
+          {
+            provider: spec.provider,
+            model: spec.model,
+            transport: spec.transport,
+            capability: "chat",
+            ...i === 0 ? { tier } : {},
+            ...input.purpose ? { purpose: input.purpose } : {},
+            ...Object.keys({ ...cfg.labels, ...input.labels }).length ? { labels: { ...cfg.labels, ...input.labels } } : {},
+            latencyMs: Math.round(performance.now() - t0)
+          },
+          e
+        );
         if (emitted || !eligibleForFallback(e)) {
           yield errorEvent(e);
           return;
@@ -4315,6 +4450,175 @@ function createAI(config = {}) {
   return client;
 }
 
+// src/catalogue/fetchers.ts
+async function getJson(f, url, headers) {
+  const res = await f(url, { headers: { accept: "application/json", ...headers } });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`${res.status} ${body.slice(0, 200)}`);
+  }
+  return res.json();
+}
+function per1M(v) {
+  if (v == null) return void 0;
+  const n = Number(v) * 1e6;
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+async function fetchOpenRouterCatalogue(opts = {}) {
+  const f = opts.fetch ?? fetch;
+  const base = opts.baseUrl ?? "https://openrouter.ai/api/v1";
+  const json = await getJson(f, `${base}/models`, {});
+  return (json.data ?? []).map((m) => {
+    const inputPer1M = per1M(m.pricing?.prompt);
+    const outputPer1M = per1M(m.pricing?.completion);
+    return {
+      provider: "openrouter",
+      model: m.id,
+      ...inputPer1M !== void 0 ? { inputPer1M } : {},
+      ...outputPer1M !== void 0 ? { outputPer1M } : {},
+      ...m.context_length ? { contextLength: m.context_length } : {}
+    };
+  });
+}
+
+// src/catalogue/types.ts
+function catalogueKey(m) {
+  return `${m.provider}:${m.model}`;
+}
+
+// src/catalogue/diff.ts
+function brandToken(model) {
+  const tail = model.split("/").pop() ?? model;
+  return tail.split("-")[0] ?? tail;
+}
+var DIRECT_PROVIDERS = /* @__PURE__ */ new Set(["openai", "anthropic", "gemini"]);
+var FULL_LIST_PROVIDERS = /* @__PURE__ */ new Set(["mistral", "deepseek", "elevenlabs"]);
+function undatedBase(id) {
+  return id.replace(/-(\d{4}-\d{2}-\d{2}|\d{8}|\d{4})$/, "");
+}
+function knownKeys() {
+  const known = /* @__PURE__ */ new Set([...Object.keys(PRICING), ...Object.keys(MEDIA_PRICING)]);
+  for (const e of allEntries()) known.add(`${e.provider}:${e.id}`);
+  for (const spec of [...Object.values(DEFAULT_TIER_MAP), ...ROUTED_SPECS]) known.add(`${spec.provider}:${spec.model}`);
+  return known;
+}
+function diffCatalogue(fetched, opts = {}) {
+  const threshold = opts.priceThreshold ?? 0.01;
+  const fetchedProviders = new Set(opts.fetchedProviders ?? fetched.map((m) => m.provider));
+  const fetchedByKey = /* @__PURE__ */ new Map();
+  for (const m of fetched) {
+    fetchedByKey.set(catalogueKey(m), m);
+    for (const a of m.aliases ?? []) {
+      const k = catalogueKey({ provider: m.provider, model: a });
+      if (!fetchedByKey.has(k)) fetchedByKey.set(k, m);
+    }
+  }
+  const known = knownKeys();
+  const trackedBrands = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(PRICING)) {
+    const [provider, model] = splitKey(key);
+    if (!trackedBrands.has(provider)) trackedBrands.set(provider, /* @__PURE__ */ new Set());
+    trackedBrands.get(provider).add(brandToken(model));
+  }
+  const added = [];
+  const reportedGroups = /* @__PURE__ */ new Set();
+  const listedByProvider = /* @__PURE__ */ new Map();
+  for (const m of fetched) {
+    if (!listedByProvider.has(m.provider)) listedByProvider.set(m.provider, /* @__PURE__ */ new Set());
+    listedByProvider.get(m.provider).add(m.model);
+  }
+  const isSnapshotOfListed = (m) => {
+    const base = undatedBase(m.model);
+    if (base === m.model) return false;
+    return listedByProvider.get(m.provider)?.has(base) === true || known.has(catalogueKey({ provider: m.provider, model: base }));
+  };
+  for (const m of fetched) {
+    if (FULL_LIST_PROVIDERS.has(m.provider)) {
+      if (m.deprecated) continue;
+      const group = [m.model, ...m.aliases ?? []].map((id) => catalogueKey({ provider: m.provider, model: id }));
+      if (group.some((k) => known.has(k) || reportedGroups.has(k))) continue;
+      for (const k of group) reportedGroups.add(k);
+      added.push(m);
+      continue;
+    }
+    if (!DIRECT_PROVIDERS.has(m.provider)) continue;
+    if (isSnapshotOfListed(m)) continue;
+    const brands = trackedBrands.get(m.provider);
+    if (!brands?.has(brandToken(m.model))) continue;
+    if (PRICING[catalogueKey(m)]) continue;
+    added.push(m);
+  }
+  const missingPrice = [];
+  for (const spec of Object.values(DEFAULT_TIER_MAP)) {
+    if (!getPrice(spec.provider, spec.model)) missingPrice.push(`${spec.provider}:${spec.model}`);
+  }
+  const priceChanged = [];
+  const removedUpstream = [];
+  for (const [key, entry] of Object.entries(PRICING)) {
+    const [provider] = splitKey(key);
+    if (!fetchedProviders.has(provider)) continue;
+    const up = fetchedByKey.get(key);
+    if (!up) {
+      removedUpstream.push(key);
+      continue;
+    }
+    if (up.inputPer1M === void 0 && up.outputPer1M === void 0) continue;
+    const inDrift = relDrift(entry.inputPer1M, up.inputPer1M);
+    const outDrift = relDrift(entry.outputPer1M, up.outputPer1M);
+    if (inDrift > threshold || outDrift > threshold) {
+      priceChanged.push({
+        key,
+        ourInputPer1M: entry.inputPer1M,
+        ourOutputPer1M: entry.outputPer1M,
+        ...up.inputPer1M !== void 0 ? { upstreamInputPer1M: up.inputPer1M } : {},
+        ...up.outputPer1M !== void 0 ? { upstreamOutputPer1M: up.outputPer1M } : {}
+      });
+    }
+  }
+  return { added, missingPrice, priceChanged, removedUpstream };
+}
+function relDrift(ours, upstream) {
+  if (upstream === void 0) return 0;
+  if (upstream === 0) return ours === 0 ? 0 : Infinity;
+  return Math.abs(ours - upstream) / upstream;
+}
+function splitKey(key) {
+  const i = key.indexOf(":");
+  return [key.slice(0, i), key.slice(i + 1)];
+}
+
+// src/catalogue/price-drift.ts
+var COVERAGE = "OpenRouter catalogue only. Not covered: direct-provider prices (no price API) and speech/image/video/OCR (hand-checked, F050).";
+function pct(ours, up) {
+  if (up === void 0) return void 0;
+  if (ours === 0) return up === 0 ? 0 : Infinity;
+  return Math.round((up - ours) / ours * 1e3) / 10;
+}
+async function checkPriceDrift(opts = {}) {
+  const measuredAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const models = await fetchOpenRouterCatalogue({ fetch: opts.fetch });
+    if (models.length === 0) return { ok: false, measuredAt, error: "OpenRouter returned an empty catalogue" };
+    const diff = diffCatalogue(models, { fetchedProviders: ["openrouter"], priceThreshold: opts.threshold ?? 0.01 });
+    const drift = diff.priceChanged.map((p) => {
+      const i = p.key.indexOf(":");
+      return {
+        key: p.key,
+        provider: p.key.slice(0, i),
+        model: p.key.slice(i + 1),
+        ours: { inputPer1M: p.ourInputPer1M, outputPer1M: p.ourOutputPer1M },
+        upstream: { inputPer1M: p.upstreamInputPer1M, outputPer1M: p.upstreamOutputPer1M },
+        inputChangePct: pct(p.ourInputPer1M, p.upstreamInputPer1M),
+        outputChangePct: pct(p.ourOutputPer1M, p.upstreamOutputPer1M)
+      };
+    });
+    const checked = models.filter((m) => m.inputPer1M !== void 0 || m.outputPer1M !== void 0).length;
+    return { ok: true, measuredAt, source: "openrouter", checked, drift, coverage: COVERAGE };
+  } catch (e) {
+    return { ok: false, measuredAt, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+
 // src/providers/stub.ts
 function stubUsage(provider, model, transport, capability) {
   return {
@@ -4499,6 +4803,9 @@ function multiSink(sinks) {
   return {
     async record(usage) {
       await Promise.allSettled(sinks.map(async (s) => s.record(usage)));
+    },
+    async recordFailure(failure) {
+      await Promise.allSettled(sinks.map(async (s) => s.recordFailure?.(failure)));
     }
   };
 }
@@ -4754,6 +5061,7 @@ export {
   bflCredits,
   byokAdapter,
   chatInputSchema,
+  checkPriceDrift,
   checkVoice,
   classifyRegionName,
   computeCost,