@parallel-protocol/x402 0.6.0 → 0.7.0

package/dist/llm.d.ts

@@ -0,0 +1,203 @@
+import { m as PriceFunction, g as MeterFunction } from './types-q_gu5wjz.js';
+import 'viem';
+
+/**
+ * Input token bound for an OpenAI-compatible chat completion, without a
+ * tokenizer. The cap the payer signs must cover the real count, whichever
+ * tokenizer the provider uses, or the response is refused and the merchant
+ * has paid the provider for nothing. Every tokenizer in use covers at least
+ * one byte of input per token (byte-level BPE, SentencePiece with byte
+ * fallback, character-level), so the number of UTF-8 bytes is a bound the
+ * real count never exceeds. English prose runs at about four characters per
+ * token, so the bound is loose there; the payer only ever pays the real
+ * count and the difference is refunded. A merchant who wants a tighter cap
+ * plugs a real tokenizer through `estimateInputTokens`.
+ */
+type ChatMessage = {
+    role?: string;
+    name?: string;
+    content?: unknown;
+    tool_calls?: unknown;
+    tool_call_id?: string;
+};
+interface ChatCompletionBody {
+    model?: unknown;
+    messages?: unknown;
+    tools?: unknown;
+    max_tokens?: unknown;
+    max_completion_tokens?: unknown;
+    n?: unknown;
+    stream?: unknown;
+    plugins?: unknown;
+    web_search_options?: unknown;
+    modalities?: unknown;
+}
+/** An upper bound on the tokens of a piece of text: its UTF-8 bytes. */
+declare function estimateTokens(text: string): number;
+/** A bound on the input tokens of a chat completion body: messages, then tools. */
+declare function estimateInputTokens(body: ChatCompletionBody): number;
+
+/** What a model costs, in USD per million tokens. */
+interface ModelPrice {
+    input: number;
+    output: number;
+    /** Largest completion the provider serves for this model, when known. */
+    maxOutputTokens?: number;
+}
+/** A fixed price list keyed by model id. */
+type PriceTable = Record<string, ModelPrice>;
+/** Where the cap looks prices up. Resolves `undefined` for an unknown model. */
+interface PriceSource {
+    get(model: string): Promise<ModelPrice | undefined>;
+}
+/** Prices written in the merchant's config: no network, no cache. */
+declare function staticPrices(table: PriceTable): PriceSource;
+interface OpenRouterPricesOptions {
+    /**
+     * How long a loaded price list is served before it is refreshed in the
+     * background: a number of milliseconds or a duration such as `"24h"`,
+     * `"1h"`, `"30m"`. Default `"24h"`. `0` refreshes on every request.
+     */
+    ttl?: number | string;
+    /** The models endpoint. Default `https://openrouter.ai/api/v1/models`. */
+    url?: string;
+    /** The fetch implementation to use. Default: the global `fetch`. */
+    fetch?: typeof fetch;
+    /** How long one load may take before it is abandoned. Default `"10s"`. */
+    timeout?: number | string;
+}
+/** Parses `"24h"`, `"90m"`, `"30s"` or a number of milliseconds. */
+declare function parseDuration(value: number | string): number;
+/**
+ * Maps the models listing to a price table, dropping models without a plain
+ * decimal price. The listing names one provider's completion limit per
+ * model, but a model is served by several providers with different limits,
+ * so no output bound is taken from it: the route's `maxOutputTokens` rules.
+ */
+declare function parseOpenRouterModels(payload: unknown): PriceTable;
+/**
+ * Live prices from OpenRouter's public models listing (no API key). Loaded on
+ * first use, then served from memory; once older than `ttl` the list is
+ * refreshed in the background while requests keep using the current one, so
+ * no request ever waits for OpenRouter after the first. A refresh that fails
+ * keeps the current list. With no list at all, requests are refused with a
+ * 503 until one loads.
+ */
+declare function openRouterPrices(options?: OpenRouterPricesOptions): PriceSource;
+
+interface ChatCompletionCapOptions {
+    /** Model prices: a live source such as `openRouterPrices()` or a fixed table. */
+    prices: PriceSource | PriceTable;
+    /**
+     * Largest completion this route pays for. It bounds the request's
+     * `max_tokens` in the cap and stands in for it when absent, so the handler
+     * must forward the same bound to the provider. Default 4096.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Extra margin applied to the input token bound, for a merchant who
+     * replaces the built-in bound with a tighter estimate. Default 0.
+     */
+    margin?: number;
+    /** Models this route serves. Default: every model the price source knows. */
+    models?: string[];
+    /**
+     * Accept streamed requests. Default false: refused before payment. A
+     * streamed response cannot carry the actual cost, so it is charged the cap.
+     */
+    allowStreaming?: boolean;
+    /** Replaces the built-in input token bound, for a real tokenizer. */
+    estimateInputTokens?: (body: ChatCompletionBody) => number;
+}
+/**
+ * The cap of an OpenAI-compatible chat completion, computed from the request
+ * body: the input token bound (plus margin) at the model's input price, plus
+ * the largest completion the request may produce at its output price.
+ * Requests this route cannot meter are refused before anything is invoiced:
+ * an unknown or disallowed model, more than one choice, non-text content,
+ * options billed outside the token model (plugins, web search, image or
+ * audio output), and streaming unless allowed.
+ */
+declare function chatCompletionCap(options: ChatCompletionCapOptions): PriceFunction;
+
+interface ForwardChatCompletionOptions {
+    /** The provider's OpenAI-compatible base URL, e.g. `https://openrouter.ai/api/v1`. */
+    baseUrl: string;
+    /** Sent as a bearer token when set. */
+    apiKey?: string;
+    /**
+     * Bound on the completion, forwarded as such: the same value the route's
+     * cap pays for. Default 4096.
+     */
+    maxOutputTokens?: number;
+    /**
+     * The request field that carries the bound. OpenRouter and most providers
+     * take `max_tokens`; OpenAI's newer models want `max_completion_tokens`.
+     * Default `"max_tokens"`.
+     */
+    outputTokensField?: "max_tokens" | "max_completion_tokens";
+    /** How long the provider may take before the call is abandoned. Default `"5m"`. */
+    timeout?: number | string;
+    /** Extra request headers (an app name, a referer). */
+    headers?: Record<string, string>;
+    /** The fetch implementation to use. Default: the global `fetch`. */
+    fetch?: typeof fetch;
+    /** The request fields forwarded to the provider. Default: `FORWARDED_FIELDS`. */
+    fields?: readonly string[];
+}
+interface ForwardedResponse {
+    status: number;
+    /** The provider's JSON, or its text when it is not JSON. */
+    body: unknown;
+}
+/**
+ * The request fields a metered route accounts for. The completion bound and
+ * `stream` are set separately; anything else in the body is dropped, so an
+ * option billed outside the token model never reaches the provider.
+ */
+declare const FORWARDED_FIELDS: readonly ["model", "messages", "tools", "tool_choice", "parallel_tool_calls", "response_format", "temperature", "top_p", "top_k", "min_p", "stop", "seed", "presence_penalty", "frequency_penalty", "repetition_penalty", "logit_bias", "reasoning", "reasoning_effort", "user"];
+/**
+ * Forwards a chat completion to an OpenAI-compatible provider and returns
+ * its status and body, for a handler to send back as they are. Only the
+ * fields the cap accounts for are forwarded, with `stream: false` and the
+ * completion bounded by `maxOutputTokens` (a `reasoning.max_tokens` budget
+ * is bounded the same way). A provider error about the request keeps its
+ * status, so the middleware settles nothing; a provider error about the
+ * merchant's account, or a provider that cannot be reached, answers 502
+ * with a fixed body; a timeout answers 504.
+ */
+declare function forwardChatCompletion(body: unknown, options: ForwardChatCompletionOptions): Promise<ForwardedResponse>;
+
+interface ChatCompletionMeterOptions {
+    /**
+     * Model prices, for providers whose responses carry token counts but no
+     * cost: `openRouterPrices()` or a fixed table in USD per million tokens.
+     */
+    prices?: PriceSource | PriceTable;
+}
+/**
+ * The amount an OpenAI-compatible chat completion actually cost, read from
+ * the provider's response: `usage.cost` in dollars when the provider reports
+ * one (OpenRouter does), otherwise `usage.prompt_tokens` and
+ * `usage.completion_tokens` at the model's prices when a price source is
+ * given. With neither, no amount: the middleware falls back to the cap.
+ * One USDp per dollar. A zero cost serves the request for free. Whatever
+ * the provider sends, the result is an amount or nothing, never a failure.
+ */
+declare function chatCompletionMeter(options?: ChatCompletionMeterOptions): MeterFunction;
+
+/**
+ * Micro-dollars to an amount string such as `"0.016875"` (1 USDp = 1 USD).
+ * Only a safe non-negative integer prints as an amount: anything else would
+ * come out in exponent form and be refused downstream.
+ */
+declare function formatMicroUsd(micro: number): string;
+/**
+ * Dollars to whole micro-dollars, rounded up. The intermediate rounding to
+ * a thousandth of a micro-dollar removes the binary noise of the product
+ * (0.0005 dollars must be 500, not 501). An amount too large to print is
+ * bounded; the cap bounds it again downstream.
+ */
+declare function microFromUsd(dollars: number): number;
+
+export { type ChatCompletionBody, type ChatCompletionCapOptions, type ChatCompletionMeterOptions, type ChatMessage, FORWARDED_FIELDS, type ForwardChatCompletionOptions, type ForwardedResponse, type ModelPrice, type OpenRouterPricesOptions, type PriceSource, type PriceTable, chatCompletionCap, chatCompletionMeter, estimateInputTokens, estimateTokens, formatMicroUsd, forwardChatCompletion, microFromUsd, openRouterPrices, parseDuration, parseOpenRouterModels, staticPrices };

