@usagetap/sdk 1.4.0 → 1.7.0

package/dist/anthropic/index.cjs

@@ -1024,6 +1024,8 @@ var SummarizationResource = class {
 };
 var GatewayResource = class {
   chat;
+  /** Buffered OpenAI Responses-compatible requests. */
+  responses;
   models;
   batches;
   transport;
@@ -1045,6 +1047,15 @@ var GatewayResource = class {
         })
       }
     };
+    this.responses = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/responses",
+        body: params,
+        options,
+        response: "json"
+      })
+    };
     this.models = {
       list: (options) => this.transport.request({
         method: "GET",
@@ -1130,7 +1141,7 @@ 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 SDK_VERSION = "1.7.0" ;
 var HAS_WINDOW = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
 var UsageTapClient = class {
   /** OpenAI-compatible chat, model, and native batch operations. */
@@ -1532,9 +1543,18 @@ var UsageTapClient = class {
         responseTokens: request.responseTokens,
         cachedInputTokens: request.cachedInputTokens,
         cacheWriteInputTokens: request.cacheWriteInputTokens,
+        cacheWrite5mInputTokens: request.cacheWrite5mInputTokens,
+        cacheWrite1hInputTokens: request.cacheWrite1hInputTokens,
         reasoningTokens: request.reasoningTokens,
         searches: request.searches,
         audioSeconds: request.audioSeconds,
+        imageInputCount: request.imageInputCount,
+        imageInputTokens: request.imageInputTokens,
+        imageOutputCount: request.imageOutputCount,
+        imageOutputTokens: request.imageOutputTokens,
+        audioInputTokens: request.audioInputTokens,
+        cachedAudioInputTokens: request.cachedAudioInputTokens,
+        audioOutputTokens: request.audioOutputTokens,
         costUsd: response.data.costUSD
       },
       correlationId: response.correlationId
@@ -1621,10 +1641,10 @@ var UsageTapClient = class {
         "incrementCustomMeter requires meterSlot"
       );
     }
-    if (!["CUSTOM1", "CUSTOM2"].includes(request.meterSlot)) {
+    if (!["CUSTOM1", "CUSTOM2", "AGENTIC_API"].includes(request.meterSlot)) {
       throw new UsageTapError(
         "USAGETAP_BAD_REQUEST",
-        "meterSlot must be CUSTOM1 or CUSTOM2"
+        "meterSlot must be CUSTOM1, CUSTOM2 or AGENTIC_API"
       );
     }
     if (typeof request.amount !== "number" || !Number.isFinite(request.amount) || request.amount <= 0) {
@@ -1697,6 +1717,28 @@ var UsageTapClient = class {
     let handlerResult;
     let handlerError;
     let endCallError;
+    let finalizationDeferred = false;
+    let finalizationPromise;
+    const finalize = () => {
+      if (!finalizationPromise) {
+        finalizationPromise = 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
+          }
+        ).then(() => void 0);
+      }
+      return finalizationPromise;
+    };
     const context = {
       begin: beginResponse,
       setUsage: (u) => {
@@ -1704,6 +1746,10 @@ var UsageTapClient = class {
       },
       setError: (err) => {
         errorPayload = err;
+      },
+      deferFinalization: () => {
+        finalizationDeferred = true;
+        return finalize;
       }
     };
     try {
@@ -1717,24 +1763,12 @@ var UsageTapClient = class {
         };
       }
     } 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 || !finalizationDeferred) {
+        try {
+          await finalize();
+        } catch (error) {
+          endCallError = error;
+        }
       }
     }
     if (handlerError) {
@@ -2076,7 +2110,8 @@ var UsageTapClient = class {
   }
   toHttpError(status, payload, correlationId) {
     const code = mapStatusToErrorCode(status);
-    const retryable = isRetryableStatus(status);
+    const apiCode = payload?.error?.code ?? payload?.result?.code ?? "UNKNOWN";
+    const retryable = isRetryableStatus(status) || isRetryableApiCode(apiCode);
     const message = payload?.error?.message ?? payload?.result?.message ?? `UsageTap responded with HTTP ${status}`;
     return new UsageTapError(code, message, {
       status,
@@ -2109,7 +2144,7 @@ function isRetryableStatus(status) {
 }
 function isRetryableApiCode(code) {
   const normalized = code.toUpperCase();
-  return normalized.includes("TRANSIENT") || normalized.includes("RETRY") || normalized.includes("TIMEOUT") || normalized.includes("THROTTLE") || normalized.includes("RATE_LIMIT");
+  return normalized === "PAYG_CONFLICT" || normalized.includes("TRANSIENT") || normalized.includes("RETRY") || normalized.includes("TIMEOUT") || normalized.includes("THROTTLE") || normalized.includes("RATE_LIMIT");
 }
 function mapApiCodeToError(code) {
   const normalized = code.toUpperCase();
@@ -2223,6 +2258,43 @@ var AnthropicPromptCompressionStats = class {
     return this.totalOriginalCharacters > 0 ? this.totalCharactersSaved / this.totalOriginalCharacters : 0;
   }
 };
+var DeferredAnthropicApiPromise = class extends Promise {
+  responseEnvelope;
+  constructor(execute) {
+    super((resolve) => resolve(void 0));
+    this.responseEnvelope = Promise.resolve().then(execute);
+  }
+  then(onfulfilled, onrejected) {
+    return this.responseEnvelope.then((result) => result.data).then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.then(void 0, onrejected);
+  }
+  finally(onfinally) {
+    return this.responseEnvelope.then((result) => result.data).finally(onfinally ?? void 0);
+  }
+  withResponse() {
+    return this.responseEnvelope;
+  }
+  async asResponse() {
+    const result = await this.responseEnvelope;
+    if (!("response" in result)) {
+      throw new TypeError("The wrapped Anthropic result does not expose a raw response");
+    }
+    return result.response;
+  }
+};
+async function resolveAnthropicResponseEnvelope(value) {
+  if (isObjectRecord(value) && typeof value.withResponse === "function") {
+    const withResponse = value.withResponse;
+    const result = await withResponse.call(value);
+    if (!isObjectRecord(result) || !("data" in result)) {
+      throw new TypeError("Anthropic create().withResponse() returned an invalid result");
+    }
+    return result;
+  }
+  return { data: await value };
+}
 var USAGETAP_CORRELATION_HEADER = "x-usage-correlation-id";
 function withSampling(client, options = {}) {
   if (!client?.messages || typeof client.messages.create !== "function" || !options) {
@@ -2235,53 +2307,56 @@ function withSampling(client, options = {}) {
   const localPolicy = typeof policy.rate === "number" ? policy : void 0;
   const usageTap = usageTapClient ?? new UsageTapClient({ apiKey, sampling: localPolicy });
   const originalCreate = client.messages.create.bind(client.messages);
-  const create = async (params, requestOptions) => {
-    const { usageTap: callContext = {}, ...providerOptions } = requestOptions ?? {};
-    const decision = params.stream === true ? Promise.resolve(false) : usageTap.shouldSampleAsync({
-      customerId: callContext.customerId,
-      feature: callContext.feature,
-      input: params
-    }, localPolicy);
-    const startedAt = Date.now();
-    try {
-      const response = await originalCreate(
-        params,
-        Object.keys(providerOptions).length ? providerOptions : void 0
-      );
-      const selected = await decision;
-      if (selected) {
-        const record = isObjectRecord(response) ? response : {};
-        await usageTap.captureSample({
-          customerId: callContext.customerId,
-          feature: callContext.feature,
-          environment: callContext.environment,
-          tags: callContext.tags,
-          provider: "anthropic",
-          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: callContext.customerId,
-          feature: callContext.feature,
-          environment: callContext.environment,
-          tags: callContext.tags,
-          provider: "anthropic",
-          model: readString(params.model),
-          input: params,
-          latencyMs: Date.now() - startedAt,
-          error: error instanceof Error ? { name: error.name, message: error.message } : { message: String(error) }
-        }).catch(() => void 0);
+  const create = (params, requestOptions) => {
+    return new DeferredAnthropicApiPromise(async () => {
+      const { usageTap: callContext = {}, ...providerOptions } = requestOptions ?? {};
+      const decision = params.stream === true ? Promise.resolve(false) : usageTap.shouldSampleAsync({
+        customerId: callContext.customerId,
+        feature: callContext.feature,
+        input: params
+      }, localPolicy);
+      const startedAt = Date.now();
+      try {
+        const result = await resolveAnthropicResponseEnvelope(originalCreate(
+          params,
+          Object.keys(providerOptions).length ? providerOptions : void 0
+        ));
+        const response = result.data;
+        const selected = await decision;
+        if (selected) {
+          const record = isObjectRecord(response) ? response : {};
+          await usageTap.captureSample({
+            customerId: callContext.customerId,
+            feature: callContext.feature,
+            environment: callContext.environment,
+            tags: callContext.tags,
+            provider: "anthropic",
+            model: readString(record.model) ?? readString(params.model),
+            input: params,
+            output: response,
+            usage: record.usage,
+            latencyMs: Date.now() - startedAt
+          }).catch(() => void 0);
+        }
+        return result;
+      } catch (error) {
+        const selected = await decision;
+        if (selected) {
+          await usageTap.captureSample({
+            customerId: callContext.customerId,
+            feature: callContext.feature,
+            environment: callContext.environment,
+            tags: callContext.tags,
+            provider: "anthropic",
+            model: readString(params.model),
+            input: params,
+            latencyMs: Date.now() - startedAt,
+            error: error instanceof Error ? { name: error.name, message: error.message } : { message: String(error) }
+          }).catch(() => void 0);
+        }
+        throw error;
       }
-      throw error;
-    }
+    });
   };
   const messages = new Proxy(client.messages, {
     get(target, prop, receiver) {
@@ -2322,7 +2397,12 @@ function withCompression(client, options = {}) {
   };
   const originalCreate = client.messages.create.bind(client.messages);
   const wrappedCreate = (params, requestOptions) => {
-    return compressAnthropicParams(params, usageTap, compression).then((outcome) => originalCreate(outcome.params, requestOptions));
+    return new DeferredAnthropicApiPromise(async () => {
+      const outcome = await compressAnthropicParams(params, usageTap, compression);
+      return resolveAnthropicResponseEnvelope(
+        originalCreate(outcome.params, requestOptions)
+      );
+    });
   };
   const proxiedMessages = new Proxy(client.messages, {
     get(target, prop, receiver) {
@@ -2417,20 +2497,22 @@ function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHint
       withUsage,
       promptCompression
     } = splitUsageOptions(options);
-    return invokeMessagesCreate({
-      params,
-      requestOptions,
-      usageContext,
-      withUsage,
-      promptCompression,
-      originalCreate,
-      usageTap,
-      defaultContext,
-      applyVendorHints,
-      defaultPromptCompression,
-      promptCompressionStats,
-      defaultSampling
-    });
+    return new DeferredAnthropicApiPromise(
+      () => invokeMessagesCreate({
+        params,
+        requestOptions,
+        usageContext,
+        withUsage,
+        promptCompression,
+        originalCreate,
+        usageTap,
+        defaultContext,
+        applyVendorHints,
+        defaultPromptCompression,
+        promptCompressionStats,
+        defaultSampling
+      })
+    );
   });
   const handler = {
     get(target, prop, receiver) {
@@ -2443,10 +2525,9 @@ function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHint
   return new Proxy(resource, handler);
 }
 async function invokeMessagesCreate(args) {
-  const beginRequest = withRuntimeCompressionContext(
-    resolveBeginRequest(args.defaultContext, args.usageContext),
-    "anthropic",
-    String(args.params.model)
+  const beginRequest = resolveBeginRequest(
+    args.defaultContext,
+    args.usageContext
   );
   const begin = await args.usageTap.beginCall(
     beginRequest,
@@ -2477,17 +2558,23 @@ async function invokeMessagesCreate(args) {
     });
     ctx.setUsage(anthropicRequestExecutionMetadata(finalParams));
     const request = attachCorrelationHeader(args.requestOptions, ctx.begin.correlationId);
-    const response = await args.originalCreate(finalParams, request);
+    const providerResult = await resolveAnthropicResponseEnvelope(
+      args.originalCreate(finalParams, request)
+    );
+    const response = providerResult.data;
     providerCompleted = true;
     if (isStreamingRequest(finalParams)) {
       ensureAsyncIterable(response, "messages.create");
-      return wrapAnthropicStreamForUsageTap(
-        response,
-        state,
-        args.usageTap,
-        args.withUsage,
-        readString(finalParams.model)
-      );
+      return {
+        ...providerResult,
+        data: wrapAnthropicStreamForUsageTap(
+          response,
+          state,
+          args.usageTap,
+          args.withUsage,
+          readString(finalParams.model)
+        )
+      };
     }
     inferAnthropicUsage(response, readString(finalParams.model), ctx);
     await captureMeteredAnthropicSample({
@@ -2500,7 +2587,7 @@ async function invokeMessagesCreate(args) {
       startedAt: sampleStartedAt
     });
     await finalizeCall(state, args.usageTap, args.withUsage);
-    return response;
+    return providerResult;
   } catch (error) {
     if (!state.error) {
       state.error = {
@@ -2583,70 +2670,19 @@ async function captureMeteredAnthropicSample({
   }).catch(() => void 0);
 }
 async function compressAnthropicParamsForCall(args) {
-  let compression = resolveEffectivePromptCompressionOptions(
+  const 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 = anthropicPolicyCompressionOptions(runtimePolicy);
-    if (runtimePolicy.mode === "SHADOW") {
-      const startedAt2 = Date.now();
-      void compressAnthropicParams(
-        args.params,
-        args.usageTap,
-        compression,
-        args.withUsage?.signal
-      ).then((outcome2) => {
-        args.ctx.setUsage({
-          runtimeCompression: anthropicRuntimeMeasurement({
-            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 compressAnthropicParams(
     args.params,
     args.usageTap,
     compression,
     args.withUsage?.signal
   );
-  if (policyDriven && runtimePolicy) {
-    const runtimeMeasurement = anthropicRuntimeMeasurement({
-      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,
@@ -2658,76 +2694,6 @@ async function compressAnthropicParamsForCall(args) {
   });
   return outcome.params;
 }
-function anthropicPolicyCompressionOptions(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 anthropicRuntimeMeasurement(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) {
@@ -3170,10 +3136,6 @@ function resolveBeginRequest(defaults, override) {
   }
   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;
@@ -3196,8 +3158,6 @@ function resolveBeginRequest(defaults, override) {
   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;
@@ -3333,21 +3293,21 @@ function applyAnthropicUsageRecord(usage, usageRecord) {
   if (cacheWriteInputTokens !== void 0) {
     usage.cacheWriteInputTokens = cacheWriteInputTokens;
   }
+  if (isObjectRecord(usageRecord.cache_creation)) {
+    const cacheWrite5m = readNumber(
+      usageRecord.cache_creation.ephemeral_5m_input_tokens
+    );
+    const cacheWrite1h = readNumber(
+      usageRecord.cache_creation.ephemeral_1h_input_tokens
+    );
+    if (cacheWrite5m !== void 0) usage.cacheWrite5mInputTokens = cacheWrite5m;
+    if (cacheWrite1h !== void 0) usage.cacheWrite1hInputTokens = cacheWrite1h;
+  }
   const baseInputTokens = readNumber(usageRecord.input_tokens ?? usageRecord.prompt_tokens);
   if (baseInputTokens !== void 0) {
     usage.inputTokens = baseInputTokens + (cachedInputTokens ?? 0) + (cacheWriteInputTokens ?? 0);
   }
 }
-function withRuntimeCompressionContext(begin, provider, model) {
-  return {
-    ...begin,
-    runtimeCompressionContext: {
-      ...begin.runtimeCompressionContext ?? {},
-      provider,
-      model
-    }
-  };
-}
 function accumulateAnthropicStreamUsage(chunk, fallbackModel, state) {
   const usage = extractAnthropicUsage(chunk, fallbackModel);
   if (usage) {