@raindrop-ai/ai-sdk 0.2.0 → 0.2.1

package/dist/index.browser.mjs

@@ -1,4 +1,4 @@
-// ../core/dist/chunk-QTUH3BHZ.js
+// ../core/dist/chunk-QNWZIOOY.js
 function normalizeFeatureFlags(input) {
   if (Array.isArray(input)) {
     return Object.fromEntries(input.map((name) => [name, "true"]));
@@ -824,6 +824,193 @@ var EventShipper = class {
     }
   }
 };
+var MODEL_USAGE_ATTRIBUTES = {
+  providerName: "gen_ai.provider.name",
+  requestModel: "gen_ai.request.model",
+  responseModel: "gen_ai.response.model",
+  inputTokens: "gen_ai.usage.input_tokens",
+  outputTokens: "gen_ai.usage.output_tokens",
+  reasoningTokens: "gen_ai.usage.reasoning_tokens",
+  cacheReadInputTokens: "gen_ai.usage.cache_read_input_tokens",
+  cacheWriteInputTokens: "gen_ai.usage.cache_write_input_tokens",
+  nonCachedInputTokens: "raindrop.usage.input_tokens.non_cached",
+  nonReasoningOutputTokens: "raindrop.usage.output_tokens.non_reasoning",
+  reasoningOutputTokens: "raindrop.usage.output_tokens.reasoning",
+  cacheReadTokens: "raindrop.usage.input_tokens.cache_read",
+  cacheWriteTokens: "raindrop.usage.input_tokens.cache_write"
+};
+var MODEL_PROVIDER_NAMES = [
+  ["google.vertex", "google-vertex"],
+  ["vertex.anthropic", "google-vertex"],
+  ["amazon-bedrock", "amazon-bedrock"],
+  ["bedrock", "amazon-bedrock"],
+  ["anthropic", "anthropic"],
+  ["openai", "openai"],
+  ["google", "google"],
+  ["azure", "azure"],
+  ["openrouter", "openrouter"]
+];
+function canonicalModelProvider(provider) {
+  var _a;
+  const normalizedProvider = provider.trim().toLowerCase();
+  if (normalizedProvider === "gateway") return "vercel";
+  const match = MODEL_PROVIDER_NAMES.find(
+    ([family]) => normalizedProvider === family || normalizedProvider.startsWith(`${family}.`)
+  );
+  return (_a = match == null ? void 0 : match[1]) != null ? _a : provider;
+}
+function tokenCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function exclusiveTokens({
+  explicit,
+  total,
+  parts,
+  semantics
+}) {
+  if (explicit !== void 0) return explicit;
+  if (total === void 0) return void 0;
+  if (semantics === "exclusive") return total;
+  const observedParts = parts.filter((part) => part !== void 0 && part > 0);
+  if (semantics === void 0 && observedParts.length > 0) return void 0;
+  const exclusive = total - observedParts.reduce((sum, part) => sum + part, 0);
+  return exclusive >= 0 ? exclusive : void 0;
+}
+function buildModelUsageAttributes(usage) {
+  const inputTokens = tokenCount(usage.inputTokens);
+  const outputTokens = tokenCount(usage.outputTokens);
+  const explicitNonCachedInputTokens = tokenCount(usage.nonCachedInputTokens);
+  const explicitNonReasoningOutputTokens = tokenCount(usage.nonReasoningOutputTokens);
+  const reasoningTokens = tokenCount(usage.reasoningTokens);
+  const cacheReadInputTokens = tokenCount(usage.cacheReadInputTokens);
+  const cacheWriteInputTokens = tokenCount(usage.cacheWriteInputTokens);
+  const nonCachedInputTokens = exclusiveTokens({
+    explicit: explicitNonCachedInputTokens,
+    total: inputTokens,
+    parts: [cacheReadInputTokens, cacheWriteInputTokens],
+    semantics: usage.inputTokenSemantics
+  });
+  const nonReasoningOutputTokens = exclusiveTokens({
+    explicit: explicitNonReasoningOutputTokens,
+    total: outputTokens,
+    parts: [reasoningTokens],
+    semantics: usage.outputTokenSemantics
+  });
+  const exclusivePoolAttributes = nonCachedInputTokens !== void 0 && nonReasoningOutputTokens !== void 0 ? [
+    // backend consumes this complete raindrop.* set as one atomic billing-pool contract.
+    attrInt(MODEL_USAGE_ATTRIBUTES.nonCachedInputTokens, nonCachedInputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.nonReasoningOutputTokens, nonReasoningOutputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.reasoningOutputTokens, reasoningTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheReadTokens, cacheReadInputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheWriteTokens, cacheWriteInputTokens)
+  ] : [];
+  return [
+    attrInt(MODEL_USAGE_ATTRIBUTES.inputTokens, inputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.outputTokens, outputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.reasoningTokens, reasoningTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheReadInputTokens, cacheReadInputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheWriteInputTokens, cacheWriteInputTokens),
+    ...exclusivePoolAttributes
+  ].filter((attribute) => attribute !== void 0);
+}
+var STRING_ALIASES = {
+  [MODEL_USAGE_ATTRIBUTES.requestModel]: ["ai.model.id", "ai.model"]
+};
+var NUMBER_ALIASES = {
+  [MODEL_USAGE_ATTRIBUTES.inputTokens]: [
+    "gen_ai.usage.prompt_tokens",
+    "ai.usage.prompt_tokens",
+    "ai.usage.promptTokens",
+    "ai.usage.input_tokens",
+    "ai.usage.inputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.outputTokens]: [
+    "gen_ai.usage.completion_tokens",
+    "ai.usage.completion_tokens",
+    "ai.usage.completionTokens",
+    "ai.usage.output_tokens",
+    "ai.usage.outputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.reasoningTokens]: [
+    "gen_ai.usage.reasoning.output_tokens",
+    "ai.usage.reasoningTokens",
+    "ai.usage.thoughts_tokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.cacheReadInputTokens]: [
+    "gen_ai.usage.cache_read_tokens",
+    "gen_ai.usage.cache_read.input_tokens",
+    "ai.usage.cachedInputTokens",
+    "ai.usage.cached_tokens",
+    "ai.usage.cache_read_tokens",
+    "ai.usage.cache_read_input_tokens",
+    "ai.usage.cacheReadInputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.cacheWriteInputTokens]: [
+    "gen_ai.usage.cache_creation_input_tokens",
+    "gen_ai.usage.cache_creation.input_tokens",
+    "ai.usage.cacheWriteInputTokens",
+    "ai.usage.cache_creation_input_tokens",
+    "ai.usage.cacheCreationInputTokens"
+  ]
+};
+function hasAttribute(attributes, key) {
+  return attributes.some((attribute) => attribute.key === key);
+}
+function findStringAttribute(attributes, keys) {
+  return attributes.find(
+    (attribute) => keys.includes(attribute.key) && typeof attribute.value.stringValue === "string" && attribute.value.stringValue.length > 0
+  );
+}
+function findNumberAttribute(attributes, keys) {
+  return attributes.find((attribute) => {
+    if (!keys.includes(attribute.key)) return false;
+    if (typeof attribute.value.doubleValue === "number" && Number.isSafeInteger(attribute.value.doubleValue) && attribute.value.doubleValue >= 0) {
+      return true;
+    }
+    const intValue = attribute.value.intValue;
+    return integerValue(intValue) !== void 0;
+  });
+}
+function integerValue(value) {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+  }
+  if (typeof value !== "string") return void 0;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function appendAlias(attributes, target, source) {
+  if (!source || hasAttribute(attributes, target)) return attributes;
+  return [...attributes, { key: target, value: { ...source.value } }];
+}
+function appendProviderAlias(attributes) {
+  if (hasAttribute(attributes, MODEL_USAGE_ATTRIBUTES.providerName)) return attributes;
+  const source = findStringAttribute(attributes, ["gen_ai.system", "ai.model.provider"]);
+  if (!(source == null ? void 0 : source.value.stringValue)) return attributes;
+  const attribute = attrString(
+    MODEL_USAGE_ATTRIBUTES.providerName,
+    canonicalModelProvider(source.value.stringValue)
+  );
+  return attribute ? [...attributes, attribute] : attributes;
+}
+function normalizeModelUsageSpan(span) {
+  const original = span.attributes;
+  if (!original || original.length === 0) return span;
+  const responseModel = findStringAttribute(original, [
+    MODEL_USAGE_ATTRIBUTES.responseModel,
+    "ai.response.model"
+  ]);
+  if (!responseModel) return span;
+  let attributes = appendAlias(original, MODEL_USAGE_ATTRIBUTES.responseModel, responseModel);
+  attributes = appendProviderAlias(attributes);
+  for (const [target, aliases] of Object.entries(STRING_ALIASES)) {
+    attributes = appendAlias(attributes, target, findStringAttribute(attributes, aliases));
+  }
+  for (const [target, aliases] of Object.entries(NUMBER_ALIASES)) {
+    attributes = appendAlias(attributes, target, findNumberAttribute(attributes, aliases));
+  }
+  return attributes === original ? span : { ...span, attributes };
+}
 var DEFAULT_SECRET_KEY_NAMES = [
   "apikey",
   "apisecret",
@@ -1024,6 +1211,10 @@ var TraceShipper = class {
         return null;
       }
     }
