@usagetap/sdk 1.3.1 → 1.4.0

package/dist/express/index.mjs

@@ -174,6 +174,75 @@ async function pipeToResponse(stream, res, options = {}) {
   }
 }
 var USAGETAP_CORRELATION_HEADER = "x-usage-correlation-id";
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function serializeSamplingError(error) {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message };
+  }
+  return { message: String(error) };
+}
+function normalizeMeteredOpenAISampling(options) {
+  if (!options) return void 0;
+  if (options === true) return { provider: "openai" };
+  const { provider = "openai", ...policyFields } = options;
+  return {
+    provider,
+    policy: typeof policyFields.rate === "number" ? policyFields : void 0
+  };
+}
+function startMeteredOpenAISampleDecision({
+  usageTap,
+  sampling,
+  beginRequest,
+  input
+}) {
+  if (!sampling) return Promise.resolve(false);
+  return usageTap.shouldSampleAsync(
+    {
+      customerId: beginRequest.customerId,
+      feature: beginRequest.feature,
+      input
+    },
+    sampling.policy
+  );
+}
+async function captureMeteredOpenAISample({
+  usageTap,
+  sampling,
+  decision,
+  ctx,
+  beginRequest,
+  input,
+  response,
+  error,
+  startedAt
+}) {
+  if (!sampling) return;
+  let selected = false;
+  try {
+    selected = await decision;
+  } catch {
+    return;
+  }
+  if (!selected) return;
+  const record = isObjectRecord(response) ? response : {};
+  await usageTap.captureSample({
+    sampleId: ctx.begin.data.callId,
+    callId: ctx.begin.data.callId,
+    customerId: beginRequest.customerId,
+    feature: beginRequest.feature,
+    tags: beginRequest.tags,
+    provider: sampling.provider,
+    model: readString(record.model) ?? readString(input.model),
+    input,
+    ...response === void 0 ? {} : { output: response },
+    usage: record.usage,
+    latencyMs: Date.now() - startedAt,
+    ...error === void 0 ? {} : { error: serializeSamplingError(error) }
+  }).catch(() => void 0);
+}
 function wrapOpenAI(client, usageTap, options = {}) {
   if (!client) {
     throw new UsageTapError("USAGETAP_BAD_REQUEST", "wrapOpenAI requires an OpenAI client instance");
@@ -181,6 +250,8 @@ function wrapOpenAI(client, usageTap, options = {}) {
   const defaultContext = options.defaultContext;
   const applyVendorHints = options.applyVendorHints !== false;
   const defaultPromptCompression = normalizePromptCompressionOptions(options.promptCompression);
+  const defaultSampling = normalizeMeteredOpenAISampling(options.sampling);
+  const provider = options.provider ?? "openai";
   const promptCompressionStats = new OpenAIPromptCompressionStats();
   const proxiedChat = client.chat ? createChatProxy(
     client.chat,
@@ -188,7 +259,9 @@ function wrapOpenAI(client, usageTap, options = {}) {
     defaultContext,
     applyVendorHints,
     defaultPromptCompression,
-    promptCompressionStats
+    promptCompressionStats,
+    defaultSampling,
+    provider
   ) : void 0;
   const proxiedResponses = typeof client.responses !== "undefined" ? createResponsesProxy(
     client.responses,
@@ -196,7 +269,9 @@ function wrapOpenAI(client, usageTap, options = {}) {
     defaultContext,
     applyVendorHints,
     defaultPromptCompression,
-    promptCompressionStats
+    promptCompressionStats,
+    defaultSampling,
+    provider
   ) : void 0;
   const handler = {
     get(target, prop, receiver) {
@@ -223,14 +298,16 @@ function wrapOpenAI(client, usageTap, options = {}) {
   };
   return new Proxy(client, handler);
 }
-function createChatProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats) {
+function createChatProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats, defaultSampling, provider) {
   const completions = createChatCompletionsProxy(
     resource.completions,
     usageTap,
     defaultContext,
     applyVendorHints,
     defaultPromptCompression,
-    promptCompressionStats
+    promptCompressionStats,
+    defaultSampling,
+    provider
   );
   const handler = {
     get(target, prop, receiver) {
@@ -242,7 +319,7 @@ function createChatProxy(resource, usageTap, defaultContext, applyVendorHints, d
   };
   return new Proxy(resource, handler);
 }
-function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats) {
+function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats, defaultSampling, provider) {
   if (!resource || typeof resource !== "object") {
     return void 0;
   }
@@ -257,9 +334,20 @@ function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHin
       withUsage: withUsage2,
       promptCompression
     } = splitUsageOptions(options);
-    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
+    const beginRequest = withRuntimeCompressionContext(
+      resolveBeginRequest(defaultContext, usageContext),
+      "openai",
+      String(params.model)
+    );
     const wantsStream = isStreamingRequest(params);
     return usageTap.withUsage(beginRequest, async (ctx) => {
+      const sampleStartedAt = Date.now();
+      const sampleDecision = wantsStream ? Promise.resolve(false) : startMeteredOpenAISampleDecision({
+        usageTap,
+        sampling: defaultSampling,
+        beginRequest,
+        input: params
+      });
       const hintedParams = applyVendorHints ? applyResponsesVendorHints(params, ctx.begin.data.vendorHints) : params;
       const finalParams = await compressResponsesParamsForCall({
         params: hintedParams,
@@ -271,13 +359,14 @@ function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHin
         withUsage: withUsage2,
         operation: "responses.create"
       });
+      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, "responses.create");
           const wrappedStream = wrapStreamForUsageTap(rawStream, async () => {
-            const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints);
+            const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints, provider);
             if (usage) {
               ctx.setUsage(usage);
             }
@@ -287,9 +376,31 @@ function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHin
         return wrappedPromise2;
       }
       const apiPromise = originalCreate(finalParams, request);
-      const wrappedPromise = transformApiPromise(apiPromise, (response) => {
-        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx);
+      const wrappedPromise = transformApiPromise(apiPromise, async (response) => {
+        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx, provider);
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          response,
+          startedAt: sampleStartedAt
+        });
         return response;
+      }, async (error) => {
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          error,
+          startedAt: sampleStartedAt
+        });
+        throw error;
       });
       return wrappedPromise;
     }, withUsage2);
