braintrust 0.4.8 → 0.4.10

package/dist/index.mjs

@@ -1504,7 +1504,7 @@ var init_util = __esm({
 
 // src/generated_types.ts
 import { z as z6 } from "zod/v3";
-var AclObjectType, Permission, Acl, AISecret, ResponseFormatJsonSchema, ResponseFormatNullish, AnyModelParams, ApiKey, AsyncScoringState, AsyncScoringControl, BraintrustAttachmentReference, ExternalAttachmentReference, AttachmentReference, UploadStatus, AttachmentStatus, BraintrustModelParams, CallEvent, ChatCompletionContentPartTextWithTitle, ChatCompletionContentPartImageWithTitle, ChatCompletionContentPart, ChatCompletionContentPartText, ChatCompletionMessageToolCall, ChatCompletionMessageReasoning, ChatCompletionMessageParam, ChatCompletionOpenAIMessageParam, ChatCompletionTool, CodeBundle, Dataset, ObjectReferenceNullish, DatasetEvent, EnvVar, RepoInfo, Experiment, SpanType, SpanAttributes, ExperimentEvent, ExtendedSavedFunctionId, PromptBlockDataNullish, ModelParams, PromptOptionsNullish, PromptParserNullish, SavedFunctionId, PromptDataNullish, FunctionTypeEnumNullish, FunctionIdRef, PromptBlockData, GraphNode, GraphEdge, GraphData, FunctionData, Function, FunctionFormat, PromptData, FunctionTypeEnum, FunctionId, FunctionObjectType, FunctionOutputType, GitMetadataSettings, Group, IfExists, InvokeParent, StreamingMode, InvokeFunction, MessageRole, ObjectReference, OnlineScoreConfig, Organization, ProjectSettings, Project, RetentionObjectType, ProjectAutomation, ProjectLogsEvent, ProjectScoreType, ProjectScoreCategory, ProjectScoreCategories, ProjectScoreConfig, ProjectScore, ProjectTag, Prompt, PromptOptions, PromptSessionEvent, ResponseFormat, Role, RunEval, ServiceToken, SpanIFrame, SSEConsoleEventData, SSEProgressEventData, ToolFunctionDefinition, User, ViewDataSearch, ViewData, ViewOptions, View;
+var AclObjectType, Permission, Acl, AISecret, ResponseFormatJsonSchema, ResponseFormatNullish, AnyModelParams, ApiKey, AsyncScoringState, AsyncScoringControl, BraintrustAttachmentReference, ExternalAttachmentReference, AttachmentReference, UploadStatus, AttachmentStatus, BraintrustModelParams, CallEvent, ChatCompletionContentPartTextWithTitle, ChatCompletionContentPartImageWithTitle, ChatCompletionContentPartFileFile, ChatCompletionContentPartFileWithTitle, ChatCompletionContentPart, ChatCompletionContentPartText, ChatCompletionMessageToolCall, ChatCompletionMessageReasoning, ChatCompletionMessageParam, ChatCompletionOpenAIMessageParam, ChatCompletionTool, CodeBundle, Dataset, ObjectReferenceNullish, DatasetEvent, EnvVar, RepoInfo, Experiment, SpanType, SpanAttributes, ExperimentEvent, ExtendedSavedFunctionId, PromptBlockDataNullish, ModelParams, PromptOptionsNullish, PromptParserNullish, SavedFunctionId, PromptDataNullish, FunctionTypeEnumNullish, FunctionIdRef, PromptBlockData, GraphNode, GraphEdge, GraphData, FunctionData, Function, FunctionFormat, PromptData, FunctionTypeEnum, FunctionId, FunctionObjectType, FunctionOutputType, GitMetadataSettings, Group, IfExists, InvokeParent, StreamingMode, InvokeFunction, MessageRole, ObjectReference, OnlineScoreConfig, Organization, ProjectSettings, Project, RetentionObjectType, ProjectAutomation, ProjectLogsEvent, ProjectScoreType, ProjectScoreCategory, ProjectScoreCategories, ProjectScoreConfig, ProjectScore, ProjectTag, Prompt, PromptOptions, PromptSessionEvent, ResponseFormat, Role, RunEval, ServiceToken, SpanIFrame, SSEConsoleEventData, SSEProgressEventData, ToolFunctionDefinition, User, ViewDataSearch, ViewData, ViewOptions, View;
 var init_generated_types = __esm({
   "src/generated_types.ts"() {
     "use strict";
@@ -1595,10 +1595,12 @@ var init_generated_types = __esm({
       ]).optional(),
       n: z6.number().optional(),
       stop: z6.array(z6.string()).optional(),
-      reasoning_effort: z6.enum(["minimal", "low", "medium", "high"]).optional(),
+      reasoning_effort: z6.enum(["none", "minimal", "low", "medium", "high"]).optional(),
       verbosity: z6.enum(["low", "medium", "high"]).optional(),
       top_k: z6.number().optional(),
       stop_sequences: z6.array(z6.string()).optional(),
+      reasoning_enabled: z6.boolean().optional(),
+      reasoning_budget: z6.number().optional(),
       max_tokens_to_sample: z6.number().optional(),
       maxOutputTokens: z6.number().optional(),
       topP: z6.number().optional(),
@@ -1654,7 +1656,11 @@ var init_generated_types = __esm({
       upload_status: UploadStatus,
       error_message: z6.string().optional()
     });
-    BraintrustModelParams = z6.object({ use_cache: z6.boolean() }).partial();
+    BraintrustModelParams = z6.object({
+      use_cache: z6.boolean(),
+      reasoning_enabled: z6.boolean(),
+      reasoning_budget: z6.number()
+    }).partial();
     CallEvent = z6.union([
       z6.object({
         id: z6.string().optional(),
@@ -1709,9 +1715,15 @@ var init_generated_types = __esm({
       }),
       type: z6.literal("image_url")
     });
+    ChatCompletionContentPartFileFile = z6.object({ file_data: z6.string(), filename: z6.string(), file_id: z6.string() }).partial();
+    ChatCompletionContentPartFileWithTitle = z6.object({
+      file: ChatCompletionContentPartFileFile,
+      type: z6.literal("file")
+    });
     ChatCompletionContentPart = z6.union([
       ChatCompletionContentPartTextWithTitle,
-      ChatCompletionContentPartImageWithTitle
+      ChatCompletionContentPartImageWithTitle,
+      ChatCompletionContentPartFileWithTitle
     ]);
     ChatCompletionContentPartText = z6.object({
       text: z6.string().default(""),
@@ -1808,7 +1820,7 @@ var init_generated_types = __esm({
     });
     CodeBundle = z6.object({
       runtime_context: z6.object({
-        runtime: z6.enum(["node", "python"]),
+        runtime: z6.enum(["node", "python", "browser"]),
         version: z6.string()
       }),
       location: z6.union([
@@ -1869,7 +1881,9 @@ var init_generated_types = __esm({
       span_id: z6.string(),
       root_span_id: z6.string(),
       is_root: z6.union([z6.boolean(), z6.null()]).optional(),
-      origin: ObjectReferenceNullish.optional()
+      origin: ObjectReferenceNullish.optional(),
+      comments: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
+      audit_data: z6.union([z6.array(z6.unknown()), z6.null()]).optional()
     });
     EnvVar = z6.object({
       id: z6.string().uuid(),
@@ -1949,7 +1963,9 @@ var init_generated_types = __esm({
       root_span_id: z6.string(),
       span_attributes: SpanAttributes.optional(),
       is_root: z6.union([z6.boolean(), z6.null()]).optional(),
-      origin: ObjectReferenceNullish.optional()
+      origin: ObjectReferenceNullish.optional(),
+      comments: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
+      audit_data: z6.union([z6.array(z6.unknown()), z6.null()]).optional()
     });
     ExtendedSavedFunctionId = z6.union([
       z6.object({ type: z6.literal("function"), id: z6.string() }),
@@ -1961,17 +1977,19 @@ var init_generated_types = __esm({
       })
     ]);
     PromptBlockDataNullish = z6.union([
-      z6.object({ type: z6.literal("completion"), content: z6.string() }),
       z6.object({
         type: z6.literal("chat"),
         messages: z6.array(ChatCompletionMessageParam),
         tools: z6.string().optional()
       }),
+      z6.object({ type: z6.literal("completion"), content: z6.string() }),
       z6.null()
     ]);
     ModelParams = z6.union([
       z6.object({
         use_cache: z6.boolean(),
+        reasoning_enabled: z6.boolean(),
+        reasoning_budget: z6.number(),
         temperature: z6.number(),
         top_p: z6.number(),
         max_tokens: z6.number(),
@@ -1995,11 +2013,13 @@ var init_generated_types = __esm({
         ]),
         n: z6.number(),
         stop: z6.array(z6.string()),
-        reasoning_effort: z6.enum(["minimal", "low", "medium", "high"]),
+        reasoning_effort: z6.enum(["none", "minimal", "low", "medium", "high"]),
         verbosity: z6.enum(["low", "medium", "high"])
       }).partial().passthrough(),
       z6.object({
         use_cache: z6.boolean().optional(),
+        reasoning_enabled: z6.boolean().optional(),
+        reasoning_budget: z6.number().optional(),
         max_tokens: z6.number(),
         temperature: z6.number(),
         top_p: z6.number().optional(),
@@ -2009,6 +2029,8 @@ var init_generated_types = __esm({
       }).passthrough(),
       z6.object({
         use_cache: z6.boolean(),
+        reasoning_enabled: z6.boolean(),
+        reasoning_budget: z6.number(),
         temperature: z6.number(),
         maxOutputTokens: z6.number(),
         topP: z6.number(),
@@ -2016,10 +2038,16 @@ var init_generated_types = __esm({
       }).partial().passthrough(),
       z6.object({
         use_cache: z6.boolean(),
+        reasoning_enabled: z6.boolean(),
+        reasoning_budget: z6.number(),
         temperature: z6.number(),
         topK: z6.number()
       }).partial().passthrough(),
-      z6.object({ use_cache: z6.boolean() }).partial().passthrough()
+      z6.object({
+        use_cache: z6.boolean(),
+        reasoning_enabled: z6.boolean(),
+        reasoning_budget: z6.number()
+      }).partial().passthrough()
     ]);
     PromptOptionsNullish = z6.union([
       z6.object({ model: z6.string(), params: ModelParams, position: z6.string() }).partial(),
@@ -2055,17 +2083,17 @@ var init_generated_types = __esm({
       z6.null()
     ]);
     FunctionTypeEnumNullish = z6.union([
-      z6.enum(["llm", "scorer", "task", "tool"]),
+      z6.enum(["llm", "scorer", "task", "tool", "custom_view"]),
       z6.null()
     ]);
     FunctionIdRef = z6.object({}).partial().passthrough();
     PromptBlockData = z6.union([
-      z6.object({ type: z6.literal("completion"), content: z6.string() }),
       z6.object({
         type: z6.literal("chat"),
         messages: z6.array(ChatCompletionMessageParam),
         tools: z6.string().optional()
-      })
+      }),
+      z6.object({ type: z6.literal("completion"), content: z6.string() })
     ]);
     GraphNode = z6.union([
       z6.object({
@@ -2133,7 +2161,7 @@ var init_generated_types = __esm({
           z6.object({
             type: z6.literal("inline"),
             runtime_context: z6.object({
-              runtime: z6.enum(["node", "python"]),
+              runtime: z6.enum(["node", "python", "browser"]),
               version: z6.string()
             }),
             code: z6.string()
@@ -2192,7 +2220,13 @@ var init_generated_types = __esm({
         z6.null()
       ])
     }).partial();
-    FunctionTypeEnum = z6.enum(["llm", "scorer", "task", "tool"]);
+    FunctionTypeEnum = z6.enum([
+      "llm",
+      "scorer",
+      "task",
+      "tool",
+      "custom_view"
+    ]);
     FunctionId = z6.union([
       z6.object({ function_id: z6.string(), version: z6.string().optional() }),
       z6.object({
@@ -2208,7 +2242,7 @@ var init_generated_types = __esm({
       }),
       z6.object({
         inline_context: z6.object({
-          runtime: z6.enum(["node", "python"]),
+          runtime: z6.enum(["node", "python", "browser"]),
           version: z6.string()
         }),
         code: z6.string(),
@@ -2231,7 +2265,8 @@ var init_generated_types = __esm({
       "tool",
       "scorer",
       "task",
-      "agent"
+      "agent",
+      "custom_view"
     ]);
     FunctionOutputType = z6.enum(["completion", "score", "any"]);
     GitMetadataSettings = z6.object({
@@ -2359,7 +2394,8 @@ var init_generated_types = __esm({
             })
           ),
           z6.null()
-        ])
+        ]),
+        disable_realtime_queries: z6.union([z6.boolean(), z6.null()])
       }).partial(),
       z6.null()
     ]);
@@ -2447,7 +2483,10 @@ var init_generated_types = __esm({
       root_span_id: z6.string(),
       is_root: z6.union([z6.boolean(), z6.null()]).optional(),
       span_attributes: SpanAttributes.optional(),
-      origin: ObjectReferenceNullish.optional()
+      origin: ObjectReferenceNullish.optional(),
+      comments: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
+      audit_data: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
+      _async_scoring_state: z6.unknown().optional()
     });
     ProjectScoreType = z6.enum([
       "slider",
@@ -2662,7 +2701,7 @@ var init_generated_types = __esm({
       z6.null()
     ]);
     ViewData = z6.union([
-      z6.object({ search: ViewDataSearch }).partial(),
+      z6.object({ search: ViewDataSearch, custom_charts: z6.unknown() }).partial(),
       z6.null()
     ]);
     ViewOptions = z6.union([
@@ -2728,7 +2767,8 @@ var init_generated_types = __esm({
           z6.string(),
           z6.object({ from: z6.string(), to: z6.string() }),
           z6.null()
-        ])
+        ]),
+        queryShape: z6.union([z6.enum(["traces", "spans"]), z6.null()])
       }).partial(),
       z6.null()
     ]);
@@ -2749,7 +2789,8 @@ var init_generated_types = __esm({
         "scorers",
         "logs",
         "agents",
-        "monitor"
+        "monitor",
+        "for_review"
       ]),
       name: z6.string(),
       created: z6.union([z6.string(), z6.null()]).optional(),
@@ -2933,7 +2974,7 @@ var init_stream = __esm({
       /**
        * Get the underlying ReadableStream.
        *
-       * @returns The underlying ReadableStream<BraintrustStreamChunk>.
+       * @returns The underlying `ReadableStream<BraintrustStreamChunk>`.
        */
       toReadableStream() {
         return this.stream;
@@ -6771,6 +6812,19 @@ function renderMessage(render, message) {
                 url: render(c.image_url.url)
               }
             };
+          case "file":
+            return {
+              ...c,
+              file: {
+                file_data: render(c.file.file_data || ""),
+                ...c.file.file_id && {
+                  file_id: render(c.file.file_id)
+                },
+                ...c.file.filename && {
+                  filename: render(c.file.filename)
+                }
+              }
+            };
           default:
             const _exhaustiveCheck = c;
             return _exhaustiveCheck;
@@ -8529,6 +8583,7 @@ Error: ${errorText}`;
                 },
                 use_columnstore: false,
                 brainstore_realtime: true,
+                query_source: `js_sdk_object_fetcher_${this.objectType}`,
                 ...this.pinnedVersion !== void 0 ? {
                   version: this.pinnedVersion
                 } : {}
@@ -12815,6 +12870,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 +13358,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 (!result?.providerMetadata) {
-    return void 0;
-  }
-  const keys = Object.keys(result.providerMetadata);
-  return keys?.at(0);
-}
-function extractModelFromResult(result) {
-  if (result?.response?.modelId) {
-    return result.response.modelId;
-  }
-  if (result?.request?.body?.model) {
-    return result.request.body.model;
-  }
-  return void 0;
-}
-function extractModelFromWrapGenerateCallback(model) {
-  return model?.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 = providerMetadata?.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 = step?.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(block.input ?? {})
-          }
-        });
-      }
-    }
-  }
-  return toolCalls;
-}
-function buildAssistantOutputWithToolCalls(result, toolCalls) {
-  return [
-    {
-      index: 0,
-      logprobs: null,
-      finish_reason: normalizeFinishReason(result?.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 params?.prompt ?? params?.messages ?? params?.system;
-}
+init_util();
 
 // src/wrappers/attachment-utils.ts
 init_logger();
@@ -13550,7 +13425,7 @@ function processInputAttachments(input) {
     return input;
   }
   let attachmentIndex = 0;
-  const processContentPart = (part) => {
+  const processContentPart2 = (part) => {
     if (!part || typeof part !== "object") {
       return part;
     }
@@ -13598,940 +13473,1437 @@ 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: config.spanInfo?.name || "ai-sdk.doGenerate",
+// src/wrappers/ai-sdk/ai-sdk.ts
+import { zodToJsonSchema } from "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 */,
-          ...config.spanInfo?.spanAttributes || {}
+          type: "llm" /* LLM */
         },
         event: {
-          input: processedInput,
+          input: processInputAttachments2(params),
           metadata: {
-            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ...config.spanInfo?.metadata || {}
+            model: serializeModel(params.model),
+            braintrust: {
+              integration_name: "ai-sdk",
+              sdk_language: "typescript"
+            }
           }
         }
-      };
-      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;
-          }
-        }
-        let toolCalls = extractToolCallsFromSteps(result?.steps);
-        if (!toolCalls || toolCalls.length === 0) {
-          toolCalls = extractToolCallsFromBlocks(result?.content);
-        }
-        span.log({
-          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : result?.content,
-          metadata,
-          metrics: normalizeUsageMetrics(
-            result.usage,
-            provider,
-            result.providerMetadata
-          )
+      }
+    );
+  };
+};
+var wrapGenerateObject = (generateObject, options = {}) => {
+  return async function wrappedGenerateObject(params) {
+    return traced(
+      async (span) => {
+        const result = await generateObject({
+          ...params,
+          tools: wrapTools(params.tools)
         });
-        return result;
-      } catch (error2) {
         span.log({
-          error: error2 instanceof Error ? error2.message : String(error2)
+          output: processOutput(result, options.denyOutputPaths),
+          metrics: extractTokenMetrics(result)
         });
-        throw error2;
-      } finally {
-        span.end();
-      }
-    },
-    wrapStream: async ({ doStream, params }) => {
-      const rawInput = extractInput(params);
-      const processedInput = processInputAttachments(rawInput);
-      const spanArgs = {
-        name: config.spanInfo?.name || "ai-sdk.doStream",
+        return result;
+      },
+      {
+        name: "generateObject",
         spanAttributes: {
-          type: "llm" /* LLM */,
-          ...config.spanInfo?.spanAttributes || {}
+          type: "llm" /* LLM */
         },
         event: {
-          input: processedInput,
+          input: processInputAttachments2(params),
           metadata: {
-            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ...config.spanInfo?.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)
-              });
-              span.end();
-              controller.error(error2);
-            }
-          },
-          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
-                  );
+                metrics: {
+                  time_to_first_token: (Date.now() - startTime) / 1e3
                 }
-              }
-              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;
             }
+            params.onChunk?.(chunk);
+          },
+          onFinish: async (event) => {
+            params.onFinish?.(event);
+            span.log({
+              output: await processOutput(event, options.denyOutputPaths),
+              metrics: extractTokenMetrics(event)
+            });
+            span.end();
+          },
+          onError: async (err) => {
+            params.onError?.(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 {
-          stream: stream.pipeThrough(transformStream),
-          ...rest
-        };
-      } catch (error2) {
-        span.log({
-          error: error2 instanceof Error ? error2.message : String(error2)
-        });
-        span.end();
-        throw error2;
       }
+      return result;
+    } catch (error2) {
+      span.log({
+        error: serializeError(error2)
+      });
+      span.end();
+      throw error2;
     }
   };
-}
-
-// src/wrappers/ai-sdk-4/ai-sdk.ts
-init_logger();
-init_util2();
-function wrapAISDKModel(model) {
-  const m = model;
-  if (m?.specificationVersion === "v1" && typeof m?.provider === "string" && typeof m?.modelId === "string") {
-    return new BraintrustLanguageModelWrapper(m);
-  } else {
-    console.warn("Unsupported AI SDK model. Not wrapping.");
-    return model;
-  }
-}
-var BraintrustLanguageModelWrapper = class {
-  constructor(model) {
-    this.model = model;
-    if (typeof this.model.supportsUrl === "function") {
-      this.supportsUrl = (url) => this.model.supportsUrl(url);
-    }
-  }
-  supportsUrl;
-  get specificationVersion() {
-    return this.model.specificationVersion;
-  }
-  get provider() {
-    return this.model.provider;
-  }
-  get modelId() {
-    return this.model.modelId;
-  }
-  get defaultObjectGenerationMode() {
-    return this.model.defaultObjectGenerationMode;
-  }
-  get supportsImageUrls() {
-    return this.model.supportsImageUrls;
-  }
-  get supportsStructuredOutputs() {
-    return this.model.supportsStructuredOutputs;
-  }
-  // For the first cut, do not support custom span_info arguments. We can
-  // propagate those via async local storage
-  async doGenerate(options) {
+};
+var wrapStreamObject = (streamObject, options = {}) => {
+  return function wrappedStreamObject(params) {
     const span = startSpan({
-      name: "Chat Completion",
+      name: "streamObject",
       spanAttributes: {
-        type: "llm"
+        type: "llm" /* LLM */
+      },
+      event: {
+        input: processInputAttachments2(params),
+        metadata: {
+          model: serializeModel(params.model),
+          braintrust: {
+            integration_name: "ai-sdk",
+            sdk_language: "typescript"
+          }
+        }
       }
     });
-    const { prompt, mode, ...rest } = options;
-    const startTime = getCurrentUnixTimestamp();
     try {
-      const ret = await this.model.doGenerate(options);
-      span.log({
-        input: postProcessPrompt(prompt),
-        metadata: {
-          model: this.modelId,
-          ...rest,
-          ..."tools" in mode && mode.tools ? { tools: convertTools(mode.tools) } : "tool" in mode && mode.tool ? { tools: convertTools([mode.tool]) } : {}
-        },
-        output: postProcessOutput(ret.text, ret.toolCalls, ret.finishReason),
-        metrics: {
-          time_to_first_token: getCurrentUnixTimestamp() - startTime,
-          tokens: !isEmpty(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: ret.usage?.promptTokens,
-          completion_tokens: ret.usage?.completionTokens,
-          cached: parseCachedHeader(
-            ret.rawResponse?.headers?.[X_CACHED_HEADER] ?? ret.rawResponse?.headers?.[LEGACY_CACHED_HEADER]
-          )
+      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({
+                metrics: {
+                  time_to_first_token: (Date.now() - startTime) / 1e3
+                }
+              });
+            }
+            params.onChunk?.(chunk);
+          },
+          onFinish: async (event) => {
+            params.onFinish?.(event);
+            span.log({
+              output: await processOutput(event, options.denyOutputPaths),
+              metrics: extractTokenMetrics(event)
+            });
+            span.end();
+          },
+          onError: async (err) => {
+            params.onError?.(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)
       });
-      return ret;
-    } finally {
       span.end();
+      throw error2;
     }
-  }
-  async doStream(options) {
-    const { prompt, mode, ...rest } = options;
-    const startTime = getCurrentUnixTimestamp();
-    const span = startSpan({
-      name: "Chat Completion",
-      spanAttributes: {
-        type: "llm"
-      }
+  };
+};
+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);
     });
-    span.log({
-      input: postProcessPrompt(prompt),
-      metadata: {
-        model: this.modelId,
-        ...rest,
-        ..."tools" in mode && mode.tools ? { tools: convertTools(mode.tools) } : "tool" in mode && mode.tool ? { tools: convertTools([mode.tool]) } : {}
+  }
+  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;
       }
     });
-    let ended = false;
-    const end = () => {
-      if (!ended) {
-        span.end();
-        ended = true;
-      }
-    };
+  }
+  return tool;
+};
+var serializeError = (error2) => {
+  if (error2 instanceof Error) {
+    return error2;
+  }
+  if (typeof error2 === "object" && error2 !== null) {
     try {
-      const ret = await this.model.doStream(options);
-      let time_to_first_token = void 0;
-      let usage = void 0;
-      let fullText = void 0;
-      const toolCalls = {};
-      let finishReason = void 0;
-      return {
-        ...ret,
-        stream: ret.stream.pipeThrough(
-          new TransformStream({
-            transform(chunk, controller) {
-              if (time_to_first_token === void 0) {
-                time_to_first_token = getCurrentUnixTimestamp() - startTime;
-                span.log({ metrics: { time_to_first_token } });
-              }
-              switch (chunk.type) {
-                case "text-delta":
-                  if (fullText === void 0) {
-                    fullText = "";
-                  }
-                  fullText += chunk.textDelta;
-                  break;
-                case "tool-call":
-                  toolCalls[chunk.toolCallId] = {
-                    toolCallType: chunk.toolCallType,
-                    toolCallId: chunk.toolCallId,
-                    toolName: chunk.toolName,
-                    args: chunk.args
-                  };
-                  break;
-                case "tool-call-delta":
-                  if (toolCalls[chunk.toolCallId] === void 0) {
-                    toolCalls[chunk.toolCallId] = {
-                      toolCallType: chunk.toolCallType,
-                      toolCallId: chunk.toolCallId,
-                      toolName: chunk.toolName,
-                      args: ""
-                    };
-                  }
-                  toolCalls[chunk.toolCallId].args += chunk.argsTextDelta;
-                  break;
-                case "finish":
-                  usage = chunk.usage;
-                  finishReason = chunk.finishReason;
-                  break;
-              }
-              controller.enqueue(chunk);
-            },
-            async flush(controller) {
-              span.log({
-                output: postProcessOutput(
-                  fullText,
-                  Object.keys(toolCalls).length > 0 ? Object.values(toolCalls) : void 0,
-                  finishReason
-                ),
-                metrics: {
-                  time_to_first_token,
-                  tokens: !isEmpty(usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: usage?.promptTokens,
-                  completion_tokens: usage?.completionTokens,
-                  cached: parseCachedHeader(
-                    ret.rawResponse?.headers?.[X_CACHED_HEADER] ?? ret.rawResponse?.headers?.[LEGACY_CACHED_HEADER]
-                  )
-                }
-              });
-              end();
-              controller.terminate();
-            }
-          })
-        )
-      };
-    } finally {
-      end();
+      return JSON.stringify(error2);
+    } catch {
     }
   }
+  return String(error2);
 };
-function convertTools(tools) {
-  return tools.map((tool) => {
-    const { type: _, ...rest } = tool;
+var serializeModel = (model) => {
+  return typeof model === "string" ? model : model?.modelId;
+};
+var isZodSchema = (value) => {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+};
+var serializeZodSchema = (schema) => {
+  try {
+    return zodToJsonSchema(schema);
+  } catch {
     return {
-      type: tool.type,
-      function: rest
+      type: "object",
+      description: "Zod schema (conversion failed)"
     };
-  });
-}
-function postProcessPrompt(prompt) {
-  return prompt.flatMap((message) => {
-    switch (message.role) {
-      case "system":
-        return [
-          {
-            role: "system",
-            content: message.content
-          }
-        ];
-      case "assistant":
-        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"
-          )
-        );
-        return [
-          {
-            role: "assistant",
-            content: textPart?.text,
-            ...toolCallParts.length > 0 ? {
-              tool_calls: toolCallParts.map((part) => ({
-                id: part.toolCallId,
-                function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.args)
-                },
-                type: "function"
-              }))
-            } : {}
-          }
-        ];
-      case "user":
-        return [
-          {
-            role: "user",
-            content: message.content.map((part) => {
-              switch (part.type) {
-                case "text":
-                  return {
-                    type: "text",
-                    text: part.text,
-                    ...part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}
-                  };
-                case "image":
-                  return {
-                    type: "image_url",
-                    image_url: {
-                      url: part.image.toString(),
-                      ...part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}
-                    }
-                  };
-                default:
-                  return part;
-              }
-            })
-          }
-        ];
-      case "tool":
-        return message.content.map((part) => ({
-          role: "tool",
-          tool_call_id: part.toolCallId,
-          content: JSON.stringify(part.result)
-        }));
+  }
+};
+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)
+      };
     }
-  });
-}
-function postProcessOutput(text, toolCalls, finishReason) {
-  return [
-    {
-      index: 0,
-      message: {
-        role: "assistant",
-        content: 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
+  }
+  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 {
+          ...part,
+          image: imageAttachment
+        };
+      }
+    }
+    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 = mimeTypeSection.match(/data:(.*?);/)?.[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
+        });
+      }
+    }
+    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"
   ];
-}
-
-// src/wrappers/ai-sdk-5/ai-sdk.ts
-init_logger();
-var V3_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
-  "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;
+  for (const name of getterNames) {
+    try {
+      if (obj && name in obj && typeof obj[name] !== "function") {
+        getterValues[name] = obj[name];
+      }
+    } catch {
+    }
+  }
+  return getterValues;
+};
+var processOutput = async (output, denyOutputPaths) => {
+  const getterValues = extractGetterValues(output);
+  const processed = await processOutputAttachments(output);
+  const merged = { ...processed, ...getterValues };
+  return omit(merged, 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 files.map((file, index) => {
+  return output;
+};
+var convertFileToAttachment = (file, index) => {
+  try {
     const mediaType = file.mediaType || "application/octet-stream";
     const filename = `generated_file_${index}.${getExtensionFromMediaType(mediaType)}`;
-    const blob = convertDataToBlob(file.data, 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) {
-      return null;
+      console.warn(`Failed to convert file at index ${index} to Blob`);
+      return file;
     }
     return new Attachment({
       data: blob,
       filename,
       contentType: mediaType
     });
-  }).filter((attachment) => attachment !== null);
+  } catch (error2) {
+    console.warn(`Error processing file at index ${index}:`, error2);
+    return file;
+  }
+};
+function extractTokenMetrics(result) {
+  const metrics2 = {};
+  const usage = result?.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;
 }
-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(result?.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,
-          metadata: {
-            ...extractModelParameters(params, V3_EXCLUDE_KEYS),
-            ...provider ? { provider } : {},
-            ...model ? { model } : {},
-            ...finishReason ? { finish_reason: finishReason } : {}
-          }
-        });
-        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 provider = detectProviderFromResult(result);
-        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 } : {}
-          }
-        });
-        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)
+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);
       }
-    });
-    const userOnFinish = params.onFinish;
-    const userOnError = params.onError;
-    const userOnChunk = params.onChunk;
-    try {
-      const wrappedModel = wrapLanguageModel({
-        model: params.model,
-        middleware: BraintrustMiddleware({ spanInfo })
+    } 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);
+        }
       });
-      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;
-              span.log({
-                metrics: {
-                  time_to_first_token: (Date.now() - startTime) / 1e3
-                }
-              });
-            }
-            if (typeof userOnChunk === "function") {
-              userOnChunk(chunk);
-            }
-          },
-          onFinish: async (event) => {
-            if (typeof userOnFinish === "function") {
-              await userOnFinish(event);
-            }
-            const provider = detectProviderFromResult(event);
-            const model = extractModelFromResult(event);
-            const finishReason = normalizeFinishReason(event?.finishReason);
-            const outputAttachments = processFilesAsAttachments(event.files);
-            const output = outputAttachments ? {
-              text: event?.text || event?.content,
-              files: outputAttachments
-            } : event?.text || event?.content;
-            span.log({
-              output,
-              metadata: {
-                ...extractModelParameters(params, V3_EXCLUDE_KEYS),
-                ...provider ? { provider } : {},
-                ...model ? { model } : {},
-                ...finishReason ? { finish_reason: finishReason } : {}
-              }
-            });
-            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) {
+    }
+  } 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/deprecated/wrapAISDKModel.ts
+init_logger();
+init_util2();
+function wrapAISDKModel(model) {
+  const m = model;
+  if (m?.specificationVersion === "v1" && typeof m?.provider === "string" && typeof m?.modelId === "string") {
+    return new BraintrustLanguageModelWrapper(m);
+  } else {
+    console.warn("Unsupported AI SDK model. Not wrapping.");
+    return model;
+  }
+}
+var BraintrustLanguageModelWrapper = class {
+  constructor(model) {
+    this.model = model;
+    if (typeof this.model.supportsUrl === "function") {
+      this.supportsUrl = (url) => this.model.supportsUrl(url);
+    }
+  }
+  supportsUrl;
+  get specificationVersion() {
+    return this.model.specificationVersion;
+  }
+  get provider() {
+    return this.model.provider;
+  }
+  get modelId() {
+    return this.model.modelId;
+  }
+  get defaultObjectGenerationMode() {
+    return this.model.defaultObjectGenerationMode;
+  }
+  get supportsImageUrls() {
+    return this.model.supportsImageUrls;
+  }
+  get supportsStructuredOutputs() {
+    return this.model.supportsStructuredOutputs;
+  }
+  // For the first cut, do not support custom span_info arguments. We can
+  // propagate those via async local storage
+  async doGenerate(options) {
+    const span = startSpan({
+      name: "Chat Completion",
+      spanAttributes: {
+        type: "llm"
+      }
+    });
+    const { prompt, mode, ...rest } = options;
+    const startTime = getCurrentUnixTimestamp();
+    try {
+      const ret = await this.model.doGenerate(options);
       span.log({
-        error: error2 instanceof Error ? error2.message : String(error2)
+        input: postProcessPrompt(prompt),
+        metadata: {
+          model: this.modelId,
+          ...rest,
+          ..."tools" in mode && mode.tools ? { tools: convertTools(mode.tools) } : "tool" in mode && mode.tool ? { tools: convertTools([mode.tool]) } : {}
+        },
+        output: postProcessOutput(ret.text, ret.toolCalls, ret.finishReason),
+        metrics: {
+          time_to_first_token: getCurrentUnixTimestamp() - startTime,
+          tokens: !isEmpty(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
+          prompt_tokens: ret.usage?.promptTokens,
+          completion_tokens: ret.usage?.completionTokens,
+          cached: parseCachedHeader(
+            ret.rawResponse?.headers?.[X_CACHED_HEADER] ?? ret.rawResponse?.headers?.[LEGACY_CACHED_HEADER]
+          )
+        }
       });
+      return ret;
+    } finally {
       span.end();
-      throw error2;
     }
-  };
-  const wrappedStreamObject = (params) => {
-    const { spanInfo } = extractSpanInfo(params);
-    const input = processInputAttachments(extractInput(params));
+  }
+  async doStream(options) {
+    const { prompt, mode, ...rest } = options;
+    const startTime = getCurrentUnixTimestamp();
     const span = startSpan({
-      name: "ai-sdk.streamObject",
-      event: {
-        input,
-        metadata: extractModelParameters(params, V3_EXCLUDE_KEYS)
+      name: "Chat Completion",
+      spanAttributes: {
+        type: "llm"
       }
     });
-    const userOnFinish = params.onFinish;
-    const userOnError = params.onError;
+    span.log({
+      input: postProcessPrompt(prompt),
+      metadata: {
+        model: this.modelId,
+        ...rest,
+        ..."tools" in mode && mode.tools ? { tools: convertTools(mode.tools) } : "tool" in mode && mode.tool ? { tools: convertTools([mode.tool]) } : {}
+      }
+    });
+    let ended = false;
+    const end = () => {
+      if (!ended) {
+        span.end();
+        ended = true;
+      }
+    };
     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(event?.finishReason);
-            const outputAttachments = processFilesAsAttachments(event.files);
-            const output = outputAttachments ? { object: event?.object, files: outputAttachments } : event?.object;
-            span.log({
-              output,
-              metadata: {
-                ...extractModelParameters(params, V3_EXCLUDE_KEYS),
-                ...provider ? { provider } : {},
-                ...model ? { model } : {},
-                ...finishReason ? { finish_reason: finishReason } : {}
+      const ret = await this.model.doStream(options);
+      let time_to_first_token = void 0;
+      let usage = void 0;
+      let fullText = void 0;
+      const toolCalls = {};
+      let finishReason = void 0;
+      return {
+        ...ret,
+        stream: ret.stream.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              if (time_to_first_token === void 0) {
+                time_to_first_token = getCurrentUnixTimestamp() - startTime;
+                span.log({ metrics: { time_to_first_token } });
               }
-            });
-            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
+              switch (chunk.type) {
+                case "text-delta":
+                  if (fullText === void 0) {
+                    fullText = "";
+                  }
+                  fullText += chunk.textDelta;
+                  break;
+                case "tool-call":
+                  toolCalls[chunk.toolCallId] = {
+                    toolCallType: chunk.toolCallType,
+                    toolCallId: chunk.toolCallId,
+                    toolName: chunk.toolName,
+                    args: chunk.args
+                  };
+                  break;
+                case "tool-call-delta":
+                  if (toolCalls[chunk.toolCallId] === void 0) {
+                    toolCalls[chunk.toolCallId] = {
+                      toolCallType: chunk.toolCallType,
+                      toolCallId: chunk.toolCallId,
+                      toolName: chunk.toolName,
+                      args: ""
+                    };
+                  }
+                  toolCalls[chunk.toolCallId].args += chunk.argsTextDelta;
+                  break;
+                case "finish":
+                  usage = chunk.usage;
+                  finishReason = chunk.finishReason;
+                  break;
+              }
+              controller.enqueue(chunk);
+            },
+            async flush(controller) {
+              span.log({
+                output: postProcessOutput(
+                  fullText,
+                  Object.keys(toolCalls).length > 0 ? Object.values(toolCalls) : void 0,
+                  finishReason
+                ),
+                metrics: {
+                  time_to_first_token,
+                  tokens: !isEmpty(usage) ? usage.promptTokens + usage.completionTokens : void 0,
+                  prompt_tokens: usage?.promptTokens,
+                  completion_tokens: usage?.completionTokens,
+                  cached: parseCachedHeader(
+                    ret.rawResponse?.headers?.[X_CACHED_HEADER] ?? ret.rawResponse?.headers?.[LEGACY_CACHED_HEADER]
+                  )
+                }
+              });
+              end();
+              controller.terminate();
             }
-          });
-        }
+          })
+        )
       };
-      const [stream1, stream2] = result.baseStream.tee();
-      result.baseStream = stream2;
-      stream1.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            trackFirstAccess();
-            controller.enqueue(chunk);
+    } finally {
+      end();
+    }
+  }
+};
+function convertTools(tools) {
+  return tools.map((tool) => {
+    const { type: _, ...rest } = tool;
+    return {
+      type: tool.type,
+      function: rest
+    };
+  });
+}
+function postProcessPrompt(prompt) {
+  return prompt.flatMap((message) => {
+    switch (message.role) {
+      case "system":
+        return [
+          {
+            role: "system",
+            content: message.content
           }
-        })
-      ).pipeTo(
-        new WritableStream({
-          write() {
+        ];
+      case "assistant":
+        const textPart = message.content.find(
+          (part) => part.type === "text"
+        );
+        const toolCallParts = message.content.filter(
+          (part) => part.type === "tool-call"
+        );
+        return [
+          {
+            role: "assistant",
+            content: textPart?.text,
+            ...toolCallParts.length > 0 ? {
+              tool_calls: toolCallParts.map((part) => ({
+                id: part.toolCallId,
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.args)
+                },
+                type: "function"
+              }))
+            } : {}
           }
-        })
-      ).catch(() => {
-      });
-      return result;
-    } catch (error2) {
-      span.log({
-        error: error2 instanceof Error ? error2.message : String(error2)
-      });
-      span.end();
-      throw error2;
+        ];
+      case "user":
+        return [
+          {
+            role: "user",
+            content: message.content.map((part) => {
+              switch (part.type) {
+                case "text":
+                  return {
+                    type: "text",
+                    text: part.text,
+                    ...part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}
+                  };
+                case "image":
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.image.toString(),
+                      ...part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}
+                    }
+                  };
+                default:
+                  return part;
+              }
+            })
+          }
+        ];
+      case "tool":
+        return message.content.map((part) => ({
+          role: "tool",
+          tool_call_id: part.toolCallId,
+          content: JSON.stringify(part.result)
+        }));
     }
-  };
+  });
+}
+function postProcessOutput(text, toolCalls, finishReason) {
+  return [
+    {
+      index: 0,
+      message: {
+        role: "assistant",
+        content: 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 {
-    generateText: wrappedGenerateText,
-    generateObject: wrappedGenerateObject,
-    streamText: wrappedStreamText,
-    streamObject: wrappedStreamObject
+    ...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/mastra/mastra.ts
-init_logger();
-var aiSDKFormatWarning = false;
-function wrapMastraAgent(agent, options) {
-  const prefix = options?.name ?? options?.span_name ?? agent.name ?? "Agent";
-  if (!hasAllMethods(agent)) {
-    return agent;
+// src/wrappers/ai-sdk/deprecated/BraintrustMiddleware.ts
+function detectProviderFromResult(result) {
+  if (!result?.providerMetadata) {
+    return void 0;
   }
-  if (agent.tools) {
-    agent.__setTools(wrapTools(agent.tools));
+  const keys = Object.keys(result.providerMetadata);
+  return keys?.at(0);
+}
+function extractModelFromResult(result) {
+  if (result?.response?.modelId) {
+    return result.response.modelId;
   }
-  return new Proxy(agent, {
-    get(target, prop, receiver) {
-      const value = Reflect.get(target, prop, receiver);
-      if (prop === "generate" && typeof value === "function") {
-        return wrapGenerate(value, target, prefix);
-      }
-      if (prop === "stream" && typeof value === "function") {
-        return wrapStream(value, target, prefix);
+  if (result?.request?.body?.model) {
+    return result.request.body.model;
+  }
+  return void 0;
+}
+function extractModelFromWrapGenerateCallback(model) {
+  return model?.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 = providerMetadata?.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: normalizeFinishReason(result?.finishReason) ?? (toolCalls.length ? "tool_calls" : void 0),
+      message: {
+        role: "assistant",
+        tool_calls: toolCalls.length > 0 ? toolCalls : void 0
       }
-      if (typeof value === "function") {
-        return value.bind(target);
+    }
+  ];
+}
+function extractToolCallsFromSteps(steps) {
+  const toolCalls = [];
+  if (!Array.isArray(steps)) return toolCalls;
+  let idx = 0;
+  for (const step of steps) {
+    const blocks = step?.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(block.input ?? {})
+          }
+        });
       }
-      return value;
     }
-  });
+  }
+  return toolCalls;
 }
-function hasAllMethods(a) {
-  return typeof a.generate === "function" && typeof a.stream === "function";
+function extractToolCallsFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return [];
+  return extractToolCallsFromSteps([{ content: blocks }]);
 }
-function wrapGenerate(original, target, prefix) {
-  return function(...args) {
-    const input = args[0];
-    return traced(
-      async (span) => {
-        const result = await original.apply(target, args);
+function extractInput(params) {
+  return params?.prompt ?? params?.messages ?? params?.system;
+}
+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: config.spanInfo?.name || "ai-sdk.doGenerate",
+        spanAttributes: {
+          type: "llm" /* LLM */,
+          ...config.spanInfo?.spanAttributes || {}
+        },
+        event: {
+          input: processedInput,
+          metadata: {
+            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
+            ...config.spanInfo?.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);
-        const finishReason = normalizeFinishReason(result?.finishReason);
-        const metrics2 = result?.usage ? normalizeUsageMetrics(
-          result.usage,
-          provider,
-          result.providerMetadata
-        ) : {};
+        if (model !== void 0) {
+          metadata.model = model;
+        } else if (modelFromWrapGenerate) {
+          const modelId = extractModelFromWrapGenerateCallback(
+            modelFromWrapGenerate
+          );
+          if (modelId) {
+            metadata.model = modelId;
+          }
+        }
+        let toolCalls = extractToolCallsFromSteps(result?.steps);
+        if (!toolCalls || toolCalls.length === 0) {
+          toolCalls = extractToolCallsFromBlocks(result?.content);
+        }
         span.log({
-          input,
-          output: result,
-          metadata: {
-            agent_name: target.name ?? prefix,
-            ...provider ? { provider } : {},
-            ...model ? { model } : {},
-            ...finishReason ? { finish_reason: finishReason } : {}
-          },
-          metrics: metrics2
+          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : result?.content,
+          metadata,
+          metrics: normalizeUsageMetrics(
+            result.usage,
+            provider,
+            result.providerMetadata
+          )
         });
         return result;
-      },
-      {
-        name: `${prefix}.generate`
-      }
-    );
-  };
-}
-function wrapStream(original, target, prefix) {
-  return function(...args) {
-    const input = args[0];
-    const span = startSpan({
-      name: `${prefix}.stream`,
-      event: {
-        input,
-        metadata: {
-          agent_name: target.name ?? prefix
-        }
-      }
-    });
-    const baseOpts = typeof args[1] === "object" && args[1] !== null ? args[1] : {};
-    if (baseOpts.format && baseOpts.format !== "aisdk" && !aiSDKFormatWarning) {
-      aiSDKFormatWarning = true;
-      console.warn(
-        `Braintrust Mastra wrapper: For best compatibility, use { format: 'aisdk' } (AI SDK v5) instead of format: '${baseOpts.format}'. See https://mastra.ai/en/docs/frameworks/agentic-uis/ai-sdk for more details.`
-      );
-    }
-    const wrappedOpts = {
-      ...baseOpts,
-      format: baseOpts.format || "aisdk"
-      // Default to AI SDK v5 format if not specified
-    };
-    const userOnChunk = baseOpts?.onChunk;
-    const userOnFinish = baseOpts?.onFinish;
-    const userOnError = baseOpts?.onError;
-    const startTime = Date.now();
-    let receivedFirst = false;
-    wrappedOpts.onChunk = (chunk) => {
-      try {
-        userOnChunk?.(chunk);
-      } finally {
-        if (!receivedFirst) {
-          receivedFirst = true;
-          span.log({
-            metrics: { time_to_first_token: (Date.now() - startTime) / 1e3 }
-          });
-        }
-      }
-    };
-    wrappedOpts.onFinish = async (event) => {
-      try {
-        await userOnFinish?.(event);
-      } finally {
-        const e = event;
-        const provider = detectProviderFromResult(e);
-        const model = extractModelFromResult(e);
-        const finishReason = normalizeFinishReason(e?.finishReason);
-        const metrics2 = e?.usage ? normalizeUsageMetrics(e.usage, provider, e.providerMetadata) : {};
+      } catch (error2) {
         span.log({
-          output: e.text ?? e.content ?? e,
-          metadata: {
-            agent_name: target.name ?? prefix,
-            ...provider ? { provider } : {},
-            ...model ? { model } : {},
-            ...finishReason ? { finish_reason: finishReason } : {}
-          },
-          metrics: metrics2
+          error: error2 instanceof Error ? error2.message : String(error2)
         });
+        throw error2;
+      } finally {
         span.end();
       }
-    };
-    wrappedOpts.onError = async (err) => {
+    },
+    wrapStream: async ({ doStream, params }) => {
+      const rawInput = extractInput(params);
+      const processedInput = processInputAttachments(rawInput);
+      const spanArgs = {
+        name: config.spanInfo?.name || "ai-sdk.doStream",
+        spanAttributes: {
+          type: "llm" /* LLM */,
+          ...config.spanInfo?.spanAttributes || {}
+        },
+        event: {
+          input: processedInput,
+          metadata: {
+            ...extractModelParameters(params, V2_EXCLUDE_KEYS),
+            ...config.spanInfo?.metadata || {}
+          }
+        }
+      };
+      const span = startSpan(spanArgs);
       try {
-        await userOnError?.(err);
-      } finally {
-        logError(span, err);
+        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({
+                error: error2 instanceof Error ? error2.message : String(error2)
+              });
+              span.end();
+              controller.error(error2);
+            }
+          },
+          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) {
+              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 withCurrent(
-      span,
-      () => original.apply(target, [args[0], wrappedOpts, ...args.slice(2)])
-    );
+    }
   };
 }
 
@@ -14610,10 +14982,14 @@ function createProxy(create) {
       const apiPromise = Reflect.apply(target, thisArg, argArray);
       const onThen = function(msgOrStream) {
         if (!args["stream"]) {
+          const ttft = getCurrentUnixTimestamp() - sspan.startTime;
           const event = parseEventFromMessage(msgOrStream);
           span.log({
             ...event,
-            metrics: event.metrics ? finalizeAnthropicTokens(event.metrics) : void 0
+            metrics: event.metrics ? finalizeAnthropicTokens({
+              ...event.metrics,
+              time_to_first_token: ttft
+            }) : { time_to_first_token: ttft }
           });
           span.end();
           return msgOrStream;
@@ -14829,6 +15205,11 @@ function coalesceInput(messages, system) {
   return input;
 }
 
+// src/wrappers/mastra.ts
+function wrapMastraAgent(agent, _options) {
+  return agent;
+}
+
 // src/wrappers/claude-agent-sdk/claude-agent-sdk.ts
 init_logger();
 init_util2();
@@ -14892,7 +15273,7 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
         }
         const lastMessage = currentMessages[currentMessages.length - 1];
         if (lastMessage?.message?.usage) {
-          const outputTokens = getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
+          const outputTokens = getNumberProperty2(lastMessage.message.usage, "output_tokens") || 0;
           accumulatedOutputTokens += outputTokens;
         }
         currentMessages.length = 0;
@@ -15007,16 +15388,16 @@ function _extractUsageFromMessage(message) {
   if (!usage || typeof usage !== "object") {
     return metrics2;
   }
-  const inputTokens = getNumberProperty(usage, "input_tokens");
+  const inputTokens = getNumberProperty2(usage, "input_tokens");
   if (inputTokens !== void 0) {
     metrics2.prompt_tokens = inputTokens;
   }
-  const outputTokens = getNumberProperty(usage, "output_tokens");
+  const outputTokens = getNumberProperty2(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 = getNumberProperty2(usage, "cache_read_input_tokens") || 0;
+  const cacheCreationTokens = getNumberProperty2(usage, "cache_creation_input_tokens") || 0;
   if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
     const cacheTokens = extractAnthropicCacheTokens(
       cacheReadTokens,
@@ -15107,6 +15488,13 @@ function wrapClaudeAgentSDK(sdk) {
     }
   });
 }
+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/google-genai.ts
 init_logger();