@usagetap/sdk 0.4.0 → 0.6.0

package/dist/openai/index.mjs

@@ -0,0 +1,768 @@
+// 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
+    };
+  }
+};
+
+// 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 } = 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;
+    }, withUsage);
+  };
+  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 } = 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;
+    }, withUsage);
+  };
+  const wrappedStream = originalStream ? (params, options) => {
+    const { requestOptions, usageContext, withUsage } = 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;
+    }, withUsage);
+  } : 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, ...rest } = options;
+  const requestOptions = Object.keys(rest).length ? cloneRequestOptions(rest) : void 0;
+  return {
+    requestOptions,
+    usageContext: usageTap,
+    withUsage
+  };
+}
+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 dedupeStrings(values);
+}
+function dedupeStrings(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);
+}
+
+export { createOpenAIAdapter, createOpenRouterAdapter, pipeToResponse, streamOpenAIRoute, toNextResponse, wrapOpenAI };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map