@@ -304,7 +415,7 @@ function createResponsesProxy(resource, usageTap, defaultContext, applyVendorHin
   };
   return new Proxy(resource, handler);
 }
-function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats) {
+function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVendorHints, defaultPromptCompression, promptCompressionStats, defaultSampling, provider) {
   const originalCreate = resource.create.bind(resource);
   const streamCandidate = resource.stream;
   const originalStream = typeof streamCandidate === "function" ? streamCandidate.bind(resource) : void 0;
@@ -315,9 +426,20 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
       withUsage: withUsage2,
       promptCompression
     } = splitUsageOptions(options);
-    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
+    const beginRequest = withRuntimeCompressionContext(
+      resolveBeginRequest(defaultContext, usageContext),
+      "openai",
+      String(params.model)
+    );
     const wantsStream = isStreamingRequest(params);
     return usageTap.withUsage(beginRequest, async (ctx) => {
+      const sampleStartedAt = Date.now();
+      const sampleDecision = wantsStream ? Promise.resolve(false) : startMeteredOpenAISampleDecision({
+        usageTap,
+        sampling: defaultSampling,
+        beginRequest,
+        input: params
+      });
       const hintedParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
       const finalParams = await compressChatParamsForCall({
         params: hintedParams,
@@ -329,13 +451,14 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
         withUsage: withUsage2,
         operation: "chat.completions.create"
       });
+      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);
+            const usage = await extractUsageFromStream(rawStream, ctx.begin.data.vendorHints, provider);
             if (usage) {
               ctx.setUsage(usage);
             }
@@ -345,9 +468,31 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
         return wrappedPromise2;
       }
       const apiPromise = originalCreate(finalParams, request);
-      const wrappedPromise = transformApiPromise(apiPromise, (response) => {
-        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx);
+      const wrappedPromise = transformApiPromise(apiPromise, async (response) => {
+        tryInferUsage(response, ctx.begin.data.vendorHints, void 0, ctx, provider);
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          response,
+          startedAt: sampleStartedAt
+        });
         return response;
+      }, async (error) => {
+        await captureMeteredOpenAISample({
+          usageTap,
+          sampling: defaultSampling,
+          decision: sampleDecision,
+          ctx,
+          beginRequest,
+          input: params,
+          error,
+          startedAt: sampleStartedAt
+        });
+        throw error;
       });
       return wrappedPromise;
     }, withUsage2);
@@ -359,7 +504,11 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
       withUsage: withUsage2,
       promptCompression
     } = splitUsageOptions(options);
