braintrust 3.18.0 → 3.19.0

package/dist/workerd.js

@@ -164,6 +164,7 @@ __export(workerd_exports, {
   wrapAISDKModel: () => wrapAISDKModel,
   wrapAgentClass: () => wrapAgentClass,
   wrapAnthropic: () => wrapAnthropic,
+  wrapBedrockRuntime: () => wrapBedrockRuntime,
   wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
@@ -181,6 +182,7 @@ __export(workerd_exports, {
   wrapOpenRouter: () => wrapOpenRouter,
   wrapOpenRouterAgent: () => wrapOpenRouterAgent,
   wrapPiCodingAgentSDK: () => wrapPiCodingAgentSDK,
+  wrapStrandsAgentSDK: () => wrapStrandsAgentSDK,
   wrapTraced: () => wrapTraced,
   wrapVitest: () => wrapVitest
 });
@@ -7816,15 +7818,15 @@ function getSpanParentObject(options) {
   return NOOP_SPAN;
 }
 function logError(span, error) {
-  let errorMessage2 = "<error>";
+  let errorMessage = "<error>";
   let stackTrace = "";
   if (error instanceof Error) {
-    errorMessage2 = error.message;
+    errorMessage = error.message;
     stackTrace = error.stack || "";
   } else {
-    errorMessage2 = String(error);
+    errorMessage = String(error);
   }
-  span.log({ error: `${errorMessage2}
+  span.log({ error: `${errorMessage}
 
 ${stackTrace}` });
 }
@@ -10260,7 +10262,10 @@ function patchStreamIfNeeded(stream, options) {
       let completed = false;
       stream.next = async (...args) => {
         try {
-          const result = await originalNext(...args);
+          const result = await runNextWithWrapper(
+            options,
+            () => originalNext(...args)
+          );
           if (result.done) {
             if (!completed) {
               completed = true;
@@ -10352,7 +10357,10 @@ function patchStreamIfNeeded(stream, options) {
       let completed = false;
       iterator.next = async function(...args) {
         try {
-          const result = await originalNext(...args);
+          const result = await runNextWithWrapper(
+            options,
+            () => originalNext(...args)
+          );
           if (result.done) {
             if (!completed) {
               completed = true;
@@ -10438,6 +10446,9 @@ function patchStreamIfNeeded(stream, options) {
     return stream;
   }
 }
+function runNextWithWrapper(options, callback) {
+  return options.aroundNext ? options.aroundNext(callback) : callback();
+}
 
 // src/instrumentation/core/channel-tracing-utils.ts
 function hasChannelSpanInfo(value) {
@@ -10462,11 +10473,23 @@ function buildStartSpanArgs(config, event) {
     mergeDicts(spanAttributes, spanInfo.spanAttributes);
   }
   return {
-    name: typeof spanInfo?.name === "string" && spanInfo.name ? spanInfo.name : config.name,
+    name: typeof spanInfo?.name === "string" && spanInfo.name ? spanInfo.name : resolveConfigName(config.name, event),
     spanAttributes,
     spanInfoMetadata: isObject(spanInfo?.metadata) ? spanInfo.metadata : void 0
   };
 }
+function resolveConfigName(name, event) {
+  if (typeof name === "string") {
+    return name;
+  }
+  try {
+    const resolved = name(event.arguments ?? [], event);
+    return resolved || "unknown";
+  } catch (error) {
+    debugLogger.error("Error resolving instrumentation span name:", error);
+    return "unknown";
+  }
+}
 function mergeInputMetadata(metadata, spanInfoMetadata) {
   if (!spanInfoMetadata) {
     return isObject(metadata) ? (
@@ -10826,6 +10849,26 @@ var BasePlugin = class {
   }
 };
 
+// src/instrumentation/core/logging.ts
+function toLoggedError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    const serialized = JSON.stringify(error);
+    return serialized === void 0 ? String(error) : serialized;
+  } catch {
+    try {
+      return String(error);
+    } catch {
+      return "<unserializable error>";
+    }
+  }
+}
+
 // src/instrumentation/auto-instrumentation-suppression.ts
 var autoInstrumentationSuppressionStore;
 function suppressionStore() {
@@ -12333,7 +12376,7 @@ async function finalizeCodexRun(state, params = {}) {
   try {
     const error = params.error;
     safeLog(state.span, {
-      ...error ? { error: error instanceof Error ? error.message : String(error) } : {},
+      ...error ? { error: toLoggedError(error) } : {},
       metadata: state.metadata,
       metrics,
       output
@@ -12439,7 +12482,7 @@ async function finishActiveLlmSpan(state, error) {
   state.activeLlmSpan = void 0;
   const output = buildLlmOutput(active);
   safeLog(active.span, {
-    ...error ? { error: error instanceof Error ? error.message : String(error) } : {},
+    ...error ? { error: toLoggedError(error) } : {},
     metadata: active.metadata,
     ...output ? { output } : {}
   });
@@ -12962,9 +13005,6 @@ function extractAnthropicToolNames(tools) {
   }
   return toolNames;
 }
-function toErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 function getAnthropicToolRunnerInput(args) {
   return args.length > 0 ? args[0] : void 0;
 }
@@ -12998,7 +13038,7 @@ function wrapAnthropicToolRunnerTool(tool, index, state) {
             return result;
           };
           const finalizeError = (error) => {
-            span.log({ error: toErrorMessage(error) });
+            span.log({ error: toLoggedError(error) });
             throw error;
           };
           try {
@@ -13154,7 +13194,7 @@ function finalizeAnthropicToolRunnerError(state, error) {
   }
   state.finalized = true;
   state.span.log({
-    error: error instanceof Error ? error.message : String(error)
+    error: toLoggedError(error)
   });
   state.span.end();
 }
@@ -13483,7 +13523,7 @@ function processAttachmentsInInput(input) {
 function coalesceInput(messages, system) {
   const input = (messages || []).slice();
   if (system) {
-    input.push({ role: "system", content: system });
+    input.unshift({ role: "system", content: system });
   }
   return input;
 }
@@ -15070,9 +15110,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
             }
             span.log({ output: lastValue });
           } catch (error) {
-            span.log({
-              error: error instanceof Error ? error.message : String(error)
-            });
+            span.log({ error: toLoggedError(error) });
             throw error;
           } finally {
             span.end();
@@ -16085,9 +16123,6 @@ function bindClaudeLocalToolContextToAsyncIterable(result, localToolContext) {
 var LOCAL_TOOL_HANDLER_WRAPPED = /* @__PURE__ */ Symbol.for(
   "braintrust.claude_agent_sdk.local_tool_handler_wrapped"
 );
-function toErrorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 function getToolUseIdFromExtra(extra) {
   if (!extra || typeof extra !== "object" || !("_meta" in extra)) {
     return void 0;
@@ -16134,7 +16169,7 @@ function wrapLocalClaudeToolHandler(handler, getMetadata) {
         return result;
       };
       const finalizeError = (error) => {
-        span.log({ error: toErrorMessage2(error) });
+        span.log({ error: toLoggedError(error) });
         span.end();
         throw error;
       };
@@ -17835,7 +17870,7 @@ async function handleToolUpdate(state, update) {
     toolCall
   });
   finishToolSpan(toolState, {
-    error: toolCall?.status === "error" ? stringifyUnknown(result) : void 0,
+    error: toolCall?.status === "error" ? toLoggedError(result) : void 0,
     metadata: {
       "cursor_sdk.tool.status": toolCall?.status ?? "completed"
     },
@@ -17918,7 +17953,7 @@ async function handleToolMessage(state, message) {
     truncated: message.truncated
   });
   finishToolSpan(toolState, {
-    error: message.status === "error" ? stringifyUnknown(message.result) : void 0,
+    error: message.status === "error" ? toLoggedError(message.result) : void 0,
     metadata: {
       "cursor_sdk.tool.status": message.status
     },
@@ -17969,7 +18004,7 @@ async function handleConversationStep(state, step) {
     toolCall
   });
   finishToolSpan(toolState, {
-    error: toolCall?.status === "error" ? stringifyUnknown(toolCall.result) : void 0,
+    error: toolCall?.status === "error" ? toLoggedError(toolCall.result) : void 0,
     metadata: {
       "cursor_sdk.tool.status": toolCall?.status ?? "completed"
     },
@@ -18079,7 +18114,7 @@ async function finalizeCursorRun(state, params = {}) {
     };
     if (error) {
       safeLog2(state.span, {
-        error: error instanceof Error ? error.message : String(error),
+        error: toLoggedError(error),
         metadata,
         metrics: {
           ...cleanMetrics2(state.metrics),
@@ -18265,19 +18300,6 @@ function getString(obj, key) {
   const value = obj?.[key];
   return typeof value === "string" ? value : void 0;
 }
-function stringifyUnknown(value) {
-  if (value instanceof Error) {
-    return value.message;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
 function safeLog2(span, event) {
   try {
     span.log(event);
@@ -20793,9 +20815,7 @@ function patchOpenRouterCallModelResult(args) {
       return;
     }
     ended = true;
-    span.log({
-      error: normalizeError(error).message
-    });
+    span.log({ error: toLoggedError(error) });
     span.end();
   };
   const finalizeFromResponse = async (fallbackOutput) => {
@@ -21866,9 +21886,7 @@ function patchOpenRouterCallModelResult2(args) {
       return;
     }
     ended = true;
-    span.log({
-      error: normalizeError2(error).message
-    });
+    span.log({ error: toLoggedError(error) });
     span.end();
   };
   const finalizeFromResponse = async (fallbackOutput) => {
@@ -24242,6 +24260,652 @@ function aggregateGroqReasoning(chunks) {
   return reasoning.length > 0 ? reasoning : void 0;
 }
 
+// src/instrumentation/plugins/bedrock-runtime-channels.ts
+var clientSendChannel = channel({
+  channelName: "client.send",
+  kind: "async"
+});
+var bedrockRuntimeChannels = defineChannels("aws-bedrock-runtime", {
+  clientSend: clientSendChannel
+});
+var smithyCoreChannels = defineChannels("@smithy/core", {
+  clientSend: clientSendChannel
+});
+var smithyClientChannels = defineChannels("@smithy/smithy-client", {
+  clientSend: clientSendChannel
+});
+
+// src/instrumentation/plugins/bedrock-runtime-common.ts
+var BEDROCK_RUNTIME_COMMAND_OPERATIONS = {
+  ConverseCommand: "converse",
+  ConverseStreamCommand: "converseStream",
+  InvokeModelCommand: "invokeModel",
+  InvokeModelWithBidirectionalStreamCommand: "invokeModelWithBidirectionalStream",
+  InvokeModelWithResponseStreamCommand: "invokeModelWithResponseStream"
+};
+function getBedrockRuntimeCommandName(command) {
+  if (!isObject(command) || !isObject(command.constructor)) {
+    return void 0;
+  }
+  const input = command.input;
+  if (!isObject(input) || typeof input.modelId !== "string") {
+    return void 0;
+  }
+  const commandName = command.constructor.name;
+  return isBedrockRuntimeCommandName(commandName) ? commandName : void 0;
+}
+function getBedrockRuntimeOperation(command) {
+  const commandName = getBedrockRuntimeCommandName(command);
+  return commandName ? BEDROCK_RUNTIME_COMMAND_OPERATIONS[commandName] : void 0;
+}
+function getBedrockRuntimeCommandInput(command) {
+  return isObject(command) ? command.input : void 0;
+}
+function buildBedrockRuntimeSpanInfo(command) {
+  const commandName = getBedrockRuntimeCommandName(command);
+  const operation = getBedrockRuntimeOperation(command);
+  return {
+    name: operation ? `bedrock.${operation}` : "bedrock.client.send",
+    metadata: {
+      ...commandName ? { command: commandName } : {},
+      ...operation ? { operation } : {}
+    }
+  };
+}
+function isBedrockRuntimeCommandName(commandName) {
+  return commandName === "ConverseCommand" || commandName === "ConverseStreamCommand" || commandName === "InvokeModelCommand" || commandName === "InvokeModelWithBidirectionalStreamCommand" || commandName === "InvokeModelWithResponseStreamCommand";
+}
+
+// src/instrumentation/plugins/bedrock-runtime-plugin.ts
+var BedrockRuntimePlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      ...[
+        bedrockRuntimeChannels.clientSend,
+        smithyCoreChannels.clientSend,
+        smithyClientChannels.clientSend
+      ].map((channel2) => traceBedrockRuntimeClientSendChannel(channel2))
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function traceBedrockRuntimeClientSendChannel(channel2) {
+  return traceStreamingChannel(channel2, {
+    name: ([command]) => buildBedrockRuntimeSpanInfo(command).name,
+    shouldTrace: ([command, optionsOrCb, cb]) => getBedrockRuntimeOperation(command) !== void 0 && typeof optionsOrCb !== "function" && typeof cb !== "function",
+    type: "llm" /* LLM */,
+    extractInput: ([command]) => extractBedrockRuntimeInput(command),
+    extractOutput: (result, endEvent) => extractBedrockRuntimeOutput(endEvent?.arguments?.[0], result),
+    extractMetadata: (result, endEvent) => extractBedrockRuntimeResponseMetadata(endEvent?.arguments?.[0], result),
+    extractMetrics: (result) => extractBedrockRuntimeResponseMetrics(result),
+    patchResult: ({ endEvent, result, span, startTime }) => patchBedrockRuntimeStreamingResult({
+      command: endEvent.arguments?.[0],
+      result,
+      span,
+      startTime
+    })
+  });
+}
+function extractBedrockRuntimeInput(command) {
+  const operation = getBedrockRuntimeOperation(command);
+  const commandName = getBedrockRuntimeCommandName(command);
+  const request = getBedrockRuntimeCommandInput(command);
+  const metadata = {
+    provider: "aws-bedrock",
+    ...commandName ? { command: commandName } : {},
+    ...operation ? { operation } : {},
+    ...extractBedrockRuntimeRequestMetadata(request)
+  };
+  if (operation === "converse" || operation === "converseStream") {
+    const converseRequest = isObject(request) ? request : void 0;
+    return {
+      input: sanitizeBedrockValue({
+        messages: converseRequest?.messages,
+        system: converseRequest?.system
+      }),
+      metadata
+    };
+  }
+  if (operation === "invokeModel" || operation === "invokeModelWithBidirectionalStream" || operation === "invokeModelWithResponseStream") {
+    const invokeRequest = isObject(request) ? request : void 0;
+    return {
+      input: parseJsonBody(invokeRequest?.body) ?? summarizeBody(invokeRequest?.body),
+      metadata
+    };
+  }
+  return {
+    input: sanitizeBedrockValue(request),
+    metadata
+  };
+}
+function extractBedrockRuntimeRequestMetadata(request) {
+  if (!isObject(request)) {
+    return {};
+  }
+  const metadata = {};
+  for (const key of [
+    "modelId",
+    "contentType",
+    "accept",
+    "trace",
+    "guardrailIdentifier",
+    "guardrailVersion",
+    "performanceConfig",
+    "performanceConfigLatency",
+    "serviceTier"
+  ]) {
+    const value = request[key];
+    if (value !== void 0) {
+      metadata[key === "modelId" ? "model" : key] = value;
+    }
+  }
+  if (isObject(request.inferenceConfig)) {
+    Object.assign(metadata, sanitizeBedrockValue(request.inferenceConfig));
+  }
+  return metadata;
+}
+function extractBedrockRuntimeOutput(command, result) {
+  const operation = getBedrockRuntimeOperation(command);
+  if (operation === "converse") {
+    return sanitizeBedrockValue(
+      result?.output?.message
+    );
+  }
+  if (operation === "invokeModel") {
+    const response = isObject(result) ? result : void 0;
+    return parseJsonBody(response?.body) ?? summarizeBody(response?.body);
+  }
+  return sanitizeBedrockValue(result);
+}
+function extractBedrockRuntimeResponseMetadata(command, result) {
+  const operation = getBedrockRuntimeOperation(command);
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const metadata = {};
+  for (const key of [
+    "stopReason",
+    "contentType",
+    "performanceConfig",
+    "performanceConfigLatency",
+    "serviceTier"
+  ]) {
+    const value = result[key];
+    if (value !== void 0) {
+      metadata[key] = value;
+    }
+  }
+  if (operation === "converse" && result.additionalModelResponseFields !== void 0) {
+    metadata.additionalModelResponseFields = sanitizeBedrockValue(
+      result.additionalModelResponseFields
+    );
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function extractBedrockRuntimeResponseMetrics(result) {
+  if (!isObject(result)) {
+    return {};
+  }
+  const parsedBody = parseJsonBody(result.body);
+  if (isObject(parsedBody)) {
+    const metadata = isObject(parsedBody.metadata) ? parsedBody.metadata : void 0;
+    const metrics = parseBedrockRuntimeMetrics(
+      parsedBody.usage ?? metadata?.usage,
+      parsedBody.metrics ?? metadata?.metrics
+    );
+    if (Object.keys(metrics).length > 0) {
+      return metrics;
+    }
+  }
+  return parseBedrockRuntimeMetrics(result.usage, result.metrics);
+}
+function parseBedrockRuntimeMetrics(usage, responseMetrics) {
+  const metrics = {};
+  const usageRecord = isObject(usage) ? usage : {};
+  const promptTokens = firstNumber3(
+    usageRecord.inputTokens,
+    usageRecord.inputTokenCount,
+    usageRecord.input_tokens,
+    usageRecord.prompt_tokens
+  );
+  if (promptTokens !== void 0) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  const completionTokens = firstNumber3(
+    usageRecord.outputTokens,
+    usageRecord.outputTokenCount,
+    usageRecord.output_tokens,
+    usageRecord.completion_tokens
+  );
+  if (completionTokens !== void 0) {
+    metrics.completion_tokens = completionTokens;
+  }
+  const totalTokens = firstNumber3(
+    usageRecord.totalTokens,
+    usageRecord.totalTokenCount,
+    usageRecord.total_tokens,
+    usageRecord.tokens
+  );
+  if (totalTokens !== void 0) {
+    metrics.tokens = totalTokens;
+  }
+  const cacheReadInputTokens = firstNumber3(
+    usageRecord.cacheReadInputTokens,
+    usageRecord.cacheReadInputTokenCount,
+    usageRecord.cache_read_input_tokens,
+    usageRecord.prompt_cached_tokens
+  );
+  if (cacheReadInputTokens !== void 0) {
+    metrics.prompt_cached_tokens = cacheReadInputTokens;
+  }
+  const cacheWriteInputTokens = firstNumber3(
+    usageRecord.cacheWriteInputTokens,
+    usageRecord.cacheWriteInputTokenCount,
+    usageRecord.cache_write_input_tokens,
+    usageRecord.cache_creation_input_tokens,
+    usageRecord.prompt_cache_creation_tokens
+  );
+  if (cacheWriteInputTokens !== void 0) {
+    metrics.prompt_cache_creation_tokens = cacheWriteInputTokens;
+  }
+  if (metrics.tokens === void 0) {
+    const tokenParts = [
+      promptTokens,
+      completionTokens,
+      cacheReadInputTokens,
+      cacheWriteInputTokens
+    ].filter((value) => value !== void 0);
+    if (tokenParts.length > 0) {
+      metrics.tokens = tokenParts.reduce((total, value) => total + value, 0);
+    }
+  }
+  if (isObject(responseMetrics) && typeof responseMetrics.latencyMs === "number") {
+    metrics.latency_ms = responseMetrics.latencyMs;
+  }
+  return metrics;
+}
+function firstNumber3(...values) {
+  return values.find((value) => typeof value === "number");
+}
+function patchBedrockRuntimeStreamingResult(args) {
+  const operation = getBedrockRuntimeOperation(args.command);
+  if (!isObject(args.result)) {
+    return false;
+  }
+  if (operation === "converseStream" && isAsyncIterable(args.result.stream)) {
+    patchConverseStream(
+      args.result.stream,
+      args.span,
+      args.startTime
+    );
+    return true;
+  }
+  if ((operation === "invokeModelWithBidirectionalStream" || operation === "invokeModelWithResponseStream") && isAsyncIterable(args.result.body)) {
+    patchInvokeModelResponseStream(
+      args.result.body,
+      args.span,
+      args.startTime
+    );
+    return true;
+  }
+  return false;
+}
+function patchConverseStream(stream, span, startTime) {
+  let firstChunkTime;
+  patchStreamIfNeeded(stream, {
+    onChunk: (chunk) => {
+      if (firstChunkTime === void 0 && isObject(chunk.contentBlockDelta)) {
+        firstChunkTime = getCurrentUnixTimestamp();
+      }
+    },
+    onComplete: (chunks) => {
+      const aggregated = aggregateBedrockConverseStreamChunks(chunks);
+      const metrics = { ...aggregated.metrics };
+      if (firstChunkTime !== void 0) {
+        metrics.time_to_first_token = firstChunkTime - startTime;
+      }
+      logBedrockStreamAggregation(span, aggregated, metrics);
+      span.end();
+    },
+    onError: (error) => {
+      span.log({ error: error.message });
+      span.end();
+    }
+  });
+}
+function patchInvokeModelResponseStream(stream, span, startTime) {
+  let firstChunkTime;
+  patchStreamIfNeeded(stream, {
+    onChunk: (chunk) => {
+      if (firstChunkTime === void 0 && isObject(chunk.chunk)) {
+        firstChunkTime = getCurrentUnixTimestamp();
+      }
+    },
+    onComplete: (chunks) => {
+      const aggregated = aggregateInvokeModelResponseStreamChunks(chunks);
+      const metrics = { ...aggregated.metrics };
+      if (firstChunkTime !== void 0) {
+        metrics.time_to_first_token = firstChunkTime - startTime;
+      }
+      logBedrockStreamAggregation(span, aggregated, metrics);
+      span.end();
+    },
+    onError: (error) => {
+      span.log({ error: error.message });
+      span.end();
+    }
+  });
+}
+var BEDROCK_STREAM_EXCEPTION_KEYS = [
+  "internalServerException",
+  "modelStreamErrorException",
+  "validationException",
+  "throttlingException",
+  "modelTimeoutException",
+  "serviceUnavailableException"
+];
+function aggregateBedrockConverseStreamChunks(chunks) {
+  let role;
+  let stopReason;
+  let usage;
+  let responseMetrics;
+  const contentByIndex = /* @__PURE__ */ new Map();
+  const metadata = {};
+  for (const chunk of chunks) {
+    const exception = extractBedrockStreamException(chunk);
+    if (exception) {
+      return exception;
+    }
+    if (typeof chunk.messageStart?.role === "string") {
+      role = chunk.messageStart.role;
+    }
+    const startIndex = chunk.contentBlockStart?.contentBlockIndex;
+    if (typeof startIndex === "number") {
+      contentByIndex.set(startIndex, {
+        ...contentByIndex.get(startIndex) ?? {},
+        ...sanitizeRecord(chunk.contentBlockStart?.start)
+      });
+    }
+    const deltaIndex = chunk.contentBlockDelta?.contentBlockIndex;
+    const delta = chunk.contentBlockDelta?.delta;
+    if (typeof deltaIndex === "number" && isObject(delta)) {
+      const existing = contentByIndex.get(deltaIndex) ?? {};
+      contentByIndex.set(deltaIndex, mergeContentBlockDelta(existing, delta));
+    }
+    if (typeof chunk.messageStop?.stopReason === "string") {
+      stopReason = chunk.messageStop.stopReason;
+    }
+    if (chunk.messageStop?.additionalModelResponseFields !== void 0) {
+      metadata.additionalModelResponseFields = sanitizeBedrockValue(
+        chunk.messageStop.additionalModelResponseFields
+      );
+    }
+    if (chunk.metadata?.usage !== void 0) {
+      usage = chunk.metadata.usage;
+    }
+    if (chunk.metadata?.metrics !== void 0) {
+      responseMetrics = chunk.metadata.metrics;
+    }
+    if (chunk.metadata?.performanceConfig !== void 0) {
+      metadata.performanceConfig = sanitizeBedrockValue(
+        chunk.metadata.performanceConfig
+      );
+    }
+    if (chunk.metadata?.serviceTier !== void 0) {
+      metadata.serviceTier = chunk.metadata.serviceTier;
+    }
+  }
+  if (stopReason !== void 0) {
+    metadata.stopReason = stopReason;
+  }
+  const content = [...contentByIndex.entries()].sort(([left], [right]) => left - right).map(([, value]) => value).filter((value) => Object.keys(value).length > 0);
+  return {
+    output: {
+      role,
+      content
+    },
+    metrics: parseBedrockRuntimeMetrics(usage, responseMetrics),
+    ...Object.keys(metadata).length > 0 ? { metadata } : {}
+  };
+}
+function aggregateInvokeModelResponseStreamChunks(chunks) {
+  for (const chunk of chunks) {
+    const exception = extractBedrockStreamException(chunk);
+    if (exception) {
+      return exception;
+    }
+  }
+  const parsedChunks = chunks.map((chunk) => parseJsonBody(chunk.chunk?.bytes)).filter((chunk) => chunk !== void 0);
+  const jsonLikeChunks = parsedChunks.filter(isObject);
+  const text = parsedChunks.map(extractTextFromJsonLike).join("");
+  const lastMetadataChunk = jsonLikeChunks.slice().reverse().find((chunk) => isObject(chunk.metadata));
+  const metadata = isObject(lastMetadataChunk?.metadata) ? sanitizeRecord(lastMetadataChunk.metadata) : void 0;
+  let usage;
+  for (const chunk of jsonLikeChunks) {
+    const message = chunk.message;
+    for (const candidate of [
+      isObject(chunk.usage) ? chunk.usage : void 0,
+      isObject(message) && isObject(message.usage) ? message.usage : void 0
+    ]) {
+      if (candidate !== void 0) {
+        usage = {
+          ...usage,
+          ...sanitizeRecord(candidate)
+        };
+      }
+    }
+  }
+  return {
+    output: text.length > 0 ? { text } : {
+      chunk_count: chunks.length,
+      chunks: sanitizeBedrockValue(
+        (jsonLikeChunks.length > 0 ? jsonLikeChunks : chunks).slice(
+          0,
+          20
+        )
+      )
+    },
+    metrics: parseBedrockRuntimeMetrics(
+      usage ?? (isObject(metadata) ? metadata.usage : void 0),
+      isObject(metadata) ? metadata.metrics : void 0
+    ),
+    ...metadata ? { metadata } : {}
+  };
+}
+function logBedrockStreamAggregation(span, aggregated, metrics) {
+  span.log(
+    aggregated.error !== void 0 ? {
+      error: aggregated.error,
+      ...aggregated.metadata ? { metadata: aggregated.metadata } : {},
+      metrics
+    } : {
+      output: aggregated.output,
+      ...aggregated.metadata ? { metadata: aggregated.metadata } : {},
+      metrics
+    }
+  );
+}
+function extractBedrockStreamException(chunk) {
+  if (!isObject(chunk)) {
+    return void 0;
+  }
+  for (const [key, value] of Object.entries(chunk)) {
+    if (!isBedrockStreamExceptionKey(key) || !isObject(value)) {
+      continue;
+    }
+    const name = typeof value.name === "string" ? value.name : key;
+    const message = typeof value.message === "string" ? value.message : typeof value.originalMessage === "string" ? value.originalMessage : void 0;
+    const metadata = {
+      exception: key
+    };
+    if (typeof value.name === "string") {
+      metadata.exceptionName = value.name;
+    }
+    if (typeof value.$fault === "string") {
+      metadata.fault = value.$fault;
+    }
+    if (typeof value.originalMessage === "string") {
+      metadata.originalMessage = value.originalMessage;
+    }
+    if (typeof value.originalStatusCode === "number") {
+      metadata.originalStatusCode = value.originalStatusCode;
+    }
+    return {
+      error: message ? `${name}: ${message}` : name,
+      metadata,
+      metrics: {}
+    };
+  }
+  return void 0;
+}
+function isBedrockStreamExceptionKey(key) {
+  return BEDROCK_STREAM_EXCEPTION_KEYS.some((candidate) => candidate === key);
+}
+function mergeContentBlockDelta(existing, delta) {
+  const next = { ...existing };
+  if (typeof delta.text === "string") {
+    next.text = `${typeof next.text === "string" ? next.text : ""}${delta.text}`;
+  }
+  if (isObject(delta.reasoningContent)) {
+    const existingReasoning = isObject(next.reasoningContent) ? next.reasoningContent : {};
+    next.reasoningContent = {
+      ...existingReasoning,
+      ...sanitizeRecord(delta.reasoningContent),
+      ...typeof delta.reasoningContent.text === "string" ? {
+        text: `${typeof existingReasoning.text === "string" ? existingReasoning.text : ""}${delta.reasoningContent.text}`
+      } : {}
+    };
+  }
+  if (isObject(delta.toolUse)) {
+    const existingToolUse = isObject(next.toolUse) ? next.toolUse : {};
+    next.toolUse = {
+      ...existingToolUse,
+      ...sanitizeRecord(delta.toolUse),
+      ...typeof delta.toolUse.input === "string" ? {
+        input: `${typeof existingToolUse.input === "string" ? existingToolUse.input : ""}${delta.toolUse.input}`
+      } : {}
+    };
+  }
+  for (const [key, value] of Object.entries(delta)) {
+    if (key !== "text" && key !== "reasoningContent" && key !== "toolUse" && isSafeBedrockObjectKey(key)) {
+      next[key] = sanitizeBedrockValue(value);
+    }
+  }
+  return next;
+}
+function parseJsonBody(body) {
+  const text = decodeBodyToString(body);
+  if (text === void 0 || text.length === 0) {
+    return void 0;
+  }
+  try {
+    return sanitizeBedrockValue(JSON.parse(text));
+  } catch {
+    return void 0;
+  }
+}
+function summarizeBody(body) {
+  if (body === void 0 || body === null) {
+    return void 0;
+  }
+  const text = decodeBodyToString(body);
+  if (text !== void 0) {
+    return text.length > 2e3 ? `${text.slice(0, 2e3)}...` : text;
+  }
+  return sanitizeBedrockValue(body);
+}
+function decodeBodyToString(body) {
+  if (typeof body === "string") {
+    return body;
+  }
+  if (body instanceof Uint8Array) {
+    return new TextDecoder().decode(body);
+  }
+  if (body instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(body));
+  }
+  return void 0;
+}
+function sanitizeRecord(value) {
+  return isObject(value) ? sanitizeBedrockValue(value) : {};
+}
+function sanitizeBedrockValue(value, depth = 0) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return { byte_length: value.byteLength };
+  }
+  if (value instanceof ArrayBuffer) {
+    return { byte_length: value.byteLength };
+  }
+  if (Array.isArray(value)) {
+    return depth > 20 ? "[MaxDepth]" : value.map((item) => sanitizeBedrockValue(item, depth + 1));
+  }
+  if (!isObject(value)) {
+    return String(value);
+  }
+  if (depth > 20) {
+    return "[MaxDepth]";
+  }
+  const output = {};
+  for (const [key, nested] of Object.entries(value)) {
+    if (!isSafeBedrockObjectKey(key)) {
+      continue;
+    }
+    output[key] = sanitizeBedrockValue(nested, depth + 1);
+  }
+  return output;
+}
+function isSafeBedrockObjectKey(key) {
+  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+function extractTextFromJsonLike(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(extractTextFromJsonLike).join("");
+  }
+  if (!isObject(value)) {
+    return "";
+  }
+  const contentBlockDelta = value.contentBlockDelta;
+  if (isObject(contentBlockDelta)) {
+    return extractTextFromJsonLike(contentBlockDelta.delta);
+  }
+  if (isObject(value.delta)) {
+    return extractTextFromJsonLike(value.delta);
+  }
+  if (typeof value.text === "string") {
+    return value.text;
+  }
+  if (typeof value.outputText === "string") {
+    return value.outputText;
+  }
+  if (typeof value.completion === "string") {
+    return value.completion;
+  }
+  if (typeof value.generation === "string") {
+    return value.generation;
+  }
+  if (Array.isArray(value.content)) {
+    return value.content.map(extractTextFromJsonLike).join("");
+  }
+  if (Array.isArray(value.output)) {
+    return value.output.map(extractTextFromJsonLike).join("");
+  }
+  if (Array.isArray(value.outputs)) {
+    return value.outputs.map(extractTextFromJsonLike).join("");
+  }
+  return "";
+}
+
 // src/instrumentation/plugins/genkit-channels.ts
 var genkitChannels = defineChannels("@genkit-ai/ai", {
   generate: channel({
@@ -24666,7 +25330,7 @@ function createDeferredSpanFinalizer(span) {
       try {
         await callback();
       } catch (error) {
-        span.log({ error: errorMessage(error) });
+        span.log({ error: toLoggedError(error) });
       } finally {
         span.end();
       }
@@ -24820,9 +25484,6 @@ function pickNumberMetrics(values) {
     })
   );
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 function stringValue(value) {
   return typeof value === "string" ? value : void 0;
 }
@@ -25367,10 +26028,22 @@ var flueChannels = defineChannels("@flue/runtime", {
 
 // src/instrumentation/plugins/flue-plugin.ts
 var FLUE_AUTO_STATE = /* @__PURE__ */ Symbol.for("braintrust.flue.auto-state");
+var FLUE_INSTRUMENTATION_KEY = /* @__PURE__ */ Symbol.for("braintrust.flue.instrumentation");
 var FLUE_OBSERVE_BRIDGE = /* @__PURE__ */ Symbol.for("braintrust.flue.observe-bridge");
-var braintrustFlueObserver = (event, ctx) => {
+function observeFlue(event, ctx) {
   getObserveBridge().handle(event, ctx);
-};
+}
+var interceptFlueExecution = (operation, ctx, next) => getObserveBridge().intercept(operation, ctx, next);
+var braintrustFlueObserver = Object.assign(
+  observeFlue,
+  {
+    dispose() {
+    },
+    interceptor: interceptFlueExecution,
+    key: FLUE_INSTRUMENTATION_KEY,
+    observe: observeFlue
+  }
+);
 var FluePlugin = class extends BasePlugin {
   onEnable() {
     this.unsubscribers.push(enableFlueAutoInstrumentation());
@@ -25385,16 +26058,16 @@ var FluePlugin = class extends BasePlugin {
 function enableFlueAutoInstrumentation() {
   const state = getAutoState();
   state.refCount += 1;
-  if (!state.handlers) {
-    const channel2 = flueChannels.createContext.tracingChannel();
+  if (!state.createContextHandlers) {
+    const createContextChannel = flueChannels.createContext.tracingChannel();
     const handlers = {
       end: (event) => {
         subscribeToFlueContext(event.result, state);
       }
     };
-    channel2.subscribe(handlers);
-    state.channel = channel2;
-    state.handlers = handlers;
+    createContextChannel.subscribe(handlers);
+    state.createContextChannel = createContextChannel;
+    state.createContextHandlers = handlers;
   }
   let released = false;
   return () => {
@@ -25438,8 +26111,8 @@ function releaseAutoState(state) {
     return;
   }
   try {
-    if (state.channel && state.handlers) {
-      state.channel.unsubscribe(state.handlers);
+    if (state.createContextChannel && state.createContextHandlers) {
+      state.createContextChannel.unsubscribe(state.createContextHandlers);
     }
   } finally {
     Reflect.deleteProperty(globalThis, FLUE_AUTO_STATE);
@@ -25497,7 +26170,7 @@ function isObservableFlueContext(value) {
 }
 function isFlueEvent(event) {
   const type = Reflect.get(event, "type");
-  return type === "run_start" || type === "run_end" || type === "operation_start" || type === "operation" || type === "turn_request" || type === "turn" || type === "tool_start" || type === "tool_call" || type === "task_start" || type === "task" || type === "compaction_start" || type === "compaction";
+  return type === "run_start" || type === "run_resume" || type === "run_end" || type === "operation_start" || type === "operation" || type === "turn_request" || type === "turn" || type === "tool_start" || type === "tool_call" || type === "tool" || type === "task_start" || type === "task" || type === "compaction_start" || type === "compaction";
 }
 function flueContextFromUnknown(ctx) {
   if (!isObjectLike(ctx)) {
@@ -25544,11 +26217,97 @@ var FlueObserveBridge = class {
     this.toolsByKey.clear();
     this.turnsByKey.clear();
   }
+  intercept(operation, executionContext, next) {
+    let span;
+    try {
+      span = this.spanForExecutionOperation(operation, executionContext);
+    } catch (error) {
+      logInstrumentationError3("Flue execution interceptor", error);
+    }
+    return span ? runWithCurrentSpanStore(span, next) : next();
+  }
+  spanForExecutionOperation(operation, executionContext) {
+    switch (operation.type) {
+      case "workflow":
+        return this.ensureWorkflowSpanForExecution(operation, executionContext);
+      case "agent":
+        return this.operationsById.get(operation.operationId)?.span;
+      case "model":
+        return this.turnsByKey.get(operation.turnId)?.span;
+      case "tool":
+        return this.spanForToolExecution(operation, executionContext);
+      case "task":
+        return this.tasksById.get(operation.taskId)?.span;
+      default:
+        return void 0;
+    }
+  }
+  ensureWorkflowSpanForExecution(operation, executionContext) {
+    const existing = this.runsById.get(operation.runId);
+    if (existing) {
+      return existing.span;
+    }
+    const ctx = flueContextFromUnknown(executionContext.eventContext) ?? flueContextFromUnknown({
+      id: operation.workflowName,
+      runId: operation.runId
+    });
+    if (operation.phase === "resume") {
+      this.handleRunResume(
+        {
+          eventIndex: 0,
+          runId: operation.runId,
+          startedAt: operation.startedAt,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "run_resume",
+          v: 3,
+          workflowName: operation.workflowName
+        },
+        ctx
+      );
+    } else {
+      this.handleRunStart(
+        {
+          eventIndex: 0,
+          input: void 0,
+          runId: operation.runId,
+          startedAt: operation.startedAt,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "run_start",
+          v: 3,
+          workflowName: operation.workflowName
+        },
+        ctx
+      );
+    }
+    return this.runsById.get(operation.runId)?.span;
+  }
+  spanForToolExecution(operation, executionContext) {
+    const contextual = this.toolsByKey.get(
+      toolKey({ ...executionContext, toolCallId: operation.toolCallId })
+    );
+    if (contextual) {
+      return contextual.span;
+    }
+    let fallback2;
+    for (const state of this.toolsByKey.values()) {
+      if (state.metadata["flue.tool_call_id"] !== operation.toolCallId) {
+        continue;
+      }
+      if (state.metadata["flue.tool_name"] === operation.toolName) {
+        return state.span;
+      }
+      fallback2 ??= state.span;
+    }
+    return fallback2;
+  }
   handleEvent(event, ctx) {
     switch (event.type) {
       case "run_start":
         this.handleRunStart(event, ctx);
         return;
+      case "run_resume":
+        this.handleRunResume(event, ctx);
+        return;
       case "run_end":
         this.handleRunEnd(event);
         return;
@@ -25568,6 +26327,7 @@ var FlueObserveBridge = class {
         this.handleToolStart(event);
         return;
       case "tool_call":
+      case "tool":
         this.handleToolCall(event);
         return;
       case "task_start":
@@ -25591,30 +26351,61 @@ var FlueObserveBridge = class {
       return;
     }
     const workflowName = event.workflowName ?? event.owner?.workflowName ?? (typeof ctx?.id === "string" ? ctx.id : "unknown");
+    const input = flueRunInput(event);
     const metadata = {
-      ...extractPayloadMetadata(event.payload),
+      ...extractPayloadMetadata(input),
       ...extractEventMetadata(event, ctx),
       ...workflowName ? { "flue.workflow_name": workflowName } : {},
       provider: "flue"
     };
+    const existing = this.runsById.get(event.runId);
+    if (existing) {
+      existing.metadata = metadata;
+      safeLog3(existing.span, { input, metadata });
+      return;
+    }
     const span = startSpan({
       name: `workflow:${workflowName}`,
       spanAttributes: { type: "task" /* TASK */ },
       startTime: eventTime(event.startedAt ?? event.timestamp),
       event: {
-        input: event.payload,
+        input,
         metadata
       }
     });
-    const activeContext = enterCurrentFlueSpan(span);
-    this.runsById.set(event.runId, { activeContext, metadata, span });
+    this.runsById.set(event.runId, { metadata, span });
+  }
+  handleRunResume(event, ctx) {
+    if (!event.runId) {
+      return;
+    }
+    const workflowName = event.workflowName ?? (typeof ctx?.id === "string" ? ctx.id : "unknown");
+    const metadata = {
+      ...extractEventMetadata(event, ctx),
+      ...workflowName ? { "flue.workflow_name": workflowName } : {},
+      "flue.workflow_phase": "resume",
+      provider: "flue"
+    };
+    const existing = this.runsById.get(event.runId);
+    if (existing) {
+      existing.metadata = metadata;
+      safeLog3(existing.span, { metadata });
+      return;
+    }
+    const span = startSpan({
+      name: `workflow:${workflowName}`,
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.startedAt ?? event.timestamp),
+      event: { metadata }
+    });
+    this.runsById.set(event.runId, { metadata, span });
   }
   handleRunEnd(event) {
     const state = this.runsById.get(event.runId);
     this.finishPendingSpansForRun(event);
     if (state) {
       safeLog3(state.span, {
-        ...event.isError ? { error: errorToString(event.error) } : {},
+        ...event.isError ? { error: toLoggedError(event.error) } : {},
         metadata: {
           ...state.metadata,
           ...extractEventMetadata(event),
@@ -25625,7 +26416,6 @@ var FlueObserveBridge = class {
       });
       safeEnd(state.span, eventTime(event.timestamp));
       this.runsById.delete(event.runId);
-      restoreCurrentFlueSpan(state.activeContext);
     }
     void flush().catch((error) => {
       logInstrumentationError3("Flue flush", error);
@@ -25663,7 +26453,7 @@ var FlueObserveBridge = class {
     };
     this.finishPendingChildrenForOperation(event, output);
     safeLog3(state.span, {
-      ...event.isError ? { error: errorToString(event.error) } : {},
+      ...event.isError ? { error: toLoggedError(event.error) } : {},
       metadata,
       metrics: durationMetrics2(event.durationMs),
       output
@@ -25676,31 +26466,33 @@ var FlueObserveBridge = class {
     if (!key) {
       return;
     }
+    const input = flueTurnRequestInput(event);
+    const model = flueTurnRequestModel(event);
+    const provider = flueTurnRequestProvider(event);
+    const api = flueTurnRequestApi(event);
+    const reasoning = flueTurnRequestReasoning(event);
     const metadata = {
       ...extractEventMetadata(event),
-      ...event.api ? { "flue.api": event.api } : {},
-      ...event.model ? { model: event.model, "flue.model": event.model } : {},
-      ...event.provider ? { provider: event.provider } : { provider: "flue" },
-      ...event.provider ? { "flue.provider": event.provider } : {},
+      ...api ? { "flue.api": api } : {},
+      ...model ? { model, "flue.model": model } : {},
+      ...provider ? { provider } : { provider: "flue" },
+      ...provider ? { "flue.provider": provider } : {},
       ...event.purpose ? { "flue.turn_purpose": event.purpose } : {},
-      ...event.reasoning ? { reasoning: event.reasoning } : {},
-      ...event.input?.systemPrompt ? { "flue.system_prompt": event.input.systemPrompt } : {},
-      ...event.input?.tools ? { tools: event.input.tools } : {}
+      ...reasoning ? { reasoning } : {},
+      ...input?.systemPrompt ? { "flue.system_prompt": input.systemPrompt } : {},
+      ...input?.tools ? { tools: input.tools } : {}
     };
     const parent = this.parentSpanForTurn(event);
     const span = startFlueSpan(parent, {
-      name: `llm:${event.model ?? event.purpose ?? "unknown"}`,
+      name: `llm:${model ?? event.purpose ?? "unknown"}`,
       spanAttributes: { type: "llm" /* LLM */ },
       startTime: eventTime(event.timestamp),
       event: {
-        input: event.input?.messages,
+        input: input?.messages,
         metadata
       }
     });
-    this.logOperationInput(
-      event.operationId,
-      event.input?.messages ?? event.input
-    );
+    this.logOperationInput(event.operationId, input?.messages ?? input);
     this.turnsByKey.set(key, { metadata, span });
   }
   handleTurn(event) {
@@ -25709,25 +26501,32 @@ var FlueObserveBridge = class {
       return;
     }
     const state = this.turnsByKey.get(key) ?? this.startSyntheticTurn(event);
+    const model = flueTurnModel(event);
+    const provider = flueTurnProvider(event);
+    const api = flueTurnApi(event);
+    const stopReason = flueTurnStopReason(event);
+    const usage = flueTurnUsage(event);
+    const output = flueTurnOutput(event);
+    const error = flueTurnError(event);
     const metadata = {
       ...state.metadata,
       ...extractEventMetadata(event),
-      ...event.api ? { "flue.api": event.api } : {},
-      ...event.model ? { model: event.model, "flue.model": event.model } : {},
-      ...event.provider ? { provider: event.provider } : {},
-      ...event.provider ? { "flue.provider": event.provider } : {},
+      ...api ? { "flue.api": api } : {},
+      ...model ? { model, "flue.model": model } : {},
+      ...provider ? { provider } : {},
+      ...provider ? { "flue.provider": provider } : {},
       ...event.purpose ? { "flue.turn_purpose": event.purpose } : {},
-      ...event.stopReason ? { "flue.stop_reason": event.stopReason } : {},
+      ...stopReason ? { "flue.stop_reason": stopReason } : {},
       ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
     };
     safeLog3(state.span, {
-      ...event.isError ? { error: errorToString(event.error) } : {},
+      ...event.isError ? { error: toLoggedError(error) } : {},
       metadata,
       metrics: {
         ...durationMetrics2(event.durationMs),
-        ...metricsFromUsage(event.usage)
+        ...metricsFromUsage(usage)
       },
-      output: event.output
+      output
     });
     safeEnd(state.span, eventTime(event.timestamp));
     this.turnsByKey.delete(key);
@@ -25736,6 +26535,7 @@ var FlueObserveBridge = class {
     if (!event.toolCallId) {
       return;
     }
+    const input = flueToolInput(event);
     const metadata = {
       ...extractEventMetadata(event),
       ...event.toolName ? { "flue.tool_name": event.toolName } : {},
@@ -25748,12 +26548,11 @@ var FlueObserveBridge = class {
       spanAttributes: { type: "tool" /* TOOL */ },
       startTime: eventTime(event.timestamp),
       event: {
-        input: event.args,
+        input,
         metadata
       }
     });
-    const activeContext = enterCurrentFlueSpan(span);
-    this.toolsByKey.set(toolKey(event), { activeContext, metadata, span });
+    this.toolsByKey.set(toolKey(event), { metadata, span });
   }
   handleToolCall(event) {
     if (!event.toolCallId) {
@@ -25761,6 +26560,8 @@ var FlueObserveBridge = class {
     }
     const key = toolKey(event);
     const state = this.toolsByKey.get(key) ?? this.startSyntheticTool(event);
+    const output = flueToolOutput(event);
+    const error = flueToolError(event);
     const metadata = {
       ...state.metadata,
       ...extractEventMetadata(event),
@@ -25769,14 +26570,13 @@ var FlueObserveBridge = class {
       ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
     };
     safeLog3(state.span, {
-      ...event.isError ? { error: errorToString(event.result) } : {},
+      ...event.isError ? { error: toLoggedError(error) } : {},
       metadata,
       metrics: durationMetrics2(event.durationMs),
-      output: event.result
+      output
     });
     safeEnd(state.span, eventTime(event.timestamp));
     this.toolsByKey.delete(key);
-    restoreCurrentFlueSpan(state.activeContext);
   }
   handleTaskStart(event) {
     if (!event.taskId) {
@@ -25807,7 +26607,7 @@ var FlueObserveBridge = class {
       return;
     }
     safeLog3(state.span, {
-      ...event.isError ? { error: errorToString(event.result) } : {},
+      ...event.isError ? { error: toLoggedError(event.result) } : {},
       metadata: {
         ...state.metadata,
         ...extractEventMetadata(event),
@@ -25945,16 +26745,19 @@ var FlueObserveBridge = class {
     return { metadata, span };
   }
   startSyntheticTurn(event) {
+    const model = flueTurnModel(event);
+    const provider = flueTurnProvider(event);
+    const api = flueTurnApi(event);
     const metadata = {
       ...extractEventMetadata(event),
-      ...event.api ? { "flue.api": event.api } : {},
-      ...event.model ? { model: event.model, "flue.model": event.model } : {},
-      ...event.provider ? { provider: event.provider } : { provider: "flue" },
-      ...event.provider ? { "flue.provider": event.provider } : {},
+      ...api ? { "flue.api": api } : {},
+      ...model ? { model, "flue.model": model } : {},
+      ...provider ? { provider } : { provider: "flue" },
+      ...provider ? { "flue.provider": provider } : {},
       ...event.purpose ? { "flue.turn_purpose": event.purpose } : {}
     };
     const span = startFlueSpan(this.parentSpanForEvent(event), {
-      name: `llm:${event.model ?? event.purpose ?? "unknown"}`,
+      name: `llm:${model ?? event.purpose ?? "unknown"}`,
       spanAttributes: { type: "llm" /* LLM */ },
       startTime: eventTime(event.timestamp),
       event: { metadata }
@@ -26108,6 +26911,60 @@ function extractPayloadMetadata(payload) {
   }
   return Object.fromEntries(Object.entries(metadata));
 }
+function flueRunInput(event) {
+  return event.input !== void 0 ? event.input : event.payload;
+}
+function flueTurnRequestInput(event) {
+  return event.request?.input ?? event.input;
+}
+function flueTurnRequestModel(event) {
+  return event.request?.model ?? event.model;
+}
+function flueTurnRequestProvider(event) {
+  return event.request?.providerName ?? event.provider ?? event.request?.providerId;
+}
+function flueTurnRequestApi(event) {
+  return event.request?.api ?? event.api;
+}
+function flueTurnRequestReasoning(event) {
+  return event.request?.reasoning ?? event.reasoning;
+}
+function flueTurnModel(event) {
+  return event.request?.model ?? event.model;
+}
+function flueTurnProvider(event) {
+  return event.request?.providerName ?? event.provider ?? event.request?.providerId;
+}
+function flueTurnApi(event) {
+  return event.request?.api ?? event.api;
+}
+function flueTurnUsage(event) {
+  return event.response?.usage ?? event.usage;
+}
+function flueTurnOutput(event) {
+  return event.response?.output ?? event.output;
+}
+function flueTurnStopReason(event) {
+  return event.response?.stopReason ?? event.stopReason;
+}
+function flueTurnError(event) {
+  return event.response?.error ?? event.response?.errorInfo?.message ?? event.error;
+}
+function flueToolInput(event) {
+  if (event.args !== void 0) {
+    return event.args;
+  }
+  if (event.arguments !== void 0) {
+    return event.arguments;
+  }
+  return event.input;
+}
+function flueToolOutput(event) {
+  return event.output !== void 0 ? event.output : event.result;
+}
+function flueToolError(event) {
+  return event.error ?? event.errorInfo?.message ?? flueToolOutput(event);
+}
 function operationOutput(event) {
   if (event.operationKind === "prompt" || event.operationKind === "skill") {
     return llmResultFromOperationResult(event.result);
@@ -26181,33 +27038,14 @@ function stateMatchesRun(state, runId) {
 function startFlueSpan(parent, args) {
   return parent ? withCurrent(parent, () => startSpan(args)) : startSpan(args);
 }
-function enterCurrentFlueSpan(span) {
-  const contextManager = _internalGetGlobalState()?.contextManager;
-  const store = contextManager ? Reflect.get(contextManager, BRAINTRUST_CURRENT_SPAN_STORE) : void 0;
-  if (!contextManager || !isCurrentSpanStore(store)) {
-    return void 0;
-  }
-  const previous = store.getStore();
-  try {
-    store.enterWith(contextManager.wrapSpanForStore(span));
-    return { previous, store };
-  } catch (error) {
-    logInstrumentationError3("Flue context propagation", error);
-    return void 0;
-  }
-}
-function isCurrentSpanStore(value) {
-  return isObjectLike(value) && typeof Reflect.get(value, "enterWith") === "function" && typeof Reflect.get(value, "getStore") === "function";
-}
-function restoreCurrentFlueSpan(activeContext) {
-  if (!activeContext) {
-    return;
-  }
-  try {
-    activeContext.store.enterWith(activeContext.previous);
-  } catch (error) {
-    logInstrumentationError3("Flue context restoration", error);
+function runWithCurrentSpanStore(span, next) {
+  const state = _internalGetGlobalState();
+  const contextManager = state?.contextManager;
+  const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (contextManager && typeof currentSpanStore?.run === "function") {
+    return currentSpanStore.run(contextManager.wrapSpanForStore(span), next);
   }
+  return withCurrent(span, () => next());
 }
 function safeLog3(span, event) {
   try {
@@ -26223,19 +27061,6 @@ function safeEnd(span, endTime) {
     logInstrumentationError3("Flue span end", error);
   }
 }
-function errorToString(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return String(error);
-  }
-}
 function logInstrumentationError3(label, error) {
   console.error(`Error in ${label} instrumentation:`, error);
 }
@@ -27065,11 +27890,11 @@ function patchAssistantMessageStream(stream, promptState, llmState) {
 function recordPiAssistantMessageEvent(promptState, llmState, event) {
   recordFirstTokenMetric(llmState, event);
   const message = "message" in event ? event.message : void 0;
-  const errorMessage2 = "error" in event ? event.error : void 0;
+  const errorMessage = "error" in event ? event.error : void 0;
   if (event.type === "done" && isPiAssistantMessage(message)) {
     finishPiLlmSpan(promptState, llmState, message);
-  } else if (event.type === "error" && isPiAssistantMessage(errorMessage2)) {
-    finishPiLlmSpan(promptState, llmState, errorMessage2);
+  } else if (event.type === "error" && isPiAssistantMessage(errorMessage)) {
+    finishPiLlmSpan(promptState, llmState, errorMessage);
   }
 }
 function recordFirstTokenMetric(state, event) {
@@ -27163,7 +27988,7 @@ function finishPiToolSpan(state, event) {
   };
   try {
     safeLog4(toolState.span, {
-      ...event.isError ? { error: stringifyUnknown2(event.result) } : {},
+      ...event.isError ? { error: toLoggedError(event.result) } : {},
       metadata,
       output: event.result
     });
@@ -27195,7 +28020,7 @@ async function finalizePiPromptRun(state, error) {
   };
   try {
     safeLog4(state.span, {
-      ...error ? { error: stringifyUnknown2(error) } : {},
+      ...error ? { error: toLoggedError(error) } : {},
       metadata,
       metrics: {
         ...cleanMetrics5(state.metrics),
@@ -27255,7 +28080,7 @@ function finishPiLlmSpan(promptState, llmState, message, error) {
   }
   try {
     safeLog4(llmState.span, {
-      ...error || messageError ? { error: stringifyUnknown2(error ?? messageError) } : {},
+      ...error || messageError ? { error: toLoggedError(error ?? messageError) } : {},
       metadata: {
         ...llmState.metadata,
         ...message ? extractAssistantMetadata(message) : {}
@@ -27271,7 +28096,7 @@ function finishOpenToolSpans(state, error) {
   for (const [, toolState] of state.activeToolSpans) {
     try {
       safeLog4(toolState.span, {
-        error: error ? stringifyUnknown2(error) : "Pi tool did not complete"
+        error: error ? toLoggedError(error) : "Pi tool did not complete"
       });
       toolState.span.end();
     } finally {
@@ -27543,10 +28368,10 @@ function stringifyArguments(value) {
   try {
     return JSON.stringify(value);
   } catch {
-    return stringifyUnknown2(value);
+    return stringifyUnknown(value);
   }
 }
-function stringifyUnknown2(value) {
+function stringifyUnknown(value) {
   if (value instanceof Error) {
     return value.message;
   }
@@ -27570,10 +28395,790 @@ function logInstrumentationError4(context, error) {
   debugLogger.debug(`${context}:`, error);
 }
 
-// src/instrumentation/braintrust-plugin.ts
-function getIntegrationConfig(integrations, key) {
-  return integrations[key];
+// src/instrumentation/plugins/strands-agent-sdk-channels.ts
+var strandsAgentSDKChannels = defineChannels("@strands-agents/sdk", {
+  agentStream: channel({
+    channelName: "Agent.stream",
+    kind: "sync-stream"
+  }),
+  graphStream: channel({
+    channelName: "Graph.stream",
+    kind: "sync-stream"
+  }),
+  swarmStream: channel({
+    channelName: "Swarm.stream",
+    kind: "sync-stream"
+  })
+});
+
+// src/instrumentation/plugins/strands-agent-sdk-plugin.ts
+var StrandsAgentSDKPlugin = class extends BasePlugin {
+  activeChildParents = /* @__PURE__ */ new WeakMap();
+  onEnable() {
+    this.subscribeToAgentStream();
+    this.subscribeToMultiAgentStream(
+      strandsAgentSDKChannels.graphStream,
+      "Graph.stream"
+    );
+    this.subscribeToMultiAgentStream(
+      strandsAgentSDKChannels.swarmStream,
+      "Swarm.stream"
+    );
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+  subscribeToAgentStream() {
+    const channel2 = strandsAgentSDKChannels.agentStream.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(channel2);
+    const handlers = {
+      start: (event) => {
+        const state = startAgentStream(event, this.activeChildParents);
+        if (state) {
+          states.set(event, state);
+        }
+      },
+      end: (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        const result = event.result;
+        if (isAsyncIterable(result)) {
+          patchStreamIfNeeded(result, {
+            aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
+            onChunk: (chunk) => handleAgentStreamEvent(state, chunk),
+            onComplete: () => {
+              finalizeAgentStream(state);
+              states.delete(event);
+            },
+            onError: (error) => {
+              finalizeAgentStream(state, error);
+              states.delete(event);
+            }
+          });
+          return;
+        }
+        finalizeAgentStream(state, void 0, result);
+        states.delete(event);
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        finalizeAgentStream(state, event.error);
+        states.delete(event);
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindAutoInstrumentationSuppression?.();
+      channel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToMultiAgentStream(channel2, operation) {
+    const tracingChannel2 = channel2.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(tracingChannel2);
+    const handlers = {
+      start: (event) => {
+        const state = startMultiAgentStream(
+          event,
+          operation,
+          this.activeChildParents
+        );
+        if (state) {
+          states.set(event, state);
+        }
+      },
+      end: (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        const result = event.result;
+        if (isAsyncIterable(result)) {
+          patchStreamIfNeeded(result, {
+            aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
+            onChunk: (chunk) => handleMultiAgentStreamEvent(
+              state,
+              chunk,
+              this.activeChildParents
+            ),
+            onComplete: () => {
+              finalizeMultiAgentStream(state, this.activeChildParents);
+              states.delete(event);
+            },
+            onError: (error) => {
+              finalizeMultiAgentStream(state, this.activeChildParents, error);
+              states.delete(event);
+            }
+          });
+          return;
+        }
+        finalizeMultiAgentStream(
+          state,
+          this.activeChildParents,
+          void 0,
+          result
+        );
+        states.delete(event);
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        finalizeMultiAgentStream(state, this.activeChildParents, event.error);
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindAutoInstrumentationSuppression?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+};
+function startAgentStream(event, activeChildParents) {
+  const agent = extractAgent(event);
+  const model = agent?.model;
+  const metadata = {
+    ...extractAgentMetadata2(agent),
+    ...extractModelMetadata3(model),
+    "strands.operation": "Agent.stream",
+    provider: extractProvider(model),
+    ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
+  };
+  const parentSpan = agent ? getOnlyChildParent(activeChildParents, agent) : void 0;
+  const span = parentSpan ? withCurrent(
+    parentSpan,
+    () => startSpan({
+      event: {
+        input: event.arguments[0],
+        metadata
+      },
+      name: formatAgentSpanName(agent),
+      spanAttributes: { type: "task" /* TASK */ }
+    })
+  ) : startSpan({
+    event: {
+      input: event.arguments[0],
+      metadata
+    },
+    name: formatAgentSpanName(agent),
+    spanAttributes: { type: "task" /* TASK */ }
+  });
+  return {
+    activeTools: /* @__PURE__ */ new Map(),
+    finalized: false,
+    metadata,
+    span,
+    startTime: getCurrentUnixTimestamp()
+  };
+}
+function startMultiAgentStream(event, operation, activeChildParents) {
+  const orchestrator = extractOrchestrator(event);
+  const metadata = {
+    "strands.operation": operation,
+    provider: "strands",
+    ...orchestrator?.id ? { "strands.orchestrator.id": orchestrator.id } : {},
+    ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
+  };
+  const parentSpan = orchestrator ? getOnlyChildParent(activeChildParents, orchestrator) : void 0;
+  const span = parentSpan ? withCurrent(
+    parentSpan,
+    () => startSpan({
+      event: {
+        input: event.arguments[0],
+        metadata
+      },
+      name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
+      spanAttributes: { type: "task" /* TASK */ }
+    })
+  ) : startSpan({
+    event: {
+      input: event.arguments[0],
+      metadata
+    },
+    name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
+    spanAttributes: { type: "task" /* TASK */ }
+  });
+  return {
+    activeNodes: /* @__PURE__ */ new Map(),
+    finalized: false,
+    handoffs: [],
+    metadata,
+    operation,
+    orchestrator,
+    span,
+    startTime: getCurrentUnixTimestamp()
+  };
+}
+function handleAgentStreamEvent(state, event) {
+  try {
+    switch (event.type) {
+      case "beforeModelCallEvent":
+        startModelSpan(state, event);
+        break;
+      case "modelStreamUpdateEvent":
+        collectModelStreamMetadata(state, event);
+        break;
+      case "afterModelCallEvent":
+        finalizeModelSpan(state, event);
+        break;
+      case "beforeToolCallEvent":
+        startToolSpan2(state, event);
+        break;
+      case "afterToolCallEvent":
+        finalizeToolSpan(state, event);
+        break;
+      case "toolResultEvent":
+        finalizeToolSpanFromResult(state, event.result);
+        break;
+      case "agentResultEvent":
+        safeLog5(state.span, {
+          metadata: {
+            ...state.metadata,
+            ...extractAgentResultMetadata(event.result)
+          },
+          metrics: {
+            ...buildDurationMetrics4(state.startTime),
+            ...parseUsage(event.result?.metrics?.accumulatedUsage)
+          },
+          output: extractAgentResultOutput(event.result)
+        });
+        break;
+      default:
+        break;
+    }
+  } catch (error) {
+    logInstrumentationError5("Strands Agent SDK event", error);
+  }
+}
+function handleMultiAgentStreamEvent(state, event, activeChildParents) {
+  try {
+    switch (event.type) {
+      case "beforeNodeCallEvent":
+        startNodeSpan(state, event, activeChildParents);
+        break;
+      case "nodeResultEvent":
+        logNodeResult(state, event);
+        break;
+      case "afterNodeCallEvent":
+        finalizeNodeSpan(state, event, activeChildParents);
+        break;
+      case "multiAgentHandoffEvent":
+        collectHandoff(state, event);
+        break;
+      case "multiAgentResultEvent":
+        safeLog5(state.span, {
+          metadata: {
+            ...state.metadata,
+            ...state.handoffs.length > 0 ? { "strands.handoffs": state.handoffs } : {},
+            ...extractMultiAgentResultMetadata(event.result)
+          },
+          metrics: {
+            ...buildDurationMetrics4(state.startTime),
+            ...parseUsage(event.result?.usage)
+          },
+          output: extractMultiAgentResultOutput(event.result)
+        });
+        break;
+      default:
+        break;
+    }
+  } catch (error) {
+    logInstrumentationError5("Strands Agent SDK multi-agent event", error);
+  }
+}
+function startModelSpan(state, event) {
+  if (state.activeModel) {
+    finalizeModelSpan(state);
+  }
+  const model = event.model ?? event.agent?.model;
+  const metadata = {
+    ...extractModelMetadata3(model),
+    "strands.operation": "model.stream",
+    ...typeof event.projectedInputTokens === "number" ? { "strands.projected_input_tokens": event.projectedInputTokens } : {},
+    provider: extractProvider(model)
+  };
+  const span = withCurrent(
+    state.span,
+    () => startSpan({
+      event: {
+        input: Array.isArray(event.agent?.messages) ? event.agent.messages : void 0,
+        metadata
+      },
+      name: formatModelSpanName(model),
+      spanAttributes: { type: "llm" /* LLM */ }
+    })
+  );
+  state.activeModel = {
+    metadata,
+    metrics: typeof event.projectedInputTokens === "number" ? { prompt_tokens: event.projectedInputTokens } : {},
+    span,
+    startTime: getCurrentUnixTimestamp()
+  };
+}
+function collectModelStreamMetadata(state, event) {
+  if (!state.activeModel || event.event?.type !== "modelMetadataEvent") {
+    return;
+  }
+  Object.assign(state.activeModel.metrics, parseUsage(event.event.usage));
+  Object.assign(
+    state.activeModel.metrics,
+    parseModelMetrics(event.event.metrics)
+  );
+}
+function finalizeModelSpan(state, event) {
+  const modelState = state.activeModel;
+  if (!modelState) {
+    return;
+  }
+  state.activeModel = void 0;
+  const metadata = {
+    ...modelState.metadata,
+    ...event?.attemptCount ? { "strands.model.attempt": event.attemptCount } : {},
+    ...event?.stopData?.stopReason ? { "strands.stop_reason": event.stopData.stopReason } : {}
+  };
+  const metrics = {
+    ...buildDurationMetrics4(modelState.startTime),
+    ...modelState.metrics
+  };
+  safeLog5(modelState.span, {
+    ...event?.error ? { error: toLoggedError(event.error) } : {},
+    metadata,
+    metrics: cleanMetrics6(metrics),
+    output: event?.stopData?.message
+  });
+  modelState.span.end();
+}
+function startToolSpan2(state, event) {
+  const toolUse = event.toolUse;
+  const key = toolKey2(toolUse);
+  if (state.activeTools.has(key)) {
+    finalizeToolSpanState(state.activeTools.get(key));
+    state.activeTools.delete(key);
+  }
+  const name = extractToolName3(toolUse, event.tool);
+  const span = withCurrent(
+    state.span,
+    () => startSpan({
+      event: {
+        input: toolUse?.input,
+        metadata: {
+          "gen_ai.tool.call.id": toolUse?.toolUseId,
+          "gen_ai.tool.name": name,
+          "strands.operation": "tool.call",
+          "strands.tool.name": name,
+          provider: "strands"
+        }
+      },
+      name: `tool: ${name}`,
+      spanAttributes: { type: "tool" /* TOOL */ }
+    })
+  );
+  state.activeTools.set(key, {
+    span,
+    startTime: getCurrentUnixTimestamp(),
+    toolUse
+  });
+}
+function finalizeToolSpan(state, event) {
+  const key = toolKey2(event.toolUse);
+  const toolState = state.activeTools.get(key);
+  if (!toolState) {
+    return;
+  }
+  state.activeTools.delete(key);
+  finalizeToolSpanState(toolState, {
+    error: event.error,
+    result: event.result,
+    toolUse: event.toolUse
+  });
+}
+function finalizeToolSpanFromResult(state, result) {
+  if (!isObject(result)) {
+    return;
+  }
+  const toolUseId = result.toolUseId;
+  if (typeof toolUseId !== "string") {
+    return;
+  }
+  const toolState = state.activeTools.get(toolUseId);
+  if (!toolState) {
+    return;
+  }
+  state.activeTools.delete(toolUseId);
+  finalizeToolSpanState(toolState, { result });
+}
+function finalizeToolSpanState(toolState, data = {}) {
+  if (!toolState) {
+    return;
+  }
+  const result = data.result;
+  safeLog5(toolState.span, {
+    ...data.error ? { error: toLoggedError(data.error) } : {},
+    metadata: {
+      ...data.toolUse?.toolUseId ?? toolState.toolUse?.toolUseId ? {
+        "gen_ai.tool.call.id": data.toolUse?.toolUseId ?? toolState.toolUse?.toolUseId
+      } : {},
+      ...extractToolName3(data.toolUse ?? toolState.toolUse) ? {
+        "gen_ai.tool.name": extractToolName3(
+          data.toolUse ?? toolState.toolUse
+        )
+      } : {},
+      ...isObject(result) && typeof result.status === "string" ? { "strands.tool.status": result.status } : {}
+    },
+    metrics: buildDurationMetrics4(toolState.startTime),
+    output: result
+  });
+  toolState.span.end();
+}
+function startNodeSpan(state, event, activeChildParents) {
+  const nodeId = event.nodeId ?? "unknown";
+  const node = findNode(event.orchestrator ?? state.orchestrator, nodeId);
+  const child = extractNodeChild(node);
+  const metadata = {
+    "strands.node.id": nodeId,
+    ...node?.type ? { "strands.node.type": node.type } : {},
+    "strands.operation": "node.call",
+    provider: "strands"
+  };
+  const span = withCurrent(
+    state.span,
+    () => startSpan({
+      event: { metadata },
+      name: `node: ${nodeId}`,
+      spanAttributes: { type: "task" /* TASK */ }
+    })
+  );
+  const nodeState = {
+    ...child ? { child } : {},
+    span,
+    startTime: getCurrentUnixTimestamp()
+  };
+  state.activeNodes.set(nodeId, nodeState);
+  if (child) {
+    pushChildParent(activeChildParents, child, span);
+  }
+}
+function logNodeResult(state, event) {
+  const nodeId = event.nodeId ?? event.result?.nodeId ?? "unknown";
+  const nodeState = state.activeNodes.get(nodeId);
+  if (!nodeState) {
+    return;
+  }
+  safeLog5(nodeState.span, {
+    ...event.result?.error ? { error: toLoggedError(event.result.error) } : {},
+    metadata: {
+      ...event.nodeType ? { "strands.node.type": event.nodeType } : {},
+      ...event.result?.status ? { "strands.node.status": event.result.status } : {}
+    },
+    metrics: {
+      ...buildDurationMetrics4(nodeState.startTime),
+      ...typeof event.result?.duration === "number" ? { "strands.node.duration_ms": event.result.duration } : {},
+      ...parseUsage(event.result?.usage)
+    },
+    output: extractNodeResultOutput(event.result)
+  });
+}
+function finalizeNodeSpan(state, event, activeChildParents) {
+  const nodeId = event.nodeId ?? "unknown";
+  const nodeState = state.activeNodes.get(nodeId);
+  if (!nodeState) {
+    return;
+  }
+  state.activeNodes.delete(nodeId);
+  if (event.error) {
+    safeLog5(nodeState.span, { error: toLoggedError(event.error) });
+  }
+  nodeState.span.end();
+  if (nodeState.child) {
+    popChildParent(activeChildParents, nodeState.child, nodeState.span);
+  }
+}
+function collectHandoff(state, event) {
+  state.handoffs.push({
+    ...event.source ? { source: event.source } : {},
+    ...Array.isArray(event.targets) ? { targets: event.targets } : {}
+  });
+}
+function finalizeAgentStream(state, error, output) {
+  if (state.finalized) {
+    return;
+  }
+  state.finalized = true;
+  finalizeModelSpan(state);
+  for (const toolState of state.activeTools.values()) {
+    finalizeToolSpanState(toolState);
+  }
+  state.activeTools.clear();
+  safeLog5(state.span, {
+    ...error ? { error: toLoggedError(error) } : {},
+    metrics: buildDurationMetrics4(state.startTime),
+    ...output !== void 0 ? { output } : {}
+  });
+  state.span.end();
+}
+function finalizeMultiAgentStream(state, activeChildParents, error, output) {
+  if (state.finalized) {
+    return;
+  }
+  state.finalized = true;
+  for (const nodeState of state.activeNodes.values()) {
+    if (nodeState.child) {
+      popChildParent(activeChildParents, nodeState.child, nodeState.span);
+    }
+    nodeState.span.end();
+  }
+  state.activeNodes.clear();
+  safeLog5(state.span, {
+    ...error ? { error: toLoggedError(error) } : {},
+    metrics: buildDurationMetrics4(state.startTime),
+    ...output !== void 0 ? { output } : {}
+  });
+  state.span.end();
+}
+function extractAgent(event) {
+  const candidate = event.agent ?? event.self;
+  return isObject(candidate) && typeof candidate.stream === "function" ? candidate : void 0;
+}
+function extractOrchestrator(event) {
+  const candidate = event.orchestrator ?? event.self;
+  return isObject(candidate) && typeof candidate.stream === "function" ? candidate : void 0;
+}
+function extractAgentMetadata2(agent) {
+  return {
+    ...agent?.id ? { "strands.agent.id": agent.id } : {},
+    ...agent?.name ? { "strands.agent.name": agent.name } : {},
+    ...agent?.description ? { "strands.agent.description": agent.description } : {}
+  };
+}
+function extractModelMetadata3(model) {
+  const config = getModelConfig(model);
+  const modelName2 = extractModelName2(model);
+  return {
+    ...modelName2 ? { model: modelName2 } : {},
+    ...config?.api ? { "strands.model.api": config.api } : {},
+    ...model?.stateful !== void 0 ? { "strands.model.stateful": model.stateful } : {}
+  };
+}
+function extractAgentResultMetadata(result) {
+  return {
+    ...result?.stopReason ? { "strands.stop_reason": result.stopReason } : {},
+    ...typeof result?.metrics?.latestContextSize === "number" ? { "strands.context_size": result.metrics.latestContextSize } : {},
+    ...typeof result?.metrics?.projectedContextSize === "number" ? {
+      "strands.projected_context_size": result.metrics.projectedContextSize
+    } : {}
+  };
+}
+function extractMultiAgentResultMetadata(result) {
+  return {
+    ...result?.status ? { "strands.status": result.status } : {},
+    ...typeof result?.duration === "number" ? { "strands.duration_ms": result.duration } : {}
+  };
+}
+function extractProvider(model) {
+  const config = getModelConfig(model);
+  if (typeof config?.provider === "string") {
+    return config.provider;
+  }
+  const constructorName = getConstructorName(model).toLowerCase();
+  if (constructorName.includes("openai")) {
+    return "openai";
+  }
+  if (constructorName.includes("anthropic")) {
+    return "anthropic";
+  }
+  if (constructorName.includes("bedrock")) {
+    return "bedrock";
+  }
+  if (constructorName.includes("google")) {
+    return "google";
+  }
+  if (constructorName.includes("vercel")) {
+    return "vercel";
+  }
+  return "strands";
+}
+function extractModelName2(model) {
+  const config = getModelConfig(model);
+  if (typeof model?.modelId === "string") {
+    return model.modelId;
+  }
+  if (typeof config?.modelId === "string") {
+    return config.modelId;
+  }
+  if (typeof config?.model === "string") {
+    return config.model;
+  }
+  return void 0;
+}
+function getModelConfig(model) {
+  if (!model || typeof model.getConfig !== "function") {
+    return void 0;
+  }
+  try {
+    return model.getConfig();
+  } catch (error) {
+    logInstrumentationError5("Strands Agent SDK model config", error);
+    return void 0;
+  }
+}
+function formatAgentSpanName(agent) {
+  return agent?.name ? `Agent: ${agent.name}` : "Strands Agent";
+}
+function formatModelSpanName(model) {
+  const modelName2 = extractModelName2(model);
+  return modelName2 ? `Strands model: ${modelName2}` : "Strands model";
+}
+function extractAgentResultOutput(result) {
+  if (!result) {
+    return void 0;
+  }
+  if (result.structuredOutput !== void 0) {
+    return result.structuredOutput;
+  }
+  if (result.lastMessage) {
+    return result.lastMessage;
+  }
+  return result;
+}
+function extractMultiAgentResultOutput(result) {
+  if (!result) {
+    return void 0;
+  }
+  if (Array.isArray(result.content)) {
+    return normalizeContentBlocks(result.content);
+  }
+  return result;
+}
+function extractNodeResultOutput(result) {
+  if (!result) {
+    return void 0;
+  }
+  if (result.structuredOutput !== void 0) {
+    return result.structuredOutput;
+  }
+  if (Array.isArray(result.content)) {
+    return normalizeContentBlocks(result.content);
+  }
+  return result;
+}
+function normalizeContentBlocks(blocks) {
+  const text = blocks.map((block) => typeof block.text === "string" ? block.text : void 0).filter((part) => Boolean(part)).join("");
+  return text.length > 0 ? text : blocks;
+}
+function parseUsage(usage) {
+  const metrics = {};
+  assignMetric(metrics, "prompt_tokens", usage?.inputTokens);
+  assignMetric(metrics, "completion_tokens", usage?.outputTokens);
+  assignMetric(metrics, "tokens", usage?.totalTokens);
+  assignMetric(metrics, "prompt_cached_tokens", usage?.cacheReadInputTokens);
+  assignMetric(
+    metrics,
+    "prompt_cache_creation_tokens",
+    usage?.cacheWriteInputTokens
+  );
+  return metrics;
+}
+function parseModelMetrics(metrics) {
+  const parsed = {};
+  assignMetric(parsed, "strands.latency_ms", metrics?.latencyMs);
+  assignMetric(
+    parsed,
+    "strands.time_to_first_byte_ms",
+    metrics?.timeToFirstByteMs
+  );
+  return parsed;
+}
+function assignMetric(metrics, key, value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    metrics[key] = value;
+  }
+}
+function buildDurationMetrics4(startTime) {
+  const end = getCurrentUnixTimestamp();
+  return {
+    duration: end - startTime,
+    end,
+    start: startTime
+  };
+}
+function cleanMetrics6(metrics) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(metrics)) {
+    if (Number.isFinite(value)) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function extractToolName3(toolUse, tool) {
+  return toolUse?.name ?? tool?.name ?? "unknown";
+}
+function toolKey2(toolUse) {
+  return toolUse?.toolUseId ?? toolUse?.name ?? "unknown";
+}
+function findNode(orchestrator, nodeId) {
+  try {
+    return orchestrator?.nodes?.get(nodeId);
+  } catch {
+    return void 0;
+  }
+}
+function extractNodeChild(node) {
+  const child = node?.agent ?? node?.orchestrator;
+  return isObject(child) ? child : void 0;
+}
+function pushChildParent(activeChildParents, child, span) {
+  const parents = activeChildParents.get(child) ?? /* @__PURE__ */ new Set();
+  parents.add(span);
+  activeChildParents.set(child, parents);
+}
+function popChildParent(activeChildParents, child, span) {
+  const parents = activeChildParents.get(child);
+  if (!parents) {
+    return;
+  }
+  parents.delete(span);
+  if (parents.size === 0) {
+    activeChildParents.delete(child);
+  }
+}
+function getOnlyChildParent(activeChildParents, child) {
+  const parents = activeChildParents.get(child);
+  if (!parents || parents.size !== 1) {
+    return void 0;
+  }
+  return parents.values().next().value;
+}
+function getConstructorName(value) {
+  if (!isObject(value)) {
+    return "";
+  }
+  const constructor = value.constructor;
+  return typeof constructor === "function" && typeof constructor.name === "string" ? constructor.name : "";
+}
+function safeLog5(span, event) {
+  try {
+    span.log(event);
+  } catch (error) {
+    logInstrumentationError5("Strands Agent SDK span log", error);
+  }
 }
+function logInstrumentationError5(context, error) {
+  debugLogger.debug(`${context}:`, error);
+}
+
+// src/instrumentation/braintrust-plugin.ts
 var BraintrustPlugin = class extends BasePlugin {
   config;
   openaiPlugin = null;
@@ -27591,11 +29196,13 @@ var BraintrustPlugin = class extends BasePlugin {
   googleADKPlugin = null;
   coherePlugin = null;
   groqPlugin = null;
+  bedrockRuntimePlugin = null;
   genkitPlugin = null;
   gitHubCopilotPlugin = null;
   fluePlugin = null;
   langChainPlugin = null;
   piCodingAgentPlugin = null;
+  strandsAgentSDKPlugin = null;
   constructor(config = {}) {
     super();
     this.config = config;
@@ -27662,6 +29269,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.groqPlugin = new GroqPlugin();
       this.groqPlugin.enable();
     }
+    if (integrations.bedrock !== false && integrations.awsBedrock !== false && integrations.awsBedrockRuntime !== false) {
+      this.bedrockRuntimePlugin = new BedrockRuntimePlugin();
+      this.bedrockRuntimePlugin.enable();
+    }
     if (integrations.genkit !== false) {
       this.genkitPlugin = new GenkitPlugin();
       this.genkitPlugin.enable();
@@ -27674,7 +29285,11 @@ var BraintrustPlugin = class extends BasePlugin {
       this.piCodingAgentPlugin = new PiCodingAgentPlugin();
       this.piCodingAgentPlugin.enable();
     }
-    if (getIntegrationConfig(integrations, "flue") !== false) {
+    if (integrations.strandsAgentSDK !== false) {
+      this.strandsAgentSDKPlugin = new StrandsAgentSDKPlugin();
+      this.strandsAgentSDKPlugin.enable();
+    }
+    if (integrations.flue !== false) {
       this.fluePlugin = new FluePlugin();
       this.fluePlugin.enable();
     }
@@ -27744,6 +29359,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.groqPlugin.disable();
       this.groqPlugin = null;
     }
+    if (this.bedrockRuntimePlugin) {
+      this.bedrockRuntimePlugin.disable();
+      this.bedrockRuntimePlugin = null;
+    }
     if (this.genkitPlugin) {
       this.genkitPlugin.disable();
       this.genkitPlugin = null;
@@ -27756,6 +29375,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.piCodingAgentPlugin.disable();
       this.piCodingAgentPlugin = null;
     }
+    if (this.strandsAgentSDKPlugin) {
+      this.strandsAgentSDKPlugin.disable();
+      this.strandsAgentSDKPlugin = null;
+    }
     if (this.fluePlugin) {
       this.fluePlugin.disable();
       this.fluePlugin = null;
@@ -27780,6 +29403,10 @@ var envIntegrationAliases = {
   picodingagent: "piCodingAgent",
   picodingagentsdk: "piCodingAgent",
   "@earendil-works/pi-coding-agent": "piCodingAgent",
+  strandsAgentSDK: "strandsAgentSDK",
+  strandsagentsdk: "strandsAgentSDK",
+  "strands-agent-sdk": "strandsAgentSDK",
+  "@strands-agents/sdk": "strandsAgentSDK",
   anthropic: "anthropic",
   aisdk: "aisdk",
   "ai-sdk": "aisdk",
@@ -27810,6 +29437,12 @@ var envIntegrationAliases = {
   cohere: "cohere",
   groq: "groq",
   "groq-sdk": "groq",
+  bedrock: "bedrock",
+  "aws-bedrock": "awsBedrock",
+  awsbedrock: "awsBedrock",
+  "aws-bedrock-runtime": "awsBedrockRuntime",
+  awsbedrockruntime: "awsBedrockRuntime",
+  "@aws-sdk/client-bedrock-runtime": "awsBedrockRuntime",
   genkit: "genkit",
   "firebase-genkit": "genkit",
   githubcopilot: "gitHubCopilot",
@@ -27842,20 +29475,25 @@ function getDefaultInstrumentationIntegrations() {
     mistral: true,
     cohere: true,
     groq: true,
+    bedrock: true,
+    awsBedrock: true,
+    awsBedrockRuntime: true,
     genkit: true,
     gitHubCopilot: true,
     langchain: true,
     langgraph: true,
-    piCodingAgent: true
+    piCodingAgent: true,
+    strandsAgentSDK: true
   };
 }
 function readDisabledInstrumentationEnvConfig(disabledList) {
   const integrations = {};
   if (disabledList) {
     for (const value of disabledList.split(",")) {
-      const sdk = value.trim().toLowerCase();
+      const rawSdk = value.trim();
+      const sdk = rawSdk.toLowerCase();
       if (sdk.length > 0) {
-        integrations[envIntegrationAliases[sdk] ?? sdk] = false;
+        integrations[envIntegrationAliases[rawSdk] ?? envIntegrationAliases[sdk] ?? sdk] = false;
       }
     }
   }
@@ -28134,6 +29772,7 @@ __export(exports_exports, {
   wrapAISDKModel: () => wrapAISDKModel,
   wrapAgentClass: () => wrapAgentClass,
   wrapAnthropic: () => wrapAnthropic,
+  wrapBedrockRuntime: () => wrapBedrockRuntime,
   wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
@@ -28151,6 +29790,7 @@ __export(exports_exports, {
   wrapOpenRouter: () => wrapOpenRouter,
   wrapOpenRouterAgent: () => wrapOpenRouterAgent,
   wrapPiCodingAgentSDK: () => wrapPiCodingAgentSDK,
+  wrapStrandsAgentSDK: () => wrapStrandsAgentSDK,
   wrapTraced: () => wrapTraced,
   wrapVitest: () => wrapVitest
 });
@@ -30259,6 +31899,174 @@ function patchAgentSessionClass(AgentSession) {
   });
 }
 
+// src/wrappers/strands-agent-sdk.ts
+var WRAPPED_CLASS = /* @__PURE__ */ Symbol.for("braintrust.strands-agent-sdk.wrapped-class");
+var WRAPPED_INSTANCE = /* @__PURE__ */ Symbol.for(
+  "braintrust.strands-agent-sdk.wrapped-instance"
+);
+function wrapStrandsAgentSDK(sdk) {
+  if (!sdk || typeof sdk !== "object") {
+    return sdk;
+  }
+  const maybeSDK = sdk;
+  if (typeof maybeSDK.Agent !== "function" && typeof maybeSDK.Graph !== "function" && typeof maybeSDK.Swarm !== "function") {
+    console.warn("Unsupported Strands Agent SDK. Not wrapping.");
+    return sdk;
+  }
+  const target = isModuleNamespace4(sdk) ? Object.setPrototypeOf({}, sdk) : sdk;
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      const value = Reflect.get(target2, prop, receiver);
+      if (prop === "Agent" && typeof value === "function") {
+        return wrapAgentClass2(value);
+      }
+      if (prop === "Graph" && typeof value === "function") {
+        return wrapMultiAgentClass(
+          value,
+          "graph"
+        );
+      }
+      if (prop === "Swarm" && typeof value === "function") {
+        return wrapMultiAgentClass(
+          value,
+          "swarm"
+        );
+      }
+      return value;
+    }
+  });
+}
+function isModuleNamespace4(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  if (obj.constructor?.name === "Module") {
+    return true;
+  }
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    return false;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(obj, keys[0]);
+  return descriptor ? !descriptor.configurable && !descriptor.writable : false;
+}
+function wrapAgentClass2(AgentClass) {
+  if (AgentClass[WRAPPED_CLASS]) {
+    return AgentClass;
+  }
+  return new Proxy(AgentClass, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_CLASS) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    construct(target, args, newTarget) {
+      const instance = Reflect.construct(target, args, newTarget);
+      return wrapAgentInstance(instance);
+    }
+  });
+}
+function wrapMultiAgentClass(MultiAgentClass, kind) {
+  if (MultiAgentClass[WRAPPED_CLASS]) {
+    return MultiAgentClass;
+  }
+  return new Proxy(MultiAgentClass, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_CLASS) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    construct(target, args, newTarget) {
+      const instance = Reflect.construct(target, args, newTarget);
+      return wrapMultiAgentInstance(instance, kind);
+    }
+  });
+}
+function wrapAgentInstance(agent) {
+  if (!agent || typeof agent !== "object") {
+    return agent;
+  }
+  if (agent[WRAPPED_INSTANCE]) {
+    return agent;
+  }
+  const proxy = new Proxy(agent, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_INSTANCE) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "stream" && typeof value === "function") {
+        return function(args, options) {
+          const callArgs = [args, options];
+          return strandsAgentSDKChannels.agentStream.traceSync(
+            () => Reflect.apply(value, target, callArgs),
+            {
+              agent: proxy,
+              arguments: callArgs,
+              self: proxy
+            }
+          );
+        };
+      }
+      if (prop === "invoke" && typeof value === "function") {
+        return async function(args, options) {
+          return consumeAsyncGenerator(proxy.stream(args, options));
+        };
+      }
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  return proxy;
+}
+function wrapMultiAgentInstance(orchestrator, kind) {
+  if (!orchestrator || typeof orchestrator !== "object") {
+    return orchestrator;
+  }
+  if (orchestrator[WRAPPED_INSTANCE]) {
+    return orchestrator;
+  }
+  const proxy = new Proxy(orchestrator, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_INSTANCE) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "stream" && typeof value === "function") {
+        return function(input, options) {
+          const callArgs = [input, options];
+          const channel2 = kind === "graph" ? strandsAgentSDKChannels.graphStream : strandsAgentSDKChannels.swarmStream;
+          return channel2.traceSync(
+            () => Reflect.apply(value, target, callArgs),
+            {
+              arguments: callArgs,
+              orchestrator: proxy,
+              self: proxy
+            }
+          );
+        };
+      }
+      if (prop === "invoke" && typeof value === "function") {
+        return async function(input, options) {
+          return consumeAsyncGenerator(proxy.stream(input, options));
+        };
+      }
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  return proxy;
+}
+async function consumeAsyncGenerator(generator) {
+  let result = await generator.next();
+  while (!result.done) {
+    result = await generator.next();
+  }
+  return result.value;
+}
+
 // src/wrappers/google-genai.ts
 function wrapGoogleGenAI(googleGenAI) {
   if (!googleGenAI || typeof googleGenAI !== "object") {
@@ -30411,7 +32219,7 @@ function wrapGoogleADK(adkModule) {
         );
       }
       if ((prop === "LlmAgent" || prop === "Agent" || prop === "SequentialAgent" || prop === "ParallelAgent" || prop === "LoopAgent") && typeof value === "function") {
-        return wrapAgentClass2(value);
+        return wrapAgentClass3(value);
       }
       if (prop === "FunctionTool" && typeof value === "function") {
         return wrapToolClass(value);
@@ -30447,15 +32255,15 @@ function wrapRunnerRunAsync(runner) {
     });
   };
 }
-function wrapAgentClass2(AgentClass) {
+function wrapAgentClass3(AgentClass) {
   return new Proxy(AgentClass, {
     construct(target, args) {
       const instance = Reflect.construct(target, args);
-      return wrapAgentInstance(instance);
+      return wrapAgentInstance2(instance);
     }
   });
 }
-function wrapAgentInstance(agent) {
+function wrapAgentInstance2(agent) {
   return new Proxy(agent, {
     get(target, prop, receiver) {
       if (prop === "runAsync") {
@@ -31427,6 +33235,90 @@ function wrapEmbeddingsCreate2(create) {
   });
 }
 
+// src/wrappers/bedrock-runtime.ts
+function wrapBedrockRuntime(client) {
+  if (isSupportedBedrockRuntimeClient(client)) {
+    return bedrockRuntimeProxy(client);
+  }
+  console.warn("Unsupported Bedrock Runtime library. Not wrapping.");
+  return client;
+}
+var bedrockRuntimeProxyCache = /* @__PURE__ */ new WeakMap();
+var BEDROCK_RUNTIME_OPERATION_METHODS = /* @__PURE__ */ new Set([
+  "converse",
+  "converseStream",
+  "invokeModel",
+  "invokeModelWithBidirectionalStream",
+  "invokeModelWithResponseStream"
+]);
+function isRecord6(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSupportedBedrockRuntimeClient(value) {
+  return isRecord6(value) && typeof value.send === "function";
+}
+function bedrockRuntimeProxy(client) {
+  const cached = bedrockRuntimeProxyCache.get(client);
+  if (cached) {
+    return cached;
+  }
+  const privateMethodWorkaroundCache = /* @__PURE__ */ new WeakMap();
+  const operationMethodCache = /* @__PURE__ */ new WeakMap();
+  const proxy = new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "send") {
+        return wrapSend(target.send.bind(target));
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      if (typeof prop === "string" && BEDROCK_RUNTIME_OPERATION_METHODS.has(prop)) {
+        const cachedValue2 = operationMethodCache.get(value);
+        if (cachedValue2) {
+          return cachedValue2;
+        }
+        const thisBoundValue2 = function(...args) {
+          const thisArg = this === proxy ? proxy : this;
+          const output = Reflect.apply(value, thisArg, args);
+          return output === target ? proxy : output;
+        };
+        operationMethodCache.set(value, thisBoundValue2);
+        return thisBoundValue2;
+      }
+      const cachedValue = privateMethodWorkaroundCache.get(value);
+      if (cachedValue) {
+        return cachedValue;
+      }
+      const thisBoundValue = function(...args) {
+        const thisArg = this === proxy ? target : this;
+        const output = Reflect.apply(value, thisArg, args);
+        return output === target ? proxy : output;
+      };
+      privateMethodWorkaroundCache.set(value, thisBoundValue);
+      return thisBoundValue;
+    }
+  });
+  bedrockRuntimeProxyCache.set(client, proxy);
+  return proxy;
+}
+function wrapSend(send) {
+  return (command, optionsOrCb, cb) => {
+    if (getBedrockRuntimeOperation(command) === void 0 || typeof optionsOrCb === "function" || typeof cb === "function") {
+      return send(command, optionsOrCb, cb);
+    }
+    return bedrockRuntimeChannels.clientSend.tracePromise(
+      () => runWithAutoInstrumentationSuppressed(
+        () => send(command, optionsOrCb)
+      ),
+      {
+        arguments: [command, optionsOrCb],
+        span_info: buildBedrockRuntimeSpanInfo(command)
+      }
+    );
+  };
+}
+
 // src/wrappers/github-copilot.ts
 function isGitHubCopilotClient(value) {
   return value !== null && typeof value === "object" && typeof value.createSession === "function" && typeof value.resumeSession === "function";
@@ -34292,14 +36184,15 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           return;
         }
         const eventDataset = experiment ? experiment.dataset : Dataset2.isDataset(evaluator.data) ? evaluator.data : void 0;
-        const inlineOrigin = datum.origin === void 0 ? void 0 : ObjectReference.parse(datum.origin);
-        const origin = inlineOrigin ?? (eventDataset && datum.id && datum._xact_id ? {
+        const inlineDatasetOrigin = eventDataset && datum.id && datum._xact_id ? {
           object_type: "dataset",
           object_id: await eventDataset.id,
           id: datum.id,
           created: datum.created,
           _xact_id: datum._xact_id
-        } : void 0);
+        } : void 0;
+        const parsedDatumOrigin = ObjectReference.safeParse(datum.origin);
+        const origin = inlineDatasetOrigin ?? (parsedDatumOrigin?.success ? parsedDatumOrigin.data : void 0);
         const baseEvent = {
           name: "eval",
           spanAttributes: {