package/dist/llm.js

@@ -0,0 +1,473 @@
+import { X402ConfigError, X402PriceRejectedError } from './chunk-AFRDHGDT.js';
+
+// src/llm/estimate.ts
+function estimateTokens(text) {
+  let bytes = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    bytes += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+  }
+  return bytes;
+}
+var TOKENS_PER_MESSAGE = 8;
+var PRIMING_TOKENS = 3;
+function messageText(message) {
+  const parts = [
+    String(message.role ?? ""),
+    String(message.name ?? "")
+  ];
+  if (typeof message.content === "string") {
+    parts.push(message.content);
+  } else if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (typeof part?.text === "string") parts.push(part.text);
+      else if (part?.text != null) parts.push(String(part.text));
+    }
+  } else if (message.content != null) {
+    parts.push(JSON.stringify(message.content) ?? "");
+  }
+  if (message.tool_calls != null) {
+    parts.push(JSON.stringify(message.tool_calls) ?? "");
+  }
+  if (message.tool_call_id != null) parts.push(String(message.tool_call_id));
+  return parts.join(" ");
+}
+function estimateInputTokens(body) {
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  let tokens = PRIMING_TOKENS;
+  for (const message of messages) {
+    const text = typeof message === "object" && message !== null ? messageText(message) : String(message ?? "");
+    tokens += TOKENS_PER_MESSAGE + estimateTokens(text);
+  }
+  if (body.tools != null) {
+    tokens += estimateTokens(JSON.stringify(body.tools) ?? "");
+  }
+  return tokens;
+}
+
+// src/llm/money.ts
+function formatMicroUsd(micro) {
+  if (!Number.isSafeInteger(micro) || micro < 0) {
+    throw new RangeError(`not a micro-dollar amount: ${micro}`);
+  }
+  const whole = Math.floor(micro / 1e6);
+  const fraction = String(micro % 1e6).padStart(6, "0");
+  return `${whole}.${fraction}`;
+}
+function clampMicro(micro) {
+  if (Number.isNaN(micro) || micro <= 0) return 0;
+  return Math.min(Math.ceil(micro), Number.MAX_SAFE_INTEGER);
+}
+function microFromUsd(dollars2) {
+  return clampMicro(Math.round(dollars2 * 1e9) / 1e3);
+}
+
+// src/llm/prices.ts
+function lookup(table, model) {
+  return Object.hasOwn(table, model) ? table[model] : void 0;
+}
+function staticPrices(table) {
+  for (const [model, price] of Object.entries(table)) {
+    if (!isValidPrice(price)) {
+      throw new X402ConfigError(
+        `Invalid price for model "${model}": expected { input, output } in USD per million tokens`
+      );
+    }
+  }
+  return { get: async (model) => lookup(table, model) };
+}
+function isPriceSource(value) {
+  return typeof value.get === "function";
+}
+function toPriceSource(value) {
+  return isPriceSource(value) ? value : staticPrices(value);
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+var DEFAULT_MAX_OUTPUT_TOKENS = 4096;
+function isValidPrice(price) {
+  if (typeof price !== "object" || price === null) return false;
+  const { input, output, maxOutputTokens } = price;
+  const rate = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+  const bound = maxOutputTokens === void 0 || typeof maxOutputTokens === "number" && Number.isInteger(maxOutputTokens) && maxOutputTokens > 0;
+  return rate(input) && rate(output) && bound;
+}
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var RETRY_AFTER_MS = 5e3;
+var MISS_REFRESH_MS = 5 * 6e4;
+var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+function shortName(value) {
+  return value.length > 80 ? `${value.slice(0, 77)}...` : value;
+}
+function parseDuration(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new X402ConfigError(`Invalid duration: ${value}`);
+    }
+    return value;
+  }
+  const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);
+  if (!match) {
+    throw new X402ConfigError(
+      `Invalid duration "${value}": expected a number of milliseconds or a value like "24h", "30m", "10s"`
+    );
+  }
+  const amount = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  const factor = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return amount * factor;
+}
+var DECIMAL = /^\d+(?:\.\d+)?$/;
+function perMillion(perToken) {
+  if (typeof perToken !== "string" || !DECIMAL.test(perToken)) return NaN;
+  const value = Number(perToken) * 1e6;
+  return Math.round(value * 1e9) / 1e9;
+}
+function parseOpenRouterModels(payload) {
+  const data = payload?.data;
+  if (!Array.isArray(data)) {
+    throw new Error("unexpected models payload: no `data` array");
+  }
+  const table = /* @__PURE__ */ Object.create(null);
+  for (const raw of data) {
+    if (typeof raw?.id !== "string" || typeof raw.pricing !== "object") {
+      continue;
+    }
+    const input = perMillion(raw.pricing?.prompt);
+    const output = perMillion(raw.pricing?.completion);
+    if (!Number.isFinite(input) || !Number.isFinite(output)) continue;
+    table[raw.id] = { input, output };
+  }
+  if (Object.keys(table).length === 0) {
+    throw new Error("unexpected models payload: no priced model");
+  }
+  return table;
+}
+function openRouterPrices(options = {}) {
+  const ttlMs = parseDuration(options.ttl ?? DEFAULT_TTL_MS);
+  const timeoutMs = parseDuration(options.timeout ?? DEFAULT_TIMEOUT_MS);
+  const url = options.url ?? OPENROUTER_MODELS_URL;
+  const doFetch = options.fetch ?? globalThis.fetch;
+  let table;
+  let loadedAt = 0;
+  let failedAt = 0;
+  let inflight;
+  const load = () => {
+    if (inflight) return inflight;
+    inflight = (async () => {
+      const res = await doFetch(url, {
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok) throw new Error(`OpenRouter models: HTTP ${res.status}`);
+      table = parseOpenRouterModels(await res.json());
+      loadedAt = Date.now();
+    })().catch((cause) => {
+      failedAt = Date.now();
+      throw cause;
+    }).finally(() => {
+      inflight = void 0;
+    });
+    return inflight;
+  };
+  const canRetry = () => Date.now() - failedAt >= RETRY_AFTER_MS;
+  return {
+    async get(model) {
+      if (!table) {
+        if (canRetry()) await load().catch(() => {
+        });
+        if (!table) {
+          throw new X402PriceRejectedError(
+            "PRICING_UNAVAILABLE",
+            "Model prices are not available right now, retry shortly",
+            503
+          );
+        }
+      } else if (Date.now() - loadedAt >= ttlMs && canRetry()) {
+        load().catch(() => {
+        });
+      }
+      const price = lookup(table, model);
+      if (price) return price;
+      if (!inflight && Date.now() - loadedAt >= MISS_REFRESH_MS && canRetry()) {
+        load().catch(() => {
+        });
+      }
+      if (inflight) {
+        throw new X402PriceRejectedError(
+          "UNKNOWN_MODEL",
+          `No price known for model "${shortName(model)}" yet. The price list is being refreshed, retry in a few seconds.`
+        );
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/llm/cap.ts
+var DEFAULT_MARGIN = 0;
+function reject(code, message) {
+  throw new X402PriceRejectedError(code, message);
+}
+function isTextOnly(modalities) {
+  return Array.isArray(modalities) && modalities.every((modality) => modality === "text");
+}
+function chatCompletionCap(options) {
+  const source = toPriceSource(options.prices);
+  const maxOutputTokens = options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+  const margin = options.margin ?? DEFAULT_MARGIN;
+  const allowed = options.models ? new Set(options.models) : void 0;
+  const estimate = options.estimateInputTokens ?? estimateInputTokens;
+  if (positiveInteger(maxOutputTokens) === void 0) {
+    throw new X402ConfigError(
+      `chatCompletionCap: maxOutputTokens must be a positive integer, got ${maxOutputTokens}`
+    );
+  }
+  if (!Number.isFinite(margin) || margin < 0) {
+    throw new X402ConfigError(
+      `chatCompletionCap: margin must be a non-negative number, got ${margin}`
+    );
+  }
+  if (allowed?.size === 0) {
+    throw new X402ConfigError("chatCompletionCap: models must not be empty");
+  }
+  return async (ctx) => {
+    const raw = ctx.body;
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      reject("INVALID_REQUEST", "Expected a JSON chat completion body");
+    }
+    const body = raw;
+    const model = body.model;
+    if (typeof model !== "string" || model.length === 0) {
+      reject("INVALID_REQUEST", "Expected a `model` in the request body");
+    }
+    if (!Array.isArray(body.messages) || body.messages.length === 0) {
+      reject("INVALID_REQUEST", "Expected a non-empty `messages` array");
+    }
+    if (allowed && !allowed.has(model)) {
+      reject(
+        "MODEL_NOT_ALLOWED",
+        `Model "${shortName(model)}" is not served here`
+      );
+    }
+    if (body.n != null && body.n !== 1) {
+      reject("UNSUPPORTED_OPTION", "Only one choice per request (`n` = 1)");
+    }
+    if (body.stream != null && body.stream !== false && !options.allowStreaming) {
+      reject("UNSUPPORTED_OPTION", "Streaming is not supported on this route");
+    }
+    if (body.plugins != null || body.web_search_options != null) {
+      reject(
+        "UNSUPPORTED_OPTION",
+        "Plugins and web search are not supported on this route"
+      );
+    }
+    if (body.modalities != null && !isTextOnly(body.modalities)) {
+      reject(
+        "UNSUPPORTED_OPTION",
+        "Only text output is supported on this route"
+      );
+    }
+    for (const message of body.messages) {
+      if (!Array.isArray(message?.content)) continue;
+      for (const part of message.content) {
+        if (part?.type !== "text") {
+          reject(
+            "UNSUPPORTED_OPTION",
+            "Only text content is supported on this route"
+          );
+        }
+      }
+    }
+    const requestedRaw = body.max_tokens ?? body.max_completion_tokens;
+    let requested;
+    if (requestedRaw != null) {
+      requested = positiveInteger(requestedRaw);
+      if (requested === void 0) {
+        reject("INVALID_REQUEST", "`max_tokens` must be a positive integer");
+      }
+    }
+    const price = await source.get(model);
+    if (!price) {
+      reject("UNKNOWN_MODEL", `No price known for model "${shortName(model)}"`);
+    }
+    if (!isValidPrice(price)) {
+      throw new X402ConfigError(
+        `chatCompletionCap: the price source returned an invalid price for model "${shortName(model)}"`
+      );
+    }
+    const inputTokens = Math.ceil(estimate(body) * (1 + margin));
+    const outputTokens = Math.min(
+      requested ?? maxOutputTokens,
+      maxOutputTokens,
+      price.maxOutputTokens ?? Number.POSITIVE_INFINITY
+    );
+    const micro = Math.max(
+      1,
+      clampMicro(inputTokens * price.input + outputTokens * price.output)
+    );
+    return formatMicroUsd(micro);
+  };
+}
+
+// src/llm/forward.ts
+var FORWARDED_FIELDS = [
+  "model",
+  "messages",
+  "tools",
+  "tool_choice",
+  "parallel_tool_calls",
+  "response_format",
+  "temperature",
+  "top_p",
+  "top_k",
+  "min_p",
+  "stop",
+  "seed",
+  "presence_penalty",
+  "frequency_penalty",
+  "repetition_penalty",
+  "logit_bias",
+  "reasoning",
+  "reasoning_effort",
+  "user"
+];
+var DEFAULT_TIMEOUT_MS2 = 5 * 6e4;
+var CLIENT_STATUSES = /* @__PURE__ */ new Set([400, 404, 405, 408, 409, 413, 415, 422, 429]);
+var failure = (status, error, message) => ({
+  status,
+  body: { error, message }
+});
+async function forwardChatCompletion(body, options) {
+  if (typeof options.baseUrl !== "string" || !URL.canParse(options.baseUrl)) {
+    throw new X402ConfigError(
+      `forwardChatCompletion: baseUrl must be a URL, got ${JSON.stringify(options.baseUrl)}`
+    );
+  }
+  const maxOutputTokens = options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+  if (positiveInteger(maxOutputTokens) === void 0) {
+    throw new X402ConfigError(
+      `forwardChatCompletion: maxOutputTokens must be a positive integer, got ${maxOutputTokens}`
+    );
+  }
+  const timeoutMs = parseDuration(options.timeout ?? DEFAULT_TIMEOUT_MS2);
+  const fields = options.fields ?? FORWARDED_FIELDS;
+  const outputField = options.outputTokensField ?? "max_tokens";
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const source = typeof body === "object" && body !== null && !Array.isArray(body) ? body : {};
+  const upstream = {};
+  for (const field of fields) {
+    if (Object.hasOwn(source, field) && source[field] !== void 0) {
+      upstream[field] = source[field];
+    }
+  }
+  const requested = positiveInteger(source.max_tokens) ?? positiveInteger(source.max_completion_tokens);
+  const bound = Math.min(requested ?? maxOutputTokens, maxOutputTokens);
+  delete upstream.max_tokens;
+  delete upstream.max_completion_tokens;
+  upstream[outputField] = bound;
+  upstream.stream = false;
+  const reasoning = upstream.reasoning;
+  if (typeof reasoning === "object" && reasoning !== null) {
+    const budget = reasoning.max_tokens;
+    if (typeof budget === "number" && budget > bound) {
+      upstream.reasoning = { ...reasoning, max_tokens: bound };
+    }
+  }
+  const url = `${options.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+  let status;
+  let text;
+  try {
+    const res = await doFetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...options.apiKey && { authorization: `Bearer ${options.apiKey}` },
+        ...options.headers
+      },
+      body: JSON.stringify(upstream),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    status = res.status;
+    text = await res.text();
+  } catch (cause) {
+    return cause?.name === "TimeoutError" ? failure(
+      504,
+      "UPSTREAM_TIMEOUT",
+      "The model provider did not answer in time"
+    ) : failure(
+      502,
+      "UPSTREAM_UNAVAILABLE",
+      "The model provider could not be reached"
+    );
+  }
+  if (status >= 200 && status < 300) {
+    let parsed = text;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+    }
+    return { status, body: parsed };
+  }
+  if (CLIENT_STATUSES.has(status)) {
+    let parsed = text;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+    }
+    return { status, body: parsed };
+  }
+  return failure(
+    502,
+    "UPSTREAM_ERROR",
+    "The model provider refused the request"
+  );
+}
+
+// src/llm/meter.ts
+var DECIMAL2 = /^\d+(?:\.\d+)?$/;
+function nonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function dollars(value) {
+  const number = typeof value === "number" ? value : typeof value === "string" && DECIMAL2.test(value) ? Number(value) : void 0;
+  return number !== void 0 && Number.isFinite(number) && number >= 0 ? number : void 0;
+}
+function chatCompletionMeter(options = {}) {
+  const source = options.prices === void 0 ? void 0 : toPriceSource(options.prices);
+  return async ({ body, request }) => {
+    const response = body;
+    const usage = response?.usage;
+    if (typeof usage !== "object" || usage === null || Array.isArray(usage)) {
+      return void 0;
+    }
+    const { cost, prompt_tokens, completion_tokens } = usage;
+    const reported = dollars(cost);
+    if (reported !== void 0) return formatMicroUsd(microFromUsd(reported));
+    if (!source) return void 0;
+    const input = nonNegativeInteger(prompt_tokens);
+    const output = nonNegativeInteger(completion_tokens);
+    if (input === void 0 || output === void 0) return void 0;
+    const candidates = [
+      response?.model,
+      request.body?.model
+    ].filter((model) => typeof model === "string");
+    for (const model of candidates) {
+      let price;
+      try {
+        price = await source.get(model);
+      } catch {
+        return void 0;
+      }
+      if (isValidPrice(price)) {
+        return formatMicroUsd(
+          clampMicro(input * price.input + output * price.output)
+        );
+      }
+    }
+    return void 0;
+  };
+}
+
+export { FORWARDED_FIELDS, chatCompletionCap, chatCompletionMeter, estimateInputTokens, estimateTokens, formatMicroUsd, forwardChatCompletion, microFromUsd, openRouterPrices, parseDuration, parseOpenRouterModels, staticPrices };