@usagetap/sdk 0.4.0 → 0.6.0

package/dist/{index.js → index.mjs}

@@ -125,7 +125,7 @@ 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.4.0" ;
+var SDK_VERSION = "0.6.0" ;
 var HAS_WINDOW = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
 var UsageTapClient = class {
   apiKey;
@@ -637,742 +637,6 @@ function wrapEndCallError(error, correlationId) {
   );
 }
 
-// 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);
@@ -1616,39 +880,6 @@ async function finalizeCall(callState, usageTap, error, usage) {
   }
 }
 
-// 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 });
-}
-
-export { UsageTapClient, UsageTapError, createIdempotencyKey, createOpenAIAdapter, createOpenRouterAdapter, isUsageTapError, pipeToResponse, streamOpenAIRoute, toNextResponse, withUsage, withUsageMiddleware, wrapFetch, wrapOpenAI };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { UsageTapClient, UsageTapError, createIdempotencyKey, isUsageTapError, wrapFetch };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map