@usagetap/sdk 1.2.0 → 1.3.2

package/dist/openai/index.mjs

@@ -26,16 +26,1546 @@ var UsageTapError = class extends Error {
     };
   }
 };
+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_PROMPT_COMPRESSION_MIN_CONTEXT_TOKENS = 1e3;
+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"
+  );
+  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 }
+      }),
+      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/client.ts
+var CALL_BEGIN_PATH = "call_begin";
+var CALL_END_PATH = "call_end";
+var COMPRESS_PROMPT_PATH = "compress_prompt";
+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_TYPE = "application/vnd.usagetap.v1+json";
+var DEFAULT_BASE_URL = "https://api.usagetap.com";
+var SDK_VERSION = "1.3.2" ;
+var HAS_WINDOW = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+var UsageTapClient = class {
+  apiKey;
+  baseUrl;
+  fetchImpl;
+  defaultFeature;
+  defaultTags;
+  defaultHeaders;
+  retryDefaults;
+  idempotencyGenerator;
+  logFn;
+  metricFn;
+  authHeader;
+  autoIdempotency;
+  tokenCompanyApiKey;
+  tokenCompanyEndpoint;
+  model;
+  tokenCompanyModel;
+  aggressiveness;
+  tokenCompanyAggressiveness;
+  tokenCompanyAppId;
+  usageTapCompressionApiKey;
+  usageTapCompressionEndpoint;
+  usageTapCompressionMessagesEndpoint;
+  usageTapCompressionModel;
+  usageTapCompressionAggressiveness;
+  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 normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+    this.baseUrl = new URL(normalizedBaseUrl);
+    this.apiKey = apiKey;
+    this.fetchImpl = wrapFetchImplementation(fetchCandidate, !options.fetchImpl);
+    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;
+  }
+  async beginCall(request, options = {}) {
+    const idempotencyKey = request.idempotencyKey ?? request.idempotency ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    const payload = {
+      ...request,
+      feature: request.feature ?? this.defaultFeature,
+      tags: this.mergeTags(request.tags)
+    };
+    if (idempotencyKey) {
+      payload.idempotencyKey = idempotencyKey;
+      payload.idempotency = idempotencyKey;
+    }
+    const response = await this.request(
+      CALL_BEGIN_PATH,
+      payload,
+      {
+        ...options,
+        idempotencyKey
+      }
+    );
+    return response;
+  }
+  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,
+      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,
+      modelUsed: request.modelUsed,
+      metrics: {
+        inputTokens: request.inputTokens,
+        responseTokens: request.responseTokens,
+        cachedInputTokens: request.cachedInputTokens,
+        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.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 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,
+      originalCharacters: result.originalCharacters,
+      compressedCharacters: result.compressedCharacters,
+      savedCharacters: result.savedCharacters,
+      originalTokens: result.originalTokens,
+      compressedTokens: result.compressedTokens,
+      savedTokens: result.savedTokens,
+      tokenSavingsRatio: result.tokenSavingsRatio,
+      savingsRatio: result.savingsRatio,
+      techniques: result.techniques
+    };
+  }
+  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_TYPE
+    };
+    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 {
@@ -233,6 +1763,68 @@ async function pipeToResponse(stream, res, options = {}) {
   }
 }
 var USAGETAP_CORRELATION_HEADER = "x-usage-correlation-id";
