braintrust 3.6.0 → 3.7.0

package/dev/dist/index.js

@@ -24,25 +24,51 @@ function patchTracingChannel(tracingChannelFn) {
   if (TracingChannel.prototype.tracePromise) {
     TracingChannel.prototype.tracePromise = function(fn, context = {}, thisArg, ...args) {
       const { start, end, asyncStart, asyncEnd, error } = this;
-      function reject2(err) {
+      function publishRejected(err) {
         context.error = err;
         _optionalChain([error, 'optionalAccess', _14 => _14.publish, 'call', _15 => _15(context)]);
         _optionalChain([asyncStart, 'optionalAccess', _16 => _16.publish, 'call', _17 => _17(context)]);
         _optionalChain([asyncEnd, 'optionalAccess', _18 => _18.publish, 'call', _19 => _19(context)]);
-        return Promise.reject(err);
       }
-      function resolve(result) {
+      function publishResolved(result) {
         context.result = result;
         _optionalChain([asyncStart, 'optionalAccess', _20 => _20.publish, 'call', _21 => _21(context)]);
         _optionalChain([asyncEnd, 'optionalAccess', _22 => _22.publish, 'call', _23 => _23(context)]);
-        return result;
       }
       return start.runStores(context, () => {
         try {
           const result = Reflect.apply(fn, thisArg, args);
           _optionalChain([end, 'optionalAccess', _24 => _24.publish, 'call', _25 => _25(context)]);
           if (result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function") {
-            return result.then(resolve, reject2);
+            if (result.constructor === Promise) {
+              return result.then(
+                (res) => {
+                  publishResolved(res);
+                  return res;
+                },
+                (err) => {
+                  publishRejected(err);
+                  return Promise.reject(err);
+                }
+              );
+            }
+            void result.then(
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              (resolved) => {
+                try {
+                  publishResolved(resolved);
+                } catch (e2) {
+                }
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              (err) => {
+                try {
+                  publishRejected(err);
+                } catch (e3) {
+                }
+              }
+            );
+            return result;
           }
           context.result = result;
           _optionalChain([asyncStart, 'optionalAccess', _26 => _26.publish, 'call', _27 => _27(context)]);
@@ -279,7 +305,7 @@ async function currentRepo() {
     } else {
       return null;
     }
-  } catch (e2) {
+  } catch (e4) {
     return null;
   }
 }
@@ -312,7 +338,7 @@ async function getBaseBranch(remote = void 0) {
           throw new Error(`Could not find HEAD branch in remote ${remoteName}`);
         }
         branch = match[1];
-      } catch (e3) {
+      } catch (e5) {
         branch = "main";
       }
     }
@@ -335,7 +361,7 @@ async function getBaseBranchAncestor(remote = void 0) {
       `${remoteName}/${baseBranch}`
     ]);
     return ancestor.trim();
-  } catch (e4) {
+  } catch (e6) {
     return void 0;
   }
 }
@@ -362,7 +388,7 @@ async function getPastNAncestors(n = 1e3, remote = void 0) {
 async function attempt(fn) {
   try {
     return await fn();
-  } catch (e5) {
+  } catch (e7) {
     return void 0;
   }
 }
@@ -983,7 +1009,7 @@ function tryMakeUuid3(s) {
       throw new Error();
     }
     return { bytes: new Uint8Array(ret), isUUID: true };
-  } catch (e6) {
+  } catch (e8) {
     return { bytes: void 0, isUUID: false };
   }
 }
@@ -1147,7 +1173,7 @@ var SpanComponentsV3 = class _SpanComponentsV3 {
         }
       }
       return _SpanComponentsV3.fromJsonObj(jsonObj);
-    } catch (e7) {
+    } catch (e9) {
       throw new Error(INVALID_ENCODING_ERRMSG3);
     }
   }
@@ -1506,7 +1532,7 @@ function tryMakeHexTraceId(s) {
       }
       return { bytes, isHex: true };
     }
-  } catch (e8) {
+  } catch (e10) {
   }
   return { bytes: void 0, isHex: false };
 }
@@ -1522,7 +1548,7 @@ function tryMakeHexSpanId(s) {
       }
       return { bytes, isHex: true };
     }
-  } catch (e9) {
+  } catch (e11) {
   }
   return { bytes: void 0, isHex: false };
 }
@@ -1671,7 +1697,7 @@ var SpanComponentsV4 = class _SpanComponentsV4 {
         }
       }
       return _SpanComponentsV4.fromJsonObj(jsonObj);
-    } catch (e10) {
+    } catch (e12) {
       throw new Error(INVALID_ENCODING_ERRMSG_V4);
     }
   }
@@ -3612,7 +3638,7 @@ function getMustacheVars(prompt) {
     return _mustache2.default.parse(prompt).filter(
       (span) => span[0] === "name" || span[0] === "&"
     );
-  } catch (e11) {
+  } catch (e13) {
     return [];
   }
 }
@@ -4371,13 +4397,13 @@ var SpanCache = (_class6 = class {
               cache.fileHandle.close().catch(() => {
               });
               cache.fileHandle = null;
-            } catch (e12) {
+            } catch (e14) {
             }
           }
           if (cache.cacheFilePath && canUseSpanCache() && isomorph_default.unlinkSync) {
             try {
               isomorph_default.unlinkSync(cache.cacheFilePath);
-            } catch (e13) {
+            } catch (e15) {
             }
           }
         }
@@ -4474,10 +4500,10 @@ var SpanCache = (_class6 = class {
             } else {
               spanMap.set(record.spanId, record.data);
             }
-          } catch (e14) {
+          } catch (e16) {
           }
         }
-      } catch (e15) {
+      } catch (e17) {
       }
     }
     for (const record of this.writeBuffer) {
@@ -4549,7 +4575,7 @@ var SpanCache = (_class6 = class {
     if (this.cacheFilePath && canUseSpanCache() && isomorph_default.unlinkSync) {
       try {
         isomorph_default.unlinkSync(this.cacheFilePath);
-      } catch (e16) {
+      } catch (e18) {
       }
       this.cacheFilePath = null;
     }
@@ -5130,7 +5156,7 @@ var HTTPConnection = class _HTTPConnection {
     try {
       const resp = await this.get("ping");
       return resp.status === 200;
-    } catch (e17) {
+    } catch (e19) {
       return false;
     }
   }
@@ -8373,7 +8399,7 @@ function isURL(url) {
   try {
     const parsedUrl = new URL(url.trim());
     return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
-  } catch (e18) {
+  } catch (e20) {
     return false;
   }
 }
@@ -9759,7 +9785,7 @@ function convertDataToBlob(data, mediaType) {
     } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
       return new Blob([data], { type: mediaType });
     }
-  } catch (e19) {
+  } catch (e21) {
     return null;
   }
   return null;
@@ -10468,7 +10494,7 @@ var AnthropicPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(anthropicChannels.betaMessagesCreate, {
         ...anthropicConfig,
-        name: "anthropic.beta.messages.create"
+        name: "anthropic.messages.create"
       })
     );
   }
