@usagetap/sdk 1.4.0 → 1.7.0

package/dist/index.cjs

@@ -1027,6 +1027,8 @@ var SummarizationResource = class {
 };
 var GatewayResource = class {
   chat;
+  /** Buffered OpenAI Responses-compatible requests. */
+  responses;
   models;
   batches;
   transport;
@@ -1048,6 +1050,15 @@ var GatewayResource = class {
         })
       }
     };
+    this.responses = {
+      create: (params, options) => this.transport.request({
+        method: "POST",
+        path: "/v1/responses",
+        body: params,
+        options,
+        response: "json"
+      })
+    };
     this.models = {
       list: (options) => this.transport.request({
         method: "GET",
@@ -1133,7 +1144,7 @@ var USER_AGENT = "UsageTapClient";
 var CANONICAL_MEDIA_TYPE2 = "application/vnd.usagetap.v1+json";
 var DEFAULT_BASE_URL = "https://api.usagetap.com";
 var DEFAULT_RUN_INACTIVITY_MS = 60 * 60 * 1e3;
-var SDK_VERSION = "1.4.0" ;
+var SDK_VERSION = "1.7.0" ;
 var HAS_WINDOW = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
 var UsageTapClient = class {
   /** OpenAI-compatible chat, model, and native batch operations. */
@@ -1535,9 +1546,18 @@ var UsageTapClient = class {
         responseTokens: request.responseTokens,
         cachedInputTokens: request.cachedInputTokens,
         cacheWriteInputTokens: request.cacheWriteInputTokens,
+        cacheWrite5mInputTokens: request.cacheWrite5mInputTokens,
+        cacheWrite1hInputTokens: request.cacheWrite1hInputTokens,
         reasoningTokens: request.reasoningTokens,
         searches: request.searches,
         audioSeconds: request.audioSeconds,
+        imageInputCount: request.imageInputCount,
+        imageInputTokens: request.imageInputTokens,
+        imageOutputCount: request.imageOutputCount,
+        imageOutputTokens: request.imageOutputTokens,
+        audioInputTokens: request.audioInputTokens,
+        cachedAudioInputTokens: request.cachedAudioInputTokens,
+        audioOutputTokens: request.audioOutputTokens,
         costUsd: response.data.costUSD
       },
       correlationId: response.correlationId
@@ -1624,10 +1644,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) {
@@ -1700,6 +1720,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) => {
@@ -1707,6 +1749,10 @@ var UsageTapClient = class {
       },
       setError: (err) => {
         errorPayload = err;
+      },
+      deferFinalization: () => {
+        finalizationDeferred = true;
+        return finalize;
       }
     };
     try {
@@ -1720,24 +1766,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) {
@@ -2079,7 +2113,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,
@@ -2112,7 +2147,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();
@@ -2181,6 +2216,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);
 }
@@ -2209,59 +2250,103 @@ 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,
-    provider = "openai"
+    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");
-        const runIdHeader = headers.get("x-usagetap-run-id");
-        if (customerIdHeader) {
-          contextOverride.customerId = customerIdHeader;
-        }
-        if (featureHeader) {
-          contextOverride.feature = featureHeader;
-        }
-        if (tagsHeader) {
-          const tags = parseStringArray(tagsHeader);
-          if (tags) {
-            contextOverride.tags = tags;
-          }
-        }
-        if (runIdHeader) {
-          contextOverride.runId = runIdHeader;
-        }
+      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);
@@ -2280,36 +2365,64 @@ function wrapFetch(usageTap, options) {
             batch: context.batch,
             pricingMode: context.batch ? "batch" : "standard"
           } : {}
-        },
-        finalized: false
+        }
       };
     } catch (error) {
       if (isUsageTapError(error) && error.code === "USAGETAP_CIRCUIT_OPEN") {
         throw error;
       }
-      console.error("[wrapFetch] Failed to begin call:", error);
-      return baseFetch(input, init);
+      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;
     }
   };
@@ -2317,137 +2430,217 @@ 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 completionDetails = isJsonRecord(
-          usageRecord.completion_tokens_details ?? usageRecord.output_tokens_details
-        ) ? usageRecord.completion_tokens_details ?? usageRecord.output_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 ?? completionDetails?.reasoning_tokens
-        );
-        if (reasoningTokens !== void 0) {
-          usage.reasoningTokens = reasoningTokens;
-        }
-      }
-      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;
-    }
+    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 completionDetails = isJsonRecord(
-                usageRecord.completion_tokens_details ?? usageRecord.output_tokens_details
-              ) ? usageRecord.completion_tokens_details ?? usageRecord.output_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 ?? completionDetails?.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,
@@ -2468,23 +2661,46 @@ function executionMetadataFromOpenAIRequest(body, provider) {
   );
   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, error, usage) {
-  if (callState.finalized) return;
-  callState.finalized = true;
+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);
   }
 }