@usagetap/sdk 1.3.2 → 1.7.0

package/dist/index.mjs

@@ -243,6 +243,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"
@@ -257,7 +262,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
     }
@@ -753,10 +766,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";
@@ -767,11 +1139,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;
@@ -796,6 +1173,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;
@@ -818,10 +1200,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) : {};
@@ -843,11 +1236,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)
     };
@@ -865,6 +1369,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(
@@ -962,6 +1488,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
@@ -1003,14 +1533,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
@@ -1097,10 +1642,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) {
@@ -1115,6 +1660,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;
     }
@@ -1151,6 +1705,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 };
@@ -1159,6 +1718,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) => {
@@ -1166,6 +1747,10 @@ var UsageTapClient = class {
       },
       setError: (err) => {
         errorPayload = err;
+      },
+      deferFinalization: () => {
+        finalizationDeferred = true;
+        return finalize;
       }
     };
     try {
@@ -1179,24 +1764,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) {
@@ -1218,17 +1791,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;
@@ -1416,7 +2058,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}`;
@@ -1469,7 +2111,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,
@@ -1502,7 +2145,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();
@@ -1571,6 +2214,12 @@ function wrapEndCallError(error, correlationId) {
 }
 
 // src/adapters/fetch-wrapper.ts
+var USAGETAP_CONTEXT_HEADERS = [
+  "x-usagetap-customer-id",
+  "x-usagetap-feature",
+  "x-usagetap-tags",
+  "x-usagetap-run-id"
+];
 function isJsonRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1599,87 +2248,179 @@ function parseStringArray(value) {
   }
   return void 0;
 }
+function contextOverrideFromHeaders(headers) {
+  const context = {};
+  const customerId = headers.get("x-usagetap-customer-id");
+  const feature = headers.get("x-usagetap-feature");
+  const tags = headers.get("x-usagetap-tags");
+  const runId = headers.get("x-usagetap-run-id");
+  if (customerId) context.customerId = customerId;
+  if (feature) context.feature = feature;
+  if (tags) {
+    const parsed = parseStringArray(tags);
+    if (parsed) context.tags = parsed;
+  }
+  if (runId) context.runId = runId;
+  return context;
+}
+function ensureStreamUsageBody(body) {
+  const streamOptions = isJsonRecord(body.stream_options) ? body.stream_options : {};
+  return {
+    ...body,
+    stream_options: {
+      ...streamOptions,
+      include_usage: true
+    }
+  };
+}
+async function bodyTextFromInit(body) {
+  if (typeof body === "string") return body;
+  if (body instanceof URLSearchParams) return body.toString();
+  if (body instanceof Blob) return body.text();
+  if (body instanceof ArrayBuffer) return new TextDecoder().decode(body);
+  if (ArrayBuffer.isView(body)) {
+    return new TextDecoder().decode(
+      new Uint8Array(body.buffer, body.byteOffset, body.byteLength)
+    );
+  }
+  return void 0;
+}
 function wrapFetch(usageTap, options) {
   const {
     defaultContext,
     baseFetch = globalThis.fetch,
     autoIdempotency = true,
-    isOpenAIEndpoint = defaultIsOpenAIEndpoint
+    isOpenAIEndpoint = defaultIsOpenAIEndpoint,
+    provider = "openai",
+    onMeteringError,
+    strictMetering = false
   } = options;
+  const meteringFailureOptions = { onMeteringError, strictMetering };
   return async function wrappedFetch(input, init) {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
     if (!isOpenAIEndpoint(url)) {
       return baseFetch(input, init);
     }
+    const inputRequest = input instanceof Request ? input : void 0;
+    const effectiveHeaders = new Headers(inputRequest?.headers);
+    new Headers(init?.headers).forEach((value, key) => effectiveHeaders.set(key, value));
+    const vendorHeaders = new Headers(effectiveHeaders);
+    const contextOverride = contextOverrideFromHeaders(effectiveHeaders);
+    for (const header of USAGETAP_CONTEXT_HEADERS) {
+      vendorHeaders.delete(header);
+    }
     let body;
     let isStreaming = false;
-    const contextOverride = {};
     try {
-      if (init?.body && typeof init.body === "string") {
-        const parsedBody = parseJsonRecord(init.body);
-        if (!parsedBody) {
-          return baseFetch(input, init);
-        }
-        body = parsedBody;
-        isStreaming = parsedBody.stream === true;
-        const headers = new Headers(init.headers);
-        const customerIdHeader = headers.get("x-usagetap-customer-id");
-        const featureHeader = headers.get("x-usagetap-feature");
-        const tagsHeader = headers.get("x-usagetap-tags");
-        if (customerIdHeader) {
-          contextOverride.customerId = customerIdHeader;
-        }
-        if (featureHeader) {
-          contextOverride.feature = featureHeader;
-        }
-        if (tagsHeader) {
-          const tags = parseStringArray(tagsHeader);
-          if (tags) {
-            contextOverride.tags = tags;
-          }
-        }
+      if (init?.body) {
+        const bodyText = await bodyTextFromInit(init.body);
+        body = bodyText ? parseJsonRecord(bodyText) : void 0;
+      } else if (inputRequest?.body) {
+        body = parseJsonRecord(await inputRequest.clone().text());
       }
     } catch {
-      return baseFetch(input, init);
+      body = void 0;
     }
+    if (!body) {
+      const error = new Error(
+        "Unable to parse the intercepted provider request body as JSON"
+      );
+      await reportMeteringError(meteringFailureOptions, {
+        stage: "request",
+        error
+      });
+      if (strictMetering) throw error;
+      return baseFetch(input, { ...init, headers: vendorHeaders });
+    }
+    isStreaming = body.stream === true;
+    const vendorBody = isStreaming && url.includes("/v1/chat/completions") ? JSON.stringify(ensureStreamUsageBody(body)) : void 0;
     const context = {
       ...defaultContext,
       ...contextOverride,
       idempotency: autoIdempotency ? crypto.randomUUID() : void 0
     };
+    if (requestUsesWebSearch(body)) {
+      context.requested = {
+        ...context.requested ?? {},
+        search: true
+      };
+    }
     let callState;
     try {
       const beginResponse = await usageTap.beginCall(context);
       callState = {
         callId: beginResponse.data.callId,
         correlationId: beginResponse.correlationId,
-        usage: {},
-        finalized: false
+        usage: {
+          ...executionMetadataFromOpenAIRequest(body, provider),
+          ...beginResponse.data.pricingMode ? {
+            pricingMode: beginResponse.data.pricingMode,
+            batch: beginResponse.data.pricingMode === "batch"
+          } : context.pricingMode ? {
+            pricingMode: context.pricingMode,
+            batch: context.pricingMode === "batch"
+          } : typeof context.batch === "boolean" ? {
+            batch: context.batch,
+            pricingMode: context.batch ? "batch" : "standard"
+          } : {}
+        }
       };
     } catch (error) {
-      console.error("[wrapFetch] Failed to begin call:", error);
-      return baseFetch(input, init);
+      if (isUsageTapError(error) && error.code === "USAGETAP_CIRCUIT_OPEN") {
+        throw error;
+      }
+      await reportMeteringError(meteringFailureOptions, {
+        stage: "begin",
+        error
+      });
+      if (strictMetering) throw error;
+      return baseFetch(input, {
+        ...init,
+        headers: vendorHeaders,
+        ...vendorBody ? { body: vendorBody } : {}
+      });
+    }
+    if (callState.correlationId) {
+      vendorHeaders.set("x-usage-correlation-id", callState.correlationId);
     }
     const modifiedInit = {
       ...init,
-      headers: {
-        ...init?.headers,
-        "x-usage-correlation-id": callState.correlationId || ""
-      }
+      headers: vendorHeaders,
+      ...vendorBody ? { body: vendorBody } : {}
     };
     try {
       const response = await baseFetch(input, modifiedInit);
+      if (!response.ok) {
+        await finalizeHttpError(
+          response,
+          callState,
+          usageTap,
+          meteringFailureOptions
+        );
+        return response;
+      }
       if (isStreaming) {
-        return wrapStreamingResponse(response, callState, usageTap);
+        return await wrapStreamingResponse(
+          response,
+          callState,
+          usageTap,
+          meteringFailureOptions
+        );
       } else {
-        return await wrapNonStreamingResponse(response, callState, usageTap, body);
+        return await wrapNonStreamingResponse(
+          response,
+          callState,
+          usageTap,
+          body,
+          meteringFailureOptions
+        );
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      await finalizeCall(callState, usageTap, {
+      await finalizeCall(callState, usageTap, meteringFailureOptions, {
         code: "VENDOR_ERROR",
         message
-      });
+      }, { responseErrorMessage: message });
       throw error;
     }
   };
@@ -1687,137 +2428,277 @@ function wrapFetch(usageTap, options) {
 function defaultIsOpenAIEndpoint(url) {
   return url.includes("/v1/chat/completions") || url.includes("/v1/responses") || url.includes("/v1/embeddings");
 }
-async function wrapNonStreamingResponse(response, callState, usageTap, requestBody) {
+function requestUsesWebSearch(body) {
+  return Array.isArray(body?.tools) && body.tools.some((tool) => {
+    if (!isJsonRecord(tool)) return false;
+    return tool.type === "web_search" || tool.type === "web_search_preview";
+  });
+}
+function usageFromOpenAIResponse(parsed, provider) {
+  const usage = {};
+  const usageBlock = parsed.usage;
+  if (isJsonRecord(usageBlock)) {
+    const usageRecord = usageBlock;
+    const promptDetails = isJsonRecord(
+      usageRecord.prompt_tokens_details ?? usageRecord.input_tokens_details
+    ) ? usageRecord.prompt_tokens_details ?? usageRecord.input_tokens_details : void 0;
+    const completionDetails = isJsonRecord(
+      usageRecord.completion_tokens_details ?? usageRecord.output_tokens_details
+    ) ? usageRecord.completion_tokens_details ?? usageRecord.output_tokens_details : void 0;
+    const cachedTokenDetails = isJsonRecord(promptDetails?.cached_tokens_details) ? promptDetails.cached_tokens_details : void 0;
+    const cacheCreation = isJsonRecord(usageRecord.cache_creation) ? usageRecord.cache_creation : void 0;
+    const promptTokens = readNumber(
+      usageRecord.prompt_tokens ?? usageRecord.input_tokens
+    );
+    if (promptTokens !== void 0) usage.inputTokens = promptTokens;
+    const completionTokens = readNumber(
+      usageRecord.completion_tokens ?? usageRecord.output_tokens
+    );
+    if (completionTokens !== void 0) usage.responseTokens = completionTokens;
+    const cachedTokens = readNumber(
+      usageRecord.prompt_cache_hit_tokens ?? usageRecord.cache_read_input_tokens ?? usageRecord.cached_tokens ?? promptDetails?.cached_tokens
+    );
+    if (cachedTokens !== void 0) usage.cachedInputTokens = cachedTokens;
+    const cacheWriteTokens = readNumber(
+      usageRecord.cache_creation_input_tokens ?? usageRecord.cache_write_input_tokens ?? usageRecord.cache_write_tokens ?? promptDetails?.cache_write_tokens ?? promptDetails?.cache_creation_tokens
+    );
+    if (cacheWriteTokens !== void 0) {
+      usage.cacheWriteInputTokens = cacheWriteTokens;
+    }
+    const cacheWrite5m = readNumber(
+      usageRecord.cache_write_5m_input_tokens ?? cacheCreation?.ephemeral_5m_input_tokens
+    );
+    if (cacheWrite5m !== void 0) usage.cacheWrite5mInputTokens = cacheWrite5m;
+    const cacheWrite1h = readNumber(
+      usageRecord.cache_write_1h_input_tokens ?? cacheCreation?.ephemeral_1h_input_tokens
+    );
+    if (cacheWrite1h !== void 0) usage.cacheWrite1hInputTokens = cacheWrite1h;
+    if (provider?.toLowerCase() === "anthropic" && promptTokens !== void 0) {
+      usage.inputTokens = promptTokens + (cachedTokens ?? 0) + (cacheWriteTokens ?? 0);
+    }
+    const audioInputTokens = readNumber(promptDetails?.audio_tokens);
+    if (audioInputTokens !== void 0) usage.audioInputTokens = audioInputTokens;
+    const cachedAudioInputTokens = readNumber(
+      promptDetails?.cached_audio_tokens ?? cachedTokenDetails?.audio_tokens
+    );
+    if (cachedAudioInputTokens !== void 0) {
+      usage.cachedAudioInputTokens = cachedAudioInputTokens;
+    }
+    const imageInputTokens = readNumber(promptDetails?.image_tokens);
+    if (imageInputTokens !== void 0) usage.imageInputTokens = imageInputTokens;
+    const imageOutputTokens = readNumber(completionDetails?.image_tokens);
+    if (imageOutputTokens !== void 0) usage.imageOutputTokens = imageOutputTokens;
+    const audioOutputTokens = readNumber(completionDetails?.audio_tokens);
+    if (audioOutputTokens !== void 0) usage.audioOutputTokens = audioOutputTokens;
+    const reasoningTokens = readNumber(
+      usageRecord.reasoning_tokens ?? completionDetails?.reasoning_tokens
+    );
+    if (reasoningTokens !== void 0) usage.reasoningTokens = reasoningTokens;
+    const serverToolUse = isJsonRecord(usageRecord.server_tool_use) ? usageRecord.server_tool_use : void 0;
+    const outputSearches = Array.isArray(parsed.output) ? parsed.output.filter(
+      (item) => isJsonRecord(item) && item.type === "web_search_call"
+    ).length : 0;
+    const searches = readNumber(
+      usageRecord.searches ?? usageRecord.web_search_queries ?? serverToolUse?.web_search_requests ?? (outputSearches > 0 ? outputSearches : void 0)
+    );
+    if (searches !== void 0 && searches > 0) usage.searches = searches;
+  }
+  const modelFromResponse = readString(parsed.model);
+  if (modelFromResponse) usage.modelUsed = modelFromResponse;
+  const reasoning = isJsonRecord(parsed.reasoning) ? parsed.reasoning : void 0;
+  const responseEffort = normalizeReasoningEffort(reasoning?.effort);
+  if (responseEffort) {
+    usage.reasoningEffort = responseEffort;
+    usage.reasoningEffortSource = "provider_response";
+  }
+  const responseMode = readString(reasoning?.type ?? reasoning?.mode);
+  if (responseMode) usage.reasoningMode = responseMode;
+  return usage;
+}
+async function wrapNonStreamingResponse(response, callState, usageTap, requestBody, meteringFailureOptions) {
   const clonedResponse = response.clone();
   try {
     const parsed = await clonedResponse.json();
-    const usage = {};
-    if (isJsonRecord(parsed)) {
-      const usageBlock = parsed.usage;
-      if (isJsonRecord(usageBlock)) {
-        const usageRecord = usageBlock;
-        const promptDetails = isJsonRecord(usageRecord.prompt_tokens_details) ? usageRecord.prompt_tokens_details : void 0;
-        const promptTokens = readNumber(usageRecord.prompt_tokens ?? usageRecord.input_tokens);
-        if (promptTokens !== void 0) {
-          usage.inputTokens = promptTokens;
-        }
-        const completionTokens = readNumber(usageRecord.completion_tokens ?? usageRecord.output_tokens);
-        if (completionTokens !== void 0) {
-          usage.responseTokens = completionTokens;
-        }
-        const cachedTokens = readNumber(
-          usageRecord.prompt_cache_hit_tokens ?? usageRecord.cache_read_input_tokens ?? usageRecord.cached_tokens ?? promptDetails?.cached_tokens
-        );
-        if (cachedTokens !== void 0) {
-          usage.cachedInputTokens = cachedTokens;
-        }
-        const reasoningTokens = readNumber(usageRecord.reasoning_tokens);
-        if (reasoningTokens !== void 0) {
-          usage.reasoningTokens = reasoningTokens;
-        }
-      }
-      const modelFromResponse = readString(parsed.model);
-      if (modelFromResponse) {
-        usage.modelUsed = modelFromResponse;
-      }
-    }
+    const usage = isJsonRecord(parsed) ? usageFromOpenAIResponse(parsed, readString(callState.usage.providerUsed)) : {};
     if (!usage.modelUsed && requestBody) {
       const requestModel = readString(requestBody.model);
       if (requestModel) {
         usage.modelUsed = requestModel;
       }
     }
-    await finalizeCall(callState, usageTap, void 0, usage);
+    await finalizeCall(callState, usageTap, meteringFailureOptions, void 0, {
+      ...usage,
+      responseStatusCode: response.status
+    });
     return response;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    await finalizeCall(callState, usageTap, {
+    await finalizeCall(callState, usageTap, meteringFailureOptions, {
       code: "RESPONSE_PARSE_ERROR",
       message
+    }, {
+      responseStatusCode: response.status,
+      responseErrorMessage: message
     });
     return response;
   }
 }
-function wrapStreamingResponse(response, callState, usageTap) {
+async function finalizeHttpError(response, callState, usageTap, meteringFailureOptions) {
+  let message = `${response.status} ${response.statusText || "Provider request failed"}`.trim();
+  try {
+    const text = await response.clone().text();
+    const parsed = parseJsonRecord(text);
+    const errorRecord = parsed && isJsonRecord(parsed.error) ? parsed.error : void 0;
+    message = readString(errorRecord?.message) ?? readString(parsed?.message) ?? (text.trim() || message);
+  } catch {
+  }
+  await finalizeCall(callState, usageTap, meteringFailureOptions, {
+    code: "VENDOR_HTTP_ERROR",
+    message
+  }, {
+    responseStatusCode: response.status,
+    responseErrorMessage: message
+  });
+}
+async function wrapStreamingResponse(response, callState, usageTap, meteringFailureOptions) {
   if (!response.body) {
-    void finalizeCall(callState, usageTap, {
+    await finalizeCall(callState, usageTap, meteringFailureOptions, {
       code: "NO_RESPONSE_BODY",
       message: "Streaming response has no body"
+    }, {
+      responseStatusCode: response.status,
+      responseErrorMessage: "Streaming response has no body"
     });
     return response;
   }
-  const originalBody = response.body;
+  const reader = response.body.getReader();
   const accumulatedUsage = {};
   const textDecoder = new TextDecoder();
-  const transformStream = new TransformStream({
-    transform(chunk, controller) {
-      controller.enqueue(chunk);
+  let pendingSseText = "";
+  const applyUsageEvent = (eventText) => {
+    const data = eventText.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+    if (!data || data === "[DONE]") return;
+    const parsedRecord = parseJsonRecord(data);
+    if (!parsedRecord) return;
+    const responseRecord = isJsonRecord(parsedRecord.response) ? parsedRecord.response : parsedRecord;
+    Object.assign(
+      accumulatedUsage,
+      usageFromOpenAIResponse(
+        responseRecord,
+        readString(callState.usage.providerUsed)
+      )
+    );
+  };
+  const applyCompleteSseEvents = (final = false) => {
+    const events = pendingSseText.split(/\r?\n\r?\n/);
+    const tail = events.pop() ?? "";
+    pendingSseText = final ? "" : tail;
+    for (const eventText of events) applyUsageEvent(eventText);
+    if (final && tail) applyUsageEvent(tail);
+  };
+  const finalizeStream = async (error) => {
+    pendingSseText += textDecoder.decode();
+    applyCompleteSseEvents(true);
+    await finalizeCall(
+      callState,
+      usageTap,
+      meteringFailureOptions,
+      error,
+      {
+        ...accumulatedUsage,
+        responseStatusCode: response.status,
+        ...error ? { responseErrorMessage: error.message } : {}
+      }
+    );
+  };
+  const wrappedBody = new ReadableStream({
+    async pull(controller) {
       try {
-        const text = textDecoder.decode(chunk, { stream: true });
-        const lines = text.split("\n");
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6);
-            if (data === "[DONE]") continue;
-            const parsedRecord = parseJsonRecord(data);
-            if (!parsedRecord) {
-              continue;
-            }
-            const usageBlock = parsedRecord.usage;
-            if (isJsonRecord(usageBlock)) {
-              const usageRecord = usageBlock;
-              const promptDetails = isJsonRecord(usageRecord.prompt_tokens_details) ? usageRecord.prompt_tokens_details : void 0;
-              const promptTokens = readNumber(usageRecord.prompt_tokens ?? usageRecord.input_tokens);
-              if (promptTokens !== void 0) {
-                accumulatedUsage.inputTokens = promptTokens;
-              }
-              const completionTokens = readNumber(usageRecord.completion_tokens ?? usageRecord.output_tokens);
-              if (completionTokens !== void 0) {
-                accumulatedUsage.responseTokens = completionTokens;
-              }
-              const cachedTokens = readNumber(
-                usageRecord.prompt_cache_hit_tokens ?? usageRecord.cache_read_input_tokens ?? usageRecord.cached_tokens ?? promptDetails?.cached_tokens
-              );
-              if (cachedTokens !== void 0) {
-                accumulatedUsage.cachedInputTokens = cachedTokens;
-              }
-              const reasoningTokens = readNumber(usageRecord.reasoning_tokens);
-              if (reasoningTokens !== void 0) {
-                accumulatedUsage.reasoningTokens = reasoningTokens;
-              }
-            }
-            const model = readString(parsedRecord.model);
-            if (model) {
-              accumulatedUsage.modelUsed = model;
-            }
-          }
+        const result = await reader.read();
+        if (result.done) {
+          await finalizeStream();
+          controller.close();
+          return;
         }
-      } catch {
+        const chunk = result.value;
+        pendingSseText += textDecoder.decode(chunk, { stream: true });
+        applyCompleteSseEvents();
+        controller.enqueue(chunk);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await finalizeStream({ code: "VENDOR_STREAM_ERROR", message }).catch(() => void 0);
+        controller.error(error);
       }
     },
-    async flush() {
-      await finalizeCall(callState, usageTap, void 0, accumulatedUsage);
+    async cancel(reason) {
+      const message = reason instanceof Error ? reason.message : typeof reason === "string" && reason ? reason : "Provider stream consumption was cancelled before completion";
+      try {
+        await reader.cancel(reason);
+      } finally {
+        await finalizeStream({ code: "STREAM_ABORTED", message });
+      }
     }
   });
-  const wrappedBody = originalBody.pipeThrough(transformStream);
   return new Response(wrappedBody, {
     status: response.status,
     statusText: response.statusText,
     headers: response.headers
   });
 }
-async function finalizeCall(callState, usageTap, error, usage) {
-  if (callState.finalized) return;
-  callState.finalized = true;
+function normalizeReasoningEffort(value) {
+  return value === "none" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max" ? value : void 0;
+}
+function executionMetadataFromOpenAIRequest(body, provider) {
+  const reasoning = isJsonRecord(body?.reasoning) ? body.reasoning : void 0;
+  const effort = normalizeReasoningEffort(
+    body?.reasoning_effort ?? reasoning?.effort ?? body?.thinking_level
+  );
+  const mode = readString(reasoning?.type ?? reasoning?.mode);
+  const budget = readNumber(
+    reasoning?.budget_tokens ?? body?.thinking_budget ?? body?.thinking_budget_tokens
+  );
+  return {
+    providerUsed: provider,
+    ...typeof body?.model === "string" ? { modelUsed: body.model } : {},
+    ...effort ? { reasoningEffort: effort, reasoningEffortSource: "provider_request" } : {},
+    ...mode ? { reasoningMode: mode } : {},
+    ...budget !== void 0 ? { reasoningBudgetTokens: budget } : {}
+  };
+}
+async function finalizeCall(callState, usageTap, meteringFailureOptions, error, usage) {
+  if (!callState.finalizationPromise) {
+    callState.finalizationPromise = (async () => {
+      try {
+        await usageTap.endCall({
+          callId: callState.callId,
+          ...callState.usage,
+          ...usage,
+          error
+        });
+      } catch (endError) {
+        await reportMeteringError(meteringFailureOptions, {
+          stage: "end",
+          callId: callState.callId,
+          error: endError
+        });
+        if (meteringFailureOptions.strictMetering) {
+          throw endError;
+        }
+      }
+    })();
+  }
+  await callState.finalizationPromise;
+}
+async function reportMeteringError(options, event) {
+  console.error("[wrapFetch] Metering failure", {
+    stage: event.stage,
+    callId: event.callId,
+    message: event.error instanceof Error ? event.error.message : String(event.error)
+  });
   try {
-    await usageTap.endCall({
-      callId: callState.callId,
-      ...callState.usage,
-      ...usage,
-      error
-    });
-  } catch (err) {
-    console.error("[wrapFetch] Failed to finalize call:", err);
+    await options.onMeteringError?.(event);
+  } catch (callbackError) {
+    console.error("[wrapFetch] onMeteringError callback failed", callbackError);
   }
 }