@@ -10491,9 +10517,12 @@ function parseMetricsFromUsage2(usage) {
   return metrics;
 }
 function aggregateAnthropicStreamChunks(chunks) {
-  const deltas = [];
+  const fallbackTextDeltas = [];
+  const contentBlocks = {};
+  const contentBlockDeltas = {};
   let metrics = {};
   let metadata = {};
+  let role;
   for (const event of chunks) {
     switch (_optionalChain([event, 'optionalAccess', _179 => _179.type])) {
       case "message_start":
@@ -10501,15 +10530,43 @@ function aggregateAnthropicStreamChunks(chunks) {
           const initialMetrics = parseMetricsFromUsage2(event.message.usage);
           metrics = { ...metrics, ...initialMetrics };
         }
+        if (typeof _optionalChain([event, 'access', _182 => _182.message, 'optionalAccess', _183 => _183.role]) === "string") {
+          role = event.message.role;
+        }
+        break;
+      case "content_block_start":
+        if (event.content_block) {
+          contentBlocks[event.index] = event.content_block;
+          contentBlockDeltas[event.index] = [];
+        }
         break;
       case "content_block_delta":
-        if (_optionalChain([event, 'access', _182 => _182.delta, 'optionalAccess', _183 => _183.type]) === "text_delta") {
+        if (_optionalChain([event, 'access', _184 => _184.delta, 'optionalAccess', _185 => _185.type]) === "text_delta") {
           const text = event.delta.text;
           if (text) {
-            deltas.push(text);
+            if (contentBlocks[event.index] !== void 0 || contentBlockDeltas[event.index] !== void 0) {
+              contentBlockDeltas[event.index] ??= [];
+              contentBlockDeltas[event.index].push(text);
+            } else {
+              fallbackTextDeltas.push(text);
+            }
+          }
+        } else if (_optionalChain([event, 'access', _186 => _186.delta, 'optionalAccess', _187 => _187.type]) === "input_json_delta") {
+          const partialJson = event.delta.partial_json;
+          if (partialJson) {
+            contentBlockDeltas[event.index] ??= [];
+            contentBlockDeltas[event.index].push(partialJson);
           }
         }
         break;
+      case "content_block_stop":
+        finalizeContentBlock(
+          event.index,
+          contentBlocks,
+          contentBlockDeltas,
+          fallbackTextDeltas
+        );
+        break;
       case "message_delta":
         if (event.usage) {
           const finalMetrics = parseMetricsFromUsage2(event.usage);
@@ -10521,7 +10578,21 @@ function aggregateAnthropicStreamChunks(chunks) {
         break;
     }
   }
-  const output = deltas.join("");
+  const orderedContent = Object.entries(contentBlocks).map(([index, block]) => ({
+    block,
+    index: Number(index)
+  })).filter(({ block }) => block !== void 0).sort((left, right) => left.index - right.index).map(({ block }) => block);
+  let output = fallbackTextDeltas.join("");
+  if (orderedContent.length > 0) {
+    if (orderedContent.every(isTextContentBlock)) {
+      output = orderedContent.map((block) => block.text).join("");
+    } else {
+      output = {
+        ...role ? { role } : {},
+        content: orderedContent
+      };
+    }
+  }
   const finalized = finalizeAnthropicTokens(metrics);
   const filteredMetrics = Object.fromEntries(
     Object.entries(finalized).filter(
@@ -10534,6 +10605,49 @@ function aggregateAnthropicStreamChunks(chunks) {
     metadata
   };
 }
+function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallbackTextDeltas) {
+  const contentBlock = contentBlocks[index];
+  if (!contentBlock) {
+    return;
+  }
+  const text = _nullishCoalesce(_optionalChain([contentBlockDeltas, 'access', _188 => _188[index], 'optionalAccess', _189 => _189.join, 'call', _190 => _190("")]), () => ( ""));
+  if (isToolUseContentBlock(contentBlock)) {
+    if (!text) {
+      return;
+    }
+    try {
+      contentBlocks[index] = {
+        ...contentBlock,
+        input: JSON.parse(text)
+      };
+    } catch (e22) {
+      fallbackTextDeltas.push(text);
+      delete contentBlocks[index];
+    }
+    return;
+  }
+  if (isTextContentBlock(contentBlock)) {
+    if (!text) {
+      delete contentBlocks[index];
+      return;
+    }
+    contentBlocks[index] = {
+      ...contentBlock,
+      text
+    };
+    return;
+  }
+  if (text) {
+    fallbackTextDeltas.push(text);
+  }
+  delete contentBlocks[index];
+}
+function isTextContentBlock(contentBlock) {
+  return contentBlock.type === "text";
+}
+function isToolUseContentBlock(contentBlock) {
+  return contentBlock.type === "tool_use";
+}
 function isAnthropicBase64ContentBlock(input) {
   return (input.type === "image" || input.type === "document") && isObject(input.source) && input.source.type === "base64";
 }
@@ -10660,7 +10774,7 @@ function isZodSchema(value) {
 function serializeZodSchema(schema) {
   try {
     return zodToJsonSchema(schema);
-  } catch (e20) {
+  } catch (e23) {
     return {
       type: "object",
       description: "Zod schema (conversion failed)"
@@ -10960,7 +11074,7 @@ function extractTopLevelAISDKMetrics(result, event, startTime) {
   return metrics;
 }
 function hasModelChildTracing(event) {
-  return _optionalChain([event, 'optionalAccess', _184 => _184.__braintrust_ai_sdk_model_wrapped]) === true;
+  return _optionalChain([event, 'optionalAccess', _191 => _191.__braintrust_ai_sdk_model_wrapped]) === true;
 }
 function extractMetadataFromParams(params, self) {
   const metadata = {
@@ -10969,7 +11083,7 @@ function extractMetadataFromParams(params, self) {
       sdk_language: "typescript"
     }
   };
-  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _185 => _185.settings, 'optionalAccess', _186 => _186.model]) ? _optionalChain([self, 'access', _187 => _187.settings, 'optionalAccess', _188 => _188.model]) : void 0;
+  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _192 => _192.settings, 'optionalAccess', _193 => _193.model]) ? _optionalChain([self, 'access', _194 => _194.settings, 'optionalAccess', _195 => _195.model]) : void 0;
   const { model, provider } = serializeModelWithProvider(
     _nullishCoalesce(params.model, () => ( agentModel))
   );
@@ -11071,9 +11185,9 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
               case "raw":
                 if (chunk.rawValue) {
                   const rawVal = chunk.rawValue;
-                  if (_optionalChain([rawVal, 'access', _189 => _189.delta, 'optionalAccess', _190 => _190.content])) {
+                  if (_optionalChain([rawVal, 'access', _196 => _196.delta, 'optionalAccess', _197 => _197.content])) {
                     text += rawVal.delta.content;
-                  } else if (_optionalChain([rawVal, 'access', _191 => _191.choices, 'optionalAccess', _192 => _192[0], 'optionalAccess', _193 => _193.delta, 'optionalAccess', _194 => _194.content])) {
+                  } else if (_optionalChain([rawVal, 'access', _198 => _198.choices, 'optionalAccess', _199 => _199[0], 'optionalAccess', _200 => _200.delta, 'optionalAccess', _201 => _201.content])) {
                     text += rawVal.choices[0].delta.content;
                   } else if (typeof rawVal.text === "string") {
                     text += rawVal.text;
@@ -11210,14 +11324,14 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
   return {
     cleanup: cleanup.length > 0 ? () => {
       while (cleanup.length > 0) {
-        _optionalChain([cleanup, 'access', _195 => _195.pop, 'call', _196 => _196(), 'optionalCall', _197 => _197()]);
+        _optionalChain([cleanup, 'access', _202 => _202.pop, 'call', _203 => _203(), 'optionalCall', _204 => _204()]);
       }
     } : void 0,
     modelWrapped
   };
 }
 function finalizeAISDKChildTracing(event) {
-  const cleanup = _optionalChain([event, 'optionalAccess', _198 => _198.__braintrust_ai_sdk_cleanup]);
+  const cleanup = _optionalChain([event, 'optionalAccess', _205 => _205.__braintrust_ai_sdk_cleanup]);
   if (event && typeof cleanup === "function") {
     cleanup();
     delete event.__braintrust_ai_sdk_cleanup;
@@ -11282,7 +11396,7 @@ async function processAISDKStreamingOutput(result, denyOutputPaths) {
     if ("text" in result && typeof result.text === "string") {
       outputRecord.text = result.text;
     }
-  } catch (e21) {
+  } catch (e24) {
   }
   try {
     if ("object" in result) {
@@ -11291,7 +11405,7 @@ async function processAISDKStreamingOutput(result, denyOutputPaths) {
         outputRecord.object = resolvedObject;
       }
     }
-  } catch (e22) {
+  } catch (e25) {
   }
   return outputRecord;
 }
@@ -11309,10 +11423,10 @@ function buildAISDKChildMetadata(model) {
 function buildResolvedMetadataPayload(result) {
   const gatewayInfo = extractGatewayRoutingInfo(result);
   const metadata = {};
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _199 => _199.provider])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _206 => _206.provider])) {
     metadata.provider = gatewayInfo.provider;
   }
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _200 => _200.model])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _207 => _207.model])) {
     metadata.model = gatewayInfo.model;
   }
   if (result.finishReason !== void 0) {
@@ -11347,7 +11461,7 @@ function processAISDKOutput(output, denyOutputPaths) {
 }
 function extractTokenMetrics(result) {
   const metrics = {};
-  let usage = _optionalChain([result, 'optionalAccess', _201 => _201.totalUsage]) || _optionalChain([result, 'optionalAccess', _202 => _202.usage]);
+  let usage = _optionalChain([result, 'optionalAccess', _208 => _208.totalUsage]) || _optionalChain([result, 'optionalAccess', _209 => _209.usage]);
   if (!usage && result) {
     try {
       if ("totalUsage" in result && typeof result.totalUsage !== "function") {
@@ -11355,14 +11469,14 @@ function extractTokenMetrics(result) {
       } else if ("usage" in result && typeof result.usage !== "function") {
         usage = result.usage;
       }
-    } catch (e23) {
+    } catch (e26) {
     }
   }
   if (!usage) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _203 => _203.inputTokens, 'optionalAccess', _204 => _204.total]),
+    _optionalChain([usage, 'access', _210 => _210.inputTokens, 'optionalAccess', _211 => _211.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -11371,7 +11485,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _205 => _205.outputTokens, 'optionalAccess', _206 => _206.total]),
+    _optionalChain([usage, 'access', _212 => _212.outputTokens, 'optionalAccess', _213 => _213.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -11438,7 +11552,7 @@ function extractGetterValues(obj) {
       if (obj && name in obj && isSerializableOutputValue(obj[name])) {
         getterValues[name] = obj[name];
       }
-    } catch (e24) {
+    } catch (e27) {
     }
   }
   return getterValues;
@@ -11457,11 +11571,11 @@ function extractSerializableOutputFields(output) {
   ];
   for (const name of directFieldNames) {
     try {
-      const value = _optionalChain([output, 'optionalAccess', _207 => _207[name]]);
+      const value = _optionalChain([output, 'optionalAccess', _214 => _214[name]]);
       if (isSerializableOutputValue(value)) {
         serialized[name] = value;
       }
-    } catch (e25) {
+    } catch (e28) {
     }
   }
   return {
@@ -11485,8 +11599,8 @@ function isSerializableOutputValue(value) {
   return true;
 }
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _208 => _208.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _209 => _209.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _215 => _215.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _216 => _216.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -11510,8 +11624,8 @@ function parseGatewayModelString(modelString) {
   return { model: modelString };
 }
 function extractGatewayRoutingInfo(result) {
-  if (_optionalChain([result, 'optionalAccess', _210 => _210.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
-    const routing2 = _optionalChain([result, 'access', _211 => _211.steps, 'access', _212 => _212[0], 'optionalAccess', _213 => _213.providerMetadata, 'optionalAccess', _214 => _214.gateway, 'optionalAccess', _215 => _215.routing]);
+  if (_optionalChain([result, 'optionalAccess', _217 => _217.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+    const routing2 = _optionalChain([result, 'access', _218 => _218.steps, 'access', _219 => _219[0], 'optionalAccess', _220 => _220.providerMetadata, 'optionalAccess', _221 => _221.gateway, 'optionalAccess', _222 => _222.routing]);
     if (routing2) {
       return {
         provider: routing2.resolvedProvider || routing2.finalProvider,
@@ -11519,7 +11633,7 @@ function extractGatewayRoutingInfo(result) {
       };
     }
   }
-  const routing = _optionalChain([result, 'optionalAccess', _216 => _216.providerMetadata, 'optionalAccess', _217 => _217.gateway, 'optionalAccess', _218 => _218.routing]);
+  const routing = _optionalChain([result, 'optionalAccess', _223 => _223.providerMetadata, 'optionalAccess', _224 => _224.gateway, 'optionalAccess', _225 => _225.routing]);
   if (routing) {
     return {
       provider: routing.resolvedProvider || routing.finalProvider,
@@ -11529,12 +11643,12 @@ function extractGatewayRoutingInfo(result) {
   return null;
 }
 function extractCostFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _219 => _219.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+  if (_optionalChain([result, 'optionalAccess', _226 => _226.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
     let totalCost = 0;
     let foundCost = false;
     for (const step of result.steps) {
-      const gateway2 = _optionalChain([step, 'optionalAccess', _220 => _220.providerMetadata, 'optionalAccess', _221 => _221.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _222 => _222.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _223 => _223.marketCost]));
+      const gateway2 = _optionalChain([step, 'optionalAccess', _227 => _227.providerMetadata, 'optionalAccess', _228 => _228.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _229 => _229.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _230 => _230.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -11544,8 +11658,8 @@ function extractCostFromResult(result) {
       return totalCost;
     }
   }
-  const gateway = _optionalChain([result, 'optionalAccess', _224 => _224.providerMetadata, 'optionalAccess', _225 => _225.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _226 => _226.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _227 => _227.marketCost]));
+  const gateway = _optionalChain([result, 'optionalAccess', _231 => _231.providerMetadata, 'optionalAccess', _232 => _232.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _233 => _233.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _234 => _234.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -11656,12 +11770,15 @@ var claudeAgentSDKChannels = defineChannels(
   {
     query: channel({
       channelName: "query",
-      kind: "async"
+      kind: "sync-stream"
     })
   }
 );
 
 // src/instrumentation/plugins/claude-agent-sdk-plugin.ts
+function isSubAgentToolName(toolName) {
+  return toolName === "Agent" || toolName === "Task";
+}
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -11697,7 +11814,7 @@ function extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _228 => _228.message, 'optionalAccess', _229 => _229.usage]);
+    usage = _optionalChain([message, 'access', _235 => _235.message, 'optionalAccess', _236 => _236.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -11715,55 +11832,409 @@ function extractUsageFromMessage(message) {
   const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
   const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
   if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
-    const cacheTokens = extractAnthropicCacheTokens(
-      cacheReadTokens,
-      cacheCreationTokens
+    Object.assign(
+      metrics,
+      extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
     );
-    Object.assign(metrics, cacheTokens);
   }
   if (Object.keys(metrics).length > 0) {
     Object.assign(metrics, finalizeAnthropicTokens(metrics));
   }
   return metrics;
 }
-function buildLLMInput(prompt, conversationHistory) {
-  const promptMessage = typeof prompt === "string" ? { content: prompt, role: "user" } : void 0;
-  const inputParts = [
-    ...promptMessage ? [promptMessage] : [],
-    ...conversationHistory
-  ];
+function buildLLMInput(prompt, conversationHistory, capturedPromptMessages) {
+  const promptMessages = [];
+  if (typeof prompt === "string") {
+    promptMessages.push({ content: prompt, role: "user" });
+  } else if (capturedPromptMessages && capturedPromptMessages.length > 0) {
+    for (const msg of capturedPromptMessages) {
+      const role = _optionalChain([msg, 'access', _237 => _237.message, 'optionalAccess', _238 => _238.role]);
+      const content = _optionalChain([msg, 'access', _239 => _239.message, 'optionalAccess', _240 => _240.content]);
+      if (role && content !== void 0) {
+        promptMessages.push({ content, role });
+      }
+    }
+  }
+  const inputParts = [...promptMessages, ...conversationHistory];
   return inputParts.length > 0 ? inputParts : void 0;
 }
-async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
-  if (messages.length === 0) return void 0;
+function formatCapturedMessages(messages) {
+  return messages.length > 0 ? messages : [];
+}
+async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, capturedPromptMessages, parentSpan) {
+  if (messages.length === 0) {
+    return void 0;
+  }
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _230 => _230.message, 'optionalAccess', _231 => _231.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _241 => _241.message, 'optionalAccess', _242 => _242.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = extractUsageFromMessage(lastMessage);
-  const input = buildLLMInput(prompt, conversationHistory);
+  const input = buildLLMInput(
+    prompt,
+    conversationHistory,
+    capturedPromptMessages
+  );
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _232 => _232.message, 'optionalAccess', _233 => _233.content]) && _optionalChain([m, 'access', _234 => _234.message, 'optionalAccess', _235 => _235.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _243 => _243.message, 'optionalAccess', _244 => _244.content]) && _optionalChain([m, 'access', _245 => _245.message, 'optionalAccess', _246 => _246.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter(
     (c) => c !== void 0
   );
   const span = startSpan({
     name: "anthropic.messages.create",
+    parent: parentSpan,
     spanAttributes: {
       type: "llm" /* LLM */
     },
-    startTime,
-    parent: parentSpan
+    startTime
   });
   span.log({
     input,
-    output: outputs,
     metadata: model ? { model } : void 0,
-    metrics: usage
+    metrics: usage,
+    output: outputs
   });
   await span.end();
-  return _optionalChain([lastMessage, 'access', _236 => _236.message, 'optionalAccess', _237 => _237.content]) && _optionalChain([lastMessage, 'access', _238 => _238.message, 'optionalAccess', _239 => _239.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _247 => _247.message, 'optionalAccess', _248 => _248.content]) && _optionalChain([lastMessage, 'access', _249 => _249.message, 'optionalAccess', _250 => _250.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+}
+function getMcpServerMetadata(serverName, mcpServers) {
+  if (!serverName || !mcpServers) {
+    return {};
+  }
+  const serverConfig = mcpServers[serverName];
+  if (!serverConfig) {
+    return {};
+  }
+  const metadata = {};
+  if (serverConfig.type) {
+    metadata["mcp.type"] = serverConfig.type;
+  } else if (typeof serverConfig === "object" && "transport" in serverConfig) {
+    metadata["mcp.type"] = "sdk";
+  }
+  if (serverConfig.url) {
+    metadata["mcp.url"] = serverConfig.url;
+  }
+  if (serverConfig.command) {
+    metadata["mcp.command"] = serverConfig.command;
+    if (serverConfig.args) {
+      metadata["mcp.args"] = serverConfig.args.join(" ");
+    }
+  }
+  return metadata;
+}
+function parseToolName(rawToolName) {
+  const mcpMatch = rawToolName.match(/^mcp__([^_]+)__(.+)$/);
+  if (mcpMatch) {
+    const [, mcpServer, toolName] = mcpMatch;
+    return {
+      displayName: `tool: ${mcpServer}/${toolName}`,
+      mcpServer,
+      rawToolName,
+      toolName
+    };
+  }
+  return {
+    displayName: `tool: ${rawToolName}`,
+    rawToolName,
+    toolName: rawToolName
+  };
+}
+function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, subAgentSpans, endedSubAgentSpans) {
+  const preToolUse = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
+      return {};
+    }
+    if (isSubAgentToolName(input.tool_name)) {
+      return {};
+    }
+    const parsed = parseToolName(input.tool_name);
+    const toolSpan = startSpan({
+      event: {
+        input: input.tool_input,
+        metadata: {
+          "claude_agent_sdk.cwd": input.cwd,
+          "claude_agent_sdk.raw_tool_name": parsed.rawToolName,
+          "claude_agent_sdk.session_id": input.session_id,
+          "gen_ai.tool.call.id": toolUseID,
+          "gen_ai.tool.name": parsed.toolName,
+          ...parsed.mcpServer && { "mcp.server": parsed.mcpServer },
+          ...getMcpServerMetadata(parsed.mcpServer, mcpServers)
+        }
+      },
+      name: parsed.displayName,
+      parent: await resolveParentSpan(toolUseID),
+      spanAttributes: { type: "tool" /* TOOL */ }
+    });
+    activeToolSpans.set(toolUseID, toolSpan);
+    return {};
+  };
+  const postToolUse = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PostToolUse" || !toolUseID) {
+      return {};
+    }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        const response = input.tool_response;
+        const metadata = {};
+        if (_optionalChain([response, 'optionalAccess', _251 => _251.status])) {
+          metadata["claude_agent_sdk.status"] = response.status;
+        }
+        if (_optionalChain([response, 'optionalAccess', _252 => _252.totalDurationMs])) {
+          metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
+        }
+        if (_optionalChain([response, 'optionalAccess', _253 => _253.totalToolUseCount]) !== void 0) {
+          metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
+        }
+        subAgentSpan.log({
+          metadata,
+          output: _optionalChain([response, 'optionalAccess', _254 => _254.content])
+        });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
+    const toolSpan = activeToolSpans.get(toolUseID);
+    if (!toolSpan) {
+      return {};
+    }
+    try {
+      toolSpan.log({ output: input.tool_response });
+    } finally {
+      toolSpan.end();
+      activeToolSpans.delete(toolUseID);
+    }
+    return {};
+  };
+  const postToolUseFailure = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PostToolUseFailure" || !toolUseID) {
+      return {};
+    }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        subAgentSpan.log({ error: input.error });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
+    const toolSpan = activeToolSpans.get(toolUseID);
+    if (!toolSpan) {
+      return {};
+    }
+    const parsed = parseToolName(input.tool_name);
+    try {
+      toolSpan.log({
+        error: input.error,
+        metadata: {
+          "claude_agent_sdk.is_interrupt": input.is_interrupt,
+          "claude_agent_sdk.session_id": input.session_id,
+          "gen_ai.tool.call.id": toolUseID,
+          "gen_ai.tool.name": parsed.toolName,
+          ...parsed.mcpServer && { "mcp.server": parsed.mcpServer }
+        }
+      });
+    } finally {
+      toolSpan.end();
+      activeToolSpans.delete(toolUseID);
+    }
+    return {};
+  };
+  return { postToolUse, postToolUseFailure, preToolUse };
+}
+function injectTracingHooks(options, resolveParentSpan, activeToolSpans, subAgentSpans, endedSubAgentSpans) {
+  const { preToolUse, postToolUse, postToolUseFailure } = createToolTracingHooks(
+    resolveParentSpan,
+    activeToolSpans,
+    options.mcpServers,
+    subAgentSpans,
+    endedSubAgentSpans
+  );
+  const existingHooks = _nullishCoalesce(options.hooks, () => ( {}));
+  return {
+    ...options,
+    hooks: {
+      ...existingHooks,
+      PostToolUse: [
+        ..._nullishCoalesce(existingHooks.PostToolUse, () => ( [])),
+        { hooks: [postToolUse] }
+      ],
+      PostToolUseFailure: [
+        ..._nullishCoalesce(existingHooks.PostToolUseFailure, () => ( [])),
+        {
+          hooks: [postToolUseFailure]
+        }
+      ],
+      PreToolUse: [
+        ..._nullishCoalesce(existingHooks.PreToolUse, () => ( [])),
+        { hooks: [preToolUse] }
+      ]
+    }
+  };
+}
+async function finalizeCurrentMessageGroup(state) {
+  if (state.currentMessages.length === 0) {
+    return;
+  }
+  const parentToolUseId = _nullishCoalesce(_optionalChain([state, 'access', _255 => _255.currentMessages, 'access', _256 => _256[0], 'optionalAccess', _257 => _257.parent_tool_use_id]), () => ( null));
+  let parentSpan = await state.span.export();
+  if (parentToolUseId) {
+    const subAgentSpan = state.subAgentSpans.get(parentToolUseId);
+    if (subAgentSpan) {
+      parentSpan = await subAgentSpan.export();
+    }
+  }
+  const finalMessage = await createLLMSpanForMessages(
+    state.currentMessages,
+    state.originalPrompt,
+    state.finalResults,
+    state.options,
+    state.currentMessageStartTime,
+    state.capturedPromptMessages,
+    parentSpan
+  );
+  if (finalMessage) {
+    state.finalResults.push(finalMessage);
+  }
+  const lastMessage = state.currentMessages[state.currentMessages.length - 1];
+  if (_optionalChain([lastMessage, 'optionalAccess', _258 => _258.message, 'optionalAccess', _259 => _259.usage])) {
+    state.accumulatedOutputTokens += getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
+  }
+  state.currentMessages.length = 0;
+}
+function maybeTrackToolUseContext(state, message) {
+  if (message.type !== "assistant" || !Array.isArray(_optionalChain([message, 'access', _260 => _260.message, 'optionalAccess', _261 => _261.content]))) {
+    return;
+  }
+  const parentToolUseId = _nullishCoalesce(message.parent_tool_use_id, () => ( null));
+  for (const block of message.message.content) {
+    if (typeof block !== "object" || block === null || !("type" in block) || block.type !== "tool_use" || !("id" in block) || typeof block.id !== "string") {
+      continue;
+    }
+    state.toolUseToParent.set(block.id, parentToolUseId);
+    if (block.name === "Task" && typeof block.input === "object" && block.input !== null && "subagent_type" in block.input && typeof block.input.subagent_type === "string") {
+      state.pendingSubAgentNames.set(block.id, block.input.subagent_type);
+    }
+  }
+}
+async function maybeStartSubAgentSpan(state, message) {
+  if (!("parent_tool_use_id" in message)) {
+    return;
+  }
+  const parentToolUseId = message.parent_tool_use_id;
+  if (!parentToolUseId) {
+    return;
+  }
+  await ensureSubAgentSpan(
+    state.pendingSubAgentNames,
+    state.span,
+    state.subAgentSpans,
+    parentToolUseId
+  );
+}
+async function ensureSubAgentSpan(pendingSubAgentNames, rootSpan, subAgentSpans, parentToolUseId) {
+  const existingSpan = subAgentSpans.get(parentToolUseId);
+  if (existingSpan) {
+    return existingSpan;
+  }
+  const agentName = pendingSubAgentNames.get(parentToolUseId);
+  const spanName = agentName ? `Agent: ${agentName}` : "Agent: sub-agent";
+  const subAgentSpan = startSpan({
+    event: {
+      metadata: {
+        ...agentName && { "claude_agent_sdk.agent_type": agentName }
+      }
+    },
+    name: spanName,
+    parent: await rootSpan.export(),
+    spanAttributes: { type: "task" /* TASK */ }
+  });
+  subAgentSpans.set(parentToolUseId, subAgentSpan);
+  return subAgentSpan;
+}
+async function handleStreamMessage(state, message) {
+  maybeTrackToolUseContext(state, message);
+  await maybeStartSubAgentSpan(state, message);
+  const messageId = _optionalChain([message, 'access', _262 => _262.message, 'optionalAccess', _263 => _263.id]);
+  if (messageId && messageId !== state.currentMessageId) {
+    await finalizeCurrentMessageGroup(state);
+    state.currentMessageId = messageId;
+    state.currentMessageStartTime = getCurrentUnixTimestamp();
+  }
+  if (message.type === "assistant" && _optionalChain([message, 'access', _264 => _264.message, 'optionalAccess', _265 => _265.usage])) {
+    state.currentMessages.push(message);
+  }
+  if (message.type !== "result" || !message.usage) {
+    return;
+  }
+  const finalUsageMetrics = extractUsageFromMessage(message);
+  if (state.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
+    const lastMessage = state.currentMessages[state.currentMessages.length - 1];
+    if (_optionalChain([lastMessage, 'optionalAccess', _266 => _266.message, 'optionalAccess', _267 => _267.usage])) {
+      const adjustedTokens = finalUsageMetrics.completion_tokens - state.accumulatedOutputTokens;
+      if (adjustedTokens >= 0) {
+        lastMessage.message.usage.output_tokens = adjustedTokens;
+      }
+      const resultUsage = message.usage;
+      if (resultUsage && typeof resultUsage === "object") {
+        const cacheReadTokens = getNumberProperty(
+          resultUsage,
+          "cache_read_input_tokens"
+        );
+        if (cacheReadTokens !== void 0) {
+          lastMessage.message.usage.cache_read_input_tokens = cacheReadTokens;
+        }
+        const cacheCreationTokens = getNumberProperty(
+          resultUsage,
+          "cache_creation_input_tokens"
+        );
+        if (cacheCreationTokens !== void 0) {
+          lastMessage.message.usage.cache_creation_input_tokens = cacheCreationTokens;
+        }
+      }
+    }
+  }
+  const metadata = {};
+  if (message.num_turns !== void 0) {
+    metadata.num_turns = message.num_turns;
+  }
+  if (message.session_id !== void 0) {
+    metadata.session_id = message.session_id;
+  }
+  if (Object.keys(metadata).length > 0) {
+    state.span.log({ metadata });
+  }
+}
+async function finalizeQuerySpan(state) {
+  try {
+    await finalizeCurrentMessageGroup(state);
+    state.span.log({
+      output: state.finalResults.length > 0 ? state.finalResults[state.finalResults.length - 1] : void 0
+    });
+    if (state.capturedPromptMessages) {
+      if (state.promptStarted()) {
+        await state.promptDone;
+      }
+      if (state.capturedPromptMessages.length > 0) {
+        state.span.log({
+          input: formatCapturedMessages(state.capturedPromptMessages)
+        });
+      }
+    }
+  } finally {
+    for (const [id, subAgentSpan] of state.subAgentSpans) {
+      if (!state.endedSubAgentSpans.has(id)) {
+        subAgentSpan.end();
+      }
+    }
+    state.subAgentSpans.clear();
+    state.span.end();
+  }
 }
 var ClaudeAgentSDKPlugin = class extends BasePlugin {
   onEnable() {
@@ -11775,19 +12246,36 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
     }
     this.unsubscribers = [];
   }
-  /**
-   * Subscribe to the query channel for agent interactions.
-   * Handles streaming responses and traces both the top-level agent task
-   * and individual LLM calls.
-   */
   subscribeToQuery() {
     const channel2 = claudeAgentSDKChannels.query.tracingChannel();
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
-        const params = event.arguments[0];
-        const prompt = _optionalChain([params, 'optionalAccess', _240 => _240.prompt]);
-        const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _241 => _241.options]), () => ( {}));
+        const params = _nullishCoalesce(event.arguments[0], () => ( {}));
+        const originalPrompt = params.prompt;
+        const options = _nullishCoalesce(params.options, () => ( {}));
+        const promptIsAsyncIterable = isAsyncIterable(originalPrompt);
+        let promptStarted = false;
+        let capturedPromptMessages;
+        let resolvePromptDone;
+        const promptDone = new Promise((resolve) => {
+          resolvePromptDone = resolve;
+        });
+        if (promptIsAsyncIterable) {
+          capturedPromptMessages = [];
+          const promptStream = originalPrompt;
+          params.prompt = (async function* () {
+            promptStarted = true;
+            try {
+              for await (const message of promptStream) {
+                capturedPromptMessages.push(message);
+                yield message;
+              }
+            } finally {
+              _optionalChain([resolvePromptDone, 'optionalCall', _268 => _268()]);
+            }
+          })();
+        }
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -11797,163 +12285,115 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         const startTime = getCurrentUnixTimestamp();
         try {
           span.log({
-            input: typeof prompt === "string" ? prompt : {
-              type: "streaming",
-              description: "AsyncIterable<ClaudeAgentSDKMessage>"
-            },
+            input: typeof originalPrompt === "string" ? originalPrompt : promptIsAsyncIterable ? void 0 : originalPrompt !== void 0 ? String(originalPrompt) : void 0,
             metadata: filterSerializableOptions(options)
           });
         } catch (error) {
           console.error("Error extracting input for Claude Agent SDK:", error);
         }
+        const activeToolSpans = /* @__PURE__ */ new Map();
+        const subAgentSpans = /* @__PURE__ */ new Map();
+        const endedSubAgentSpans = /* @__PURE__ */ new Set();
+        const toolUseToParent = /* @__PURE__ */ new Map();
+        const pendingSubAgentNames = /* @__PURE__ */ new Map();
+        const optionsWithHooks = injectTracingHooks(
+          options,
+          async (toolUseID) => {
+            const parentToolUseId = toolUseToParent.get(toolUseID);
+            if (parentToolUseId) {
+              const subAgentSpan = await ensureSubAgentSpan(
+                pendingSubAgentNames,
+                span,
+                subAgentSpans,
+                parentToolUseId
+              );
+              return subAgentSpan.export();
+            }
+            return span.export();
+          },
+          activeToolSpans,
+          subAgentSpans,
+          endedSubAgentSpans
+        );
+        params.options = optionsWithHooks;
+        event.arguments[0] = params;
         spans.set(event, {
-          span,
-          startTime,
-          conversationHistory: [],
-          currentMessages: [],
+          accumulatedOutputTokens: 0,
+          activeToolSpans,
+          capturedPromptMessages,
           currentMessageId: void 0,
           currentMessageStartTime: startTime,
-          accumulatedOutputTokens: 0
+          currentMessages: [],
+          endedSubAgentSpans,
+          finalResults: [],
+          options: optionsWithHooks,
+          originalPrompt,
+          pendingSubAgentNames,
+          processing: Promise.resolve(),
+          promptDone,
+          promptStarted: () => promptStarted,
+          span,
+          subAgentSpans,
+          toolUseToParent
         });
       },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
+      end: (event) => {
+        const state = spans.get(event);
+        if (!state) {
           return;
         }
         const eventResult = event.result;
         if (eventResult === void 0) {
-          spanData.span.end();
+          state.span.end();
           spans.delete(event);
           return;
         }
         if (isAsyncIterable(eventResult)) {
           patchStreamIfNeeded(eventResult, {
-            onChunk: async (message) => {
-              const currentTime = getCurrentUnixTimestamp();
-              const params = event.arguments[0];
-              const prompt = _optionalChain([params, 'optionalAccess', _242 => _242.prompt]);
-              const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _243 => _243.options]), () => ( {}));
-              const messageId = _optionalChain([message, 'access', _244 => _244.message, 'optionalAccess', _245 => _245.id]);
-              if (messageId && messageId !== spanData.currentMessageId) {
-                if (spanData.currentMessages.length > 0) {
-                  const finalMessage = await createLLMSpanForMessages(
-                    spanData.currentMessages,
-                    prompt,
-                    spanData.conversationHistory,
-                    options,
-                    spanData.currentMessageStartTime,
-                    await spanData.span.export()
-                  );
-                  if (finalMessage) {
-                    spanData.conversationHistory.push(finalMessage);
-                  }
-                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (_optionalChain([lastMessage, 'optionalAccess', _246 => _246.message, 'optionalAccess', _247 => _247.usage])) {
-                    const outputTokens = getNumberProperty(
-                      lastMessage.message.usage,
-                      "output_tokens"
-                    ) || 0;
-                    spanData.accumulatedOutputTokens += outputTokens;
-                  }
-                  spanData.currentMessages = [];
-                }
-                spanData.currentMessageId = messageId;
-                spanData.currentMessageStartTime = currentTime;
-              }
-              if (message.type === "assistant" && _optionalChain([message, 'access', _248 => _248.message, 'optionalAccess', _249 => _249.usage])) {
-                spanData.currentMessages.push(message);
-              }
-              if (message.type === "result" && message.usage) {
-                const finalUsageMetrics = extractUsageFromMessage(message);
-                if (spanData.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
-                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (_optionalChain([lastMessage, 'optionalAccess', _250 => _250.message, 'optionalAccess', _251 => _251.usage])) {
-                    const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
-                    if (adjustedTokens >= 0) {
-                      lastMessage.message.usage.output_tokens = adjustedTokens;
-                    }
-                  }
-                }
-                const result_metadata = {};
-                if (message.num_turns !== void 0) {
-                  result_metadata.num_turns = message.num_turns;
-                }
-                if (message.session_id !== void 0) {
-                  result_metadata.session_id = message.session_id;
-                }
-                if (Object.keys(result_metadata).length > 0) {
-                  spanData.span.log({
-                    metadata: result_metadata
-                  });
-                }
-              }
-            },
-            onComplete: async () => {
-              try {
-                const params = event.arguments[0];
-                const prompt = _optionalChain([params, 'optionalAccess', _252 => _252.prompt]);
-                const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _253 => _253.options]), () => ( {}));
-                if (spanData.currentMessages.length > 0) {
-                  const finalMessage = await createLLMSpanForMessages(
-                    spanData.currentMessages,
-                    prompt,
-                    spanData.conversationHistory,
-                    options,
-                    spanData.currentMessageStartTime,
-                    await spanData.span.export()
-                  );
-                  if (finalMessage) {
-                    spanData.conversationHistory.push(finalMessage);
-                  }
-                }
-                spanData.span.log({
-                  output: spanData.conversationHistory.length > 0 ? spanData.conversationHistory[spanData.conversationHistory.length - 1] : void 0
-                });
-              } catch (error) {
+            onChunk: (message) => {
+              maybeTrackToolUseContext(state, message);
+              state.processing = state.processing.then(() => handleStreamMessage(state, message)).catch((error) => {
                 console.error(
-                  "Error extracting output for Claude Agent SDK:",
+                  "Error processing Claude Agent SDK stream chunk:",
                   error
                 );
-              } finally {
-                spanData.span.end();
+              });
+            },
+            onComplete: () => {
+              void state.processing.then(() => finalizeQuerySpan(state)).finally(() => {
                 spans.delete(event);
-              }
+              });
             },
             onError: (error) => {
-              spanData.span.log({
-                error: error.message
+              void state.processing.then(() => {
+                state.span.log({
+                  error: error.message
+                });
+              }).then(() => finalizeQuerySpan(state)).finally(() => {
+                spans.delete(event);
               });
-              spanData.span.end();
-              spans.delete(event);
             }
           });
-        } else {
-          try {
-            spanData.span.log({
-              output: eventResult
-            });
-          } catch (error) {
-            console.error(
-              "Error extracting output for Claude Agent SDK:",
-              error
-            );
-          } finally {
-            spanData.span.end();
-            spans.delete(event);
-          }
+          return;
+        }
+        try {
+          state.span.log({ output: eventResult });
+        } catch (error) {
+          console.error("Error extracting output for Claude Agent SDK:", error);
+        } finally {
+          state.span.end();
+          spans.delete(event);
         }
       },
       error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData || !event.error) {
+        const state = spans.get(event);
+        if (!state || !event.error) {
           return;
         }
-        const { span } = spanData;
-        span.log({
+        state.span.log({
           error: event.error.message
         });
-        span.end();
+        state.span.end();
         spans.delete(event);
       }
     };
@@ -11977,6 +12417,18 @@ var googleGenAIChannels = defineChannels("@google/genai", {
 });
 
 // src/instrumentation/plugins/google-genai-plugin.ts
+var GOOGLE_GENAI_INTERNAL_CONTEXT = {
+  caller_filename: "<node-internal>",
+  caller_functionname: "<node-internal>",
+  caller_lineno: 0
+};
+function createWrapperParityEvent(args) {
+  return {
+    context: GOOGLE_GENAI_INTERNAL_CONTEXT,
+    input: args.input,
+    metadata: args.metadata
+  };
+}
 var GoogleGenAIPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToGoogleGenAIChannels();
@@ -11985,51 +12437,282 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToGoogleGenAIChannels() {
-    this.unsubscribers.push(
-      traceAsyncChannel(googleGenAIChannels.generateContent, {
-        name: "google-genai.generateContent",
-        type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const input = serializeInput(params);
-          const metadata = extractMetadata(params);
-          return {
-            input,
-            metadata: { ...metadata, provider: "google-genai" }
-          };
-        },
-        extractOutput: (result) => {
-          return result;
-        },
-        extractMetrics: (result, startTime) => {
-          return extractGenerateContentMetrics(result, startTime);
-        }
-      })
+    this.subscribeToGenerateContentChannel();
+    this.subscribeToGenerateContentStreamChannel();
+  }
+  subscribeToGenerateContentChannel() {
+    const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
+      tracingChannel2,
+      states,
+      (event) => {
+        const params = event.arguments[0];
+        const input = serializeInput(params);
+        const metadata = extractMetadata(params);
+        const span = startSpan({
+          name: "generate_content",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: createWrapperParityEvent({ input, metadata })
+        });
+        return {
+          span,
+          startTime: getCurrentUnixTimestamp()
+        };
+      }
     );
-    this.unsubscribers.push(
-      traceStreamingChannel(googleGenAIChannels.generateContentStream, {
-        name: "google-genai.generateContentStream",
-        type: "llm" /* LLM */,
-        extractInput: ([params]) => {
+    const handlers = {
+      start: (event) => {
+        ensureSpanState(states, event, () => {
+          const params = event.arguments[0];
           const input = serializeInput(params);
           const metadata = extractMetadata(params);
+          const span = startSpan({
+            name: "generate_content",
+            spanAttributes: {
+              type: "llm" /* LLM */
+            },
+            event: createWrapperParityEvent({ input, metadata })
+          });
           return {
-            input,
-            metadata: { ...metadata, provider: "google-genai" }
+            span,
+            startTime: getCurrentUnixTimestamp()
           };
-        },
-        extractOutput: (result) => {
-          return result;
-        },
-        extractMetrics: () => {
-          return {};
-        },
-        aggregateChunks: (chunks, _result, _endEvent, startTime) => {
-          return aggregateGenerateContentChunks(chunks, startTime);
+        });
+      },
+      asyncEnd: (event) => {
+        const spanState = states.get(event);
+        if (!spanState) {
+          return;
         }
-      })
-    );
+        try {
+          spanState.span.log({
+            metrics: cleanMetrics(
+              extractGenerateContentMetrics(
+                event.result,
+                spanState.startTime
+              )
+            ),
+            output: event.result
+          });
+        } finally {
+          spanState.span.end();
+          states.delete(event);
+        }
+      },
+      error: (event) => {
+        logErrorAndEndSpan(states, event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _269 => _269()]);
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToGenerateContentStreamChannel() {
+    const tracingChannel2 = googleGenAIChannels.generateContentStream.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        const streamEvent = event;
+        const params = event.arguments[0];
+        streamEvent.googleGenAIInput = serializeInput(params);
+        streamEvent.googleGenAIMetadata = extractMetadata(params);
+      },
+      asyncEnd: (event) => {
+        const streamEvent = event;
+        patchGoogleGenAIStreamingResult({
+          input: streamEvent.googleGenAIInput,
+          metadata: streamEvent.googleGenAIMetadata,
+          result: streamEvent.result
+        });
+      },
+      error: () => {
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      tracingChannel2.unsubscribe(handlers);
+    });
   }
 };
+function ensureSpanState(states, event, create) {
+  const existing = states.get(event);
+  if (existing) {
+    return existing;
+  }
+  const created = create();
+  states.set(event, created);
+  return created;
+}
+function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
+  const state = _internalGetGlobalState();
+  const startChannel = tracingChannel2.start;
+  const currentSpanStore = _optionalChain([state, 'optionalAccess', _270 => _270.contextManager]) ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!_optionalChain([startChannel, 'optionalAccess', _271 => _271.bindStore]) || !currentSpanStore) {
+    return void 0;
+  }
+  startChannel.bindStore(
+    currentSpanStore,
+    (event) => ensureSpanState(
+      states,
+      event,
+      () => create(event)
+    ).span
+  );
+  return () => {
+    _optionalChain([startChannel, 'access', _272 => _272.unbindStore, 'optionalCall', _273 => _273(currentSpanStore)]);
+  };
+}
+function logErrorAndEndSpan(states, event) {
+  const spanState = states.get(event);
+  if (!spanState) {
+    return;
+  }
+  spanState.span.log({
+    error: event.error.message
+  });
+  spanState.span.end();
+  states.delete(event);
+}
+function patchGoogleGenAIStreamingResult(args) {
+  const { input, metadata, result } = args;
+  if (!input || !metadata || !result || typeof result !== "object" || typeof result.next !== "function") {
+    return false;
+  }
+  const chunks = [];
+  let firstTokenTime = null;
+  let finalized = false;
+  let span = null;
+  let startTime = null;
+  const ensureSpan = () => {
+    if (!span) {
+      span = startSpan({
+        name: "generate_content_stream",
+        spanAttributes: {
+          type: "llm" /* LLM */
+        },
+        event: {
+          input,
+          metadata
+        }
+      });
+      startTime = getCurrentUnixTimestamp();
+    }
+    return span;
+  };
+  const finalize = (options) => {
+    if (finalized || !span) {
+      return;
+    }
+    finalized = true;
+    if (options.result) {
+      const { end, ...metricsWithoutEnd } = options.result.metrics;
+      span.log({
+        metrics: cleanMetrics(metricsWithoutEnd),
+        output: options.result.aggregated
+      });
+      span.end(typeof end === "number" ? { endTime: end } : void 0);
+      return;
+    }
+    if (options.error !== void 0) {
+      span.log({
+        error: options.error instanceof Error ? options.error.message : String(options.error)
+      });
+    }
+    span.end();
+  };
+  const patchIterator = (iterator) => {
+    if (typeof iterator !== "object" || iterator === null || "__braintrustGoogleGenAIPatched" in iterator) {
+      return iterator;
+    }
+    const iteratorRecord = iterator;
+    const originalNext = typeof iteratorRecord.next === "function" ? iteratorRecord.next.bind(iterator) : void 0;
+    const originalReturn = typeof iteratorRecord.return === "function" ? iteratorRecord.return.bind(iterator) : void 0;
+    const originalThrow = typeof iteratorRecord.throw === "function" ? iteratorRecord.throw.bind(iterator) : void 0;
+    const asyncIteratorMethod = iteratorRecord[Symbol.asyncIterator];
+    const originalAsyncIterator = typeof asyncIteratorMethod === "function" ? asyncIteratorMethod.bind(iterator) : void 0;
+    Object.defineProperty(iteratorRecord, "__braintrustGoogleGenAIPatched", {
+      configurable: true,
+      enumerable: false,
+      value: true,
+      writable: false
+    });
+    if (originalNext) {
+      iteratorRecord.next = async (...nextArgs) => {
+        ensureSpan();
+        try {
+          const nextResult = await originalNext(
+            ...nextArgs
+          );
+          if (!nextResult.done && nextResult.value) {
+            if (firstTokenTime === null) {
+              firstTokenTime = getCurrentUnixTimestamp();
+            }
+            chunks.push(nextResult.value);
+          }
+          if (nextResult.done && startTime !== null) {
+            finalize({
+              result: aggregateGenerateContentChunks(
+                chunks,
+                startTime,
+                firstTokenTime
+              )
+            });
+          }
+          return nextResult;
+        } catch (error) {
+          finalize({ error });
+          throw error;
+        }
+      };
+    }
+    if (originalReturn) {
+      iteratorRecord.return = async (...returnArgs) => {
+        ensureSpan();
+        try {
+          return await originalReturn(
+            ...returnArgs
+          );
+        } finally {
+          if (startTime !== null) {
+            finalize({
+              result: chunks.length > 0 ? aggregateGenerateContentChunks(
+                chunks,
+                startTime,
+                firstTokenTime
+              ) : void 0
+            });
+          } else {
+            finalize({});
+          }
+        }
+      };
+    }
+    if (originalThrow) {
+      iteratorRecord.throw = async (...throwArgs) => {
+        ensureSpan();
+        try {
+          return await originalThrow(
+            ...throwArgs
+          );
+        } catch (error) {
+          finalize({ error });
+          throw error;
+        }
+      };
+    }
+    iteratorRecord[Symbol.asyncIterator] = () => {
+      const asyncIterator = originalAsyncIterator ? originalAsyncIterator() : iterator;
+      return patchIterator(asyncIterator);
+    };
+    return iterator;
+  };
+  patchIterator(result);
+  return true;
+}
 function serializeInput(params) {
   const input = {
     model: params.model,
@@ -12038,11 +12721,13 @@ function serializeInput(params) {
   if (params.config) {
     const config = tryToDict(params.config);
     if (config) {
-      const tools = serializeTools(params);
-      if (tools) {
-        config.tools = tools;
-      }
-      input.config = config;
+      const filteredConfig = {};
+      Object.keys(config).forEach((key) => {
+        if (key !== "tools") {
+          filteredConfig[key] = config[key];
+        }
+      });
+      input.config = filteredConfig;
     }
   }
   return input;
@@ -12100,7 +12785,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _254 => _254.config, 'optionalAccess', _255 => _255.tools])) {
+  if (!_optionalChain([params, 'access', _274 => _274.config, 'optionalAccess', _275 => _275.tools])) {
     return null;
   }
   try {
@@ -12110,7 +12795,7 @@ function serializeTools(params) {
       }
       return tool;
     });
-  } catch (e26) {
+  } catch (e29) {
     return null;
   }
 }
@@ -12129,15 +12814,21 @@ function extractMetadata(params) {
       });
     }
   }