+function withCompression(client, options = {}) {
+  if (!client) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "withCompression requires an OpenAI-compatible client instance"
+    );
+  }
+  const {
+    apiKey,
+    usageTapClient,
+    ...compressionOverrides
+  } = options;
+  const usageTap = usageTapClient ?? new UsageTapClient({ apiKey });
+  const compression = {
+    provider: "usagetap",
+    minContextTokens: DEFAULT_PROMPT_COMPRESSION_MIN_CONTEXT_TOKENS,
+    ...compressionOverrides
+  };
+  const proxiedChat = client.chat ? createCompressionOnlyChatProxy(client.chat, usageTap, compression) : void 0;
+  const proxiedResponses = typeof client.responses !== "undefined" ? createCompressionOnlyResponsesProxy(
+    client.responses,
+    usageTap,
+    compression
+  ) : void 0;
+  return new Proxy(client, {
+    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 === "unwrap") {
+        return () => target;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+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,
+    ...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
+  });
+}
 function wrapOpenAI(client, usageTap, options = {}) {
   if (!client) {
     throw new UsageTapError("USAGETAP_BAD_REQUEST", "wrapOpenAI requires an OpenAI client instance");
@@ -282,6 +1874,47 @@ function wrapOpenAI(client, usageTap, options = {}) {
   };
   return new Proxy(client, handler);
 }
+function createCompressionOnlyChatProxy(resource, usageTap, compression) {
+  const completions = resource.completions;
+  const originalCreate = completions.create.bind(completions);
+  const streamCandidate = completions.stream;
+  const originalStream = typeof streamCandidate === "function" ? streamCandidate.bind(completions) : void 0;
+  const wrappedCreate = (params, options) => {
+    return compressChatParams(params, usageTap, compression).then((outcome) => originalCreate(outcome.params, options));
+  };
+  const wrappedStream = originalStream ? (params, options) => compressChatParams(params, usageTap, compression).then((outcome) => originalStream(outcome.params, options)) : void 0;
+  const proxiedCompletions = new Proxy(completions, {
+    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, {
+    get(target, prop, receiver) {
+      if (prop === "completions") return proxiedCompletions;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function createCompressionOnlyResponsesProxy(resource, usageTap, compression) {
+  if (!resource || typeof resource !== "object") {
+    return resource;
+  }
+  if (!("create" in resource) || typeof resource.create !== "function") {
+    return resource;
+  }
+  const originalCreate = resource.create.bind(resource);
+  const wrappedCreate = (params, options) => {
+    return compressResponsesParams(params, usageTap, compression).then((outcome) => originalCreate(outcome.params, options));
+  };
+  return new Proxy(resource, {
+    get(target, prop, receiver) {
+      if (prop === "create") return wrappedCreate;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
 function streamOpenAIRoute(usageTap, openai, options) {
   if (!options?.getRequest) {
     throw new UsageTapError("USAGETAP_BAD_REQUEST", "streamOpenAIRoute requires a getRequest function");
@@ -603,6 +2236,12 @@ async function compressChatParams(params, usageTap, compression, signal) {
   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",
@@ -634,6 +2273,16 @@ async function compressResponsesParams(params, usageTap, compression, signal) {
   }
   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,
@@ -863,6 +2512,9 @@ function normalizePromptCompressionOptions(options) {
   }
   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;
@@ -984,9 +2636,9 @@ function buildPromptCompressionTelemetry(segments) {
   );
   const savedCharacters = Math.max(0, originalCharacters - compressedCharacters);
   const savedTokens = Math.max(0, originalTokens - compressedTokens);
-  const providers = dedupeStrings(segments.map((segment) => segment.result.provider));
-  const roles = dedupeStrings(segments.map((segment) => `role:${segment.role}`));
-  const techniques = dedupeStrings([
+  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),
@@ -1166,9 +2818,9 @@ function mergeTags(a, b) {
   if (!values.length) {
     return void 0;
   }
-  return dedupeStrings(values);
+  return dedupeStrings2(values);
 }
-function dedupeStrings(values) {
+function dedupeStrings2(values) {
   return Array.from(new Set(values));
 }
 function isStreamingRequest(params) {
@@ -1413,6 +3065,6 @@ function createOpenRouterAdapter(init) {
   return createOpenAIAdapter(init);
 }
 
-export { OpenAIPromptCompressionStats, createOpenAIAdapter, createOpenRouterAdapter, pipeToResponse, streamOpenAIRoute, toNextResponse, wrapOpenAI };
+export { OpenAIPromptCompressionStats, createOpenAIAdapter, createOpenRouterAdapter, pipeToResponse, streamOpenAIRoute, toNextResponse, withCompression, withMetering, wrapOpenAI };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map