braintrust 0.4.8 → 0.4.9

package/dist/index.js

@@ -2933,7 +2933,7 @@ var init_stream = __esm({
       /**
        * Get the underlying ReadableStream.
        *
-       * @returns The underlying ReadableStream<BraintrustStreamChunk>.
+       * @returns The underlying `ReadableStream<BraintrustStreamChunk>`.
        */
       toReadableStream() {
         return this.stream;
@@ -12815,6 +12815,11 @@ function proxyCreate(target, hooks) {
         } else {
           const event = hooks.resultToEventFunc(result);
           const span = timedSpan.span;
+          const ttft = getCurrentUnixTimestamp() - timedSpan.start;
+          if (!event.metrics) {
+            event.metrics = {};
+          }
+          event.metrics.time_to_first_token = ttft;
           span.log(event);
           span.end();
           return result;
@@ -13298,194 +13303,9 @@ var WrapperStream = class {
   }
 };
 
-// src/wrappers/ai-sdk-5/middleware.ts
-init_util();
-init_logger();
-
-// src/wrappers/anthropic-tokens-util.ts
-function finalizeAnthropicTokens(metrics2) {
-  const prompt_tokens = (metrics2.prompt_tokens || 0) + (metrics2.prompt_cached_tokens || 0) + (metrics2.prompt_cache_creation_tokens || 0);
-  return {
-    ...metrics2,
-    prompt_tokens,
-    tokens: prompt_tokens + (metrics2.completion_tokens || 0)
-  };
-}
-function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens = 0) {
-  const cacheTokens = {};
-  if (cacheReadTokens > 0) {
-    cacheTokens.prompt_cached_tokens = cacheReadTokens;
-  }
-  if (cacheCreationTokens > 0) {
-    cacheTokens.prompt_cache_creation_tokens = cacheCreationTokens;
-  }
-  return cacheTokens;
-}
-
-// src/wrappers/ai-sdk-shared/utils.ts
+// src/wrappers/ai-sdk/ai-sdk.ts
 init_logger();
-function detectProviderFromResult(result) {
-  if (!_optionalChain([result, 'optionalAccess', _157 => _157.providerMetadata])) {
-    return void 0;
-  }
-  const keys = Object.keys(result.providerMetadata);
-  return _optionalChain([keys, 'optionalAccess', _158 => _158.at, 'call', _159 => _159(0)]);
-}
-function extractModelFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _160 => _160.response, 'optionalAccess', _161 => _161.modelId])) {
-    return result.response.modelId;
-  }
-  if (_optionalChain([result, 'optionalAccess', _162 => _162.request, 'optionalAccess', _163 => _163.body, 'optionalAccess', _164 => _164.model])) {
-    return result.request.body.model;
-  }
-  return void 0;
-}
-function extractModelFromWrapGenerateCallback(model) {
-  return _optionalChain([model, 'optionalAccess', _165 => _165.modelId]);
-}
-function camelToSnake(str) {
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function extractModelParameters(params, excludeKeys) {
-  const modelParams = {};
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== void 0 && !excludeKeys.has(key)) {
-      const snakeKey = camelToSnake(key);
-      modelParams[snakeKey] = value;
-    }
-  }
-  return modelParams;
-}
-function getNumberProperty(obj, key) {
-  if (!obj || typeof obj !== "object" || !(key in obj)) {
-    return void 0;
-  }
-  const value = Reflect.get(obj, key);
-  return typeof value === "number" ? value : void 0;
-}
-function normalizeUsageMetrics(usage, provider, providerMetadata) {
-  const metrics2 = {};
-  const inputTokens = getNumberProperty(usage, "inputTokens");
-  if (inputTokens !== void 0) {
-    metrics2.prompt_tokens = inputTokens;
-  }
-  const outputTokens = getNumberProperty(usage, "outputTokens");
-  if (outputTokens !== void 0) {
-    metrics2.completion_tokens = outputTokens;
-  }
-  const totalTokens = getNumberProperty(usage, "totalTokens");
-  if (totalTokens !== void 0) {
-    metrics2.tokens = totalTokens;
-  }
-  const reasoningTokens = getNumberProperty(usage, "reasoningTokens");
-  if (reasoningTokens !== void 0) {
-    metrics2.completion_reasoning_tokens = reasoningTokens;
-  }
-  const cachedInputTokens = getNumberProperty(usage, "cachedInputTokens");
-  if (cachedInputTokens !== void 0) {
-    metrics2.prompt_cached_tokens = cachedInputTokens;
-  }
-  if (provider === "anthropic") {
-    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _166 => _166.anthropic]);
-    if (anthropicMetadata) {
-      const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
-      const cacheCreationTokens = getNumberProperty(
-        anthropicMetadata.usage,
-        "cache_creation_input_tokens"
-      ) || 0;
-      const cacheTokens = extractAnthropicCacheTokens(
-        cacheReadTokens,
-        cacheCreationTokens
-      );
-      Object.assign(metrics2, cacheTokens);
-      Object.assign(metrics2, finalizeAnthropicTokens(metrics2));
-    }
-  }
-  return metrics2;
-}
-function normalizeFinishReason(reason) {
-  if (typeof reason !== "string") return void 0;
-  return reason.replace(/-/g, "_");
-}
-function extractToolCallsFromSteps(steps) {
-  const toolCalls = [];
-  if (!Array.isArray(steps)) return toolCalls;
-  let idx = 0;
-  for (const step of steps) {
-    const blocks = _optionalChain([step, 'optionalAccess', _167 => _167.content]);
-    if (!Array.isArray(blocks)) continue;
-    for (const block of blocks) {
-      if (block && typeof block === "object" && block.type === "tool-call") {
-        toolCalls.push({
-          id: block.toolCallId,
-          type: "function",
-          index: idx++,
-          function: {
-            name: block.toolName,
-            arguments: typeof block.input === "string" ? block.input : JSON.stringify(_nullishCoalesce(block.input, () => ( {})))
-          }
-        });
-      }
-    }
-  }
-  return toolCalls;
-}
-function buildAssistantOutputWithToolCalls(result, toolCalls) {
-  return [
-    {
-      index: 0,
-      logprobs: null,
-      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _168 => _168.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
-      message: {
-        role: "assistant",
-        tool_calls: toolCalls.length > 0 ? toolCalls : void 0
-      }
-    }
-  ];
-}
-function extractToolCallsFromBlocks(blocks) {
-  if (!Array.isArray(blocks)) return [];
-  return extractToolCallsFromSteps([{ content: blocks }]);
-}
-function wrapTools(tools) {
-  if (!tools) return tools;
-  const inferName = (tool, fallback2) => tool && (tool.name || tool.toolName || tool.id) || fallback2;
-  if (Array.isArray(tools)) {
-    const arr = tools;
-    const out = arr.map((tool, idx) => {
-      if (tool != null && typeof tool === "object" && "execute" in tool && typeof tool.execute === "function") {
-        const name = inferName(tool, `tool[${idx}]`);
-        return {
-          ...tool,
-          execute: wrapTraced(tool.execute.bind(tool), {
-            name,
-            type: "tool"
-          })
-        };
-      }
-      return tool;
-    });
-    return out;
-  }
-  const wrappedTools = {};
-  for (const [key, tool] of Object.entries(tools)) {
-    if (tool != null && typeof tool === "object" && "execute" in tool && typeof tool.execute === "function") {
-      wrappedTools[key] = {
-        ...tool,
-        execute: wrapTraced(tool.execute.bind(tool), {
-          name: key,
-          type: "tool"
-        })
-      };
-    } else {
-      wrappedTools[key] = tool;
-    }
-  }
-  return wrappedTools;
-}
-function extractInput(params) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _169 => _169.prompt]), () => ( _optionalChain([params, 'optionalAccess', _170 => _170.messages]))), () => ( _optionalChain([params, 'optionalAccess', _171 => _171.system])));
-}
+init_util();
 
 // src/wrappers/attachment-utils.ts
 init_logger();
@@ -13550,7 +13370,7 @@ function processInputAttachments(input) {
     return input;
   }
   let attachmentIndex = 0;