+  const tools = serializeTools(params);
+  if (tools) {
+    metadata.tools = tools;
+  }
   return metadata;
 }
 function extractGenerateContentMetrics(response, startTime) {
   const metrics = {};
-  if (startTime) {
+  if (startTime !== void 0) {
     const end = getCurrentUnixTimestamp();
+    metrics.start = startTime;
+    metrics.end = end;
     metrics.duration = end - startTime;
   }
-  if (_optionalChain([response, 'optionalAccess', _256 => _256.usageMetadata])) {
+  if (_optionalChain([response, 'optionalAccess', _276 => _276.usageMetadata])) {
     populateUsageMetrics(metrics, response.usageMetadata);
   }
   return metrics;
@@ -12159,19 +12850,18 @@ function populateUsageMetrics(metrics, usage) {
     metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
   }
 }
-function aggregateGenerateContentChunks(chunks, startTime) {
-  const metrics = {};
-  if (startTime !== void 0) {
-    const end = getCurrentUnixTimestamp();
-    metrics.duration = end - startTime;
-  }
-  let firstTokenTime = null;
-  if (chunks.length > 0 && firstTokenTime === null && startTime !== void 0) {
-    firstTokenTime = getCurrentUnixTimestamp();
+function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
+  const end = getCurrentUnixTimestamp();
+  const metrics = {
+    start: startTime,
+    end,
+    duration: end - startTime
+  };
+  if (firstTokenTime !== null) {
     metrics.time_to_first_token = firstTokenTime - startTime;
   }
   if (chunks.length === 0) {
-    return { output: {}, metrics };
+    return { aggregated: {}, metrics };
   }
   let text = "";
   let thoughtText = "";
@@ -12185,7 +12875,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _257 => _257.content, 'optionalAccess', _258 => _258.parts])) {
+        if (_optionalChain([candidate, 'access', _277 => _277.content, 'optionalAccess', _278 => _278.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -12207,7 +12897,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
       }
     }
   }
-  const output = {};
+  const aggregated = {};
   const parts = [];
   if (thoughtText) {
     parts.push({ text: thoughtText, thought: true });
@@ -12216,7 +12906,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _259 => _259.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _279 => _279.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -12233,16 +12923,25 @@ function aggregateGenerateContentChunks(chunks, startTime) {
       }
       candidates.push(candidateDict);
     }
-    output.candidates = candidates;
+    aggregated.candidates = candidates;
   }
   if (usageMetadata) {
-    output.usageMetadata = usageMetadata;
+    aggregated.usageMetadata = usageMetadata;
     populateUsageMetrics(metrics, usageMetadata);
   }
   if (text) {
-    output.text = text;
+    aggregated.text = text;
+  }
+  return { aggregated, metrics };
+}
+function cleanMetrics(metrics) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(metrics)) {
+    if (value !== null && value !== void 0) {
+      cleaned[key] = value;
+    }
   }
