@kunal_dutt/token-lens 0.2.17 → 0.2.19

package/sdk.mjs

@@ -1,5 +1,5 @@
 // src/sdk/index.ts
-import { createHash as createHash3, randomUUID } from "node:crypto";
+import { createHash as createHash4, randomUUID } from "node:crypto";
 
 // src/core/advice.ts
 var fmt = (n) => n.toLocaleString("en-US");
@@ -203,7 +203,7 @@ var BytePairEncodingCore = class {
     });
     this.bytePairNonUtfSortedEncoder = binaryLookup.sort((a, b) => compareUint8Arrays(a[0], b[0]));
     this.specialTokensEncoder = specialTokensEncoder ?? /* @__PURE__ */ new Map();
-    this.specialTokensDecoder = specialTokensEncoder ? new Map([...specialTokensEncoder].map(([key, value]) => [value, key])) : /* @__PURE__ */ new Map();
+    this.specialTokensDecoder = specialTokensEncoder ? new Map([...specialTokensEncoder].map(([key2, value]) => [value, key2])) : /* @__PURE__ */ new Map();
     this.tokenSplitRegex = tokenSplitRegex;
     const allSpecialTokensRegex = [...this.specialTokensEncoder.keys()].map(escapeRegExp).join("|");
     try {
@@ -336,38 +336,38 @@ var BytePairEncodingCore = class {
       if (tokenBytesOrString) yield tokenBytesOrString;
     }
   }