+    try {
+      current = normalizeModelUsageSpan(current);
+    } catch (e) {
+    }
     if (!this.disableDefaultRedaction) {
       current = defaultTransformSpan(current);
     }
@@ -1357,7 +1548,7 @@ async function* asyncGeneratorWithCurrent(span, gen) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.2.0"};
+  version: "0.2.1"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -2054,6 +2245,15 @@ function attrsFromHeaders(headers) {
   if (!isRecord(headers)) return [];
   return Object.entries(headers).filter(([, v]) => typeof v === "string").map(([k, v]) => attrString(`ai.request.headers.${k}`, v));
 }
+function attrsFromModelProvider(provider) {
+  if (typeof provider !== "string" || provider.length === 0) return [];
+  const providerName = canonicalModelProvider(provider);
+  return [
+    attrString("ai.model.provider", provider),
+    attrString(MODEL_USAGE_ATTRIBUTES.providerName, providerName),
+    attrString("gen_ai.system", provider)
+  ];
+}
 function attrsFromSettings(args) {
   if (!isRecord(args)) return [];
   const result = [];
@@ -2236,6 +2436,126 @@ function runWithParentToolContext(ctx, fn) {
   return getStorage2().run(ctx, fn);
 }
 
+// src/internal/usage.ts
+function firstTokenCount(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function flatUsageSemantics(provider) {
+  const normalizedProvider = typeof provider === "string" ? provider.trim().toLowerCase() : void 0;
+  if (normalizedProvider === "anthropic" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("anthropic.")) || normalizedProvider === "vertex.anthropic" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("vertex.anthropic."))) {
+    return {
+      inputTokenSemantics: "exclusive",
+      outputTokenSemantics: "total"
+    };
+  }
+  if (normalizedProvider === "openai" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("openai.")) || normalizedProvider === "azure" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("azure."))) {
+    return {
+      inputTokenSemantics: "total",
+      outputTokenSemantics: "total"
+    };
+  }
+  if (normalizedProvider === "google" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("google."))) {
+    return {
+      inputTokenSemantics: "total",
+      // Google v5 reports candidate output and thoughts separately.
+      outputTokenSemantics: "exclusive"
+    };
+  }
+  return {};
+}
+var CACHE_WRITE_METADATA_KEYS = [
+  ["anthropic", "cacheCreationInputTokens"],
+  ["openai", "cacheWriteTokens"],
+  ["bedrock", "cacheWriteInputTokens"]
+];
+function cacheWriteTokensFromProviderMetadata(providerMetadata) {
+  if (!isRecord(providerMetadata)) return void 0;
+  return firstTokenCount(
+    ...CACHE_WRITE_METADATA_KEYS.flatMap(([namespace, key]) => {
+      const scope = providerMetadata[namespace];
+      if (!isRecord(scope)) return [];
+      const usage = scope["usage"];
+      return [scope[key], isRecord(usage) ? usage[key] : void 0];
+    })
+  );
+}
+function extractUsageMetricsFromUsage(usage, provider, providerMetadata) {
+  if (!isRecord(usage)) return {};
+  const inputTokenValue = usage["inputTokens"];
+  const outputTokenValue = usage["outputTokens"];
+  const inputTokenDetails = usage["inputTokenDetails"];
+  const outputTokenDetails = usage["outputTokenDetails"];
+  const hasStructuredUsage = isRecord(inputTokenValue) || isRecord(outputTokenValue) || isRecord(inputTokenDetails) || isRecord(outputTokenDetails);
+  const inputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["total"] : void 0,
+    inputTokenValue,
+    usage["promptTokens"],
+    usage["prompt_tokens"]
+  );
+  const outputTokens = firstTokenCount(
+    isRecord(outputTokenValue) ? outputTokenValue["total"] : void 0,
+    outputTokenValue,
+    usage["completionTokens"],
+    usage["completion_tokens"]
+  );
+  const reasoningTokens = firstTokenCount(
+    isRecord(outputTokenValue) ? outputTokenValue["reasoning"] : void 0,
+    isRecord(outputTokenDetails) ? outputTokenDetails["reasoningTokens"] : void 0,
+    usage["reasoningTokens"],
+    usage["completionReasoningTokens"],
+    usage["completion_reasoning_tokens"],
+    usage["reasoning_tokens"],
+    usage["thinkingTokens"],
+    usage["thinking_tokens"]
+  );
+  const cacheReadInputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["cacheRead"] : void 0,
+    isRecord(inputTokenDetails) ? inputTokenDetails["cacheReadTokens"] : void 0,
+    usage["cachedInputTokens"],
+    usage["promptCachedTokens"],
+    usage["prompt_cached_tokens"]
+  );
+  const cacheWriteInputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["cacheWrite"] : void 0,
+    isRecord(inputTokenDetails) ? inputTokenDetails["cacheWriteTokens"] : void 0,
+    usage["cacheWriteInputTokens"],
+    usage["cacheCreationInputTokens"],
+    usage["cache_creation_input_tokens"],
+    cacheWriteTokensFromProviderMetadata(providerMetadata)
+  );
+  const nonCachedInputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["noCache"] : void 0,
+    isRecord(inputTokenDetails) ? inputTokenDetails["noCacheTokens"] : void 0
+  );
+  const nonReasoningOutputTokens = firstTokenCount(
+    isRecord(outputTokenValue) ? outputTokenValue["text"] : void 0,
+    isRecord(outputTokenDetails) ? outputTokenDetails["textTokens"] : void 0
+  );
+  const totalTokens = firstTokenCount(
+    usage["totalTokens"],
+    usage["tokens"],
+    usage["total_tokens"],
+    inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0
+  );
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    nonCachedInputTokens,
+    nonReasoningOutputTokens,
+    reasoningTokens,
+    cacheReadInputTokens,
+    cachedInputTokens: cacheReadInputTokens,
+    cacheWriteInputTokens,
+    ...hasStructuredUsage ? {} : flatUsageSemantics(provider)
+  };
+}
+
 // src/internal/raindrop-telemetry-integration.ts
 function hasUnresolvedToolApproval(event) {
   var _a;
@@ -2405,6 +2725,8 @@ var RaindropTelemetryIntegration = class {
         rootParent: rootSpan ? this.spanParentRef(rootSpan) : rootParentOverride != null ? rootParentOverride : inheritedParent,
         stepSpan: void 0,
         stepParent: void 0,
+        stepProvider: void 0,
+        stepModelId: void 0,
         toolSpans: /* @__PURE__ */ new Map(),
         embedSpans: /* @__PURE__ */ new Map(),
         parentContextToolCallIds: /* @__PURE__ */ new Set(),
@@ -2458,15 +2780,16 @@ var RaindropTelemetryIntegration = class {
           attrString("operation.name", operationName),
           attrString("resource.name", resourceName),
           attrString("ai.telemetry.functionId", state.functionId),
-          attrString("ai.model.provider", event.provider),
+          ...attrsFromModelProvider(event.provider),
           attrString("ai.model.id", event.modelId),
-          attrString("gen_ai.system", event.provider),
-          attrString("gen_ai.request.model", event.modelId),
+          attrString(MODEL_USAGE_ATTRIBUTES.requestModel, event.modelId),
           ...inputAttrs
         ]
       });
       state.stepSpan = stepSpan;
       state.stepParent = this.spanParentRef(stepSpan);
