@usagetap/sdk 1.3.2 → 1.7.0

package/dist/anthropic/index.cjs

@@ -242,6 +242,11 @@ async function compressMessagesWithUsageTap(options) {
     aggressiveness,
     "UsageTap prompt message compression"
   );
+  if (options.latencyBudgetMs !== void 0 && (!Number.isFinite(options.latencyBudgetMs) || options.latencyBudgetMs < 0)) {
+    throw new Error(
+      "UsageTap prompt message compression latencyBudgetMs must be a non-negative number"
+    );
+  }
   const original = stableStringifyInput(options.input);
   const headers = {
     "content-type": "application/json"
@@ -256,7 +261,15 @@ async function compressMessagesWithUsageTap(options) {
       headers,
       body: JSON.stringify({
         ...cloneInputRecord(options.input),
-        compression_settings: { aggressiveness }
+        compression_settings: {
+          aggressiveness,
+          ...options.mode === void 0 ? {} : { mode: options.mode },
+          ...options.latencyBudgetMs === void 0 ? {} : { latency_budget_ms: options.latencyBudgetMs },
+          ...options.compactEmptyUserMessages === void 0 ? {} : { compact_empty_user_messages: options.compactEmptyUserMessages },
+          ...options.compactDuplicateUserTextParts === void 0 ? {} : {
+            compact_duplicate_user_text_parts: options.compactDuplicateUserTextParts
+          }
+        }
       }),
       signal: options.signal
     }
@@ -752,10 +765,369 @@ function scalarToToon(value) {
   return JSON.stringify(text);
 }
 
+// src/resources.ts
+var CANONICAL_MEDIA_TYPE = "application/vnd.usagetap.v1+json";
+var DEFAULT_GATEWAY_BASE_URL = "https://gateway.usagetap.com";
+function normalizedBaseUrl(value) {
+  return `${value.replace(/\/+$/, "")}/`;
+}
+function errorMessage(payload, status) {
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    const error = record.error;
+    if (error && typeof error === "object") {
+      const message2 = error.message;
+      if (typeof message2 === "string" && message2) return message2;
+    }
+    const message = record.message;
+    if (typeof message === "string" && message) return message;
+  }
+  return `UsageTap request failed with HTTP ${status}`;
+}
+function errorCode(status) {
+  if (status === 401 || status === 403) return "USAGETAP_AUTH_ERROR";
+  if (status === 429) return "USAGETAP_RATE_LIMITED";
+  if (status >= 500) return "USAGETAP_SERVER_ERROR";
+  return "USAGETAP_BAD_REQUEST";
+}
+var ResourceTransport = class {
+  baseUrl;
+  apiKey;
+  fetchImpl;
+  defaultHeaders;
+  sdkVersion;
+  constructor(baseUrl, config) {
+    this.baseUrl = normalizedBaseUrl(baseUrl);
+    this.apiKey = config.apiKey;
+    this.fetchImpl = config.fetchImpl;
+    this.defaultHeaders = config.headers ?? {};
+    this.sdkVersion = config.sdkVersion;
+  }
+  async request(request) {
+    const body = request.body === void 0 ? void 0 : JSON.stringify(request.body);
+    const headers = {
+      ...this.defaultHeaders,
+      accept: request.response === "data" ? CANONICAL_MEDIA_TYPE : request.response === "ndjson" ? "application/x-ndjson" : "application/json",
+      authorization: `Bearer ${this.apiKey}`,
+      "x-usage-sdk": `js/${this.sdkVersion}`,
+      ...body ? { "content-type": "application/json" } : {},
+      ...request.options?.idempotencyKey ? { "idempotency-key": request.options.idempotencyKey } : {},
+      ...request.options?.headers
+    };
+    let response;
+    try {
+      response = await this.fetchImpl(
+        new URL(request.path.replace(/^\/+/, ""), this.baseUrl),
+        {
+          method: request.method,
+          headers,
+          body,
+          signal: request.options?.signal
+        }
+      );
+    } catch (error) {
+      throw new UsageTapError(
+        "USAGETAP_NETWORK_ERROR",
+        "Failed to reach UsageTap",
+        { retryable: true, cause: error }
+      );
+    }
+    const requestId = response.headers.get("x-request-id") ?? response.headers.get("x-usage-correlation-id") ?? void 0;
+    const text = await response.text();
+    let payload;
+    if (text && request.response !== "ndjson") {
+      try {
+        payload = JSON.parse(text);
+      } catch (error) {
+        throw new UsageTapError(
+          "USAGETAP_INVALID_RESPONSE",
+          "UsageTap returned invalid JSON",
+          { status: response.status, correlationId: requestId, cause: error }
+        );
+      }
+    }
+    if (!response.ok) {
+      throw new UsageTapError(
+        errorCode(response.status),
+        errorMessage(payload, response.status),
+        {
+          status: response.status,
+          retryable: response.status === 429 || response.status >= 500,
+          correlationId: requestId,
+          details: payload && typeof payload === "object" ? payload : void 0
+        }
+      );
+    }
+    if (request.response === "ndjson") {
+      if (!text.trim()) return [];
+      try {
+        return text.trim().split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+      } catch (error) {
+        throw new UsageTapError(
+          "USAGETAP_INVALID_RESPONSE",
+          "UsageTap returned invalid NDJSON",
+          { status: response.status, correlationId: requestId, cause: error }
+        );
+      }
+    }
+    if (request.response === "data") {
+      if (!payload || typeof payload !== "object" || !("data" in payload)) {
+        throw new UsageTapError(
+          "USAGETAP_INVALID_RESPONSE",
+          "UsageTap response missing data",
+          { status: response.status, correlationId: requestId }
+        );
+      }
+      return payload.data;
+    }
+    if (payload === void 0) {
+      throw new UsageTapError(
+        "USAGETAP_INVALID_RESPONSE",
+        "UsageTap response was empty",
+        { status: response.status, correlationId: requestId }
+      );
+    }
+    return payload;
+  }
+};
+function resourceId(value, keys, label) {
+  const id = typeof value === "string" ? value : keys.map((key) => value[key]).find((candidate) => Boolean(candidate?.trim()));
+  if (!id?.trim()) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      `${label} requires a non-empty ID`
+    );
+  }
+  return id.trim();
+}
+function terminalSummary(status) {
+  return status === "COMPLETE" || status === "FAILED";
+}
+function terminalGatewayBatch(status) {
+  return ["completed", "failed", "expired", "cancelled"].includes(status);
+}
+function validateWaitOptions(options) {
+  const pollIntervalMs = options.pollIntervalMs ?? 1500;
+  const timeoutMs = options.timeoutMs ?? 3 * 6e4;
+  if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 0) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "pollIntervalMs must be a non-negative number"
+    );
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "timeoutMs must be a positive number"
+    );
+  }
+  return { pollIntervalMs, timeoutMs };
+}
+var SummarizationResource = class {
+  summaries;
+  batches;
+  profiles;
+  measurements;
+  transport;
+  constructor(config) {
+    this.transport = new ResourceTransport(config.apiBaseUrl, config);
+    this.summaries = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/compression/summaries",
+        body: params,
+        options,
+        response: "data"
+      }),
+      retrieve: (jobId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/compression/jobs/${encodeURIComponent(
+          resourceId(jobId, ["jobId"], "summaries.retrieve")
+        )}`,
+        options,
+        response: "data"
+      }),
+      wait: (job, options) => this.waitForSummary(job, options)
+    };
+    this.batches = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/compression/batches",
+        body: params,
+        options,
+        response: "data"
+      }),
+      retrieve: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/compression/batches/${encodeURIComponent(
+          resourceId(batchId, ["batchId"], "summarization.batches.retrieve")
+        )}`,
+        options,
+        response: "data"
+      }),
+      wait: (batch, options) => this.waitForBatch(batch, options)
+    };
+    this.profiles = {
+      retrieve: (profile, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/compression/profiles/${encodeURIComponent(
+          resourceId(profile, [], "summarization.profiles.retrieve")
+        )}`,
+        options,
+        response: "data"
+      })
+    };
+    this.measurements = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/compression/measurements",
+        body: params,
+        options,
+        response: "data"
+      })
+    };
+  }
+  async waitForSummary(value, options = {}) {
+    const { pollIntervalMs, timeoutMs } = validateWaitOptions(options);
+    const deadline = Date.now() + timeoutMs;
+    let job = typeof value === "string" ? await this.summaries.retrieve(value, options) : value;
+    while (!terminalSummary(job.status)) {
+      if (Date.now() >= deadline) {
+        throw new UsageTapError(
+          "USAGETAP_RETRY_EXHAUSTED",
+          `Summarization job ${job.jobId} did not finish before timeout`,
+          { retryable: true }
+        );
+      }
+      await sleep(pollIntervalMs, options.signal);
+      job = await this.summaries.retrieve(job.jobId, options);
+    }
+    return job;
+  }
+  async waitForBatch(value, options = {}) {
+    const { pollIntervalMs, timeoutMs } = validateWaitOptions(options);
+    const deadline = Date.now() + timeoutMs;
+    let batch = typeof value === "string" ? await this.batches.retrieve(value, options) : value;
+    while (!terminalSummary(batch.status)) {
+      if (Date.now() >= deadline) {
+        throw new UsageTapError(
+          "USAGETAP_RETRY_EXHAUSTED",
+          `Summarization batch ${batch.batchId} did not finish before timeout`,
+          { retryable: true }
+        );
+      }
+      await sleep(pollIntervalMs, options.signal);
+      batch = await this.batches.retrieve(batch.batchId, options);
+    }
+    return batch;
+  }
+};
+var GatewayResource = class {
+  chat;
+  /** Buffered OpenAI Responses-compatible requests. */
+  responses;
+  models;
+  batches;
+  transport;
+  idempotencyGenerator;
+  constructor(config) {
+    this.transport = new ResourceTransport(
+      config.gatewayBaseUrl ?? DEFAULT_GATEWAY_BASE_URL,
+      config
+    );
+    this.idempotencyGenerator = config.idempotencyGenerator ?? createIdempotencyKey;
+    this.chat = {
+      completions: {
+        create: (params, options) => this.transport.request({
+          method: "POST",
+          path: "/v1/chat/completions",
+          body: params,
+          options,
+          response: "json"
+        })
+      }
+    };
+    this.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",
+        path: "/v1/models",
+        options,
+        response: "json"
+      })
+    };
+    this.batches = {
+      create: (params, options = {}) => this.transport.request({
+        method: "POST",
+        path: "/v1/batches",
+        body: params,
+        options: {
+          ...options,
+          idempotencyKey: options.idempotencyKey ?? this.idempotencyGenerator()
+        },
+        response: "json"
+      }),
+      retrieve: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.retrieve")
+        )}`,
+        options,
+        response: "json"
+      }),
+      wait: (batch, options) => this.waitForBatch(batch, options),
+      cancel: (batchId, options) => this.transport.request({
+        method: "POST",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.cancel")
+        )}/cancel`,
+        options,
+        response: "json"
+      }),
+      results: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.results")
+        )}/results`,
+        options,
+        response: "ndjson"
+      })
+    };
+  }
+  async waitForBatch(value, options = {}) {
+    const { pollIntervalMs, timeoutMs } = validateWaitOptions(options);
+    const deadline = Date.now() + timeoutMs;
+    let batch = typeof value === "string" ? await this.batches.retrieve(value, options) : value;
+    while (!terminalGatewayBatch(batch.status)) {
+      if (Date.now() >= deadline) {
+        throw new UsageTapError(
+          "USAGETAP_RETRY_EXHAUSTED",
+          `Gateway batch ${batch.id} did not finish before timeout`,
+          { retryable: true }
+        );
+      }
+      await sleep(pollIntervalMs, options.signal);
+      batch = await this.batches.retrieve(batch.id, options);
+    }
+    return batch;
+  }
+};
+
 // src/client.ts
 var CALL_BEGIN_PATH = "call_begin";
 var CALL_END_PATH = "call_end";
 var COMPRESS_PROMPT_PATH = "compress_prompt";
