@broberg/ai-sdk 0.47.1 → 0.49.0

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   resolveModel,
   resolveTier,
   setAvailability
-} from "./chunk-ZFWSLSE7.js";
+} from "./chunk-SWV5YIEE.js";
 import {
   DEFAULT_CLIP_SEC,
   MEDIA_PRICING_CHECKED_AT,
@@ -2866,6 +2866,8 @@ async function resolveAudio(audio, fetchImpl = fetch) {
 }
 
 // src/capabilities/contracts/index.ts
+var RAW_SNIPPET_CHARS = 200;
+var CLASSIFY_ABSTAIN_SENTENCE = 'If none of the labels fit, return {"label": null}.';
 function parseJsonLoose(text) {
   const fenced = text.replace(/```(?:json)?/gi, "").trim();
   const start = fenced.search(/[[{]/);
@@ -2946,7 +2948,19 @@ Your previous output was not valid JSON. Return ONLY parseable JSON.` : base,
     },
     async classify(input) {
       const res = await client.chat({
-        system: 'You are a zero-shot classifier. Choose exactly one label from the provided list. Return ONLY JSON: {"label": "<one of the labels>", "confidence": <0..1>}.',
+        // F060 — the model must be ALLOWED to say "none of these". Without that sentence,
+        // measured by trail on 444 golden examples (mistral-small-latest, temp 0): of 38
+        // inputs the model refused when invited to, this prompt turned 34 into a
+        // confident WRONG label inside the menu and let none through as a refusal. That
+        // undid F052 from the outside — the code stopped guessing labels[0], and the
+        // prompt made the model guess instead.
+        //
+        // It is exactly ONE sentence, the one trail measured. They isolated it: removing
+        // only this sentence reproduces the failure (35 wrong vs our 34), so it is the
+        // invitation to refuse that matters, not the confidence field or the wording
+        // around it. Do not "tidy" it away, and do not change the words — an unmeasured
+        // edit on top of a measured one makes the measurement say nothing.
+        system: "You are a zero-shot classifier. Choose exactly one label from the provided list. " + CLASSIFY_ABSTAIN_SENTENCE + ' Return ONLY JSON: {"label": "<one of the labels>", "confidence": <0..1>}.',
         prompt: `Labels: ${JSON.stringify(input.labels)}
 
 Text:
@@ -2954,13 +2968,26 @@ ${input.text}`,
         tier: input.tier ?? "cheap",
         purpose: input.purpose ?? "contract:classify"
       });
-      const parsed = parseJsonLoose(res.text);
+      let parsed;
+      try {
+        parsed = parseJsonLoose(res.text);
+      } catch (err) {
+        if (input.onUnparseable !== "value") throw err;
+        return {
+          label: null,
+          rawLabel: res.text.slice(0, RAW_SNIPPET_CHARS),
+          confidence: null,
+          outcome: "unparseable",
+          usage: res.usage
+        };
+      }
       const matched = matchLabel(parsed.label, input.labels);
       return {
         label: matched,
-        ...matched !== null ? {} : { rawLabel: typeof parsed.label === "string" ? parsed.label : res.text.slice(0, 200) },
+        ...matched !== null ? {} : { rawLabel: typeof parsed.label === "string" ? parsed.label : res.text.slice(0, RAW_SNIPPET_CHARS) },
         // 0 is a real confidence; "no confidence reported" is not 0.
         confidence: typeof parsed.confidence === "number" ? parsed.confidence : null,
+        outcome: matched !== null ? "answered" : "out-of-set",
         usage: res.usage
       };
     },
@@ -2977,7 +3004,7 @@ ${JSON.stringify(input.items)}`,
       const raw = parseJsonLoose(res.text);
       if (!Array.isArray(raw)) {
         throw new Error(
-          `ai.contracts.rerank: the model did not return a JSON array. Got: ${res.text.slice(0, 200)}${res.text.length > 200 ? "\u2026" : ""}`
+          `ai.contracts.rerank: the model did not return a JSON array. Got: ${res.text.slice(0, RAW_SNIPPET_CHARS)}${res.text.length > RAW_SNIPPET_CHARS ? "\u2026" : ""}`
         );
       }
       const scored = /* @__PURE__ */ new Map();
@@ -3378,83 +3405,201 @@ var aiConfigSchema = z.object({
   availability: availabilitySchema.optional()
 });
 
+// src/cost/sinks/upmetrics.ts
+import { randomUUID } from "crypto";
+
 // src/version.ts
-var VERSION = "0.47.1";
-var SDK_TAG = "@broberg/ai-sdk@0.47.1";
+var VERSION = "0.49.0";
+var SDK_TAG = "@broberg/ai-sdk@0.49.0";
 
 // src/cost/sinks/upmetrics.ts
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+var MAX_QUEUE = 30;
+var MAX_ATTEMPTS = 5;
+var MAX_BACKOFF_MS = 3e4;
 function upmetricsSink(config) {
   const doFetch = config.fetch ?? fetch;
   const url = `${config.baseUrl.replace(/\/$/, "")}/api/agent`;
+  const retry = config.retry ?? true;
+  const baseMs = config.retryBaseMs ?? 1e3;
+  const queue = [];
+  const counts = { sent: 0, retried: 0, dropped: 0, rejected: 0 };
+  let inFlight = 0;
+  let timer = null;
+  function buildBody(usage) {
+    const startedAt = usage.ts || (/* @__PURE__ */ new Date()).toISOString();
+    const endedAt = new Date(
+      new Date(startedAt).getTime() + (usage.latencyMs || 0)
+    ).toISOString();
+    const agentKind = config.agentKind ?? (usage.capability === "embedding" ? "embedding" : "chatbot");
+    const body = {
+      mode: "record",
+      agent_kind: agentKind,
+      agent_name: config.agentName,
+      provider: usage.provider,
+      model: usage.model,
+      status: "success",
+      input_tokens: usage.inputTokens,
+      output_tokens: usage.outputTokens,
+      cache_read_tokens: usage.cacheReadTokens,
+      cache_creation_tokens: usage.cacheCreationTokens,
+      cost_usd: usage.costUsd,
+      duration_ms: usage.latencyMs,
+      started_at: startedAt,
+      ended_at: endedAt,
+      tags: {
+        // Consumer attribution labels (e.g. tenantId) ride in tags so no new
+        // top-level field risks the strict-shape ingest schema (F011). The
+        // SDK-owned keys win — a label can never clobber capability/transport/sdk.
+        ...usage.labels,
+        capability: usage.capability,
+        transport: usage.transport,
+        // F042: data residency of the route that answered. Rides in tags like
+        // capability/transport — no ingest-schema change, and without it the one
+        // field built for auditability existed only in memory.
+        region: usage.region,
+        // 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
+        // about our rows however carefully they were applied.
+        cost_basis: usage.costBasis ?? "computed",
+        sdk: SDK_TAG,
+        // F061: the receiver's dedupe key. IDENTICAL across every retry of this record
+        // — the body is built once and the same string is resent — and different
+        // between records. Sent on the FIRST attempt too: a first attempt can reach the
+        // server and lose its answer, and the retry must then dedupe against it. Placed
+        // after the labels spread, so a consumer label cannot overwrite it.
+        idempotencyKey: randomUUID()
+      }
+    };
+    if (usage.tier !== void 0) body.tier = usage.tier;
+    if (usage.purpose !== void 0) body.purpose = usage.purpose;
+    if (usage.toolCalls) {
+      body.tool_calls = usage.toolCalls.map((t) => ({
+        name: t.name,
+        count: t.count,
+        error_count: t.errorCount ?? 0
+      }));
+    }
+    void config.complianceMode;
+    return JSON.stringify(body);
+  }
+  async function send(body) {
+    try {
+      const res = await doFetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "X-Upmetrics-Key": config.apiKey
+        },
+        body
+      });
+      if (res.ok) return { kind: "ok" };
+      const text = await res.text().catch(() => "");
+      const err = new Error(`upmetricsSink: ingest returned ${res.status}: ${text.slice(0, 200)}`);
+      return { kind: isRetryableStatus(res.status) ? "retry" : "reject", err };
+    } catch (err) {
+      return { kind: "retry", err };
+    }
+  }
+  function lose(err) {
+    counts.dropped += 1;
+    config.onError?.(err);
+  }
+  function enforceCap() {
+    while (queue.length > MAX_QUEUE) {
+      queue.shift();
+      lose(new Error(`upmetricsSink: retry queue full (${MAX_QUEUE}) \u2014 dropped the oldest pending record`));
+    }
+  }
+  function settle(p, r) {
+    if (r.kind === "ok") {
+      counts.sent += 1;
+      return false;
+    }
+    if (r.kind === "reject") {
+      counts.rejected += 1;
+      config.onError?.(r.err);
+      return false;
+    }
+    if (p.attempts >= MAX_ATTEMPTS) {
+      lose(r.err);
+      return false;
+    }
+    return true;
+  }
+  function schedule() {
+    if (timer || queue.length === 0) return;
+    const head = queue[0];
+    const delay = Math.min(baseMs * 2 ** (head.attempts - 1), MAX_BACKOFF_MS);
+    timer = setTimeout(() => {
+      timer = null;
+      void drainOne();
+    }, delay);
+    timer.unref?.();
+  }
+  async function drainOne() {
+    const p = queue.shift();
+    if (!p) return;
+    inFlight += 1;
+    p.attempts += 1;
+    counts.retried += 1;
+    const r = await send(p.body);
+    inFlight -= 1;
+    if (settle(p, r)) {
+      queue.unshift(p);
+      enforceCap();
+    }
+    schedule();
+  }
   return {
     async record(usage) {
       try {
-        const startedAt = usage.ts || (/* @__PURE__ */ new Date()).toISOString();
-        const endedAt = new Date(
-          new Date(startedAt).getTime() + (usage.latencyMs || 0)
-        ).toISOString();
-        const agentKind = config.agentKind ?? (usage.capability === "embedding" ? "embedding" : "chatbot");
-        const body = {
-          mode: "record",
-          agent_kind: agentKind,
-          agent_name: config.agentName,
-          provider: usage.provider,
-          model: usage.model,
-          status: "success",
-          input_tokens: usage.inputTokens,
-          output_tokens: usage.outputTokens,
-          cache_read_tokens: usage.cacheReadTokens,
-          cache_creation_tokens: usage.cacheCreationTokens,
-          cost_usd: usage.costUsd,
-          duration_ms: usage.latencyMs,
-          started_at: startedAt,
-          ended_at: endedAt,
-          tags: {
-            // Consumer attribution labels (e.g. tenantId) ride in tags so no new
-            // top-level field risks the strict-shape ingest schema (F011). The
-            // SDK-owned keys win — a label can never clobber capability/transport/sdk.
-            ...usage.labels,
-            capability: usage.capability,
-            transport: usage.transport,
-            // F042: data residency of the route that answered. Rides in tags like
-            // capability/transport — no ingest-schema change, and without it the one
-            // field built for auditability existed only in memory.
-            region: usage.region,
-            // 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
-            // about our rows however carefully they were applied.
-            cost_basis: usage.costBasis ?? "computed",
-            sdk: SDK_TAG
-          }
-        };
-        if (usage.tier !== void 0) body.tier = usage.tier;
-        if (usage.purpose !== void 0) body.purpose = usage.purpose;
-        if (usage.toolCalls) {
-          body.tool_calls = usage.toolCalls.map((t) => ({
-            name: t.name,
-            count: t.count,
-            error_count: t.errorCount ?? 0
-          }));
+        const body = buildBody(usage);
+        const r = await send(body);
+        if (r.kind === "ok") {
+          counts.sent += 1;
+          return;
         }
-        void config.complianceMode;
-        const res = await doFetch(url, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            "X-Upmetrics-Key": config.apiKey
-          },
-          body: JSON.stringify(body)
-        });
-        if (!res.ok) {
-          const text = await res.text().catch(() => "");
-          config.onError?.(
-            new Error(`upmetricsSink: ingest returned ${res.status}: ${text.slice(0, 200)}`)
-          );
+        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);
+        timer = null;
+      }
+      const batch = queue.splice(0);
+      const stillPending = [];
+      for (const p of batch) {
+        inFlight += 1;
+        p.attempts += 1;
+        counts.retried += 1;
+        const r = await send(p.body);
+        inFlight -= 1;
+        if (settle(p, r)) stillPending.push(p);
+      }
+      queue.unshift(...stillPending);
+      enforceCap();
+      schedule();
+    },
+    stats() {
+      return { ...counts, queued: queue.length + inFlight };
     }
   };
 }
@@ -4256,11 +4401,18 @@ CREATE TABLE IF NOT EXISTS ai_usage (
   latency_ms INTEGER NOT NULL,
   subprocess INTEGER NOT NULL DEFAULT 0
 )`;
+function requireBun(what) {
+  if (typeof globalThis.Bun !== "undefined") return;
+  throw new Error(
+    `${what} requires the Bun runtime: it is backed by bun:sqlite, which Node cannot import (ERR_UNSUPPORTED_ESM_URL_SCHEME). Use upmetricsSink() on Node \u2014 it is the canonical sink. This throws at setup on purpose: the client swallows per-call sink errors, so a sink that can never write would otherwise look exactly like one recording zero spend.`
+  );
+}
 async function openDb(dbPath, readonly = false) {
   const { Database } = await import("bun:sqlite");
   return new Database(dbPath, readonly ? { readonly: true } : void 0);
 }
 function sqliteSink(config) {
+  requireBun("sqliteSink");
   let ready = null;
   const init = async () => {
     const db = await openDb(config.dbPath);
@@ -4307,6 +4459,7 @@ function sqliteSink(config) {
   };
 }
 async function getCostSummary(dbPath) {
+  requireBun("getCostSummary");
   const db = await openDb(dbPath);
   db.run(CREATE_TABLE);
   const total = db.query(`SELECT SUM(cost_usd) AS total FROM ai_usage`).get();