-  const processContentPart = (part) => {
+  const processContentPart2 = (part) => {
     if (!part || typeof part !== "object") {
       return part;
     }
@@ -13598,229 +13418,825 @@ function processInputAttachments(input) {
     }
     return part;
   };
-  const processMessage = (message) => {
+  const processMessage2 = (message) => {
     if (!message || typeof message !== "object") {
       return message;
     }
     if (Array.isArray(message.content)) {
       return {
         ...message,
-        content: message.content.map(processContentPart)
+        content: message.content.map(processContentPart2)
       };
     }
     return message;
   };
   if (Array.isArray(input)) {
-    return input.map(processMessage);
+    return input.map(processMessage2);
   } else if (typeof input === "object" && input.content) {
-    return processMessage(input);
+    return processMessage2(input);
   }
   return input;
 }
 
-// src/wrappers/ai-sdk-5/middleware.ts
-var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
-  "prompt",
-  // Already captured as input
-  "system",
-  // Already captured as input
-  "messages",
-  // Already captured as input
-  "model",
-  // Already captured in metadata.model
-  "providerOptions"
-  // Internal AI SDK configuration
-]);
-function BraintrustMiddleware(config = {}) {
-  return {
-    wrapGenerate: async ({
-      doGenerate,
-      params,
-      model: modelFromWrapGenerate
-    }) => {
-      const rawInput = extractInput(params);
-      const processedInput = processInputAttachments(rawInput);
-      const spanArgs = {
-        name: _optionalChain([config, 'access', _172 => _172.spanInfo, 'optionalAccess', _173 => _173.name]) || "ai-sdk.doGenerate",
+// src/wrappers/ai-sdk/ai-sdk.ts
+var _zodtojsonschema = require('zod-to-json-schema');
+var DENY_OUTPUT_PATHS = [
+  // v3
+  "roundtrips[].request.body",
+  "roundtrips[].response.headers",
+  "rawResponse.headers",
+  "responseMessages",
+  // v5
+  "request.body",
+  "response.body",
+  "response.headers",
+  "steps[].request.body",
+  "steps[].response.body",
+  "steps[].response.headers"
+];
+function wrapAISDK(aiSDK, options = {}) {
+  return new Proxy(aiSDK, {
+    get(target, prop, receiver) {
+      const original = Reflect.get(target, prop, receiver);
+      switch (prop) {
+        case "generateText":
+          return wrapGenerateText(original, options);
+        case "streamText":
+          return wrapStreamText(original, options);
+        case "generateObject":
+          return wrapGenerateObject(original, options);
+        case "streamObject":
+          return wrapStreamObject(original, options);
+      }
+      return original;
+    }
+  });
+}
+var wrapGenerateText = (generateText, options = {}) => {
+  return async function wrappedGenerateText(params) {
+    return traced(
+      async (span) => {
+        const result = await generateText({
+          ...params,
+          tools: wrapTools(params.tools)
+        });
+        span.log({
+          output: await processOutput(result, options.denyOutputPaths),
+          metrics: extractTokenMetrics(result)
+        });
+        return result;
+      },
+      {
+        name: "generateText",
         spanAttributes: {
-          type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _174 => _174.spanInfo, 'optionalAccess', _175 => _175.spanAttributes]) || {}
+          type: "llm" /* LLM */
         },
         event: {
-          input: processedInput,
+          input: processInputAttachments2(params),
           metadata: {
-            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _176 => _176.spanInfo, 'optionalAccess', _177 => _177.metadata]) || {}
-          }
-        }
-      };
-      const span = startSpan(spanArgs);
-      try {
-        const result = await doGenerate();
-        const metadata = {};
-        const provider = detectProviderFromResult(result);
-        if (provider !== void 0) {
-          metadata.provider = provider;
-        }
-        if (result.finishReason !== void 0) {
-          metadata.finish_reason = result.finishReason;
-        }
-        const model = extractModelFromResult(result);
-        if (model !== void 0) {
-          metadata.model = model;
-        } else if (modelFromWrapGenerate) {
-          const modelId = extractModelFromWrapGenerateCallback(
-            modelFromWrapGenerate
-          );
-          if (modelId) {
-            metadata.model = modelId;
+            model: serializeModel(params.model),
+            braintrust: {
+              integration_name: "ai-sdk",
+              sdk_language: "typescript"
+            }
           }
         }
-        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _178 => _178.steps]));
-        if (!toolCalls || toolCalls.length === 0) {
-          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _179 => _179.content]));
-        }
+      }
+    );
+  };
+};
+var wrapGenerateObject = (generateObject, options = {}) => {
+  return async function wrappedGenerateObject(params) {
+    return traced(
+      async (span) => {
+        const result = await generateObject({
+          ...params,
+          tools: wrapTools(params.tools)
+        });
         span.log({
-          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _180 => _180.content]),
-          metadata,
-          metrics: normalizeUsageMetrics(
-            result.usage,
-            provider,
-            result.providerMetadata
-          )
+          output: processOutput(result, options.denyOutputPaths),
+          metrics: extractTokenMetrics(result)
         });
         return result;
-      } catch (error2) {
-        span.log({
-          error: error2 instanceof Error ? error2.message : String(error2)
-        });
-        throw error2;
-      } finally {
-        span.end();
-      }
-    },
-    wrapStream: async ({ doStream, params }) => {
-      const rawInput = extractInput(params);
-      const processedInput = processInputAttachments(rawInput);
-      const spanArgs = {
-        name: _optionalChain([config, 'access', _181 => _181.spanInfo, 'optionalAccess', _182 => _182.name]) || "ai-sdk.doStream",
+      },
+      {
+        name: "generateObject",
         spanAttributes: {
-          type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _183 => _183.spanInfo, 'optionalAccess', _184 => _184.spanAttributes]) || {}
+          type: "llm" /* LLM */
         },
         event: {
-          input: processedInput,
+          input: processInputAttachments2(params),
           metadata: {
-            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _185 => _185.spanInfo, 'optionalAccess', _186 => _186.metadata]) || {}
+            model: serializeModel(params.model),
+            braintrust: {
+              integration_name: "ai-sdk",
+              sdk_language: "typescript"
+            }
           }
         }
-      };
-      const span = startSpan(spanArgs);
-      try {
-        const { stream, ...rest } = await doStream();
-        const textChunks = [];
-        const toolBlocks = [];
-        let finalUsage = {};
-        let finalFinishReason = void 0;
-        let providerMetadata = {};
-        const transformStream = new TransformStream({
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          transform(chunk, controller) {
-            try {
-              if (chunk.type === "text-delta" && chunk.delta) {
-                textChunks.push(chunk.delta);
-              }
-              if (chunk.type === "tool-call" || chunk.type === "tool-result") {
-                toolBlocks.push(chunk);
-              }
-              if (chunk.type === "finish") {
-                finalFinishReason = chunk.finishReason;
-                finalUsage = chunk.usage || {};
-                providerMetadata = chunk.providerMetadata || {};
-              }
-              controller.enqueue(chunk);
-            } catch (error2) {
+      }
+    );
+  };
+};
+var wrapStreamText = (streamText, options = {}) => {
+  return function wrappedStreamText(params) {
+    const span = startSpan({
+      name: "streamText",
+      spanAttributes: {
+        type: "llm" /* LLM */
+      },
+      event: {
+        input: processInputAttachments2(params),
+        metadata: {
+          model: serializeModel(params.model),
+          braintrust: {
+            integration_name: "ai-sdk",
+            sdk_language: "typescript"
+          }
+        }
+      }
+    });
+    try {
+      const startTime = Date.now();
+      let receivedFirst = false;
+      const result = withCurrent(
+        span,
+        () => streamText({
+          ...params,
+          tools: wrapTools(params.tools),
+          onChunk: (chunk) => {
+            if (!receivedFirst) {
+              receivedFirst = true;
               span.log({
-                error: error2 instanceof Error ? error2.message : String(error2)
+                metrics: {
+                  time_to_first_token: (Date.now() - startTime) / 1e3
+                }
               });
-              span.end();
-              controller.error(error2);
             }
+            _optionalChain([params, 'access', _157 => _157.onChunk, 'optionalCall', _158 => _158(chunk)]);
           },
-          flush() {
-            try {
-              const generatedText = textChunks.join("");
-              let output = generatedText ? [{ type: "text", text: generatedText }] : [];
-              const resultForDetection = {
-                providerMetadata,
-                response: rest.response,
-                ...rest,
-                finishReason: finalFinishReason
-              };
-              const metadata = {};
-              const provider = detectProviderFromResult(resultForDetection);
-              if (provider !== void 0) {
-                metadata.provider = provider;
-              }
-              if (finalFinishReason !== void 0) {
-                metadata.finish_reason = finalFinishReason;
-              }
-              const model = extractModelFromResult(resultForDetection);
-              if (model !== void 0) {
-                metadata.model = model;
-              }
-              if (toolBlocks.length > 0) {
-                const toolCalls = extractToolCallsFromSteps([
-                  { content: toolBlocks }
-                ]);
-                if (toolCalls.length > 0) {
-                  output = buildAssistantOutputWithToolCalls(
-                    resultForDetection,
-                    toolCalls
-                  );
-                }
-              }
-              span.log({
-                output,
-                metadata,
-                metrics: normalizeUsageMetrics(
-                  finalUsage,
-                  provider,
-                  providerMetadata
-                )
-              });
-              span.end();
-            } catch (error2) {
+          onFinish: async (event) => {
+            _optionalChain([params, 'access', _159 => _159.onFinish, 'optionalCall', _160 => _160(event)]);
+            span.log({
+              output: await processOutput(event, options.denyOutputPaths),
+              metrics: extractTokenMetrics(event)
+            });
+            span.end();
+          },
+          onError: async (err) => {
+            _optionalChain([params, 'access', _161 => _161.onError, 'optionalCall', _162 => _162(err)]);
+            span.log({
+              error: serializeError(err)
+            });
+            span.end();
+          }
+        })
+      );
+      const trackFirstToken = () => {
+        if (!receivedFirst) {
+          receivedFirst = true;
+          span.log({
+            metrics: {
+              time_to_first_token: (Date.now() - startTime) / 1e3
+            }
+          });
+        }
+      };
+      if (result && result.baseStream) {
+        const [stream1, stream2] = result.baseStream.tee();
+        result.baseStream = stream2;
+        stream1.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              trackFirstToken();
+              controller.enqueue(chunk);
+            }
+          })
+        ).pipeTo(
+          new WritableStream({
+            write() {
+            }
+          })
+        ).catch(() => {
+        });
+      }
+      return result;
+    } catch (error2) {
+      span.log({
+        error: serializeError(error2)
+      });
+      span.end();
+      throw error2;
+    }
+  };
+};
+var wrapStreamObject = (streamObject, options = {}) => {
+  return function wrappedStreamObject(params) {
+    const span = startSpan({
+      name: "streamObject",
+      spanAttributes: {
+        type: "llm" /* LLM */
+      },
+      event: {
+        input: processInputAttachments2(params),
+        metadata: {
+          model: serializeModel(params.model),
+          braintrust: {
+            integration_name: "ai-sdk",
+            sdk_language: "typescript"
+          }
+        }
+      }
+    });
+    try {
+      const startTime = Date.now();
+      let receivedFirst = false;
+      const result = withCurrent(
+        span,
+        () => streamObject({
+          ...params,
+          tools: wrapTools(params.tools),
+          onChunk: (chunk) => {
+            if (!receivedFirst) {
+              receivedFirst = true;
               span.log({
-                error: error2 instanceof Error ? error2.message : String(error2)
+                metrics: {
+                  time_to_first_token: (Date.now() - startTime) / 1e3
+                }
               });
-              span.end();
-              throw error2;
             }
+            _optionalChain([params, 'access', _163 => _163.onChunk, 'optionalCall', _164 => _164(chunk)]);
+          },
+          onFinish: async (event) => {
+            _optionalChain([params, 'access', _165 => _165.onFinish, 'optionalCall', _166 => _166(event)]);
+            span.log({
+              output: await processOutput(event, options.denyOutputPaths),
+              metrics: extractTokenMetrics(event)
+            });
+            span.end();
+          },
+          onError: async (err) => {
+            _optionalChain([params, 'access', _167 => _167.onError, 'optionalCall', _168 => _168(err)]);
+            span.log({
+              error: serializeError(err)
+            });
+            span.end();
           }
+        })
+      );
+      const trackFirstToken = () => {
+        if (!receivedFirst) {
+          receivedFirst = true;
+          span.log({
+            metrics: {
+              time_to_first_token: (Date.now() - startTime) / 1e3
+            }
+          });
+        }
+      };
+      if (result && result.baseStream) {
+        const [stream1, stream2] = result.baseStream.tee();
+        result.baseStream = stream2;
+        stream1.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              trackFirstToken();
+              controller.enqueue(chunk);
+            }
+          })
+        ).pipeTo(
+          new WritableStream({
+            write() {
+            }
+          })
+        ).catch(() => {
         });