+var SAMPLES_PATH = "samples";
+var SAMPLING_SETTINGS_PATH = "sampling/settings";
+var SAMPLING_DECIDE_PATH = "sampling/decide";
 var CHECK_USAGE_PATH = "customers/{customerId}/usage";
 var CREATE_CUSTOMER_PATH = "customers";
 var CHANGE_PLAN_PATH = "customers/{customerId}/change_plan";
@@ -766,11 +1138,16 @@ 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 CANONICAL_MEDIA_TYPE2 = "application/vnd.usagetap.v1+json";
 var DEFAULT_BASE_URL = "https://api.usagetap.com";
-var SDK_VERSION = "1.3.2" ;
+var DEFAULT_RUN_INACTIVITY_MS = 60 * 60 * 1e3;
+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. */
+  gateway;
+  /** Published-profile context summarization operations. */
+  summarization;
   apiKey;
   baseUrl;
   fetchImpl;
@@ -795,6 +1172,11 @@ var UsageTapClient = class {
   usageTapCompressionMessagesEndpoint;
   usageTapCompressionModel;
   usageTapCompressionAggressiveness;
+  sampling;
+  samplingSettingsCacheMs;
+  circuitBreaker;
+  circuitBreakerRuns = /* @__PURE__ */ new Map();
+  samplingSettingsCache;
   constructor(options = {}) {
     const apiKey = options.apiKey?.trim() || readEnvironmentVariable("USAGETAP_API_KEY");
     const baseUrl = options.baseUrl?.trim() || readEnvironmentVariable("USAGETAP_BASE_URL") || DEFAULT_BASE_URL;
@@ -817,10 +1199,21 @@ var UsageTapClient = class {
         "A global fetch implementation was not found. Pass fetchImpl in UsageTapClientOptions."
       );
     }
-    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-    this.baseUrl = new URL(normalizedBaseUrl);
+    const normalizedBaseUrl2 = normalizeBaseUrl(baseUrl);
+    this.baseUrl = new URL(normalizedBaseUrl2);
     this.apiKey = apiKey;
     this.fetchImpl = wrapFetchImplementation(fetchCandidate, !options.fetchImpl);
+    const resourceConfig = {
+      apiKey,
+      apiBaseUrl: normalizedBaseUrl2,
+      gatewayBaseUrl: options.gatewayBaseUrl?.trim() || readEnvironmentVariable("USAGETAP_GATEWAY_URL"),
+      fetchImpl: this.fetchImpl,
+      headers: options.headers,
+      sdkVersion: SDK_VERSION,
+      idempotencyGenerator: options.idempotencyGenerator
+    };
+    this.gateway = new GatewayResource(resourceConfig);
+    this.summarization = new SummarizationResource(resourceConfig);
     this.defaultFeature = options.defaultFeature;
     this.defaultTags = options.defaultTags?.length ? dedupeStrings(options.defaultTags) : void 0;
     this.defaultHeaders = options.headers ? normalizeHeaderDictionary(options.headers) : {};
@@ -842,11 +1235,122 @@ var UsageTapClient = class {
     this.usageTapCompressionMessagesEndpoint = options.usageTapCompressionMessagesEndpoint;
     this.usageTapCompressionModel = options.usageTapCompressionModel;
     this.usageTapCompressionAggressiveness = options.usageTapCompressionAggressiveness;
+    this.sampling = options.sampling;
+    this.samplingSettingsCacheMs = Number.isFinite(options.samplingSettingsCacheMs) ? Math.max(0, Number(options.samplingSettingsCacheMs)) : 5 * 60 * 1e3;
+    if (options.circuitBreaker) {
+      const maxCallsPerRun = options.circuitBreaker.maxCallsPerRun;
+      if (!Number.isInteger(maxCallsPerRun) || maxCallsPerRun < 1) {
+        throw new UsageTapError(
+          "USAGETAP_BAD_REQUEST",
+          "circuitBreaker.maxCallsPerRun must be a positive integer"
+        );
+      }
+      const runInactivityMs = options.circuitBreaker.runInactivityMs ?? DEFAULT_RUN_INACTIVITY_MS;
+      if (!Number.isFinite(runInactivityMs) || runInactivityMs < 1) {
+        throw new UsageTapError(
+          "USAGETAP_BAD_REQUEST",
+          "circuitBreaker.runInactivityMs must be a positive number"
+        );
+      }
+      this.circuitBreaker = {
+        maxCallsPerRun,
+        runInactivityMs
+      };
+    }
+  }
+  shouldSample(request, policy = this.sampling || void 0) {
+    if (!policy) return false;
+    const rate = Math.min(1, Math.max(0, Number(policy.rate) || 0));
+    if (rate <= 0) return false;
+    const customerId = request.customerId?.trim();
+    if (customerId && policy.customers?.exclude?.includes(customerId)) return false;
+    const feature = request.feature?.trim();
+    if (feature && policy.features?.exclude?.includes(feature)) return false;
+    const included = policy.features?.include?.filter(Boolean) ?? [];
+    if (included.length > 0 && (!feature || !included.includes(feature))) return false;
+    const minimum = Math.max(0, Math.round(policy.minInputTokens ?? 0));
+    if (minimum > 0 && estimatePromptTokens(request.input) < minimum) return false;
+    return (policy.random ?? Math.random)() < rate;
+  }
+  async getSamplingSettings(options = {}) {
+    const now = Date.now();
+    if (!options.forceRefresh && this.samplingSettingsCache && this.samplingSettingsCache.expiresAtMs > now) {
+      return {
+        result: { status: "ACCEPTED", code: "SAMPLING_SETTINGS_CACHED" },
+        data: this.samplingSettingsCache.settings,
+        correlationId: options.correlationId ?? "local-cache"
+      };
+    }
+    const response = await this.requestGet(
+      SAMPLING_SETTINGS_PATH,
+      {
+        signal: options.signal,
+        headers: options.headers,
+        retries: options.retries,
+        correlationId: options.correlationId
+      }
+    );
+    const serverCacheMs = Math.max(0, Number(response.data.cacheSeconds) || 0) * 1e3;
+    const cacheMs = Math.min(this.samplingSettingsCacheMs, serverCacheMs);
+    this.samplingSettingsCache = {
+      settings: response.data,
+      expiresAtMs: now + cacheMs
+    };
+    return response;
+  }
+  async shouldSampleAsync(request, policy) {
+    if (policy) return this.shouldSample(request, policy);
+    if (this.sampling === false) return false;
+    if (this.sampling) return this.shouldSample(request, this.sampling);
+    try {
+      const settings = await this.getSamplingSettings();
+      return this.shouldSample(request, settings.data);
+    } catch {
+      return false;
+    }
+  }
+  async decideSample(request, options = {}) {
+    const hasTokens = Number.isFinite(request.inputTokens) && Number(request.inputTokens) >= 0;
+    const hasCharacters = Number.isFinite(request.inputCharacters) && Number(request.inputCharacters) >= 0;
+    if (!hasTokens && !hasCharacters) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "decideSample requires inputTokens or inputCharacters"
+      );
+    }
+    return this.request(
+      SAMPLING_DECIDE_PATH,
+      request,
+      options
+    );
+  }
+  async captureSample(request, options = {}) {
+    if (!request || request.input === void 0) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "captureSample requires input"
+      );
+    }
+    if (!request.provider?.trim()) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "captureSample requires provider"
+      );
+    }
+    const sampleId = request.sampleId?.trim() || this.idempotencyGenerator();
+    return this.request(
+      SAMPLES_PATH,
+      { ...request, sampleId },
+      { ...options, idempotencyKey: sampleId }
+    );
   }
   async beginCall(request, options = {}) {
     const idempotencyKey = request.idempotencyKey ?? request.idempotency ?? (this.autoIdempotency ? this.idempotencyGenerator() : void 0);
+    this.reserveRunCall(request, idempotencyKey);
+    const apiRequest = { ...request };
+    delete apiRequest.runId;
     const payload = {
-      ...request,
+      ...apiRequest,
       feature: request.feature ?? this.defaultFeature,
       tags: this.mergeTags(request.tags)
     };
@@ -864,6 +1368,28 @@ var UsageTapClient = class {
     );
     return response;
   }
