@usagetap/sdk 1.3.2 → 1.4.0

package/dist/adapters/openrouter.mjs

@@ -1,16 +1,2238 @@
+// 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/prompt-compression.ts
+var DEFAULT_TTC_ENDPOINT = "https://api.thetokencompany.com/v1/compress";
+var DEFAULT_TTC_MODEL = "bear-2";
+var DEFAULT_TTC_AGGRESSIVENESS = 0.2;
+var DEFAULT_USAGETAP_COMPRESSION_ENDPOINT = "https://compress.usagetap.com/v1/compress";
+var DEFAULT_USAGETAP_MESSAGES_COMPRESSION_ENDPOINT = "https://compress.usagetap.com/v1/messages/compress";
+var PROTECTED_TEXT_PATTERN = /<ttc_safe>[\s\S]*?<\/ttc_safe>|<usagetap_safe>[\s\S]*?<\/usagetap_safe>/g;
+async function compressPrompt(options) {
+  const input = resolvePromptCompressionInput(options);
+  try {
+    if (options.provider === "usagetap") {
+      return await compressWithUsageTap(options);
+    }
+    if (options.provider === "thetokencompany" || options.tokenCompanyApiKey) {
+      return await compressWithTheTokenCompany(options);
+    }
+    if (options.provider === "toon") {
+      return compressPromptToon(input);
+    }
+    return compressPromptHeuristic(input);
+  } catch (error) {
+    if (options.failOpen === false) {
+      throw error;
+    }
+    return createPromptCompressionFallback(
+      input,
+      options.provider ?? (options.tokenCompanyApiKey ? "thetokencompany" : "heuristic"),
+      error
+    );
+  }
+}
+function compressPromptHeuristic(input) {
+  const original = stableStringifyInput(input);
+  const techniques = /* @__PURE__ */ new Set();
+  const compressedInput = compressValue(input, techniques, { allowToonString: false });
+  const compressed = stableStringifyInput(compressedInput);
+  const chosenInput = compressed.length <= original.length ? compressedInput : input;
+  const chosen = compressed.length <= original.length ? compressed : original;
+  if (!techniques.size) {
+    techniques.add("no-op");
+  }
+  return buildResult(
+    input,
+    chosenInput,
+    "heuristic",
+    original,
+    chosen,
+    Array.from(techniques)
+  );
+}
+function compressPromptToon(input) {
+  const original = stableStringifyInput(input);
+  const compressedInput = typeof input === "string" ? compressText(input, /* @__PURE__ */ new Set(), { allowToonString: true }) : encodeToon(input);
+  const compressed = stableStringifyInput(compressedInput);
+  return buildResult(input, compressedInput, "toon", original, compressed, [
+    "toon",
+    "json-minify"
+  ]);
+}
+async function compressPromptMessages(options) {
+  try {
+    return await compressMessagesWithUsageTap(options);
+  } catch (error) {
+    if (options.failOpen === false) {
+      throw error;
+    }
+    return createPromptCompressionFallback(
+      options.input,
+      options.provider ?? "usagetap",
+      error
+    );
+  }
+}
+async function compressWithTheTokenCompany(options) {
+  if (!options.tokenCompanyApiKey) {
+    throw new Error(
+      "tokenCompanyApiKey is required when provider is thetokencompany"
+    );
+  }
+  const fetchCandidate = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchCandidate !== "function") {
+    throw new Error(
+      "A fetch implementation is required for The Token Company compression"
+    );
+  }
+  return compressWithCompatibleRemoteProvider({
+    options,
+    provider: "thetokencompany",
+    endpoint: options.tokenCompanyEndpoint ?? DEFAULT_TTC_ENDPOINT,
+    model: options.model ?? options.tokenCompanyModel ?? DEFAULT_TTC_MODEL,
+    aggressiveness: options.aggressiveness ?? options.tokenCompanyAggressiveness ?? DEFAULT_TTC_AGGRESSIVENESS,
+    apiKey: options.tokenCompanyApiKey,
+    appId: options.tokenCompanyAppId,
+    providerLabel: "The Token Company"
+  });
+}
+async function compressWithUsageTap(options) {
+  const fetchCandidate = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchCandidate !== "function") {
+    throw new Error(
+      "A fetch implementation is required for UsageTap prompt compression"
+    );
+  }
+  return compressWithCompatibleRemoteProvider({
+    options,
+    provider: "usagetap",
+    endpoint: options.usageTapCompressionEndpoint ?? DEFAULT_USAGETAP_COMPRESSION_ENDPOINT,
+    model: options.model ?? options.usageTapCompressionModel ?? options.tokenCompanyModel ?? DEFAULT_TTC_MODEL,
+    aggressiveness: options.aggressiveness ?? options.usageTapCompressionAggressiveness ?? options.tokenCompanyAggressiveness ?? DEFAULT_TTC_AGGRESSIVENESS,
+    apiKey: options.usageTapCompressionApiKey,
+    appId: options.tokenCompanyAppId,
+    providerLabel: "UsageTap prompt compression"
+  });
+}
+async function compressMessagesWithUsageTap(options) {
+  const fetchCandidate = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchCandidate !== "function") {
+    throw new Error(
+      "A fetch implementation is required for UsageTap prompt message compression"
+    );
+  }
+  const aggressiveness = options.aggressiveness ?? options.usageTapCompressionAggressiveness ?? DEFAULT_TTC_AGGRESSIVENESS;
+  validateAggressiveness(
+    aggressiveness,
+    "UsageTap prompt message compression"
+  );
+  if (options.latencyBudgetMs !== void 0 && (!Number.isFinite(options.latencyBudgetMs) || options.latencyBudgetMs < 0)) {
+    throw new Error(
+      "UsageTap prompt message compression latencyBudgetMs must be a non-negative number"
+    );
+  }
+  const original = stableStringifyInput(options.input);
+  const headers = {
+    "content-type": "application/json"
+  };
+  if (options.usageTapCompressionApiKey) {
+    headers.authorization = `Bearer ${options.usageTapCompressionApiKey}`;
+  }
+  const response = await fetchCandidate(
+    options.usageTapCompressionMessagesEndpoint ?? DEFAULT_USAGETAP_MESSAGES_COMPRESSION_ENDPOINT,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        ...cloneInputRecord(options.input),
+        compression_settings: {
+          aggressiveness,
+          ...options.mode === void 0 ? {} : { mode: options.mode },
+          ...options.latencyBudgetMs === void 0 ? {} : { latency_budget_ms: options.latencyBudgetMs },
+          ...options.compactEmptyUserMessages === void 0 ? {} : { compact_empty_user_messages: options.compactEmptyUserMessages },
+          ...options.compactDuplicateUserTextParts === void 0 ? {} : {
+            compact_duplicate_user_text_parts: options.compactDuplicateUserTextParts
+          }
+        }
+      }),
+      signal: options.signal
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `UsageTap prompt message compression failed with HTTP ${response.status}`
+    );
+  }
+  const payload = await response.json();
+  const compressedInput = payload.compressed_request ?? payload.compressedInput ?? payload.compressed ?? (payload.messages !== void 0 ? { ...cloneInputRecord(options.input), messages: payload.messages } : void 0);
+  if (compressedInput === void 0) {
+    throw new Error(
+      "UsageTap prompt message compression response did not include compressed content"
+    );
+  }
+  const compressed = stableStringifyInput(compressedInput);
+  const tokenCounts = normalizeCompatibleTokenCounts(payload);
+  return buildResult(
+    options.input,
+    compressedInput,
+    "usagetap",
+    original,
+    compressed,
+    ["usagetap", "messages-endpoint"],
+    tokenCounts
+  );
+}
+async function compressWithCompatibleRemoteProvider(args) {
+  const { options, provider, endpoint, model, aggressiveness, apiKey, appId, providerLabel } = args;
+  const fetchCandidate = options.fetchImpl ?? globalThis.fetch;
+  const sourceInput = resolvePromptCompressionInput(options);
+  const original = stableStringifyInput(sourceInput);
+  const heuristic = compressPromptHeuristic(sourceInput);
+  const input = typeof heuristic.compressedInput === "string" ? heuristic.compressedInput : stableStringifyInput(heuristic.compressedInput);
+  if (!isValidAggressiveness(aggressiveness)) {
+    throw new Error(`${providerLabel} aggressiveness must be between 0.0 and 1.0`);
+  }
+  const headers = {
+    "content-type": "application/json"
+  };
+  if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+  }
+  const response = await fetchCandidate(
+    endpoint,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model,
+        input,
+        ...provider === "usagetap" ? { text: input } : {},
+        compression_settings: { aggressiveness },
+        ...appId ? { app_id: appId } : {}
+      }),
+      signal: options.signal
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `${providerLabel} failed with HTTP ${response.status}`
+    );
+  }
+  const payload = await response.json();
+  const tokenCompanyResult = normalizeTheTokenCompanyCompressResponse(payload);
+  const compressedInput = payload.compressedInput ?? payload.compressed ?? tokenCompanyResult?.output ?? payload.output ?? payload.text;
+  if (compressedInput === void 0) {
+    throw new Error(`${providerLabel} response did not include compressed content`);
+  }
+  const compressed = stableStringifyInput(compressedInput);
+  const tokenCounts = tokenCompanyResult ? {
+    originalTokens: tokenCompanyResult.input_tokens,
+    compressedTokens: tokenCompanyResult.output_tokens,
+    savedTokens: tokenCompanyResult.tokens_saved
+  } : void 0;
+  return buildResult(
+    sourceInput,
+    compressedInput,
+    provider,
+    original,
+    compressed,
+    [...heuristic.techniques, provider],
+    tokenCounts
+  );
+}
+function resolvePromptCompressionInput(options) {
+  if (options.input !== void 0) {
+    return options.input;
+  }
+  if (options.text !== void 0) {
+    return options.text;
+  }
+  throw new Error("Prompt compression requires input or text");
+}
+function validateAggressiveness(value, label) {
+  if (typeof value === "number") {
+    if (!isValidAggressiveness(value)) {
+      throw new Error(`${label} aggressiveness must be between 0.0 and 1.0`);
+    }
+    return;
+  }
+  for (const aggressiveness of Object.values(value)) {
+    if (aggressiveness !== void 0 && !isValidAggressiveness(aggressiveness)) {
+      throw new Error(`${label} aggressiveness must be between 0.0 and 1.0`);
+    }
+  }
+}
+function isValidAggressiveness(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function cloneInputRecord(input) {
+  return input && typeof input === "object" && !Array.isArray(input) ? { ...input } : { input };
+}
+function normalizeCompatibleTokenCounts(data) {
+  const inputTokens = typeof data.input_tokens === "number" ? data.input_tokens : data.original_input_tokens;
+  const outputTokens = data.output_tokens;
+  if (typeof inputTokens !== "number" || typeof outputTokens !== "number") {
+    return void 0;
+  }
+  return {
+    originalTokens: inputTokens,
+    compressedTokens: outputTokens,
+    savedTokens: typeof data.tokens_saved === "number" ? data.tokens_saved : inputTokens - outputTokens
+  };
+}
+function normalizeTheTokenCompanyCompressResponse(data) {
+  if (typeof data.output !== "string" || typeof data.output_tokens !== "number") {
+    return void 0;
+  }
+  const inputTokens = typeof data.input_tokens === "number" ? data.input_tokens : data.original_input_tokens;
+  if (typeof inputTokens !== "number") {
+    return void 0;
+  }
+  const tokensSaved = typeof data.tokens_saved === "number" ? data.tokens_saved : inputTokens - data.output_tokens;
+  const compressionRatio = typeof data.compression_ratio === "number" ? data.compression_ratio : data.output_tokens === 0 ? 0 : inputTokens / data.output_tokens;
+  return {
+    output: data.output,
+    output_tokens: data.output_tokens,
+    input_tokens: inputTokens,
+    tokens_saved: tokensSaved,
+    compression_ratio: compressionRatio
+  };
+}
+function createPromptCompressionFallback(input, provider = "heuristic", error) {
+  const original = stableStringifyInput(input);
+  const techniques = ["fallback-original"];
+  if (error) {
+    techniques.push("compression-error");
+  }
+  return buildResult(input, input, provider, original, original, techniques);
+}
+function buildResult(input, compressedInput, provider, original, compressed, techniques, tokenCounts) {
+  const originalCharacters = original.length;
+  const compressedCharacters = compressed.length;
+  const savedCharacters = Math.max(
+    0,
+    originalCharacters - compressedCharacters
+  );
+  const originalTokens = tokenCounts?.originalTokens ?? estimatePromptTokens(original);
+  const compressedTokens = tokenCounts?.compressedTokens ?? estimatePromptTokens(compressed);
+  const savedTokens = Math.max(
+    0,
+    tokenCounts?.savedTokens ?? originalTokens - compressedTokens
+  );
+  return {
+    input,
+    compressedInput,
+    provider,
+    originalCharacters,
+    compressedCharacters,
+    savedCharacters,
+    originalTokens,
+    compressedTokens,
+    savedTokens,
+    tokenSavingsRatio: originalTokens > 0 ? savedTokens / originalTokens : 0,
+    savingsRatio: originalCharacters > 0 ? savedCharacters / originalCharacters : 0,
+    techniques
+  };
+}
+function estimatePromptTokens(input) {
+  const text = typeof input === "string" ? input : stableStringifyInput(input);
+  return text.match(/[\p{L}\p{N}]+|[^\s]/gu)?.length ?? 0;
+}
+function compressValue(value, techniques, options) {
+  if (typeof value === "string") return compressText(value, techniques, options);
+  if (Array.isArray(value)) {
+    techniques.add("json-minify");
+    return value.map((item) => compressValue(item, techniques, options));
+  }
+  if (value && typeof value === "object") {
+    techniques.add("json-minify");
+    return Object.keys(value).reduce((acc, key) => {
+      const child = value[key];
+      if (child !== void 0) {
+        acc[key] = compressValue(child, techniques, options);
+      }
+      return acc;
+    }, {});
+  }
+  return value;
+}
+function compressText(value, techniques, options) {
+  const protectedSpans = [];
+  const text = value.replace(PROTECTED_TEXT_PATTERN, (match) => {
+    const placeholder = `__USAGETAP_PROTECTED_${protectedSpans.length}__`;
+    protectedSpans.push(match);
+    techniques.add("protected-text");
+    return placeholder;
+  });
+  const compressed = compressTextWithoutProtection(text, techniques, options);
+  return protectedSpans.reduce(
+    (output, span, index) => output.replace(`__USAGETAP_PROTECTED_${index}__`, span),
+    compressed
+  );
+}
+function compressTextWithoutProtection(value, techniques, options) {
+  const fencePattern = /```([\w-]+)?\n([\s\S]*?)```/g;
+  const parts = [];
+  let cursor = 0;
+  let match;
+  while ((match = fencePattern.exec(value)) !== null) {
+    const before = value.slice(cursor, match.index);
+    const compressedBefore = compressPlainTextAndEmbeddedJson(
+      before,
+      techniques,
+      options
+    );
+    if (compressedBefore) parts.push(compressedBefore);
+    const lang = match[1]?.toLowerCase();
+    const code = cleanCodeBlock(match[2] ?? "");
+    const compressedCode = lang === "json" ? compressJsonText(code, techniques, options) : void 0;
+    if (compressedCode?.format === "toon") {
+      parts.push(`\`\`\`toon
+${compressedCode.text}
+\`\`\``);
+    } else if (compressedCode?.format === "json") {
+      parts.push(`\`\`\`json
+${compressedCode.text}
+\`\`\``);
+    } else {
+      if (code !== match[2]) {
+        techniques.add("code-whitespace");
+      }
+      parts.push(lang ? `\`\`\`${lang}
+${code}
+\`\`\`` : `\`\`\`
+${code}
+\`\`\``);
+    }
+    cursor = match.index + match[0].length;
+  }
+  const after = compressPlainTextAndEmbeddedJson(value.slice(cursor), techniques, options);
+  if (after) parts.push(after);
+  return parts.join("\n").trim();
+}
+function compressPlainText(value, techniques) {
+  const compressed = value.split("\n").map((line) => line.trim()).filter((line) => line).join("\n").replace(/[ \t]{2,}/g, " ").trim();
+  if (compressed !== value.trim()) {
+    techniques.add("text-whitespace");
+  }
+  return compressed;
+}
+function compressPlainTextAndEmbeddedJson(value, techniques, options) {
+  const normalized = compressPlainText(value, techniques);
+  return compressEmbeddedJson(normalized, techniques, options);
+}
+function cleanCodeBlock(code) {
+  const lines = code.replace(/\r\n/g, "\n").split("\n");
+  while (lines.length && lines[0].trim() === "") lines.shift();
+  while (lines.length && lines[lines.length - 1].trim() === "") lines.pop();
+  const commonIndent = lines.filter((line) => line.trim()).reduce((min, line) => {
+    const indent = /^[ \t]*/.exec(line)?.[0].length ?? 0;
+    return min === void 0 ? indent : Math.min(min, indent);
+  }, void 0);
+  return lines.map((line) => commonIndent ? line.slice(commonIndent) : line).join("\n").replace(/[ \t]+$/gm, "");
+}
+function stableStringifyInput(input) {
+  if (typeof input === "string") return input;
+  return JSON.stringify(input) ?? String(input);
+}
+function compressJsonText(text, techniques, options) {
+  const parsed = safeParseJson(text);
+  if (parsed === void 0) {
+    return void 0;
+  }
+  const compactJson = JSON.stringify(parsed);
+  const candidates = [
+    { format: "json", text: compactJson }
+  ];
+  if (options.allowToonString || shouldUseToonForJson(parsed)) {
+    candidates.push({ format: "toon", text: encodeToon(parsed) });
+  }
+  const originalLength = text.trim().length;
+  const best = candidates.reduce(
+    (winner, candidate) => candidate.text.length < winner.text.length ? candidate : winner
+  );
+  if (best.text.length >= originalLength) {
+    return void 0;
+  }
+  techniques.add(best.format === "toon" ? "embedded-json-toon" : "embedded-json-minify");
+  return best;
+}
+function compressEmbeddedJson(text, techniques, options) {
+  let result = "";
+  let cursor = 0;
+  while (cursor < text.length) {
+    const start = findNextJsonStart(text, cursor);
+    if (start < 0) {
+      result += text.slice(cursor);
+      break;
+    }
+    result += text.slice(cursor, start);
+    const span = findBalancedJsonSpan(text, start);
+    if (!span) {
+      result += text[start];
+      cursor = start + 1;
+      continue;
+    }
+    const candidate = compressJsonText(span.text, techniques, options);
+    if (candidate) {
+      result += candidate.text;
+    } else {
+      result += span.text;
+    }
+    cursor = span.end;
+  }
+  return result;
+}
+function findNextJsonStart(text, from) {
+  const objectStart = text.indexOf("{", from);
+  const arrayStart = text.indexOf("[", from);
+  if (objectStart < 0) return arrayStart;
+  if (arrayStart < 0) return objectStart;
+  return Math.min(objectStart, arrayStart);
+}
+function findBalancedJsonSpan(text, start) {
+  const opener = text[start];
+  const closer = opener === "{" ? "}" : opener === "[" ? "]" : void 0;
+  if (!closer) return void 0;
+  const stack = [closer];
+  let inString = false;
+  let escaped = false;
+  for (let index = start + 1; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      stack.push(char === "{" ? "}" : "]");
+      continue;
+    }
+    if (char === stack[stack.length - 1]) {
+      stack.pop();
+      if (!stack.length) {
+        const end = index + 1;
+        return { text: text.slice(start, end), end };
+      }
+    }
+  }
+  return void 0;
+}
+function safeParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function shouldUseToonForJson(value) {
+  if (Array.isArray(value)) {
+    return isUniformObjectArray(value) || value.some(shouldUseToonForJson);
+  }
+  if (isPlainObject(value)) {
+    return Object.values(value).some(shouldUseToonForJson);
+  }
+  return false;
+}
+function encodeToon(value, indent = 0) {
+  if (isPrimitive(value)) {
+    return scalarToToon(value);
+  }
+  if (Array.isArray(value)) {
+    return encodeArrayToon(value, indent);
+  }
+  if (isPlainObject(value)) {
+    const lines = [];
+    for (const [key, child] of Object.entries(value)) {
+      lines.push(...encodePropertyToon(key, child, indent));
+    }
+    return lines.join("\n");
+  }
+  return scalarToToon(String(value));
+}
+function encodePropertyToon(key, value, indent) {
+  const prefix = " ".repeat(indent);
+  const toonKey = keyToToon(key);
+  if (isPrimitive(value)) {
+    return [`${prefix}${toonKey}: ${scalarToToon(value)}`];
+  }
+  if (Array.isArray(value)) {
+    if (value.every(isPrimitive)) {
+      return [`${prefix}${toonKey}[${value.length}]: ${value.map(scalarToToon).join(",")}`];
+    }
+    if (isUniformObjectArray(value)) {
+      const fields = Object.keys(value[0]);
+      const header = `${prefix}${toonKey}[${value.length}]{${fields.map(keyToToon).join(",")}}:`;
+      const rows = value.map(
+        (item) => `${" ".repeat(indent + 2)}${fields.map(
+          (field) => scalarToToon(item[field])
+        ).join(",")}`
+      );
+      return [header, ...rows];
+    }
+    return [
+      `${prefix}${toonKey}[${value.length}]:`,
+      ...value.flatMap((item, index) => {
+        if (isPrimitive(item)) {
+          return [`${" ".repeat(indent + 2)}- ${scalarToToon(item)}`];
+        }
+        return [
+          `${" ".repeat(indent + 2)}- item${index}:`,
+          ...encodeToon(item, indent + 4).split("\n")
+        ];
+      })
+    ];
+  }
+  return [`${prefix}${toonKey}:`, ...encodeToon(value, indent + 2).split("\n")];
+}
+function encodeArrayToon(value, indent) {
+  if (value.every(isPrimitive)) {
+    return `[${value.length}]: ${value.map(scalarToToon).join(",")}`;
+  }
+  if (isUniformObjectArray(value)) {
+    const fields = Object.keys(value[0]);
+    return [
+      `[${value.length}]{${fields.map(keyToToon).join(",")}}:`,
+      ...value.map(
+        (item) => `${" ".repeat(indent + 2)}${fields.map(
+          (field) => scalarToToon(item[field])
+        ).join(",")}`
+      )
+    ].join("\n");
+  }
+  return value.flatMap((item, index) => [
+    `${" ".repeat(indent)}- item${index}:`,
+    ...encodeToon(item, indent + 2).split("\n")
+  ]).join("\n");
+}
+function isUniformObjectArray(value) {
+  if (!value.length || !value.every(isPlainObject)) {
+    return false;
+  }
+  const fields = Object.keys(value[0]);
+  if (!fields.length) {
+    return false;
+  }
+  return value.every((item) => {
+    const record = item;
+    const itemFields = Object.keys(record);
+    return itemFields.length === fields.length && fields.every((field) => itemFields.includes(field) && isPrimitive(record[field]));
+  });
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function keyToToon(key) {
+  return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(key) ? key : JSON.stringify(key);
+}
+function scalarToToon(value) {
+  if (value === null) return "null";
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  const text = String(value);
+  if (text && !/^(true|false|null|-?\d+(?:\.\d+)?)$/i.test(text) && /^[A-Za-z0-9_./@-]+(?: [A-Za-z0-9_./@-]+)*$/.test(text)) {
+    return text;
+  }
+  return JSON.stringify(text);
+}
+
+// src/resources.ts
+var CANONICAL_MEDIA_TYPE = "application/vnd.usagetap.v1+json";
+var DEFAULT_GATEWAY_BASE_URL = "https://gateway.usagetap.com";
+function normalizedBaseUrl(value) {
+  return `${value.replace(/\/+$/, "")}/`;
+}
+function errorMessage(payload, status) {
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    const error = record.error;
+    if (error && typeof error === "object") {
+      const message2 = error.message;
+      if (typeof message2 === "string" && message2) return message2;
+    }
+    const message = record.message;
+    if (typeof message === "string" && message) return message;
+  }
+  return `UsageTap request failed with HTTP ${status}`;
+}
+function errorCode(status) {
+  if (status === 401 || status === 403) return "USAGETAP_AUTH_ERROR";
+  if (status === 429) return "USAGETAP_RATE_LIMITED";
+  if (status >= 500) return "USAGETAP_SERVER_ERROR";
+  return "USAGETAP_BAD_REQUEST";
+}
+var ResourceTransport = class {
+  baseUrl;
+  apiKey;
+  fetchImpl;
+  defaultHeaders;
+  sdkVersion;
+  constructor(baseUrl, config) {
+    this.baseUrl = normalizedBaseUrl(baseUrl);
+    this.apiKey = config.apiKey;
+    this.fetchImpl = config.fetchImpl;
+    this.defaultHeaders = config.headers ?? {};
+    this.sdkVersion = config.sdkVersion;
+  }
+  async request(request) {
+    const body = request.body === void 0 ? void 0 : JSON.stringify(request.body);
+    const headers = {
+      ...this.defaultHeaders,
+      accept: request.response === "data" ? CANONICAL_MEDIA_TYPE : request.response === "ndjson" ? "application/x-ndjson" : "application/json",
+      authorization: `Bearer ${this.apiKey}`,
+      "x-usage-sdk": `js/${this.sdkVersion}`,
+      ...body ? { "content-type": "application/json" } : {},
+      ...request.options?.idempotencyKey ? { "idempotency-key": request.options.idempotencyKey } : {},
+      ...request.options?.headers
+    };
+    let response;
+    try {
+      response = await this.fetchImpl(
+        new URL(request.path.replace(/^\/+/, ""), this.baseUrl),
+        {
+          method: request.method,
+          headers,
+          body,
+          signal: request.options?.signal
+        }
+      );
+    } catch (error) {
+      throw new UsageTapError(
+        "USAGETAP_NETWORK_ERROR",
+        "Failed to reach UsageTap",
+        { retryable: true, cause: error }
+      );
+    }
+    const requestId = response.headers.get("x-request-id") ?? response.headers.get("x-usage-correlation-id") ?? void 0;
+    const text = await response.text();
+    let payload;
+    if (text && request.response !== "ndjson") {
+      try {
+        payload = JSON.parse(text);
+      } catch (error) {
+        throw new UsageTapError(
+          "USAGETAP_INVALID_RESPONSE",
+          "UsageTap returned invalid JSON",
+          { status: response.status, correlationId: requestId, cause: error }
+        );
+      }
+    }
+    if (!response.ok) {
+      throw new UsageTapError(
+        errorCode(response.status),
+        errorMessage(payload, response.status),
+        {
+          status: response.status,
+          retryable: response.status === 429 || response.status >= 500,
+          correlationId: requestId,
+          details: payload && typeof payload === "object" ? payload : void 0
+        }
+      );
+    }
+    if (request.response === "ndjson") {
+      if (!text.trim()) return [];
+      try {
+        return text.trim().split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+      } catch (error) {
+        throw new UsageTapError(
+          "USAGETAP_INVALID_RESPONSE",
+          "UsageTap returned invalid NDJSON",
+          { status: response.status, correlationId: requestId, cause: error }
+        );
+      }
+    }
+    if (request.response === "data") {
+      if (!payload || typeof payload !== "object" || !("data" in payload)) {
+        throw new UsageTapError(
+          "USAGETAP_INVALID_RESPONSE",
+          "UsageTap response missing data",
+          { status: response.status, correlationId: requestId }
+        );
+      }
+      return payload.data;
+    }
+    if (payload === void 0) {
+      throw new UsageTapError(
+        "USAGETAP_INVALID_RESPONSE",
+        "UsageTap response was empty",
+        { status: response.status, correlationId: requestId }
+      );
+    }
+    return payload;
+  }
+};
+function resourceId(value, keys, label) {
+  const id = typeof value === "string" ? value : keys.map((key) => value[key]).find((candidate) => Boolean(candidate?.trim()));
+  if (!id?.trim()) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      `${label} requires a non-empty ID`
+    );
+  }
+  return id.trim();
+}
+function terminalSummary(status) {
+  return status === "COMPLETE" || status === "FAILED";
+}
+function terminalGatewayBatch(status) {
+  return ["completed", "failed", "expired", "cancelled"].includes(status);
+}
+function validateWaitOptions(options) {
+  const pollIntervalMs = options.pollIntervalMs ?? 1500;
+  const timeoutMs = options.timeoutMs ?? 3 * 6e4;
+  if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 0) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "pollIntervalMs must be a non-negative number"
+    );
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "timeoutMs must be a positive number"
+    );
+  }
+  return { pollIntervalMs, timeoutMs };
+}
+var SummarizationResource = class {
+  summaries;
+  batches;
+  profiles;
+  measurements;
+  transport;
+  constructor(config) {
+    this.transport = new ResourceTransport(config.apiBaseUrl, config);
+    this.summaries = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/compression/summaries",
+        body: params,
+        options,
+        response: "data"
+      }),
+      retrieve: (jobId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/compression/jobs/${encodeURIComponent(
+          resourceId(jobId, ["jobId"], "summaries.retrieve")
+        )}`,
+        options,
+        response: "data"
+      }),
+      wait: (job, options) => this.waitForSummary(job, options)
+    };
+    this.batches = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/compression/batches",
+        body: params,
+        options,
+        response: "data"
+      }),
+      retrieve: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/compression/batches/${encodeURIComponent(
+          resourceId(batchId, ["batchId"], "summarization.batches.retrieve")
+        )}`,
+        options,
+        response: "data"
+      }),
+      wait: (batch, options) => this.waitForBatch(batch, options)
+    };
+    this.profiles = {
+      retrieve: (profile, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/compression/profiles/${encodeURIComponent(
+          resourceId(profile, [], "summarization.profiles.retrieve")
+        )}`,
+        options,
+        response: "data"
+      })
+    };
+    this.measurements = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/compression/measurements",
+        body: params,
+        options,
+        response: "data"
+      })
+    };
+  }
+  async waitForSummary(value, options = {}) {
+    const { pollIntervalMs, timeoutMs } = validateWaitOptions(options);
+    const deadline = Date.now() + timeoutMs;
+    let job = typeof value === "string" ? await this.summaries.retrieve(value, options) : value;
+    while (!terminalSummary(job.status)) {
+      if (Date.now() >= deadline) {
+        throw new UsageTapError(
+          "USAGETAP_RETRY_EXHAUSTED",
+          `Summarization job ${job.jobId} did not finish before timeout`,
+          { retryable: true }
+        );
+      }
+      await sleep(pollIntervalMs, options.signal);
+      job = await this.summaries.retrieve(job.jobId, options);
+    }
+    return job;
+  }
+  async waitForBatch(value, options = {}) {
+    const { pollIntervalMs, timeoutMs } = validateWaitOptions(options);
+    const deadline = Date.now() + timeoutMs;
+    let batch = typeof value === "string" ? await this.batches.retrieve(value, options) : value;
+    while (!terminalSummary(batch.status)) {
+      if (Date.now() >= deadline) {
+        throw new UsageTapError(
+          "USAGETAP_RETRY_EXHAUSTED",
+          `Summarization batch ${batch.batchId} did not finish before timeout`,
+          { retryable: true }
+        );
+      }
+      await sleep(pollIntervalMs, options.signal);
+      batch = await this.batches.retrieve(batch.batchId, options);
+    }
+    return batch;
+  }
+};
+var GatewayResource = class {
+  chat;
+  models;
+  batches;
+  transport;
+  idempotencyGenerator;
+  constructor(config) {
+    this.transport = new ResourceTransport(
+      config.gatewayBaseUrl ?? DEFAULT_GATEWAY_BASE_URL,
+      config
+    );
+    this.idempotencyGenerator = config.idempotencyGenerator ?? createIdempotencyKey;
+    this.chat = {
+      completions: {
+        create: (params, options) => this.transport.request({
+          method: "POST",
+          path: "/v1/chat/completions",
+          body: params,
+          options,
+          response: "json"
+        })
+      }
+    };
+    this.models = {
+      list: (options) => this.transport.request({
+        method: "GET",
+        path: "/v1/models",
+        options,
+        response: "json"
+      })
+    };
+    this.batches = {
+      create: (params, options = {}) => this.transport.request({
+        method: "POST",
+        path: "/v1/batches",
+        body: params,
+        options: {
+          ...options,
+          idempotencyKey: options.idempotencyKey ?? this.idempotencyGenerator()
+        },
+        response: "json"
+      }),
+      retrieve: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.retrieve")
+        )}`,
+        options,
+        response: "json"
+      }),
+      wait: (batch, options) => this.waitForBatch(batch, options),
+      cancel: (batchId, options) => this.transport.request({
+        method: "POST",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.cancel")
+        )}/cancel`,
+        options,
+        response: "json"
+      }),
+      results: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.results")
+        )}/results`,
+        options,
+        response: "ndjson"
+      })
+    };
+  }
+  async waitForBatch(value, options = {}) {
+    const { pollIntervalMs, timeoutMs } = validateWaitOptions(options);
+    const deadline = Date.now() + timeoutMs;
+    let batch = typeof value === "string" ? await this.batches.retrieve(value, options) : value;
+    while (!terminalGatewayBatch(batch.status)) {
+      if (Date.now() >= deadline) {
+        throw new UsageTapError(
+          "USAGETAP_RETRY_EXHAUSTED",
+          `Gateway batch ${batch.id} did not finish before timeout`,
+          { retryable: true }
+        );
+      }
+      await sleep(pollIntervalMs, options.signal);
+      batch = await this.batches.retrieve(batch.id, options);
+    }
+    return batch;
+  }
+};
+
+// src/client.ts
+var CALL_BEGIN_PATH = "call_begin";
+var CALL_END_PATH = "call_end";
+var COMPRESS_PROMPT_PATH = "compress_prompt";
+var SAMPLES_PATH = "samples";
+var SAMPLING_SETTINGS_PATH = "sampling/settings";
+var SAMPLING_DECIDE_PATH = "sampling/decide";
+var CHECK_USAGE_PATH = "customers/{customerId}/usage";
+var CREATE_CUSTOMER_PATH = "customers";
+var CHANGE_PLAN_PATH = "customers/{customerId}/change_plan";
+var INCREMENT_CUSTOM_METER_PATH = "custom_meter";
+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_TYPE2 = "application/vnd.usagetap.v1+json";
+var DEFAULT_BASE_URL = "https://api.usagetap.com";
+var DEFAULT_RUN_INACTIVITY_MS = 60 * 60 * 1e3;
+var SDK_VERSION = "1.4.0" ;
+var HAS_WINDOW = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+var UsageTapClient = class {
+  /** OpenAI-compatible chat, model, and native batch operations. */
+  gateway;
+  /** Published-profile context summarization operations. */
+  summarization;
+  apiKey;
+  baseUrl;
+  fetchImpl;
+  defaultFeature;
+  defaultTags;
+  defaultHeaders;
+  retryDefaults;
+  idempotencyGenerator;
+  logFn;
+  metricFn;
+  authHeader;
+  autoIdempotency;
+  tokenCompanyApiKey;
+  tokenCompanyEndpoint;
+  model;
+  tokenCompanyModel;
+  aggressiveness;
+  tokenCompanyAggressiveness;
+  tokenCompanyAppId;
+  usageTapCompressionApiKey;
+  usageTapCompressionEndpoint;
+  usageTapCompressionMessagesEndpoint;
+  usageTapCompressionModel;
+  usageTapCompressionAggressiveness;
+  sampling;
+  samplingSettingsCacheMs;
+  circuitBreaker;
+  circuitBreakerRuns = /* @__PURE__ */ new Map();
+  samplingSettingsCache;
+  constructor(options = {}) {
+    const apiKey = options.apiKey?.trim() || readEnvironmentVariable("USAGETAP_API_KEY");
+    const baseUrl = options.baseUrl?.trim() || readEnvironmentVariable("USAGETAP_BASE_URL") || DEFAULT_BASE_URL;
+    if (!apiKey) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "UsageTapClient requires an apiKey or the USAGETAP_API_KEY environment variable"
+      );
+    }
+    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 normalizedBaseUrl2 = normalizeBaseUrl(baseUrl);
+    this.baseUrl = new URL(normalizedBaseUrl2);
+    this.apiKey = apiKey;
+    this.fetchImpl = wrapFetchImplementation(fetchCandidate, !options.fetchImpl);
+    const resourceConfig = {
+      apiKey,
+      apiBaseUrl: normalizedBaseUrl2,
+      gatewayBaseUrl: options.gatewayBaseUrl?.trim() || readEnvironmentVariable("USAGETAP_GATEWAY_URL"),
+      fetchImpl: this.fetchImpl,
+      headers: options.headers,
+      sdkVersion: SDK_VERSION,
+      idempotencyGenerator: options.idempotencyGenerator
+    };
+    this.gateway = new GatewayResource(resourceConfig);
+    this.summarization = new SummarizationResource(resourceConfig);
+    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.metricFn = options.onUsageMetric;
+    this.authHeader = options.useApiKeyHeader ? API_KEY_HEADER : AUTH_HEADER;
+    this.autoIdempotency = options.autoIdempotency ?? true;
+    this.tokenCompanyApiKey = options.tokenCompanyApiKey;
+    this.tokenCompanyEndpoint = options.tokenCompanyEndpoint;
+    this.model = options.model;
+    this.tokenCompanyModel = options.tokenCompanyModel;
+    this.aggressiveness = options.aggressiveness;
+    this.tokenCompanyAggressiveness = options.tokenCompanyAggressiveness;
+    this.tokenCompanyAppId = options.tokenCompanyAppId;
+    this.usageTapCompressionApiKey = options.usageTapCompressionApiKey ?? apiKey;
+    this.usageTapCompressionEndpoint = options.usageTapCompressionEndpoint;
+    this.usageTapCompressionMessagesEndpoint = options.usageTapCompressionMessagesEndpoint;
+    this.usageTapCompressionModel = options.usageTapCompressionModel;
+    this.usageTapCompressionAggressiveness = options.usageTapCompressionAggressiveness;
+    this.sampling = options.sampling;
+    this.samplingSettingsCacheMs = Number.isFinite(options.samplingSettingsCacheMs) ? Math.max(0, Number(options.samplingSettingsCacheMs)) : 5 * 60 * 1e3;
+    if (options.circuitBreaker) {
+      const maxCallsPerRun = options.circuitBreaker.maxCallsPerRun;
+      if (!Number.isInteger(maxCallsPerRun) || maxCallsPerRun < 1) {
+        throw new UsageTapError(
+          "USAGETAP_BAD_REQUEST",
+          "circuitBreaker.maxCallsPerRun must be a positive integer"
+        );
+      }
+      const runInactivityMs = options.circuitBreaker.runInactivityMs ?? DEFAULT_RUN_INACTIVITY_MS;
+      if (!Number.isFinite(runInactivityMs) || runInactivityMs < 1) {
+        throw new UsageTapError(
+          "USAGETAP_BAD_REQUEST",
+          "circuitBreaker.runInactivityMs must be a positive number"
+        );
+      }
+      this.circuitBreaker = {
+        maxCallsPerRun,
+        runInactivityMs
+      };
+    }
+  }
+  shouldSample(request, policy = this.sampling || void 0) {
+    if (!policy) return false;
+    const rate = Math.min(1, Math.max(0, Number(policy.rate) || 0));
+    if (rate <= 0) return false;
+    const customerId = request.customerId?.trim();
+    if (customerId && policy.customers?.exclude?.includes(customerId)) return false;
+    const feature = request.feature?.trim();
+    if (feature && policy.features?.exclude?.includes(feature)) return false;
+    const included = policy.features?.include?.filter(Boolean) ?? [];
+    if (included.length > 0 && (!feature || !included.includes(feature))) return false;
+    const minimum = Math.max(0, Math.round(policy.minInputTokens ?? 0));
+    if (minimum > 0 && estimatePromptTokens(request.input) < minimum) return false;
+    return (policy.random ?? Math.random)() < rate;
+  }
+  async getSamplingSettings(options = {}) {
+    const now = Date.now();
+    if (!options.forceRefresh && this.samplingSettingsCache && this.samplingSettingsCache.expiresAtMs > now) {
+      return {
+        result: { status: "ACCEPTED", code: "SAMPLING_SETTINGS_CACHED" },
+        data: this.samplingSettingsCache.settings,
+        correlationId: options.correlationId ?? "local-cache"
+      };
+    }
+    const response = await this.requestGet(
+      SAMPLING_SETTINGS_PATH,
+      {
+        signal: options.signal,
+        headers: options.headers,
+        retries: options.retries,
+        correlationId: options.correlationId
+      }
+    );
+    const serverCacheMs = Math.max(0, Number(response.data.cacheSeconds) || 0) * 1e3;
+    const cacheMs = Math.min(this.samplingSettingsCacheMs, serverCacheMs);
+    this.samplingSettingsCache = {
+      settings: response.data,
+      expiresAtMs: now + cacheMs
+    };
+    return response;
+  }
+  async shouldSampleAsync(request, policy) {
+    if (policy) return this.shouldSample(request, policy);
+    if (this.sampling === false) return false;
+    if (this.sampling) return this.shouldSample(request, this.sampling);
+    try {
+      const settings = await this.getSamplingSettings();
+      return this.shouldSample(request, settings.data);
+    } catch {
+      return false;
+    }
+  }
+  async decideSample(request, options = {}) {
+    const hasTokens = Number.isFinite(request.inputTokens) && Number(request.inputTokens) >= 0;
+    const hasCharacters = Number.isFinite(request.inputCharacters) && Number(request.inputCharacters) >= 0;
+    if (!hasTokens && !hasCharacters) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "decideSample requires inputTokens or inputCharacters"
+      );
+    }
+    return this.request(
+      SAMPLING_DECIDE_PATH,
+      request,
+      options
+    );
+  }
+  async captureSample(request, options = {}) {
+    if (!request || request.input === void 0) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "captureSample requires input"
+      );
+    }
+    if (!request.provider?.trim()) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "captureSample requires provider"
+      );
+    }
+    const sampleId = request.sampleId?.trim() || this.idempotencyGenerator();
+    return this.request(
+      SAMPLES_PATH,
+      { ...request, sampleId },
+      { ...options, idempotencyKey: sampleId }
+    );
+  }
+  async beginCall(request, options = {}) {
+    const idempotencyKey = request.idempotencyKey ?? request.idempotency ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    this.reserveRunCall(request, idempotencyKey);
+    const apiRequest = { ...request };
+    delete apiRequest.runId;
+    const payload = {
+      ...apiRequest,
+      feature: request.feature ?? this.defaultFeature,
+      tags: this.mergeTags(request.tags)
+    };
+    if (idempotencyKey) {
+      payload.idempotencyKey = idempotencyKey;
+      payload.idempotency = idempotencyKey;
+    }
+    const response = await this.request(
+      CALL_BEGIN_PATH,
+      payload,
+      {
+        ...options,
+        idempotencyKey
+      }
+    );
+    return response;
+  }
+  /**
+   * Inspect a configured run circuit breaker without consuming another call.
+   */
+  canRunContinue(request) {
+    const identity = this.resolveRunIdentity(request);
+    if (!identity || !this.circuitBreaker) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "canRunContinue requires circuitBreaker configuration and a non-empty runId"
+      );
+    }
+    this.expireInactiveRuns();
+    const calls = this.circuitBreakerRuns.get(identity.key)?.calls ?? 0;
+    return this.createCircuitBreakerDecision(identity.customerId, identity.runId, calls);
+  }
+  /**
+   * Release local state after a workflow finishes. Returns true when state existed.
+   */
+  resetRun(request) {
+    const identity = this.resolveRunIdentity(request);
+    return identity ? this.circuitBreakerRuns.delete(identity.key) : false;
+  }
+  async promptCompress(request, options = {}) {
+    if (!request?.callId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "promptCompress requires callId"
+      );
+    }
+    const requestInput = request.input ?? request.text;
+    if (requestInput === void 0) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "promptCompress requires input or text"
+      );
+    }
+    const result = await this.compressPromptInput(requestInput, {
+      provider: request.provider,
+      model: request.model,
+      tokenCompanyModel: request.tokenCompanyModel,
+      aggressiveness: request.aggressiveness,
+      tokenCompanyAggressiveness: request.tokenCompanyAggressiveness,
+      tokenCompanyAppId: request.tokenCompanyAppId,
+      usageTapCompressionModel: request.usageTapCompressionModel,
+      usageTapCompressionAggressiveness: request.usageTapCompressionAggressiveness,
+      signal: options.signal
+    });
+    try {
+      await this.recordPromptCompression(
+        {
+          callId: request.callId,
+          promptCompression: this.toPromptCompressionTelemetry(result)
+        },
+        options
+      );
+      return { ...result, callId: request.callId };
+    } catch (error) {
+      return {
+        ...createPromptCompressionFallback(
+          requestInput,
+          request.provider ?? result.provider,
+          error
+        ),
+        callId: request.callId
+      };
+    }
+  }
+  async compressPromptInput(input, options = {}) {
+    return compressPrompt({
+      input,
+      provider: options.provider,
+      tokenCompanyApiKey: this.tokenCompanyApiKey,
+      tokenCompanyEndpoint: this.tokenCompanyEndpoint,
+      model: options.model ?? this.model,
+      tokenCompanyModel: options.tokenCompanyModel ?? this.tokenCompanyModel,
+      aggressiveness: options.aggressiveness ?? this.aggressiveness,
+      tokenCompanyAggressiveness: options.tokenCompanyAggressiveness ?? this.tokenCompanyAggressiveness,
+      tokenCompanyAppId: options.tokenCompanyAppId ?? this.tokenCompanyAppId,
+      usageTapCompressionApiKey: this.usageTapCompressionApiKey,
+      usageTapCompressionEndpoint: this.usageTapCompressionEndpoint,
+      usageTapCompressionModel: options.usageTapCompressionModel ?? this.usageTapCompressionModel,
+      usageTapCompressionAggressiveness: options.usageTapCompressionAggressiveness ?? this.usageTapCompressionAggressiveness,
+      fetchImpl: this.fetchImpl,
+      signal: options.signal,
+      failOpen: options.failOpen
+    });
+  }
+  /**
+   * Compress text with UsageTap's hosted compression service.
+   *
+   * This is the short, standalone path. It does not create a metered call and
+   * fails open to the original text unless failOpen is explicitly disabled.
+   */
+  async compress(text, options = {}) {
+    if (typeof text !== "string") {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "compress requires text"
+      );
+    }
+    const result = await this.compressPromptInput(text, {
+      ...options,
+      provider: "usagetap"
+    });
+    const output = typeof result.compressedInput === "string" ? result.compressedInput : text;
+    return {
+      ...result,
+      compressedInput: output,
+      output
+    };
+  }
+  async compressPromptMessages(input, options = {}) {
+    return compressPromptMessages({
+      input,
+      provider: options.provider ?? "usagetap",
+      usageTapCompressionApiKey: this.usageTapCompressionApiKey,
+      usageTapCompressionMessagesEndpoint: this.usageTapCompressionMessagesEndpoint,
+      aggressiveness: options.aggressiveness ?? this.aggressiveness,
+      usageTapCompressionAggressiveness: options.usageTapCompressionAggressiveness ?? this.usageTapCompressionAggressiveness,
+      mode: options.mode,
+      latencyBudgetMs: options.latencyBudgetMs,
+      compactEmptyUserMessages: options.compactEmptyUserMessages,
+      compactDuplicateUserTextParts: options.compactDuplicateUserTextParts,
+      fetchImpl: this.fetchImpl,
+      signal: options.signal,
+      failOpen: options.failOpen
+    });
+  }
+  async recordPromptCompression(request, options = {}) {
+    if (!request?.callId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "recordPromptCompression requires callId"
+      );
+    }
+    return this.request(
+      COMPRESS_PROMPT_PATH,
+      {
+        callId: request.callId,
+        promptCompression: request.promptCompression
+      },
+      options
+    );
+  }
+  async endCall(request, options = {}) {
+    if (!request?.callId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "endCall requires callId"
+      );
+    }
+    const { customerId, feature, tags, ...apiPayload } = request;
+    const response = await this.request(
+      CALL_END_PATH,
+      apiPayload,
+      options
+    );
+    this.emitUsageMetric({
+      type: "call_end",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      customerId: customerId ?? "unknown",
+      callId: request.callId,
+      feature: feature ?? this.defaultFeature,
+      tags: tags ?? this.defaultTags,
+      providerUsed: request.providerUsed,
+      modelUsed: request.modelUsed,
+      reasoningEffort: request.reasoningEffort,
+      reasoningEffortSource: request.reasoningEffortSource,
+      reasoningMode: request.reasoningMode,
+      reasoningBudgetTokens: request.reasoningBudgetTokens,
+      metrics: {
+        inputTokens: request.inputTokens,
+        responseTokens: request.responseTokens,
+        cachedInputTokens: request.cachedInputTokens,
+        cacheWriteInputTokens: request.cacheWriteInputTokens,
+        reasoningTokens: request.reasoningTokens,
+        searches: request.searches,
+        audioSeconds: request.audioSeconds,
+        costUsd: response.data.costUSD
+      },
+      correlationId: response.correlationId
+    });
+    return response;
+  }
+  async checkUsage(request, options = {}) {
+    if (!request?.customerId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "checkUsage requires customerId"
+      );
+    }
+    const path = CHECK_USAGE_PATH.replace(
+      "{customerId}",
+      encodeURIComponent(request.customerId)
+    );
+    const response = await this.requestGet(
+      path,
+      options
+    );
+    return response;
+  }
+  async createCustomer(request, options = {}) {
+    if (!request?.customerId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "createCustomer requires customerId"
+      );
+    }
+    const idempotencyKey = options.idempotencyKey ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    const response = await this.request(
+      CREATE_CUSTOMER_PATH,
+      { ...request },
+      {
+        ...options,
+        idempotencyKey
+      }
+    );
+    return response;
+  }
+  async changePlan(request, options = {}) {
+    if (!request?.customerId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "changePlan requires customerId"
+      );
+    }
+    if (!request?.planId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "changePlan requires planId"
+      );
+    }
+    const path = CHANGE_PLAN_PATH.replace(
+      "{customerId}",
+      encodeURIComponent(request.customerId)
+    );
+    const idempotencyKey = options.idempotencyKey ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    const payload = {
+      planId: request.planId,
+      strategy: request.strategy ?? "IMMEDIATE_RESET"
+    };
+    const response = await this.request(
+      path,
+      payload,
+      {
+        ...options,
+        idempotencyKey
+      }
+    );
+    return response;
+  }
+  async incrementCustomMeter(request, options = {}) {
+    if (!request?.customerId) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "incrementCustomMeter requires customerId"
+      );
+    }
+    if (!request?.meterSlot) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "incrementCustomMeter requires meterSlot"
+      );
+    }
+    if (!["CUSTOM1", "CUSTOM2"].includes(request.meterSlot)) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "meterSlot must be CUSTOM1 or CUSTOM2"
+      );
+    }
+    if (typeof request.amount !== "number" || !Number.isFinite(request.amount) || request.amount <= 0) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "incrementCustomMeter requires a positive numeric amount"
+      );
+    }
+    const idempotencyKey = options.idempotencyKey ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    const payload = {
+      customerId: request.customerId,
+      meterSlot: request.meterSlot,
+      amount: request.amount
+    };
+    if (request.customerUserId) {
+      payload.customerUserId = request.customerUserId;
+    }
+    if (request.customerUserName) {
+      payload.customerUserName = request.customerUserName;
+    }
+    if (request.customerUserEmail) {
+      payload.customerUserEmail = request.customerUserEmail;
+    }
+    if (request.feature) {
+      payload.feature = request.feature;
+    }
+    if (request.tags && request.tags.length > 0) {
+      payload.tags = request.tags;
+    }
+    if (request.metadata) {
+      payload.metadata = request.metadata;
+    }
+    const response = await this.request(
+      INCREMENT_CUSTOM_METER_PATH,
+      payload,
+      {
+        ...options,
+        idempotencyKey
+      }
+    );
+    this.emitUsageMetric({
+      type: "custom_meter",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      customerId: request.customerId,
+      feature: request.feature ?? this.defaultFeature,
+      tags: request.tags ?? this.defaultTags,
+      metrics: {
+        customMeterSlot: request.meterSlot,
+        customMeterAmount: request.amount
+      },
+      correlationId: response.correlationId
+    });
+    return response;
+  }
+  async withUsage(beginRequest, handler, options = {}) {
+    const idempotencyKey = beginRequest.idempotencyKey ?? beginRequest.idempotency ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    const beginPayload = idempotencyKey ? { ...beginRequest, idempotencyKey, idempotency: idempotencyKey } : { ...beginRequest };
+    const beginResponse = await this.beginCall(beginPayload, options);
+    let usage = {};
+    const pricingMode = beginResponse.data.pricingMode ?? beginRequest.pricingMode ?? (beginRequest.batch === true ? "batch" : beginRequest.batch === false ? "standard" : void 0);
+    if (pricingMode) {
+      usage.pricingMode = pricingMode;
+      usage.batch = pricingMode === "batch";
+    }
+    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,
+            // Pass context for metric tracking
+            customerId: beginRequest.customerId,
+            feature: beginRequest.feature ?? this.defaultFeature,
+            tags: beginRequest.tags ?? this.defaultTags,
+            ...usage,
+            error: errorPayload
+          },
+          {
+            ...options,
+            correlationId: beginResponse.correlationId
+          }
+        );
+      } catch (error) {
+        endCallError = error;
+      }
+    }
+    if (handlerError) {
+      throw handlerError;
+    }
+    if (endCallError) {
+      throw wrapEndCallError(endCallError, beginResponse.correlationId);
+    }
+    return handlerResult;
+  }
+  /**
+   * Meter one operation. Pass only a customer ID for the common path, or the
+   * existing begin-call request object when feature, tags, or entitlements are needed.
+   */
+  async meter(request, handler, options = {}) {
+    const beginRequest = typeof request === "string" ? { customerId: request } : request;
+    return this.withUsage(beginRequest, handler, options);
+  }
+  toPromptCompressionTelemetry(result) {
+    return {
+      provider: result.provider,
+      originalTokens: result.originalTokens,
+      compressedTokens: result.compressedTokens,
+      savedTokens: result.savedTokens,
+      tokenSavingsRatio: result.tokenSavingsRatio,
+      techniques: result.techniques
+    };
+  }
+  reserveRunCall(request, idempotencyKey) {
+    const identity = this.resolveRunIdentity(request);
+    if (!identity || !this.circuitBreaker) return;
+    this.expireInactiveRuns();
+    const now = Date.now();
+    const state = this.circuitBreakerRuns.get(identity.key) ?? {
+      calls: 0,
+      reservationKeys: /* @__PURE__ */ new Set(),
+      lastSeenAtMs: now
+    };
+    const reservationKey = idempotencyKey ?? this.idempotencyGenerator();
+    state.lastSeenAtMs = now;
+    if (state.reservationKeys.has(reservationKey)) {
+      this.circuitBreakerRuns.set(identity.key, state);
+      return;
+    }
+    const decision = this.createCircuitBreakerDecision(
+      identity.customerId,
+      identity.runId,
+      state.calls
+    );
+    if (!decision.allowed) {
+      throw new UsageTapError(
+        "USAGETAP_CIRCUIT_OPEN",
+        `Run ${identity.runId} reached its ${decision.limit}-call circuit-breaker limit`,
+        {
+          details: {
+            reason: decision.reason,
+            customerId: identity.customerId,
+            runId: identity.runId,
+            calls: decision.calls,
+            limit: decision.limit,
+            remaining: decision.remaining
+          }
+        }
+      );
+    }
+    state.calls += 1;
+    state.reservationKeys.add(reservationKey);
+    this.circuitBreakerRuns.set(identity.key, state);
+  }
+  resolveRunIdentity(request) {
+    const customerId = request.customerId?.trim();
+    const runId = request.runId?.trim();
+    if (!customerId || !runId) return void 0;
+    return {
+      key: `${customerId}\0${runId}`,
+      customerId,
+      runId
+    };
+  }
+  createCircuitBreakerDecision(customerId, runId, calls) {
+    const limit = this.circuitBreaker?.maxCallsPerRun ?? 0;
+    const allowed = calls < limit;
+    return {
+      allowed,
+      ...allowed ? {} : { reason: "max_calls_per_run" },
+      customerId,
+      runId,
+      calls,
+      limit,
+      remaining: Math.max(0, limit - calls)
+    };
+  }
+  expireInactiveRuns() {
+    if (!this.circuitBreaker || this.circuitBreakerRuns.size === 0) return;
+    const expiredBefore = Date.now() - this.circuitBreaker.runInactivityMs;
+    for (const [key, state] of this.circuitBreakerRuns) {
+      if (state.lastSeenAtMs < expiredBefore) {
+        this.circuitBreakerRuns.delete(key);
+      }
+    }
+  }
+  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 requestGet(path, options) {
+    const url = new URL(path, this.baseUrl).toString();
+    const headers = this.composeHeaders(void 0, 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,
+          correlationId: options.correlationId
+        });
+        const response = await this.performFetch({
+          url,
+          method: "GET",
+          headers,
+          signal: options.signal
+        });
+        this.log({
+          event: "request:success",
+          path,
+          attempt,
+          correlationId: response.correlationId,
+          elapsedMs: startTime() - startedAt
+        });
+        return response;
+      },
+      resolvedRetry,
+      (error) => this.shouldRetry(error),
+      (attempt, delayMs, error) => {
+        this.log({
+          event: "retry:scheduled",
+          path,
+          attempt,
+          correlationId: options.correlationId,
+          error,
+          elapsedMs: delayMs
+        });
+      },
+      options.signal
+    ).catch((error) => {
+      this.log({
+        event: "retry:exhausted",
+        path,
+        attempt: resolvedRetry.maxAttempts,
+        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}`,
+      "content-type": "application/json",
+      accept: CANONICAL_MEDIA_TYPE2
+    };
+    if (!HAS_WINDOW) {
+      headers["user-agent"] = `${USER_AGENT}/${SDK_VERSION}`;
+    }
+    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);
+  }
+  emitUsageMetric(event) {
+    try {
+      this.metricFn?.(event);
+    } catch {
+    }
+  }
+  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 readEnvironmentVariable(name) {
+  const runtime = globalThis;
+  const value = runtime.process?.env?.[name]?.trim();
+  return value || 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 wrapFetchImplementation(fetchCandidate, preferGlobalContext) {
+  const target = preferGlobalContext ? globalThis : void 0;
+  return ((...args) => target ? Reflect.apply(fetchCandidate, target, args) : fetchCandidate(...args));
+}
+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
+var OpenAIPromptCompressionStats = class {
+  history = [];
+  failures = [];
+  _record(turn) {
+    this.history.push(turn);
+  }
+  _recordFailure(failure) {
+    this.failures.push(failure);
+  }
+  get totalOriginalTokens() {
+    return this.history.reduce((sum, turn) => sum + (turn.originalTokens ?? 0), 0);
+  }
+  get totalCompressedTokens() {
+    return this.history.reduce((sum, turn) => sum + (turn.compressedTokens ?? 0), 0);
+  }
+  get totalTokensSaved() {
+    return this.history.reduce((sum, turn) => sum + (turn.savedTokens ?? 0), 0);
+  }
+  get totalOriginalCharacters() {
+    return this.history.reduce((sum, turn) => sum + turn.originalCharacters, 0);
+  }
+  get totalCompressedCharacters() {
+    return this.history.reduce((sum, turn) => sum + turn.compressedCharacters, 0);
+  }
+  get totalCharactersSaved() {
+    return this.history.reduce((sum, turn) => sum + turn.savedCharacters, 0);
+  }
+  get calls() {
+    return this.history.length;
+  }
+  get telemetryFailures() {
+    return this.failures.length;
+  }
+  get failOpenEvents() {
+    return this.history.filter(
+      (turn) => turn.techniques.includes("compression-error") || turn.techniques.includes("fallback-original")
+    ).length;
+  }
+  get tokenSavingsRatio() {
+    return this.totalOriginalTokens > 0 ? this.totalTokensSaved / this.totalOriginalTokens : 0;
+  }
+  get savingsRatio() {
+    return this.totalOriginalCharacters > 0 ? this.totalCharactersSaved / this.totalOriginalCharacters : 0;
+  }
+};
 function createOpenAIAdapter(init) {
-  const { client, usageTap } = init;
+  const { client, usageTap, provider = "openai" } = init;
   return {
     async invoke(params) {
       const result = await usageTap.withUsage(
         params.begin,
         async (ctx) => {
+          ctx.setUsage({ providerUsed: provider });
           const response = await params.call(client, {
             hints: ctx.begin.data.vendorHints,
             begin: ctx.begin
           });
-          tryInferUsage(response, ctx.begin.data.vendorHints, params.extractUsage, ctx);
+          tryInferUsage(response, ctx.begin.data.vendorHints, params.extractUsage, ctx, provider);
           return {
             data: response,
             begin: ctx.begin
@@ -24,6 +2246,7 @@ function createOpenAIAdapter(init) {
       const result = await usageTap.withUsage(
         params.begin,
         async (ctx) => {
+          ctx.setUsage({ providerUsed: provider });
           const { stream, onComplete } = await params.call(client, {
             hints: ctx.begin.data.vendorHints,
             begin: ctx.begin
@@ -43,32 +2266,1639 @@ function createOpenAIAdapter(init) {
               throw error;
             }
           }, ctx);
-          const finalize = async () => {
-            await wrapped.__usageTapFinalize?.();
-          };
-          return {
-            stream: wrapped,
-            begin: ctx.begin,
-            finalize
-          };
-        },
-        params.withUsageOptions
-      );
-      return result;
+          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 withSampling(client, options = {}) {
+  if (!client || !options) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "withSampling requires an OpenAI-compatible client and sampling options"
+    );
+  }
+  const { apiKey, usageTapClient, provider = "openai", ...policy } = options;
+  const localPolicy = typeof policy.rate === "number" ? policy : void 0;
+  const usageTap = usageTapClient ?? new UsageTapClient({ apiKey, sampling: localPolicy });
+  const wrapCreate = (create) => async (params, requestOptions) => {
+    const { usageTap: callContextRaw, ...providerOptions } = requestOptions ?? {};
+    const callContext = isObjectRecord(callContextRaw) ? callContextRaw : {};
+    const streaming = params.stream === true;
+    const decision = streaming ? Promise.resolve(false) : usageTap.shouldSampleAsync({
+      customerId: readString(callContext.customerId),
+      feature: readString(callContext.feature),
+      input: params
+    }, localPolicy);
+    const startedAt = Date.now();
+    try {
+      const response = await create(
+        params,
+        Object.keys(providerOptions).length ? providerOptions : void 0
+      );
+      const selected = await decision;
+      if (selected) {
+        const record = isObjectRecord(response) ? response : {};
+        await usageTap.captureSample({
+          customerId: readString(callContext.customerId),
+          feature: readString(callContext.feature),
+          environment: readString(callContext.environment),
+          tags: readStringArray(callContext.tags),
+          provider,
+          model: readString(record.model) ?? readString(params.model),
+          input: params,
+          output: response,
+          usage: record.usage,
+          latencyMs: Date.now() - startedAt
+        }).catch(() => void 0);
+      }
+      return response;
+    } catch (error) {
+      const selected = await decision;
+      if (selected) {
+        await usageTap.captureSample({
+          customerId: readString(callContext.customerId),
+          feature: readString(callContext.feature),
+          environment: readString(callContext.environment),
+          tags: readStringArray(callContext.tags),
+          provider,
+          model: readString(params.model),
+          input: params,
+          latencyMs: Date.now() - startedAt,
+          error: serializeSamplingError(error)
+        }).catch(() => void 0);
+      }
+      throw error;
+    }
+  };
+  const chat = client.chat?.completions ? new Proxy(client.chat, {
+    get(target, prop, receiver) {
+      if (prop !== "completions") return safeReflectGet(target, prop, receiver);
+      const completions = target.completions;
+      return new Proxy(completions, {
+        get(completionTarget, completionProp, completionReceiver) {
+          if (completionProp === "create") {
+            return wrapCreate(
+              completionTarget.create.bind(completionTarget)
+            );
+          }
+          return safeReflectGet(
+            completionTarget,
+            completionProp,
+            completionReceiver
+          );
+        }
+      });
+    }
+  }) : void 0;
+  const responses = typeof client.responses !== "undefined" && client.responses ? new Proxy(client.responses, {
+    get(target, prop, receiver) {
+      if (prop === "create") {
+        const create = Reflect.get(target, prop, receiver);
+        return wrapCreate(create.bind(target));
+      }
+      return safeReflectGet(target, prop, receiver);
+    }
+  }) : void 0;
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "chat" && chat) return chat;
+      if (prop === "responses" && responses) return responses;
+      if (prop === "unwrap") return () => target;
+      return safeReflectGet(target, prop, receiver);
+    }
+  });
+}
+function safeReflectGet(target, prop, receiver) {
+  return Reflect.get(target, prop, receiver);
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((item) => typeof item === "string");
+  return strings.length ? strings : void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function serializeSamplingError(error) {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message };
+  }
+  return { message: String(error) };
+}
+function normalizeMeteredOpenAISampling(options) {
+  if (!options) return void 0;
+  if (options === true) return { provider: "openai" };
+  const { provider = "openai", ...policyFields } = options;
+  return {
+    provider,
+    policy: typeof policyFields.rate === "number" ? policyFields : void 0
+  };
+}
+function startMeteredOpenAISampleDecision({
+  usageTap,
+  sampling,
+  beginRequest,
+  input
+}) {
+  if (!sampling) return Promise.resolve(false);
+  return usageTap.shouldSampleAsync(
+    {
+      customerId: beginRequest.customerId,
+      feature: beginRequest.feature,
+      input
+    },
+    sampling.policy
+  );
+}
+async function captureMeteredOpenAISample({
+  usageTap,
+  sampling,
+  decision,
+  ctx,
+  beginRequest,
+  input,
+  response,
+  error,
+  startedAt
+}) {
+  if (!sampling) return;
+  let selected = false;
+  try {
+    selected = await decision;
+  } catch {
+    return;
+  }
+  if (!selected) return;
+  const record = isObjectRecord(response) ? response : {};
+  await usageTap.captureSample({
+    sampleId: ctx.begin.data.callId,
+    callId: ctx.begin.data.callId,
+    customerId: beginRequest.customerId,
+    feature: beginRequest.feature,
+    tags: beginRequest.tags,
+    provider: sampling.provider,
+    model: readString(record.model) ?? readString(input.model),
+    input,
+    ...response === void 0 ? {} : { output: response },
+    usage: record.usage,
+    latencyMs: Date.now() - startedAt,
+    ...error === void 0 ? {} : { error: serializeSamplingError(error) }
+  }).catch(() => void 0);
+}
+function withMetering(client, customer) {
+  const config = typeof customer === "string" ? { customerId: customer } : customer;
+  if (!config?.customerId) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "withMetering requires a customerId"
+    );
+  }
+  const {
+    apiKey,
+    usageTapClient,
+    applyVendorHints,
+    promptCompression,
+    sampling,
+    provider,
+    ...defaultContext
+  } = config;
+  const usageTap = usageTapClient ?? new UsageTapClient({ apiKey });
+  const normalizedCompression = promptCompression === true ? { provider: "usagetap" } : promptCompression ? { provider: "usagetap", ...promptCompression } : void 0;
+  return wrapOpenAI(client, usageTap, {
+    defaultContext,
+    applyVendorHints,
+    promptCompression: normalizedCompression,
+    sampling,
+    provider
+  });
+}
+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 defaultPromptCompression = normalizePromptCompressionOptions(options.promptCompression);
+  const defaultSampling = normalizeMeteredOpenAISampling(options.sampling);
+  const provider = options.provider ?? "openai";
+  const promptCompressionStats = new OpenAIPromptCompressionStats();
+  const proxiedChat = client.chat ? createChatProxy(
+    client.chat,
+    usageTap,
+    defaultContext,
+    applyVendorHints,
+    defaultPromptCompression,
+    promptCompressionStats,
+    defaultSampling,
+    provider
+  ) : void 0;
+  const proxiedResponses = typeof client.responses !== "undefined" ? createResponsesProxy(
+    client.responses,
+    usageTap,
+    defaultContext,
+    applyVendorHints,
+    defaultPromptCompression,
+    promptCompressionStats,
+    defaultSampling,
+    provider
+  ) : 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 === "promptCompression") {
+        return promptCompressionStats;
+      }
+      if (prop === "unwrap") {
+        return () => target;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+  return new Proxy(client, handler);
+}
+function createChatProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats, defaultSampling, provider) {
+  const completions = createChatCompletionsProxy(
+    resource.completions,
+    usageTap,
+    defaultContext,
+    applyVendorHints,
+    defaultPromptCompression,
+    promptCompressionStats,
+    defaultSampling,
+    provider
+  );
+  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, defaultPromptCompression, promptCompressionStats, defaultSampling, provider) {
+  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,
+      promptCompression
+    } = splitUsageOptions(options);
+    const beginRequest = withRuntimeCompressionContext(
+      resolveBeginRequest(defaultContext, usageContext),
+      "openai",
+      String(params.model)
+    );
+    const wantsStream = isStreamingRequest(params);
+    return usageTap.withUsage(beginRequest, async (ctx) => {
+      const sampleStartedAt = Date.now();
+      const sampleDecision = wantsStream ? Promise.resolve(false) : startMeteredOpenAISampleDecision({
+        usageTap,
+        sampling: defaultSampling,
+        beginRequest,
+        input: params
+      });
+      const hintedParams = applyVendorHints ? applyResponsesVendorHints(params, ctx.begin.data.vendorHints) : params;
+      const finalParams = await compressResponsesParamsForCall({
+        params: hintedParams,
+        usageTap,
+        ctx,
+        defaultPromptCompression,
+        callPromptCompression: promptCompression,
+        stats: promptCompressionStats,
+        withUsage,
+        operation: "responses.create"
+      });
+      ctx.setUsage(openAIRequestExecutionMetadata(finalParams, provider));
+      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, provider);
+            if (usage) {
+              ctx.setUsage(usage);
+            }
+          }, ctx);
+          return wrappedStream;
+        });
+        return wrappedPromise2;
+      }
+      const apiPromise = originalCreate(finalParams, request);
+      const wrappedPromise = transformApiPromise(apiPromise, async (response) => {
+        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx, provider);
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          response,
+          startedAt: sampleStartedAt
+        });
+        return response;
+      }, async (error) => {
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          error,
+          startedAt: sampleStartedAt
+        });
+        throw error;
+      });
+      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, defaultPromptCompression, promptCompressionStats, defaultSampling, provider) {
+  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,
+      promptCompression
+    } = splitUsageOptions(options);
+    const beginRequest = withRuntimeCompressionContext(
+      resolveBeginRequest(defaultContext, usageContext),
+      "openai",
+      String(params.model)
+    );
+    const wantsStream = isStreamingRequest(params);
+    return usageTap.withUsage(beginRequest, async (ctx) => {
+      const sampleStartedAt = Date.now();
+      const sampleDecision = wantsStream ? Promise.resolve(false) : startMeteredOpenAISampleDecision({
+        usageTap,
+        sampling: defaultSampling,
+        beginRequest,
+        input: params
+      });
+      const hintedParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
+      const finalParams = await compressChatParamsForCall({
+        params: hintedParams,
+        usageTap,
+        ctx,
+        defaultPromptCompression,
+        callPromptCompression: promptCompression,
+        stats: promptCompressionStats,
+        withUsage,
+        operation: "chat.completions.create"
+      });
+      ctx.setUsage(openAIRequestExecutionMetadata(finalParams, provider));
+      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, provider);
+            if (usage) {
+              ctx.setUsage(usage);
+            }
+          }, ctx);
+          return wrappedStream2;
+        });
+        return wrappedPromise2;
+      }
+      const apiPromise = originalCreate(finalParams, request);
+      const wrappedPromise = transformApiPromise(apiPromise, async (response) => {
+        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx, provider);
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          response,
+          startedAt: sampleStartedAt
+        });
+        return response;
+      }, async (error) => {
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          error,
+          startedAt: sampleStartedAt
+        });
+        throw error;
+      });
+      return wrappedPromise;
+    }, withUsage);
+  };
+  const wrappedStream = originalStream ? (params, options) => {
+    const {
+      requestOptions,
+      usageContext,
+      withUsage,
+      promptCompression
+    } = splitUsageOptions(options);
+    const beginRequest = withRuntimeCompressionContext(
+      resolveBeginRequest(defaultContext, usageContext),
+      "openai",
+      String(params.model)
+    );
+    return usageTap.withUsage(beginRequest, async (ctx) => {
+      const hintedParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
+      const finalParams = await compressChatParamsForCall({
+        params: hintedParams,
+        usageTap,
+        ctx,
+        defaultPromptCompression,
+        callPromptCompression: promptCompression,
+        stats: promptCompressionStats,
+        withUsage,
+        operation: "chat.completions.stream"
+      });
+      ctx.setUsage(openAIRequestExecutionMetadata(finalParams, provider));
+      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,
+            provider
+          );
+          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);
+}
+async function compressChatParamsForCall(args) {
+  let compression = resolveEffectivePromptCompressionOptions(
+    args.defaultPromptCompression,
+    args.callPromptCompression
+  );
+  const runtimePolicy = args.ctx.begin.data.runtimeCompressionPolicy;
+  const policyDriven = !compression && Boolean(runtimePolicy);
+  if (policyDriven && runtimePolicy) {
+    if (!runtimePolicy.selected) {
+      args.ctx.setUsage({
+        runtimeCompression: bypassedRuntimeMeasurement(runtimePolicy)
+      });
+      return args.params;
+    }
+    compression = openAIPolicyCompressionOptions(runtimePolicy);
+    if (runtimePolicy.mode === "SHADOW") {
+      const startedAt2 = Date.now();
+      void compressChatParams(
+        args.params,
+        args.usageTap,
+        compression,
+        args.withUsage?.signal
+      ).then((outcome2) => {
+        args.ctx.setUsage({
+          runtimeCompression: openAIRuntimeMeasurement({
+            policy: runtimePolicy,
+            telemetry: buildPromptCompressionTelemetry(outcome2.segments),
+            latencyMs: Date.now() - startedAt2,
+            shadow: true,
+            originalPayload: args.params,
+            resultPayload: outcome2.params
+          })
+        });
+      }).catch(() => {
+        args.ctx.setUsage({
+          runtimeCompression: failedRuntimeMeasurement(
+            runtimePolicy,
+            Date.now() - startedAt2
+          )
+        });
+      });
+      return args.params;
+    }
+  }
+  if (!compression) {
+    return args.params;
+  }
+  const startedAt = Date.now();
+  const outcome = await compressChatParams(
+    args.params,
+    args.usageTap,
+    compression,
+    args.withUsage?.signal
+  );
+  if (policyDriven && runtimePolicy) {
+    const runtimeMeasurement = openAIRuntimeMeasurement({
+      policy: runtimePolicy,
+      telemetry: buildPromptCompressionTelemetry(outcome.segments),
+      latencyMs: Date.now() - startedAt,
+      originalPayload: args.params,
+      resultPayload: outcome.params
+    });
+    args.ctx.setUsage({ runtimeCompression: runtimeMeasurement });
+    if (runtimeMeasurement.decision !== "compressed") return args.params;
+  }
+  await recordCompressionOutcome({
+    outcome,
+    compression,
+    usageTap: args.usageTap,
+    ctx: args.ctx,
+    stats: args.stats,
+    withUsage: args.withUsage,
+    operation: args.operation
+  });
+  return outcome.params;
+}
+async function compressResponsesParamsForCall(args) {
+  let compression = resolveEffectivePromptCompressionOptions(
+    args.defaultPromptCompression,
+    args.callPromptCompression
+  );
+  const runtimePolicy = args.ctx.begin.data.runtimeCompressionPolicy;
+  const policyDriven = !compression && Boolean(runtimePolicy);
+  if (policyDriven && runtimePolicy) {
+    if (!runtimePolicy.selected) {
+      args.ctx.setUsage({
+        runtimeCompression: bypassedRuntimeMeasurement(runtimePolicy)
+      });
+      return args.params;
+    }
+    compression = openAIPolicyCompressionOptions(runtimePolicy);
+    if (runtimePolicy.mode === "SHADOW") {
+      const startedAt2 = Date.now();
+      void compressResponsesParams(
+        args.params,
+        args.usageTap,
+        compression,
+        args.withUsage?.signal
+      ).then((outcome2) => {
+        args.ctx.setUsage({
+          runtimeCompression: openAIRuntimeMeasurement({
+            policy: runtimePolicy,
+            telemetry: buildPromptCompressionTelemetry(outcome2.segments),
+            latencyMs: Date.now() - startedAt2,
+            shadow: true,
+            originalPayload: args.params,
+            resultPayload: outcome2.params
+          })
+        });
+      }).catch(() => {
+        args.ctx.setUsage({
+          runtimeCompression: failedRuntimeMeasurement(
+            runtimePolicy,
+            Date.now() - startedAt2
+          )
+        });
+      });
+      return args.params;
+    }
+  }
+  if (!compression) {
+    return args.params;
+  }
+  const startedAt = Date.now();
+  const outcome = await compressResponsesParams(
+    args.params,
+    args.usageTap,
+    compression,
+    args.withUsage?.signal
+  );
+  if (policyDriven && runtimePolicy) {
+    const runtimeMeasurement = openAIRuntimeMeasurement({
+      policy: runtimePolicy,
+      telemetry: buildPromptCompressionTelemetry(outcome.segments),
+      latencyMs: Date.now() - startedAt,
+      originalPayload: args.params,
+      resultPayload: outcome.params
+    });
+    args.ctx.setUsage({ runtimeCompression: runtimeMeasurement });
+    if (runtimeMeasurement.decision !== "compressed") return args.params;
+  }
+  await recordCompressionOutcome({
+    outcome,
+    compression,
+    usageTap: args.usageTap,
+    ctx: args.ctx,
+    stats: args.stats,
+    withUsage: args.withUsage,
+    operation: args.operation
+  });
+  return outcome.params;
+}
+function openAIPolicyCompressionOptions(policy) {
+  const roles = Object.fromEntries(
+    ["system", "user", "tool", "assistant"].filter((role) => policy.snapshot.scope.messageRoles.includes(role)).map((role) => [role, true])
+  );
+  return {
+    provider: "usagetap",
+    roles,
+    minContextTokens: policy.snapshot.scope.minimumTokens,
+    failOpen: true
+  };
+}
+function bypassedRuntimeMeasurement(policy) {
+  return {
+    policyId: policy.policyId,
+    policyVersionId: policy.policyVersionId,
+    policyVersion: policy.version,
+    rolloutMode: policy.mode,
+    decision: "bypassed",
+    reasonCode: "not_in_rollout_sample",
+    methodsAttempted: [],
+    methodsApplied: [],
+    originalTokens: 0,
+    resultTokens: 0,
+    savedTokens: 0,
+    reductionPercentage: 0,
+    compressionLatencyMs: 0,
+    compressionComputeCostUsd: 0,
+    financialsEstimated: true
+  };
+}
+function failedRuntimeMeasurement(policy, latencyMs) {
+  return {
+    ...bypassedRuntimeMeasurement(policy),
+    decision: "fallback",
+    reasonCode: "transformation_failed",
+    methodsAttempted: ["deterministic"],
+    compressionLatencyMs: latencyMs
+  };
+}
+function openAIRuntimeMeasurement(input) {
+  const telemetry = input.telemetry;
+  const originalTokens = telemetry?.originalTokens ?? estimatePromptTokens(JSON.stringify(input.originalPayload));
+  const resultTokens = telemetry?.compressedTokens ?? originalTokens;
+  const savedTokens = Math.max(0, telemetry?.savedTokens ?? 0);
+  const reductionPercentage = originalTokens > 0 ? savedTokens / originalTokens * 100 : 0;
+  const belowMinimumSize = originalTokens < input.policy.snapshot.scope.minimumTokens;
+  const latencyExceeded = input.latencyMs > input.policy.snapshot.gates.maximumLatencyMs;
+  const belowSavings = savedTokens < input.policy.snapshot.gates.minimumTokensRemoved || reductionPercentage < input.policy.snapshot.gates.minimumReductionPercentage;
+  const accepted = !belowMinimumSize && !latencyExceeded && !belowSavings;
+  const deepText = input.policy.snapshot.methods.deepText.enabled && !input.policy.snapshot.rollout.deterministicOnly && (input.policy.mode !== "CANARY" || input.policy.snapshot.rollout.deepTextCanaryAllowed);
+  const reasonCode = belowMinimumSize ? "below_minimum_size" : latencyExceeded ? "latency_budget_exceeded" : belowSavings ? "below_minimum_savings" : void 0;
+  const measurement = {
+    policyId: input.policy.policyId,
+    policyVersionId: input.policy.policyVersionId,
+    policyVersion: input.policy.version,
+    rolloutMode: input.policy.mode,
+    decision: accepted ? input.shadow ? "bypassed" : "compressed" : latencyExceeded ? "fallback" : "skipped",
+    ...reasonCode ? { reasonCode } : {},
+    methodsAttempted: [
+      "deterministic",
+      ...deepText ? ["deep_text"] : []
+    ],
+    methodsApplied: accepted ? ["deterministic"] : [],
+    originalTokens,
+    resultTokens: accepted ? resultTokens : originalTokens,
+    savedTokens: accepted ? savedTokens : 0,
+    reductionPercentage: accepted ? reductionPercentage : 0,
+    compressionLatencyMs: input.latencyMs,
+    compressionComputeCostUsd: 0,
+    financialsEstimated: true
+  };
+  return measurement;
+}
+async function recordCompressionOutcome(args) {
+  const telemetry = buildPromptCompressionTelemetry(args.outcome.segments);
+  if (!telemetry) {
+    return;
+  }
+  const turn = {
+    ...telemetry,
+    callId: args.ctx.begin.data.callId,
+    operation: args.operation,
+    messagesCompressed: args.outcome.segments.length,
+    timestamp: Date.now()
+  };
+  args.stats._record(turn);
+  try {
+    await args.usageTap.recordPromptCompression(
+      {
+        callId: args.ctx.begin.data.callId,
+        promptCompression: telemetry
+      },
+      promptCompressionRequestOptions(args.withUsage, args.ctx.begin.correlationId)
+    );
+  } catch (error) {
+    args.stats._recordFailure({
+      callId: args.ctx.begin.data.callId,
+      operation: args.operation,
+      stage: "telemetry",
+      message: error instanceof Error ? error.message : String(error),
+      timestamp: Date.now()
+    });
+    if (args.compression.failOpen === false) {
+      throw error;
+    }
+  }
+}
+async function compressChatParams(params, usageTap, compression, signal) {
+  if (!params || typeof params !== "object") {
+    return { params, segments: [] };
+  }
+  const source = cloneRecord(params);
+  const messages = Array.isArray(source.messages) ? source.messages : void 0;
+  if (!messages) {
+    return { params, segments: [] };
+  }
+  if (isBelowMinContextTokens(
+    { messages, tools: source.tools },
+    compression.minContextTokens
+  )) {
+    return { params, segments: [] };
+  }
+  if (shouldUseUsageTapMessageEndpoint(compression)) {
+    const result = await usageTap.compressPromptMessages(source, {
+      provider: "usagetap",
+      failOpen: compression.failOpen,
+      mode: compression.mode,
+      latencyBudgetMs: compression.latencyBudgetMs,
+      compactEmptyUserMessages: compression.compactEmptyUserMessages,
+      compactDuplicateUserTextParts: compression.compactDuplicateUserTextParts,
+      aggressiveness: resolveMessageEndpointAggressiveness(compression),
+      signal
+    });
+    return {
+      params: result.compressedInput,
+      segments: [{ role: "user", result }]
+    };
+  }
+  const messageResults = await Promise.all(
+    messages.map(
+      (message) => compressOpenAIMessage(message, usageTap, compression, signal)
+    )
+  );
+  return {
+    params: {
+      ...source,
+      messages: messageResults.map((result) => result.value)
+    },
+    segments: messageResults.flatMap((result) => result.segments)
+  };
+}
+async function compressResponsesParams(params, usageTap, compression, signal) {
+  if (!params || typeof params !== "object") {
+    return { params, segments: [] };
+  }
+  const source = cloneRecord(params);
+  const segments = [];
+  if (isBelowMinContextTokens(
+    {
+      instructions: source.instructions,
+      input: source.input,
+      tools: source.tools
+    },
+    compression.minContextTokens
+  )) {
+    return { params, segments };
+  }
+  if (typeof source.instructions === "string") {
+    const compressed = await compressTextForRole(
+      source.instructions,
+      "system",
+      usageTap,
+      compression,
+      signal
+    );
+    if (compressed) {
+      source.instructions = compressed.text;
+      segments.push(compressed.segment);
+    }
+  }
+  if (typeof source.input === "string") {
+    const compressed = await compressTextForRole(
+      source.input,
+      "user",
+      usageTap,
+      compression,
+      signal
+    );
+    if (compressed) {
+      source.input = compressed.text;
+      segments.push(compressed.segment);
+    }
+  } else if (Array.isArray(source.input)) {
+    const inputResults = await Promise.all(
+      source.input.map(
+        (item) => compressResponsesInputItem(item, usageTap, compression, signal)
+      )
+    );
+    source.input = inputResults.map((result) => result.value);
+    segments.push(...inputResults.flatMap((result) => result.segments));
+  }
+  return {
+    params: source,
+    segments
+  };
+}
+async function compressOpenAIMessage(message, usageTap, compression, signal) {
+  if (!isObjectRecord(message)) {
+    return { value: message, segments: [] };
+  }
+  const role = mapOpenAIRole(message.role);
+  if (!role) {
+    return { value: message, segments: [] };
+  }
+  const content = message.content;
+  if (typeof content === "string") {
+    const compressed = await compressTextForRole(
+      content,
+      role,
+      usageTap,
+      compression,
+      signal
+    );
+    if (!compressed) {
+      return { value: message, segments: [] };
+    }
+    return {
+      value: { ...message, content: compressed.text },
+      segments: [compressed.segment]
+    };
+  }
+  if (Array.isArray(content)) {
+    const blockResults = await Promise.all(
+      content.map(
+        (block) => compressOpenAITextBlock(block, role, usageTap, compression, signal)
+      )
+    );
+    const segments = blockResults.flatMap(
+      (result) => result.segment ? [result.segment] : []
+    );
+    return {
+      value: segments.length ? { ...message, content: blockResults.map((result) => result.value) } : message,
+      segments
+    };
+  }
+  return { value: message, segments: [] };
+}
+async function compressOpenAITextBlock(block, role, usageTap, compression, signal) {
+  if (!isObjectRecord(block) || block.type !== "text" || typeof block.text !== "string") {
+    return { value: block };
+  }
+  const compressed = await compressTextForRole(
+    block.text,
+    role,
+    usageTap,
+    compression,
+    signal
+  );
+  if (!compressed) {
+    return { value: block };
+  }
+  return {
+    value: { ...block, text: compressed.text },
+    segment: compressed.segment
+  };
+}
+async function compressResponsesInputItem(item, usageTap, compression, signal) {
+  if (!isObjectRecord(item)) {
+    return { value: item, segments: [] };
+  }
+  const specialToolRole = mapResponsesItemTypeToRole(item.type);
+  const role = specialToolRole ?? mapOpenAIRole(item.role);
+  const segments = [];
+  let next = item;
+  if (role && typeof item.content === "string") {
+    const compressed = await compressTextForRole(
+      item.content,
+      role,
+      usageTap,
+      compression,
+      signal
+    );
+    if (compressed) {
+      next = { ...next, content: compressed.text };
+      segments.push(compressed.segment);
+    }
+  } else if (role && Array.isArray(item.content)) {
+    const contentResults = await Promise.all(
+      item.content.map(
+        (block) => compressResponsesContentBlock(block, role, usageTap, compression, signal)
+      )
+    );
+    segments.push(
+      ...contentResults.flatMap(
+        (result) => result.segment ? [result.segment] : []
+      )
+    );
+    if (segments.length) {
+      next = {
+        ...next,
+        content: contentResults.map((result) => result.value)
+      };
+    }
+  }
+  if (specialToolRole && typeof item.output === "string") {
+    const compressed = await compressTextForRole(
+      item.output,
+      specialToolRole,
+      usageTap,
+      compression,
+      signal
+    );
+    if (compressed) {
+      next = { ...next, output: compressed.text };
+      segments.push(compressed.segment);
+    }
+  }
+  return { value: next, segments };
+}
+async function compressResponsesContentBlock(block, role, usageTap, compression, signal) {
+  if (!isObjectRecord(block)) {
+    return { value: block };
+  }
+  if ((block.type === "input_text" || block.type === "text") && typeof block.text === "string") {
+    const compressed = await compressTextForRole(
+      block.text,
+      role,
+      usageTap,
+      compression,
+      signal
+    );
+    if (compressed) {
+      return {
+        value: { ...block, text: compressed.text },
+        segment: compressed.segment
+      };
+    }
+  }
+  if (role === "tool" && typeof block.output === "string") {
+    const compressed = await compressTextForRole(
+      block.output,
+      role,
+      usageTap,
+      compression,
+      signal
+    );
+    if (compressed) {
+      return {
+        value: { ...block, output: compressed.text },
+        segment: compressed.segment
+      };
+    }
+  }
+  return { value: block };
+}
+async function compressTextForRole(text, role, usageTap, compression, signal) {
+  if (!text.trim()) {
+    return void 0;
+  }
+  const roleOptions = resolveRoleCompressionOptions(compression, role);
+  if (!roleOptions) {
+    return void 0;
+  }
+  const estimatedTokens = estimatePromptTokens(text);
+  if (typeof roleOptions.minTokens === "number" && estimatedTokens < roleOptions.minTokens) {
+    return void 0;
+  }
+  const result = await usageTap.compressPromptInput(text, {
+    provider: roleOptions.provider,
+    failOpen: roleOptions.failOpen,
+    tokenCompanyModel: roleOptions.tokenCompanyModel,
+    aggressiveness: roleOptions.aggressiveness,
+    tokenCompanyAggressiveness: roleOptions.tokenCompanyAggressiveness,
+    tokenCompanyAppId: roleOptions.tokenCompanyAppId,
+    usageTapCompressionModel: roleOptions.usageTapCompressionModel,
+    usageTapCompressionAggressiveness: roleOptions.usageTapCompressionAggressiveness,
+    signal
+  });
+  const compressedText = typeof result.compressedInput === "string" ? result.compressedInput : String(result.compressedInput);
+  return {
+    text: compressedText,
+    segment: { role, result: { ...result, compressedInput: compressedText } }
+  };
+}
+function normalizePromptCompressionOptions(options) {
+  if (!options) {
+    return void 0;
+  }
+  if (options === true) {
+    return {};
+  }
+  if (options.enabled === false) {
+    return void 0;
+  }
+  return options;
+}
+function isBelowMinContextTokens(context, minContextTokens) {
+  return typeof minContextTokens === "number" && estimatePromptTokens(context) < Math.max(0, minContextTokens);
+}
+function resolveEffectivePromptCompressionOptions(defaults, override) {
+  if (override === false) {
+    return void 0;
+  }
+  if (override === void 0) {
+    return defaults;
+  }
+  if (override === true) {
+    return defaults ?? {};
+  }
+  const merged = {
+    ...defaults ?? {},
+    ...override,
+    roles: override.roles ?? defaults?.roles
+  };
+  return normalizePromptCompressionOptions(merged);
+}
+function resolveRoleCompressionOptions(compression, role) {
+  const hasExplicitRoles = compression.roles !== void 0;
+  const setting = compression.roles?.[role];
+  if (hasExplicitRoles && setting === void 0) {
+    return void 0;
+  }
+  if (!hasExplicitRoles && role === "assistant") {
+    return void 0;
+  }
+  if (setting === false) {
+    return void 0;
+  }
+  const roleOptions = typeof setting === "object" ? setting : void 0;
+  if (roleOptions?.enabled === false) {
+    return void 0;
+  }
+  return {
+    provider: roleOptions?.provider ?? compression.provider,
+    minTokens: roleOptions?.minTokens ?? compression.minTokens,
+    failOpen: compression.failOpen,
+    tokenCompanyModel: compression.tokenCompanyModel,
+    aggressiveness: roleOptions?.aggressiveness ?? resolveAggressiveness(compression, role),
+    tokenCompanyAggressiveness: roleOptions?.tokenCompanyAggressiveness ?? resolveTokenCompanyAggressiveness(compression, role),
+    tokenCompanyAppId: compression.tokenCompanyAppId,
+    usageTapCompressionModel: compression.usageTapCompressionModel,
+    usageTapCompressionAggressiveness: roleOptions?.usageTapCompressionAggressiveness ?? resolveUsageTapCompressionAggressiveness(compression, role)
+  };
+}
+function resolveAggressiveness(compression, role) {
+  if (typeof compression.aggressiveness === "number") {
+    return compression.aggressiveness;
+  }
+  return compression.aggressiveness?.[role];
+}
+function resolveTokenCompanyAggressiveness(compression, role) {
+  if (typeof compression.tokenCompanyAggressiveness === "number") {
+    return compression.tokenCompanyAggressiveness;
+  }
+  return compression.tokenCompanyAggressiveness?.[role];
+}
+function resolveUsageTapCompressionAggressiveness(compression, role) {
+  if (typeof compression.usageTapCompressionAggressiveness === "number") {
+    return compression.usageTapCompressionAggressiveness;
+  }
+  return compression.usageTapCompressionAggressiveness?.[role];
+}
+function shouldUseUsageTapMessageEndpoint(compression) {
+  if (compression.provider !== "usagetap") {
+    return false;
+  }
+  return Object.values(compression.roles ?? {}).every((setting) => {
+    if (typeof setting !== "object" || setting === null) {
+      return true;
+    }
+    return setting.provider === void 0 || setting.provider === "usagetap";
+  });
+}
+function resolveMessageEndpointAggressiveness(compression) {
+  const base = compression.aggressiveness ?? compression.usageTapCompressionAggressiveness ?? compression.tokenCompanyAggressiveness;
+  if (typeof base === "number" || base === void 0) {
+    return hasExplicitEnabledRoles(compression) ? buildRoleAggressiveness(compression, base) : base;
+  }
+  return buildRoleAggressiveness(compression, void 0, base);
+}
+function hasExplicitEnabledRoles(compression) {
+  return Object.values(compression.roles ?? {}).some((setting) => setting !== false);
+}
+function buildRoleAggressiveness(compression, fallback, base = {}) {
+  const roles = ["system", "user", "tool", "assistant"];
+  const result = {};
+  for (const role of roles) {
+    const roleOptions = resolveRoleCompressionOptions(compression, role);
+    if (!roleOptions) {
+      continue;
+    }
+    const roleAggressiveness = roleOptions.aggressiveness ?? roleOptions.usageTapCompressionAggressiveness ?? roleOptions.tokenCompanyAggressiveness ?? base[role] ?? fallback;
+    if (roleAggressiveness !== void 0) {
+      result[role] = roleAggressiveness;
+    }
+  }
+  return result;
+}
+function buildPromptCompressionTelemetry(segments) {
+  if (!segments.length) {
+    return void 0;
+  }
+  const originalCharacters = segments.reduce(
+    (sum, segment) => sum + segment.result.originalCharacters,
+    0
+  );
+  const compressedCharacters = segments.reduce(
+    (sum, segment) => sum + segment.result.compressedCharacters,
+    0
+  );
+  const originalTokens = segments.reduce(
+    (sum, segment) => sum + segment.result.originalTokens,
+    0
+  );
+  const compressedTokens = segments.reduce(
+    (sum, segment) => sum + segment.result.compressedTokens,
+    0
+  );
+  const savedCharacters = Math.max(0, originalCharacters - compressedCharacters);
+  const savedTokens = Math.max(0, originalTokens - compressedTokens);
+  const providers = dedupeStrings2(segments.map((segment) => segment.result.provider));
+  const roles = dedupeStrings2(segments.map((segment) => `role:${segment.role}`));
+  const techniques = dedupeStrings2([
+    "openai-wrapper",
+    ...roles,
+    ...segments.flatMap((segment) => segment.result.techniques),
+    ...providers.length > 1 ? ["mixed-providers"] : []
+  ]);
+  return {
+    provider: segments[0]?.result.provider ?? "heuristic",
+    originalCharacters,
+    compressedCharacters,
+    savedCharacters,
+    originalTokens,
+    compressedTokens,
+    savedTokens,
+    tokenSavingsRatio: originalTokens > 0 ? savedTokens / originalTokens : 0,
+    savingsRatio: originalCharacters > 0 ? savedCharacters / originalCharacters : 0,
+    techniques
+  };
+}
+function promptCompressionRequestOptions(withUsage, correlationId) {
+  return {
+    signal: withUsage?.signal,
+    headers: withUsage?.headers,
+    retries: withUsage?.retries,
+    correlationId
+  };
+}
+function mapOpenAIRole(role) {
+  if (role === "system" || role === "developer") {
+    return "system";
+  }
+  if (role === "user") {
+    return "user";
+  }
+  if (role === "tool" || role === "function") {
+    return "tool";
+  }
+  if (role === "assistant") {
+    return "assistant";
+  }
+  return void 0;
+}
+function mapResponsesItemTypeToRole(type) {
+  if (type === "function_call_output" || type === "tool_result" || type === "computer_call_output") {
+    return "tool";
+  }
+  return void 0;
+}
+function splitUsageOptions(options) {
+  if (!options || typeof options !== "object") {
+    return {};
+  }
+  const { usageTap, withUsage, promptCompression, ...rest } = options;
+  const requestOptions = Object.keys(rest).length ? cloneRequestOptions(rest) : void 0;
+  return {
+    requestOptions,
+    usageContext: usageTap,
+    withUsage,
+    promptCompression
+  };
+}
+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 runtimeCompressionContext = current.runtimeCompressionContext ?? base.runtimeCompressionContext;
+  if (runtimeCompressionContext) {
+    begin.runtimeCompressionContext = runtimeCompressionContext;
+  }
+  const requested = current.requested ?? base.requested;
+  if (requested) begin.requested = requested;
+  const feature = current.feature ?? base.feature;
+  if (feature) begin.feature = feature;
+  const runId = current.runId ?? base.runId;
+  if (runId) begin.runId = runId;
+  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;
+  const customerUserId = current.customerUserId ?? base.customerUserId;
+  if (customerUserId) begin.customerUserId = customerUserId;
+  const customerUserName = current.customerUserName ?? base.customerUserName;
+  if (customerUserName) begin.customerUserName = customerUserName;
+  const customerUserEmail = current.customerUserEmail ?? base.customerUserEmail;
+  if (customerUserEmail) begin.customerUserEmail = customerUserEmail;
+  const stripeCustomerId = current.stripeCustomerId ?? base.stripeCustomerId;
+  if (stripeCustomerId) begin.stripeCustomerId = stripeCustomerId;
+  const holdUsd = current.holdUsd ?? base.holdUsd;
+  if (typeof holdUsd === "number") begin.holdUsd = holdUsd;
+  const batch = current.batch ?? base.batch;
+  if (typeof batch === "boolean") begin.batch = batch;
+  const pricingMode = current.pricingMode ?? base.pricingMode;
+  if (pricingMode) begin.pricingMode = pricingMode;
+  if (tags?.length) {
+    begin.tags = tags;
+  }
+  return begin;
+}
+function withRuntimeCompressionContext(begin, provider, model) {
+  return {
+    ...begin,
+    runtimeCompressionContext: {
+      ...begin.runtimeCompressionContext ?? {},
+      provider,
+      model
     }
   };
 }
+function transformApiPromise(apiPromise, onResolve, onReject) {
+  const resolvedPromise = Promise.resolve(apiPromise).then(onResolve, onReject);
+  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 tryInferUsage(response, hints, extractor, ctx) {
+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, provider = "openai") {
+  const finalPayload = await resolveStreamFinalPayload(stream);
+  if (!finalPayload) {
+    return void 0;
+  }
+  return inferUsageFromResponse(finalPayload, hints, provider);
+}
+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, provider = "openai") {
   const explicit = extractor?.(response);
-  const inferred = explicit ?? inferUsageFromResponse(response, hints);
+  const inferred = explicit ?? inferUsageFromResponse(response, hints, provider);
   if (inferred) {
     ctx.setUsage(inferred);
   }
 }
-function inferUsageFromResponse(response, hints) {
+function inferUsageFromResponse(response, hints, provider = "openai") {
   if (!response || typeof response !== "object") {
     return void 0;
   }
@@ -76,12 +3906,41 @@ function inferUsageFromResponse(response, hints) {
   if (!candidate.usage) {
     return void 0;
   }
-  const cachedInputTokens = candidate.usage.prompt_tokens_details?.cached_tokens ?? candidate.usage.cached_tokens;
+  const cachedInputTokens = candidate.usage.prompt_tokens_details?.cached_tokens ?? candidate.usage.input_tokens_details?.cached_tokens ?? candidate.usage.cached_tokens;
+  const responseEffort = normalizeExecutionReasoningEffort(
+    candidate.reasoning?.effort
+  );
   return {
+    providerUsed: provider,
     modelUsed: candidate.model ?? hints?.preferredModel,
-    inputTokens: candidate.usage.prompt_tokens,
-    responseTokens: candidate.usage.completion_tokens,
-    cachedInputTokens
+    inputTokens: candidate.usage.prompt_tokens ?? candidate.usage.input_tokens,
+    responseTokens: candidate.usage.completion_tokens ?? candidate.usage.output_tokens,
+    cachedInputTokens,
+    reasoningTokens: candidate.usage.completion_tokens_details?.reasoning_tokens ?? candidate.usage.output_tokens_details?.reasoning_tokens,
+    ...responseEffort ? {
+      reasoningEffort: responseEffort,
+      reasoningEffortSource: "provider_response"
+    } : {},
+    ...typeof candidate.reasoning?.type === "string" ? { reasoningMode: candidate.reasoning.type } : typeof candidate.reasoning?.mode === "string" ? { reasoningMode: candidate.reasoning.mode } : {}
+  };
+}
+function normalizeExecutionReasoningEffort(value) {
+  return value === "none" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max" ? value : void 0;
+}
+function openAIRequestExecutionMetadata(params, provider) {
+  const record = params && typeof params === "object" ? params : {};
+  const reasoning = record.reasoning && typeof record.reasoning === "object" ? record.reasoning : void 0;
+  const effort = normalizeExecutionReasoningEffort(
+    record.reasoning_effort ?? reasoning?.effort ?? record.thinking_level
+  );
+  const mode = typeof reasoning?.type === "string" ? reasoning.type : typeof reasoning?.mode === "string" ? reasoning.mode : void 0;
+  const rawBudget = reasoning?.budget_tokens ?? record.thinking_budget ?? record.thinking_budget_tokens;
+  const budget = typeof rawBudget === "number" && Number.isInteger(rawBudget) && rawBudget >= 0 ? rawBudget : void 0;
+  return {
+    providerUsed: provider,
+    ...effort ? { reasoningEffort: effort, reasoningEffortSource: "provider_request" } : {},
+    ...mode ? { reasoningMode: mode } : {},
+    ...budget !== void 0 ? { reasoningBudgetTokens: budget } : {}
   };
 }
 function wrapStreamForUsageTap(source, finalize, ctx) {
@@ -183,9 +4042,24 @@ function isIteratorResult(value) {
 
 // src/adapters/openrouter.ts
 function createOpenRouterAdapter(init) {
-  return createOpenAIAdapter(init);
+  return createOpenAIAdapter({ ...init, provider: "openrouter" });
+}
+function withMetering2(client, customer) {
+  return withMetering(
+    client,
+    typeof customer === "string" ? { customerId: customer, provider: "openrouter" } : { ...customer, provider: "openrouter" }
+  );
+}
+function wrapOpenAI2(client, usageTap, options = {}) {
+  return wrapOpenAI(client, usageTap, {
+    ...options,
+    provider: "openrouter"
+  });
+}
+function withSampling2(client, options = {}) {
+  return withSampling(client, { ...options, provider: "openrouter" });
 }
 
-export { createOpenRouterAdapter };
+export { createOpenRouterAdapter, withMetering2 as withMetering, withSampling2 as withSampling, wrapOpenAI2 as wrapOpenAI };
 //# sourceMappingURL=openrouter.mjs.map
 //# sourceMappingURL=openrouter.mjs.map