+      }
+      return result;
+    } catch (error2) {
+      span.log({
+        error: serializeError(error2)
+      });
+      span.end();
+      throw error2;
+    }
+  };
+};
+var wrapTools = (tools) => {
+  if (!tools) return tools;
+  const inferName = (tool, fallback2) => tool && (tool.name || tool.toolName || tool.id) || fallback2;
+  if (Array.isArray(tools)) {
+    return tools.map((tool, idx) => {
+      const name = inferName(tool, `tool[${idx}]`);
+      return wrapToolExecute(tool, name);
+    });
+  }
+  const wrappedTools = {};
+  for (const [key, tool] of Object.entries(tools)) {
+    wrappedTools[key] = wrapToolExecute(tool, key);
+  }
+  return wrappedTools;
+};
+var wrapToolExecute = (tool, name) => {
+  if (tool != null && typeof tool === "object" && "execute" in tool && typeof tool.execute === "function") {
+    const originalExecute = tool.execute;
+    return new Proxy(tool, {
+      get(target, prop) {
+        if (prop === "execute") {
+          return (...args) => traced(
+            async (span) => {
+              span.log({ input: args.length === 1 ? args[0] : args });
+              const result = await originalExecute.apply(target, args);
+              span.log({ output: result });
+              return result;
+            },
+            {
+              name,
+              spanAttributes: {
+                type: "tool" /* TOOL */
+              }
+            }
+          );
+        }
+        return target[prop];
+      },
+      // Implement additional traps for full transparency
+      has(target, prop) {
+        return prop in target;
+      },
+      ownKeys(target) {
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return Object.getOwnPropertyDescriptor(target, prop);
+      },
+      set(target, prop, value) {
+        target[prop] = value;
+        return true;
+      },
+      deleteProperty(target, prop) {
+        delete target[prop];
+        return true;
+      },
+      defineProperty(target, prop, descriptor) {
+        Object.defineProperty(target, prop, descriptor);
+        return true;
+      },
+      getPrototypeOf(target) {
+        return Object.getPrototypeOf(target);
+      },
+      setPrototypeOf(target, proto) {
+        Object.setPrototypeOf(target, proto);
+        return true;
+      },
+      isExtensible(target) {
+        return Object.isExtensible(target);
+      },
+      preventExtensions(target) {
+        Object.preventExtensions(target);
+        return true;
+      }
+    });
+  }
+  return tool;
+};
+var serializeError = (error2) => {
+  if (error2 instanceof Error) {
+    return error2;
+  }
+  if (typeof error2 === "object" && error2 !== null) {
+    try {
+      return JSON.stringify(error2);
+    } catch (e11) {
+    }
+  }
+  return String(error2);
+};
+var serializeModel = (model) => {
+  return typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _169 => _169.modelId]);
+};
+var isZodSchema = (value) => {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+};
+var serializeZodSchema = (schema) => {
+  try {
+    return _zodtojsonschema.zodToJsonSchema.call(void 0, schema);
+  } catch (e12) {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
+  }
+};
+var processTools = (tools) => {
+  if (!tools || typeof tools !== "object") return tools;
+  if (Array.isArray(tools)) {
+    return tools.map(processTool);
+  }
+  const processed = {};
+  for (const [key, tool] of Object.entries(tools)) {
+    processed[key] = processTool(tool);
+  }
+  return processed;
+};
+var processTool = (tool) => {
+  if (!tool || typeof tool !== "object") return tool;
+  const processed = { ...tool };
+  if (isZodSchema(processed.inputSchema)) {
+    processed.inputSchema = serializeZodSchema(processed.inputSchema);
+  }
+  if (isZodSchema(processed.parameters)) {
+    processed.parameters = serializeZodSchema(processed.parameters);
+  }
+  if ("execute" in processed) {
+    processed.execute = "[Function]";
+  }
+  if ("render" in processed) {
+    processed.render = "[Function]";
+  }
+  return processed;
+};
+var processInputAttachments2 = (input) => {
+  if (!input) return input;
+  const processed = { ...input };
+  if (input.messages && Array.isArray(input.messages)) {
+    processed.messages = input.messages.map(processMessage);
+  }
+  if (input.prompt && typeof input.prompt === "object" && !Array.isArray(input.prompt)) {
+    processed.prompt = processPromptContent(input.prompt);
+  }
+  if (input.tools) {
+    processed.tools = processTools(input.tools);
+  }
+  return processed;
+};
+var processMessage = (message) => {
+  if (!message || typeof message !== "object") return message;
+  if (Array.isArray(message.content)) {
+    return {
+      ...message,
+      content: message.content.map(processContentPart)
+    };
+  }
+  if (typeof message.content === "object" && message.content !== null) {
+    return {
+      ...message,
+      content: processContentPart(message.content)
+    };
+  }
+  return message;
+};
+var processPromptContent = (prompt) => {
+  if (Array.isArray(prompt)) {
+    return prompt.map(processContentPart);
+  }
+  if (prompt.content) {
+    if (Array.isArray(prompt.content)) {
+      return {
+        ...prompt,
+        content: prompt.content.map(processContentPart)
+      };
+    } else if (typeof prompt.content === "object") {
+      return {
+        ...prompt,
+        content: processContentPart(prompt.content)
+      };
+    }
+  }
+  return prompt;
+};
+var processContentPart = (part) => {
+  if (!part || typeof part !== "object") return part;
+  try {
+    if (part.type === "image" && part.image) {
+      const imageAttachment = convertImageToAttachment(
+        part.image,
+        part.mimeType || part.mediaType
+      );
+      if (imageAttachment) {
         return {
-          stream: stream.pipeThrough(transformStream),
-          ...rest
+          ...part,
+          image: imageAttachment
         };
-      } catch (error2) {
-        span.log({
-          error: error2 instanceof Error ? error2.message : String(error2)
+      }
+    }
+    if (part.type === "file" && part.data && (part.mimeType || part.mediaType)) {
+      const fileAttachment = convertDataToAttachment(
+        part.data,
+        part.mimeType || part.mediaType,
+        part.name || part.filename
+      );
+      if (fileAttachment) {
+        return {
+          ...part,
+          data: fileAttachment
+        };
+      }
+    }
+    if (part.type === "image_url" && part.image_url) {
+      if (typeof part.image_url === "object" && part.image_url.url) {
+        const imageAttachment = convertImageToAttachment(part.image_url.url);
+        if (imageAttachment) {
+          return {
+            ...part,
+            image_url: {
+              ...part.image_url,
+              url: imageAttachment
+            }
+          };
+        }
+      }
+    }
+  } catch (error2) {
+    console.warn("Error processing content part:", error2);
+  }
+  return part;
+};
+var convertImageToAttachment = (image, explicitMimeType) => {
+  try {
+    if (typeof image === "string" && image.startsWith("data:")) {
+      const [mimeTypeSection, base64Data] = image.split(",");
+      const mimeType = _optionalChain([mimeTypeSection, 'access', _170 => _170.match, 'call', _171 => _171(/data:(.*?);/), 'optionalAccess', _172 => _172[1]]);
+      if (mimeType && base64Data) {
+        const blob = convertDataToBlob(base64Data, mimeType);
+        if (blob) {
+          return new Attachment({
+            data: blob,
+            filename: `image.${getExtensionFromMediaType(mimeType)}`,
+            contentType: mimeType
+          });
+        }
+      }
+    }
+    if (explicitMimeType) {
+      if (image instanceof Uint8Array) {
+        return new Attachment({
+          data: new Blob([image], { type: explicitMimeType }),
+          filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
+          contentType: explicitMimeType
+        });
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(image)) {
+        return new Attachment({
+          data: new Blob([image], { type: explicitMimeType }),
+          filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
+          contentType: explicitMimeType
         });
-        span.end();
-        throw error2;
       }
     }
-  };
+    if (image instanceof Blob && image.type) {
+      return new Attachment({
+        data: image,
+        filename: `image.${getExtensionFromMediaType(image.type)}`,
+        contentType: image.type
+      });
+    }
+    if (image instanceof Attachment) {
+      return image;
+    }
+  } catch (error2) {
+    console.warn("Error converting image to attachment:", error2);
+  }
+  return null;
+};
+var convertDataToAttachment = (data, mimeType, filename) => {
+  if (!mimeType) return null;
+  try {
+    let blob = null;
+    if (typeof data === "string" && data.startsWith("data:")) {
+      const [, base64Data] = data.split(",");
+      if (base64Data) {
+        blob = convertDataToBlob(base64Data, mimeType);
+      }
+    } else if (typeof data === "string" && data.length > 0) {
+      blob = convertDataToBlob(data, mimeType);
+    } else if (data instanceof Uint8Array) {
+      blob = new Blob([data], { type: mimeType });
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+      blob = new Blob([data], { type: mimeType });
+    } else if (data instanceof Blob) {
+      blob = data;
+    }
+    if (blob) {
+      return new Attachment({
+        data: blob,
+        filename: filename || `file.${getExtensionFromMediaType(mimeType)}`,
+        contentType: mimeType
+      });
+    }
+  } catch (error2) {
+    console.warn("Error converting data to attachment:", error2);
+  }
+  return null;
+};
+var extractGetterValues = (obj) => {
+  const getterValues = {};
+  const getterNames = [
+    "text",
+    "finishReason",
+    "usage",
+    "toolCalls",
+    "toolResults",
+    "warnings",
+    "experimental_providerMetadata",
+    "rawResponse",
+    "response"
+  ];
+  for (const name of getterNames) {
+    try {
+      if (obj && name in obj && typeof obj[name] !== "function") {
+        getterValues[name] = obj[name];
+      }
+    } catch (e13) {
+    }
+  }
+  return getterValues;
+};
+var processOutput = async (output, denyOutputPaths) => {
+  const getterValues = extractGetterValues(output);
+  const processed = await processOutputAttachments(output);
+  const merged = { ...processed, ...getterValues };
+  return omit(merged, _nullishCoalesce(denyOutputPaths, () => ( DENY_OUTPUT_PATHS)));
+};
+var processOutputAttachments = async (output) => {
+  try {
+    return await doProcessOutputAttachments(output);
+  } catch (error2) {
+    console.error("Error processing output attachments:", error2);
+    return output;
+  }
+};
+var doProcessOutputAttachments = async (output) => {
+  if (!output || !("files" in output)) {
+    return output;
+  }
+  if (output.files && typeof output.files.then === "function") {
+    return {
+      ...output,
+      files: output.files.then(async (files) => {
+        if (!files || !Array.isArray(files) || files.length === 0) {
+          return files;
+        }
+        return files.map(convertFileToAttachment);
+      })
+    };
+  } else if (output.files && Array.isArray(output.files) && output.files.length > 0) {
+    return {
+      ...output,
+      files: output.files.map(convertFileToAttachment)
+    };
+  }
+  return output;
+};
+var convertFileToAttachment = (file, index) => {
+  try {
+    const mediaType = file.mediaType || "application/octet-stream";
+    const filename = `generated_file_${index}.${getExtensionFromMediaType(mediaType)}`;
+    let blob = null;
+    if (file.base64) {
+      blob = convertDataToBlob(file.base64, mediaType);
+    } else if (file.uint8Array) {
+      blob = new Blob([file.uint8Array], { type: mediaType });
+    }
+    if (!blob) {
+      console.warn(`Failed to convert file at index ${index} to Blob`);
+      return file;
+    }
+    return new Attachment({
+      data: blob,
+      filename,
+      contentType: mediaType
+    });
+  } catch (error2) {
+    console.warn(`Error processing file at index ${index}:`, error2);
+    return file;
+  }
+};
+function extractTokenMetrics(result) {
+  const metrics2 = {};
+  const usage = _optionalChain([result, 'optionalAccess', _173 => _173.usage]);
+  if (!usage) {
+    return metrics2;
+  }
+  if (usage.inputTokens !== void 0) {
+    metrics2.prompt_tokens = usage.inputTokens;
+  } else if (usage.promptTokens !== void 0) {
+    metrics2.prompt_tokens = usage.promptTokens;
+  } else if (usage.prompt_tokens !== void 0) {
+    metrics2.prompt_tokens = usage.prompt_tokens;
+  }
+  if (usage.outputTokens !== void 0) {
+    metrics2.completion_tokens = usage.outputTokens;
+  } else if (usage.completionTokens !== void 0) {
+    metrics2.completion_tokens = usage.completionTokens;
+  } else if (usage.completion_tokens !== void 0) {
+    metrics2.completion_tokens = usage.completion_tokens;
+  }
+  if (usage.totalTokens !== void 0) {
+    metrics2.tokens = usage.totalTokens;
+  } else if (usage.tokens !== void 0) {
+    metrics2.tokens = usage.tokens;
+  } else if (usage.total_tokens !== void 0) {
+    metrics2.tokens = usage.total_tokens;
+  }
+  if (usage.cachedInputTokens !== void 0 || usage.promptCachedTokens !== void 0 || usage.prompt_cached_tokens !== void 0) {
+    metrics2.prompt_cached_tokens = usage.cachedInputTokens || usage.promptCachedTokens || usage.prompt_cached_tokens;
+  }
+  if (usage.promptCacheCreationTokens !== void 0 || usage.prompt_cache_creation_tokens !== void 0) {
+    metrics2.prompt_cache_creation_tokens = usage.promptCacheCreationTokens || usage.prompt_cache_creation_tokens;
+  }
+  if (usage.promptReasoningTokens !== void 0 || usage.prompt_reasoning_tokens !== void 0) {
+    metrics2.prompt_reasoning_tokens = usage.promptReasoningTokens || usage.prompt_reasoning_tokens;
+  }
+  if (usage.completionCachedTokens !== void 0 || usage.completion_cached_tokens !== void 0) {
+    metrics2.completion_cached_tokens = usage.completionCachedTokens || usage.completion_cached_tokens;
+  }
+  if (usage.reasoningTokens !== void 0 || usage.completionReasoningTokens !== void 0 || usage.completion_reasoning_tokens !== void 0 || usage.reasoning_tokens !== void 0 || usage.thinkingTokens !== void 0 || usage.thinking_tokens !== void 0) {
+    const reasoningTokenCount = usage.reasoningTokens || usage.completionReasoningTokens || usage.completion_reasoning_tokens || usage.reasoning_tokens || usage.thinkingTokens || usage.thinking_tokens;
+    metrics2.completion_reasoning_tokens = reasoningTokenCount;
+    metrics2.reasoning_tokens = reasoningTokenCount;
+  }
+  if (usage.completionAudioTokens !== void 0 || usage.completion_audio_tokens !== void 0) {
+    metrics2.completion_audio_tokens = usage.completionAudioTokens || usage.completion_audio_tokens;
+  }
+  return metrics2;
 }
+var deepCopy = (obj) => {
+  return JSON.parse(JSON.stringify(obj));
+};
+var parsePath = (path3) => {
+  const keys = [];
+  let current = "";
+  for (let i = 0; i < path3.length; i++) {
+    const char = path3[i];
+    if (char === ".") {
+      if (current) {
+        keys.push(current);
+        current = "";
+      }
+    } else if (char === "[") {
+      if (current) {
+        keys.push(current);
+        current = "";
+      }
+      let bracketContent = "";
+      i++;
+      while (i < path3.length && path3[i] !== "]") {
+        bracketContent += path3[i];
+        i++;
+      }
+      if (bracketContent === "") {
+        keys.push("[]");
+      } else {
+        const index = parseInt(bracketContent, 10);
+        keys.push(isNaN(index) ? bracketContent : index);
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    keys.push(current);
+  }
+  return keys;
+};
+var omitAtPath = (obj, keys) => {
+  if (keys.length === 0) return;
+  const firstKey = keys[0];
+  const remainingKeys = keys.slice(1);
+  if (firstKey === "[]") {
+    if (Array.isArray(obj)) {
+      obj.forEach((item) => {
+        if (remainingKeys.length > 0) {
+          omitAtPath(item, remainingKeys);
+        }
+      });
+    }
+  } else if (remainingKeys.length === 0) {
+    if (obj && typeof obj === "object" && firstKey in obj) {
+      obj[firstKey] = "<omitted>";
+    }
+  } else {
+    if (obj && typeof obj === "object" && firstKey in obj) {
+      omitAtPath(obj[firstKey], remainingKeys);
+    }
+  }
+};
+var omit = (obj, paths) => {
+  const result = deepCopy(obj);
+  for (const path3 of paths) {
+    const keys = parsePath(path3);
+    omitAtPath(result, keys);
+  }
+  return result;
+};
 
-// src/wrappers/ai-sdk-4/ai-sdk.ts
+// src/wrappers/ai-sdk/deprecated/wrapAISDKModel.ts
 init_logger();
 init_util2();
 function wrapAISDKModel(model) {
   const m = model;
-  if (_optionalChain([m, 'optionalAccess', _187 => _187.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _188 => _188.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _189 => _189.modelId]) === "string") {
+  if (_optionalChain([m, 'optionalAccess', _174 => _174.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _175 => _175.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _176 => _176.modelId]) === "string") {
     return new BraintrustLanguageModelWrapper(m);
   } else {
     console.warn("Unsupported AI SDK model. Not wrapping.");
@@ -13877,10 +14293,10 @@ var BraintrustLanguageModelWrapper = class {
         metrics: {
           time_to_first_token: getCurrentUnixTimestamp() - startTime,
           tokens: !isEmpty(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: _optionalChain([ret, 'access', _190 => _190.usage, 'optionalAccess', _191 => _191.promptTokens]),
-          completion_tokens: _optionalChain([ret, 'access', _192 => _192.usage, 'optionalAccess', _193 => _193.completionTokens]),
+          prompt_tokens: _optionalChain([ret, 'access', _177 => _177.usage, 'optionalAccess', _178 => _178.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _179 => _179.usage, 'optionalAccess', _180 => _180.completionTokens]),
           cached: parseCachedHeader(
-            _nullishCoalesce(_optionalChain([ret, 'access', _194 => _194.rawResponse, 'optionalAccess', _195 => _195.headers, 'optionalAccess', _196 => _196[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _197 => _197.rawResponse, 'optionalAccess', _198 => _198.headers, 'optionalAccess', _199 => _199[LEGACY_CACHED_HEADER]])))
+            _nullishCoalesce(_optionalChain([ret, 'access', _181 => _181.rawResponse, 'optionalAccess', _182 => _182.headers, 'optionalAccess', _183 => _183[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _184 => _184.rawResponse, 'optionalAccess', _185 => _185.headers, 'optionalAccess', _186 => _186[LEGACY_CACHED_HEADER]])))
           )
         }
       });
@@ -13972,10 +14388,10 @@ var BraintrustLanguageModelWrapper = class {
                 metrics: {
                   time_to_first_token,
                   tokens: !isEmpty(usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _200 => _200.promptTokens]),
-                  completion_tokens: _optionalChain([usage, 'optionalAccess', _201 => _201.completionTokens]),
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _187 => _187.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _188 => _188.completionTokens]),
                   cached: parseCachedHeader(
-                    _nullishCoalesce(_optionalChain([ret, 'access', _202 => _202.rawResponse, 'optionalAccess', _203 => _203.headers, 'optionalAccess', _204 => _204[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _205 => _205.rawResponse, 'optionalAccess', _206 => _206.headers, 'optionalAccess', _207 => _207[LEGACY_CACHED_HEADER]])))
+                    _nullishCoalesce(_optionalChain([ret, 'access', _189 => _189.rawResponse, 'optionalAccess', _190 => _190.headers, 'optionalAccess', _191 => _191[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _192 => _192.rawResponse, 'optionalAccess', _193 => _193.headers, 'optionalAccess', _194 => _194[LEGACY_CACHED_HEADER]])))
                   )
                 }
               });
@@ -14013,16 +14429,13 @@ function postProcessPrompt(prompt) {
         const textPart = message.content.find(
           (part) => part.type === "text"
         );
-        const toolCallParts = (
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          message.content.filter(
-            (part) => part.type === "tool-call"
-          )
+        const toolCallParts = message.content.filter(
+          (part) => part.type === "tool-call"
         );
         return [
           {
             role: "assistant",
-            content: _optionalChain([textPart, 'optionalAccess', _208 => _208.text]),
+            content: _optionalChain([textPart, 'optionalAccess', _195 => _195.text]),
             ...toolCallParts.length > 0 ? {
               tool_calls: toolCallParts.map((part) => ({
                 id: part.toolCallId,
@@ -14068,34 +14481,183 @@ function postProcessPrompt(prompt) {
           content: JSON.stringify(part.result)
         }));
     }
-  });
+  });
+}
+function postProcessOutput(text, toolCalls, finishReason) {
+  return [
+    {
+      index: 0,
+      message: {
+        role: "assistant",
+        content: _nullishCoalesce(text, () => ( "")),
+        ...toolCalls && toolCalls.length > 0 ? {
+          tool_calls: toolCalls.map((toolCall) => ({
+            id: toolCall.toolCallId,
+            function: {
+              name: toolCall.toolName,
+              arguments: toolCall.args
+            },
+            type: "function"
+          }))
+        } : {}
+      },
+      finish_reason: finishReason
+    }
+  ];
+}
+
+// src/wrappers/ai-sdk/deprecated/BraintrustMiddleware.ts
+init_util();
+init_logger();
+
+// src/wrappers/anthropic-tokens-util.ts
+function finalizeAnthropicTokens(metrics2) {
+  const prompt_tokens = (metrics2.prompt_tokens || 0) + (metrics2.prompt_cached_tokens || 0) + (metrics2.prompt_cache_creation_tokens || 0);
+  return {
+    ...metrics2,
+    prompt_tokens,
+    tokens: prompt_tokens + (metrics2.completion_tokens || 0)
+  };
+}
+function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens = 0) {
+  const cacheTokens = {};
+  if (cacheReadTokens > 0) {
+    cacheTokens.prompt_cached_tokens = cacheReadTokens;
+  }
+  if (cacheCreationTokens > 0) {
+    cacheTokens.prompt_cache_creation_tokens = cacheCreationTokens;
+  }
+  return cacheTokens;
+}
+
+// src/wrappers/ai-sdk/deprecated/BraintrustMiddleware.ts
+function detectProviderFromResult(result) {
+  if (!_optionalChain([result, 'optionalAccess', _196 => _196.providerMetadata])) {
+    return void 0;
+  }
+  const keys = Object.keys(result.providerMetadata);
+  return _optionalChain([keys, 'optionalAccess', _197 => _197.at, 'call', _198 => _198(0)]);
+}
+function extractModelFromResult(result) {
+  if (_optionalChain([result, 'optionalAccess', _199 => _199.response, 'optionalAccess', _200 => _200.modelId])) {
+    return result.response.modelId;
+  }
+  if (_optionalChain([result, 'optionalAccess', _201 => _201.request, 'optionalAccess', _202 => _202.body, 'optionalAccess', _203 => _203.model])) {
+    return result.request.body.model;
+  }
+  return void 0;
+}
+function extractModelFromWrapGenerateCallback(model) {
+  return _optionalChain([model, 'optionalAccess', _204 => _204.modelId]);
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function extractModelParameters(params, excludeKeys) {
+  const modelParams = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && !excludeKeys.has(key)) {
+      const snakeKey = camelToSnake(key);
+      modelParams[snakeKey] = value;
+    }
+  }
+  return modelParams;
 }