+  /**
+   * Inspect a configured run circuit breaker without consuming another call.
+   */
+  canRunContinue(request) {
+    const identity = this.resolveRunIdentity(request);
+    if (!identity || !this.circuitBreaker) {
+      throw new UsageTapError(
+        "USAGETAP_BAD_REQUEST",
+        "canRunContinue requires circuitBreaker configuration and a non-empty runId"
+      );
+    }
+    this.expireInactiveRuns();
+    const calls = this.circuitBreakerRuns.get(identity.key)?.calls ?? 0;
+    return this.createCircuitBreakerDecision(identity.customerId, identity.runId, calls);
+  }
+  /**
+   * Release local state after a workflow finishes. Returns true when state existed.
+   */
+  resetRun(request) {
+    const identity = this.resolveRunIdentity(request);
+    return identity ? this.circuitBreakerRuns.delete(identity.key) : false;
+  }
   async promptCompress(request, options = {}) {
     if (!request?.callId) {
       throw new UsageTapError(
@@ -961,6 +1487,10 @@ var UsageTapClient = class {
       usageTapCompressionMessagesEndpoint: this.usageTapCompressionMessagesEndpoint,
       aggressiveness: options.aggressiveness ?? this.aggressiveness,
       usageTapCompressionAggressiveness: options.usageTapCompressionAggressiveness ?? this.usageTapCompressionAggressiveness,
+      mode: options.mode,
+      latencyBudgetMs: options.latencyBudgetMs,
+      compactEmptyUserMessages: options.compactEmptyUserMessages,
+      compactDuplicateUserTextParts: options.compactDuplicateUserTextParts,
       fetchImpl: this.fetchImpl,
       signal: options.signal,
       failOpen: options.failOpen
@@ -1002,14 +1532,29 @@ var UsageTapClient = class {
       callId: request.callId,
       feature: feature ?? this.defaultFeature,
       tags: tags ?? this.defaultTags,
+      providerUsed: request.providerUsed,
       modelUsed: request.modelUsed,
+      reasoningEffort: request.reasoningEffort,
+      reasoningEffortSource: request.reasoningEffortSource,
+      reasoningMode: request.reasoningMode,
+      reasoningBudgetTokens: request.reasoningBudgetTokens,
       metrics: {
         inputTokens: request.inputTokens,
         responseTokens: request.responseTokens,
         cachedInputTokens: request.cachedInputTokens,
+        cacheWriteInputTokens: request.cacheWriteInputTokens,
+        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
@@ -1096,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) {
@@ -1114,6 +1659,15 @@ var UsageTapClient = class {
       meterSlot: request.meterSlot,
       amount: request.amount
     };
+    if (request.customerUserId) {
+      payload.customerUserId = request.customerUserId;
+    }
+    if (request.customerUserName) {
+      payload.customerUserName = request.customerUserName;
+    }
+    if (request.customerUserEmail) {
+      payload.customerUserEmail = request.customerUserEmail;
+    }
     if (request.feature) {
       payload.feature = request.feature;
     }
@@ -1150,6 +1704,11 @@ var UsageTapClient = class {
     const beginPayload = idempotencyKey ? { ...beginRequest, idempotencyKey, idempotency: idempotencyKey } : { ...beginRequest };
     const beginResponse = await this.beginCall(beginPayload, options);
     let usage = {};
+    const pricingMode = beginResponse.data.pricingMode ?? beginRequest.pricingMode ?? (beginRequest.batch === true ? "batch" : beginRequest.batch === false ? "standard" : void 0);
+    if (pricingMode) {
+      usage.pricingMode = pricingMode;
+      usage.batch = pricingMode === "batch";
+    }
     const initialStripeCustomerId = typeof beginResponse.data.stripeCustomerId === "string" ? beginResponse.data.stripeCustomerId : typeof beginRequest.stripeCustomerId === "string" ? beginRequest.stripeCustomerId : void 0;
     if (initialStripeCustomerId) {
       usage = { ...usage, stripeCustomerId: initialStripeCustomerId };
@@ -1158,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) => {
@@ -1165,6 +1746,10 @@ var UsageTapClient = class {
       },
       setError: (err) => {
         errorPayload = err;
+      },
+      deferFinalization: () => {
+        finalizationDeferred = true;
+        return finalize;
       }
     };
     try {
@@ -1178,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) {
@@ -1217,17 +1790,86 @@ var UsageTapClient = class {
   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
     };
   }
+  reserveRunCall(request, idempotencyKey) {
+    const identity = this.resolveRunIdentity(request);
+    if (!identity || !this.circuitBreaker) return;
+    this.expireInactiveRuns();
+    const now = Date.now();
+    const state = this.circuitBreakerRuns.get(identity.key) ?? {
+      calls: 0,
+      reservationKeys: /* @__PURE__ */ new Set(),
+      lastSeenAtMs: now
+    };
+    const reservationKey = idempotencyKey ?? this.idempotencyGenerator();
+    state.lastSeenAtMs = now;
+    if (state.reservationKeys.has(reservationKey)) {
+      this.circuitBreakerRuns.set(identity.key, state);
+      return;
+    }
+    const decision = this.createCircuitBreakerDecision(
+      identity.customerId,
+      identity.runId,
+      state.calls
+    );
+    if (!decision.allowed) {
+      throw new UsageTapError(
+        "USAGETAP_CIRCUIT_OPEN",
+        `Run ${identity.runId} reached its ${decision.limit}-call circuit-breaker limit`,
+        {
+          details: {
+            reason: decision.reason,
+            customerId: identity.customerId,
+            runId: identity.runId,
+            calls: decision.calls,
+            limit: decision.limit,
+            remaining: decision.remaining
+          }
+        }
+      );
+    }
+    state.calls += 1;
+    state.reservationKeys.add(reservationKey);
+    this.circuitBreakerRuns.set(identity.key, state);
+  }
+  resolveRunIdentity(request) {
+    const customerId = request.customerId?.trim();
+    const runId = request.runId?.trim();
+    if (!customerId || !runId) return void 0;
+    return {
+      key: `${customerId}\0${runId}`,
+      customerId,
+      runId
+    };
+  }
+  createCircuitBreakerDecision(customerId, runId, calls) {
+    const limit = this.circuitBreaker?.maxCallsPerRun ?? 0;
+    const allowed = calls < limit;
+    return {
+      allowed,
+      ...allowed ? {} : { reason: "max_calls_per_run" },
+      customerId,
+      runId,
+      calls,
+      limit,
+      remaining: Math.max(0, limit - calls)
+    };
+  }
+  expireInactiveRuns() {
+    if (!this.circuitBreaker || this.circuitBreakerRuns.size === 0) return;
+    const expiredBefore = Date.now() - this.circuitBreaker.runInactivityMs;
+    for (const [key, state] of this.circuitBreakerRuns) {
+      if (state.lastSeenAtMs < expiredBefore) {
+        this.circuitBreakerRuns.delete(key);
+      }
+    }
+  }
   async request(path, payload, options) {
     const url = new URL(path, this.baseUrl).toString();
     const body = payload !== void 0 ? JSON.stringify(payload) : void 0;
@@ -1415,7 +2057,7 @@ var UsageTapClient = class {
       ...this.defaultHeaders,
       [SDK_HEADER]: `js/${SDK_VERSION}`,
       "content-type": "application/json",
-      accept: CANONICAL_MEDIA_TYPE
+      accept: CANONICAL_MEDIA_TYPE2
     };
     if (!HAS_WINDOW) {
       headers["user-agent"] = `${USER_AGENT}/${SDK_VERSION}`;
@@ -1468,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,
@@ -1501,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();
@@ -1615,7 +2258,123 @@ 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) {
+    throw new UsageTapError(
+      "USAGETAP_BAD_REQUEST",
+      "withSampling requires an Anthropic client and sampling options"
+    );
+  }
+  const { apiKey, usageTapClient, ...policy } = 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 = (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;
+      }
+    });
+  };
+  const messages = new Proxy(client.messages, {
+    get(target, prop, receiver) {
+      if (prop === "create") return create;
+      return safeReflectGet(target, prop, receiver);
+    }
+  });
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "messages") return messages;
+      if (prop === "unwrap") return () => target;
+      return safeReflectGet(target, prop, receiver);
+    }
+  });
+}
+function safeReflectGet(target, prop, receiver) {
+  return Reflect.get(target, prop, receiver);
+}
 function withCompression(client, options = {}) {
   if (!client?.messages || typeof client.messages.create !== "function") {
     throw new UsageTapError(
@@ -1626,17 +2385,24 @@ function withCompression(client, options = {}) {
   const {
     apiKey,
     usageTapClient,
+    sampling,
     ...compressionOverrides
   } = options;
   const usageTap = usageTapClient ?? new UsageTapClient({ apiKey });
   const compression = {
     provider: "usagetap",
+    roles: { user: { enabled: true, aggressiveness: 0.2 } },
     minContextTokens: DEFAULT_PROMPT_COMPRESSION_MIN_CONTEXT_TOKENS,
     ...compressionOverrides
   };
   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) {
@@ -1644,13 +2410,18 @@ function withCompression(client, options = {}) {
       return Reflect.get(target, prop, receiver);
     }
   });
-  return new Proxy(client, {
+  const compressed = new Proxy(client, {
     get(target, prop, receiver) {
       if (prop === "messages") return proxiedMessages;
       if (prop === "unwrap") return () => target;
       return Reflect.get(target, prop, receiver);
     }
   });
+  return sampling ? withSampling(compressed, {
+    ...sampling === true ? {} : sampling,
+    apiKey,
+    usageTapClient
+  }) : compressed;
 }
 function withMetering(client, customer) {
   const config = typeof customer === "string" ? { customerId: customer } : customer;
@@ -1665,6 +2436,7 @@ function withMetering(client, customer) {
     usageTapClient,
     applyVendorHints,
     promptCompression,
+    sampling,
     ...defaultContext
   } = config;
   const usageTap = usageTapClient ?? new UsageTapClient({ apiKey });
@@ -1672,7 +2444,8 @@ function withMetering(client, customer) {
   return wrapAnthropic(client, usageTap, {
     defaultContext,
     applyVendorHints,
-    promptCompression: normalizedCompression
+    promptCompression: normalizedCompression,
+    sampling
   });
 }
 function wrapAnthropic(client, usageTap, options = {}) {
@@ -1685,6 +2458,7 @@ function wrapAnthropic(client, usageTap, options = {}) {
   const defaultContext = options.defaultContext;
   const applyVendorHints = options.applyVendorHints !== false;
   const defaultPromptCompression = normalizePromptCompressionOptions(options.promptCompression);
+  const defaultSampling = normalizeMeteredAnthropicSampling(options.sampling);
   const promptCompressionStats = new AnthropicPromptCompressionStats();
   const proxiedMessages = createMessagesProxy(
     client.messages,
@@ -1692,7 +2466,8 @@ function wrapAnthropic(client, usageTap, options = {}) {
     defaultContext,
     applyVendorHints,
     defaultPromptCompression,
-    promptCompressionStats
+    promptCompressionStats,
+    defaultSampling
   );
   const handler = {
     get(target, prop, receiver) {
@@ -1710,7 +2485,7 @@ function wrapAnthropic(client, usageTap, options = {}) {
   };
   return new Proxy(client, handler);
 }
-function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats) {
+function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats, defaultSampling) {
   if (typeof resource.create !== "function") {
     throw new UsageTapError("USAGETAP_BAD_REQUEST", "wrapAnthropic requires client.messages.create");
   }
@@ -1722,19 +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
-    });
+    return new DeferredAnthropicApiPromise(
+      () => invokeMessagesCreate({
+        params,
+        requestOptions,
+        usageContext,
+        withUsage,
+        promptCompression,
+        originalCreate,
+        usageTap,
+        defaultContext,
+        applyVendorHints,
+        defaultPromptCompression,
+        promptCompressionStats,
+        defaultSampling
+      })
+    );
   });
   const handler = {
     get(target, prop, receiver) {
@@ -1747,13 +2525,25 @@ function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHint
   return new Proxy(resource, handler);
 }
 async function invokeMessagesCreate(args) {
-  const beginRequest = resolveBeginRequest(args.defaultContext, args.usageContext);
+  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);
+  const sampleStartedAt = Date.now();
+  const wantsStream = isStreamingRequest(args.params);
+  const sampleDecision = wantsStream ? Promise.resolve(false) : startMeteredAnthropicSampleDecision({
+    usageTap: args.usageTap,
+    sampling: args.defaultSampling,
+    beginRequest,
+    input: args.params
+  });
+  let providerCompleted = false;
   try {
     const hintedParams = args.applyVendorHints ? applyAnthropicVendorHints(args.params, ctx.begin.data.vendorHints) : args.params;
     const finalParams = await compressAnthropicParamsForCall({
@@ -1766,21 +2556,38 @@ async function invokeMessagesCreate(args) {
       withUsage: args.withUsage,
       operation: "messages.create"
     });
+    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({
+      usageTap: args.usageTap,
+      sampling: args.defaultSampling,
+      decision: sampleDecision,
+      state,
+      input: args.params,
+      response,
+      startedAt: sampleStartedAt
+    });
     await finalizeCall(state, args.usageTap, args.withUsage);
-    return response;
+    return providerResult;
   } catch (error) {
     if (!state.error) {
       state.error = {
@@ -1788,10 +2595,80 @@ async function invokeMessagesCreate(args) {
         message: error instanceof Error ? error.message : String(error)
       };
     }
+    if (!providerCompleted) {
+      await captureMeteredAnthropicSample({
+        usageTap: args.usageTap,
+        sampling: args.defaultSampling,
+        decision: sampleDecision,
+        state,
+        input: args.params,
+        error,
+        startedAt: sampleStartedAt
+      });
+    }
     await finalizeCall(state, args.usageTap, args.withUsage);
     throw error;
   }
 }
+function normalizeMeteredAnthropicSampling(options) {
+  if (!options) return void 0;
+  if (options === true) return {};
+  return {
+    policy: typeof options.rate === "number" ? options : void 0
+  };
+}
+function startMeteredAnthropicSampleDecision({
+  usageTap,
+  sampling,
+  beginRequest,
+  input
+}) {
+  if (!sampling) return Promise.resolve(false);
+  return usageTap.shouldSampleAsync(
+    {
+      customerId: beginRequest.customerId,
+      feature: beginRequest.feature,
+      input
+    },
+    sampling.policy
+  );
+}
+async function captureMeteredAnthropicSample({
+  usageTap,
+  sampling,
+  decision,
+  state,
+  input,
+  response,
+  error,
+  startedAt
+}) {
+  if (!sampling) return;
+  let selected = false;
+  try {
+    selected = await decision;
+  } catch {
+    return;
+  }
+  if (!selected) return;
+  const record = isObjectRecord(response) ? response : {};
+  await usageTap.captureSample({
+    sampleId: state.begin.data.callId,
+    callId: state.begin.data.callId,
+    customerId: state.beginRequest.customerId,
+    feature: state.beginRequest.feature,
+    tags: state.beginRequest.tags,
+    provider: "anthropic",
+    model: readString(record.model) ?? readString(input.model),
+    input,
+    ...response === void 0 ? {} : { output: response },
+    usage: record.usage,
+    latencyMs: Date.now() - startedAt,
+    ...error === void 0 ? {} : {
+      error: error instanceof Error ? { name: error.name, message: error.message } : { message: String(error) }
+    }
+  }).catch(() => void 0);
+}
 async function compressAnthropicParamsForCall(args) {
   const compression = resolveEffectivePromptCompressionOptions(
     args.defaultPromptCompression,
@@ -1871,6 +2748,10 @@ async function compressAnthropicParams(params, usageTap, compression, signal) {
     const result = await usageTap.compressPromptMessages(source, {
       provider: "usagetap",
       failOpen: compression.failOpen,
+      mode: compression.mode,
+      latencyBudgetMs: compression.latencyBudgetMs,
+      compactEmptyUserMessages: compression.compactEmptyUserMessages,
+      compactDuplicateUserTextParts: compression.compactDuplicateUserTextParts,
       aggressiveness: resolveMessageEndpointAggressiveness(compression),
       signal
     });
@@ -2259,6 +3140,8 @@ function resolveBeginRequest(defaults, override) {
   if (requested) begin.requested = requested;
   const feature = current.feature ?? base.feature;
   if (feature) begin.feature = feature;
+  const runId = current.runId ?? base.runId;
+  if (runId) begin.runId = runId;
   const idempotency = current.idempotency ?? base.idempotency;
   if (idempotency) begin.idempotency = idempotency;
   const idempotencyKey = current.idempotencyKey ?? base.idempotencyKey;
@@ -2267,10 +3150,14 @@ function resolveBeginRequest(defaults, override) {
   if (customerName) begin.customerName = customerName;
   const customerEmail = current.customerEmail ?? base.customerEmail;
   if (customerEmail) begin.customerEmail = customerEmail;
+  const customerUserId = current.customerUserId ?? base.customerUserId;
+  if (customerUserId) begin.customerUserId = customerUserId;
+  const customerUserName = current.customerUserName ?? base.customerUserName;
+  if (customerUserName) begin.customerUserName = customerUserName;
+  const customerUserEmail = current.customerUserEmail ?? base.customerUserEmail;
+  if (customerUserEmail) begin.customerUserEmail = customerUserEmail;
   const stripeCustomerId = current.stripeCustomerId ?? base.stripeCustomerId;
   if (stripeCustomerId) begin.stripeCustomerId = stripeCustomerId;
-  const holdUsd = current.holdUsd ?? base.holdUsd;
-  if (typeof holdUsd === "number") begin.holdUsd = holdUsd;
   const batch = current.batch ?? base.batch;
   if (typeof batch === "boolean") begin.batch = batch;
   const pricingMode = current.pricingMode ?? base.pricingMode;
@@ -2282,6 +3169,11 @@ function resolveBeginRequest(defaults, override) {
 }
 function createCallState(beginRequest, begin) {
   const usage = {};
+  const pricingMode = begin.data.pricingMode ?? beginRequest.pricingMode ?? (beginRequest.batch === true ? "batch" : beginRequest.batch === false ? "standard" : void 0);
+  if (pricingMode) {
+    usage.pricingMode = pricingMode;
+    usage.batch = pricingMode === "batch";
+  }
   const stripeCustomerId = typeof begin.data.stripeCustomerId === "string" ? begin.data.stripeCustomerId : typeof beginRequest.stripeCustomerId === "string" ? beginRequest.stripeCustomerId : void 0;
   if (stripeCustomerId) {
     usage.stripeCustomerId = stripeCustomerId;
@@ -2345,10 +3237,12 @@ function inferAnthropicUsage(response, fallbackModel, ctx) {
 }
 function extractAnthropicUsage(payload, fallbackModel) {
   if (!isObjectRecord(payload)) {
-    return fallbackModel ? { modelUsed: fallbackModel } : void 0;
+    return { providerUsed: "anthropic", ...fallbackModel ? { modelUsed: fallbackModel } : {} };
   }
   const usage = findAnthropicUsageRecord(payload);
-  const result = {};
+  const result = {
+    providerUsed: "anthropic"
+  };
   const model = readString(payload.model) ?? readString(payload.message?.model) ?? fallbackModel;
   if (model) {
     result.modelUsed = model;
@@ -2358,6 +3252,21 @@ function extractAnthropicUsage(payload, fallbackModel) {
   }
   return Object.keys(result).length ? result : void 0;
 }
+function anthropicRequestExecutionMetadata(params) {
+  const outputConfig = isObjectRecord(params.output_config) ? params.output_config : void 0;
+  const thinking = isObjectRecord(params.thinking) ? params.thinking : void 0;
+  const rawEffort = outputConfig?.effort;
+  const effort = rawEffort === "none" || rawEffort === "minimal" || rawEffort === "low" || rawEffort === "medium" || rawEffort === "high" || rawEffort === "xhigh" || rawEffort === "max" ? rawEffort : void 0;
+  const mode = readString(thinking?.type);
+  const rawBudget = readNumber(thinking?.budget_tokens);
+  const budget = rawBudget !== void 0 && Number.isInteger(rawBudget) && rawBudget >= 0 ? rawBudget : void 0;
+  return {
+    providerUsed: "anthropic",
+    ...effort ? { reasoningEffort: effort, reasoningEffortSource: "provider_request" } : {},
+    ...mode ? { reasoningMode: mode } : {},
+    ...budget !== void 0 ? { reasoningBudgetTokens: budget } : {}
+  };
+}
 function findAnthropicUsageRecord(payload) {
   if (isObjectRecord(payload.usage)) {
     return payload.usage;
@@ -2368,10 +3277,6 @@ function findAnthropicUsageRecord(payload) {
   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;
@@ -2382,6 +3287,26 @@ function applyAnthropicUsageRecord(usage, usageRecord) {
   if (cachedInputTokens !== void 0) {
     usage.cachedInputTokens = cachedInputTokens;
   }
+  const cacheWriteInputTokens = readNumber(
+    usageRecord.cache_creation_input_tokens ?? usageRecord.prompt_cache_miss_tokens ?? usageRecord.cache_write_tokens
+  );
+  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 accumulateAnthropicStreamUsage(chunk, fallbackModel, state) {
   const usage = extractAnthropicUsage(chunk, fallbackModel);
@@ -2608,6 +3533,7 @@ function isIteratorResult(value) {
 exports.AnthropicPromptCompressionStats = AnthropicPromptCompressionStats;
 exports.withCompression = withCompression;
 exports.withMetering = withMetering;
+exports.withSampling = withSampling;
 exports.wrapAnthropic = wrapAnthropic;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map