@usagetap/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1573 @@
+'use strict';
+
+// src/errors.ts
+var UsageTapError = class extends Error {
+  code;
+  status;
+  retryable;
+  correlationId;
+  details;
+  constructor(code, message, init = {}) {
+    super(message, init.cause ? { cause: init.cause } : void 0);
+    this.name = "UsageTapError";
+    this.code = code;
+    this.status = init.status;
+    this.retryable = init.retryable ?? false;
+    this.correlationId = init.correlationId;
+    this.details = init.details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      retryable: this.retryable,
+      correlationId: this.correlationId,
+      details: this.details
+    };
+  }
+};
+function isUsageTapError(error) {
+  return error instanceof UsageTapError;
+}
+
+// src/idempotency.ts
+function createIdempotencyKey() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  const random = () => Math.random().toString(16).slice(2, 10);
+  return `${random()}-${random()}`;
+}
+
+// src/retry.ts
+var DEFAULTS = {
+  maxAttempts: 3,
+  baseDelayMs: 250,
+  maxDelayMs: 5e3,
+  jitterRatio: 0.2
+};
+function resolveRetryOptions(base, override) {
+  const merged = { ...DEFAULTS, ...base, ...override };
+  return {
+    maxAttempts: Math.max(1, Math.floor(merged.maxAttempts)),
+    baseDelayMs: Math.max(0, merged.baseDelayMs),
+    maxDelayMs: Math.max(merged.baseDelayMs, merged.maxDelayMs),
+    jitterRatio: Math.min(Math.max(merged.jitterRatio, 0), 1)
+  };
+}
+async function sleep(delayMs, signal) {
+  if (delayMs <= 0) {
+    signal?.throwIfAborted?.();
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, delayMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      const abortError = new Error("Aborted");
+      abortError.name = "AbortError";
+      reject(abortError);
+    };
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function computeDelay(attempt, options) {
+  const exp = options.baseDelayMs * Math.pow(2, attempt - 1);
+  const capped = Math.min(exp, options.maxDelayMs);
+  const jitter = capped * options.jitterRatio;
+  const min = capped - jitter;
+  const max = capped + jitter;
+  return Math.max(0, Math.random() * (max - min) + min);
+}
+async function runWithRetry(operation, options, shouldRetry, onSchedule, signal) {
+  let attempt = 0;
+  let lastError;
+  while (attempt < options.maxAttempts) {
+    attempt += 1;
+    signal?.throwIfAborted?.();
+    try {
+      return await operation(attempt);
+    } catch (error) {
+      lastError = error;
+      if (attempt >= options.maxAttempts || !shouldRetry(error)) {
+        throw error;
+      }
+      const delayMs = computeDelay(attempt, options);
+      onSchedule?.(attempt, delayMs, error);
+      await sleep(delayMs, signal);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+// src/client.ts
+var CALL_BEGIN_PATH = "call_begin";
+var CALL_END_PATH = "call_end";
+var AUTH_HEADER = "authorization";
+var API_KEY_HEADER = "x-api-key";
+var CORRELATION_HEADER = "x-usage-correlation-id";
+var IDEMPOTENCY_HEADER = "idempotency-key";
+var SDK_HEADER = "x-usage-sdk";
+var USER_AGENT = "UsageTapClient";
+var CANONICAL_MEDIA_TYPE = "application/vnd.usagetap.v1+json";
+var SDK_VERSION = "0.1.0" ;
+var HAS_WINDOW = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+var UsageTapClient = class {
+  apiKey;
+  baseUrl;
+  fetchImpl;
+  defaultFeature;
+  defaultTags;
+  defaultHeaders;
+  retryDefaults;
+  idempotencyGenerator;
+  logFn;
+  authHeader;
+  autoIdempotency;
+  constructor(options) {
+    if (!options) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "UsageTapClient options are required"
+      );
+    }
+    if (!options.apiKey) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "UsageTapClient requires an apiKey"
+      );
+    }
+    if (!options.baseUrl) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "UsageTapClient requires a baseUrl"
+      );
+    }
+    if (HAS_WINDOW && !options.allowBrowser) {
+      throw new UsageTapError(
+        "USAGETAP_BROWSER_RUNTIME",
+        "UsageTapClient is designed for server-side environments. Pass allowBrowser=true only for testing."
+      );
+    }
+    const fetchCandidate = options.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchCandidate !== "function") {
+      throw new UsageTapError(
+        "USAGETAP_NETWORK_ERROR",
+        "A global fetch implementation was not found. Pass fetchImpl in UsageTapClientOptions."
+      );
+    }
+    const normalizedBaseUrl = normalizeBaseUrl(options.baseUrl);
+    this.baseUrl = new URL(normalizedBaseUrl);
+    this.apiKey = options.apiKey;
+    this.fetchImpl = fetchCandidate;
+    this.defaultFeature = options.defaultFeature;
+    this.defaultTags = options.defaultTags?.length ? dedupeStrings(options.defaultTags) : void 0;
+    this.defaultHeaders = options.headers ? normalizeHeaderDictionary(options.headers) : {};
+    this.retryDefaults = resolveRetryOptions(options.retries);
+    this.idempotencyGenerator = options.idempotencyGenerator ?? createIdempotencyKey;
+    this.logFn = options.onLog;
+    this.authHeader = options.useApiKeyHeader ? API_KEY_HEADER : AUTH_HEADER;
+    this.autoIdempotency = options.autoIdempotency ?? true;
+  }
+  async beginCall(request, options = {}) {
+    const idempotencyKey = request.idempotency ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    const payload = {
+      ...request,
+      feature: request.feature ?? this.defaultFeature,
+      tags: this.mergeTags(request.tags)
+    };
+    if (idempotencyKey) {
+      payload.idempotency = idempotencyKey;
+    }
+    const response = await this.request(
+      CALL_BEGIN_PATH,
+      payload,
+      {
+        ...options,
+        idempotencyKey
+      }
+    );
+    return response;
+  }
+  async endCall(request, options = {}) {
+    if (!request?.callId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "endCall requires callId"
+      );
+    }
+    const payload = { ...request };
+    const response = await this.request(
+      CALL_END_PATH,
+      payload,
+      options
+    );
+    return response;
+  }
+  async withUsage(beginRequest, handler, options = {}) {
+    const idempotencyKey = beginRequest.idempotency ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    const beginPayload = idempotencyKey ? { ...beginRequest, idempotency: idempotencyKey } : { ...beginRequest };
+    const beginResponse = await this.beginCall(beginPayload, options);
+    let usage = {};
+    const initialStripeCustomerId = typeof beginResponse.data.stripeCustomerId === "string" ? beginResponse.data.stripeCustomerId : typeof beginRequest.stripeCustomerId === "string" ? beginRequest.stripeCustomerId : void 0;
+    if (initialStripeCustomerId) {
+      usage = { ...usage, stripeCustomerId: initialStripeCustomerId };
+    }
+    let errorPayload;
+    let handlerResult;
+    let handlerError;
+    let endCallError;
+    const context = {
+      begin: beginResponse,
+      setUsage: (u) => {
+        usage = { ...usage, ...u };
+      },
+      setError: (err) => {
+        errorPayload = err;
+      }
+    };
+    try {
+      handlerResult = await handler(context);
+    } catch (error) {
+      handlerError = error;
+      if (!errorPayload) {
+        errorPayload = {
+          code: options.defaultErrorCode ?? "VENDOR_ERROR",
+          message: error instanceof Error ? error.message : String(error)
+        };
+      }
+    } finally {
+      try {
+        await this.endCall(
+          {
+            callId: beginResponse.data.callId,
+            ...usage,
+            error: errorPayload
+          },
+          {
+            ...options,
+            correlationId: beginResponse.correlationId
+          }
+        );
+      } catch (error) {
+        endCallError = error;
+      }
+    }
+    if (handlerError) {
+      throw handlerError;
+    }
+    if (endCallError) {
+      throw wrapEndCallError(endCallError, beginResponse.correlationId);
+    }
+    return handlerResult;
+  }
+  async request(path, payload, options) {
+    const url = new URL(path, this.baseUrl).toString();
+    const body = payload !== void 0 ? JSON.stringify(payload) : void 0;
+    const headers = this.composeHeaders(body, options);
+    const resolvedRetry = resolveRetryOptions(
+      this.retryDefaults,
+      options.retries
+    );
+    const startTime = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+    return runWithRetry(
+      async (attempt) => {
+        const startedAt = startTime();
+        this.log({
+          event: "request:start",
+          path,
+          attempt,
+          idempotencyKey: options.idempotencyKey,
+          correlationId: options.correlationId
+        });
+        const response = await this.performFetch({
+          url,
+          method: "POST",
+          headers,
+          body,
+          signal: options.signal
+        });
+        this.log({
+          event: "request:success",
+          path,
+          attempt,
+          idempotencyKey: options.idempotencyKey,
+          correlationId: response.correlationId,
+          elapsedMs: startTime() - startedAt
+        });
+        return response;
+      },
+      resolvedRetry,
+      (error) => this.shouldRetry(error),
+      (attempt, delayMs, error) => {
+        this.log({
+          event: "retry:scheduled",
+          path,
+          attempt,
+          idempotencyKey: options.idempotencyKey,
+          correlationId: options.correlationId,
+          error,
+          elapsedMs: delayMs
+        });
+      },
+      options.signal
+    ).catch((error) => {
+      this.log({
+        event: "retry:exhausted",
+        path,
+        attempt: resolvedRetry.maxAttempts,
+        idempotencyKey: options.idempotencyKey,
+        correlationId: options.correlationId,
+        error
+      });
+      throw error;
+    });
+  }
+  async performFetch(init) {
+    let response;
+    try {
+      response = await this.fetchImpl(init.url, {
+        method: init.method,
+        headers: init.headers,
+        body: init.body,
+        signal: init.signal
+      });
+    } catch (error) {
+      throw new UsageTapError(
+        "USAGETAP_NETWORK_ERROR",
+        "Failed to reach UsageTap",
+        {
+          retryable: true,
+          cause: error
+        }
+      );
+    }
+    const correlationId = response.headers.get(CORRELATION_HEADER) ?? void 0;
+    const text = await response.text();
+    let payload;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch (error) {
+        throw new UsageTapError(
+          "USAGETAP_INVALID_RESPONSE",
+          "UsageTap returned invalid JSON",
+          {
+            retryable: false,
+            correlationId,
+            cause: error
+          }
+        );
+      }
+    }
+    if (!response.ok) {
+      throw this.toHttpError(response.status, payload, correlationId);
+    }
+    if (!payload?.result || payload.result.status !== "ACCEPTED") {
+      throw this.toApiError(payload, correlationId);
+    }
+    const resolvedCorrelation = payload.correlationId ?? correlationId;
+    if (payload.data === void 0 || payload.data === null || !resolvedCorrelation) {
+      throw new UsageTapError(
+        "USAGETAP_INVALID_RESPONSE",
+        "UsageTap response missing data or correlationId",
+        {
+          correlationId: resolvedCorrelation ?? correlationId
+        }
+      );
+    }
+    return {
+      result: {
+        status: payload.result.status,
+        code: payload.result.code,
+        message: payload.result.message,
+        timestamp: payload.result.timestamp
+      },
+      data: payload.data,
+      correlationId: resolvedCorrelation
+    };
+  }
+  composeHeaders(body, options) {
+    const headers = {
+      ...this.defaultHeaders,
+      [SDK_HEADER]: `js/${SDK_VERSION}`,
+      "user-agent": `${USER_AGENT}/${SDK_VERSION}`,
+      "content-type": "application/json",
+      accept: CANONICAL_MEDIA_TYPE
+    };
+    if (this.authHeader === API_KEY_HEADER) {
+      headers[API_KEY_HEADER] = this.apiKey;
+    } else {
+      headers[AUTH_HEADER] = `Bearer ${this.apiKey}`;
+    }
+    if (options.idempotencyKey) {
+      headers[IDEMPOTENCY_HEADER] = options.idempotencyKey;
+    }
+    if (options.correlationId) {
+      headers[CORRELATION_HEADER] = options.correlationId;
+    }
+    if (!body) {
+      delete headers["content-type"];
+    }
+    if (options.headers) {
+      Object.assign(headers, normalizeHeaderDictionary(options.headers));
+    }
+    return headers;
+  }
+  log(entry) {
+    this.logFn?.(entry);
+  }
+  mergeTags(tags) {
+    if (!tags && !this.defaultTags) {
+      return void 0;
+    }
+    const combined = [...this.defaultTags ?? [], ...tags ?? []].filter(
+      Boolean
+    );
+    return combined.length ? dedupeStrings(combined) : void 0;
+  }
+  shouldRetry(error) {
+    if (isUsageTapError(error)) {
+      return Boolean(error.retryable);
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      return false;
+    }
+    return false;
+  }
+  toHttpError(status, payload, correlationId) {
+    const code = mapStatusToErrorCode(status);
+    const retryable = isRetryableStatus(status);
+    const message = payload?.error?.message ?? payload?.result?.message ?? `UsageTap responded with HTTP ${status}`;
+    return new UsageTapError(code, message, {
+      status,
+      retryable,
+      correlationId: payload?.correlationId ?? correlationId,
+      details: sanitizeDetails(payload)
+    });
+  }
+  toApiError(payload, correlationId) {
+    const normalizedCode = payload?.error?.code ?? payload?.result?.code ?? "UNKNOWN";
+    const retryable = isRetryableApiCode(normalizedCode);
+    const message = payload?.error?.message ?? payload?.result?.message ?? "UsageTap reported an error";
+    return new UsageTapError(mapApiCodeToError(normalizedCode), message, {
+      retryable,
+      correlationId: payload?.correlationId ?? correlationId,
+      details: sanitizeDetails(payload)
+    });
+  }
+};
+function mapStatusToErrorCode(status) {
+  if (status === 401 || status === 403) return "USAGETAP_AUTH_ERROR";
+  if (status === 400 || status === 404 || status === 409)
+    return "USAGETAP_BAD_REQUEST";
+  if (status === 429) return "USAGETAP_RATE_LIMITED";
+  if (status >= 500) return "USAGETAP_SERVER_ERROR";
+  return "USAGETAP_INVALID_RESPONSE";
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function isRetryableApiCode(code) {
+  const normalized = code.toUpperCase();
+  return normalized.includes("TRANSIENT") || normalized.includes("RETRY") || normalized.includes("TIMEOUT") || normalized.includes("THROTTLE") || normalized.includes("RATE_LIMIT");
+}
+function mapApiCodeToError(code) {
+  const normalized = code.toUpperCase();
+  if (normalized.includes("AUTH") || normalized.includes("TOKEN")) {
+    return "USAGETAP_AUTH_ERROR";
+  }
+  if (normalized.includes("RATE") || normalized.includes("THROTTLE")) {
+    return "USAGETAP_RATE_LIMITED";
+  }
+  if (normalized.includes("SERVER") || normalized.includes("TRANSIENT")) {
+    return "USAGETAP_SERVER_ERROR";
+  }
+  if (normalized.includes("IDEMPOTENCY") || normalized.includes("VALIDATION") || normalized.includes("REQUEST")) {
+    return "USAGETAP_BAD_REQUEST";
+  }
+  return "USAGETAP_INVALID_RESPONSE";
+}
+function sanitizeDetails(payload) {
+  if (!payload) return void 0;
+  const details = {};
+  if (payload.result) details.result = payload.result;
+  if (payload.error) details.error = payload.error;
+  return Object.keys(details).length ? details : void 0;
+}
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim();
+  if (!trimmed) return trimmed;
+  return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+function normalizeHeaderDictionary(dict) {
+  return Object.keys(dict).reduce((acc, key) => {
+    acc[key.toLowerCase()] = dict[key];
+    return acc;
+  }, {});
+}
+function dedupeStrings(values) {
+  return Array.from(
+    new Set(values.map((value) => value.trim()).filter(Boolean))
+  );
+}
+function wrapEndCallError(error, correlationId) {
+  if (isUsageTapError(error)) {
+    return new UsageTapError("USAGETAP_END_CALL_ERROR", error.message, {
+      correlationId: error.correlationId ?? correlationId,
+      details: error.details,
+      cause: error
+    });
+  }
+  return new UsageTapError(
+    "USAGETAP_END_CALL_ERROR",
+    "Failed to finalize UsageTap call",
+    {
+      correlationId,
+      cause: error
+    }
+  );
+}
+
+// src/adapters/openai.ts
+function createOpenAIAdapter(init) {
+  const { client, usageTap } = init;
+  return {
+    async invoke(params) {
+      const result = await usageTap.withUsage(
+        params.begin,
+        async (ctx) => {
+          const response = await params.call(client, {
+            hints: ctx.begin.data.vendorHints,
+            begin: ctx.begin
+          });
+          tryInferUsage(response, ctx.begin.data.vendorHints, params.extractUsage, ctx);
+          return {
+            data: response,
+            begin: ctx.begin
+          };
+        },
+        params.withUsageOptions
+      );
+      return result;
+    },
+    async invokeStream(params) {
+      const result = await usageTap.withUsage(
+        params.begin,
+        async (ctx) => {
+          const { stream, onComplete } = await params.call(client, {
+            hints: ctx.begin.data.vendorHints,
+            begin: ctx.begin
+          });
+          const wrapped = wrapStreamForUsageTap(stream, async () => {
+            if (!onComplete) return;
+            try {
+              const maybeUsage = await onComplete();
+              if (maybeUsage) {
+                ctx.setUsage(maybeUsage);
+              }
+            } catch (error) {
+              ctx.setError({
+                code: "USAGE_FINALIZE_ERROR",
+                message: error instanceof Error ? error.message : String(error)
+              });
+              throw error;
+            }
+          }, ctx);
+          const finalize = async () => {
+            await wrapped.__usageTapFinalize?.();
+          };
+          return {
+            stream: wrapped,
+            begin: ctx.begin,
+            finalize
+          };
+        },
+        params.withUsageOptions
+      );
+      return result;
+    }
+  };
+}
+function toNextResponse(stream, options = {}) {
+  const mode = options.mode ?? "text";
+  const headers = new Headers(options.headers ?? {});
+  if (mode === "sse") {
+    headers.set("content-type", "text/event-stream; charset=utf-8");
+    headers.set("cache-control", "no-cache, no-transform");
+    headers.set("connection", "keep-alive");
+    headers.set("x-accel-buffering", "no");
+  } else {
+    headers.set("content-type", options.contentType ?? "text/plain; charset=utf-8");
+  }
+  const encoder = new TextEncoder();
+  let iterator;
+  const body = new ReadableStream({
+    async start(controller) {
+      try {
+        const getIterator = stream[Symbol.asyncIterator];
+        if (typeof getIterator !== "function") {
+          controller.close();
+          return;
+        }
+        iterator = getIterator.call(stream);
+        while (true) {
+          const result = await iterator.next();
+          if (result.done) {
+            break;
+          }
+          const text = chunkToText(result.value);
+          if (!text) {
+            continue;
+          }
+          if (mode === "sse") {
+            controller.enqueue(encoder.encode(formatSsePayload(text, options.sse)));
+          } else {
+            controller.enqueue(encoder.encode(text));
+          }
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        await stream.__usageTapFinalize?.();
+      }
+    },
+    async cancel() {
+      if (!iterator) {
+        const getIterator = stream[Symbol.asyncIterator];
+        if (typeof getIterator === "function") {
+          iterator = getIterator.call(stream);
+        }
+      }
+      if (iterator && typeof iterator.return === "function") {
+        await iterator.return();
+      }
+      await stream.__usageTapFinalize?.();
+    }
+  });
+  return new Response(body, { headers });
+}
+async function pipeToResponse(stream, res, options = {}) {
+  const mode = options.mode ?? "text";
+  if (mode === "sse") {
+    setHeaderIfPossible(res, "Content-Type", "text/event-stream; charset=utf-8");
+    setHeaderIfPossible(res, "Cache-Control", "no-cache, no-transform");
+    setHeaderIfPossible(res, "Connection", "keep-alive");
+    setHeaderIfPossible(res, "X-Accel-Buffering", "no");
+  } else {
+    setHeaderIfPossible(res, "Content-Type", options.contentType ?? "text/plain; charset=utf-8");
+  }
+  const encoder = new TextEncoder();
+  const iterator = stream[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      const result = await iterator.next();
+      if (result.done) {
+        break;
+      }
+      const text = chunkToText(result.value);
+      if (!text) {
+        continue;
+      }
+      const payload = mode === "sse" ? formatSsePayload(text, options.sse) : text;
+      res.write(Buffer.from(encoder.encode(payload)));
+      res.flush?.();
+    }
+  } finally {
+    res.end();
+    await stream.__usageTapFinalize?.();
+  }
+}
+var USAGETAP_CORRELATION_HEADER = "x-usage-correlation-id";
+function wrapOpenAI(client, usageTap, options = {}) {
+  if (!client) {
+    throw new UsageTapError("USAGETAP_BAD_REQUEST", "wrapOpenAI requires an OpenAI client instance");
+  }
+  const defaultContext = options.defaultContext;
+  const applyVendorHints = options.applyVendorHints !== false;
+  const proxiedChat = client.chat ? createChatProxy(client.chat, usageTap, defaultContext, applyVendorHints) : void 0;
+  const proxiedResponses = typeof client.responses !== "undefined" ? createResponsesProxy(client.responses, usageTap, defaultContext, applyVendorHints) : void 0;
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === "chat" && proxiedChat) {
+        return proxiedChat;
+      }
+      if (prop === "responses" && typeof target.responses !== "undefined") {
+        return proxiedResponses ?? Reflect.get(target, prop, receiver);
+      }
+      if (prop === "toNextResponse") {
+        return toNextResponse;
+      }
+      if (prop === "pipeToResponse") {
+        return pipeToResponse;
+      }
+      if (prop === "unwrap") {
+        return () => target;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+  return new Proxy(client, handler);
+}
+function streamOpenAIRoute(usageTap, openai, options) {
+  if (!options?.getRequest) {
+    throw new UsageTapError("USAGETAP_BAD_REQUEST", "streamOpenAIRoute requires a getRequest function");
+  }
+  const wrapConfig = options.wrapOptions || options.defaultContext ? {
+    ...options.wrapOptions ?? {},
+    defaultContext: options.defaultContext ?? options.wrapOptions?.defaultContext
+  } : void 0;
+  const wrappedClient = wrapConfig ? wrapOpenAI(openai, usageTap, wrapConfig) : wrapOpenAI(openai, usageTap);
+  return async (req) => {
+    const requestConfig = await options.getRequest(req);
+    const mergedParams = {
+      ...requestConfig.params,
+      stream: true
+    };
+    const callOptions = {};
+    if (requestConfig.usageTap) {
+      callOptions.usageTap = requestConfig.usageTap;
+    }
+    if (requestConfig.withUsage) {
+      callOptions.withUsage = requestConfig.withUsage;
+    }
+    const stream = await wrappedClient.chat.completions.create(
+      mergedParams,
+      Object.keys(callOptions).length ? callOptions : void 0
+    );
+    const baseResponse = toNextResponse(stream, {
+      mode: options.stream?.mode ?? "sse",
+      headers: options.stream?.headers
+    });
+    const init = options.stream?.responseInit;
+    if (!init) {
+      return baseResponse;
+    }
+    const mergedHeaders = new Headers(baseResponse.headers);
+    if (init.headers) {
+      const extra = normalizeHeaders(init.headers);
+      for (const [key, value] of Object.entries(extra)) {
+        mergedHeaders.set(key, value);
+      }
+    }
+    return new Response(baseResponse.body, {
+      status: init.status ?? baseResponse.status,
+      statusText: init.statusText ?? baseResponse.statusText,
+      headers: mergedHeaders
+    });
+  };
+}
+function createChatProxy(resource, usageTap, defaultContext, applyVendorHints) {
+  const completions = createChatCompletionsProxy(
+    resource.completions,
+    usageTap,
+    defaultContext,
+    applyVendorHints
+  );
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === "completions") {
+        return completions;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+  return new Proxy(resource, handler);
+}
+function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHints) {
+  if (!resource || typeof resource !== "object") {
+    return void 0;
+  }
+  if (!("create" in resource) || typeof resource.create !== "function") {
+    return resource;
+  }
+  const originalCreate = resource.create.bind(resource);
+  const wrappedCreate = (params, options) => {
+    const { requestOptions, usageContext, withUsage: withUsage2 } = splitUsageOptions(options);
+    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
+    const wantsStream = isStreamingRequest(params);
+    return usageTap.withUsage(beginRequest, (ctx) => {
+      const finalParams = applyVendorHints ? applyResponsesVendorHints(params, ctx.begin.data.vendorHints) : params;
+      const request = attachCorrelationHeader(requestOptions, ctx.begin.correlationId);
+      if (wantsStream) {
+        const apiPromise2 = originalCreate(finalParams, request);
+        const wrappedPromise2 = transformApiPromise(apiPromise2, (rawStream) => {
+          ensureAsyncIterable(rawStream, "responses.create");
+          const wrappedStream = wrapStreamForUsageTap(rawStream, async () => {
+            const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints);
+            if (usage) {
+              ctx.setUsage(usage);
+            }
+          }, ctx);
+          return wrappedStream;
+        });
+        return wrappedPromise2;
+      }
+      const apiPromise = originalCreate(finalParams, request);
+      const wrappedPromise = transformApiPromise(apiPromise, (response) => {
+        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx);
+        return response;
+      });
+      return wrappedPromise;
+    }, withUsage2);
+  };
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === "create") {
+        return wrappedCreate;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+  return new Proxy(resource, handler);
+}
+function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVendorHints) {
+  const originalCreate = resource.create.bind(resource);
+  const streamCandidate = resource.stream;
+  const originalStream = typeof streamCandidate === "function" ? streamCandidate.bind(resource) : void 0;
+  const wrappedCreate = (params, options) => {
+    const { requestOptions, usageContext, withUsage: withUsage2 } = splitUsageOptions(options);
+    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
+    const wantsStream = isStreamingRequest(params);
+    return usageTap.withUsage(beginRequest, (ctx) => {
+      const finalParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
+      const request = attachCorrelationHeader(requestOptions, ctx.begin.correlationId);
+      if (wantsStream) {
+        const apiPromise2 = originalCreate(finalParams, request);
+        const wrappedPromise2 = transformApiPromise(apiPromise2, (rawStream) => {
+          ensureAsyncIterable(rawStream, "chat.completions.create");
+          const wrappedStream2 = wrapStreamForUsageTap(rawStream, async () => {
+            const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints);
+            if (usage) {
+              ctx.setUsage(usage);
+            }
+          }, ctx);
+          return wrappedStream2;
+        });
+        return wrappedPromise2;
+      }
+      const apiPromise = originalCreate(finalParams, request);
+      const wrappedPromise = transformApiPromise(apiPromise, (response) => {
+        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx);
+        return response;
+      });
+      return wrappedPromise;
+    }, withUsage2);
+  };
+  const wrappedStream = originalStream ? (params, options) => {
+    const { requestOptions, usageContext, withUsage: withUsage2 } = splitUsageOptions(options);
+    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
+    return usageTap.withUsage(beginRequest, (ctx) => {
+      const finalParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
+      const request = attachCorrelationHeader(requestOptions, ctx.begin.correlationId);
+      const apiPromise = originalStream(finalParams, request);
+      const wrappedPromise = transformApiPromise(apiPromise, (rawStream) => {
+        ensureAsyncIterable(rawStream, "chat.completions.stream");
+        const wrappedStreamInner = wrapStreamForUsageTap(rawStream, async () => {
+          const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints);
+          if (usage) {
+            ctx.setUsage(usage);
+          }
+        }, ctx);
+        return wrappedStreamInner;
+      });
+      return wrappedPromise;
+    }, withUsage2);
+  } : void 0;
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === "create") {
+        return wrappedCreate;
+      }
+      if (prop === "stream" && wrappedStream) {
+        return wrappedStream;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+  return new Proxy(resource, handler);
+}
+function splitUsageOptions(options) {
+  if (!options || typeof options !== "object") {
+    return {};
+  }
+  const { usageTap, withUsage: withUsage2, ...rest } = options;
+  const requestOptions = Object.keys(rest).length ? cloneRequestOptions(rest) : void 0;
+  return {
+    requestOptions,
+    usageContext: usageTap,
+    withUsage: withUsage2
+  };
+}
+function resolveBeginRequest(defaults, override) {
+  const base = defaults ?? {};
+  const current = override ?? {};
+  const customerId = current.customerId ?? base.customerId;
+  if (!customerId) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "wrapOpenAI requires usageTap.customerId (provide defaultContext or options.usageTap)"
+    );
+  }
+  const tags = mergeTags(base.tags, current.tags);
+  const begin = { customerId };
+  const requested = current.requested ?? base.requested;
+  if (requested) begin.requested = requested;
+  const feature = current.feature ?? base.feature;
+  if (feature) begin.feature = feature;
+  const idempotency = current.idempotency ?? base.idempotency;
+  if (idempotency) begin.idempotency = idempotency;
+  const customerName = current.customerName ?? base.customerName;
+  if (customerName) begin.customerName = customerName;
+  const customerEmail = current.customerEmail ?? base.customerEmail;
+  if (customerEmail) begin.customerEmail = customerEmail;
+  if (tags?.length) {
+    begin.tags = tags;
+  }
+  return begin;
+}
+function transformApiPromise(apiPromise, onResolve) {
+  const resolvedPromise = Promise.resolve(apiPromise).then(onResolve);
+  if (isObjectRecord(apiPromise)) {
+    const proto = Object.getPrototypeOf(apiPromise);
+    if (proto) {
+      Object.setPrototypeOf(resolvedPromise, proto);
+    }
+    for (const key of Reflect.ownKeys(apiPromise)) {
+      if (key === "then" || key === "catch" || key === "finally") {
+        continue;
+      }
+      try {
+        const descriptor = Object.getOwnPropertyDescriptor(apiPromise, key);
+        if (descriptor) {
+          Reflect.defineProperty(resolvedPromise, key, descriptor);
+        }
+      } catch {
+      }
+    }
+  }
+  return resolvedPromise;
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function cloneRecord(value) {
+  return isObjectRecord(value) ? { ...value } : {};
+}
+function isStringTuple(value) {
+  return Array.isArray(value) && value.length >= 2 && typeof value[0] === "string" && typeof value[1] === "string";
+}
+function cloneRequestOptions(source) {
+  const clone = { ...source };
+  if ("headers" in clone) {
+    clone.headers = normalizeHeaders(clone.headers);
+  }
+  return clone;
+}
+function attachCorrelationHeader(options, correlationId) {
+  const normalized = normalizeHeaders(options?.headers);
+  if (correlationId && !normalized[USAGETAP_CORRELATION_HEADER]) {
+    normalized[USAGETAP_CORRELATION_HEADER] = correlationId;
+  }
+  if (!options) {
+    return Object.keys(normalized).length ? { headers: normalized } : void 0;
+  }
+  const next = { ...options };
+  if (Object.keys(normalized).length) {
+    next.headers = normalized;
+  }
+  return next;
+}
+function normalizeHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  if (headers instanceof Headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key.toLowerCase()] = value;
+    });
+    return result;
+  }
+  if (Array.isArray(headers)) {
+    const result = {};
+    for (const entry of headers) {
+      if (!isStringTuple(entry)) {
+        continue;
+      }
+      const [key, value] = entry;
+      result[key.toLowerCase()] = value;
+    }
+    return result;
+  }
+  if (isObjectRecord(headers)) {
+    const result = {};
+    const record = headers;
+    for (const key of Object.keys(record)) {
+      const value = record[key];
+      if (value !== void 0 && value !== null) {
+        result[key.toLowerCase()] = String(value);
+      }
+    }
+    return result;
+  }
+  return {};
+}
+function mergeTags(a, b) {
+  const values = [...a ?? [], ...b ?? []].map((value) => typeof value === "string" ? value.trim() : "").filter(Boolean);
+  if (!values.length) {
+    return void 0;
+  }
+  return dedupeStrings2(values);
+}
+function dedupeStrings2(values) {
+  return Array.from(new Set(values));
+}
+function isStreamingRequest(params) {
+  if (!params || typeof params !== "object") {
+    return false;
+  }
+  const stream = params.stream;
+  if (typeof stream === "boolean") {
+    return stream;
+  }
+  return stream != null;
+}
+function applyChatVendorHints(params, hints) {
+  if (!hints) {
+    return params;
+  }
+  const next = cloneRecord(params);
+  if (hints.preferredModel && (next.model === void 0 || next.model === null)) {
+    next.model = hints.preferredModel;
+  }
+  if (typeof hints.maxResponseTokens === "number" && next.max_tokens == null) {
+    next.max_tokens = hints.maxResponseTokens;
+  }
+  if (typeof hints.maxInputTokens === "number" && next.max_input_tokens == null) {
+    next.max_input_tokens = hints.maxInputTokens;
+  }
+  return next;
+}
+function applyResponsesVendorHints(params, hints) {
+  if (!hints) {
+    return params;
+  }
+  const next = cloneRecord(params);
+  if (hints.preferredModel && (next.model === void 0 || next.model === null)) {
+    next.model = hints.preferredModel;
+  }
+  if (typeof hints.maxResponseTokens === "number" && next.max_output_tokens == null) {
+    next.max_output_tokens = hints.maxResponseTokens;
+  }
+  return next;
+}
+async function extractUsageFromStream(stream, hints) {
+  const finalPayload = await resolveStreamFinalPayload(stream);
+  if (!finalPayload) {
+    return void 0;
+  }
+  return inferUsageFromResponse(finalPayload, hints);
+}
+async function resolveStreamFinalPayload(stream) {
+  if (!stream || typeof stream !== "object") {
+    return void 0;
+  }
+  const candidate = stream;
+  if (typeof candidate.finalChatCompletion === "function") {
+    return candidate.finalChatCompletion();
+  }
+  if (typeof candidate.finalResponse === "function") {
+    return candidate.finalResponse();
+  }
+  if (typeof candidate.finalCompletion === "function") {
+    return candidate.finalCompletion();
+  }
+  if (typeof candidate.finalContent === "function") {
+    return candidate.finalContent();
+  }
+  return void 0;
+}
+function ensureAsyncIterable(value, label) {
+  if (!value || typeof value !== "object" || typeof value[Symbol.asyncIterator] !== "function") {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      `${label} expected an async iterable stream but received ${typeof value}`
+    );
+  }
+}
+function chunkToText(chunk) {
+  if (chunk === void 0 || chunk === null) {
+    return "";
+  }
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (typeof chunk === "object") {
+    const candidate = chunk;
+    const delta = candidate.choices?.[0]?.delta;
+    const content = delta?.content ?? candidate.content;
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content.map((entry) => {
+        if (!entry) return "";
+        if (typeof entry === "string") return entry;
+        if (typeof entry.text === "string") return entry.text;
+        return "";
+      }).join("");
+    }
+  }
+  return String(chunk);
+}
+function formatSsePayload(text, options) {
+  if (!text) {
+    return "";
+  }
+  const lines = text.split(/\r?\n/);
+  const eventLine = options?.event ? `event: ${options.event}
+` : "";
+  const retryLine = options?.retry ? `retry: ${options.retry}
+` : "";
+  const dataLines = lines.map((line) => `data: ${line}`).join("\n");
+  return `${eventLine}${retryLine}${dataLines}
+
+`;
+}
+function setHeaderIfPossible(res, key, value) {
+  if (typeof res.setHeader === "function" && res.headersSent !== true) {
+    res.setHeader(key, value);
+  }
+}
+function tryInferUsage(response, hints, extractor, ctx) {
+  const explicit = extractor?.(response);
+  const inferred = explicit ?? inferUsageFromResponse(response, hints);
+  if (inferred) {
+    ctx.setUsage(inferred);
+  }
+}
+function inferUsageFromResponse(response, hints) {
+  if (!response || typeof response !== "object") {
+    return void 0;
+  }
+  const candidate = response;
+  if (!candidate.usage) {
+    return void 0;
+  }
+  return {
+    modelUsed: candidate.model ?? hints?.preferredModel,
+    inputTokens: candidate.usage.prompt_tokens,
+    responseTokens: candidate.usage.completion_tokens,
+    cachedTokens: candidate.usage.cached_tokens
+  };
+}
+function wrapStreamForUsageTap(source, finalize, ctx) {
+  const getIterator = source[Symbol.asyncIterator];
+  if (typeof getIterator !== "function") {
+    throw new TypeError("Stream is not async iterable");
+  }
+  const iterator = getIterator.call(source);
+  let completed = false;
+  const invokeFinalize = async () => {
+    if (completed) return;
+    completed = true;
+    try {
+      await finalize();
+    } catch (error) {
+      ctx.setError({
+        code: "USAGE_FINALIZE_ERROR",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  };
+  const prototype = Object.getPrototypeOf(source) ?? Object.prototype;
+  const wrapped = Object.create(prototype);
+  for (const key of Reflect.ownKeys(source)) {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (descriptor) {
+        Object.defineProperty(wrapped, key, descriptor);
+      }
+    } catch {
+    }
+  }
+  Object.defineProperty(wrapped, Symbol.asyncIterator, {
+    value() {
+      return this;
+    },
+    configurable: true
+  });
+  Object.defineProperty(wrapped, "next", {
+    value: async (...args) => {
+      try {
+        const result = await iterator.next(...args);
+        if (result.done) {
+          await invokeFinalize();
+        }
+        return result;
+      } catch (error) {
+        await invokeFinalize().catch(() => void 0);
+        throw error;
+      }
+    },
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(wrapped, "return", {
+    value: async (value) => {
+      if (typeof iterator.return === "function") {
+        const rawResult = await iterator.return(value);
+        if (!isIteratorResult(rawResult)) {
+          throw new TypeError("Iterator.return() returned an invalid result");
+        }
+        await invokeFinalize();
+        return rawResult;
+      }
+      await invokeFinalize();
+      return { done: true, value };
+    },
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(wrapped, "throw", {
+    value: async (error) => {
+      if (typeof iterator.throw === "function") {
+        const rawResult = await iterator.throw(error);
+        if (!isIteratorResult(rawResult)) {
+          throw new TypeError("Iterator.throw() returned an invalid result");
+        }
+        await invokeFinalize();
+        return rawResult;
+      }
+      await invokeFinalize();
+      throw error;
+    },
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(wrapped, "__usageTapFinalize", {
+    value: async () => {
+      await invokeFinalize();
+    },
+    configurable: true
+  });
+  return wrapped;
+}
+function isIteratorResult(value) {
+  return isObjectRecord(value) && "done" in value;
+}
+
+// src/adapters/openrouter.ts
+function createOpenRouterAdapter(init) {
+  return createOpenAIAdapter(init);
+}
+
+// src/adapters/fetch-wrapper.ts
+function isJsonRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function parseJsonRecord(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return isJsonRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseStringArray(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+      return parsed;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function wrapFetch(usageTap, options) {
+  const {
+    defaultContext,
+    baseFetch = globalThis.fetch,
+    autoIdempotency = true,
+    isOpenAIEndpoint = defaultIsOpenAIEndpoint
+  } = options;
+  return async function wrappedFetch(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (!isOpenAIEndpoint(url)) {
+      return baseFetch(input, init);
+    }
+    let body;
+    let isStreaming = false;
+    const contextOverride = {};
+    try {
+      if (init?.body && typeof init.body === "string") {
+        const parsedBody = parseJsonRecord(init.body);
+        if (!parsedBody) {
+          return baseFetch(input, init);
+        }
+        body = parsedBody;
+        isStreaming = parsedBody.stream === true;
+        const headers = new Headers(init.headers);
+        const customerIdHeader = headers.get("x-usagetap-customer-id");
+        const featureHeader = headers.get("x-usagetap-feature");
+        const tagsHeader = headers.get("x-usagetap-tags");
+        if (customerIdHeader) {
+          contextOverride.customerId = customerIdHeader;
+        }
+        if (featureHeader) {
+          contextOverride.feature = featureHeader;
+        }
+        if (tagsHeader) {
+          const tags = parseStringArray(tagsHeader);
+          if (tags) {
+            contextOverride.tags = tags;
+          }
+        }
+      }
+    } catch {
+      return baseFetch(input, init);
+    }
+    const context = {
+      ...defaultContext,
+      ...contextOverride,
+      idempotency: autoIdempotency ? crypto.randomUUID() : void 0
+    };
+    let callState;
+    try {
+      const beginResponse = await usageTap.beginCall(context);
+      callState = {
+        callId: beginResponse.data.callId,
+        correlationId: beginResponse.correlationId,
+        usage: {},
+        finalized: false
+      };
+    } catch (error) {
+      console.error("[wrapFetch] Failed to begin call:", error);
+      return baseFetch(input, init);
+    }
+    const modifiedInit = {
+      ...init,
+      headers: {
+        ...init?.headers,
+        "x-usage-correlation-id": callState.correlationId || ""
+      }
+    };
+    try {
+      const response = await baseFetch(input, modifiedInit);
+      if (isStreaming) {
+        return wrapStreamingResponse(response, callState, usageTap);
+      } else {
+        return await wrapNonStreamingResponse(response, callState, usageTap, body);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await finalizeCall(callState, usageTap, {
+        code: "VENDOR_ERROR",
+        message
+      });
+      throw error;
+    }
+  };
+}
+function defaultIsOpenAIEndpoint(url) {
+  return url.includes("/v1/chat/completions") || url.includes("/v1/responses") || url.includes("/v1/embeddings");
+}
+async function wrapNonStreamingResponse(response, callState, usageTap, requestBody) {
+  const clonedResponse = response.clone();
+  try {
+    const parsed = await clonedResponse.json();
+    const usage = {};
+    if (isJsonRecord(parsed)) {
+      const usageBlock = parsed.usage;
+      if (isJsonRecord(usageBlock)) {
+        const promptTokens = readNumber(usageBlock.prompt_tokens ?? usageBlock.input_tokens);
+        if (promptTokens !== void 0) {
+          usage.inputTokens = promptTokens;
+        }
+        const completionTokens = readNumber(usageBlock.completion_tokens ?? usageBlock.output_tokens);
+        if (completionTokens !== void 0) {
+          usage.responseTokens = completionTokens;
+        }
+        const cachedTokens = readNumber(usageBlock.prompt_cache_hit_tokens);
+        if (cachedTokens !== void 0) {
+          usage.cachedTokens = cachedTokens;
+        }
+        const reasoningTokens = readNumber(usageBlock.reasoning_tokens);
+        if (reasoningTokens !== void 0) {
+          usage.reasoningTokens = reasoningTokens;
+        }
+      }
+      const modelFromResponse = readString(parsed.model);
+      if (modelFromResponse) {
+        usage.modelUsed = modelFromResponse;
+      }
+    }
+    if (!usage.modelUsed && requestBody) {
+      const requestModel = readString(requestBody.model);
+      if (requestModel) {
+        usage.modelUsed = requestModel;
+      }
+    }
+    await finalizeCall(callState, usageTap, void 0, usage);
+    return response;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await finalizeCall(callState, usageTap, {
+      code: "RESPONSE_PARSE_ERROR",
+      message
+    });
+    return response;
+  }
+}
+function wrapStreamingResponse(response, callState, usageTap) {
+  if (!response.body) {
+    void finalizeCall(callState, usageTap, {
+      code: "NO_RESPONSE_BODY",
+      message: "Streaming response has no body"
+    });
+    return response;
+  }
+  const originalBody = response.body;
+  const accumulatedUsage = {};
+  const textDecoder = new TextDecoder();
+  const transformStream = new TransformStream({
+    transform(chunk, controller) {
+      controller.enqueue(chunk);
+      try {
+        const text = textDecoder.decode(chunk, { stream: true });
+        const lines = text.split("\n");
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") continue;
+            const parsedRecord = parseJsonRecord(data);
+            if (!parsedRecord) {
+              continue;
+            }
+            const usageBlock = parsedRecord.usage;
+            if (isJsonRecord(usageBlock)) {
+              const promptTokens = readNumber(usageBlock.prompt_tokens ?? usageBlock.input_tokens);
+              if (promptTokens !== void 0) {
+                accumulatedUsage.inputTokens = promptTokens;
+              }
+              const completionTokens = readNumber(usageBlock.completion_tokens ?? usageBlock.output_tokens);
+              if (completionTokens !== void 0) {
+                accumulatedUsage.responseTokens = completionTokens;
+              }
+              const cachedTokens = readNumber(usageBlock.prompt_cache_hit_tokens);
+              if (cachedTokens !== void 0) {
+                accumulatedUsage.cachedTokens = cachedTokens;
+              }
+              const reasoningTokens = readNumber(usageBlock.reasoning_tokens);
+              if (reasoningTokens !== void 0) {
+                accumulatedUsage.reasoningTokens = reasoningTokens;
+              }
+            }
+            const model = readString(parsedRecord.model);
+            if (model) {
+              accumulatedUsage.modelUsed = model;
+            }
+          }
+        }
+      } catch {
+      }
+    },
+    async flush() {
+      await finalizeCall(callState, usageTap, void 0, accumulatedUsage);
+    }
+  });
+  const wrappedBody = originalBody.pipeThrough(transformStream);
+  return new Response(wrappedBody, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+async function finalizeCall(callState, usageTap, error, usage) {
+  if (callState.finalized) return;
+  callState.finalized = true;
+  try {
+    await usageTap.endCall({
+      callId: callState.callId,
+      ...callState.usage,
+      ...usage,
+      error
+    });
+  } catch (err) {
+    console.error("[wrapFetch] Failed to finalize call:", err);
+  }
+}
+
+// src/adapters/express-middleware.ts
+function withUsageMiddleware(usageTap, options) {
+  return async (req, res, next) => {
+    try {
+      const customerId = await options.getCustomerId(req);
+      const feature = options.getFeature ? await options.getFeature(req) : void 0;
+      const tags = options.getTags ? await options.getTags(req) : void 0;
+      const baseContext = {
+        customerId,
+        feature,
+        tags,
+        ...options.defaultContext
+      };
+      req.usageTap = {
+        openai: (client, contextOverride, wrapOptions) => {
+          const mergedContext = { ...baseContext, ...contextOverride };
+          return wrapOpenAI(client, usageTap, {
+            ...wrapOptions,
+            defaultContext: mergedContext
+          });
+        },
+        pipeToResponse
+      };
+      next();
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+function withUsage(usageTap, getCustomerId) {
+  return withUsageMiddleware(usageTap, { getCustomerId });
+}
+
+exports.UsageTapClient = UsageTapClient;
+exports.UsageTapError = UsageTapError;
+exports.createIdempotencyKey = createIdempotencyKey;
+exports.createOpenAIAdapter = createOpenAIAdapter;
+exports.createOpenRouterAdapter = createOpenRouterAdapter;
+exports.isUsageTapError = isUsageTapError;
+exports.pipeToResponse = pipeToResponse;
+exports.streamOpenAIRoute = streamOpenAIRoute;
+exports.toNextResponse = toNextResponse;
+exports.withUsage = withUsage;
+exports.withUsageMiddleware = withUsageMiddleware;
+exports.wrapFetch = wrapFetch;
+exports.wrapOpenAI = wrapOpenAI;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map