-    const beginRequest = resolveBeginRequest(defaultContext, usageContext);
+    const beginRequest = withRuntimeCompressionContext(
+      resolveBeginRequest(defaultContext, usageContext),
+      "openai",
+      String(params.model)
+    );
     return usageTap.withUsage(beginRequest, async (ctx) => {
       const hintedParams = applyVendorHints ? applyChatVendorHints(params, ctx.begin.data.vendorHints) : params;
       const finalParams = await compressChatParamsForCall({
@@ -372,12 +521,17 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
         withUsage: withUsage2,
         operation: "chat.completions.stream"
       });
+      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, ctx.begin.data.vendorHints);
+          const usage = await extractUsageFromStream(
+            rawStream,
+            ctx.begin.data.vendorHints,
+            provider
+          );
           if (usage) {
             ctx.setUsage(usage);
           }
@@ -401,19 +555,70 @@ function createChatCompletionsProxy(resource, usageTap, defaultContext, applyVen
   return new Proxy(resource, handler);
 }
 async function compressChatParamsForCall(args) {
-  const compression = resolveEffectivePromptCompressionOptions(
+  let compression = resolveEffectivePromptCompressionOptions(
     args.defaultPromptCompression,
     args.callPromptCompression
   );
+  const runtimePolicy = args.ctx.begin.data.runtimeCompressionPolicy;
+  const policyDriven = !compression && Boolean(runtimePolicy);
+  if (policyDriven && runtimePolicy) {
+    if (!runtimePolicy.selected) {
+      args.ctx.setUsage({
+        runtimeCompression: bypassedRuntimeMeasurement(runtimePolicy)
+      });
+      return args.params;
+    }
+    compression = 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,
@@ -426,19 +631,70 @@ async function compressChatParamsForCall(args) {
   return outcome.params;
 }
 async function compressResponsesParamsForCall(args) {
-  const compression = resolveEffectivePromptCompressionOptions(
+  let compression = resolveEffectivePromptCompressionOptions(
     args.defaultPromptCompression,
     args.callPromptCompression
   );
+  const runtimePolicy = args.ctx.begin.data.runtimeCompressionPolicy;
+  const policyDriven = !compression && Boolean(runtimePolicy);
+  if (policyDriven && runtimePolicy) {
+    if (!runtimePolicy.selected) {
+      args.ctx.setUsage({
+        runtimeCompression: bypassedRuntimeMeasurement(runtimePolicy)
+      });
+      return args.params;
+    }
+    compression = 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,
@@ -450,6 +706,79 @@ 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) {
@@ -503,6 +832,10 @@ async function compressChatParams(params, usageTap, compression, signal) {
     const result = await usageTap.compressPromptMessages(source, {
       provider: "usagetap",
       failOpen: compression.failOpen,
+      mode: compression.mode,
+      latencyBudgetMs: compression.latencyBudgetMs,
+      compactEmptyUserMessages: compression.compactEmptyUserMessages,
+      compactDuplicateUserTextParts: compression.compactDuplicateUserTextParts,
       aggressiveness: resolveMessageEndpointAggressiveness(compression),
       signal
     });
@@ -968,23 +1301,53 @@ function resolveBeginRequest(defaults, override) {
   }
   const tags = mergeTags(base.tags, current.tags);
   const begin = { customerId };
+  const runtimeCompressionContext = current.runtimeCompressionContext ?? base.runtimeCompressionContext;
+  if (runtimeCompressionContext) {
+    begin.runtimeCompressionContext = runtimeCompressionContext;
+  }
   const requested = current.requested ?? base.requested;
   if (requested) begin.requested = requested;
   const feature = current.feature ?? base.feature;
   if (feature) begin.feature = feature;
+  const runId = current.runId ?? base.runId;
+  if (runId) begin.runId = runId;
   const idempotency = current.idempotency ?? base.idempotency;
   if (idempotency) begin.idempotency = idempotency;
   const customerName = current.customerName ?? base.customerName;
   if (customerName) begin.customerName = customerName;
   const customerEmail = current.customerEmail ?? base.customerEmail;
   if (customerEmail) begin.customerEmail = customerEmail;
+  const customerUserId = current.customerUserId ?? base.customerUserId;
+  if (customerUserId) begin.customerUserId = customerUserId;
+  const customerUserName = current.customerUserName ?? base.customerUserName;
+  if (customerUserName) begin.customerUserName = customerUserName;
+  const customerUserEmail = current.customerUserEmail ?? base.customerUserEmail;
+  if (customerUserEmail) begin.customerUserEmail = customerUserEmail;
+  const stripeCustomerId = current.stripeCustomerId ?? base.stripeCustomerId;
+  if (stripeCustomerId) begin.stripeCustomerId = stripeCustomerId;
+  const holdUsd = current.holdUsd ?? base.holdUsd;
+  if (typeof holdUsd === "number") begin.holdUsd = holdUsd;
+  const batch = current.batch ?? base.batch;
+  if (typeof batch === "boolean") begin.batch = batch;
+  const pricingMode = current.pricingMode ?? base.pricingMode;
+  if (pricingMode) begin.pricingMode = pricingMode;
   if (tags?.length) {
     begin.tags = tags;
   }
   return begin;
 }
-function transformApiPromise(apiPromise, onResolve) {
-  const resolvedPromise = Promise.resolve(apiPromise).then(onResolve);
+function withRuntimeCompressionContext(begin, provider, model) {
+  return {
+    ...begin,
+    runtimeCompressionContext: {
+      ...begin.runtimeCompressionContext ?? {},
+      provider,
+      model
+    }
+  };
+}
+function transformApiPromise(apiPromise, onResolve, onReject) {
+  const resolvedPromise = Promise.resolve(apiPromise).then(onResolve, onReject);
   if (isObjectRecord(apiPromise)) {
     const proto = Object.getPrototypeOf(apiPromise);
     if (proto) {
@@ -1119,12 +1482,12 @@ function applyResponsesVendorHints(params, hints) {
   }
   return next;
 }
-async function extractUsageFromStream(stream, hints) {
+async function extractUsageFromStream(stream, hints, provider = "openai") {
   const finalPayload = await resolveStreamFinalPayload(stream);
   if (!finalPayload) {
     return void 0;
   }
-  return inferUsageFromResponse(finalPayload, hints);
+  return inferUsageFromResponse(finalPayload, hints, provider);
 }
 async function resolveStreamFinalPayload(stream) {
   if (!stream || typeof stream !== "object") {
@@ -1197,13 +1560,13 @@ function setHeaderIfPossible(res, key, value) {
     res.setHeader(key, value);
   }
 }
-function tryInferUsage(response, hints, extractor, ctx) {
-  const inferred = inferUsageFromResponse(response, hints);
+function tryInferUsage(response, hints, extractor, ctx, provider = "openai") {
+  const inferred = inferUsageFromResponse(response, hints, provider);
   if (inferred) {
     ctx.setUsage(inferred);
   }
 }
-function inferUsageFromResponse(response, hints) {
+function inferUsageFromResponse(response, hints, provider = "openai") {
   if (!response || typeof response !== "object") {
     return void 0;
   }
@@ -1211,12 +1574,41 @@ function inferUsageFromResponse(response, hints) {
   if (!candidate.usage) {
     return void 0;
   }
-  const cachedInputTokens = candidate.usage.prompt_tokens_details?.cached_tokens ?? candidate.usage.cached_tokens;
+  const cachedInputTokens = candidate.usage.prompt_tokens_details?.cached_tokens ?? candidate.usage.input_tokens_details?.cached_tokens ?? candidate.usage.cached_tokens;
+  const responseEffort = normalizeExecutionReasoningEffort(
+    candidate.reasoning?.effort
+  );
   return {
+    providerUsed: provider,
     modelUsed: candidate.model ?? hints?.preferredModel,
-    inputTokens: candidate.usage.prompt_tokens,
-    responseTokens: candidate.usage.completion_tokens,
-    cachedInputTokens
+    inputTokens: candidate.usage.prompt_tokens ?? candidate.usage.input_tokens,
+    responseTokens: candidate.usage.completion_tokens ?? candidate.usage.output_tokens,
+    cachedInputTokens,
+    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 } : {}
+  };
+}
+function normalizeExecutionReasoningEffort(value) {
+  return value === "none" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max" ? value : void 0;
+}
+function openAIRequestExecutionMetadata(params, provider) {
+  const record = params && typeof params === "object" ? params : {};
+  const reasoning = record.reasoning && typeof record.reasoning === "object" ? record.reasoning : void 0;
+  const effort = normalizeExecutionReasoningEffort(
+    record.reasoning_effort ?? reasoning?.effort ?? record.thinking_level
+  );
+  const mode = typeof reasoning?.type === "string" ? reasoning.type : typeof reasoning?.mode === "string" ? reasoning.mode : void 0;
+  const rawBudget = reasoning?.budget_tokens ?? record.thinking_budget ?? record.thinking_budget_tokens;
+  const budget = typeof rawBudget === "number" && Number.isInteger(rawBudget) && rawBudget >= 0 ? rawBudget : void 0;
+  return {
+    providerUsed: provider,
+    ...effort ? { reasoningEffort: effort, reasoningEffortSource: "provider_request" } : {},
+    ...mode ? { reasoningMode: mode } : {},
+    ...budget !== void 0 ? { reasoningBudgetTokens: budget } : {}
   };
 }
 function wrapStreamForUsageTap(source, finalize, ctx) {