@usagetap/sdk 1.4.0 → 1.7.0

package/dist/adapters/openrouter.mjs

@@ -1021,6 +1021,8 @@ var SummarizationResource = class {
 };
 var GatewayResource = class {
   chat;
+  /** Buffered OpenAI Responses-compatible requests. */
+  responses;
   models;
   batches;
   transport;
@@ -1042,6 +1044,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",
@@ -1127,7 +1138,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. */
@@ -1529,9 +1540,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
@@ -1618,10 +1638,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) {
@@ -1694,6 +1714,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) => {
@@ -1701,6 +1743,10 @@ var UsageTapClient = class {
       },
       setError: (err) => {
         errorPayload = err;
+      },
+      deferFinalization: () => {
+        finalizationDeferred = true;
+        return finalize;
       }
     };
     try {
@@ -1714,24 +1760,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) {
@@ -2073,7 +2107,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,
@@ -2106,7 +2141,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();
@@ -2246,25 +2281,29 @@ function createOpenAIAdapter(init) {
       const result = await usageTap.withUsage(
         params.begin,
         async (ctx) => {
+          const settle = deferUsageFinalization(ctx);
           ctx.setUsage({ providerUsed: provider });
           const { stream, onComplete } = await params.call(client, {
             hints: ctx.begin.data.vendorHints,
             begin: ctx.begin
           });
-          const wrapped = wrapStreamForUsageTap(stream, async () => {
-            if (!onComplete) return;
+          const wrapped = wrapStreamForUsageTap(stream, async (termination) => {
             try {
-              const maybeUsage = await onComplete();
-              if (maybeUsage) {
-                ctx.setUsage(maybeUsage);
+              if (termination === "complete" && onComplete) {
+                const maybeUsage = await onComplete();
+                if (maybeUsage) {
+                  ctx.setUsage(maybeUsage);
+                }
               }
             } catch (error) {
               ctx.setError({
                 code: "USAGE_FINALIZE_ERROR",
                 message: error instanceof Error ? error.message : String(error)
               });
+              await settle();
               throw error;
             }
+            await settle();
           }, ctx);
           const finalize = async () => {
             await wrapped.__usageTapFinalize?.();
@@ -2665,13 +2704,13 @@ function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHin
       withUsage,
       promptCompression
     } = splitUsageOptions(options);
-    const beginRequest = withRuntimeCompressionContext(
+    const beginRequest = responsesBeginRequest(
       resolveBeginRequest(defaultContext, usageContext),
-      "openai",
-      String(params.model)
+      params
     );
     const wantsStream = isStreamingRequest(params);
     return usageTap.withUsage(beginRequest, async (ctx) => {
+      const settle = wantsStream ? deferUsageFinalization(ctx) : void 0;
       const sampleStartedAt = Date.now();
       const sampleDecision = wantsStream ? Promise.resolve(false) : startMeteredOpenAISampleDecision({
         usageTap,
@@ -2696,12 +2735,31 @@ function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHin
         const apiPromise2 = originalCreate(finalParams, request);
         const wrappedPromise2 = transformApiPromise(apiPromise2, (rawStream) => {
           ensureAsyncIterable(rawStream, "responses.create");
-          const wrappedStream = wrapStreamForUsageTap(rawStream, async () => {
-            const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints, provider);
-            if (usage) {
-              ctx.setUsage(usage);
+          const wrappedStream = wrapStreamForUsageTap(rawStream, async (termination) => {
+            try {
+              if (termination === "complete") {
+                const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints, provider);
+                if (usage) {
+                  ctx.setUsage(usage);
+                }
+              }
+            } catch (error) {
+              ctx.setError({
+                code: "USAGE_FINALIZE_ERROR",
+                message: error instanceof Error ? error.message : String(error)
+              });
+              throw error;
+            } finally {
+              await settle?.();
             }
-          }, ctx);
+          }, ctx, (chunk) => {
+            tryInferUsageFromStreamChunk(
+              chunk,
+              ctx.begin.data.vendorHints,
+              ctx,
+              provider
+            );
+          });
           return wrappedStream;
         });
         return wrappedPromise2;
@@ -2757,13 +2815,10 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
       withUsage,
       promptCompression
     } = splitUsageOptions(options);
-    const beginRequest = withRuntimeCompressionContext(
-      resolveBeginRequest(defaultContext, usageContext),
-      "openai",
-      String(params.model)
-    );
+    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
     const wantsStream = isStreamingRequest(params);
     return usageTap.withUsage(beginRequest, async (ctx) => {
+      const settle = wantsStream ? deferUsageFinalization(ctx) : void 0;
       const sampleStartedAt = Date.now();
       const sampleDecision = wantsStream ? Promise.resolve(false) : startMeteredOpenAISampleDecision({
         usageTap,
@@ -2772,7 +2827,7 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
         input: params
       });
       const hintedParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
-      const finalParams = await compressChatParamsForCall({
+      const compressedParams = await compressChatParamsForCall({
         params: hintedParams,
         usageTap,
         ctx,
@@ -2782,18 +2837,38 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
         withUsage,
         operation: "chat.completions.create"
       });
+      const finalParams = wantsStream ? ensureOpenAIStreamUsage(compressedParams) : compressedParams;
       ctx.setUsage(openAIRequestExecutionMetadata(finalParams, provider));
       const request = attachCorrelationHeader(requestOptions, ctx.begin.correlationId);
       if (wantsStream) {
         const apiPromise2 = originalCreate(finalParams, request);
         const wrappedPromise2 = transformApiPromise(apiPromise2, (rawStream) => {
           ensureAsyncIterable(rawStream, "chat.completions.create");
-          const wrappedStream2 = wrapStreamForUsageTap(rawStream, async () => {
-            const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints, provider);
-            if (usage) {
-              ctx.setUsage(usage);
+          const wrappedStream2 = wrapStreamForUsageTap(rawStream, async (termination) => {
+            try {
+              if (termination === "complete") {
+                const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints, provider);
+                if (usage) {
+                  ctx.setUsage(usage);
+                }
+              }
+            } catch (error) {
+              ctx.setError({
+                code: "USAGE_FINALIZE_ERROR",
+                message: error instanceof Error ? error.message : String(error)
+              });
+              throw error;
+            } finally {
+              await settle?.();
             }
-          }, ctx);
+          }, ctx, (chunk) => {
+            tryInferUsageFromStreamChunk(
+              chunk,
+              ctx.begin.data.vendorHints,
+              ctx,
+              provider
+            );
+          });
           return wrappedStream2;
         });
         return wrappedPromise2;
@@ -2835,14 +2910,11 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
       withUsage,
       promptCompression
     } = splitUsageOptions(options);
-    const beginRequest = withRuntimeCompressionContext(
-      resolveBeginRequest(defaultContext, usageContext),
-      "openai",
-      String(params.model)
-    );
+    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
     return usageTap.withUsage(beginRequest, async (ctx) => {
+      const settle = deferUsageFinalization(ctx);
       const hintedParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
-      const finalParams = await compressChatParamsForCall({
+      const compressedParams = await compressChatParamsForCall({
         params: hintedParams,
         usageTap,
         ctx,
@@ -2852,21 +2924,41 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
         withUsage,
         operation: "chat.completions.stream"
       });
+      const finalParams = ensureOpenAIStreamUsage(compressedParams);
       ctx.setUsage(openAIRequestExecutionMetadata(finalParams, provider));
       const request = attachCorrelationHeader(requestOptions, ctx.begin.correlationId);
       const apiPromise = originalStream(finalParams, request);
       const wrappedPromise = transformApiPromise(apiPromise, (rawStream) => {
         ensureAsyncIterable(rawStream, "chat.completions.stream");
-        const wrappedStreamInner = wrapStreamForUsageTap(rawStream, async () => {
-          const usage = await extractUsageFromStream(
-            rawStream,
+        const wrappedStreamInner = wrapStreamForUsageTap(rawStream, async (termination) => {
+          try {
+            if (termination === "complete") {
+              const usage = await extractUsageFromStream(
+                rawStream,
+                ctx.begin.data.vendorHints,
+                provider
+              );
+              if (usage) {
+                ctx.setUsage(usage);
+              }
+            }
+          } catch (error) {
+            ctx.setError({
+              code: "USAGE_FINALIZE_ERROR",
+              message: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          } finally {
+            await settle();
+          }
+        }, ctx, (chunk) => {
+          tryInferUsageFromStreamChunk(
+            chunk,
             ctx.begin.data.vendorHints,
+            ctx,
             provider
           );
-          if (usage) {
-            ctx.setUsage(usage);
-          }
-        }, ctx);
+        });
         return wrappedStreamInner;
       });
       return wrappedPromise;
@@ -2886,70 +2978,19 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
   return new Proxy(resource, handler);
 }
 async function compressChatParamsForCall(args) {
-  let compression = resolveEffectivePromptCompressionOptions(
+  const compression = resolveEffectivePromptCompressionOptions(
     args.defaultPromptCompression,
     args.callPromptCompression
   );
-  const runtimePolicy = args.ctx.begin.data.runtimeCompressionPolicy;
-  const policyDriven = !compression && Boolean(runtimePolicy);
-  if (policyDriven && runtimePolicy) {
-    if (!runtimePolicy.selected) {
-      args.ctx.setUsage({
-        runtimeCompression: bypassedRuntimeMeasurement(runtimePolicy)
-      });
-      return args.params;
-    }
-    compression = openAIPolicyCompressionOptions(runtimePolicy);
-    if (runtimePolicy.mode === "SHADOW") {
-      const startedAt2 = Date.now();
-      void compressChatParams(
-        args.params,
-        args.usageTap,
-        compression,
-        args.withUsage?.signal
-      ).then((outcome2) => {
-        args.ctx.setUsage({
-          runtimeCompression: openAIRuntimeMeasurement({
-            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 compressChatParams(
     args.params,
     args.usageTap,
     compression,
     args.withUsage?.signal
   );
-  if (policyDriven && runtimePolicy) {
-    const runtimeMeasurement = openAIRuntimeMeasurement({
-      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,
@@ -2962,70 +3003,19 @@ async function compressChatParamsForCall(args) {
   return outcome.params;
 }
 async function compressResponsesParamsForCall(args) {
-  let compression = resolveEffectivePromptCompressionOptions(
+  const compression = resolveEffectivePromptCompressionOptions(
     args.defaultPromptCompression,
     args.callPromptCompression
   );
-  const runtimePolicy = args.ctx.begin.data.runtimeCompressionPolicy;
-  const policyDriven = !compression && Boolean(runtimePolicy);
-  if (policyDriven && runtimePolicy) {
-    if (!runtimePolicy.selected) {
-      args.ctx.setUsage({
-        runtimeCompression: bypassedRuntimeMeasurement(runtimePolicy)
-      });
-      return args.params;
-    }
-    compression = openAIPolicyCompressionOptions(runtimePolicy);
-    if (runtimePolicy.mode === "SHADOW") {
-      const startedAt2 = Date.now();
-      void compressResponsesParams(
-        args.params,
-        args.usageTap,
-        compression,
-        args.withUsage?.signal
-      ).then((outcome2) => {
-        args.ctx.setUsage({
-          runtimeCompression: openAIRuntimeMeasurement({
-            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 compressResponsesParams(
     args.params,
     args.usageTap,
     compression,
     args.withUsage?.signal
   );
-  if (policyDriven && runtimePolicy) {
-    const runtimeMeasurement = openAIRuntimeMeasurement({
-      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,
@@ -3037,79 +3027,6 @@ async function compressResponsesParamsForCall(args) {
   });
   return outcome.params;
 }
-function openAIPolicyCompressionOptions(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 openAIRuntimeMeasurement(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) {
@@ -3632,10 +3549,6 @@ function resolveBeginRequest(defaults, override) {
   }
   const tags = mergeTags(base.tags, current.tags);
   const begin = { customerId };
-  const runtimeCompressionContext = current.runtimeCompressionContext ?? base.runtimeCompressionContext;
-  if (runtimeCompressionContext) {
-    begin.runtimeCompressionContext = runtimeCompressionContext;
-  }
   const requested = current.requested ?? base.requested;
   if (requested) begin.requested = requested;
   const feature = current.feature ?? base.feature;
@@ -3656,8 +3569,6 @@ function resolveBeginRequest(defaults, override) {
   if (customerUserEmail) begin.customerUserEmail = customerUserEmail;
   const stripeCustomerId = current.stripeCustomerId ?? base.stripeCustomerId;
   if (stripeCustomerId) begin.stripeCustomerId = stripeCustomerId;
-  const holdUsd = current.holdUsd ?? base.holdUsd;
-  if (typeof holdUsd === "number") begin.holdUsd = holdUsd;
   const batch = current.batch ?? base.batch;
   if (typeof batch === "boolean") begin.batch = batch;
   const pricingMode = current.pricingMode ?? base.pricingMode;
@@ -3667,16 +3578,25 @@ function resolveBeginRequest(defaults, override) {
   }
   return begin;
 }
-function withRuntimeCompressionContext(begin, provider, model) {
+function responsesBeginRequest(begin, params) {
+  if (!responsesRequestUsesWebSearch(params)) return begin;
   return {
     ...begin,
-    runtimeCompressionContext: {
-      ...begin.runtimeCompressionContext ?? {},
-      provider,
-      model
+    requested: {
+      ...begin.requested ?? {},
+      search: true
     }
   };
 }
+function responsesRequestUsesWebSearch(params) {
+  if (!params || typeof params !== "object") return false;
+  const tools = params.tools;
+  return Array.isArray(tools) && tools.some((tool) => {
+    if (!tool || typeof tool !== "object") return false;
+    const type = tool.type;
+    return type === "web_search" || type === "web_search_preview";
+  });
+}
 function transformApiPromise(apiPromise, onResolve, onReject) {
   const resolvedPromise = Promise.resolve(apiPromise).then(onResolve, onReject);
   if (isObjectRecord(apiPromise)) {
@@ -3907,6 +3827,11 @@ function inferUsageFromResponse(response, hints, provider = "openai") {
     return void 0;
   }
   const cachedInputTokens = candidate.usage.prompt_tokens_details?.cached_tokens ?? candidate.usage.input_tokens_details?.cached_tokens ?? candidate.usage.cached_tokens;
+  const cacheWriteInputTokens = candidate.usage.prompt_tokens_details?.cache_write_tokens ?? candidate.usage.prompt_tokens_details?.cache_creation_tokens ?? candidate.usage.input_tokens_details?.cache_write_tokens ?? candidate.usage.input_tokens_details?.cache_creation_tokens ?? candidate.usage.cache_creation_input_tokens ?? candidate.usage.cache_write_input_tokens ?? candidate.usage.cache_write_tokens;
+  const cacheWrite5mInputTokens = candidate.usage.cache_write_5m_input_tokens ?? candidate.usage.cache_creation?.ephemeral_5m_input_tokens;
+  const cacheWrite1hInputTokens = candidate.usage.cache_write_1h_input_tokens ?? candidate.usage.cache_creation?.ephemeral_1h_input_tokens;
+  const outputSearches = Array.isArray(candidate.output) ? candidate.output.filter((item) => item?.type === "web_search_call").length : 0;
+  const searches = candidate.usage.searches ?? candidate.usage.web_search_queries ?? candidate.usage.server_tool_use?.web_search_requests ?? outputSearches;
   const responseEffort = normalizeExecutionReasoningEffort(
     candidate.reasoning?.effort
   );
@@ -3916,12 +3841,21 @@ function inferUsageFromResponse(response, hints, provider = "openai") {
     inputTokens: candidate.usage.prompt_tokens ?? candidate.usage.input_tokens,
     responseTokens: candidate.usage.completion_tokens ?? candidate.usage.output_tokens,
     cachedInputTokens,
+    cacheWriteInputTokens,
+    cacheWrite5mInputTokens,
+    cacheWrite1hInputTokens,
+    audioInputTokens: candidate.usage.prompt_tokens_details?.audio_tokens ?? candidate.usage.input_tokens_details?.audio_tokens,
+    cachedAudioInputTokens: candidate.usage.prompt_tokens_details?.cached_audio_tokens ?? candidate.usage.input_tokens_details?.cached_audio_tokens ?? candidate.usage.prompt_tokens_details?.cached_tokens_details?.audio_tokens ?? candidate.usage.input_tokens_details?.cached_tokens_details?.audio_tokens,
+    imageInputTokens: candidate.usage.prompt_tokens_details?.image_tokens ?? candidate.usage.input_tokens_details?.image_tokens,
+    imageOutputTokens: candidate.usage.completion_tokens_details?.image_tokens ?? candidate.usage.output_tokens_details?.image_tokens,
+    audioOutputTokens: candidate.usage.completion_tokens_details?.audio_tokens ?? candidate.usage.output_tokens_details?.audio_tokens,
     reasoningTokens: candidate.usage.completion_tokens_details?.reasoning_tokens ?? candidate.usage.output_tokens_details?.reasoning_tokens,
     ...responseEffort ? {
       reasoningEffort: responseEffort,
       reasoningEffortSource: "provider_response"
     } : {},
-    ...typeof candidate.reasoning?.type === "string" ? { reasoningMode: candidate.reasoning.type } : typeof candidate.reasoning?.mode === "string" ? { reasoningMode: candidate.reasoning.mode } : {}
+    ...typeof candidate.reasoning?.type === "string" ? { reasoningMode: candidate.reasoning.type } : typeof candidate.reasoning?.mode === "string" ? { reasoningMode: candidate.reasoning.mode } : {},
+    ...typeof searches === "number" && searches > 0 ? { searches } : {}
   };
 }
 function normalizeExecutionReasoningEffort(value) {
@@ -3938,29 +3872,64 @@ function openAIRequestExecutionMetadata(params, provider) {
   const budget = typeof rawBudget === "number" && Number.isInteger(rawBudget) && rawBudget >= 0 ? rawBudget : void 0;
   return {
     providerUsed: provider,
+    ...typeof record.model === "string" ? { modelUsed: record.model } : {},
     ...effort ? { reasoningEffort: effort, reasoningEffortSource: "provider_request" } : {},
     ...mode ? { reasoningMode: mode } : {},
     ...budget !== void 0 ? { reasoningBudgetTokens: budget } : {}
   };
 }
-function wrapStreamForUsageTap(source, finalize, ctx) {
+function tryInferUsageFromStreamChunk(chunk, hints, ctx, provider) {
+  const payload = isObjectRecord(chunk) && isObjectRecord(chunk.response) ? chunk.response : chunk;
+  const inferred = inferUsageFromResponse(payload, hints, provider);
+  if (inferred) {
+    ctx.setUsage(inferred);
+  }
+}
+function ensureOpenAIStreamUsage(params) {
+  if (!isObjectRecord(params)) {
+    return params;
+  }
+  const streamOptions = isObjectRecord(params.stream_options) ? params.stream_options : {};
+  return {
+    ...params,
+    stream_options: {
+      ...streamOptions,
+      include_usage: true
+    }
+  };
+}
+function deferUsageFinalization(ctx) {
+  return ctx.deferFinalization?.() ?? (() => Promise.resolve());
+}
+function wrapStreamForUsageTap(source, finalize, ctx, onChunk) {
   const getIterator = source[Symbol.asyncIterator];
   if (typeof getIterator !== "function") {
     throw new TypeError("Stream is not async iterable");
   }
   const iterator = getIterator.call(source);
   let completed = false;
-  const invokeFinalize = async () => {
+  const invokeFinalize = async (termination, error) => {
     if (completed) return;
     completed = true;
+    if (termination === "cancel" || termination === "manual") {
+      ctx.setError({
+        code: "STREAM_ABORTED",
+        message: termination === "cancel" ? "Provider stream consumption was cancelled before completion" : "Provider stream was finalized before completion"
+      });
+    } else if (termination === "error") {
+      ctx.setError({
+        code: "VENDOR_ERROR",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
     try {
-      await finalize();
-    } catch (error) {
+      await finalize(termination);
+    } catch (error2) {
       ctx.setError({
         code: "USAGE_FINALIZE_ERROR",
-        message: error instanceof Error ? error.message : String(error)
+        message: error2 instanceof Error ? error2.message : String(error2)
       });
-      throw error;
+      throw error2;
     }
   };
   const prototype = Object.getPrototypeOf(source) ?? Object.prototype;
@@ -3984,12 +3953,15 @@ function wrapStreamForUsageTap(source, finalize, ctx) {
     value: async (...args) => {
       try {
         const result = await iterator.next(...args);
+        if (!result.done) {
+          onChunk?.(result.value);
+        }
         if (result.done) {
-          await invokeFinalize();
+          await invokeFinalize("complete");
         }
         return result;
       } catch (error) {
-        await invokeFinalize().catch(() => void 0);
+        await invokeFinalize("error", error).catch(() => void 0);
         throw error;
       }
     },
@@ -3998,39 +3970,49 @@ function wrapStreamForUsageTap(source, finalize, ctx) {
   });
   Object.defineProperty(wrapped, "return", {
     value: async (value) => {
-      if (typeof iterator.return === "function") {
-        const rawResult = await iterator.return(value);
-        if (!isIteratorResult(rawResult)) {
-          throw new TypeError("Iterator.return() returned an invalid result");
+      try {
+        if (typeof iterator.return === "function") {
+          const rawResult = await iterator.return(value);
+          if (!isIteratorResult(rawResult)) {
+            throw new TypeError("Iterator.return() returned an invalid result");
+          }
+          await invokeFinalize("cancel");
+          return rawResult;
         }
-        await invokeFinalize();
-        return rawResult;
+        await invokeFinalize("cancel");
+        return { done: true, value };
+      } catch (error) {
+        await invokeFinalize("error", error).catch(() => void 0);
+        throw error;
       }
-      await invokeFinalize();
-      return { done: true, value };
     },
     configurable: true,
     writable: true
   });
   Object.defineProperty(wrapped, "throw", {
     value: async (error) => {
-      if (typeof iterator.throw === "function") {
-        const rawResult = await iterator.throw(error);
-        if (!isIteratorResult(rawResult)) {
-          throw new TypeError("Iterator.throw() returned an invalid result");
+      try {
+        if (typeof iterator.throw === "function") {
+          const rawResult = await iterator.throw(error);
+          if (!isIteratorResult(rawResult)) {
+            throw new TypeError("Iterator.throw() returned an invalid result");
+          }
+          await invokeFinalize("error", error);
+          return rawResult;
         }
-        await invokeFinalize();
-        return rawResult;
+        await invokeFinalize("error", error);
+        throw error;
+      } catch (thrownError) {
+        await invokeFinalize("error", thrownError).catch(() => void 0);
+        throw thrownError;
       }
-      await invokeFinalize();
-      throw error;
     },
     configurable: true,
     writable: true
   });
   Object.defineProperty(wrapped, "__usageTapFinalize", {
     value: async () => {
-      await invokeFinalize();
+      await invokeFinalize("manual");
     },
     configurable: true
   });