@usagetap/sdk 1.3.1 → 1.4.0

package/dist/adapters/anthropic.mjs

@@ -240,6 +240,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"
@@ -254,7 +259,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
     }
@@ -750,10 +763,358 @@ 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;
+  models;
+  batches;
+  transport;
+  idempotencyGenerator;
+  constructor(config) {
+    this.transport = new ResourceTransport(
+      config.gatewayBaseUrl ?? DEFAULT_GATEWAY_BASE_URL,
+      config
+    );
+    this.idempotencyGenerator = config.idempotencyGenerator ?? createIdempotencyKey;
+    this.chat = {
+      completions: {
+        create: (params, options) => this.transport.request({
+          method: "POST",
+          path: "/v1/chat/completions",
+          body: params,
+          options,
+          response: "json"
+        })
+      }
+    };
+    this.models = {
+      list: (options) => this.transport.request({
+        method: "GET",
+        path: "/v1/models",
+        options,
+        response: "json"
+      })
+    };
+    this.batches = {
+      create: (params, options = {}) => this.transport.request({
+        method: "POST",
+        path: "/v1/batches",
+        body: params,
+        options: {
+          ...options,
+          idempotencyKey: options.idempotencyKey ?? this.idempotencyGenerator()
+        },
+        response: "json"
+      }),
+      retrieve: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.retrieve")
+        )}`,
+        options,
+        response: "json"
+      }),
+      wait: (batch, options) => this.waitForBatch(batch, options),
+      cancel: (batchId, options) => this.transport.request({
+        method: "POST",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.cancel")
+        )}/cancel`,
+        options,
+        response: "json"
+      }),
+      results: (batchId, options) => this.transport.request({
+        method: "GET",
+        path: `/v1/batches/${encodeURIComponent(
+          resourceId(batchId, ["id"], "gateway.batches.results")
+        )}/results`,
+        options,
+        response: "ndjson"
+      })
+    };
+  }
+  async waitForBatch(value, options = {}) {
+    const { pollIntervalMs, timeoutMs } = validateWaitOptions(options);
+    const deadline = Date.now() + timeoutMs;
+    let batch = typeof value === "string" ? await this.batches.retrieve(value, options) : value;
+    while (!terminalGatewayBatch(batch.status)) {
+      if (Date.now() >= deadline) {
+        throw new UsageTapError(
+          "USAGETAP_RETRY_EXHAUSTED",
+          `Gateway batch ${batch.id} did not finish before timeout`,
+          { retryable: true }
+        );
+      }
+      await sleep(pollIntervalMs, options.signal);
+      batch = await this.batches.retrieve(batch.id, options);
+    }
+    return batch;
+  }
+};
+
 // src/client.ts
 var CALL_BEGIN_PATH = "call_begin";
 var CALL_END_PATH = "call_end";
 var COMPRESS_PROMPT_PATH = "compress_prompt";
+var SAMPLES_PATH = "samples";
+var SAMPLING_SETTINGS_PATH = "sampling/settings";
+var SAMPLING_DECIDE_PATH = "sampling/decide";
 var CHECK_USAGE_PATH = "customers/{customerId}/usage";
 var CREATE_CUSTOMER_PATH = "customers";
 var CHANGE_PLAN_PATH = "customers/{customerId}/change_plan";
@@ -764,11 +1125,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.1" ;
+var DEFAULT_RUN_INACTIVITY_MS = 60 * 60 * 1e3;
+var SDK_VERSION = "1.4.0" ;
 var HAS_WINDOW = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
 var UsageTapClient = class {
+  /** OpenAI-compatible chat, model, and native batch operations. */
+  gateway;
+  /** Published-profile context summarization operations. */
+  summarization;
   apiKey;
   baseUrl;
   fetchImpl;
@@ -793,6 +1159,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;
@@ -815,10 +1186,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) : {};
@@ -840,11 +1222,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)
     };
@@ -862,6 +1355,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(
@@ -959,6 +1474,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
@@ -1000,11 +1519,17 @@ 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,
         reasoningTokens: request.reasoningTokens,
         searches: request.searches,
         audioSeconds: request.audioSeconds,
@@ -1112,6 +1637,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;
     }