-function postProcessOutput(text, toolCalls, finishReason) {
+function getNumberProperty(obj, key) {
+  if (!obj || typeof obj !== "object" || !(key in obj)) {
+    return void 0;
+  }
+  const value = Reflect.get(obj, key);
+  return typeof value === "number" ? value : void 0;
+}
+function normalizeUsageMetrics(usage, provider, providerMetadata) {
+  const metrics2 = {};
+  const inputTokens = getNumberProperty(usage, "inputTokens");
+  if (inputTokens !== void 0) {
+    metrics2.prompt_tokens = inputTokens;
+  }
+  const outputTokens = getNumberProperty(usage, "outputTokens");
+  if (outputTokens !== void 0) {
+    metrics2.completion_tokens = outputTokens;
+  }
+  const totalTokens = getNumberProperty(usage, "totalTokens");
+  if (totalTokens !== void 0) {
+    metrics2.tokens = totalTokens;
+  }
+  const reasoningTokens = getNumberProperty(usage, "reasoningTokens");
+  if (reasoningTokens !== void 0) {
+    metrics2.completion_reasoning_tokens = reasoningTokens;
+  }
+  const cachedInputTokens = getNumberProperty(usage, "cachedInputTokens");
+  if (cachedInputTokens !== void 0) {
+    metrics2.prompt_cached_tokens = cachedInputTokens;
+  }
+  if (provider === "anthropic") {
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _205 => _205.anthropic]);
+    if (anthropicMetadata) {
+      const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
+      const cacheCreationTokens = getNumberProperty(
+        anthropicMetadata.usage,
+        "cache_creation_input_tokens"
+      ) || 0;
+      const cacheTokens = extractAnthropicCacheTokens(
+        cacheReadTokens,
+        cacheCreationTokens
+      );
+      Object.assign(metrics2, cacheTokens);
+      Object.assign(metrics2, finalizeAnthropicTokens(metrics2));
+    }
+  }
+  return metrics2;
+}
+function normalizeFinishReason(reason) {
+  if (typeof reason !== "string") return void 0;
+  return reason.replace(/-/g, "_");
+}
+function buildAssistantOutputWithToolCalls(result, toolCalls) {
   return [
     {
       index: 0,
+      logprobs: null,
+      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _206 => _206.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
       message: {
         role: "assistant",
-        content: _nullishCoalesce(text, () => ( "")),
-        ...toolCalls && toolCalls.length > 0 ? {
-          tool_calls: toolCalls.map((toolCall) => ({
-            id: toolCall.toolCallId,
-            function: {
-              name: toolCall.toolName,
-              arguments: toolCall.args
-            },
-            type: "function"
-          }))
-        } : {}
-      },
-      finish_reason: finishReason
+        tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+      }
     }
   ];
 }