-  getBpeRankFromString(key) {
-    return this.bytePairStringRankEncoder.get(key);
+  getBpeRankFromString(key2) {
+    return this.bytePairStringRankEncoder.get(key2);
   }
-  getBpeRankFromStringOrThrow(key) {
-    const value = this.getBpeRankFromString(key);
-    if (value === void 0) throw new Error(`The byte-pair encoding does not contain a value for: ${key}`);
+  getBpeRankFromStringOrThrow(key2) {
+    const value = this.getBpeRankFromString(key2);
+    if (value === void 0) throw new Error(`The byte-pair encoding does not contain a value for: ${key2}`);
     return value;
   }
-  getBpeRankFromBytes(key) {
-    const keyAsString = tryConvertToString(key);
+  getBpeRankFromBytes(key2) {
+    const keyAsString = tryConvertToString(key2);
     if (keyAsString !== void 0) return this.getBpeRankFromString(keyAsString);
-    const index = this.binarySearch(key);
+    const index = this.binarySearch(key2);
     if (index !== -1) return this.bytePairNonUtfSortedEncoder[index][1];
   }
-  getBpeRankFromBytesOrThrow(key) {
-    const value = this.getBpeRankFromBytes(key);
-    if (value === void 0) throw new Error(`The byte-pair encoding does not contain a value for: ${key.toString()}`);
+  getBpeRankFromBytesOrThrow(key2) {
+    const value = this.getBpeRankFromBytes(key2);
+    if (value === void 0) throw new Error(`The byte-pair encoding does not contain a value for: ${key2.toString()}`);
     return value;
   }
-  binarySearch(key) {
+  binarySearch(key2) {
     let low = 0;
     let high = this.bytePairNonUtfSortedEncoder.length - 1;
     while (low <= high) {
       const mid = low + high >>> 1;
       const midKey = this.bytePairNonUtfSortedEncoder[mid][0];
       let cmp = 0;
-      const maxLength = Math.min(midKey.length, key.length);
+      const maxLength = Math.min(midKey.length, key2.length);
       for (let i = 0; i < maxLength; i++) {
-        cmp = midKey[i] - key[i];
+        cmp = midKey[i] - key2[i];
         if (cmp !== 0) break;
       }
-      if (cmp === 0) cmp = midKey.length - key.length;
+      if (cmp === 0) cmp = midKey.length - key2.length;
       if (cmp === 0) return mid;
       if (cmp < 0) low = mid + 1;
       else high = mid - 1;
@@ -394,13 +394,13 @@ var BytePairEncodingCore = class {
     }
     return this.specialTokensDecoder.get(tokenRank);
   }
-  addToMergeCache(key, value) {
+  addToMergeCache(key2, value) {
     if (!this.mergeCache) return;
     if (this.mergeCache.size >= this.mergeCacheSize) {
       const firstKey = this.mergeCache.keys().next().value;
       this.mergeCache.delete(firstKey);
     }
-    this.mergeCache.set(key, value);
+    this.mergeCache.set(key2, value);
   }
   bytePairEncode(input) {
     if (input.length === 1 && isAscii(input.codePointAt(0))) return [this.getBpeRankFromStringOrThrow(input)];
@@ -420,8 +420,8 @@ var BytePairEncodingCore = class {
     const ranks = [];
     const getRank = (startIndex, pairStart = starts[startIndex], pairEnd = starts[startIndex + 2]) => {
       if (pairEnd === void 0) return Number.POSITIVE_INFINITY;
-      const key = piece.subarray(pairStart, pairEnd);
-      return this.getBpeRankFromBytes(key) ?? Number.POSITIVE_INFINITY;
+      const key2 = piece.subarray(pairStart, pairEnd);
+      return this.getBpeRankFromBytes(key2) ?? Number.POSITIVE_INFINITY;
     };
     for (let i = 0; i <= piece.length; i++) {
       starts.push(i);
@@ -206098,8 +206098,8 @@ function counts(text) {
   const m = /* @__PURE__ */ new Map();
   for (const [kind, re] of ANCHORS) {
     for (const hit of text.match(re) ?? []) {
-      const key = `${kind}:${hit.toLowerCase()}`;
-      m.set(key, (m.get(key) ?? 0) + 1);
+      const key2 = `${kind}:${hit.toLowerCase()}`;
+      m.set(key2, (m.get(key2) ?? 0) + 1);
     }
   }
   return m;
@@ -206108,7 +206108,7 @@ function checkMeaning(original, rewritten, mode = "count") {
   const before = counts(original);
   const after = counts(rewritten);
   const lost = [];
-  for (const [key, n] of before) if ((after.get(key) ?? 0) < (mode === "count" ? n : 1)) lost.push(key);
+  for (const [key2, n] of before) if ((after.get(key2) ?? 0) < (mode === "count" ? n : 1)) lost.push(key2);
   return { ok: lost.length === 0, lost };
 }
 var DROPPABLE = new Set(
@@ -206207,13 +206207,13 @@ function dedupeSentences(text, applied) {
   const seen = /* @__PURE__ */ new Set();
   return text.split("\n").map(
     (line) => line.split(/(?<=[.!?])\s+/).filter((sentence) => {
-      const key = sentence.replace(/\W+/g, " ").trim().toLowerCase();
-      if (key.split(" ").length < 4) return true;
-      if (seen.has(key)) {
+      const key2 = sentence.replace(/\W+/g, " ").trim().toLowerCase();
+      if (key2.split(" ").length < 4) return true;
+      if (seen.has(key2)) {
         applied.push("repeated sentence");
         return false;
       }
-      seen.add(key);
+      seen.add(key2);
       return true;
     }).join(" ")
   ).join("\n");
@@ -206261,11 +206261,11 @@ function trimLog(text, level, applied) {
       i++;
     }
   }
-  const key = level === "aggressive" ? normalizeLogLine : (l) => l;
+  const key2 = level === "aggressive" ? normalizeLogLine : (l) => l;
   const result = [];
   for (let i = 0; i < out.length; ) {
     let j = i + 1;
-    while (j < out.length && out[i].trim() && key(out[j]) === key(out[i])) j++;
+    while (j < out.length && out[i].trim() && key2(out[j]) === key2(out[i])) j++;
     result.push(out[i]);
     if (j - i >= 3) {
       result.push(`... same line repeated ${j - i - 1} more times`);
@@ -206480,6 +206480,90 @@ var PROFILES = {
     reasoning: false,
     pricing: { inputPerMTok: 2, outputPerMTok: 6 }
   }),
+  // Open-weight families, as served by API hosts (Groq, Together, Fireworks, OpenRouter, their makers' own
+  // APIs) or run locally (Ollama, LM Studio, vLLM). Hosted prices differ by host: these are typical list
+  // prices, and running locally costs no tokens, so set your own price in settings or registerModel.
+  llama: P({
+    id: "llama",
+    label: "Llama",
+    family: "other",
+    contextWindow: 128e3,
+    tokenizer: "heuristic",
+    charsPerToken: 3.9,
+    reasoning: false,
+    pricing: { inputPerMTok: 0.27, outputPerMTok: 0.85 }
+  }),
+  qwen: P({
+    id: "qwen",
+    label: "Qwen",
+    family: "other",
+    contextWindow: 128e3,
+    tokenizer: "heuristic",
+    charsPerToken: 3.8,
+    reasoning: false,
+    pricing: { inputPerMTok: 0.4, outputPerMTok: 1.2 }
+  }),
+  kimi: P({
+    id: "kimi",
+    label: "Kimi",
+    family: "other",
+    contextWindow: 256e3,
+    tokenizer: "heuristic",
+    charsPerToken: 3.8,
+    reasoning: false,
+    pricing: { inputPerMTok: 0.6, outputPerMTok: 2.5, cachedInputPerMTok: 0.15 }
+  }),
+  glm: P({
+    id: "glm",
+    label: "GLM",
+    family: "other",
+    contextWindow: 2e5,
+    tokenizer: "heuristic",
+    charsPerToken: 3.8,
+    reasoning: false,
+    pricing: { inputPerMTok: 0.6, outputPerMTok: 2.2, cachedInputPerMTok: 0.11 }
+  }),
+  command: P({
+    id: "command",
+    label: "Cohere Command",
+    family: "other",
+    contextWindow: 256e3,
+    tokenizer: "heuristic",
+    charsPerToken: 4,
+    reasoning: false,
+    pricing: { inputPerMTok: 2.5, outputPerMTok: 10 }
+  }),
+  sonar: P({
+    id: "sonar",
+    label: "Perplexity Sonar",
+    family: "other",
+    contextWindow: 128e3,
+    tokenizer: "heuristic",
+    charsPerToken: 4,
+    reasoning: false,
+    pricing: { inputPerMTok: 1, outputPerMTok: 1 }
+  }),
+  // Small open models, mostly run locally (where tokens cost nothing): priced at a typical host's rate.
+  gemma: P({
+    id: "gemma",
+    label: "Gemma",
+    family: "other",
+    contextWindow: 128e3,
+    tokenizer: "heuristic",
+    charsPerToken: 3.9,
+    reasoning: false,
+    pricing: { inputPerMTok: 0.1, outputPerMTok: 0.2 }
+  }),
+  phi: P({
+    id: "phi",
+    label: "Phi",
+    family: "other",
+    contextWindow: 16e3,
+    tokenizer: "heuristic",
+    charsPerToken: 3.9,
+    reasoning: false,
+    pricing: { inputPerMTok: 0.07, outputPerMTok: 0.14 }
+  }),
   generic: P({
     id: "generic",
     label: "Unknown model",
@@ -206497,12 +206581,22 @@ var RULES2 = [
   [/\bclaude\b.*\bopus\b|\bopus\b/, "claude-opus"],
   [/\bsonnet\b/, "claude-sonnet"],
   [/\bhaiku\b/, "claude-haiku"],
+  // Open models whose names can carry "flash" or "pro" come before the Gemini rules.
+  [/\b(qwen|qwq)/, "qwen"],
+  [/\b(glm|chatglm|zhipu)\b|\bglm-?\d/, "glm"],
+  [/\b(kimi|moonshot)/, "kimi"],
+  [/\bgemma/, "gemma"],
   [/\bgemini\b.*\bflash\b|\bflash\b/, "gemini-flash"],
   [/\bgemini\b.*\b(pro|ultra|deep think)\b|^\s*\d(\.\d)?\s*pro\b|\bdeep think\b/, "gemini-pro"],
   [/\bdeepseek\b.*\b(r1|reason|think|deepthink)|\bdeepthink\b/, "deepseek-reasoning"],
   [/\bdeepseek\b/, "deepseek"],
   [/\b(mistral|le chat|magistral|codestral)\b/, "mistral"],
   [/\bgrok\b/, "grok"],
+  // After DeepSeek, so "deepseek-r1-distill-llama" stays DeepSeek.
+  [/\bllama|codellama/, "llama"],
+  [/\bcommand[- ]?(r|a)\b|\bcohere\b/, "command"],
+  [/\bsonar\b|\bperplexity\b/, "sonar"],
+  [/\bphi-?\d/, "phi"],
   [/\bo[1-9](-mini|-pro)?\b|\bgpt[- ]?\S*\s*(thinking|pro)\b|\bthinking\b/, "gpt-reasoning"],
   [/\b(gpt|chatgpt)\b|\bgpt-?\d/, "gpt"],
   [/\bgemini\b/, "gemini-pro"],
@@ -206561,33 +206655,8 @@ function detectProfile(hint, siteId = "generic") {
   return PROFILES[SITE_DEFAULTS[siteId] ?? "generic"];
 }
 
-// src/gateway/config.ts
-var DEFAULTS = {
-  port: 8080,
-  host: "0.0.0.0",
-  mode: "optimize",
-  level: "auto",
-  safe: { prompt: true, minifyJson: true, collapseRepeats: true, dedupeToolOutputs: true, dedupePassages: true, dedupeImages: true, promptCaching: true, dedupeRetries: true, cacheEmbeddings: true },
-  optIn: { elideOldToolOutputs: false, lazyTools: false, trimToolFields: false, compactJson: false, parkToolOutputs: false, flex: false, warmCache: false },
-  verify: { sampleRate: 0.05, minSimilarity: 0.8, maxShareOfSavings: 0.2, freeChecks: 5, probation: 5 },
-  runBudget: {},
-  batch: { flushSeconds: 60, pollSeconds: 60, maxRequests: 1e3, discount: 0.5 },
-  flexDiscount: 0.5,
-  embeddingsCacheMB: 256,
-  // Models carry their own long-context price (src/core/models.ts); entries here override or add to them.
-  priceTiers: [],
-  storage: { keyPrefix: "token-lens:", flushSeconds: 10, runDays: 7 },
-  retryWindowSeconds: 120,
-  blockOverContext: false,
-  upstreams: {},
-  routes: [],
-  models: [],
-  clientKeys: [],
-  maxBodyBytes: 32 * 1024 * 1024,
-  maxRuns: 2e3,
-  logRequests: true,
-  reportToolArgs: false
-};
+// src/gateway/customers.ts
+import { createHash } from "node:crypto";
 
 // src/gateway/metrics.ts
 var emptyTotals = () => ({
@@ -206671,12 +206740,260 @@ function view(t) {
   };
 }
 
+// src/gateway/customers.ts
+var CUSTOMER_DEFAULTS = {
+  fromBody: false,
+  hashIds: false,
+  maxCustomers: 1e5,
+  budget: {},
+  plans: {},
+  teamBudgets: {}
+};
+function periodKey(period, now) {
+  const iso = now.toISOString();
+  return period === "day" ? `d${iso.slice(0, 10)}` : `m${iso.slice(0, 7)}`;
+}
+var hashId = (id) => `h:${createHash("sha256").update(id).digest("hex").slice(0, 16)}`;
+function clean(id) {
+  if (typeof id !== "string") return void 0;
+  const s = id.replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, 128);
+  return s || void 0;
+}
+function customerOf(headerValue, body, cfg) {
+  const raw = clean(headerValue) ?? (cfg.fromBody ? clean(body?.safety_identifier) ?? clean(body?.user) ?? clean(body?.metadata?.user_id) : void 0);
+  if (!raw) return void 0;
+  return cfg.hashIds ? hashId(raw) : raw;
+}
+var storedId = (id, cfg) => cfg.hashIds ? hashId(id) : id;
+var LIMITS = [
+  ["dailyUsd", "day", "usd"],
+  ["monthlyUsd", "month", "usd"],
+  ["dailyTokens", "day", "tokens"],
+  ["monthlyTokens", "month", "tokens"]
+];
+var HEADER_LIMITS = {
+  "daily-usd": "dailyUsd",
+  "monthly-usd": "monthlyUsd",
+  "daily-tokens": "dailyTokens",
+  "monthly-tokens": "monthlyTokens"
+};
+var isLimit = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+function cleanBudget(b) {
+  const out = {};
+  for (const [k] of LIMITS) if (isLimit(b?.[k])) out[k] = b[k];
+  return out;
+}
+var UnknownPlanError = class extends Error {
+};
+function customerBudget(cfg, plan, header) {
+  if (plan && !cfg.plans[plan]) throw new UnknownPlanError(`Unknown plan "${plan}". Plans in this gateway's config: ${Object.keys(cfg.plans).join(", ") || "none"}.`);
+  const fromHeaders = {};
+  for (const [suffix, key2] of Object.entries(HEADER_LIMITS)) {
+    const v = header(`x-token-lens-customer-${suffix}`);
+    if (v !== void 0 && v !== "") fromHeaders[key2] = Number(v);
+  }
+  return { ...cleanBudget(cfg.budget), ...cleanBudget(plan ? cfg.plans[plan] : void 0), ...cleanBudget(fromHeaders) };
+}
+var hasLimits = (b) => LIMITS.some(([k]) => b[k] !== void 0);
+var TEAM = "";
+var key = (...parts) => parts.join("\0");
+var CustomerLedger = class {
+  constructor(maxCustomers) {
+    this.maxCustomers = maxCustomers;
+  }
+  maxCustomers;
+  /** key(app, customer) -> totals. Map order is least recently seen first. */
+  rows = /* @__PURE__ */ new Map();
+  /** key(period, app, customer | TEAM) -> spend recorded by this copy. */
+  local = /* @__PURE__ */ new Map();
+  /** What of `local` was already written to shared storage. */
+  flushed = /* @__PURE__ */ new Map();
+  /** Spend of every copy, as last read from shared storage (includes what this copy flushed). */
+  shared = /* @__PURE__ */ new Map();
+  periods = "";
+  prune(now) {
+    const day = periodKey("day", now);
+    const month = periodKey("month", now);
+    const current = day + month;
+    if (current !== this.periods) {
+      this.periods = current;
+      for (const m of [this.local, this.flushed, this.shared])
+        for (const k of m.keys()) {
+          const p = k.slice(0, k.indexOf("\0"));
+          if (p !== day && p !== month) m.delete(k);
+        }
+    }
+    return [day, month];
+  }
+  /** One call: the same figures as the savings report, for the customer and its team. */
+  record(app, customer, m, now = /* @__PURE__ */ new Date()) {
+    const t = emptyTotals();
+    addCall(t, m);
+    if (customer) {
+      const k = key(app, customer);
+      let row = this.rows.get(k);
+      if (row) this.rows.delete(k);
+      else row = { totals: emptyTotals(), firstSeen: now.toISOString(), lastSeen: "" };
+      row.lastSeen = now.toISOString();
+      for (const f of Object.keys(t)) row.totals[f] += t[f];
+      this.rows.set(k, row);
+      while (this.rows.size > this.maxCustomers) this.rows.delete(this.rows.keys().next().value);
+    }
+    if (m.status >= 400 || m.replayed) return;
+    const spend = { usd: t.costUsd, tokens: t.inputTokens + t.outputTokens };
+    if (!spend.usd && !spend.tokens) return;
+    for (const p of this.prune(now))
+      for (const who of customer ? [customer, TEAM] : [TEAM]) {
+        const k = key(p, app, who);
+        const s = this.local.get(k) ?? { usd: 0, tokens: 0 };
+        s.usd += spend.usd;
+        s.tokens += spend.tokens;
+        this.local.set(k, s);
+      }
+  }
+  /** Spend in the current day or month, across every copy when shared storage is on. */
+  spent(app, customer, period, now = /* @__PURE__ */ new Date()) {
+    const [day, month] = this.prune(now);
+    const k = key(period === "day" ? day : month, app, customer ?? TEAM);
+    const l = this.local.get(k);
+    const f = this.flushed.get(k);
+    const s = this.shared.get(k);
+    return {
+      usd: (s?.usd ?? 0) + (l?.usd ?? 0) - (f?.usd ?? 0),
+      tokens: (s?.tokens ?? 0) + (l?.tokens ?? 0) - (f?.tokens ?? 0)
+    };
+  }
+  /** The first limit already reached, the customer's checked before the team's. */
+  over(app, customer, budgets, now = /* @__PURE__ */ new Date()) {
+    const checks = [["team", budgets.team, void 0]];
+    if (customer) checks.unshift(["customer", budgets.customer, customer]);
+    for (const [who, budget, id] of checks)
+      for (const [limit, period, field] of LIMITS) {
+        const cap = budget[limit];
+        if (cap === void 0) continue;
+        const spent = this.spent(app, id, period, now)[field];
+        if (spent >= cap) return { who, limit, cap, spent };
+      }
+    return void 0;
+  }
+  /** What is left under the tightest limits that apply, for the response headers. */
+  remaining(app, customer, budgets, now = /* @__PURE__ */ new Date()) {
+    const out = {};
+    const pairs = [[budgets.team, void 0]];
+    if (customer) pairs.push([budgets.customer, customer]);
+    for (const [budget, id] of pairs)
+      for (const [limit, period, field] of LIMITS) {
+        const cap = budget[limit];
+        if (cap === void 0) continue;
+        const left = Math.max(0, cap - this.spent(app, id, period, now)[field]);
+        out[field] = Math.min(out[field] ?? Infinity, left);
+      }
+    return out;
+  }
+  // ---------------------------------------------------------- reports
+  /** Raw totals rows (key: team and customer), for shared storage. */
+  snapshot() {
+    return new Map([...this.rows].map(([k, r]) => [k, { ...r.totals }]));
+  }
+  lastSeen(app, customer) {
+    return this.rows.get(key(app, customer))?.lastSeen;
+  }
+  /**
+   * One row per customer with savings, spend today and this month; `rows` from
+   * shared storage when given, else this copy's own. `app` limits it to a team.
+   */
+  list(app, rows = this.snapshot(), now = /* @__PURE__ */ new Date()) {
+    const out = [];
+    for (const [k, t] of rows) {
+      const [team, customer] = k.split("\0");
+      if (app !== void 0 && team !== app) continue;
+      out.push(this.view(team, customer, t, now));
+    }
+    return out.sort((a, b) => b.costBeforeUsd - a.costBeforeUsd);
+  }
+  view(team, customer, t = emptyTotals(), now = /* @__PURE__ */ new Date()) {
+    const today = this.spent(team, customer, "day", now);
+    const month = this.spent(team, customer, "month", now);
+    const round2 = (n) => Math.round(n * 1e6) / 1e6;
+    return {
+      team,
+      customer,
+      ...view(t),
+      lastSeen: this.lastSeen(team, customer),
+      spentToday: { usd: round2(today.usd), tokens: today.tokens },
+      spentThisMonth: { usd: round2(month.usd), tokens: month.tokens }
+    };
+  }
+  // ---------------------------------------------------------- shared storage
+  /** Spend recorded since the last flush, by period key and field; marks it flushed. */
+  takeSpendDeltas(now = /* @__PURE__ */ new Date()) {
+    this.prune(now);
+    const out = [];
+    for (const [k, s] of this.local) {
+      const f = this.flushed.get(k) ?? { usd: 0, tokens: 0 };
+      const [period, ...rest] = k.split("\0");
+      const field = rest.join("\0");
+      if (s.usd !== f.usd) out.push({ period, field: `${field}\0usd`, by: s.usd - f.usd });
+      if (s.tokens !== f.tokens) out.push({ period, field: `${field}\0tokens`, by: s.tokens - f.tokens });
+      this.flushed.set(k, { ...s });
+    }
+    return out;
+  }
+  /** Every copy's spend for one period, as read from shared storage (fields: team, customer, usd|tokens). */
+  setSharedSpend(period, fields) {
+    for (const k of [...this.shared.keys()]) if (k.startsWith(`${period}\0`)) this.shared.delete(k);
+    for (const [field, value] of Object.entries(fields)) {
+      const parts = field.split("\0");
+      const name = parts.pop();
+      if (name !== "usd" && name !== "tokens") continue;
+      const k = key(period, ...parts);
+      const s = this.shared.get(k) ?? { usd: 0, tokens: 0 };
+      s[name] = Number(value);
+      this.shared.set(k, s);
+    }
+  }
+  /** Periods to read back from shared storage. */
+  currentPeriods(now = /* @__PURE__ */ new Date()) {
+    return this.prune(now);
+  }
+};
+
+// src/gateway/config.ts
+var DEFAULTS = {
+  port: 8080,
+  host: "0.0.0.0",
+  mode: "optimize",
+  level: "auto",
+  safe: { prompt: true, minifyJson: true, collapseRepeats: true, dedupeToolOutputs: true, dedupePassages: true, dedupeImages: true, promptCaching: true, dedupeRetries: true, cacheEmbeddings: true },
+  optIn: { elideOldToolOutputs: false, lazyTools: false, trimToolFields: false, compactJson: false, parkToolOutputs: false, flex: false, warmCache: false },
+  verify: { sampleRate: 0.05, minSimilarity: 0.8, maxShareOfSavings: 0.2, freeChecks: 5, probation: 5 },
+  runBudget: {},
+  batch: { flushSeconds: 60, pollSeconds: 60, maxRequests: 1e3, discount: 0.5 },
+  flexDiscount: 0.5,
+  embeddingsCacheMB: 256,
+  // Models carry their own long-context price (src/core/models.ts); entries here override or add to them.
+  priceTiers: [],
+  storage: { keyPrefix: "token-lens:", flushSeconds: 10, runDays: 7 },
+  retryWindowSeconds: 120,
+  blockOverContext: false,
+  upstreams: {},
+  routes: [],
+  models: [],
+  clientKeys: [],
+  customers: CUSTOMER_DEFAULTS,
+  isolateTeams: false,
+  maxBodyBytes: 32 * 1024 * 1024,
+  maxRuns: 2e3,
+  logRequests: true,
+  reportToolArgs: false
+};
+
 // src/gateway/optimize.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/gateway/images.ts
-import { createHash } from "node:crypto";
-var keyOf = (s) => createHash("sha256").update(s).digest("hex").slice(0, 24);
+import { createHash as createHash2 } from "node:crypto";
+var keyOf = (s) => createHash2("sha256").update(s).digest("hex").slice(0, 24);
 function imageSize(buf) {
   if (buf.length < 24) return void 0;
   if (buf.readUInt32BE(0) === 2303741511) return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
@@ -206713,33 +207030,33 @@ function findImages(protocol, body) {
     parts.forEach((p, idx) => {
       if (!p || typeof p !== "object") return;
       let data;
-      let key;
+      let key2;
       let detail;
       let textPart = (text) => ({ type: "text", text });
       if (protocol === "openai-chat" && p.type === "image_url") {
         const url = typeof p.image_url === "string" ? p.image_url : p.image_url?.url;
         if (typeof url !== "string") return;
         data = fromDataUrl(url);
-        key = keyOf(url);
+        key2 = keyOf(url);
         detail = p.image_url?.detail;
       } else if (protocol === "openai-responses" && p.type === "input_image") {
         if (typeof p.image_url !== "string") return;
         data = fromDataUrl(p.image_url);
-        key = keyOf(p.image_url);
+        key2 = keyOf(p.image_url);
         detail = p.detail;
         textPart = (text) => ({ type: "input_text", text });
       } else if (protocol === "anthropic" && p.type === "image") {
         const src = p.source ?? {};
         if (src.type === "base64" && typeof src.data === "string") {
           data = Buffer.from(src.data, "base64");
-          key = keyOf(src.data);
-        } else if (typeof src.url === "string") key = keyOf(src.url);
+          key2 = keyOf(src.data);
+        } else if (typeof src.url === "string") key2 = keyOf(src.url);
         else return;
       } else if (protocol === "anthropic" && p.type === "tool_result" && Array.isArray(p.content)) {
         return visit(p.content, turn);
       } else return;
       const size = data ? imageSize(data) : void 0;
-      out.push({ turn, key, ...size, detail, replace: (text) => parts[idx] = textPart(text) });
+      out.push({ turn, key: key2, ...size, detail, replace: (text) => parts[idx] = textPart(text) });
     });
   };
   const list = protocol === "openai-responses" ? Array.isArray(body?.input) ? body.input : [] : Array.isArray(body?.messages) ? body.messages : [];
@@ -206797,18 +207114,18 @@ function canonicalArgs(args) {
   const walk = (x) => Array.isArray(x) ? x.map(walk) : x && typeof x === "object" ? Object.fromEntries(Object.keys(x).sort().map((k) => [k, walk(x[k])])) : x;
   return JSON.stringify(walk(v ?? {}));
 }
-var textRef = (part, turn, obj, key) => ({
+var textRef = (part, turn, obj, key2) => ({
   part,
   turn,
-  get: () => obj[key],
+  get: () => obj[key2],
   set: (t) => {
-    obj[key] = t;
+    obj[key2] = t;
   }
 });
 var readOnly = (part, turn, text) => ({ part, turn, get: () => text });
-function contentRefs(part, turn, holder, key, types) {
-  const content = holder[key];
-  if (typeof content === "string") return [textRef(part, turn, holder, key)];
+function contentRefs(part, turn, holder, key2, types) {
+  const content = holder[key2];
+  if (typeof content === "string") return [textRef(part, turn, holder, key2)];
   if (!Array.isArray(content)) return [];
   return content.filter((b) => b && typeof b === "object" && types.includes(b.type) && typeof b.text === "string").map((b) => textRef(part, turn, b, "text"));
 }
@@ -206965,6 +207282,11 @@ function mergeUsage(a, b) {
 function usageIn(obj) {
   return readUsage(obj?.usage ?? obj?.message?.usage ?? obj?.response?.usage);
 }
+function errorBody(protocol, status, message) {
+  if (protocol === "anthropic")
+    return { type: "error", error: { type: status === 401 ? "authentication_error" : "invalid_request_error", message } };
+  return { error: { message, type: status === 401 ? "authentication_error" : "invalid_request_error", code: null } };
+}
 
 // src/gateway/optimize.ts
 var Counter = class {
@@ -207103,18 +207425,18 @@ function dedupePassages(text, turn, seenAt) {
   let changed = false;
   const inThisMessage = /* @__PURE__ */ new Set();
   for (let i = 0; i < pieces.length; i += 2) {
-    const key = pieces[i].trim().replace(/\s+/g, " ");
-    if (key.length < 200 || key.startsWith("[Token Lens:")) continue;
-    const at = seenAt.get(key);
-    if (inThisMessage.has(key)) {
+    const key2 = pieces[i].trim().replace(/\s+/g, " ");
+    if (key2.length < 200 || key2.startsWith("[Token Lens:")) continue;
+    const at = seenAt.get(key2);
+    if (inThisMessage.has(key2)) {
       pieces[i] = "[Token Lens: same passage as earlier in this message]";
       changed = true;
     } else if (at !== void 0 && at !== turn) {
       pieces[i] = `[Token Lens: same passage as in message ${at} above]`;
       changed = true;
     } else {
-      if (at === void 0) seenAt.set(key, turn);
-      inThisMessage.add(key);
+      if (at === void 0) seenAt.set(key2, turn);
+      inThisMessage.add(key2);
     }
   }
   return changed ? pieces.join("") : null;
@@ -207174,11 +207496,11 @@ function optimizeRequest(input) {
   if (cfg.safe.dedupeToolOutputs) {
     const first = /* @__PURE__ */ new Map();
     const firstSeen = (t, turn) => {
-      const key = t.trim();
-      if (key.length < 200) return null;
-      const at = first.get(key);
+      const key2 = t.trim();
+      if (key2.length < 200) return null;
+      const at = first.get(key2);
       if (at === void 0) {
-        first.set(key, turn);
+        first.set(key2, turn);
         return null;
       }
       return at === turn ? null : `[Token Lens: same output as the earlier tool result in message ${at}, which is unchanged above]`;
@@ -207251,7 +207573,7 @@ function applyPromptCaching(input, counts2) {
   if (parsed.protocol === "anthropic") return anthropicCaching(body) ? { id: "prompt-caching", saved: 0 } : null;
   const wantKey = input.upstream.type === "anthropic" || (input.upstream.promptCacheKey ?? /(^|\.)api\.openai\.com$/.test(new URL(input.upstream.baseUrl).hostname));
   if (!wantKey || body.prompt_cache_key !== void 0) return null;
-  body.prompt_cache_key = `tl-${createHash2("sha256").update(input.runId).digest("hex").slice(0, 24)}`;
+  body.prompt_cache_key = `tl-${createHash3("sha256").update(input.runId).digest("hex").slice(0, 24)}`;
   return { id: "prompt-caching", saved: 0 };
 }
 
@@ -207343,7 +207665,7 @@ function pricedFor(profile, inputTokens) {
   if (!lc || !profile.pricing || inputTokens <= lc.aboveTokens) return profile;
   return { ...profile, pricing: { ...profile.pricing, inputPerMTok: lc.inputPerMTok, outputPerMTok: lc.outputPerMTok } };
 }
-var hash = (s) => createHash3("sha256").update(s).digest("hex");
+var hash = (s) => createHash4("sha256").update(s).digest("hex");
 var TokenLens = class {
   options;
   counter = new Counter();
@@ -207361,25 +207683,57 @@ var TokenLens = class {
   rewriteMatched = 0;
   /** Safe fixes switched off because a check found a different answer while they were in play. */
   disabled = /* @__PURE__ */ new Set();
+  customers;
+  ledger;
   constructor(options = {}) {
     this.options = options;
     this.runId = options.run ?? randomUUID();
+    this.customers = { ...CUSTOMER_DEFAULTS, ...options.customers, teamBudgets: {} };
+    this.ledger = new CustomerLedger(this.customers.maxCustomers);
   }
   // ------------------------------------------------------------ hooks
   /** A fetch that applies Token Lens to OpenAI and Anthropic API calls and passes everything else through. */
   fetch(base) {
     const real = base ?? ((input, init) => globalThis.fetch(input, init));
-    return async (input, init) => {
+    return async (input, original) => {
       const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
       const path = new URL(url).pathname;
+      const ours = /* @__PURE__ */ new Map();
+      let init = original;
+      if (original?.headers) {
+        const headers = new Headers(original.headers);
+        for (const [k, v] of headers) if (k.startsWith("x-token-lens-")) ours.set(k, v);
+        if (ours.size) {
+          for (const k of ours.keys()) headers.delete(k);
+          init = { ...original, headers };
+        }
+      }
       const protocol = PATHS.find(([re]) => re.test(path))?.[1];
       if (!protocol || (init?.method ?? "GET").toUpperCase() !== "POST" || typeof init?.body !== "string") return real(input, init);
       let prep;
       try {
-        prep = this.prepare(protocol, init.body, new URL(url).origin);
+        prep = this.prepare(protocol, init.body, new URL(url).origin, ours.get("x-token-lens-customer"));
       } catch {
         return real(input, init);
       }
+      if (prep.customer) {
+        let budget;
+        try {
+          budget = customerBudget(this.customers, ours.get("x-token-lens-plan"), (n) => ours.get(n));
+        } catch (e) {
+          if (e instanceof UnknownPlanError) return Response.json(errorBody(protocol, 400, e.message), { status: 400 });
+          throw e;
+        }
+        if (hasLimits(budget)) {
+          const over = this.ledger.over("app", prep.customer, { customer: budget, team: {} });
+          if (over) {
+            const period = over.limit.startsWith("daily") ? "daily" : "monthly";
+            const message = `Token Lens stopped this call: customer "${prep.customer}" reached its ${period} limit (${over.limit.endsWith("Usd") ? `$${over.spent.toFixed(4)} of $${over.cap}` : `${over.spent} of ${over.cap} tokens`}).`;
+            this.record({ ...this.base(prep), status: 429, usage: {}, replayed: false });
+            return Response.json(errorBody(protocol, 429, message), { status: 429, headers: { "x-token-lens-budget": `customer-${period}-${over.limit.endsWith("Usd") ? "usd" : "tokens"}` } });
+          }
+        }
+      }
       return this.send(real, input, init, prep);
     };
   }
@@ -207427,9 +207781,18 @@ var TokenLens = class {
       byFix: [...this.byFix].map(([fix, f]) => ({ fix, calls: f.calls, tokens: f.tokens, usd: Math.round(f.usd * 1e6) / 1e6 })),
       checks: { ...summarizeChecks(this.checks), recent: this.checks.slice(-20) },
       rewritePrompts: !this.options.rewritePrompts ? "off" : this.rewriteStopped ? "switched off: an output check found a different answer" : this.onProbation() ? `on probation: ${this.rewriteMatched} of ${this.probation()} answers matched so far` : "on",
-      switchedOff: [...this.disabled]
+      switchedOff: [...this.disabled],
+      byCustomer: this.ledger.list("app").map(({ team: _t, ...r }) => r)
     };
   }
+  /** One customer's savings, and spend today and this month (limits count these), or undefined before its first call. */
+  customer(id) {
+    const stored = storedId(id, this.customers);
+    const row = this.ledger.snapshot().get(`app\0${stored}`);
+    if (!row) return void 0;
+    const { team: _t, ...r } = this.ledger.view("app", stored, row);
+    return r;
+  }
   /** The report in a few plain lines. */
   summary() {
     const r = this.report();
@@ -207467,8 +207830,9 @@ var TokenLens = class {
       optIn: Object.fromEntries(Object.keys(DEFAULTS.optIn).map((k) => [k, false]))
     };
   }
-  prepare(protocol, raw, origin) {
+  prepare(protocol, raw, origin, customerHeader) {
     const body = JSON.parse(raw);
+    const customer = customerOf(customerHeader, body, this.customers);
     const parsed = parseRequest(protocol, body);
     const profile = this.profile(parsed.model);
     const before = countParts(parsed.refs, profile, this.counter);
@@ -207507,15 +207871,16 @@ var TokenLens = class {
       after,
       // As in the gateway: the sum of what each fix removed (estimates count the line breaks it drops).
       savedInput: actions.reduce((n, a) => n + a.saved, 0),
-      body: actions.length ? JSON.stringify(body) : raw
+      body: actions.length ? JSON.stringify(body) : raw,
+      customer
     };
   }
   async send(real, input, init, prep) {
     const { parsed } = prep;
     const replayable = (this.options.fixes?.dedupeRetries ?? true) && this.options.mode !== "observe" && !parsed.stream && parsed.temperature === 0;
-    const key = replayable ? hash(`${prep.protocol}\0${String(input instanceof Request ? input.url : input)}\0${prep.body}`) : "";
+    const key2 = replayable ? hash(`${prep.customer ?? ""}\0${prep.protocol}\0${String(input instanceof Request ? input.url : input)}\0${prep.body}`) : "";
     const windowMs = (this.options.retryWindowSeconds ?? 120) * 1e3;
-    const cached = replayable ? this.replays.get(key) : void 0;
+    const cached = replayable ? this.replays.get(key2) : void 0;
     if (cached && Date.now() - cached.at < windowMs) {
       this.record({ ...this.base(prep), status: cached.status, usage: cached.usage, replayed: true });
       return new Response(cached.text, { status: cached.status, headers: [...cached.headers, ["x-token-lens-replayed", "true"]] });
@@ -207569,7 +207934,7 @@ var TokenLens = class {
     const usage = usageIn(json);
     this.record({ ...this.base(prep), status: res.status, usage, replayed: false });
     if (replayable && res.ok && text) {
-      this.replays.set(key, { at: Date.now(), status: res.status, headers: [...res.headers], text, usage });
+      this.replays.set(key2, { at: Date.now(), status: res.status, headers: [...res.headers], text, usage });
       if (this.replays.size > 500) this.replays.delete(this.replays.keys().next().value);
     }
     if (res.ok && json && prep.savedInput > 0) this.maybeCheck(real, input, init, prep, json);
@@ -207647,7 +208012,8 @@ var TokenLens = class {
       stream: prep.parsed.stream,
       savedInput: prep.savedInput,
       actions: prep.actions,
-      estimatedInput: prep.after.total
+      estimatedInput: prep.after.total,
+      customer: prep.customer
     };
   }
   record(c) {
@@ -207659,6 +208025,7 @@ var TokenLens = class {
     if (!row) this.rows.set(profile.id, row = emptyTotals());
     const savedInput = c.status < 400 ? c.savedInput : 0;
     addCall(row, { profile, status: c.status, usage, estimatedInput: c.estimatedInput, savedInput, replayed: c.replayed });
+    this.ledger.record("app", c.customer, { profile, status: c.status, usage, estimatedInput: c.estimatedInput, savedInput, replayed: c.replayed });
     const unoptimized = pricedFor(c.profile, input + savedInput);
     if (!c.replayed && unoptimized !== profile) {
       const u = { ...usage, inputTokens: input };
@@ -207685,6 +208052,7 @@ var TokenLens = class {
       }
     this.options.onCall?.({
       protocol: c.protocol,
+      ...c.customer ? { customer: c.customer } : {},
       model: c.model,
       profile: profile.id,
       status: c.status,