@@ -1148,6 +1682,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 };
@@ -1215,17 +1754,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;
@@ -1413,7 +2021,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}`;
@@ -1614,6 +2222,82 @@ var AnthropicPromptCompressionStats = class {
   }
 };
 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 = 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);
+      }
+      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(
@@ -1624,11 +2308,13 @@ 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
   };
@@ -1642,13 +2328,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;
@@ -1663,6 +2354,7 @@ function withMetering(client, customer) {
     usageTapClient,
     applyVendorHints,
     promptCompression,
+    sampling,
     ...defaultContext
   } = config;
   const usageTap = usageTapClient ?? new UsageTapClient({ apiKey });
@@ -1670,7 +2362,8 @@ function withMetering(client, customer) {
   return wrapAnthropic(client, usageTap, {
     defaultContext,
     applyVendorHints,
-    promptCompression: normalizedCompression
+    promptCompression: normalizedCompression,
+    sampling
   });
 }
 function wrapAnthropic(client, usageTap, options = {}) {
@@ -1683,6 +2376,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,
@@ -1690,7 +2384,8 @@ function wrapAnthropic(client, usageTap, options = {}) {
     defaultContext,
     applyVendorHints,
     defaultPromptCompression,
-    promptCompressionStats
+    promptCompressionStats,
+    defaultSampling
   );
   const handler = {
     get(target, prop, receiver) {
@@ -1708,7 +2403,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");
   }
@@ -1731,7 +2426,8 @@ function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHint
       defaultContext,
       applyVendorHints,
       defaultPromptCompression,
-      promptCompressionStats
+      promptCompressionStats,
+      defaultSampling
     });
   });
   const handler = {
@@ -1745,13 +2441,26 @@ function createMessagesProxy(resource, usageTap, defaultContext, applyVendorHint
   return new Proxy(resource, handler);
 }
 async function invokeMessagesCreate(args) {
-  const beginRequest = resolveBeginRequest(args.defaultContext, args.usageContext);
+  const beginRequest = withRuntimeCompressionContext(
+    resolveBeginRequest(args.defaultContext, args.usageContext),
+    "anthropic",
+    String(args.params.model)
+  );
   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({
@@ -1764,8 +2473,10 @@ 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);
+    providerCompleted = true;
     if (isStreamingRequest(finalParams)) {
       ensureAsyncIterable(response, "messages.create");
       return wrapAnthropicStreamForUsageTap(
@@ -1777,6 +2488,15 @@ async function invokeMessagesCreate(args) {
       );
     }
     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;
   } catch (error) {
@@ -1786,24 +2506,145 @@ 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(
+  let compression = resolveEffectivePromptCompressionOptions(
     args.defaultPromptCompression,
     args.callPromptCompression
   );
+  const runtimePolicy = args.ctx.begin.data.runtimeCompressionPolicy;
+  const policyDriven = !compression && Boolean(runtimePolicy);
+  if (policyDriven && runtimePolicy) {
+    if (!runtimePolicy.selected) {
+      args.ctx.setUsage({
+        runtimeCompression: bypassedRuntimeMeasurement(runtimePolicy)
+      });
+      return args.params;
+    }
+    compression = 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,
@@ -1815,6 +2656,76 @@ 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) {
@@ -1869,6 +2780,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
     });
@@ -2253,10 +3168,16 @@ 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;
   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;
@@ -2265,6 +3186,12 @@ 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;
@@ -2280,6 +3207,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;
@@ -2343,10 +3275,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;
@@ -2356,6 +3290,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;
@@ -2366,10 +3315,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;
@@ -2380,6 +3325,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;
+  }
+  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);
@@ -2603,6 +3568,6 @@ function isIteratorResult(value) {
   return isObjectRecord(value) && "done" in value;
 }
 
-export { AnthropicPromptCompressionStats, withCompression, withMetering, wrapAnthropic };
+export { AnthropicPromptCompressionStats, withCompression, withMetering, withSampling, wrapAnthropic };
 //# sourceMappingURL=anthropic.mjs.map
 //# sourceMappingURL=anthropic.mjs.map