-
-// src/wrappers/ai-sdk-5/ai-sdk.ts
-init_logger();
-var V3_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
+function extractToolCallsFromSteps(steps) {
+  const toolCalls = [];
+  if (!Array.isArray(steps)) return toolCalls;
+  let idx = 0;
+  for (const step of steps) {
+    const blocks = _optionalChain([step, 'optionalAccess', _207 => _207.content]);
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (block && typeof block === "object" && block.type === "tool-call") {
+        toolCalls.push({
+          id: block.toolCallId,
+          type: "function",
+          index: idx++,
+          function: {
+            name: block.toolName,
+            arguments: typeof block.input === "string" ? block.input : JSON.stringify(_nullishCoalesce(block.input, () => ( {})))
+          }
+        });
+      }
+    }
+  }
+  return toolCalls;
+}
+function extractToolCallsFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return [];
+  return extractToolCallsFromSteps([{ content: blocks }]);
+}
+function extractInput(params) {
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _208 => _208.prompt]), () => ( _optionalChain([params, 'optionalAccess', _209 => _209.messages]))), () => ( _optionalChain([params, 'optionalAccess', _210 => _210.system])));
+}
+var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
   "prompt",
   // Already captured as input
   "system",
@@ -14104,306 +14666,202 @@ var V3_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
   // Already captured as input
   "model",
   // Already captured in metadata.model
-  "providerOptions",
+  "providerOptions"
   // Internal AI SDK configuration
-  "tools",
-  // Already captured in metadata.tools
-  "span_info"
-  // Extracted separately for prompt linking
 ]);