-  return { output, metrics };
+  return cleaned;
 }
 function tryToDict(obj) {
   if (obj === null || obj === void 0) {
@@ -12375,7 +13074,7 @@ function isZodSchema2(value) {
 function serializeZodSchema2(schema) {
   try {
     return zodToJsonSchema(schema);
-  } catch (e27) {
+  } catch (e30) {
     return {
       type: "object",
       description: "Zod schema (conversion failed)"
@@ -12597,7 +13296,7 @@ function patchOpenRouterCallModelResult(span, result, request) {
     }
     try {
       await endSpanWithResult(await originalGetResponse(), fallbackOutput);
-    } catch (e28) {
+    } catch (e31) {
       await endSpanWithResult(void 0, fallbackOutput);
     }
   };
@@ -12813,7 +13512,7 @@ function publishToolResult(tracingChannel2, event, result) {
 }
 function getToolCallId(context) {
   const toolContext = context;
-  return typeof _optionalChain([toolContext, 'optionalAccess', _260 => _260.toolCall, 'optionalAccess', _261 => _261.id]) === "string" ? toolContext.toolCall.id : void 0;
+  return typeof _optionalChain([toolContext, 'optionalAccess', _280 => _280.toolCall, 'optionalAccess', _281 => _281.id]) === "string" ? toolContext.toolCall.id : void 0;
 }
 function extractOpenRouterCallModelResultMetadata(response, turnCount) {
   const combined = {
@@ -12997,9 +13696,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _262 => _262.chatGenerationParams])) ? request.chatGenerationParams : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _263 => _263.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _264 => _264.xTitle]);
+          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _282 => _282.chatGenerationParams])) ? request.chatGenerationParams : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _283 => _283.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _284 => _284.xTitle]);
           const { messages, ...metadata } = chatGenerationParams;
           return {
             input: messages,
@@ -13010,7 +13709,7 @@ var OpenRouterPlugin = class extends BasePlugin {
           return isObject(result) ? result.choices : void 0;
         },
         extractMetrics: (result, startTime) => {
-          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _265 => _265.usage]));
+          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _285 => _285.usage]));
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
@@ -13025,9 +13724,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _266 => _266.requestBody])) ? request.requestBody : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _267 => _267.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _268 => _268.xTitle]);
+          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _286 => _286.requestBody])) ? request.requestBody : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _287 => _287.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _288 => _288.xTitle]);
           const { input, ...metadata } = requestBody;
           return {
             input,
@@ -13042,7 +13741,7 @@ var OpenRouterPlugin = class extends BasePlugin {
           if (!isObject(result)) {
             return void 0;
           }
-          const embedding = _optionalChain([result, 'access', _269 => _269.data, 'optionalAccess', _270 => _270[0], 'optionalAccess', _271 => _271.embedding]);
+          const embedding = _optionalChain([result, 'access', _289 => _289.data, 'optionalAccess', _290 => _290[0], 'optionalAccess', _291 => _291.embedding]);
           return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
         },
         extractMetadata: (result) => {
@@ -13062,9 +13761,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _272 => _272.openResponsesRequest])) ? request.openResponsesRequest : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _273 => _273.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _274 => _274.xTitle]);
+          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _292 => _292.openResponsesRequest])) ? request.openResponsesRequest : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _293 => _293.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _294 => _294.xTitle]);
           const { input, ...metadata } = openResponsesRequest;
           return {
             input,
@@ -13074,7 +13773,7 @@ var OpenRouterPlugin = class extends BasePlugin {
         extractOutput: (result) => extractOpenRouterResponseOutput(result),
         extractMetadata: (result) => extractOpenRouterResponseMetadata(result),
         extractMetrics: (result, startTime) => {
-          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _275 => _275.usage]));
+          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _295 => _295.usage]));
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
@@ -13175,12 +13874,12 @@ function aggregateOpenRouterChatChunks(chunks) {
   for (const chunk of chunks) {
     metrics = {
       ...metrics,
-      ...parseOpenRouterMetricsFromUsage(_optionalChain([chunk, 'optionalAccess', _276 => _276.usage]))
+      ...parseOpenRouterMetricsFromUsage(_optionalChain([chunk, 'optionalAccess', _296 => _296.usage]))
     };
-    const choice = _optionalChain([chunk, 'optionalAccess', _277 => _277.choices, 'optionalAccess', _278 => _278[0]]);
-    const delta = _optionalChain([choice, 'optionalAccess', _279 => _279.delta]);
+    const choice = _optionalChain([chunk, 'optionalAccess', _297 => _297.choices, 'optionalAccess', _298 => _298[0]]);
+    const delta = _optionalChain([choice, 'optionalAccess', _299 => _299.delta]);
     if (!delta) {
-      if (_optionalChain([choice, 'optionalAccess', _280 => _280.finish_reason]) !== void 0) {
+      if (_optionalChain([choice, 'optionalAccess', _300 => _300.finish_reason]) !== void 0) {
         finishReason = choice.finish_reason;
       }
       continue;
@@ -13191,7 +13890,7 @@ function aggregateOpenRouterChatChunks(chunks) {
     if (typeof delta.content === "string") {
       content += delta.content;
     }
-    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _281 => _281.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _282 => _282.finish_reason]))), () => ( void 0));
+    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _301 => _301.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _302 => _302.finish_reason]))), () => ( void 0));
     const deltaFinishReason = _nullishCoalesce(_nullishCoalesce(delta.finishReason, () => ( delta.finish_reason)), () => ( void 0));
     if (choiceFinishReason !== void 0) {
       finishReason = choiceFinishReason;
@@ -13203,11 +13902,11 @@ function aggregateOpenRouterChatChunks(chunks) {
       continue;
     }
     for (const toolDelta of toolCallDeltas) {
-      if (!_optionalChain([toolDelta, 'optionalAccess', _283 => _283.function])) {
+      if (!_optionalChain([toolDelta, 'optionalAccess', _303 => _303.function])) {
         continue;
       }
       const toolIndex = _nullishCoalesce(toolDelta.index, () => ( 0));
-      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _284 => _284[toolIndex]]);
+      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _304 => _304[toolIndex]]);
       if (!existingToolCall || toolDelta.id && existingToolCall.id !== void 0 && existingToolCall.id !== toolDelta.id) {
         const nextToolCalls = [...toolCalls || []];
         nextToolCalls[toolIndex] = {
@@ -13254,7 +13953,7 @@ function aggregateOpenRouterChatChunks(chunks) {
 function aggregateOpenRouterResponseStreamEvents(chunks) {
   let finalResponse;
   for (const chunk of chunks) {
-    const response = _optionalChain([chunk, 'optionalAccess', _285 => _285.response]);
+    const response = _optionalChain([chunk, 'optionalAccess', _305 => _305.response]);
     if (!response) {
       continue;
     }
@@ -14666,7 +15365,7 @@ var CachedSpanFetcher = (_class20 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _286 => _286.span_attributes, 'optionalAccess', _287 => _287.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _306 => _306.span_attributes, 'optionalAccess', _307 => _307.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -14700,7 +15399,7 @@ var CachedSpanFetcher = (_class20 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _288 => _288.span_attributes, 'optionalAccess', _289 => _289.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _308 => _308.span_attributes, 'optionalAccess', _309 => _309.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -14780,11 +15479,11 @@ var LocalTrace = (_class21 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _290 => _290.span_attributes, 'optionalAccess', _291 => _291.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _310 => _310.span_attributes, 'optionalAccess', _311 => _311.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _292 => _292.span_attributes, 'optionalAccess', _293 => _293.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _312 => _312.span_attributes, 'optionalAccess', _313 => _313.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -14803,7 +15502,7 @@ var LocalTrace = (_class21 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _294 => _294.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _314 => _314.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -14814,7 +15513,7 @@ var LocalTrace = (_class21 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _295 => _295.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _315 => _315.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -14990,10 +15689,10 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
-    const errorMessages = _optionalChain([validate, 'access', _296 => _296.errors, 'optionalAccess', _297 => _297.map, 'call', _298 => _298((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _316 => _316.errors, 'optionalAccess', _317 => _317.map, 'call', _318 => _318((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _299 => _299.join, 'call', _300 => _300(", ")]);
+    }), 'access', _319 => _319.join, 'call', _320 => _320(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return parameters;
@@ -15231,7 +15930,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters, st
 }
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _301 => _301.spanCache, 'optionalAccess', _302 => _302.start, 'call', _303 => _303()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _321 => _321.spanCache, 'optionalAccess', _322 => _322.start, 'call', _323 => _323()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -15286,7 +15985,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e29) {
+      } catch (e32) {
         return void 0;
       }
     })() : void 0;
@@ -15342,7 +16041,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _304 => _304.data, 'access', async _305 => _305.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _324 => _324.data, 'access', async _325 => _325.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -15368,10 +16067,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _306 => _306({
+                    _optionalChain([stream, 'optionalCall', _326 => _326({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _307 => _307.event, 'optionalAccess', _308 => _308.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _327 => _327.event, 'optionalAccess', _328 => _328.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -15535,7 +16234,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _309 => _309.event, 'optionalAccess', _310 => _310.origin])
+              origin: _optionalChain([baseEvent, 'access', _329 => _329.event, 'optionalAccess', _330 => _330.origin])
             });
           }
         };
@@ -15570,7 +16269,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _311 => _311.setTotal, 'optionalCall', _312 => _312(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _331 => _331.setTotal, 'optionalCall', _332 => _332(evaluator.evalName, scheduledTrials)]);
           q.pushAsync({ datum, trialIndex }).catch((e) => {
             if (queueErrors.length < 5) {
               queueErrors.push(e);
@@ -15655,9 +16354,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _313 => _313.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _314 => _314.dispose, 'call', _315 => _315()]);
-      _optionalChain([spanCache, 'optionalAccess', _316 => _316.stop, 'call', _317 => _317()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _333 => _333.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _334 => _334.dispose, 'call', _335 => _335()]);
+      _optionalChain([spanCache, 'optionalAccess', _336 => _336.stop, 'call', _337 => _337()]);
     }
   }
 }
@@ -15894,7 +16593,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _318 => _318.ctx, 'optionalAccess', _319 => _319.token])) {
+    if (!_optionalChain([req, 'access', _338 => _338.ctx, 'optionalAccess', _339 => _339.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -15907,7 +16606,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _320 => _320.ctx, 'optionalAccess', _321 => _321.token]),
+        apiKey: _optionalChain([req, 'access', _340 => _340.ctx, 'optionalAccess', _341 => _341.token]),
         orgName
       });
       req.ctx.state = state;
@@ -16656,7 +17355,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _322 => _322.ctx, 'optionalAccess', _323 => _323.state])) {
+      if (!_optionalChain([req, 'access', _342 => _342.ctx, 'optionalAccess', _343 => _343.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -16707,12 +17406,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: evaluator.scores.concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _324 => _324.map, 'call', _325 => _325(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _344 => _344.map, 'call', _345 => _345(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _326 => _326.ctx, 'optionalAccess', _327 => _327.projectId])
+                  _optionalChain([req, 'access', _346 => _346.ctx, 'optionalAccess', _347 => _347.projectId])
                 )
               )]), () => ( []))
             ),