@usagetap/sdk 1.0.0 → 1.1.0

package/dist/adapters/anthropic.cjs

@@ -0,0 +1,943 @@
+'use strict';
+
+// src/errors.ts
+var UsageTapError = class extends Error {
+  code;
+  status;
+  retryable;
+  correlationId;
+  details;
+  constructor(code, message, init = {}) {
+    super(message, init.cause ? { cause: init.cause } : void 0);
+    this.name = "UsageTapError";
+    this.code = code;
+    this.status = init.status;
+    this.retryable = init.retryable ?? false;
+    this.correlationId = init.correlationId;
+    this.details = init.details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      retryable: this.retryable,
+      correlationId: this.correlationId,
+      details: this.details
+    };
+  }
+};
+
+// src/prompt-compression.ts
+function estimatePromptTokens(input) {
+  const text = typeof input === "string" ? input : stableStringifyInput(input);
+  return text.match(/[\p{L}\p{N}]+|[^\s]/gu)?.length ?? 0;
+}
+function stableStringifyInput(input) {
+  if (typeof input === "string") return input;
+  return JSON.stringify(input) ?? String(input);
+}
+
+// src/adapters/anthropic.ts
+var AnthropicPromptCompressionStats = 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;
+  }
+};
+var USAGETAP_CORRELATION_HEADER = "x-usage-correlation-id";
+function wrapAnthropic(client, usageTap, options = {}) {
+  if (!client) {
+    throw new UsageTapError("USAGETAP_BAD_REQUEST", "wrapAnthropic requires an Anthropic client instance");
+  }
+  if (!client.messages || !isObjectRecord(client.messages)) {
+    throw new UsageTapError("USAGETAP_BAD_REQUEST", "wrapAnthropic requires client.messages");
+  }
+  const defaultContext = options.defaultContext;
+  const applyVendorHints = options.applyVendorHints !== false;
+  const defaultPromptCompression = normalizePromptCompressionOptions(options.promptCompression);
+  const promptCompressionStats = new AnthropicPromptCompressionStats();
+  const proxiedMessages = createMessagesProxy(
+    client.messages,
+    usageTap,
+    defaultContext,
+    applyVendorHints,
+    defaultPromptCompression,
+    promptCompressionStats
+  );
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === "messages") {
+        return proxiedMessages;
+      }
+      if (prop === "promptCompression") {
+        return promptCompressionStats;
+      }
+      if (prop === "unwrap") {
+        return () => target;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+  return new Proxy(client, handler);
+}
+function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats) {
+  if (typeof resource.create !== "function") {
+    throw new UsageTapError("USAGETAP_BAD_REQUEST", "wrapAnthropic requires client.messages.create");
+  }
+  const originalCreate = resource.create.bind(resource);
+  const wrappedCreate = ((params, options) => {
+    const {
+      requestOptions,
+      usageContext,
+      withUsage,
+      promptCompression
+    } = splitUsageOptions(options);
+    return invokeMessagesCreate({
+      params,
+      requestOptions,
+      usageContext,
+      withUsage,
+      promptCompression,
+      originalCreate,
+      usageTap,
+      defaultContext,
+      applyVendorHints,
+      defaultPromptCompression,
+      promptCompressionStats
+    });
+  });
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === "create") {
+        return wrappedCreate;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+  return new Proxy(resource, handler);
+}
+async function invokeMessagesCreate(args) {
+  const beginRequest = resolveBeginRequest(args.defaultContext, args.usageContext);
+  const begin = await args.usageTap.beginCall(
+    beginRequest,
+    beginCallOptions(args.withUsage)
+  );
+  const state = createCallState(beginRequest, begin);
+  const ctx = createUsageContext(state);
+  try {
+    const hintedParams = args.applyVendorHints ? applyAnthropicVendorHints(args.params, ctx.begin.data.vendorHints) : args.params;
+    const finalParams = await compressAnthropicParamsForCall({
+      params: hintedParams,
+      usageTap: args.usageTap,
+      ctx,
+      defaultPromptCompression: args.defaultPromptCompression,
+      callPromptCompression: args.promptCompression,
+      stats: args.promptCompressionStats,
+      withUsage: args.withUsage,
+      operation: "messages.create"
+    });
+    const request = attachCorrelationHeader(args.requestOptions, ctx.begin.correlationId);
+    const response = await args.originalCreate(finalParams, request);
+    if (isStreamingRequest(finalParams)) {
+      ensureAsyncIterable(response, "messages.create");
+      return wrapAnthropicStreamForUsageTap(
+        response,
+        state,
+        args.usageTap,
+        args.withUsage,
+        readString(finalParams.model)
+      );
+    }
+    inferAnthropicUsage(response, readString(finalParams.model), ctx);
+    await finalizeCall(state, args.usageTap, args.withUsage);
+    return response;
+  } catch (error) {
+    if (!state.error) {
+      state.error = {
+        code: args.withUsage?.defaultErrorCode ?? "VENDOR_ERROR",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    await finalizeCall(state, args.usageTap, args.withUsage);
+    throw error;
+  }
+}
+async function compressAnthropicParamsForCall(args) {
+  const compression = resolveEffectivePromptCompressionOptions(
+    args.defaultPromptCompression,
+    args.callPromptCompression
+  );
+  if (!compression) {
+    return args.params;
+  }
+  const outcome = await compressAnthropicParams(
+    args.params,
+    args.usageTap,
+    compression,
+    args.withUsage?.signal
+  );
+  await recordCompressionOutcome({
+    outcome,
+    compression,
+    usageTap: args.usageTap,
+    ctx: args.ctx,
+    stats: args.stats,
+    withUsage: args.withUsage,
+    operation: args.operation
+  });
+  return outcome.params;
+}
+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 compressAnthropicParams(params, usageTap, compression, signal) {
+  if (!params || typeof params !== "object") {
+    return { params, segments: [] };
+  }
+  const source = cloneRecord(params);
+  const segments = [];
+  if (typeof source.system === "string") {
+    const compressed = await compressTextForRole(
+      source.system,
+      "system",
+      usageTap,
+      compression,
+      signal
+    );
+    if (compressed) {
+      source.system = compressed.text;
+      segments.push(compressed.segment);
+    }
+  } else if (Array.isArray(source.system)) {
+    const systemResults = await Promise.all(
+      source.system.map(
+        (block) => compressAnthropicTextBlock(block, "system", usageTap, compression, signal)
+      )
+    );
+    const systemSegments = systemResults.flatMap(
+      (result) => result.segment ? [result.segment] : []
+    );
+    if (systemSegments.length) {
+      source.system = systemResults.map((result) => result.value);
+      segments.push(...systemSegments);
+    }
+  }
+  if (Array.isArray(source.messages)) {
+    const messageResults = await Promise.all(
+      source.messages.map(
+        (message) => compressAnthropicMessage(message, usageTap, compression, signal)
+      )
+    );
+    source.messages = messageResults.map((result) => result.value);
+    segments.push(...messageResults.flatMap((result) => result.segments));
+  }
+  return {
+    params: source,
+    segments
+  };
+}
+async function compressAnthropicMessage(message, usageTap, compression, signal) {
+  if (!isObjectRecord(message)) {
+    return { value: message, segments: [] };
+  }
+  const role = mapAnthropicMessageRole(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) => compressAnthropicContentBlock(block, role, usageTap, compression, signal)
+      )
+    );
+    const segments = blockResults.flatMap((result) => result.segments);
+    return {
+      value: segments.length ? { ...message, content: blockResults.map((result) => result.value) } : message,
+      segments
+    };
+  }
+  return { value: message, segments: [] };
+}
+async function compressAnthropicContentBlock(block, messageRole, usageTap, compression, signal) {
+  if (!isObjectRecord(block)) {
+    return { value: block, segments: [] };
+  }
+  if (block.type === "tool_result") {
+    return compressAnthropicToolResultBlock(block, usageTap, compression, signal);
+  }
+  const textResult = await compressAnthropicTextBlock(
+    block,
+    messageRole,
+    usageTap,
+    compression,
+    signal
+  );
+  return {
+    value: textResult.value,
+    segments: textResult.segment ? [textResult.segment] : []
+  };
+}
+async function compressAnthropicToolResultBlock(block, usageTap, compression, signal) {
+  const content = block.content;
+  if (typeof content === "string") {
+    const compressed = await compressTextForRole(
+      content,
+      "tool",
+      usageTap,
+      compression,
+      signal
+    );
+    if (!compressed) {
+      return { value: block, segments: [] };
+    }
+    return {
+      value: { ...block, content: compressed.text },
+      segments: [compressed.segment]
+    };
+  }
+  if (Array.isArray(content)) {
+    const contentResults = await Promise.all(
+      content.map(
+        (child) => compressAnthropicTextBlock(child, "tool", usageTap, compression, signal)
+      )
+    );
+    const segments = contentResults.flatMap(
+      (result) => result.segment ? [result.segment] : []
+    );
+    if (!segments.length) {
+      return { value: block, segments: [] };
+    }
+    return {
+      value: {
+        ...block,
+        content: contentResults.map((result) => result.value)
+      },
+      segments
+    };
+  }
+  return { value: block, segments: [] };
+}
+async function compressAnthropicTextBlock(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 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,
+    tokenCompanyAggressiveness: roleOptions.tokenCompanyAggressiveness,
+    tokenCompanyAppId: roleOptions.tokenCompanyAppId,
+    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 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,
+    tokenCompanyAggressiveness: roleOptions?.tokenCompanyAggressiveness ?? resolveTokenCompanyAggressiveness(compression, role),
+    tokenCompanyAppId: compression.tokenCompanyAppId
+  };
+}
+function resolveTokenCompanyAggressiveness(compression, role) {
+  if (typeof compression.tokenCompanyAggressiveness === "number") {
+    return compression.tokenCompanyAggressiveness;
+  }
+  return compression.tokenCompanyAggressiveness?.[role];
+}
+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 = dedupeStrings(segments.map((segment) => segment.result.provider));
+  const roles = dedupeStrings(segments.map((segment) => `role:${segment.role}`));
+  const techniques = dedupeStrings([
+    "anthropic-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 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",
+      "wrapAnthropic requires usageTap.customerId (provide defaultContext or options.usageTap)"
+    );
+  }
+  const tags = mergeTags(base.tags, current.tags);
+  const begin = { customerId };
+  const requested = current.requested ?? base.requested;
+  if (requested) begin.requested = requested;
+  const feature = current.feature ?? base.feature;
+  if (feature) begin.feature = feature;
+  const idempotency = current.idempotency ?? base.idempotency;
+  if (idempotency) begin.idempotency = idempotency;
+  const idempotencyKey = current.idempotencyKey ?? base.idempotencyKey;
+  if (idempotencyKey) begin.idempotencyKey = idempotencyKey;
+  const customerName = current.customerName ?? base.customerName;
+  if (customerName) begin.customerName = customerName;
+  const customerEmail = current.customerEmail ?? base.customerEmail;
+  if (customerEmail) begin.customerEmail = customerEmail;
+  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 createCallState(beginRequest, begin) {
+  const usage = {};
+  const stripeCustomerId = typeof begin.data.stripeCustomerId === "string" ? begin.data.stripeCustomerId : typeof beginRequest.stripeCustomerId === "string" ? beginRequest.stripeCustomerId : void 0;
+  if (stripeCustomerId) {
+    usage.stripeCustomerId = stripeCustomerId;
+  }
+  return {
+    beginRequest,
+    begin,
+    usage,
+    finalized: false
+  };
+}
+function createUsageContext(state) {
+  return {
+    begin: state.begin,
+    setUsage: (usage) => {
+      state.usage = { ...state.usage, ...usage };
+    },
+    setError: (error) => {
+      state.error = error;
+    }
+  };
+}
+async function finalizeCall(state, usageTap, options) {
+  if (state.finalized) {
+    return;
+  }
+  state.finalized = true;
+  await usageTap.endCall(
+    {
+      callId: state.begin.data.callId,
+      customerId: state.beginRequest.customerId,
+      feature: state.beginRequest.feature,
+      tags: state.beginRequest.tags,
+      ...state.usage,
+      error: state.error
+    },
+    endCallOptions(options, state.begin.correlationId)
+  );
+}
+function beginCallOptions(options) {
+  return {
+    signal: options?.signal,
+    headers: options?.headers,
+    retries: options?.retries,
+    correlationId: options?.correlationId
+  };
+}
+function endCallOptions(options, correlationId) {
+  return {
+    signal: options?.signal,
+    headers: options?.headers,
+    retries: options?.retries,
+    correlationId
+  };
+}
+function inferAnthropicUsage(response, fallbackModel, ctx) {
+  const usage = extractAnthropicUsage(response, fallbackModel);
+  if (usage) {
+    ctx.setUsage(usage);
+  }
+}
+function extractAnthropicUsage(payload, fallbackModel) {
+  if (!isObjectRecord(payload)) {
+    return fallbackModel ? { modelUsed: fallbackModel } : void 0;
+  }
+  const usage = findAnthropicUsageRecord(payload);
+  const result = {};
+  const model = readString(payload.model) ?? readString(payload.message?.model) ?? fallbackModel;
+  if (model) {
+    result.modelUsed = model;
+  }
+  if (usage) {
+    applyAnthropicUsageRecord(result, usage);
+  }
+  return Object.keys(result).length ? result : void 0;
+}
+function findAnthropicUsageRecord(payload) {
+  if (isObjectRecord(payload.usage)) {
+    return payload.usage;
+  }
+  if (isObjectRecord(payload.message) && isObjectRecord(payload.message.usage)) {
+    return payload.message.usage;
+  }
+  return void 0;
+}
+function applyAnthropicUsageRecord(usage, usageRecord) {
+  const inputTokens = readNumber(usageRecord.input_tokens ?? usageRecord.prompt_tokens);
+  if (inputTokens !== void 0) {
+    usage.inputTokens = inputTokens;
+  }
+  const outputTokens = readNumber(usageRecord.output_tokens ?? usageRecord.completion_tokens);
+  if (outputTokens !== void 0) {
+    usage.responseTokens = outputTokens;
+  }
+  const cachedInputTokens = readNumber(
+    usageRecord.cache_read_input_tokens ?? usageRecord.prompt_cache_hit_tokens ?? usageRecord.cached_tokens
+  );
+  if (cachedInputTokens !== void 0) {
+    usage.cachedInputTokens = cachedInputTokens;
+  }
+}
+function accumulateAnthropicStreamUsage(chunk, fallbackModel, state) {
+  const usage = extractAnthropicUsage(chunk, fallbackModel);
+  if (usage) {
+    state.usage = { ...state.usage, ...usage };
+  }
+}
+function wrapAnthropicStreamForUsageTap(source, state, usageTap, options, fallbackModel) {
+  const getIterator = source[Symbol.asyncIterator];
+  if (typeof getIterator !== "function") {
+    throw new TypeError("Stream is not async iterable");
+  }
+  const iterator = getIterator.call(source);
+  const invokeFinalize = async (error) => {
+    if (error && !state.error) {
+      state.error = {
+        code: options?.defaultErrorCode ?? "VENDOR_ERROR",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    await finalizeCall(state, usageTap, options);
+  };
+  const prototype = Object.getPrototypeOf(source) ?? Object.prototype;
+  const wrapped = Object.create(prototype);
+  for (const key of Reflect.ownKeys(source)) {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (descriptor) {
+        Object.defineProperty(wrapped, key, descriptor);
+      }
+    } catch {
+    }
+  }
+  Object.defineProperty(wrapped, Symbol.asyncIterator, {
+    value() {
+      return this;
+    },
+    configurable: true
+  });
+  Object.defineProperty(wrapped, "next", {
+    value: async (...args) => {
+      try {
+        const result = await iterator.next(...args);
+        if (result.value !== void 0) {
+          accumulateAnthropicStreamUsage(result.value, fallbackModel, state);
+        }
+        if (result.done) {
+          await invokeFinalize();
+        }
+        return result;
+      } catch (error) {
+        await invokeFinalize(error).catch(() => void 0);
+        throw error;
+      }
+    },
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(wrapped, "return", {
+    value: async (value) => {
+      if (typeof iterator.return === "function") {
+        const rawResult = await iterator.return(value);
+        if (!isIteratorResult(rawResult)) {
+          throw new TypeError("Iterator.return() returned an invalid result");
+        }
+        await invokeFinalize();
+        return rawResult;
+      }
+      await invokeFinalize();
+      return { done: true, value };
+    },
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(wrapped, "throw", {
+    value: async (error) => {
+      if (typeof iterator.throw === "function") {
+        const rawResult = await iterator.throw(error);
+        if (!isIteratorResult(rawResult)) {
+          throw new TypeError("Iterator.throw() returned an invalid result");
+        }
+        await invokeFinalize(error);
+        return rawResult;
+      }
+      await invokeFinalize(error);
+      throw error;
+    },
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(wrapped, "__usageTapFinalize", {
+    value: async () => {
+      await invokeFinalize();
+    },
+    configurable: true
+  });
+  return wrapped;
+}
+function applyAnthropicVendorHints(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;
+  }
+  return next;
+}
+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 cloneRequestOptions(source) {
+  const clone = { ...source };
+  if ("headers" in clone) {
+    clone.headers = normalizeHeaders(clone.headers);
+  }
+  return clone;
+}
+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 mapAnthropicMessageRole(role) {
+  if (role === "user") {
+    return "user";
+  }
+  if (role === "assistant") {
+    return "assistant";
+  }
+  return void 0;
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function cloneRecord(value) {
+  return isObjectRecord(value) ? { ...value } : {};
+}
+function isStringTuple(value) {
+  return Array.isArray(value) && value.length >= 2 && typeof value[0] === "string" && typeof value[1] === "string";
+}
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function mergeTags(a, b) {
+  const values = [...a ?? [], ...b ?? []].map((value) => typeof value === "string" ? value.trim() : "").filter(Boolean);
+  if (!values.length) {
+    return void 0;
+  }
+  return dedupeStrings(values);
+}
+function dedupeStrings(values) {
+  return Array.from(new Set(values));
+}
+function isStreamingRequest(params) {
+  if (!params || typeof params !== "object") {
+    return false;
+  }
+  const stream = params.stream;
+  if (typeof stream === "boolean") {
+    return stream;
+  }
+  return stream != null;
+}
+function 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 isIteratorResult(value) {
+  return isObjectRecord(value) && "done" in value;
+}
+
+exports.AnthropicPromptCompressionStats = AnthropicPromptCompressionStats;
+exports.wrapAnthropic = wrapAnthropic;
+//# sourceMappingURL=anthropic.cjs.map
+//# sourceMappingURL=anthropic.cjs.map