+      state.stepProvider = event.provider;
+      state.stepModelId = event.modelId;
     };
     this.onToolExecutionStart = (event) => this.toolExecutionStart(event);
     this.onToolExecutionEnd = (event) => this.toolExecutionEnd(event);
@@ -2517,23 +2840,24 @@ var RaindropTelemetryIntegration = class {
       var _a, _b, _c, _d, _e, _f, _g, _h, _i;
       const state = this.getState(event.callId);
       if (!(state == null ? void 0 : state.stepSpan)) return;
+      const responseModelId = (_b = (_a = event.response) == null ? void 0 : _a.modelId) != null ? _b : state.stepModelId;
       const outputAttrs = [];
       if (state.recordOutputs) {
         outputAttrs.push(
           attrString("ai.response.finishReason", event.finishReason),
-          attrString("ai.response.text", capText2((_a = event.text) != null ? _a : void 0)),
-          attrString("ai.response.id", (_b = event.response) == null ? void 0 : _b.id),
-          attrString("ai.response.model", (_c = event.response) == null ? void 0 : _c.modelId),
+          attrString("ai.response.text", capText2((_c = event.text) != null ? _c : void 0)),
+          attrString("ai.response.id", (_d = event.response) == null ? void 0 : _d.id),
+          attrString("ai.response.model", responseModelId),
           attrString(
             "ai.response.timestamp",
-            ((_d = event.response) == null ? void 0 : _d.timestamp) instanceof Date ? event.response.timestamp.toISOString() : (_e = event.response) == null ? void 0 : _e.timestamp
+            ((_e = event.response) == null ? void 0 : _e.timestamp) instanceof Date ? event.response.timestamp.toISOString() : (_f = event.response) == null ? void 0 : _f.timestamp
           ),
           attrString(
             "ai.response.providerMetadata",
             event.providerMetadata ? safeJsonWithUint8(event.providerMetadata) : void 0
           )
         );
-        if (((_f = event.toolCalls) == null ? void 0 : _f.length) > 0) {
+        if (((_g = event.toolCalls) == null ? void 0 : _g.length) > 0) {
           outputAttrs.push(
             attrString(
               "ai.response.toolCalls",
@@ -2547,7 +2871,7 @@ var RaindropTelemetryIntegration = class {
             )
           );
         }
-        if (((_g = event.reasoning) == null ? void 0 : _g.length) > 0) {
+        if (((_h = event.reasoning) == null ? void 0 : _h.length) > 0) {
           const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
           if (reasoningText) {
             outputAttrs.push(attrString("ai.response.reasoning", capText2(reasoningText)));
@@ -2556,25 +2880,31 @@ var RaindropTelemetryIntegration = class {
       }
       outputAttrs.push(
         attrStringArray("gen_ai.response.finish_reasons", [event.finishReason]),
-        attrString("gen_ai.response.id", (_h = event.response) == null ? void 0 : _h.id),
-        attrString("gen_ai.response.model", (_i = event.response) == null ? void 0 : _i.modelId)
+        attrString("gen_ai.response.id", (_i = event.response) == null ? void 0 : _i.id),
+        attrString(MODEL_USAGE_ATTRIBUTES.responseModel, responseModelId)
       );
       const usage = event.usage;
       if (usage) {
+        const usageMetrics = extractUsageMetricsFromUsage(
+          usage,
+          state.stepProvider,
+          event.providerMetadata
+        );
         outputAttrs.push(
-          attrInt("ai.usage.inputTokens", usage.inputTokens),
-          attrInt("ai.usage.outputTokens", usage.outputTokens),
-          attrInt("ai.usage.totalTokens", usage.totalTokens),
-          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
-          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens),
-          attrInt("gen_ai.usage.input_tokens", usage.inputTokens),
-          attrInt("gen_ai.usage.output_tokens", usage.outputTokens)
+          attrInt("ai.usage.inputTokens", usageMetrics.inputTokens),
+          attrInt("ai.usage.outputTokens", usageMetrics.outputTokens),
+          attrInt("ai.usage.totalTokens", usageMetrics.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usageMetrics.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usageMetrics.cachedInputTokens),
+          ...buildModelUsageAttributes(usageMetrics)
         );
       }
       this.emitProviderExecutedToolSpans(event, state);
       this.traceShipper.endSpan(state.stepSpan, { attributes: outputAttrs });
       state.stepSpan = void 0;
       state.stepParent = void 0;
+      state.stepProvider = void 0;
+      state.stepModelId = void 0;
     };
     // ── onEmbedStart ────────────────────────────────────────────────────────
     this.onEmbedStart = (event) => {
@@ -2649,6 +2979,8 @@ var RaindropTelemetryIntegration = class {
       const actualError = (_a = event.error) != null ? _a : error;
       if (state.stepSpan) {
         this.traceShipper.endSpan(state.stepSpan, { error: actualError });
+        state.stepProvider = void 0;
+        state.stepModelId = void 0;
       }
       for (const embedSpan of state.embedSpans.values()) {
         this.traceShipper.endSpan(embedSpan, { error: actualError });
@@ -2692,6 +3024,8 @@ var RaindropTelemetryIntegration = class {
         this.traceShipper.endSpan(state.stepSpan, { attributes: [abortedAttr] });
         state.stepSpan = void 0;
         state.stepParent = void 0;
+        state.stepProvider = void 0;
+        state.stepModelId = void 0;
       }
       for (const embedSpan of state.embedSpans.values()) {
         this.traceShipper.endSpan(embedSpan, { attributes: [abortedAttr] });
@@ -2991,12 +3325,13 @@ var RaindropTelemetryIntegration = class {
       }
       const usage = (_d = event.totalUsage) != null ? _d : event.usage;
       if (usage) {
+        const usageMetrics = extractUsageMetricsFromUsage(usage);
         outputAttrs.push(
-          attrInt("ai.usage.inputTokens", usage.inputTokens),
-          attrInt("ai.usage.outputTokens", usage.outputTokens),
-          attrInt("ai.usage.totalTokens", usage.totalTokens),
-          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
-          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens)
+          attrInt("ai.usage.inputTokens", usageMetrics.inputTokens),
+          attrInt("ai.usage.outputTokens", usageMetrics.outputTokens),
+          attrInt("ai.usage.totalTokens", usageMetrics.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usageMetrics.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usageMetrics.cachedInputTokens)
         );
       }
       outputAttrs.push(attrInt("ai.toolCall.count", state.toolCallCount));
@@ -3449,14 +3784,6 @@ function runWithParentSpanContextSync(ctx, fn) {
 function isAsyncIterable(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
 }
-function firstFiniteNumber(...values) {
-  for (const value of values) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
-  }
-  return void 0;
-}
 function resolveUsageRecord(result) {
   if (!isRecord(result)) return void 0;
   let usage;
@@ -3472,50 +3799,7 @@ function resolveUsageRecord(result) {
   return isRecord(usage) ? usage : void 0;
 }
 function extractUsageMetrics(result) {
-  const usage = resolveUsageRecord(result);
-  if (!usage) return {};
-  const inputTokenValue = usage["inputTokens"];
-  const outputTokenValue = usage["outputTokens"];
-  const inputTokens = firstFiniteNumber(
-    isRecord(inputTokenValue) ? inputTokenValue["total"] : void 0,
-    inputTokenValue,
-    usage["promptTokens"],
-    usage["prompt_tokens"]
-  );
-  const outputTokens = firstFiniteNumber(
-    isRecord(outputTokenValue) ? outputTokenValue["total"] : void 0,
-    outputTokenValue,
-    usage["completionTokens"],
-    usage["completion_tokens"]
-  );
-  const totalTokens = firstFiniteNumber(
-    usage["totalTokens"],
-    usage["tokens"],
-    usage["total_tokens"],
-    inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0
-  );
-  const reasoningTokens = firstFiniteNumber(
-    isRecord(outputTokenValue) ? outputTokenValue["reasoning"] : void 0,
-    usage["reasoningTokens"],
-    usage["completionReasoningTokens"],
-    usage["completion_reasoning_tokens"],
-    usage["reasoning_tokens"],
-    usage["thinkingTokens"],
-    usage["thinking_tokens"]
-  );
-  const cachedInputTokens = firstFiniteNumber(
-    isRecord(inputTokenValue) ? inputTokenValue["cacheRead"] : void 0,
-    usage["cachedInputTokens"],
-    usage["promptCachedTokens"],
-    usage["prompt_cached_tokens"]
-  );
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens,
-    reasoningTokens,
-    cachedInputTokens
-  };
+  return extractUsageMetricsFromUsage(resolveUsageRecord(result));
 }
 function isObjectOperation(operation) {
   return operation === "generateObject" || operation === "streamObject";
@@ -4906,8 +5190,13 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
             ended = true;
             const msToFirstChunk = firstChunkMs !== void 0 ? firstChunkMs - startMs : void 0;
             const msToFinish = finishMs !== void 0 ? finishMs - startMs : void 0;
-            const inputTokens = extractNestedTokens(usage, "inputTokens");
-            const outputTokens = extractNestedTokens(usage, "outputTokens");
+            const usageMetrics = extractUsageMetricsFromUsage(
+              usage,
+              modelInfo.provider,
+              providerMetadata
+            );
+            const finalResponseModelId = responseModelId != null ? responseModelId : modelInfo.modelId;
+            const { inputTokens, outputTokens } = usageMetrics;
             const avgOutTokensPerSecond = msToFinish && outputTokens !== void 0 && msToFinish > 0 ? 1e3 * outputTokens / msToFinish : void 0;
             ctx.traceShipper.endSpan(span, {
               attributes: [
@@ -4919,7 +5208,7 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                     safeJsonWithUint8(toolCallsLocal.length ? toolCallsLocal : void 0)
                   ),
                   attrString("ai.response.id", responseId),
-                  attrString("ai.response.model", responseModelId),
+                  attrString("ai.response.model", finalResponseModelId),
                   attrString("ai.response.timestamp", responseTimestampIso),
                   attrString(
                     "ai.response.providerMetadata",
@@ -4930,9 +5219,8 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                 attrInt("ai.usage.outputTokens", outputTokens),
                 ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
                 attrString("gen_ai.response.id", responseId),
-                attrString("gen_ai.response.model", responseModelId),
-                attrInt("gen_ai.usage.input_tokens", inputTokens),
-                attrInt("gen_ai.usage.output_tokens", outputTokens),
+                attrString(MODEL_USAGE_ATTRIBUTES.responseModel, finalResponseModelId),
+                ...buildModelUsageAttributes(usageMetrics),
                 ...msToFirstChunk !== void 0 ? [attrInt("ai.stream.msToFirstChunk", msToFirstChunk)] : [],
                 ...msToFinish !== void 0 ? [attrInt("ai.stream.msToFinish", msToFinish)] : [],
                 ...avgOutTokensPerSecond !== void 0 ? [attrDouble("ai.stream.avgOutputTokensPerSecond", avgOutTokensPerSecond)] : [],
@@ -5038,15 +5326,14 @@ function startDoGenerateSpan(operationId, options, modelInfo, parent, ctx) {
       attrString("operation.name", operationName),
       attrString("resource.name", resourceName),
       attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
-      attrString("ai.model.provider", modelInfo.provider),
+      ...attrsFromModelProvider(modelInfo.provider),
       attrString("ai.model.id", modelInfo.modelId),
       ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [
         attrString("ai.prompt.messages", promptJson),
         attrStringArray("ai.prompt.tools", toolsJson),
         attrString("ai.prompt.toolChoice", toolChoiceJson)
       ],
-      attrString("gen_ai.system", modelInfo.provider),
-      attrString("gen_ai.request.model", modelInfo.modelId),
+      attrString(MODEL_USAGE_ATTRIBUTES.requestModel, modelInfo.modelId),
       ...attrsFromGenAiRequest(options),
       attrProviderOptions(options)
     ]
@@ -5079,8 +5366,12 @@ function endDoGenerateSpan(span, result, modelInfo, ctx) {
   } else {
     responseTimestampIso = (/* @__PURE__ */ new Date()).toISOString();
   }
-  const inputTokens = extractNestedTokens(usage, "inputTokens");
-  const outputTokens = extractNestedTokens(usage, "outputTokens");
+  const usageMetrics = extractUsageMetricsFromUsage(
+    usage,
+    modelInfo.provider,
+    providerMetadata
+  );
+  const { inputTokens, outputTokens } = usageMetrics;
   ctx.traceShipper.endSpan(span, {
     attributes: [
       ...((_a = ctx.telemetry) == null ? void 0 : _a.recordOutputs) === false ? [] : [
@@ -5099,9 +5390,8 @@ function endDoGenerateSpan(span, result, modelInfo, ctx) {
       attrInt("ai.usage.completionTokens", outputTokens),
       ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
       attrString("gen_ai.response.id", responseId),
-      attrString("gen_ai.response.model", responseModelId),
-      attrInt("gen_ai.usage.input_tokens", inputTokens),
-      attrInt("gen_ai.usage.output_tokens", outputTokens)
+      attrString(MODEL_USAGE_ATTRIBUTES.responseModel, responseModelId),
+      ...buildModelUsageAttributes(usageMetrics)
     ]
   });
 }
@@ -5122,15 +5412,14 @@ function startDoStreamSpan(operationId, options, modelInfo, parent, ctx) {
       attrString("operation.name", operationName),
       attrString("resource.name", resourceName),
       attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
-      attrString("ai.model.provider", modelInfo.provider),
+      ...attrsFromModelProvider(modelInfo.provider),
       attrString("ai.model.id", modelInfo.modelId),
       ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [
         attrString("ai.prompt.messages", promptJson),
         attrStringArray("ai.prompt.tools", toolsJson),
         attrString("ai.prompt.toolChoice", toolChoiceJson)
       ],
-      attrString("gen_ai.system", modelInfo.provider),
-      attrString("gen_ai.request.model", modelInfo.modelId),
+      attrString(MODEL_USAGE_ATTRIBUTES.requestModel, modelInfo.modelId),
       ...attrsFromGenAiRequest(options),
       attrProviderOptions(options)
     ]
@@ -5195,13 +5484,6 @@ function mergeAttachments(...groups) {
   }
   return merged.length ? merged : void 0;
 }
-function extractNestedTokens(usage, key) {
-  if (!isRecord(usage)) return void 0;
-  const val = usage[key];
-  if (typeof val === "number") return val;
-  if (isRecord(val) && typeof val["total"] === "number") return val["total"];
-  return void 0;
-}
 
 // src/index.ts
 function eventMetadata(options) {