-function extractSpanInfo(params) {
-  const { span_info } = params;
-  return { spanInfo: span_info };
-}
-function processFilesAsAttachments(files) {
-  if (!files || !Array.isArray(files) || files.length === 0) {
-    return void 0;
-  }
-  return files.map((file, index) => {
-    const mediaType = file.mediaType || "application/octet-stream";
-    const filename = `generated_file_${index}.${getExtensionFromMediaType(mediaType)}`;
-    const blob = convertDataToBlob(file.data, mediaType);
-    if (!blob) {
-      return null;
-    }
-    return new Attachment({
-      data: blob,
-      filename,
-      contentType: mediaType
-    });
-  }).filter((attachment) => attachment !== null);
-}
-function wrapAISDK(ai) {
-  const {
-    wrapLanguageModel,
-    generateText,
-    streamText,
-    generateObject,
-    streamObject
-  } = ai;
-  const wrappedGenerateText = (params) => {
-    const { spanInfo } = extractSpanInfo(params);
-    return traced(
-      async (span) => {
-        const wrappedModel = wrapLanguageModel({
-          model: params.model,
-          middleware: BraintrustMiddleware({ spanInfo })
-        });
-        const result = await generateText({
-          ...params,
-          tools: params.tools ? wrapTools(params.tools) : void 0,
-          model: wrappedModel
-        });
-        const provider = detectProviderFromResult(result);
-        const model = extractModelFromResult(result);
-        const finishReason = normalizeFinishReason(_optionalChain([result, 'optionalAccess', _209 => _209.finishReason]));
-        const input = processInputAttachments(extractInput(params));
-        const outputAttachments = processFilesAsAttachments(result.files);
-        const output = outputAttachments ? { text: result.text || result.content, files: outputAttachments } : result.text || result.content;
-        span.log({
-          input,
-          output,
+function BraintrustMiddleware(config = {}) {
+  return {
+    wrapGenerate: async ({
+      doGenerate,
+      params,
+      model: modelFromWrapGenerate
+    }) => {
+      const rawInput = extractInput(params);
+      const processedInput = processInputAttachments(rawInput);
+      const spanArgs = {
+        name: _optionalChain([config, 'access', _211 => _211.spanInfo, 'optionalAccess', _212 => _212.name]) || "ai-sdk.doGenerate",
+        spanAttributes: {
+          type: "llm" /* LLM */,
+          ..._optionalChain([config, 'access', _213 => _213.spanInfo, 'optionalAccess', _214 => _214.spanAttributes]) || {}
+        },
+        event: {
+          input: processedInput,
           metadata: {
-            ...extractModelParameters(params, V3_EXCLUDE_KEYS),
-            ...provider ? { provider } : {},
-            ...model ? { model } : {},
-            ...finishReason ? { finish_reason: finishReason } : {}
+            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
+            ..._optionalChain([config, 'access', _215 => _215.spanInfo, 'optionalAccess', _216 => _216.metadata]) || {}
           }
-        });
-        return result;
-      },
-      {
-        name: "ai-sdk.generateText"
-      }
-    );
-  };
-  const wrappedGenerateObject = (params) => {
-    const { spanInfo } = extractSpanInfo(params);
-    return traced(
-      async (span) => {
-        const wrappedModel = wrapLanguageModel({
-          model: params.model,
-          middleware: BraintrustMiddleware({ spanInfo })
-        });
-        const result = await generateObject({
-          ...params,
-          tools: params.tools ? wrapTools(params.tools) : void 0,
-          model: wrappedModel
-        });
+        }
+      };
+      const span = startSpan(spanArgs);
+      try {
+        const result = await doGenerate();
+        const metadata = {};
         const provider = detectProviderFromResult(result);
+        if (provider !== void 0) {
+          metadata.provider = provider;
+        }
+        if (result.finishReason !== void 0) {
+          metadata.finish_reason = result.finishReason;
+        }
         const model = extractModelFromResult(result);
-        const finishReason = normalizeFinishReason(result.finishReason);
-        const input = processInputAttachments(extractInput(params));
-        const outputAttachments = processFilesAsAttachments(result.files);
-        const output = outputAttachments ? { object: result.object, files: outputAttachments } : result.object;
-        span.log({
-          input,
-          output,
-          metadata: {
-            ...extractModelParameters(params, V3_EXCLUDE_KEYS),
-            ...provider ? { provider } : {},
-            ...model ? { model } : {},
-            ...finishReason ? { finish_reason: finishReason } : {}
+        if (model !== void 0) {
+          metadata.model = model;
+        } else if (modelFromWrapGenerate) {
+          const modelId = extractModelFromWrapGenerateCallback(
+            modelFromWrapGenerate
+          );
+          if (modelId) {
+            metadata.model = modelId;
           }
+        }
+        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _217 => _217.steps]));
+        if (!toolCalls || toolCalls.length === 0) {
+          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _218 => _218.content]));
+        }
+        span.log({
+          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _219 => _219.content]),
+          metadata,
+          metrics: normalizeUsageMetrics(
+            result.usage,
+            provider,
+            result.providerMetadata
+          )
         });
         return result;
-      },
-      {
-        name: "ai-sdk.generateObject"
-      }
-    );
-  };
-  const wrappedStreamText = (params) => {
-    const { spanInfo } = extractSpanInfo(params);
-    const input = processInputAttachments(extractInput(params));
-    const span = startSpan({
-      name: "ai-sdk.streamText",
-      event: {
-        input,
-        metadata: extractModelParameters(params, V3_EXCLUDE_KEYS)
+      } catch (error2) {
+        span.log({
+          error: error2 instanceof Error ? error2.message : String(error2)
+        });
+        throw error2;
+      } finally {
+        span.end();
       }
-    });
-    const userOnFinish = params.onFinish;
-    const userOnError = params.onError;
-    const userOnChunk = params.onChunk;
-    try {
-      const wrappedModel = wrapLanguageModel({
-        model: params.model,
-        middleware: BraintrustMiddleware({ spanInfo })
-      });
-      const startTime = Date.now();
-      let receivedFirst = false;
-      const result = withCurrent(
-        span,
-        () => streamText({
-          ...params,
-          tools: params.tools ? wrapTools(params.tools) : void 0,
-          model: wrappedModel,
-          onChunk: (chunk) => {
-            if (!receivedFirst) {
-              receivedFirst = true;
+    },
+    wrapStream: async ({ doStream, params }) => {
+      const rawInput = extractInput(params);
+      const processedInput = processInputAttachments(rawInput);
+      const spanArgs = {
+        name: _optionalChain([config, 'access', _220 => _220.spanInfo, 'optionalAccess', _221 => _221.name]) || "ai-sdk.doStream",
+        spanAttributes: {
+          type: "llm" /* LLM */,
+          ..._optionalChain([config, 'access', _222 => _222.spanInfo, 'optionalAccess', _223 => _223.spanAttributes]) || {}
+        },
+        event: {
+          input: processedInput,
+          metadata: {
+            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
+            ..._optionalChain([config, 'access', _224 => _224.spanInfo, 'optionalAccess', _225 => _225.metadata]) || {}
+          }
+        }
+      };
+      const span = startSpan(spanArgs);
+      try {
+        const { stream, ...rest } = await doStream();
+        const textChunks = [];
+        const toolBlocks = [];
+        let finalUsage = {};
+        let finalFinishReason = void 0;
+        let providerMetadata = {};
+        const transformStream = new TransformStream({
+          transform(chunk, controller) {
+            try {
+              if (chunk.type === "text-delta" && chunk.delta) {
+                textChunks.push(chunk.delta);
+              }
+              if (chunk.type === "tool-call" || chunk.type === "tool-result") {
+                toolBlocks.push(chunk);
+              }
+              if (chunk.type === "finish") {
+                finalFinishReason = chunk.finishReason;
+                finalUsage = chunk.usage || {};
+                providerMetadata = chunk.providerMetadata || {};
+              }
+              controller.enqueue(chunk);
+            } catch (error2) {
               span.log({
-                metrics: {
-                  time_to_first_token: (Date.now() - startTime) / 1e3
-                }
+                error: error2 instanceof Error ? error2.message : String(error2)
               });
-            }
-            if (typeof userOnChunk === "function") {
-              userOnChunk(chunk);
+              span.end();
+              controller.error(error2);
             }
           },
-          onFinish: async (event) => {
-            if (typeof userOnFinish === "function") {
-              await userOnFinish(event);
-            }
-            const provider = detectProviderFromResult(event);
-            const model = extractModelFromResult(event);
-            const finishReason = normalizeFinishReason(_optionalChain([event, 'optionalAccess', _210 => _210.finishReason]));
-            const outputAttachments = processFilesAsAttachments(event.files);
-            const output = outputAttachments ? {
-              text: _optionalChain([event, 'optionalAccess', _211 => _211.text]) || _optionalChain([event, 'optionalAccess', _212 => _212.content]),
-              files: outputAttachments
-            } : _optionalChain([event, 'optionalAccess', _213 => _213.text]) || _optionalChain([event, 'optionalAccess', _214 => _214.content]);
-            span.log({
-              output,
-              metadata: {
-                ...extractModelParameters(params, V3_EXCLUDE_KEYS),
-                ...provider ? { provider } : {},
-                ...model ? { model } : {},
-                ...finishReason ? { finish_reason: finishReason } : {}
+          flush() {
+            try {
+              const generatedText = textChunks.join("");
+              let output = generatedText ? [{ type: "text", text: generatedText }] : [];
+              const resultForDetection = {
+                providerMetadata,
+                response: rest.response,
+                ...rest,
+                finishReason: finalFinishReason
+              };
+              const metadata = {};
+              const provider = detectProviderFromResult(resultForDetection);
+              if (provider !== void 0) {
+                metadata.provider = provider;
               }
-            });
-            span.end();
-          },
-          onError: async (err) => {
-            if (typeof userOnError === "function") {
-              await userOnError(err);
-            }
-            span.log({
-              error: err instanceof Error ? err.message : String(err)
-            });
-            span.end();
-          }
-        })
-      );
-      return result;
-    } catch (error2) {
-      span.log({
-        error: error2 instanceof Error ? error2.message : String(error2)
-      });
-      span.end();
-      throw error2;
-    }
-  };
-  const wrappedStreamObject = (params) => {
-    const { spanInfo } = extractSpanInfo(params);
-    const input = processInputAttachments(extractInput(params));
-    const span = startSpan({
-      name: "ai-sdk.streamObject",
-      event: {
-        input,
-        metadata: extractModelParameters(params, V3_EXCLUDE_KEYS)
-      }
-    });
-    const userOnFinish = params.onFinish;
-    const userOnError = params.onError;
-    try {
-      const wrappedModel = wrapLanguageModel({
-        model: params.model,
-        middleware: BraintrustMiddleware({ spanInfo })
-      });
-      const result = withCurrent(
-        span,
-        () => streamObject({
-          ...params,
-          tools: params.tools ? wrapTools(params.tools) : void 0,
-          model: wrappedModel,
-          onFinish: async (event) => {
-            if (typeof userOnFinish === "function") {
-              await userOnFinish(event);
-            }
-            const provider = detectProviderFromResult(event);
-            const model = extractModelFromResult(event);
-            const finishReason = normalizeFinishReason(_optionalChain([event, 'optionalAccess', _215 => _215.finishReason]));
-            const outputAttachments = processFilesAsAttachments(event.files);
-            const output = outputAttachments ? { object: _optionalChain([event, 'optionalAccess', _216 => _216.object]), files: outputAttachments } : _optionalChain([event, 'optionalAccess', _217 => _217.object]);
-            span.log({
-              output,
-              metadata: {
-                ...extractModelParameters(params, V3_EXCLUDE_KEYS),
-                ...provider ? { provider } : {},
-                ...model ? { model } : {},
-                ...finishReason ? { finish_reason: finishReason } : {}
+              if (finalFinishReason !== void 0) {
+                metadata.finish_reason = finalFinishReason;
               }
-            });
-            span.end();
-          },
-          onError: async (err) => {
-            if (typeof userOnError === "function") {
-              await userOnError(err);
-            }
-            span.log({
-              error: err instanceof Error ? err.message : String(err)
-            });
-            span.end();
-          }
-        })
-      );
-      const startTime = Date.now();
-      let receivedFirst = false;
-      const trackFirstAccess = () => {
-        if (!receivedFirst) {
-          receivedFirst = true;
-          span.log({
-            metrics: {
-              time_to_first_token: (Date.now() - startTime) / 1e3
+              const model = extractModelFromResult(resultForDetection);
+              if (model !== void 0) {
+                metadata.model = model;
+              }
+              if (toolBlocks.length > 0) {
+                const toolCalls = extractToolCallsFromSteps([
+                  { content: toolBlocks }
+                ]);
+                if (toolCalls.length > 0) {
+                  output = buildAssistantOutputWithToolCalls(
+                    resultForDetection,
+                    toolCalls
+                  );
+                }
+              }
+              span.log({
+                output,
+                metadata,
+                metrics: normalizeUsageMetrics(
+                  finalUsage,
+                  provider,
+                  providerMetadata
+                )
+              });
+              span.end();
+            } catch (error2) {
+              span.log({
+                error: error2 instanceof Error ? error2.message : String(error2)
+              });
+              span.end();
+              throw error2;
             }
-          });
-        }
-      };
-      const [stream1, stream2] = result.baseStream.tee();
-      result.baseStream = stream2;
-      stream1.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            trackFirstAccess();
-            controller.enqueue(chunk);
-          }
-        })
-      ).pipeTo(
-        new WritableStream({
-          write() {
           }
-        })
-      ).catch(() => {
-      });
-      return result;
-    } catch (error2) {
-      span.log({
-        error: error2 instanceof Error ? error2.message : String(error2)
-      });
-      span.end();
-      throw error2;
+        });
+        return {
+          stream: stream.pipeThrough(transformStream),
+          ...rest
+        };
+      } catch (error2) {
+        span.log({
+          error: error2 instanceof Error ? error2.message : String(error2)
+        });
+        span.end();
+        throw error2;
+      }
     }
   };
-  return {
-    generateText: wrappedGenerateText,
-    generateObject: wrappedGenerateObject,
-    streamText: wrappedStreamText,
-    streamObject: wrappedStreamObject
-  };
 }
 
 // src/wrappers/mastra/mastra.ts
 init_logger();
 var aiSDKFormatWarning = false;
 function wrapMastraAgent(agent, options) {
-  const prefix = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _218 => _218.name]), () => ( _optionalChain([options, 'optionalAccess', _219 => _219.span_name]))), () => ( agent.name)), () => ( "Agent"));
+  const prefix = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _226 => _226.name]), () => ( _optionalChain([options, 'optionalAccess', _227 => _227.span_name]))), () => ( agent.name)), () => ( "Agent"));
   if (!hasAllMethods(agent)) {
     return agent;
   }
   if (agent.tools) {
-    agent.__setTools(wrapTools(agent.tools));
+    agent.__setTools(wrapTools2(agent.tools));
   }
   return new Proxy(agent, {
     get(target, prop, receiver) {
@@ -14430,10 +14888,10 @@ function wrapGenerate(original, target, prefix) {
     return traced(
       async (span) => {
         const result = await original.apply(target, args);
-        const provider = detectProviderFromResult(result);
-        const model = extractModelFromResult(result);
-        const finishReason = normalizeFinishReason(_optionalChain([result, 'optionalAccess', _220 => _220.finishReason]));
-        const metrics2 = _optionalChain([result, 'optionalAccess', _221 => _221.usage]) ? normalizeUsageMetrics(
+        const provider = detectProviderFromResult2(result);
+        const model = extractModelFromResult2(result);
+        const finishReason = normalizeFinishReason2(_optionalChain([result, 'optionalAccess', _228 => _228.finishReason]));
+        const metrics2 = _optionalChain([result, 'optionalAccess', _229 => _229.usage]) ? normalizeUsageMetrics2(
           result.usage,
           provider,
           result.providerMetadata
@@ -14481,14 +14939,14 @@ function wrapStream(original, target, prefix) {
       format: baseOpts.format || "aisdk"
       // Default to AI SDK v5 format if not specified
     };
-    const userOnChunk = _optionalChain([baseOpts, 'optionalAccess', _222 => _222.onChunk]);
-    const userOnFinish = _optionalChain([baseOpts, 'optionalAccess', _223 => _223.onFinish]);
-    const userOnError = _optionalChain([baseOpts, 'optionalAccess', _224 => _224.onError]);
+    const userOnChunk = _optionalChain([baseOpts, 'optionalAccess', _230 => _230.onChunk]);
+    const userOnFinish = _optionalChain([baseOpts, 'optionalAccess', _231 => _231.onFinish]);
+    const userOnError = _optionalChain([baseOpts, 'optionalAccess', _232 => _232.onError]);
     const startTime = Date.now();
     let receivedFirst = false;
     wrappedOpts.onChunk = (chunk) => {
       try {
-        _optionalChain([userOnChunk, 'optionalCall', _225 => _225(chunk)]);
+        _optionalChain([userOnChunk, 'optionalCall', _233 => _233(chunk)]);
       } finally {
         if (!receivedFirst) {
           receivedFirst = true;
@@ -14500,13 +14958,13 @@ function wrapStream(original, target, prefix) {
     };
     wrappedOpts.onFinish = async (event) => {
       try {
-        await _optionalChain([userOnFinish, 'optionalCall', _226 => _226(event)]);
+        await _optionalChain([userOnFinish, 'optionalCall', _234 => _234(event)]);
       } finally {
         const e = event;
-        const provider = detectProviderFromResult(e);
-        const model = extractModelFromResult(e);
-        const finishReason = normalizeFinishReason(_optionalChain([e, 'optionalAccess', _227 => _227.finishReason]));
-        const metrics2 = _optionalChain([e, 'optionalAccess', _228 => _228.usage]) ? normalizeUsageMetrics(e.usage, provider, e.providerMetadata) : {};
+        const provider = detectProviderFromResult2(e);
+        const model = extractModelFromResult2(e);
+        const finishReason = normalizeFinishReason2(_optionalChain([e, 'optionalAccess', _235 => _235.finishReason]));
+        const metrics2 = _optionalChain([e, 'optionalAccess', _236 => _236.usage]) ? normalizeUsageMetrics2(e.usage, provider, e.providerMetadata) : {};
         span.log({
           output: _nullishCoalesce(_nullishCoalesce(e.text, () => ( e.content)), () => ( e)),
           metadata: {
@@ -14522,7 +14980,7 @@ function wrapStream(original, target, prefix) {
     };
     wrappedOpts.onError = async (err) => {
       try {
-        await _optionalChain([userOnError, 'optionalCall', _229 => _229(err)]);
+        await _optionalChain([userOnError, 'optionalCall', _237 => _237(err)]);
       } finally {
         logError(span, err);
         span.end();
@@ -14534,6 +14992,109 @@ function wrapStream(original, target, prefix) {
     );
   };
 }
+function detectProviderFromResult2(result) {
+  if (!_optionalChain([result, 'optionalAccess', _238 => _238.providerMetadata])) {
+    return void 0;
+  }
+  const keys = Object.keys(result.providerMetadata);
+  return _optionalChain([keys, 'optionalAccess', _239 => _239.at, 'call', _240 => _240(0)]);
+}
+function extractModelFromResult2(result) {
+  if (_optionalChain([result, 'optionalAccess', _241 => _241.response, 'optionalAccess', _242 => _242.modelId])) {
+    return result.response.modelId;
+  }
+  if (_optionalChain([result, 'optionalAccess', _243 => _243.request, 'optionalAccess', _244 => _244.body, 'optionalAccess', _245 => _245.model])) {
+    return result.request.body.model;
+  }
+  return void 0;
+}
+function normalizeFinishReason2(reason) {
+  if (typeof reason !== "string") return void 0;
+  return reason.replace(/-/g, "_");
+}
+function normalizeUsageMetrics2(usage, provider, providerMetadata) {
+  const metrics2 = {};
+  const inputTokens = getNumberProperty2(usage, "inputTokens");
+  if (inputTokens !== void 0) {
+    metrics2.prompt_tokens = inputTokens;
+  }
+  const outputTokens = getNumberProperty2(usage, "outputTokens");
+  if (outputTokens !== void 0) {
+    metrics2.completion_tokens = outputTokens;
+  }
+  const totalTokens = getNumberProperty2(usage, "totalTokens");
+  if (totalTokens !== void 0) {
+    metrics2.tokens = totalTokens;
+  }
+  const reasoningTokens = getNumberProperty2(usage, "reasoningTokens");
+  if (reasoningTokens !== void 0) {
+    metrics2.completion_reasoning_tokens = reasoningTokens;
+  }
+  const cachedInputTokens = getNumberProperty2(usage, "cachedInputTokens");
+  if (cachedInputTokens !== void 0) {
+    metrics2.prompt_cached_tokens = cachedInputTokens;
+  }
+  if (provider === "anthropic") {
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _246 => _246.anthropic]);
+    if (anthropicMetadata) {
+      const cacheReadTokens = getNumberProperty2(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
+      const cacheCreationTokens = getNumberProperty2(
+        anthropicMetadata.usage,
+        "cache_creation_input_tokens"
+      ) || 0;
+      const cacheTokens = extractAnthropicCacheTokens(
+        cacheReadTokens,
+        cacheCreationTokens
+      );
+      Object.assign(metrics2, cacheTokens);
+      Object.assign(metrics2, finalizeAnthropicTokens(metrics2));
+    }
+  }
+  return metrics2;
+}
+function wrapTools2(tools) {
+  if (!tools) return tools;
+  const inferName = (tool, fallback2) => tool && (tool.name || tool.toolName || tool.id) || fallback2;
+  if (Array.isArray(tools)) {
+    const arr = tools;
+    const out = arr.map((tool, idx) => {
+      if (tool != null && typeof tool === "object" && "execute" in tool && typeof tool.execute === "function") {
+        const name = inferName(tool, `tool[${idx}]`);
+        return {
+          ...tool,
+          execute: wrapTraced(tool.execute.bind(tool), {
+            name,
+            type: "tool"
+          })
+        };
+      }
+      return tool;
+    });
+    return out;
+  }
+  const wrappedTools = {};
+  for (const [key, tool] of Object.entries(tools)) {
+    if (tool != null && typeof tool === "object" && "execute" in tool && typeof tool.execute === "function") {
+      wrappedTools[key] = {
+        ...tool,
+        execute: wrapTraced(tool.execute.bind(tool), {
+          name: key,
+          type: "tool"
+        })
+      };
+    } else {
+      wrappedTools[key] = tool;
+    }
+  }
+  return wrappedTools;
+}
+function getNumberProperty2(obj, key) {
+  if (!obj || typeof obj !== "object" || !(key in obj)) {
+    return void 0;
+  }
+  const value = Reflect.get(obj, key);
+  return typeof value === "number" ? value : void 0;
+}
 
 // src/wrappers/anthropic.ts
 init_logger();
@@ -14705,9 +15266,9 @@ function streamNextProxy(stream, sspan) {
       return result;
     }
     const item = result.value;
-    switch (_optionalChain([item, 'optionalAccess', _230 => _230.type])) {
+    switch (_optionalChain([item, 'optionalAccess', _247 => _247.type])) {
       case "message_start":
-        const msg = _optionalChain([item, 'optionalAccess', _231 => _231.message]);
+        const msg = _optionalChain([item, 'optionalAccess', _248 => _248.message]);
         if (msg) {
           const event = parseEventFromMessage(msg);
           totals = { ...totals, ...event.metrics };
@@ -14720,20 +15281,20 @@ function streamNextProxy(stream, sspan) {
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([item, 'access', _232 => _232.delta, 'optionalAccess', _233 => _233.type]) === "text_delta") {
-          const text = _optionalChain([item, 'optionalAccess', _234 => _234.delta, 'optionalAccess', _235 => _235.text]);
+        if (_optionalChain([item, 'access', _249 => _249.delta, 'optionalAccess', _250 => _250.type]) === "text_delta") {
+          const text = _optionalChain([item, 'optionalAccess', _251 => _251.delta, 'optionalAccess', _252 => _252.text]);
           if (text) {
             deltas.push(text);
           }
         }
         break;
       case "message_delta":
-        const usage = _optionalChain([item, 'optionalAccess', _236 => _236.usage]);
+        const usage = _optionalChain([item, 'optionalAccess', _253 => _253.usage]);
         if (usage) {
           const metrics2 = parseMetricsFromUsage2(usage);
           totals = { ...totals, ...metrics2 };
         }
-        const delta = _optionalChain([item, 'optionalAccess', _237 => _237.delta]);
+        const delta = _optionalChain([item, 'optionalAccess', _254 => _254.delta]);
         if (delta) {
           metadata = { ...metadata, ...delta };
         }
@@ -14746,7 +15307,7 @@ function streamNextProxy(stream, sspan) {
 }
 function parseEventFromMessage(message) {
   const output = message ? { role: message.role, content: message.content } : null;
-  const metrics2 = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _238 => _238.usage]));
+  const metrics2 = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _255 => _255.usage]));
   const metas = ["stop_reason", "stop_sequence"];
   const metadata = {};
   for (const m of metas) {
@@ -14891,8 +15452,8 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
           finalResults.push(finalMessageContent);
         }
         const lastMessage = currentMessages[currentMessages.length - 1];
-        if (_optionalChain([lastMessage, 'optionalAccess', _239 => _239.message, 'optionalAccess', _240 => _240.usage])) {
-          const outputTokens = getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
+        if (_optionalChain([lastMessage, 'optionalAccess', _256 => _256.message, 'optionalAccess', _257 => _257.usage])) {
+          const outputTokens = getNumberProperty3(lastMessage.message.usage, "output_tokens") || 0;
           accumulatedOutputTokens += outputTokens;
         }
         currentMessages.length = 0;
@@ -14906,20 +15467,20 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
           );
           for await (const message of generator) {
             const currentTime = getCurrentUnixTimestamp();
-            const messageId = _optionalChain([message, 'access', _241 => _241.message, 'optionalAccess', _242 => _242.id]);
+            const messageId = _optionalChain([message, 'access', _258 => _258.message, 'optionalAccess', _259 => _259.id]);
             if (messageId && messageId !== currentMessageId) {
               await createLLMSpan();
               currentMessageId = messageId;
               currentMessageStartTime = currentTime;
             }
-            if (message.type === "assistant" && _optionalChain([message, 'access', _243 => _243.message, 'optionalAccess', _244 => _244.usage])) {
+            if (message.type === "assistant" && _optionalChain([message, 'access', _260 => _260.message, 'optionalAccess', _261 => _261.usage])) {
               currentMessages.push(message);
             }
             if (message.type === "result" && message.usage) {
               finalUsageMetrics = _extractUsageFromMessage(message);
               if (currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
                 const lastMessage = currentMessages[currentMessages.length - 1];
-                if (_optionalChain([lastMessage, 'optionalAccess', _245 => _245.message, 'optionalAccess', _246 => _246.usage])) {
+                if (_optionalChain([lastMessage, 'optionalAccess', _262 => _262.message, 'optionalAccess', _263 => _263.usage])) {
                   const adjustedTokens = finalUsageMetrics.completion_tokens - accumulatedOutputTokens;
                   if (adjustedTokens >= 0) {
                     lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -15000,23 +15561,23 @@ function _extractUsageFromMessage(message) {
   const metrics2 = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _247 => _247.message, 'optionalAccess', _248 => _248.usage]);
+    usage = _optionalChain([message, 'access', _264 => _264.message, 'optionalAccess', _265 => _265.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
   if (!usage || typeof usage !== "object") {
     return metrics2;
   }
-  const inputTokens = getNumberProperty(usage, "input_tokens");
+  const inputTokens = getNumberProperty3(usage, "input_tokens");
   if (inputTokens !== void 0) {
     metrics2.prompt_tokens = inputTokens;
   }
-  const outputTokens = getNumberProperty(usage, "output_tokens");
+  const outputTokens = getNumberProperty3(usage, "output_tokens");
   if (outputTokens !== void 0) {
     metrics2.completion_tokens = outputTokens;
   }
-  const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
-  const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
+  const cacheReadTokens = getNumberProperty3(usage, "cache_read_input_tokens") || 0;
+  const cacheCreationTokens = getNumberProperty3(usage, "cache_creation_input_tokens") || 0;
   if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
     const cacheTokens = extractAnthropicCacheTokens(
       cacheReadTokens,
@@ -15032,14 +15593,14 @@ function _extractUsageFromMessage(message) {
 async function _createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
   if (messages.length === 0) return void 0;
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _249 => _249.message, 'optionalAccess', _250 => _250.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _266 => _266.message, 'optionalAccess', _267 => _267.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = _extractUsageFromMessage(lastMessage);
   const input = _buildLLMInput(prompt, conversationHistory);
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _251 => _251.message, 'optionalAccess', _252 => _252.content]) && _optionalChain([m, 'access', _253 => _253.message, 'optionalAccess', _254 => _254.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _268 => _268.message, 'optionalAccess', _269 => _269.content]) && _optionalChain([m, 'access', _270 => _270.message, 'optionalAccess', _271 => _271.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter((c) => c !== void 0);
   await traced(
     (llmSpan) => {
@@ -15059,7 +15620,7 @@ async function _createLLMSpanForMessages(messages, prompt, conversationHistory,
       parent: parentSpan
     }
   );
-  return _optionalChain([lastMessage, 'access', _255 => _255.message, 'optionalAccess', _256 => _256.content]) && _optionalChain([lastMessage, 'access', _257 => _257.message, 'optionalAccess', _258 => _258.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _272 => _272.message, 'optionalAccess', _273 => _273.content]) && _optionalChain([lastMessage, 'access', _274 => _274.message, 'optionalAccess', _275 => _275.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 function wrapClaudeAgentSDK(sdk) {
   const cache = /* @__PURE__ */ new Map();
@@ -15107,6 +15668,13 @@ function wrapClaudeAgentSDK(sdk) {
     }
   });
 }
+function getNumberProperty3(obj, key) {
+  if (!obj || typeof obj !== "object" || !(key in obj)) {
+    return void 0;
+  }
+  const value = Reflect.get(obj, key);
+  return typeof value === "number" ? value : void 0;
+}
 
 // src/wrappers/google-genai.ts
 init_logger();
@@ -15345,7 +15913,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _259 => _259.config, 'optionalAccess', _260 => _260.tools])) {
+  if (!_optionalChain([params, 'access', _276 => _276.config, 'optionalAccess', _277 => _277.tools])) {
     return null;
   }
   try {
@@ -15355,7 +15923,7 @@ function serializeTools(params) {
       }
       return tool;
     });
-  } catch (e11) {
+  } catch (e14) {
     return null;
   }
 }
@@ -15428,7 +15996,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _261 => _261.content, 'optionalAccess', _262 => _262.parts])) {
+        if (_optionalChain([candidate, 'access', _278 => _278.content, 'optionalAccess', _279 => _279.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -15459,7 +16027,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _263 => _263.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _280 => _280.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -15533,7 +16101,7 @@ try {
   otelApi = (init_esm(), __toCommonJS(esm_exports));
   otelSdk = __require("@opentelemetry/sdk-trace-base");
   OTEL_AVAILABLE2 = true;
-} catch (e12) {
+} catch (e15) {
   console.warn(
     "OpenTelemetry packages are not installed. Install them with: npm install @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-http @opentelemetry/resources @opentelemetry/semantic-conventions"
   );
@@ -15688,8 +16256,8 @@ var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
                   span.instrumentationScope = span.instrumentationLibrary;
                 }
                 if (!span.parentSpanContext && span.parentSpanId) {
-                  const spanContext = _optionalChain([span, 'access', _264 => _264.spanContext, 'optionalCall', _265 => _265()]);
-                  if (_optionalChain([spanContext, 'optionalAccess', _266 => _266.traceId])) {
+                  const spanContext = _optionalChain([span, 'access', _281 => _281.spanContext, 'optionalCall', _282 => _282()]);
+                  if (_optionalChain([spanContext, 'optionalAccess', _283 => _283.traceId])) {
                     span.parentSpanContext = {
                       spanId: span.parentSpanId,
                       traceId: spanContext.traceId
@@ -15732,7 +16300,7 @@ var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
       let parentValue;
       if (otelApi && otelApi.context) {
         const currentContext = otelApi.context.active();
-        const contextValue = _optionalChain([currentContext, 'access', _267 => _267.getValue, 'optionalCall', _268 => _268("braintrust.parent")]);
+        const contextValue = _optionalChain([currentContext, 'access', _284 => _284.getValue, 'optionalCall', _285 => _285("braintrust.parent")]);
         if (typeof contextValue === "string") {
           parentValue = contextValue;
         }
@@ -15749,7 +16317,7 @@ var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
           span.setAttributes({ "braintrust.parent": parentValue });
         }
       }
-    } catch (e13) {
+    } catch (e16) {
     }
     this.aiSpanProcessor.onStart(span, parentContext);
   }
@@ -15765,7 +16333,7 @@ var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
         return typeof parentAttr === "string" ? parentAttr : void 0;
       }
       return void 0;
-    } catch (e14) {
+    } catch (e17) {
       return void 0;
     }
   }
@@ -15796,7 +16364,7 @@ function otelContextFromSpanExport(exportStr) {
     traceId: traceIdHex,
     spanId: spanIdHex,
     isRemote: true,
-    traceFlags: _nullishCoalesce(_optionalChain([otelApi, 'access', _269 => _269.TraceFlags, 'optionalAccess', _270 => _270.SAMPLED]), () => ( 1))
+    traceFlags: _nullishCoalesce(_optionalChain([otelApi, 'access', _286 => _286.TraceFlags, 'optionalAccess', _287 => _287.SAMPLED]), () => ( 1))
     // SAMPLED flag
   };
   const nonRecordingSpan = otelTrace2.wrapSpanContext(spanContext);
@@ -15901,7 +16469,7 @@ var BraintrustExporter = (_class21 = class _BraintrustExporter {
 function addParentToBaggage(parent, ctx) {
   if (!OTEL_AVAILABLE2 || !otelApi) {
     console.error("OpenTelemetry not available");
-    return ctx || _optionalChain([otelApi, 'optionalAccess', _271 => _271.context, 'access', _272 => _272.active, 'call', _273 => _273()]);
+    return ctx || _optionalChain([otelApi, 'optionalAccess', _288 => _288.context, 'access', _289 => _289.active, 'call', _290 => _290()]);
   }
   try {
     const propagation2 = otelApi.propagation;
@@ -15962,7 +16530,7 @@ function parentFromHeaders(headers) {
       return void 0;
     }
     const baggage = propagation2.getBaggage(ctx);
-    const braintrustParent = _optionalChain([baggage, 'optionalAccess', _274 => _274.getEntry, 'call', _275 => _275("braintrust.parent"), 'optionalAccess', _276 => _276.value]);
+    const braintrustParent = _optionalChain([baggage, 'optionalAccess', _291 => _291.getEntry, 'call', _292 => _292("braintrust.parent"), 'optionalAccess', _293 => _293.value]);
     if (!braintrustParent) {
       console.warn(
         "parentFromHeaders: braintrust.parent not found in OTEL baggage. Cannot create Braintrust parent without project information. Ensure the OTEL span sets braintrust.parent in baggage before exporting headers."