braintrust 3.23.1 → 3.25.0

package/dist/instrumentation/index.js

@@ -61,6 +61,7 @@ var DefaultChannel = class {
   constructor(name) {
     this.name = name;
   }
+  name;
   hasSubscribers = false;
   subscribe(_subscription) {
   }
@@ -1337,6 +1338,7 @@ var SpanComponentsV3 = class _SpanComponentsV3 {
   constructor(data) {
     this.data = data;
   }
+  data;
   toStr() {
     const jsonObj = {
       compute_object_metadata_args: this.data.compute_object_metadata_args || void 0,
@@ -1757,6 +1759,7 @@ var SpanComponentsV4 = class _SpanComponentsV4 {
   constructor(data) {
     this.data = data;
   }
+  data;
   toStr() {
     const jsonObj = {
       compute_object_metadata_args: this.data.compute_object_metadata_args || void 0,
@@ -4916,6 +4919,144 @@ var SpanCache = class {
   }
 };
 
+// src/span-origin.ts
+var INSTRUMENTATION_NAMES = {
+  AI_SDK: "ai-sdk",
+  ANTHROPIC: "anthropic",
+  BEDROCK_RUNTIME: "bedrock-runtime",
+  BRAINTRUST_JS_LOGGER: "braintrust-js-logger",
+  CLAUDE_AGENT_SDK: "claude-agent-sdk",
+  COHERE: "cohere",
+  CURSOR_SDK: "cursor-sdk",
+  EVE: "eve",
+  FLUE: "flue",
+  GENKIT: "genkit",
+  GITHUB_COPILOT: "github-copilot",
+  GOOGLE_ADK: "google-adk",
+  GOOGLE_GENAI: "google-genai",
+  GROQ: "groq",
+  HUGGINGFACE: "huggingface",
+  LANGCHAIN: "langchain",
+  LANGSMITH: "langsmith",
+  MASTRA: "mastra",
+  MISTRAL: "mistral",
+  OPENAI: "openai",
+  OPENAI_AGENTS: "openai-agents",
+  OPENAI_CODEX: "openai-codex",
+  OPENROUTER: "openrouter",
+  OPENROUTER_AGENT: "openrouter-agent",
+  PI_CODING_AGENT: "pi-coding-agent",
+  STRANDS_AGENT_SDK: "strands-agent-sdk"
+};
+var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
+  "braintrust.spanInstrumentationName"
+);
+var SDK_VERSION = true ? "3.25.0" : "0.0.0";
+function withSpanInstrumentationName(args, instrumentationName) {
+  return {
+    ...args,
+    [INTERNAL_SPAN_INSTRUMENTATION_NAME]: instrumentationName
+  };
+}
+function getSpanInstrumentationName(args) {
+  if (typeof args !== "object" || args === null) {
+    return void 0;
+  }
+  const value = args[INTERNAL_SPAN_INSTRUMENTATION_NAME];
+  return isSpanInstrumentationName(value) ? value : void 0;
+}
+function detectSpanOriginEnvironment(explicit) {
+  if (explicit) return explicit;
+  const envType = isomorph_default.getEnv("BRAINTRUST_ENVIRONMENT_TYPE");
+  const envName = isomorph_default.getEnv("BRAINTRUST_ENVIRONMENT_NAME");
+  if (envType || envName) {
+    return {
+      ...envType ? { type: envType } : {},
+      ...envName ? { name: envName } : {}
+    };
+  }
+  const ci = firstPresent([
+    ["GITHUB_ACTIONS", "github_actions"],
+    ["GITLAB_CI", "gitlab_ci"],
+    ["CIRCLECI", "circleci"],
+    ["BUILDKITE", "buildkite"],
+    ["JENKINS_URL", "jenkins"],
+    ["JENKINS_HOME", "jenkins"],
+    ["TF_BUILD", "azure_pipelines"],
+    ["TEAMCITY_VERSION", "teamcity"],
+    ["TRAVIS", "travis"],
+    ["BITBUCKET_BUILD_NUMBER", "bitbucket"]
+  ]);
+  if (ci) return { type: "ci", name: ci };
+  if (isomorph_default.getEnv("CI")) return { type: "ci", name: "ci" };
+  const earlyServer = firstPresent([
+    ["VERCEL", "vercel"],
+    ["NETLIFY", "netlify"]
+  ]);
+  if (earlyServer) return { type: "server", name: earlyServer };
+  if (isomorph_default.getEnv("ECS_CONTAINER_METADATA_URI") || isomorph_default.getEnv("ECS_CONTAINER_METADATA_URI_V4")) {
+    return { type: "server", name: "ecs" };
+  }
+  const awsExecutionEnv = isomorph_default.getEnv("AWS_EXECUTION_ENV");
+  if (awsExecutionEnv?.startsWith("AWS_ECS_")) {
+    return { type: "server", name: "ecs" };
+  }
+  if (awsExecutionEnv?.startsWith("AWS_Lambda_")) {
+    return { type: "server", name: "aws_lambda" };
+  }
+  if (isomorph_default.getEnv("AWS_LAMBDA_FUNCTION_NAME")) {
+    return { type: "server", name: "aws_lambda" };
+  }
+  const server = firstPresent([
+    ["K_SERVICE", "cloud_run"],
+    ["FUNCTION_TARGET", "gcp_functions"],
+    ["KUBERNETES_SERVICE_HOST", "kubernetes"],
+    ["DYNO", "heroku"],
+    ["FLY_APP_NAME", "fly"],
+    ["RAILWAY_ENVIRONMENT", "railway"],
+    ["RENDER_SERVICE_NAME", "render"]
+  ]);
+  if (server) return { type: "server", name: server };
+  return deploymentModeEnvironment("NODE_ENV", isomorph_default.getEnv("NODE_ENV"));
+}
+function makeSpanOrigin(instrumentationName, environment) {
+  return {
+    name: "braintrust.sdk.javascript",
+    version: SDK_VERSION,
+    instrumentation: { name: instrumentationName },
+    ...environment ? { environment } : {}
+  };
+}
+function mergeSpanOriginContext(context, instrumentationName, environment) {
+  const next = { ...context ?? {} };
+  const current = isObject2(next.span_origin) ? { ...next.span_origin } : {};
+  next.span_origin = {
+    ...makeSpanOrigin(instrumentationName, environment),
+    ...current
+  };
+  return next;
+}
+function isSpanInstrumentationName(value) {
+  return Object.values(INSTRUMENTATION_NAMES).some((name) => name === value);
+}
+function firstPresent(entries) {
+  return entries.find(([key]) => Boolean(isomorph_default.getEnv(key)))?.[1];
+}
+function deploymentModeEnvironment(_key, value) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "production" || normalized === "staging") {
+    return { type: "server", name: normalized };
+  }
+  if (normalized === "development" || normalized === "local") {
+    return { type: "local", name: normalized };
+  }
+  return { name: value };
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/logger.ts
 var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
@@ -4964,6 +5105,7 @@ var LoginInvalidOrgError = class extends Error {
     super(message);
     this.message = message;
   }
+  message;
 };
 var REDACTION_FIELDS = [
   "input",
@@ -4979,6 +5121,8 @@ var MaskingError = class {
     this.fieldName = fieldName;
     this.errorType = errorType;
   }
+  fieldName;
+  errorType;
   get errorMsg() {
     return `ERROR: Failed to mask field '${this.fieldName}' - ${this.errorType}`;
   }
@@ -5188,7 +5332,10 @@ var BraintrustState = class _BraintrustState {
       diskCache: parametersDiskCache
     });
     this.spanCache = new SpanCache({ disabled: loginParams.disableSpanCache });
+    this.spanOriginEnvironment = detectSpanOriginEnvironment();
+    this._internalSetTraceContextSigningSecret(loginParams.apiKey);
   }
+  loginParams;
   id;
   currentExperiment;
   // Note: the value of IsAsyncFlush doesn't really matter here, since we
@@ -5223,6 +5370,19 @@ var BraintrustState = class _BraintrustState {
   _idGenerator = null;
   _contextManager = null;
   _otelFlushCallback = null;
+  spanOriginEnvironment;
+  traceContextSigningSecret;
+  /** @internal */
+  _internalSetTraceContextSigningSecret(secret) {
+    const normalizedSecret = secret?.trim();
+    if (normalizedSecret) {
+      this.traceContextSigningSecret = normalizedSecret;
+    }
+  }
+  /** @internal */
+  _internalGetTraceContextSigningSecret() {
+    return (this.traceContextSigningSecret ?? this.loginToken ?? isomorph_default.getEnv("BRAINTRUST_API_KEY"))?.trim();
+  }
   resetLoginInfo() {
     this.appUrl = null;
     this.appPublicUrl = null;
@@ -5283,6 +5443,7 @@ var BraintrustState = class _BraintrustState {
     this.gitMetadataSettings = other.gitMetadataSettings;
     this.debugLogLevel = other.debugLogLevel;
     this.debugLogLevelConfigured = other.debugLogLevelConfigured;
+    this.traceContextSigningSecret = other.traceContextSigningSecret;
     setGlobalDebugLogLevel(
       this.debugLogLevelConfigured ? this.debugLogLevel ?? false : void 0
     );
@@ -5370,6 +5531,7 @@ var BraintrustState = class _BraintrustState {
     return this.debugLogLevelConfigured;
   }
   async login(loginParams) {
+    this._internalSetTraceContextSigningSecret(loginParams.apiKey);
     this.setDebugLogLevel(loginParams.debugLogLevel);
     if (this.apiUrl && !loginParams.forceLogin) {
       return;
@@ -7140,6 +7302,7 @@ function initLogger(options = {}) {
     orgName,
     forceLogin,
     debugLogLevel,
+    environment,
     fetch: fetch2,
     state: stateArg
   } = options || {};
@@ -7155,7 +7318,9 @@ function initLogger(options = {}) {
     project_id: projectId
   };
   const state = stateArg ?? _globalState;
+  state._internalSetTraceContextSigningSecret(apiKey);
   state.setDebugLogLevel(debugLogLevel);
+  state.spanOriginEnvironment = detectSpanOriginEnvironment(environment);
   state.enforceQueueSizeLimit(true);
   const lazyMetadata = new LazyValue(
     async () => {
@@ -7678,7 +7843,9 @@ function deepCopyEvent(event) {
   const ATTACHMENT_MARKER_KEY = "_bt_internal_saved_attachment_marker";
   const attachmentMarker = ++deepCopyEventMarkerCounter;
   const serialized = JSON.stringify(event, (_k, v) => {
-    if (v instanceof SpanImpl || v instanceof NoopSpan) {
+    if (v instanceof Error) {
+      return v.message;
+    } else if (v instanceof SpanImpl || v instanceof NoopSpan) {
       return `<span>`;
     } else if (v instanceof Experiment2) {
       return `<experiment>`;
@@ -7795,6 +7962,11 @@ var ObjectFetcher = class {
     this._internal_btql = _internal_btql;
     this._internalBrainstoreRealtime = _internalBrainstoreRealtime;
   }
+  objectType;
+  pinnedVersion;
+  mutateRecord;
+  _internal_btql;
+  _internalBrainstoreRealtime;
   _fetchedData = void 0;
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
@@ -8285,6 +8457,7 @@ var SpanImpl = class _SpanImpl {
   constructor(args) {
     this._state = args.state;
     this._propagatedState = args.propagatedState;
+    const instrumentationName = getSpanInstrumentationName(args) ?? INSTRUMENTATION_NAMES.BRAINTRUST_JS_LOGGER;
     const spanAttributes = args.spanAttributes ?? {};
     const rawEvent = args.event ?? {};
     const type = args.type ?? (args.parentSpanIds ? void 0 : args.defaultRootType);
@@ -8314,7 +8487,11 @@ var SpanImpl = class _SpanImpl {
       metrics: {
         start: args.startTime ?? getCurrentUnixTimestamp()
       },
-      context: { ...callerLocation },
+      context: mergeSpanOriginContext(
+        { ...callerLocation },
+        instrumentationName,
+        this._state.spanOriginEnvironment
+      ),
       span_attributes: {
         name,
         type,
@@ -8688,6 +8865,7 @@ var Dataset2 = class extends ObjectFetcher {
     this.pinnedEnvironment = pinState?.pinnedEnvironment;
     this.pinnedSnapshotName = pinState?.pinnedSnapshotName;
   }
+  state;
   lazyMetadata;
   __braintrust_dataset_marker = true;
   newRecords = 0;
@@ -9536,15 +9714,25 @@ function hasChoices(value) {
 function normalizeMetadata(metadata) {
   return isObject(metadata) ? metadata : void 0;
 }
-function startSpanForEvent(config, event, channelName) {
+function startSpanForEvent(config, event, channelName, instrumentationName) {
   const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
     config,
     event
   );
-  const span = startSpan({
-    name,
-    spanAttributes
-  });
+  const spanArgs = withSpanInstrumentationName(
+    {
+      name,
+      spanAttributes
+    },
+    instrumentationName
+  );
+  let span;
+  try {
+    span = config.startSpan?.(spanArgs) ?? startSpan(spanArgs);
+  } catch (error) {
+    debugLogger.error(`Error starting span for ${channelName}:`, error);
+    span = startSpan(spanArgs);
+  }
   const startTime = getCurrentUnixTimestamp();
   try {
     const { input, metadata } = config.extractInput(
@@ -9575,7 +9763,7 @@ function shouldTraceEvent(config, event, channelName) {
     return true;
   }
 }
-function ensureSpanStateForEvent(states, config, event, channelName) {
+function ensureSpanStateForEvent(states, config, event, channelName, instrumentationName) {
   const key = event;
   const existing = states.get(key);
   if (existing) {
@@ -9584,11 +9772,16 @@ function ensureSpanStateForEvent(states, config, event, channelName) {
   if (!shouldTraceEvent(config, event, channelName)) {
     return void 0;
   }
-  const created = startSpanForEvent(config, event, channelName);
+  const created = startSpanForEvent(
+    config,
+    event,
+    channelName,
+    instrumentationName
+  );
   states.set(key, created);
   return created;
 }
-function bindCurrentSpanStoreToStart(tracingChannel, states, config, channelName) {
+function bindCurrentSpanStoreToStart(tracingChannel, states, config, channelName, instrumentationName) {
   const state = _internalGetGlobalState();
   const startChannel = tracingChannel.start;
   const contextManager = state?.contextManager;
@@ -9606,7 +9799,8 @@ function bindCurrentSpanStoreToStart(tracingChannel, states, config, channelName
         states,
         config,
         event,
-        channelName
+        channelName,
+        instrumentationName
       );
       return spanState ? contextManager.wrapSpanForStore(spanState.span) : currentSpanStore.getStore();
     }
@@ -9615,15 +9809,21 @@ function bindCurrentSpanStoreToStart(tracingChannel, states, config, channelName
     startChannel.unbindStore(currentSpanStore);
   };
 }
-function logErrorAndEnd(states, event) {
+function logErrorAndEnd(states, event, channelName) {
   const spanData = states.get(event);
   if (!spanData) {
     return;
   }
-  spanData.span.log({
-    error: event.error.message
-  });
-  spanData.span.end();
+  try {
+    spanData.span.log({ error: event.error });
+  } catch (error) {
+    debugLogger.error(`Error logging failure for ${channelName}:`, error);
+  }
+  try {
+    spanData.span.end();
+  } catch (error) {
+    debugLogger.error(`Error ending span for ${channelName}:`, error);
+  }
   states.delete(event);
 }
 function runStreamingCompletionHook(args) {
@@ -9673,7 +9873,8 @@ function traceAsyncChannel(channel2, config) {
     tracingChannel,
     states,
     config,
-    channelName
+    channelName,
+    channel2.instrumentationName
   );
   const handlers = {
     start: (event) => {
@@ -9684,7 +9885,8 @@ function traceAsyncChannel(channel2, config) {
         states,
         config,
         event,
-        channelName
+        channelName,
+        channel2.instrumentationName
       );
     },
     asyncEnd: (event) => {
@@ -9721,7 +9923,7 @@ function traceAsyncChannel(channel2, config) {
       }
     },
     error: (event) => {
-      logErrorAndEnd(states, event);
+      logErrorAndEnd(states, event, channelName);
     }
   };
   tracingChannel.subscribe(handlers);
@@ -9738,7 +9940,8 @@ function traceStreamingChannel(channel2, config) {
     tracingChannel,
     states,
     config,
-    channelName
+    channelName,
+    channel2.instrumentationName
   );
   const handlers = {
     start: (event) => {
@@ -9749,7 +9952,8 @@ function traceStreamingChannel(channel2, config) {
         states,
         config,
         event,
-        channelName
+        channelName,
+        channel2.instrumentationName
       );
     },
     asyncEnd: (event) => {
@@ -9768,6 +9972,7 @@ function traceStreamingChannel(channel2, config) {
             }
           },
           onComplete: (chunks) => {
+            let completion2;
             try {
               let output;
               let metrics;
@@ -9798,18 +10003,11 @@ function traceStreamingChannel(channel2, config) {
               } else if (metrics.time_to_first_token === void 0 && chunks.length > 0) {
                 metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
               }
-              runStreamingCompletionHook({
-                channelName,
-                chunks,
-                config,
-                endEvent: asyncEndEvent,
+              completion2 = {
                 ...metadata !== void 0 ? { metadata } : {},
                 metrics,
-                output,
-                result: asyncEndEvent.result,
-                span,
-                startTime
-              });
+                output
+              };
               span.log({
                 output,
                 ...metadata !== void 0 ? { metadata } : {},
@@ -9821,11 +10019,49 @@ function traceStreamingChannel(channel2, config) {
                 error
               );
             } finally {
-              span.end();
+              try {
+                span.end();
+              } catch (error) {
+                debugLogger.error(
+                  `Error ending span for ${channelName}:`,
+                  error
+                );
+              }
               states.delete(event);
             }
+            if (completion2) {
+              runStreamingCompletionHook({
+                channelName,
+                chunks,
+                config,
+                endEvent: asyncEndEvent,
+                ...completion2.metadata !== void 0 ? { metadata: completion2.metadata } : {},
+                metrics: completion2.metrics,
+                output: completion2.output,
+                result: asyncEndEvent.result,
+                span,
+                startTime
+              });
+            }
           },
           onError: (error) => {
+            try {
+              span.log({ error });
+            } catch (loggingError) {
+              debugLogger.error(
+                `Error logging failure for ${channelName}:`,
+                loggingError
+              );
+            }
+            try {
+              span.end();
+            } catch (endingError) {
+              debugLogger.error(
+                `Error ending span for ${channelName}:`,
+                endingError
+              );
+            }
+            states.delete(event);
             runStreamingErrorHook({
               channelName,
               config,
@@ -9834,11 +10070,6 @@ function traceStreamingChannel(channel2, config) {
               span,
               startTime
             });
-            span.log({
-              error: error.message
-            });
-            span.end();
-            states.delete(event);
           }
         });
         return;
@@ -9853,6 +10084,7 @@ function traceStreamingChannel(channel2, config) {
         states.delete(event);
         return;
       }
+      let completion;
       try {
         const output = config.extractOutput(
           asyncEndEvent.result,
@@ -9867,17 +10099,11 @@ function traceStreamingChannel(channel2, config) {
           asyncEndEvent.result,
           asyncEndEvent
         );
-        runStreamingCompletionHook({
-          channelName,
-          config,
-          endEvent: asyncEndEvent,
+        completion = {
           ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
           metrics,
-          output,
-          result: asyncEndEvent.result,
-          span,
-          startTime
-        });
+          output
+        };
         span.log({
           output,
           ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
@@ -9886,12 +10112,30 @@ function traceStreamingChannel(channel2, config) {
       } catch (error) {
         debugLogger.error(`Error extracting output for ${channelName}:`, error);
       } finally {
-        span.end();
+        try {
+          span.end();
+        } catch (error) {
+          debugLogger.error(`Error ending span for ${channelName}:`, error);
+        }
         states.delete(event);
       }
+      if (completion) {
+        runStreamingCompletionHook({
+          channelName,
+          config,
+          endEvent: asyncEndEvent,
+          ...completion.metadata !== void 0 ? { metadata: completion.metadata } : {},
+          metrics: completion.metrics,
+          output: completion.output,
+          result: asyncEndEvent.result,
+          span,
+          startTime
+        });
+      }
     },
     error: (event) => {
       const spanData = states.get(event);
+      logErrorAndEnd(states, event, channelName);
       if (spanData) {
         runStreamingErrorHook({
           channelName,
@@ -9902,7 +10146,6 @@ function traceStreamingChannel(channel2, config) {
           startTime: spanData.startTime
         });
       }
-      logErrorAndEnd(states, event);
     }
   };
   tracingChannel.subscribe(handlers);
@@ -9919,7 +10162,8 @@ function traceSyncStreamChannel(channel2, config) {
     tracingChannel,
     states,
     config,
-    channelName
+    channelName,
+    channel2.instrumentationName
   );
   const handlers = {
     start: (event) => {
@@ -9930,7 +10174,8 @@ function traceSyncStreamChannel(channel2, config) {
         states,
         config,
         event,
-        channelName
+        channelName,
+        channel2.instrumentationName
       );
     },
     end: (event) => {
@@ -10024,7 +10269,7 @@ function traceSyncStreamChannel(channel2, config) {
       handleResolvedResult(endEvent.result);
     },
     error: (event) => {
-      logErrorAndEnd(states, event);
+      logErrorAndEnd(states, event, channelName);
     }
   };
   tracingChannel.subscribe(handlers);
@@ -10203,7 +10448,8 @@ function processInputAttachments(input) {
 function channel(spec) {
   return spec;
 }
-function defineChannels(pkg, channels) {
+function defineChannels(pkg, channels, options) {
+  const { instrumentationName } = options;
   return Object.fromEntries(
     Object.entries(channels).map(([key, spec]) => {
       const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
@@ -10216,6 +10462,7 @@ function defineChannels(pkg, channels) {
           key,
           {
             ...asyncSpec,
+            instrumentationName,
             tracingChannel: tracingChannel2,
             tracePromise: (fn, context) => tracingChannel2().tracePromise(
               fn,
@@ -10233,6 +10480,7 @@ function defineChannels(pkg, channels) {
         key,
         {
           ...syncSpec,
+          instrumentationName,
           tracingChannel,
           traceSync: (fn, context) => tracingChannel().traceSync(
             fn,
@@ -10246,44 +10494,48 @@ function defineChannels(pkg, channels) {
 }
 
 // src/instrumentation/plugins/openai-channels.ts
-var openAIChannels = defineChannels("openai", {
-  chatCompletionsCreate: channel({
-    channelName: "chat.completions.create",
-    kind: "async"
-  }),
-  embeddingsCreate: channel({
-    channelName: "embeddings.create",
-    kind: "async"
-  }),
-  betaChatCompletionsParse: channel({
-    channelName: "beta.chat.completions.parse",
-    kind: "async"
-  }),
-  betaChatCompletionsStream: channel({
-    channelName: "beta.chat.completions.stream",
-    kind: "sync-stream"
-  }),
-  moderationsCreate: channel({
-    channelName: "moderations.create",
-    kind: "async"
-  }),
-  responsesCreate: channel({
-    channelName: "responses.create",
-    kind: "async"
-  }),
-  responsesStream: channel({
-    channelName: "responses.stream",
-    kind: "sync-stream"
-  }),
-  responsesParse: channel({
-    channelName: "responses.parse",
-    kind: "async"
-  }),
-  responsesCompact: channel({
-    channelName: "responses.compact",
-    kind: "async"
-  })
-});
+var openAIChannels = defineChannels(
+  "openai",
+  {
+    chatCompletionsCreate: channel({
+      channelName: "chat.completions.create",
+      kind: "async"
+    }),
+    embeddingsCreate: channel({
+      channelName: "embeddings.create",
+      kind: "async"
+    }),
+    betaChatCompletionsParse: channel({
+      channelName: "beta.chat.completions.parse",
+      kind: "async"
+    }),
+    betaChatCompletionsStream: channel({
+      channelName: "beta.chat.completions.stream",
+      kind: "sync-stream"
+    }),
+    moderationsCreate: channel({
+      channelName: "moderations.create",
+      kind: "async"
+    }),
+    responsesCreate: channel({
+      channelName: "responses.create",
+      kind: "async"
+    }),
+    responsesStream: channel({
+      channelName: "responses.stream",
+      kind: "sync-stream"
+    }),
+    responsesParse: channel({
+      channelName: "responses.parse",
+      kind: "async"
+    }),
+    responsesCompact: channel({
+      channelName: "responses.compact",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OPENAI }
+);
 
 // src/openai-utils.ts
 var BRAINTRUST_CACHED_STREAM_METRIC = "__braintrust_cached_metric";
@@ -10798,16 +11050,20 @@ function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
 }
 
 // src/instrumentation/plugins/openai-codex-channels.ts
-var openAICodexChannels = defineChannels("@openai/codex-sdk", {
-  run: channel({
-    channelName: "Thread.run",
-    kind: "async"
-  }),
-  runStreamed: channel({
-    channelName: "Thread.runStreamed",
-    kind: "async"
-  })
-});
+var openAICodexChannels = defineChannels(
+  "@openai/codex-sdk",
+  {
+    run: channel({
+      channelName: "Thread.run",
+      kind: "async"
+    }),
+    runStreamed: channel({
+      channelName: "Thread.runStreamed",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OPENAI_CODEX }
+);
 
 // src/instrumentation/plugins/openai-codex-plugin.ts
 var PATCHED_STREAMED_TURN = /* @__PURE__ */ Symbol.for(
@@ -10895,10 +11151,15 @@ function startCodexRun(event, operation) {
     provider: "openai",
     ...event.moduleVersion ? { "openai_codex.version": event.moduleVersion } : {}
   };
-  const span = startSpan({
-    name: "OpenAI Codex",
-    spanAttributes: { type: "task" /* TASK */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        name: "OpenAI Codex",
+        spanAttributes: { type: "task" /* TASK */ }
+      },
+      INSTRUMENTATION_NAMES.OPENAI_CODEX
+    )
+  );
   const startTime = getCurrentUnixTimestamp();
   safeLog(span, {
     input: sanitizedInput,
@@ -11047,7 +11308,12 @@ async function createCompletedItemSpan(state, item) {
   if (!spanArgs) {
     return;
   }
-  const span = startSpan(spanArgs.start);
+  const span = startSpan(
+    withSpanInstrumentationName(
+      spanArgs.start,
+      INSTRUMENTATION_NAMES.OPENAI_CODEX
+    )
+  );
   safeLog(span, spanArgs.end);
   span.end();
 }
@@ -11089,15 +11355,20 @@ async function ensureActiveLlmSpan(state) {
     ...state.metadata["openai_codex.thread_id"] ? { "openai_codex.thread_id": state.metadata["openai_codex.thread_id"] } : {},
     "openai_codex.llm_sequence": sequence
   };
-  const span = startSpan({
-    event: {
-      ...sequence === 1 ? { input: state.input } : {},
-      metadata
-    },
-    name: "OpenAI Codex LLM",
-    parent: await state.span.export(),
-    spanAttributes: { type: "llm" /* LLM */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          ...sequence === 1 ? { input: state.input } : {},
+          metadata
+        },
+        name: "OpenAI Codex LLM",
+        parent: await state.span.export(),
+        spanAttributes: { type: "llm" /* LLM */ }
+      },
+      INSTRUMENTATION_NAMES.OPENAI_CODEX
+    )
+  );
   state.activeLlmSpan = {
     anonymousMessages: [],
     anonymousReasoning: [],
@@ -11143,7 +11414,15 @@ async function startCodexItemSpan(state, item) {
   if (!spanArgs) {
     return;
   }
-  state.activeItemSpans.set(itemId, startSpan(spanArgs.start));
+  state.activeItemSpans.set(
+    itemId,
+    startSpan(
+      withSpanInstrumentationName(
+        spanArgs.start,
+        INSTRUMENTATION_NAMES.OPENAI_CODEX
+      )
+    )
+  );
 }
 function updateCodexItem(state, item) {
   if (item.type === "agent_message" && typeof item.text === "string") {
@@ -11453,20 +11732,24 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
 }
 
 // src/instrumentation/plugins/anthropic-channels.ts
-var anthropicChannels = defineChannels("@anthropic-ai/sdk", {
-  messagesCreate: channel({
-    channelName: "messages.create",
-    kind: "async"
-  }),
-  betaMessagesCreate: channel({
-    channelName: "beta.messages.create",
-    kind: "async"
-  }),
-  betaMessagesToolRunner: channel({
-    channelName: "beta.messages.toolRunner",
-    kind: "sync-stream"
-  })
-});
+var anthropicChannels = defineChannels(
+  "@anthropic-ai/sdk",
+  {
+    messagesCreate: channel({
+      channelName: "messages.create",
+      kind: "async"
+    }),
+    betaMessagesCreate: channel({
+      channelName: "beta.messages.create",
+      kind: "async"
+    }),
+    betaMessagesToolRunner: channel({
+      channelName: "beta.messages.toolRunner",
+      kind: "sync-stream"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.ANTHROPIC }
+);
 
 // src/instrumentation/plugins/anthropic-plugin.ts
 var ANTHROPIC_TOOL_RUNNER_TOOL_WRAPPED = /* @__PURE__ */ Symbol.for(
@@ -11539,12 +11822,17 @@ var AnthropicPlugin = class extends BasePlugin {
           return;
         }
         const params = event.arguments[0] ?? {};
-        const span = startSpan({
-          name: "anthropic.beta.messages.toolRunner",
-          spanAttributes: {
-            type: "task" /* TASK */
-          }
-        });
+        const span = startSpan(
+          withSpanInstrumentationName(
+            {
+              name: "anthropic.beta.messages.toolRunner",
+              spanAttributes: {
+                type: "task" /* TASK */
+              }
+            },
+            INSTRUMENTATION_NAMES.ANTHROPIC
+          )
+        );
         span.log({
           input: processAttachmentsInInput(
             coalesceInput(params.messages ?? [], params.system)
@@ -11685,19 +11973,22 @@ function wrapAnthropicToolRunnerTool(tool, index, state) {
             return finalizeError(error);
           }
         },
-        {
-          event: {
-            input: getAnthropicToolRunnerInput(args),
-            metadata: {
-              "gen_ai.tool.name": toolName,
-              provider: "anthropic"
+        withSpanInstrumentationName(
+          {
+            event: {
+              input: getAnthropicToolRunnerInput(args),
+              metadata: {
+                "gen_ai.tool.name": toolName,
+                provider: "anthropic"
+              }
+            },
+            name: `tool: ${toolName}`,
+            spanAttributes: {
+              type: "tool" /* TOOL */
             }
           },
-          name: `tool: ${toolName}`,
-          spanAttributes: {
-            type: "tool" /* TOOL */
-          }
-        }
+          INSTRUMENTATION_NAMES.ANTHROPIC
+        )
       );
     },
     writable: runDescriptor?.writable ?? true
@@ -12292,32 +12583,296 @@ function currentWorkflowAgentWrapperSpan() {
   return void 0;
 }
 
-// src/wrappers/ai-sdk/telemetry.ts
-function braintrustAISDKTelemetry() {
-  const operations = /* @__PURE__ */ new Map();
-  const operationKeysByCallId = /* @__PURE__ */ new Map();
-  const workflowOperationKeyStore = isomorph_default.newAsyncLocalStorage();
-  const modelSpans = /* @__PURE__ */ new Map();
-  const objectSpans = /* @__PURE__ */ new Map();
-  const embedSpans = /* @__PURE__ */ new Map();
-  const rerankSpans = /* @__PURE__ */ new Map();
-  const toolSpans = /* @__PURE__ */ new Map();
-  let workflowAgentOperationCounter = 0;
-  const runSafely = (name, callback) => {
-    try {
-      callback();
-    } catch (error) {
-      console.error(`Error in Braintrust AI SDK telemetry ${name}:`, error);
-    }
+// src/wrappers/ai-sdk/harness-agent-context.ts
+var BRAINTRUST_TURN_CONTEXT_KEY = "__braintrust_trace_context";
+var sessionTurnParents = /* @__PURE__ */ new WeakMap();
+var wrapperTurnParents = /* @__PURE__ */ new WeakMap();
+var patchedLifecycleMethods = /* @__PURE__ */ new WeakMap();
+var harnessTurnParentStore;
+function serializedTurnContext(value) {
+  if (!isObject(value)) {
+    return void 0;
+  }
+  const context = value[BRAINTRUST_TURN_CONTEXT_KEY];
+  if (!isObject(context) || typeof context.parent !== "string" || typeof context.sessionId !== "string" || typeof context.signature !== "string") {
+    return void 0;
+  }
+  const expectedSignature = signTurnContext({
+    parent: context.parent,
+    sessionId: context.sessionId
+  });
+  if (!expectedSignature || !isomorph_default.timingSafeEqual?.(context.signature, expectedSignature)) {
+    return void 0;
+  }
+  const parent = SpanComponentsV4.fromStr(context.parent);
+  if (!parent.data.row_id || !parent.data.root_span_id || !parent.data.span_id) {
+    return void 0;
+  }
+  return {
+    parent: context.parent,
+    sessionId: context.sessionId
   };
-  const startChildSpan = (operationKey, name, type, event) => {
-    const parent = operations.get(operationKey)?.span;
-    const spanArgs = {
-      name,
-      spanAttributes: { type },
-      ...event ? { event } : {}
-    };
-    const span = parent ? parent.startSpan(spanArgs) : startSpan(spanArgs);
+}
+function signTurnContext(context) {
+  const secret = _internalGetGlobalState()._internalGetTraceContextSigningSecret();
+  return secret ? isomorph_default.hmacSha256?.(
+    secret,
+    JSON.stringify([BRAINTRUST_TURN_CONTEXT_KEY, context])
+  ) : void 0;
+}
+function continuationParentFromCreateSessionParams(params) {
+  if (!isObject(params)) {
+    return void 0;
+  }
+  const continuation = params.continueFrom ?? (isObject(params.resumeFrom) ? params.resumeFrom.continueFrom : void 0);
+  const context = serializedTurnContext(continuation);
+  if (!context) {
+    return void 0;
+  }
+  if (params.sessionId !== context.sessionId) {
+    return void 0;
+  }
+  return context.parent;
+}
+function exportSpanSynchronously(span) {
+  const parentInfo = span.getParentInfo();
+  if (!parentInfo) {
+    return void 0;
+  }
+  const objectId = parentInfo.objectId.getSync().value;
+  if (!objectId && !parentInfo.computeObjectMetadataArgs) {
+    return void 0;
+  }
+  return new SpanComponentsV4({
+    object_type: parentInfo.objectType,
+    ...objectId ? { object_id: objectId } : {
+      compute_object_metadata_args: parentInfo.computeObjectMetadataArgs ?? {}
+    },
+    row_id: span.id,
+    root_span_id: span.rootSpanId,
+    span_id: span.spanId
+  }).toStr();
+}
+function exportedParent(parent) {
+  return typeof parent === "string" ? parent : exportSpanSynchronously(parent);
+}
+function addSerializedContext(args) {
+  if (!isObject(args.continuation) || args.sessionId === void 0) {
+    return;
+  }
+  const parent = exportedParent(args.parent);
+  if (!parent) {
+    return;
+  }
+  const context = {
+    parent,
+    sessionId: args.sessionId
+  };
+  const signature = signTurnContext(context);
+  if (!signature) {
+    return;
+  }
+  Object.defineProperty(args.continuation, BRAINTRUST_TURN_CONTEXT_KEY, {
+    configurable: true,
+    enumerable: true,
+    value: {
+      ...context,
+      signature
+    },
+    writable: true
+  });
+}
+function lifecycleMethodDescriptor(session, method) {
+  let owner = session;
+  while (owner) {
+    const descriptor = Object.getOwnPropertyDescriptor(owner, method);
+    if (descriptor) {
+      return { descriptor, owner };
+    }
+    owner = Object.getPrototypeOf(owner);
+  }
+  return void 0;
+}
+function patchLifecycleMethod(session, method) {
+  let resolvedDescriptor;
+  try {
+    resolvedDescriptor = lifecycleMethodDescriptor(session, method);
+  } catch {
+    return;
+  }
+  if (!resolvedDescriptor || !("value" in resolvedDescriptor.descriptor) || typeof resolvedDescriptor.descriptor.value !== "function") {
+    return;
+  }
+  const { descriptor, owner } = resolvedDescriptor;
+  const patched = patchedLifecycleMethods.get(owner);
+  if (patched?.has(method)) {
+    return;
+  }
+  const original = descriptor.value;
+  const replacement = function(...args) {
+    const result = Reflect.apply(original, this, args);
+    const addContext = (state) => {
+      try {
+        const parent = sessionTurnParents.get(this);
+        if (!parent) {
+          return;
+        }
+        const continuation = method === "suspendTurn" ? state : isObject(state) ? state.continueFrom : void 0;
+        addSerializedContext({
+          continuation,
+          parent,
+          sessionId: typeof this.sessionId === "string" ? this.sessionId : void 0
+        });
+      } catch {
+      }
+    };
+    try {
+      if (isObject(result) && typeof result.then === "function") {
+        void Promise.resolve(result).then(addContext, () => {
+        });
+      } else {
+        addContext(result);
+      }
+    } catch {
+    }
+    return result;
+  };
+  try {
+    Object.defineProperty(owner, method, {
+      ...descriptor,
+      value: replacement
+    });
+    const ownerMethods = patched ?? /* @__PURE__ */ new Set();
+    ownerMethods.add(method);
+    if (!patched) {
+      patchedLifecycleMethods.set(owner, ownerMethods);
+    }
+  } catch {
+  }
+}
+function patchLifecycleMethods(session) {
+  patchLifecycleMethod(session, "suspendTurn");
+  patchLifecycleMethod(session, "detach");
+  patchLifecycleMethod(session, "stop");
+}
+function registerHarnessTurnSpan(args) {
+  if (!isObject(args.session)) {
+    return;
+  }
+  const session = args.session;
+  sessionTurnParents.set(session, args.span);
+  wrapperTurnParents.set(args.span, args.span);
+  patchLifecycleMethods(session);
+}
+function harnessContinuationParent(session) {
+  return isObject(session) ? sessionTurnParents.get(session) : void 0;
+}
+function captureHarnessCreateSessionParent(params) {
+  try {
+    return continuationParentFromCreateSessionParams(params);
+  } catch {
+    return void 0;
+  }
+}
+function registerHarnessSessionParent(session, parent) {
+  if (!parent || !isObject(session)) {
+    return;
+  }
+  const harnessSession = session;
+  sessionTurnParents.set(harnessSession, parent);
+  patchLifecycleMethods(harnessSession);
+}
+function currentHarnessTurnParent() {
+  return harnessTurnParentStore?.getStore() ?? wrapperTurnParents.get(currentSpan());
+}
+function bindHarnessTurnParentToStart(tracingChannel, parentFromEvent) {
+  const startChannel = tracingChannel.start;
+  if (!startChannel) {
+    return () => {
+    };
+  }
+  harnessTurnParentStore ??= isomorph_default.newAsyncLocalStorage();
+  const store = harnessTurnParentStore;
+  startChannel.bindStore(
+    store,
+    (event) => parentFromEvent(event) ?? store.getStore()
+  );
+  return () => {
+    startChannel.unbindStore(store);
+  };
+}
+function startHarnessTurnChildSpan(parent, args) {
+  const spanArgs = withSpanInstrumentationName(
+    args,
+    INSTRUMENTATION_NAMES.AI_SDK
+  );
+  return typeof parent === "string" ? startSpan({ ...spanArgs, parent }) : parent.startSpan(spanArgs);
+}
+function updateHarnessTurn(parent, update = {}) {
+  if (!parent) {
+    return;
+  }
+  const log = (event) => {
+    if (typeof parent === "string") {
+      updateSpan({ exported: parent, ...event });
+    } else {
+      parent.log(event);
+    }
+  };
+  try {
+    if (Object.prototype.hasOwnProperty.call(update, "output")) {
+      log({ output: null });
+    }
+    log(update);
+  } catch {
+  }
+}
+function endHarnessTurn(parent) {
+  const endTime = getCurrentUnixTimestamp();
+  if (!parent) {
+    return endTime;
+  }
+  try {
+    const event = { metrics: { end: endTime } };
+    if (typeof parent === "string") {
+      updateSpan({ exported: parent, ...event });
+    } else {
+      parent.log(event);
+    }
+  } catch {
+  }
+  return endTime;
+}
+
+// src/wrappers/ai-sdk/telemetry.ts
+function braintrustAISDKTelemetry() {
+  const operations = /* @__PURE__ */ new Map();
+  const operationKeysByCallId = /* @__PURE__ */ new Map();
+  const workflowOperationKeyStore = isomorph_default.newAsyncLocalStorage();
+  const modelSpans = /* @__PURE__ */ new Map();
+  const objectSpans = /* @__PURE__ */ new Map();
+  const embedSpans = /* @__PURE__ */ new Map();
+  const rerankSpans = /* @__PURE__ */ new Map();
+  const toolSpans = /* @__PURE__ */ new Map();
+  let workflowAgentOperationCounter = 0;
+  const runSafely = (name, callback) => {
+    try {
+      callback();
+    } catch (error) {
+      console.error(`Error in Braintrust AI SDK telemetry ${name}:`, error);
+    }
+  };
+  const startChildSpan = (operationKey, name, type, event, parentOverride) => {
+    const parent = operations.get(operationKey)?.span;
+    const spanArgs = withSpanInstrumentationName(
+      {
+        name,
+        spanAttributes: { type },
+        ...event ? { event } : {}
+      },
+      INSTRUMENTATION_NAMES.AI_SDK
+    );
+    const span = parentOverride ? startHarnessTurnChildSpan(parentOverride, spanArgs) : parent ? parent.startSpan(spanArgs) : startSpan(spanArgs);
     const state = operations.get(operationKey);
     if (state && type === "llm" /* LLM */) {
       state.hadModelChild = true;
@@ -12597,14 +13152,30 @@ function braintrustAISDKTelemetry() {
         const workflowAgent = operationName === "WorkflowAgent.stream";
         const wrapperSpan = workflowAgent ? currentWorkflowAgentWrapperSpan() : void 0;
         const ownsSpan = !wrapperSpan;
-        const span = ownsSpan ? startSpan({
-          name: operationName,
-          spanAttributes: { type: "function" /* FUNCTION */ }
-        }) : wrapperSpan;
+        const harnessTurnParent = currentHarnessTurnParent();
+        const span = ownsSpan ? harnessTurnParent ? startHarnessTurnChildSpan(
+          harnessTurnParent,
+          withSpanInstrumentationName(
+            {
+              name: operationName,
+              spanAttributes: { type: "function" /* FUNCTION */ }
+            },
+            INSTRUMENTATION_NAMES.AI_SDK
+          )
+        ) : startSpan(
+          withSpanInstrumentationName(
+            {
+              name: operationName,
+              spanAttributes: { type: "function" /* FUNCTION */ }
+            },
+            INSTRUMENTATION_NAMES.AI_SDK
+          )
+        ) : wrapperSpan;
         const operationKey = createOperationKey(event, operationName);
         registerOperation({
           callId: event.callId,
           hadModelChild: false,
+          harnessTurnParent,
           loggedInput: false,
           operationName,
           operationKey,
@@ -12845,7 +13416,8 @@ function braintrustAISDKTelemetry() {
               toolCallId,
               ...typeof event.toolCall.toolName === "string" ? { toolName: event.toolCall.toolName } : {}
             }
-          }
+          },
+          state?.harnessTurnParent
         );
         toolSpans.set(toolCallId, { operationKey, span });
       });
@@ -13081,74 +13653,102 @@ function finishOutput(result, operationName) {
 }
 
 // src/instrumentation/plugins/ai-sdk-channels.ts
-var aiSDKChannels = defineChannels("ai", {
-  generateText: channel({
-    channelName: "generateText",
-    kind: "async"
-  }),
-  streamText: channel({
-    channelName: "streamText",
-    kind: "async"
-  }),
-  streamTextSync: channel({
-    channelName: "streamText.sync",
-    kind: "sync-stream"
-  }),
-  generateObject: channel({
-    channelName: "generateObject",
-    kind: "async"
-  }),
-  streamObject: channel({
-    channelName: "streamObject",
-    kind: "async"
-  }),
-  streamObjectSync: channel({
-    channelName: "streamObject.sync",
-    kind: "sync-stream"
-  }),
-  embed: channel(
-    {
+var aiSDKChannels = defineChannels(
+  "ai",
+  {
+    generateText: channel({
+      channelName: "generateText",
+      kind: "async"
+    }),
+    streamText: channel({
+      channelName: "streamText",
+      kind: "async"
+    }),
+    streamTextSync: channel({
+      channelName: "streamText.sync",
+      kind: "sync-stream"
+    }),
+    generateObject: channel({
+      channelName: "generateObject",
+      kind: "async"
+    }),
+    streamObject: channel({
+      channelName: "streamObject",
+      kind: "async"
+    }),
+    streamObjectSync: channel({
+      channelName: "streamObject.sync",
+      kind: "sync-stream"
+    }),
+    embed: channel({
       channelName: "embed",
       kind: "async"
-    }
-  ),
-  embedMany: channel({
-    channelName: "embedMany",
-    kind: "async"
-  }),
-  rerank: channel({
-    channelName: "rerank",
-    kind: "async"
-  }),
-  agentGenerate: channel({
-    channelName: "Agent.generate",
-    kind: "async"
-  }),
-  agentStream: channel({
-    channelName: "Agent.stream",
-    kind: "async"
-  }),
-  agentStreamSync: channel({
-    channelName: "Agent.stream.sync",
-    kind: "sync-stream"
-  }),
-  toolLoopAgentGenerate: channel({
-    channelName: "ToolLoopAgent.generate",
-    kind: "async"
-  }),
-  toolLoopAgentStream: channel({
-    channelName: "ToolLoopAgent.stream",
-    kind: "async"
-  }),
-  workflowAgentStream: channel({
-    channelName: "WorkflowAgent.stream",
-    kind: "async"
-  }),
-  v7CreateTelemetryDispatcher: channel({
-    channelName: "createTelemetryDispatcher",
-    kind: "sync-stream"
-  })
-});
+    }),
+    embedMany: channel({
+      channelName: "embedMany",
+      kind: "async"
+    }),
+    rerank: channel({
+      channelName: "rerank",
+      kind: "async"
+    }),
+    agentGenerate: channel({
+      channelName: "Agent.generate",
+      kind: "async"
+    }),
+    agentStream: channel({
+      channelName: "Agent.stream",
+      kind: "async"
+    }),
+    agentStreamSync: channel({
+      channelName: "Agent.stream.sync",
+      kind: "sync-stream"
+    }),
+    toolLoopAgentGenerate: channel({
+      channelName: "ToolLoopAgent.generate",
+      kind: "async"
+    }),
+    toolLoopAgentStream: channel({
+      channelName: "ToolLoopAgent.stream",
+      kind: "async"
+    }),
+    workflowAgentStream: channel({
+      channelName: "WorkflowAgent.stream",
+      kind: "async"
+    }),
+    v7CreateTelemetryDispatcher: channel({
+      channelName: "createTelemetryDispatcher",
+      kind: "sync-stream"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.AI_SDK }
+);
+var harnessAgentChannels = defineChannels(
+  "@ai-sdk/harness",
+  {
+    createSession: channel({
+      channelName: "HarnessAgent.createSession",
+      kind: "async"
+    }),
+    generate: channel({
+      channelName: "HarnessAgent.generate",
+      kind: "async"
+    }),
+    stream: channel({
+      channelName: "HarnessAgent.stream",
+      kind: "async"
+    }),
+    continueGenerate: channel({
+      channelName: "HarnessAgent.continueGenerate",
+      kind: "async"
+    }),
+    continueStream: channel({
+      channelName: "HarnessAgent.continueStream",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.AI_SDK }
+);
 
 // src/instrumentation/plugins/ai-sdk-plugin.ts
 var DEFAULT_DENY_OUTPUT_PATHS = [
@@ -13225,6 +13825,17 @@ var AISDKPlugin = class extends BasePlugin {
   subscribeToAISDK() {
     const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
     this.unsubscribers.push(subscribeToAISDKV7TelemetryDispatcher());
+    this.unsubscribers.push(subscribeToHarnessAgentCreateSession());
+    this.unsubscribers.push(
+      subscribeToHarnessContinuation(
+        harnessAgentChannels.continueGenerate,
+        denyOutputPaths
+      ),
+      subscribeToHarnessContinuation(
+        harnessAgentChannels.continueStream,
+        denyOutputPaths
+      )
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.generateText, {
         name: "generateText",
@@ -13417,6 +14028,90 @@ var AISDKPlugin = class extends BasePlugin {
         })
       })
     );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.generate, {
+        name: "HarnessAgent.generate",
+        startSpan: _internalStartSpanWithInitialMerge,
+        type: "task" /* TASK */,
+        extractInput: ([params], event, span) => prepareAISDKHarnessAgentInput(params, event.self, span),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result) => extractTokenMetrics(result),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.stream, {
+        name: "HarnessAgent.stream",
+        startSpan: _internalStartSpanWithInitialMerge,
+        type: "task" /* TASK */,
+        extractInput: ([params], event, span) => prepareAISDKHarnessAgentInput(params, event.self, span),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result, startTime) => ({
+          ...extractTokenMetrics(result),
+          ...startTime === void 0 ? {} : {
+            time_to_first_token: getCurrentUnixTimestamp() - startTime
+          }
+        }),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          result,
+          resolvePromiseUsage: true,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.continueGenerate, {
+        name: "HarnessAgent.continueGenerate",
+        shouldTrace: (args) => !harnessContinuationParent(harnessSessionFromArguments(args)),
+        startSpan: _internalStartSpanWithInitialMerge,
+        type: "task" /* TASK */,
+        extractInput: ([params], event, span) => prepareAISDKHarnessAgentInput(params, event.self, span),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result) => extractTokenMetrics(result),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.continueStream, {
+        name: "HarnessAgent.continueStream",
+        shouldTrace: (args) => !harnessContinuationParent(harnessSessionFromArguments(args)),
+        startSpan: _internalStartSpanWithInitialMerge,
+        type: "task" /* TASK */,
+        extractInput: ([params], event, span) => prepareAISDKHarnessAgentInput(params, event.self, span),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result, startTime) => ({
+          ...extractTokenMetrics(result),
+          ...startTime === void 0 ? {} : {
+            time_to_first_token: getCurrentUnixTimestamp() - startTime
+          }
+        }),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          result,
+          resolvePromiseUsage: true,
+          span,
+          startTime
+        })
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.toolLoopAgentGenerate, {
         name: "ToolLoopAgent.generate",
@@ -13486,15 +14181,164 @@ var AISDKPlugin = class extends BasePlugin {
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
           defaultDenyOutputPaths: denyOutputPaths,
           endEvent,
-          onComplete: () => unregisterWorkflowAgentWrapperSpan(span),
-          result,
+          onComplete: () => unregisterWorkflowAgentWrapperSpan(span),
+          onCancel: () => unregisterWorkflowAgentWrapperSpan(span),
+          onError: () => unregisterWorkflowAgentWrapperSpan(span),
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+  }
+};
+function subscribeToHarnessAgentCreateSession() {
+  const channel2 = harnessAgentChannels.createSession.tracingChannel();
+  const parents = /* @__PURE__ */ new WeakMap();
+  const handlers = {
+    start: (event) => {
+      const parent = captureHarnessCreateSessionParent(event.arguments?.[0]);
+      if (parent) {
+        parents.set(event, parent);
+      }
+    },
+    asyncEnd: (event) => {
+      registerHarnessSessionParent(event.result, parents.get(event));
+      parents.delete(event);
+    },
+    error: (event) => {
+      parents.delete(event);
+    }
+  };
+  channel2.subscribe(handlers);
+  return () => channel2.unsubscribe(handlers);
+}
+function harnessContinuationParentFromEvent(event) {
+  try {
+    return harnessContinuationParent(event.arguments?.[0]?.session);
+  } catch {
+    return void 0;
+  }
+}
+function subscribeToHarnessContinuation(continuationChannel, defaultDenyOutputPaths) {
+  const channel2 = continuationChannel.tracingChannel();
+  const parents = /* @__PURE__ */ new WeakMap();
+  const startTimes = /* @__PURE__ */ new WeakMap();
+  const unbindParentStore = bindHarnessTurnParentToStart(
+    channel2,
+    harnessContinuationParentFromEvent
+  );
+  const handlers = {
+    start: (event) => {
+      const parent = harnessContinuationParentFromEvent(event);
+      if (!parent) {
+        return;
+      }
+      parents.set(event, parent);
+      startTimes.set(event, getCurrentUnixTimestamp());
+      try {
+        const params = event.arguments?.[0];
+        if (params) {
+          prepareAISDKHarnessAgentInput(params, event.self);
+        }
+      } catch (error) {
+        debugLogger.error(
+          "Error preparing Harness continuation telemetry:",
+          error
+        );
+      }
+    },
+    asyncEnd: (event) => {
+      const parent = parents.get(event);
+      const startTime = startTimes.get(event) ?? getCurrentUnixTimestamp();
+      parents.delete(event);
+      startTimes.delete(event);
+      if (!parent) {
+        return;
+      }
+      const endEvent = event;
+      const span = {
+        end: () => endHarnessTurn(parent),
+        log: (update) => updateHarnessTurn(
+          parent,
+          Object.prototype.hasOwnProperty.call(update, "error") && !Object.prototype.hasOwnProperty.call(update, "output") ? { ...update, output: null } : update
+        )
+      };
+      try {
+        if (isAsyncIterable(endEvent.result)) {
+          patchStreamIfNeeded(endEvent.result, {
+            onComplete: (chunks) => {
+              try {
+                const { metadata, metrics, output } = aggregateAISDKChunks(
+                  chunks,
+                  endEvent.result,
+                  endEvent
+                );
+                span.log({
+                  ...metadata ? { metadata } : {},
+                  metrics,
+                  output
+                });
+              } catch (error) {
+                debugLogger.error(
+                  "Error aggregating Harness continuation stream:",
+                  error
+                );
+              } finally {
+                span.end();
+              }
+            },
+            onError: (error) => {
+              span.log({ error: toLoggedError(error), output: null });
+              span.end();
+            }
+          });
+          return;
+        }
+        if (patchAISDKStreamingResult({
+          defaultDenyOutputPaths,
+          endEvent,
+          result: endEvent.result,
+          resolvePromiseUsage: true,
           span,
           startTime
-        })
-      })
-    );
-  }
-};
+        })) {
+          return;
+        }
+        finalizeAISDKChildTracing(endEvent);
+        span.log({
+          metrics: extractTokenMetrics(endEvent.result),
+          output: processAISDKOutput(
+            endEvent.result,
+            resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
+          )
+        });
+        span.end();
+      } catch (error) {
+        debugLogger.error("Error tracing Harness continuation:", error);
+        span.end();
+      }
+    },
+    error: (event) => {
+      const parent = parents.get(event);
+      parents.delete(event);
+      startTimes.delete(event);
+      if (!parent) {
+        return;
+      }
+      updateHarnessTurn(parent, {
+        error: toLoggedError(event.error),
+        output: null
+      });
+      endHarnessTurn(parent);
+    }
+  };
+  channel2.subscribe(handlers);
+  return () => {
+    unbindParentStore();
+    channel2.unsubscribe(handlers);
+  };
+}
 function subscribeToAISDKV7TelemetryDispatcher() {
   const channel2 = aiSDKChannels.v7CreateTelemetryDispatcher.tracingChannel();
   const telemetry = braintrustAISDKTelemetry();
@@ -13947,6 +14791,55 @@ function prepareAISDKCallInput(params, event, span, defaultDenyOutputPaths, chil
     metadata
   };
 }
+function prepareAISDKHarnessAgentInput(params, self, span) {
+  if (span) {
+    registerHarnessTurnSpan({
+      session: params.session,
+      span
+    });
+  }
+  if (isObject(self)) {
+    try {
+      if (isObject(self.settings)) {
+        const settings = self.settings;
+        if (settings.telemetry === void 0) {
+          Reflect.set(self, "settings", { ...settings, telemetry: {} });
+        }
+      }
+    } catch {
+    }
+  }
+  const selectedInput = {};
+  if (params.prompt !== void 0) {
+    selectedInput.prompt = params.prompt;
+  }
+  if (params.messages !== void 0) {
+    selectedInput.messages = params.messages;
+  }
+  if (params.toolApprovalContinuations !== void 0) {
+    selectedInput.toolApprovalContinuations = params.toolApprovalContinuations;
+  }
+  const metadata = extractMetadataFromCallParams({}, self);
+  if (isObject(params.session) && typeof params.session.sessionId === "string") {
+    metadata.sessionId = params.session.sessionId;
+  }
+  if (isObject(self)) {
+    if (typeof self.harnessId === "string") {
+      metadata.harnessId = self.harnessId;
+    }
+    if (typeof self.permissionMode === "string") {
+      metadata.permissionMode = self.permissionMode;
+    }
+  }
+  return {
+    input: processAISDKCallInput(selectedInput).input,
+    metadata
+  };
+}
+function harnessSessionFromArguments(args) {
+  const params = args[0];
+  return isObject(params) ? params.session : void 0;
+}
 function prepareAISDKWorkflowAgentStreamInput(params, event, span, defaultDenyOutputPaths) {
   registerWorkflowAgentWrapperSpan(span);
   const { input } = processAISDKWorkflowAgentCallInput(params);
@@ -14394,19 +15287,22 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
             activeEntry.openSpans.delete(span);
           }
         },
-        {
-          name: "doGenerate",
-          spanAttributes: {
-            type: "llm" /* LLM */
+        withSpanInstrumentationName(
+          {
+            name: "doGenerate",
+            spanAttributes: {
+              type: "llm" /* LLM */
+            },
+            event: buildAISDKModelStartEvent(
+              callOptions,
+              activeEntry.baseMetadata,
+              {
+                workflowAgent: activeEntry.childTracingOptions.workflowAgent
+              }
+            )
           },
-          event: buildAISDKModelStartEvent(
-            callOptions,
-            activeEntry.baseMetadata,
-            {
-              workflowAgent: activeEntry.childTracingOptions.workflowAgent
-            }
-          )
-        }
+          INSTRUMENTATION_NAMES.AI_SDK
+        )
       );
     };
     if (originalDoStream) {
@@ -14416,19 +15312,24 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
           return Reflect.apply(originalDoStream, resolvedModel, [callOptions]);
         }
         closeOpenAISDKModelPatchSpans(activeEntry);
-        const span = activeEntry.parentSpan.startSpan({
-          name: "doStream",
-          spanAttributes: {
-            type: "llm" /* LLM */
-          },
-          event: buildAISDKModelStartEvent(
-            callOptions,
-            activeEntry.baseMetadata,
+        const span = activeEntry.parentSpan.startSpan(
+          withSpanInstrumentationName(
             {
-              workflowAgent: activeEntry.childTracingOptions.workflowAgent
-            }
+              name: "doStream",
+              spanAttributes: {
+                type: "llm" /* LLM */
+              },
+              event: buildAISDKModelStartEvent(
+                callOptions,
+                activeEntry.baseMetadata,
+                {
+                  workflowAgent: activeEntry.childTracingOptions.workflowAgent
+                }
+              )
+            },
+            INSTRUMENTATION_NAMES.AI_SDK
           )
-        });
+        );
         activeEntry.openSpans.add(span);
         const streamStartTime = getCurrentUnixTimestamp();
         const result = await withCurrent(
@@ -14600,12 +15501,17 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       }
       if (isAsyncGenerator(result)) {
         return (async function* () {
-          const span = activeEntry.parentSpan.startSpan({
-            name: activeEntry.name,
-            spanAttributes: {
-              type: "tool" /* TOOL */
-            }
-          });
+          const span = activeEntry.parentSpan.startSpan(
+            withSpanInstrumentationName(
+              {
+                name: activeEntry.name,
+                spanAttributes: {
+                  type: "tool" /* TOOL */
+                }
+              },
+              INSTRUMENTATION_NAMES.AI_SDK
+            )
+          );
           span.log({ input: serializeToolExecutionInput(args) });
           try {
             let lastValue;
@@ -14629,12 +15535,15 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
           span.log({ output: awaitedResult });
           return awaitedResult;
         },
-        {
-          name: activeEntry.name,
-          spanAttributes: {
-            type: "tool" /* TOOL */
-          }
-        }
+        withSpanInstrumentationName(
+          {
+            name: activeEntry.name,
+            spanAttributes: {
+              type: "tool" /* TOOL */
+            }
+          },
+          INSTRUMENTATION_NAMES.AI_SDK
+        )
       );
     };
     cleanup.push(() => {
@@ -14793,7 +15702,10 @@ function patchAISDKStreamingResult(args) {
     defaultDenyOutputPaths,
     endEvent,
     onComplete,
+    onCancel,
+    onError,
     result,
+    resolvePromiseUsage,
     span,
     startTime
   } = args;
@@ -14803,14 +15715,43 @@ function patchAISDKStreamingResult(args) {
   const resultRecord = result;
   attachKnownResultPromiseHandlers(resultRecord);
   let finalized = false;
-  const finalize = () => {
+  const finalize = (outcome) => {
     if (finalized) {
       return;
     }
     finalized = true;
-    finalizeAISDKChildTracing(endEvent);
-    span.end();
-    onComplete?.();
+    try {
+      finalizeAISDKChildTracing(endEvent);
+    } catch (error) {
+      debugLogger.error("Error finalizing AI SDK child tracing:", error);
+    }
+    try {
+      span.end();
+    } catch (error) {
+      debugLogger.error("Error ending AI SDK streaming span:", error);
+    }
+    if (outcome && "error" in outcome) {
+      try {
+        onError?.(outcome.error);
+      } catch (error) {
+        debugLogger.error("Error in AI SDK streaming error hook:", error);
+      }
+    } else if (outcome) {
+      try {
+        onComplete?.(outcome);
+      } catch (error) {
+        debugLogger.error("Error in AI SDK streaming completion hook:", error);
+      }
+    } else {
+      try {
+        onCancel?.();
+      } catch (error) {
+        debugLogger.error(
+          "Error in AI SDK streaming cancellation hook:",
+          error
+        );
+      }
+    }
   };
   let outputLogged = false;
   const logStreamingOutput = async (firstChunkTime) => {
@@ -14820,6 +15761,22 @@ function patchAISDKStreamingResult(args) {
     outputLogged = true;
     try {
       const metrics = extractTopLevelAISDKMetrics(result, endEvent);
+      if (resolvePromiseUsage) {
+        try {
+          const resultRecord2 = result;
+          const pendingUsage = resultRecord2.totalUsage ?? resultRecord2.usage;
+          if (isPromiseLike(pendingUsage)) {
+            const usage = await Promise.resolve(pendingUsage);
+            if (isObject(usage)) {
+              Object.assign(
+                metrics,
+                extractTokenMetrics({ usage })
+              );
+            }
+          }
+        } catch {
+        }
+      }
       if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
         metrics.time_to_first_token = firstChunkTime - startTime;
       }
@@ -14828,15 +15785,29 @@ function patchAISDKStreamingResult(args) {
         resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
       );
       const metadata = buildResolvedMetadataPayload(result).metadata;
-      span.log({
-        output,
-        ...metadata ? { metadata } : {},
-        metrics
-      });
+      try {
+        span.log({
+          output,
+          ...metadata ? { metadata } : {},
+          metrics
+        });
+      } catch (error) {
+        debugLogger.error("Error logging AI SDK streaming output:", error);
+      }
+      finalize({ metrics, output });
     } catch (error) {
-      span.log({ error: toLoggedError(error) });
-    } finally {
-      finalize();
+      const loggedError = toLoggedError(error);
+      try {
+        span.log({ error: loggedError });
+      } catch (loggingError) {
+        debugLogger.error(
+          "Error logging AI SDK streaming failure:",
+          loggingError
+        );
+      }
+      finalize({
+        error: error instanceof Error ? error : new Error(String(loggedError))
+      });
     }
   };
   const createAsyncIterableHooks = () => {
@@ -14853,11 +15824,16 @@ function patchAISDKStreamingResult(args) {
       onError: (error) => {
         if (!outputLogged) {
           outputLogged = true;
-          span.log({
-            error: error.message
-          });
+          try {
+            span.log({ error });
+          } catch (loggingError) {
+            debugLogger.error(
+              "Error logging AI SDK stream failure:",
+              loggingError
+            );
+          }
         }
-        finalize();
+        finalize({ error });
       },
       onCancel: finalize
     };
@@ -14943,8 +15919,18 @@ function patchAISDKStreamingResult(args) {
           }
           controller.enqueue(value);
         } catch (error) {
-          span.log({ error: toLoggedError(error) });
-          finalize();
+          const loggedError = toLoggedError(error);
+          try {
+            span.log({ error: loggedError });
+          } catch (loggingError) {
+            debugLogger.error(
+              "Error logging AI SDK base stream failure:",
+              loggingError
+            );
+          }
+          finalize({
+            error: error instanceof Error ? error : new Error(String(loggedError))
+          });
           controller.error(error);
         }
       },
@@ -15733,7 +16719,8 @@ var claudeAgentSDKChannels = defineChannels(
       channelName: "query",
       kind: "sync-stream"
     })
-  }
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK }
 );
 
 // src/instrumentation/plugins/claude-agent-sdk-instrumentation-constants.ts
@@ -15881,22 +16868,27 @@ function wrapLocalClaudeToolHandler(handler, getMetadata) {
     const spanName = metadata.serverName ? `tool: ${metadata.serverName}/${metadata.toolName}` : `tool: ${metadata.toolName}`;
     const runWithResolvedParent = async () => {
       const parent = toolUseId && localToolParentResolver ? await localToolParentResolver(toolUseId).catch(() => void 0) : void 0;
-      const span = startSpan({
-        event: {
-          input: handlerArgs[0],
-          metadata: {
-            "claude_agent_sdk.raw_tool_name": rawToolName,
-            "gen_ai.tool.name": metadata.toolName,
-            ...toolUseId && { "gen_ai.tool.call.id": toolUseId },
-            ...metadata.serverName && {
-              "mcp.server": metadata.serverName
-            }
-          }
-        },
-        name: spanName,
-        ...parent && { parent },
-        spanAttributes: { type: "tool" /* TOOL */ }
-      });
+      const span = startSpan(
+        withSpanInstrumentationName(
+          {
+            event: {
+              input: handlerArgs[0],
+              metadata: {
+                "claude_agent_sdk.raw_tool_name": rawToolName,
+                "gen_ai.tool.name": metadata.toolName,
+                ...toolUseId && { "gen_ai.tool.call.id": toolUseId },
+                ...metadata.serverName && {
+                  "mcp.server": metadata.serverName
+                }
+              }
+            },
+            name: spanName,
+            ...parent && { parent },
+            spanAttributes: { type: "tool" /* TOOL */ }
+          },
+          INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+        )
+      );
       const runHandler = () => Reflect.apply(handler, this, handlerArgs);
       const finalizeSuccess = (result) => {
         span.log({ output: result });
@@ -16221,14 +17213,19 @@ async function createLLMSpanForMessages(messages, promptMessages, conversationHi
   ).filter(
     (c) => c !== void 0
   );
-  const span = existingSpan ?? startSpan({
-    name: "anthropic.messages.create",
-    parent: parentSpan,
-    spanAttributes: {
-      type: "llm" /* LLM */
-    },
-    startTime
-  });
+  const span = existingSpan ?? startSpan(
+    withSpanInstrumentationName(
+      {
+        name: "anthropic.messages.create",
+        parent: parentSpan,
+        spanAttributes: {
+          type: "llm" /* LLM */
+        },
+        startTime
+      },
+      INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+    )
+  );
   span.log({
     input,
     metadata: model ? { model } : void 0,
@@ -16331,25 +17328,30 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
       return {};
     }
     const parsed = parseToolName(input.tool_name);
-    const toolSpan = startSpan({
-      event: {
-        input: input.tool_input,
-        metadata: {
-          "claude_agent_sdk.cwd": input.cwd,
-          "claude_agent_sdk.raw_tool_name": parsed.rawToolName,
-          "claude_agent_sdk.session_id": input.session_id,
-          "gen_ai.tool.call.id": toolUseID,
-          "gen_ai.tool.name": parsed.toolName,
-          ...parsed.mcpServer && { "mcp.server": parsed.mcpServer },
-          ...getMcpServerMetadata(parsed.mcpServer, mcpServers)
-        }
-      },
-      name: parsed.displayName,
-      parent: await resolveParentSpan(toolUseID, {
-        agentId: input.agent_id
-      }),
-      spanAttributes: { type: "tool" /* TOOL */ }
-    });
+    const toolSpan = startSpan(
+      withSpanInstrumentationName(
+        {
+          event: {
+            input: input.tool_input,
+            metadata: {
+              "claude_agent_sdk.cwd": input.cwd,
+              "claude_agent_sdk.raw_tool_name": parsed.rawToolName,
+              "claude_agent_sdk.session_id": input.session_id,
+              "gen_ai.tool.call.id": toolUseID,
+              "gen_ai.tool.name": parsed.toolName,
+              ...parsed.mcpServer && { "mcp.server": parsed.mcpServer },
+              ...getMcpServerMetadata(parsed.mcpServer, mcpServers)
+            }
+          },
+          name: parsed.displayName,
+          parent: await resolveParentSpan(toolUseID, {
+            agentId: input.agent_id
+          }),
+          spanAttributes: { type: "tool" /* TOOL */ }
+        },
+        INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+      )
+    );
     activeToolSpans.set(toolUseID, toolSpan);
     return {};
   };
@@ -16715,14 +17717,19 @@ async function ensureSubAgentSpan(subAgentDetailsByToolUseId, rootSpan, activeTo
   const spanName = formatSubAgentSpanName(details);
   const parentToolSpan = activeToolSpans.get(parentToolUseId);
   const parentSpan = parentToolSpan ? await parentToolSpan.export() : await rootSpan.export();
-  const subAgentSpan = startSpan({
-    event: {
-      metadata: subAgentDetailsToMetadata(details)
-    },
-    name: spanName,
-    parent: parentSpan,
-    spanAttributes: { type: "task" /* TASK */ }
-  });
+  const subAgentSpan = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          metadata: subAgentDetailsToMetadata(details)
+        },
+        name: spanName,
+        parent: parentSpan,
+        spanAttributes: { type: "task" /* TASK */ }
+      },
+      INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+    )
+  );
   subAgentSpans.set(parentToolUseId, subAgentSpan);
   return subAgentSpan;
 }
@@ -16743,14 +17750,19 @@ async function ensureActiveLlmSpanForParentToolUse(rootSpan, activeLlmSpansByPar
     );
     llmParentSpan = await subAgentSpan.export();
   }
-  const llmSpan = startSpan({
-    name: "anthropic.messages.create",
-    parent: llmParentSpan,
-    spanAttributes: {
-      type: "llm" /* LLM */
-    },
-    startTime
-  });
+  const llmSpan = startSpan(
+    withSpanInstrumentationName(
+      {
+        name: "anthropic.messages.create",
+        parent: llmParentSpan,
+        spanAttributes: {
+          type: "llm" /* LLM */
+        },
+        startTime
+      },
+      INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+    )
+  );
   activeLlmSpansByParentToolUse.set(parentKey, llmSpan);
   return llmSpan;
 }
@@ -17019,12 +18031,17 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
             }
           })();
         }
-        const span = startSpan({
-          name: "Claude Agent",
-          spanAttributes: {
-            type: "task" /* TASK */
-          }
-        });
+        const span = startSpan(
+          withSpanInstrumentationName(
+            {
+              name: "Claude Agent",
+              spanAttributes: {
+                type: "task" /* TASK */
+              }
+            },
+            INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+          )
+        );
         const startTime = getCurrentUnixTimestamp();
         try {
           span.log({
@@ -17186,27 +18203,31 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
       channel2.unsubscribe(handlers);
     });
   }
-};
-
-// src/instrumentation/plugins/cursor-sdk-channels.ts
-var cursorSDKChannels = defineChannels("@cursor/sdk", {
-  create: channel({
-    channelName: "Agent.create",
-    kind: "async"
-  }),
-  resume: channel({
-    channelName: "Agent.resume",
-    kind: "async"
-  }),
-  prompt: channel({
-    channelName: "Agent.prompt",
-    kind: "async"
-  }),
-  send: channel({
-    channelName: "agent.send",
-    kind: "async"
-  })
-});
+};
+
+// src/instrumentation/plugins/cursor-sdk-channels.ts
+var cursorSDKChannels = defineChannels(
+  "@cursor/sdk",
+  {
+    create: channel({
+      channelName: "Agent.create",
+      kind: "async"
+    }),
+    resume: channel({
+      channelName: "Agent.resume",
+      kind: "async"
+    }),
+    prompt: channel({
+      channelName: "Agent.prompt",
+      kind: "async"
+    }),
+    send: channel({
+      channelName: "agent.send",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CURSOR_SDK }
+);
 
 // src/instrumentation/plugins/cursor-sdk-plugin.ts
 var PATCHED_AGENT = /* @__PURE__ */ Symbol.for("braintrust.cursor-sdk.auto-patched-agent");
@@ -17258,10 +18279,15 @@ var CursorSDKPlugin = class extends BasePlugin {
           provider: "cursor",
           ...event.moduleVersion ? { "cursor_sdk.version": event.moduleVersion } : {}
         };
-        const span = startSpan({
-          name: "Cursor Agent",
-          spanAttributes: { type: "task" /* TASK */ }
-        });
+        const span = startSpan(
+          withSpanInstrumentationName(
+            {
+              name: "Cursor Agent",
+              spanAttributes: { type: "task" /* TASK */ }
+            },
+            INSTRUMENTATION_NAMES.CURSOR_SDK
+          )
+        );
         const startTime = getCurrentUnixTimestamp();
         safeLog2(span, {
           input: sanitizeUserMessage(message),
@@ -17323,10 +18349,15 @@ var CursorSDKPlugin = class extends BasePlugin {
           provider: "cursor",
           ...event.moduleVersion ? { "cursor_sdk.version": event.moduleVersion } : {}
         };
-        const span = startSpan({
-          name: "Cursor Agent",
-          spanAttributes: { type: "task" /* TASK */ }
-        });
+        const span = startSpan(
+          withSpanInstrumentationName(
+            {
+              name: "Cursor Agent",
+              spanAttributes: { type: "task" /* TASK */ }
+            },
+            INSTRUMENTATION_NAMES.CURSOR_SDK
+          )
+        );
         const startTime = getCurrentUnixTimestamp();
         safeLog2(span, {
           input: sanitizeUserMessage(message),
@@ -17773,29 +18804,39 @@ async function startToolSpan(state, args) {
   if (args.truncated?.result !== void 0) {
     metadata["cursor_sdk.tool.result_truncated"] = args.truncated.result;
   }
-  const span = startSpan({
-    event: {
-      input: args.args,
-      metadata
-    },
-    name: `tool: ${name}`,
-    parent: await state.span.export(),
-    spanAttributes: { type: "tool" /* TOOL */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          input: args.args,
+          metadata
+        },
+        name: `tool: ${name}`,
+        parent: await state.span.export(),
+        spanAttributes: { type: "tool" /* TOOL */ }
+      },
+      INSTRUMENTATION_NAMES.CURSOR_SDK
+    )
+  );
   let subAgentSpan;
   if (isSubAgentToolName(name)) {
-    subAgentSpan = startSpan({
-      event: {
-        input: args.args,
-        metadata: {
-          "cursor_sdk.subagent.tool_call_id": args.callId,
-          "gen_ai.tool.name": name
-        }
-      },
-      name: formatSubAgentSpanName2(args.toolCall, args.args),
-      parent: await span.export(),
-      spanAttributes: { type: "task" /* TASK */ }
-    });
+    subAgentSpan = startSpan(
+      withSpanInstrumentationName(
+        {
+          event: {
+            input: args.args,
+            metadata: {
+              "cursor_sdk.subagent.tool_call_id": args.callId,
+              "gen_ai.tool.name": name
+            }
+          },
+          name: formatSubAgentSpanName2(args.toolCall, args.args),
+          parent: await span.export(),
+          spanAttributes: { type: "task" /* TASK */ }
+        },
+        INSTRUMENTATION_NAMES.CURSOR_SDK
+      )
+    );
   }
   return { span, subAgentSpan };
 }
@@ -18054,24 +19095,28 @@ function cleanMetrics2(metrics) {
 }
 
 // src/instrumentation/plugins/openai-agents-channels.ts
-var openAIAgentsCoreChannels = defineChannels("@openai/agents-core", {
-  onTraceStart: channel({
-    channelName: "tracing.processor.onTraceStart",
-    kind: "async"
-  }),
-  onTraceEnd: channel({
-    channelName: "tracing.processor.onTraceEnd",
-    kind: "async"
-  }),
-  onSpanStart: channel({
-    channelName: "tracing.processor.onSpanStart",
-    kind: "async"
-  }),
-  onSpanEnd: channel({
-    channelName: "tracing.processor.onSpanEnd",
-    kind: "async"
-  })
-});
+var openAIAgentsCoreChannels = defineChannels(
+  "@openai/agents-core",
+  {
+    onTraceStart: channel({
+      channelName: "tracing.processor.onTraceStart",
+      kind: "async"
+    }),
+    onTraceEnd: channel({
+      channelName: "tracing.processor.onTraceEnd",
+      kind: "async"
+    }),
+    onSpanStart: channel({
+      channelName: "tracing.processor.onSpanStart",
+      kind: "async"
+    }),
+    onSpanEnd: channel({
+      channelName: "tracing.processor.onSpanEnd",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OPENAI_AGENTS }
+);
 
 // src/instrumentation/plugins/openai-agents-trace-processor.ts
 function isSpanData(spanData, type) {
@@ -18187,16 +19232,19 @@ var OpenAIAgentsTraceProcessor = class _OpenAIAgentsTraceProcessor {
       this.evictOldestTrace();
     }
     const current = currentSpan();
-    const span = current && current !== NOOP_SPAN ? current.startSpan({
-      name: trace.name,
-      type: "task" /* TASK */
-    }) : this.logger ? this.logger.startSpan({
-      name: trace.name,
-      type: "task" /* TASK */
-    }) : startSpan({
-      name: trace.name,
-      type: "task" /* TASK */
-    });
+    const spanArgs = withSpanInstrumentationName(
+      {
+        name: trace.name,
+        type: "task" /* TASK */
+      },
+      INSTRUMENTATION_NAMES.OPENAI_AGENTS
+    );
+    const span = current && current !== NOOP_SPAN ? current.startSpan(spanArgs) : this.logger ? this.logger.startSpan(spanArgs) : startSpan(
+      withSpanInstrumentationName(
+        spanArgs,
+        INSTRUMENTATION_NAMES.OPENAI_AGENTS
+      )
+    );
     span.log({
       input: "Agent workflow started",
       metadata: {
@@ -18247,10 +19295,15 @@ var OpenAIAgentsTraceProcessor = class _OpenAIAgentsTraceProcessor {
     if (!parentSpan) {
       return Promise.resolve();
     }
-    const childSpan = parentSpan.startSpan({
-      name: spanNameFromAgents(span),
-      type: spanTypeFromAgents(span)
-    });
+    const childSpan = parentSpan.startSpan(
+      withSpanInstrumentationName(
+        {
+          name: spanNameFromAgents(span),
+          type: spanTypeFromAgents(span)
+        },
+        INSTRUMENTATION_NAMES.OPENAI_AGENTS
+      )
+    );
     traceData.childSpans.set(span.spanId, childSpan);
     return Promise.resolve();
   }
@@ -18515,24 +19568,28 @@ var OpenAIAgentsPlugin = class extends BasePlugin {
 };
 
 // src/instrumentation/plugins/google-genai-channels.ts
-var googleGenAIChannels = defineChannels("@google/genai", {
-  generateContent: channel({
-    channelName: "models.generateContent",
-    kind: "async"
-  }),
-  generateContentStream: channel({
-    channelName: "models.generateContentStream",
-    kind: "async"
-  }),
-  embedContent: channel({
-    channelName: "models.embedContent",
-    kind: "async"
-  }),
-  interactionsCreate: channel({
-    channelName: "interactions.create",
-    kind: "async"
-  })
-});
+var googleGenAIChannels = defineChannels(
+  "@google/genai",
+  {
+    generateContent: channel({
+      channelName: "models.generateContent",
+      kind: "async"
+    }),
+    generateContentStream: channel({
+      channelName: "models.generateContentStream",
+      kind: "async"
+    }),
+    embedContent: channel({
+      channelName: "models.embedContent",
+      kind: "async"
+    }),
+    interactionsCreate: channel({
+      channelName: "interactions.create",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.GOOGLE_GENAI }
+);
 
 // src/instrumentation/plugins/google-genai-plugin.ts
 var GOOGLE_GENAI_INTERNAL_CONTEXT = {
@@ -18570,13 +19627,18 @@ var GoogleGenAIPlugin = class extends BasePlugin {
         const params = event.arguments[0];
         const input = serializeGenerateContentInput(params);
         const metadata = extractGenerateContentMetadata(params);
-        const span = startSpan({
-          name: "generate_content",
-          spanAttributes: {
-            type: "llm" /* LLM */
-          },
-          event: createWrapperParityEvent({ input, metadata })
-        });
+        const span = startSpan(
+          withSpanInstrumentationName(
+            {
+              name: "generate_content",
+              spanAttributes: {
+                type: "llm" /* LLM */
+              },
+              event: createWrapperParityEvent({ input, metadata })
+            },
+            INSTRUMENTATION_NAMES.GOOGLE_GENAI
+          )
+        );
         return {
           span,
           startTime: getCurrentUnixTimestamp()
@@ -18589,13 +19651,18 @@ var GoogleGenAIPlugin = class extends BasePlugin {
           const params = event.arguments[0];
           const input = serializeGenerateContentInput(params);
           const metadata = extractGenerateContentMetadata(params);
-          const span = startSpan({
-            name: "generate_content",
-            spanAttributes: {
-              type: "llm" /* LLM */
-            },
-            event: createWrapperParityEvent({ input, metadata })
-          });
+          const span = startSpan(
+            withSpanInstrumentationName(
+              {
+                name: "generate_content",
+                spanAttributes: {
+                  type: "llm" /* LLM */
+                },
+                event: createWrapperParityEvent({ input, metadata })
+              },
+              INSTRUMENTATION_NAMES.GOOGLE_GENAI
+            )
+          );
           return {
             span,
             startTime: getCurrentUnixTimestamp()
@@ -18671,13 +19738,18 @@ var GoogleGenAIPlugin = class extends BasePlugin {
         const params = event.arguments[0];
         const input = serializeEmbedContentInput(params);
         const metadata = extractEmbedContentMetadata(params);
-        const span = startSpan({
-          name: "embed_content",
-          spanAttributes: {
-            type: "llm" /* LLM */
-          },
-          event: createWrapperParityEvent({ input, metadata })
-        });
+        const span = startSpan(
+          withSpanInstrumentationName(
+            {
+              name: "embed_content",
+              spanAttributes: {
+                type: "llm" /* LLM */
+              },
+              event: createWrapperParityEvent({ input, metadata })
+            },
+            INSTRUMENTATION_NAMES.GOOGLE_GENAI
+          )
+        );
         return {
           span,
           startTime: getCurrentUnixTimestamp()
@@ -18690,13 +19762,18 @@ var GoogleGenAIPlugin = class extends BasePlugin {
           const params = event.arguments[0];
           const input = serializeEmbedContentInput(params);
           const metadata = extractEmbedContentMetadata(params);
-          const span = startSpan({
-            name: "embed_content",
-            spanAttributes: {
-              type: "llm" /* LLM */
-            },
-            event: createWrapperParityEvent({ input, metadata })
-          });
+          const span = startSpan(
+            withSpanInstrumentationName(
+              {
+                name: "embed_content",
+                spanAttributes: {
+                  type: "llm" /* LLM */
+                },
+                event: createWrapperParityEvent({ input, metadata })
+              },
+              INSTRUMENTATION_NAMES.GOOGLE_GENAI
+            )
+          );
           return {
             span,
             startTime: getCurrentUnixTimestamp()
@@ -18807,16 +19884,21 @@ function patchGoogleGenAIStreamingResult(args) {
   const requestStartTime = startTime ?? getCurrentUnixTimestamp();
   const ensureSpan = () => {
     if (!span) {
-      span = startSpan({
-        name: "generate_content_stream",
-        spanAttributes: {
-          type: "llm" /* LLM */
-        },
-        event: {
-          input,
-          metadata
-        }
-      });
+      span = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: "generate_content_stream",
+            spanAttributes: {
+              type: "llm" /* LLM */
+            },
+            event: {
+              input,
+              metadata
+            }
+          },
+          INSTRUMENTATION_NAMES.GOOGLE_GENAI
+        )
+      );
     }
     return span;
   };
@@ -19584,28 +20666,32 @@ function tryToDict(obj) {
 }
 
 // src/instrumentation/plugins/huggingface-channels.ts
-var huggingFaceChannels = defineChannels("@huggingface/inference", {
-  chatCompletion: channel({
-    channelName: "chatCompletion",
-    kind: "async"
-  }),
-  chatCompletionStream: channel({
-    channelName: "chatCompletionStream",
-    kind: "sync-stream"
-  }),
-  textGeneration: channel({
-    channelName: "textGeneration",
-    kind: "async"
-  }),
-  textGenerationStream: channel({
-    channelName: "textGenerationStream",
-    kind: "sync-stream"
-  }),
-  featureExtraction: channel({
-    channelName: "featureExtraction",
-    kind: "async"
-  })
-});
+var huggingFaceChannels = defineChannels(
+  "@huggingface/inference",
+  {
+    chatCompletion: channel({
+      channelName: "chatCompletion",
+      kind: "async"
+    }),
+    chatCompletionStream: channel({
+      channelName: "chatCompletionStream",
+      kind: "sync-stream"
+    }),
+    textGeneration: channel({
+      channelName: "textGeneration",
+      kind: "async"
+    }),
+    textGenerationStream: channel({
+      channelName: "textGenerationStream",
+      kind: "sync-stream"
+    }),
+    featureExtraction: channel({
+      channelName: "featureExtraction",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.HUGGINGFACE }
+);
 
 // src/instrumentation/plugins/huggingface-plugin.ts
 var REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
@@ -20032,20 +21118,24 @@ function extractTextGenerationStreamMetadata(chunks) {
 }
 
 // src/instrumentation/plugins/openrouter-agent-channels.ts
-var openRouterAgentChannels = defineChannels("@openrouter/agent", {
-  callModel: channel({
-    channelName: "callModel",
-    kind: "sync-stream"
-  }),
-  callModelTurn: channel({
-    channelName: "callModel.turn",
-    kind: "async"
-  }),
-  toolExecute: channel({
-    channelName: "tool.execute",
-    kind: "async"
-  })
-});
+var openRouterAgentChannels = defineChannels(
+  "@openrouter/agent",
+  {
+    callModel: channel({
+      channelName: "callModel",
+      kind: "sync-stream"
+    }),
+    callModelTurn: channel({
+      channelName: "callModel.turn",
+      kind: "async"
+    }),
+    toolExecute: channel({
+      channelName: "tool.execute",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OPENROUTER_AGENT }
+);
 
 // src/instrumentation/plugins/openrouter-agent-plugin.ts
 var OpenRouterAgentPlugin = class extends BasePlugin {
@@ -20815,38 +21905,40 @@ function normalizeError(error) {
 }
 
 // src/instrumentation/plugins/openrouter-channels.ts
-var openRouterChannels = defineChannels("@openrouter/sdk", {
-  chatSend: channel({
-    channelName: "chat.send",
-    kind: "async"
-  }),
-  embeddingsGenerate: channel({
-    channelName: "embeddings.generate",
-    kind: "async"
-  }),
-  rerankRerank: channel(
-    {
+var openRouterChannels = defineChannels(
+  "@openrouter/sdk",
+  {
+    chatSend: channel({
+      channelName: "chat.send",
+      kind: "async"
+    }),
+    embeddingsGenerate: channel({
+      channelName: "embeddings.generate",
+      kind: "async"
+    }),
+    rerankRerank: channel({
       channelName: "rerank.rerank",
       kind: "async"
-    }
-  ),
-  betaResponsesSend: channel({
-    channelName: "beta.responses.send",
-    kind: "async"
-  }),
-  callModel: channel({
-    channelName: "callModel",
-    kind: "sync-stream"
-  }),
-  callModelTurn: channel({
-    channelName: "callModel.turn",
-    kind: "async"
-  }),
-  toolExecute: channel({
-    channelName: "tool.execute",
-    kind: "async"
-  })
-});
+    }),
+    betaResponsesSend: channel({
+      channelName: "beta.responses.send",
+      kind: "async"
+    }),
+    callModel: channel({
+      channelName: "callModel",
+      kind: "sync-stream"
+    }),
+    callModelTurn: channel({
+      channelName: "callModel.turn",
+      kind: "async"
+    }),
+    toolExecute: channel({
+      channelName: "tool.execute",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OPENROUTER }
+);
 
 // src/instrumentation/plugins/openrouter-plugin.ts
 var OpenRouterPlugin = class extends BasePlugin {
@@ -21886,52 +22978,56 @@ function normalizeError2(error) {
 }
 
 // src/instrumentation/plugins/mistral-channels.ts
-var mistralChannels = defineChannels("@mistralai/mistralai", {
-  chatComplete: channel({
-    channelName: "chat.complete",
-    kind: "async"
-  }),
-  chatStream: channel({
-    channelName: "chat.stream",
-    kind: "async"
-  }),
-  embeddingsCreate: channel({
-    channelName: "embeddings.create",
-    kind: "async"
-  }),
-  classifiersModerate: channel({
-    channelName: "classifiers.moderate",
-    kind: "async"
-  }),
-  classifiersModerateChat: channel({
-    channelName: "classifiers.moderateChat",
-    kind: "async"
-  }),
-  classifiersClassify: channel({
-    channelName: "classifiers.classify",
-    kind: "async"
-  }),
-  classifiersClassifyChat: channel({
-    channelName: "classifiers.classifyChat",
-    kind: "async"
-  }),
-  fimComplete: channel({
-    channelName: "fim.complete",
-    kind: "async"
-  }),
-  fimStream: channel({
-    channelName: "fim.stream",
-    kind: "async"
-  }),
-  agentsComplete: channel({
-    channelName: "agents.complete",
-    kind: "async"
-  }),
-  agentsStream: channel({
-    channelName: "agents.stream",
-    kind: "async"
-  })
-});
+var mistralChannels = defineChannels(
+  "@mistralai/mistralai",
+  {
+    chatComplete: channel({
+      channelName: "chat.complete",
+      kind: "async"
+    }),
+    chatStream: channel({
+      channelName: "chat.stream",
+      kind: "async"
+    }),
+    embeddingsCreate: channel({
+      channelName: "embeddings.create",
+      kind: "async"
+    }),
+    classifiersModerate: channel({
+      channelName: "classifiers.moderate",
+      kind: "async"
+    }),
+    classifiersModerateChat: channel({
+      channelName: "classifiers.moderateChat",
+      kind: "async"
+    }),
+    classifiersClassify: channel({
+      channelName: "classifiers.classify",
+      kind: "async"
+    }),
+    classifiersClassifyChat: channel({
+      channelName: "classifiers.classifyChat",
+      kind: "async"
+    }),
+    fimComplete: channel({
+      channelName: "fim.complete",
+      kind: "async"
+    }),
+    fimStream: channel({
+      channelName: "fim.stream",
+      kind: "async"
+    }),
+    agentsComplete: channel({
+      channelName: "agents.complete",
+      kind: "async"
+    }),
+    agentsStream: channel({
+      channelName: "agents.stream",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.MISTRAL }
+);
 
 // src/instrumentation/plugins/mistral-plugin.ts
 var MistralPlugin = class extends BasePlugin {
@@ -22551,20 +23647,24 @@ function aggregateMistralStreamChunks(chunks) {
 }
 
 // src/instrumentation/plugins/google-adk-channels.ts
-var googleADKChannels = defineChannels("@google/adk", {
-  runnerRunAsync: channel({
-    channelName: "runner.runAsync",
-    kind: "sync-stream"
-  }),
-  agentRunAsync: channel({
-    channelName: "agent.runAsync",
-    kind: "sync-stream"
-  }),
-  toolRunAsync: channel({
-    channelName: "tool.runAsync",
-    kind: "async"
-  })
-});
+var googleADKChannels = defineChannels(
+  "@google/adk",
+  {
+    runnerRunAsync: channel({
+      channelName: "runner.runAsync",
+      kind: "sync-stream"
+    }),
+    agentRunAsync: channel({
+      channelName: "agent.runAsync",
+      kind: "sync-stream"
+    }),
+    toolRunAsync: channel({
+      channelName: "tool.runAsync",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.GOOGLE_ADK }
+);
 
 // src/instrumentation/plugins/google-adk-plugin.ts
 var GoogleADKPlugin = class extends BasePlugin {
@@ -22589,12 +23689,17 @@ var GoogleADKPlugin = class extends BasePlugin {
     const createState = (event) => {
       const params = event.arguments[0] ?? {};
       const contextKey = extractRunnerContextKey(params);
-      const span = startSpan({
-        name: "Google ADK Runner",
-        spanAttributes: {
-          type: "task" /* TASK */
-        }
-      });
+      const span = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: "Google ADK Runner",
+            spanAttributes: {
+              type: "task" /* TASK */
+            }
+          },
+          INSTRUMENTATION_NAMES.GOOGLE_ADK
+        )
+      );
       const startTime = getCurrentUnixTimestamp();
       try {
         const metadata = extractRunnerMetadata(params);
@@ -22680,18 +23785,23 @@ var GoogleADKPlugin = class extends BasePlugin {
         this.activeRunnerSpans
       );
       const contextKey = extractInvocationContextKey(parentContext);
-      const span = startSpan({
-        name: agentName ? `Agent: ${agentName}` : "Google ADK Agent",
-        spanAttributes: {
-          type: "task" /* TASK */
-        },
-        ...runnerParentSpan ? {
-          parentSpanIds: {
-            spanId: runnerParentSpan.spanId,
-            rootSpanId: runnerParentSpan.rootSpanId
-          }
-        } : {}
-      });
+      const span = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: agentName ? `Agent: ${agentName}` : "Google ADK Agent",
+            spanAttributes: {
+              type: "task" /* TASK */
+            },
+            ...runnerParentSpan ? {
+              parentSpanIds: {
+                spanId: runnerParentSpan.spanId,
+                rootSpanId: runnerParentSpan.rootSpanId
+              }
+            } : {}
+          },
+          INSTRUMENTATION_NAMES.GOOGLE_ADK
+        )
+      );
       const startTime = getCurrentUnixTimestamp();
       try {
         const metadata = {
@@ -22784,22 +23894,27 @@ var GoogleADKPlugin = class extends BasePlugin {
           this.activeAgentSpans,
           this.activeRunnerSpans
         );
-        const createSpan = () => startSpan({
-          name: toolName ? `tool: ${toolName}` : "Google ADK Tool",
-          spanAttributes: {
-            type: "tool" /* TOOL */
-          },
-          event: {
-            input: req.args,
-            metadata: {
-              provider: "google-adk",
-              ...toolName && { "google_adk.tool_name": toolName },
-              ...extractToolCallId(req) && {
-                "google_adk.tool_call_id": extractToolCallId(req)
+        const createSpan = () => startSpan(
+          withSpanInstrumentationName(
+            {
+              name: toolName ? `tool: ${toolName}` : "Google ADK Tool",
+              spanAttributes: {
+                type: "tool" /* TOOL */
+              },
+              event: {
+                input: req.args,
+                metadata: {
+                  provider: "google-adk",
+                  ...toolName && { "google_adk.tool_name": toolName },
+                  ...extractToolCallId(req) && {
+                    "google_adk.tool_call_id": extractToolCallId(req)
+                  }
+                }
               }
-            }
-          }
-        });
+            },
+            INSTRUMENTATION_NAMES.GOOGLE_ADK
+          )
+        );
         const span = parentSpan ? withCurrent(parentSpan, () => createSpan()) : createSpan();
         const startTime = getCurrentUnixTimestamp();
         states.set(event, { span, startTime });
@@ -23198,24 +24313,28 @@ function cleanMetrics4(metrics) {
 }
 
 // src/instrumentation/plugins/cohere-channels.ts
-var cohereChannels = defineChannels("cohere-ai", {
-  chat: channel({
-    channelName: "chat",
-    kind: "async"
-  }),
-  chatStream: channel({
-    channelName: "chatStream",
-    kind: "async"
-  }),
-  embed: channel({
-    channelName: "embed",
-    kind: "async"
-  }),
-  rerank: channel({
-    channelName: "rerank",
-    kind: "async"
-  })
-});
+var cohereChannels = defineChannels(
+  "cohere-ai",
+  {
+    chat: channel({
+      channelName: "chat",
+      kind: "async"
+    }),
+    chatStream: channel({
+      channelName: "chatStream",
+      kind: "async"
+    }),
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    }),
+    rerank: channel({
+      channelName: "rerank",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.COHERE }
+);
 
 // src/instrumentation/plugins/cohere-plugin.ts
 var CoherePlugin = class extends BasePlugin {
@@ -23884,18 +25003,20 @@ function aggregateCohereChatStreamChunks(chunks) {
 }
 
 // src/instrumentation/plugins/groq-channels.ts
-var groqChannels = defineChannels("groq-sdk", {
-  chatCompletionsCreate: channel({
-    channelName: "chat.completions.create",
-    kind: "async"
-  }),
-  embeddingsCreate: channel(
-    {
+var groqChannels = defineChannels(
+  "groq-sdk",
+  {
+    chatCompletionsCreate: channel({
+      channelName: "chat.completions.create",
+      kind: "async"
+    }),
+    embeddingsCreate: channel({
       channelName: "embeddings.create",
       kind: "async"
-    }
-  )
-});
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.GROQ }
+);
 
 // src/instrumentation/plugins/groq-plugin.ts
 var GroqPlugin = class extends BasePlugin {
@@ -23998,15 +25119,27 @@ 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
-});
+var bedrockRuntimeChannels = defineChannels(
+  "aws-bedrock-runtime",
+  {
+    clientSend: clientSendChannel
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.BEDROCK_RUNTIME }
+);
+var smithyCoreChannels = defineChannels(
+  "@smithy/core",
+  {
+    clientSend: clientSendChannel
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.BEDROCK_RUNTIME }
+);
+var smithyClientChannels = defineChannels(
+  "@smithy/smithy-client",
+  {
+    clientSend: clientSendChannel
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.BEDROCK_RUNTIME }
+);
 
 // src/instrumentation/plugins/bedrock-runtime-common.ts
 var BEDROCK_RUNTIME_COMMAND_OPERATIONS = {
@@ -24640,38 +25773,46 @@ function extractTextFromJsonLike(value) {
 }
 
 // src/instrumentation/plugins/genkit-channels.ts
-var genkitChannels = defineChannels("@genkit-ai/ai", {
-  generate: channel({
-    channelName: "generate",
-    kind: "async"
-  }),
-  generateStream: channel({
-    channelName: "generateStream",
-    kind: "sync-stream"
-  }),
-  embed: channel({
-    channelName: "embed",
-    kind: "async"
-  }),
-  embedMany: channel({
-    channelName: "embedMany",
-    kind: "async"
-  }),
-  actionRun: channel({
-    channelName: "action.run",
-    kind: "async"
-  }),
-  actionStream: channel({
-    channelName: "action.stream",
-    kind: "sync-stream"
-  })
-});
-var genkitCoreChannels = defineChannels("@genkit-ai/core", {
-  actionSpan: channel({
-    channelName: "action.span",
-    kind: "async"
-  })
-});
+var genkitChannels = defineChannels(
+  "@genkit-ai/ai",
+  {
+    generate: channel({
+      channelName: "generate",
+      kind: "async"
+    }),
+    generateStream: channel({
+      channelName: "generateStream",
+      kind: "sync-stream"
+    }),
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    }),
+    embedMany: channel({
+      channelName: "embedMany",
+      kind: "async"
+    }),
+    actionRun: channel({
+      channelName: "action.run",
+      kind: "async"
+    }),
+    actionStream: channel({
+      channelName: "action.stream",
+      kind: "sync-stream"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.GENKIT }
+);
+var genkitCoreChannels = defineChannels(
+  "@genkit-ai/core",
+  {
+    actionSpan: channel({
+      channelName: "action.span",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.GENKIT }
+);
 
 // src/instrumentation/plugins/genkit-plugin.ts
 var GenkitPlugin = class extends BasePlugin {
@@ -24856,12 +25997,17 @@ function startActionSpanState(args) {
   if (!shouldTraceAction(args.metadata, args.runStepName)) {
     return void 0;
   }
-  const span = startSpan({
-    name: actionSpanName(args.metadata, args.runStepName),
-    spanAttributes: {
-      type: actionSpanType(args.metadata)
-    }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        name: actionSpanName(args.metadata, args.runStepName),
+        spanAttributes: {
+          type: actionSpanType(args.metadata)
+        }
+      },
+      INSTRUMENTATION_NAMES.GENKIT
+    )
+  );
   const startTime = getCurrentUnixTimestamp();
   span.log({
     input: args.input,
@@ -25222,20 +26368,24 @@ function stringValue(value) {
 }
 
 // src/instrumentation/plugins/github-copilot-channels.ts
-var gitHubCopilotChannels = defineChannels("@github/copilot-sdk", {
-  createSession: channel({
-    channelName: "client.createSession",
-    kind: "async"
-  }),
-  resumeSession: channel({
-    channelName: "client.resumeSession",
-    kind: "async"
-  }),
-  sendAndWait: channel({
-    channelName: "session.sendAndWait",
-    kind: "async"
-  })
-});
+var gitHubCopilotChannels = defineChannels(
+  "@github/copilot-sdk",
+  {
+    createSession: channel({
+      channelName: "client.createSession",
+      kind: "async"
+    }),
+    resumeSession: channel({
+      channelName: "client.resumeSession",
+      kind: "async"
+    }),
+    sendAndWait: channel({
+      channelName: "session.sendAndWait",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.GITHUB_COPILOT }
+);
 
 // src/instrumentation/plugins/github-copilot-plugin.ts
 var ROOT_AGENT_KEY = "__root__";
@@ -25326,11 +26476,16 @@ async function handleTurnStart(state, agentId) {
     return;
   }
   const parentId = await getParentIdForAgent(state, agentId);
-  const span = startSpan({
-    name: "Copilot Turn",
-    parent: parentId,
-    spanAttributes: { type: "task" /* TASK */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        name: "Copilot Turn",
+        parent: parentId,
+        spanAttributes: { type: "task" /* TASK */ }
+      },
+      INSTRUMENTATION_NAMES.GITHUB_COPILOT
+    )
+  );
   const pendingUserMessage = state.pendingUserMessages.get(key);
   if (pendingUserMessage) {
     span.log({ input: pendingUserMessage });
@@ -25361,11 +26516,16 @@ async function handleUsage(state, agentId, usage) {
   const parentId = turn ? await turn.id : await state.session.id;
   const content = state.currentMessageContent.get(key);
   const { metrics, metadata } = extractMetricsFromUsage(usage);
-  const llmSpan = startSpan({
-    name: "github.copilot.llm",
-    parent: parentId,
-    spanAttributes: { type: "llm" /* LLM */ }
-  });
+  const llmSpan = startSpan(
+    withSpanInstrumentationName(
+      {
+        name: "github.copilot.llm",
+        parent: parentId,
+        spanAttributes: { type: "llm" /* LLM */ }
+      },
+      INSTRUMENTATION_NAMES.GITHUB_COPILOT
+    )
+  );
   llmSpan.log({
     output: content ?? void 0,
     metadata,
@@ -25391,11 +26551,16 @@ async function handleToolStart(state, agentId, toolCallId, toolName, args, mcpSe
   }
   const parentId = await getToolParentId(state, agentId);
   const displayName = mcpServerName ? `tool: ${mcpServerName}/${toolName}` : `tool: ${toolName}`;
-  const span = startSpan({
-    name: displayName,
-    parent: parentId,
-    spanAttributes: { type: "tool" /* TOOL */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        name: displayName,
+        parent: parentId,
+        spanAttributes: { type: "tool" /* TOOL */ }
+      },
+      INSTRUMENTATION_NAMES.GITHUB_COPILOT
+    )
+  );
   const metadata = {
     "gen_ai.tool.name": toolName,
     "gen_ai.tool.call.id": toolCallId
@@ -25431,11 +26596,16 @@ async function handleSubagentStarted(state, agentId, toolCallId, agentDisplayNam
   }
   const tool = state.activeTools.get(toolCallId);
   const parentId = tool ? await tool.id : await state.session.id;
-  const span = startSpan({
-    name: `Agent: ${agentDisplayName}`,
-    parent: parentId,
-    spanAttributes: { type: "task" /* TASK */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        name: `Agent: ${agentDisplayName}`,
+        parent: parentId,
+        spanAttributes: { type: "task" /* TASK */ }
+      },
+      INSTRUMENTATION_NAMES.GITHUB_COPILOT
+    )
+  );
   span.log({
     metadata: {
       "github_copilot.agent_name": agentDisplayName,
@@ -25661,10 +26831,15 @@ function makeSessionHandlers(sessionStates, configArgIndex, includeProviderMetad
       if (!config || typeof config !== "object") {
         return;
       }
-      const sessionSpan = startSpan({
-        name: "Copilot Session",
-        spanAttributes: { type: "task" /* TASK */ }
-      });
+      const sessionSpan = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: "Copilot Session",
+            spanAttributes: { type: "task" /* TASK */ }
+          },
+          INSTRUMENTATION_NAMES.GITHUB_COPILOT
+        )
+      );
       const metadata = {};
       if (config.model) {
         metadata["github_copilot.model"] = config.model;
@@ -25752,12 +26927,16 @@ var GitHubCopilotPlugin = class extends BasePlugin {
 };
 
 // src/instrumentation/plugins/flue-channels.ts
-var flueChannels = defineChannels("@flue/runtime", {
-  createContext: channel({
-    channelName: "createFlueContext",
-    kind: "sync-stream"
-  })
-});
+var flueChannels = defineChannels(
+  "@flue/runtime",
+  {
+    createContext: channel({
+      channelName: "createFlueContext",
+      kind: "sync-stream"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.FLUE }
+);
 
 // src/instrumentation/plugins/flue-plugin.ts
 var FLUE_AUTO_STATE = /* @__PURE__ */ Symbol.for("braintrust.flue.auto-state");
@@ -26100,15 +27279,20 @@ var FlueObserveBridge = class {
       safeLog3(existing.span, { input, metadata });
       return;
     }
-    const span = startSpan({
-      name: `workflow:${workflowName}`,
-      spanAttributes: { type: "task" /* TASK */ },
-      startTime: eventTime(event.startedAt ?? event.timestamp),
-      event: {
-        input,
-        metadata
-      }
-    });
+    const span = startSpan(
+      withSpanInstrumentationName(
+        {
+          name: `workflow:${workflowName}`,
+          spanAttributes: { type: "task" /* TASK */ },
+          startTime: eventTime(event.startedAt ?? event.timestamp),
+          event: {
+            input,
+            metadata
+          }
+        },
+        INSTRUMENTATION_NAMES.FLUE
+      )
+    );
     this.runsById.set(event.runId, { metadata, span });
   }
   handleRunResume(event, ctx) {
@@ -26128,12 +27312,17 @@ var FlueObserveBridge = class {
       safeLog3(existing.span, { metadata });
       return;
     }
-    const span = startSpan({
-      name: `workflow:${workflowName}`,
-      spanAttributes: { type: "task" /* TASK */ },
-      startTime: eventTime(event.startedAt ?? event.timestamp),
-      event: { metadata }
-    });
+    const span = startSpan(
+      withSpanInstrumentationName(
+        {
+          name: `workflow:${workflowName}`,
+          spanAttributes: { type: "task" /* TASK */ },
+          startTime: eventTime(event.startedAt ?? event.timestamp),
+          event: { metadata }
+        },
+        INSTRUMENTATION_NAMES.FLUE
+      )
+    );
     this.runsById.set(event.runId, { metadata, span });
   }
   handleRunEnd(event) {
@@ -26772,7 +27961,14 @@ function stateMatchesRun(state, runId) {
   return state.metadata["flue.run_id"] === runId;
 }
 function startFlueSpan(parent, args) {
-  return parent ? withCurrent(parent, () => startSpan(args)) : startSpan(args);
+  return parent ? withCurrent(
+    parent,
+    () => startSpan(
+      withSpanInstrumentationName(args, INSTRUMENTATION_NAMES.FLUE)
+    )
+  ) : startSpan(
+    withSpanInstrumentationName(args, INSTRUMENTATION_NAMES.FLUE)
+  );
 }
 function runWithCurrentSpanStore(span, next) {
   const state = _internalGetGlobalState();
@@ -26862,9 +28058,13 @@ var BraintrustLangChainCallbackHandler = class {
         ...this.options.debug ? { runId, parentRunId } : {}
       }
     };
-    let span = parentSpan.startSpan(args);
+    const spanArgs = withSpanInstrumentationName(
+      args,
+      INSTRUMENTATION_NAMES.LANGCHAIN
+    );
+    let span = parentSpan.startSpan(spanArgs);
     if (!Object.is(this.options.logger, NOOP_SPAN) && Object.is(span, NOOP_SPAN)) {
-      span = initLogger().startSpan(args);
+      span = initLogger().startSpan(spanArgs);
     }
     this.spans.set(runId, span);
   }
@@ -27077,6 +28277,16 @@ function cleanObject(obj) {
     })
   );
 }
+function normalizeTokenMetrics(obj) {
+  const metrics = cleanObject(obj);
+  if (metrics.total_tokens !== void 0) {
+    metrics.tokens = metrics.total_tokens;
+  } else if (metrics.prompt_tokens !== void 0 && metrics.completion_tokens !== void 0) {
+    metrics.tokens = metrics.prompt_tokens + metrics.completion_tokens;
+  }
+  delete metrics.total_tokens;
+  return metrics;
+}
 function walkGenerations(response) {
   const result = [];
   const generations = response.generations || [];
@@ -27123,7 +28333,7 @@ function getMetricsFromResponse(response) {
       continue;
     }
     const inputTokenDetails = usageMetadata.input_token_details;
-    return cleanObject({
+    return normalizeTokenMetrics({
       total_tokens: usageMetadata.total_tokens,
       prompt_tokens: usageMetadata.input_tokens,
       completion_tokens: usageMetadata.output_tokens,
@@ -27133,7 +28343,7 @@ function getMetricsFromResponse(response) {
   }
   const llmOutput = response.llmOutput || {};
   const tokenUsage = isRecord(llmOutput.tokenUsage) ? llmOutput.tokenUsage : isRecord(llmOutput.estimatedTokens) ? llmOutput.estimatedTokens : {};
-  return cleanObject({
+  return normalizeTokenMetrics({
     total_tokens: tokenUsage.totalTokens,
     prompt_tokens: tokenUsage.promptTokens,
     completion_tokens: tokenUsage.completionTokens
@@ -27151,16 +28361,20 @@ function isRecord(value) {
 }
 
 // src/instrumentation/plugins/langchain-channels.ts
-var langChainChannels = defineChannels("@langchain/core", {
-  configure: channel({
-    channelName: "CallbackManager.configure",
-    kind: "sync-stream"
-  }),
-  configureSync: channel({
-    channelName: "CallbackManager._configureSync",
-    kind: "sync-stream"
-  })
-});
+var langChainChannels = defineChannels(
+  "@langchain/core",
+  {
+    configure: channel({
+      channelName: "CallbackManager.configure",
+      kind: "sync-stream"
+    }),
+    configureSync: channel({
+      channelName: "CallbackManager._configureSync",
+      kind: "sync-stream"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.LANGCHAIN }
+);
 
 // src/instrumentation/plugins/langchain-plugin.ts
 var LangChainPlugin = class extends BasePlugin {
@@ -27248,20 +28462,24 @@ function isBraintrustHandler(handler) {
 }
 
 // src/instrumentation/plugins/langsmith-channels.ts
-var langSmithChannels = defineChannels("langsmith", {
-  createRun: channel({
-    channelName: "Client.createRun",
-    kind: "async"
-  }),
-  updateRun: channel({
-    channelName: "Client.updateRun",
-    kind: "async"
-  }),
-  batchIngestRuns: channel({
-    channelName: "Client.batchIngestRuns",
-    kind: "async"
-  })
-});
+var langSmithChannels = defineChannels(
+  "langsmith",
+  {
+    createRun: channel({
+      channelName: "Client.createRun",
+      kind: "async"
+    }),
+    updateRun: channel({
+      channelName: "Client.updateRun",
+      kind: "async"
+    }),
+    batchIngestRuns: channel({
+      channelName: "Client.batchIngestRuns",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.LANGSMITH }
+);
 
 // src/instrumentation/plugins/langsmith-plugin.ts
 var MAX_COMPLETED_RUNS = 1e4;
@@ -27425,19 +28643,24 @@ var LangSmithPlugin = class extends BasePlugin {
     const traceId = stringValue2(ownValue(run, "trace_id")) ?? id;
     const parentId = stringValue2(ownValue(run, "parent_run_id")) ?? stringValue2(ownValue(ownValue(run, "parent_run"), "id"));
     const startTime = timestampSeconds(ownValue(run, "start_time"));
-    return startSpan({
-      name: stringValue2(ownValue(run, "name")) ?? "LangSmith run",
-      spanId: id,
-      parentSpanIds: {
-        parentSpanIds: parentId ? [parentId] : [],
-        rootSpanId: traceId
-      },
-      spanAttributes: {
-        type: mapRunType(ownValue(run, "run_type"))
-      },
-      ...startTime === void 0 ? {} : { startTime },
-      event: { id }
-    });
+    return startSpan(
+      withSpanInstrumentationName(
+        {
+          name: stringValue2(ownValue(run, "name")) ?? "LangSmith run",
+          spanId: id,
+          parentSpanIds: {
+            parentSpanIds: parentId ? [parentId] : [],
+            rootSpanId: traceId
+          },
+          spanAttributes: {
+            type: mapRunType(ownValue(run, "run_type"))
+          },
+          ...startTime === void 0 ? {} : { startTime },
+          event: { id }
+        },
+        INSTRUMENTATION_NAMES.LANGSMITH
+      )
+    );
   }
   logRun(span, run, previous, includeOutput) {
     const inputs = preferOwnValue(run, previous, "inputs");
@@ -27695,7 +28918,8 @@ var piCodingAgentChannels = defineChannels(
       channelName: "AgentSession.prompt",
       kind: "async"
     })
-  }
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.PI_CODING_AGENT }
 );
 
 // src/instrumentation/plugins/pi-coding-agent-plugin.ts
@@ -27779,14 +29003,19 @@ function startPiPromptRun(event, onFinalize) {
     ...session.model?.id || agent.state?.model?.id ? { model: session.model?.id ?? agent.state?.model?.id } : {},
     ...event.moduleVersion ? { "pi_coding_agent.version": event.moduleVersion } : {}
   };
-  const span = startSpan({
-    event: {
-      input: extractPromptInput(event.arguments[0], event.arguments[1]),
-      metadata
-    },
-    name: "AgentSession.prompt",
-    spanAttributes: { type: "task" /* TASK */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          input: extractPromptInput(event.arguments[0], event.arguments[1]),
+          metadata
+        },
+        name: "AgentSession.prompt",
+        spanAttributes: { type: "task" /* TASK */ }
+      },
+      INSTRUMENTATION_NAMES.PI_CODING_AGENT
+    )
+  );
   const streamPatchState = installPiStreamPatch(agent);
   const options = event.arguments[1];
   const promptText = event.arguments[0];
@@ -27956,15 +29185,20 @@ async function startPiLlmSpan(state, model, context, options) {
     ...extractToolMetadata(context.tools),
     "pi_coding_agent.operation": "agent.streamFn"
   };
-  const span = startSpan({
-    event: {
-      input: processInputAttachments(normalizePiContextInput(context)),
-      metadata
-    },
-    name: getLlmSpanName(model),
-    parent: await state.span.export(),
-    spanAttributes: { type: "llm" /* LLM */ }
-  });
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          input: processInputAttachments(normalizePiContextInput(context)),
+          metadata
+        },
+        name: getLlmSpanName(model),
+        parent: await state.span.export(),
+        spanAttributes: { type: "llm" /* LLM */ }
+      },
+      INSTRUMENTATION_NAMES.PI_CODING_AGENT
+    )
+  );
   const llmState = {
     finalized: false,
     metadata,
@@ -28128,19 +29362,24 @@ async function startPiToolSpan(state, event) {
   const restoreAutoInstrumentation = enterAutoInstrumentationAllowed();
   const metadata = {
     "gen_ai.tool.call.id": event.toolCallId,
-    "gen_ai.tool.name": event.toolName,
-    "pi_coding_agent.tool.name": event.toolName
-  };
-  try {
-    const span = startSpan({
-      event: {
-        input: event.args,
-        metadata
-      },
-      name: event.toolName || "tool",
-      parent: await state.span.export(),
-      spanAttributes: { type: "tool" /* TOOL */ }
-    });
+    "gen_ai.tool.name": event.toolName,
+    "pi_coding_agent.tool.name": event.toolName
+  };
+  try {
+    const span = startSpan(
+      withSpanInstrumentationName(
+        {
+          event: {
+            input: event.args,
+            metadata
+          },
+          name: event.toolName || "tool",
+          parent: await state.span.export(),
+          spanAttributes: { type: "tool" /* TOOL */ }
+        },
+        INSTRUMENTATION_NAMES.PI_CODING_AGENT
+      )
+    );
     state.activeToolSpans.set(event.toolCallId, {
       restoreAutoInstrumentation,
       span
@@ -28572,20 +29811,24 @@ function logInstrumentationError4(context, error) {
 }
 
 // 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"
-  })
-});
+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"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK }
+);
 
 // src/instrumentation/plugins/strands-agent-sdk-plugin.ts
 var MAX_STRANDS_STRING_ATTACHMENT_CACHE_ENTRIES = 32;
@@ -28740,22 +29983,32 @@ function startAgentStream(event, activeChildParents) {
   );
   const span = parentSpan ? withCurrent(
     parentSpan,
-    () => startSpan({
-      event: {
-        input,
-        metadata
+    () => startSpan(
+      withSpanInstrumentationName(
+        {
+          event: {
+            input,
+            metadata
+          },
+          name: formatAgentSpanName(agent),
+          spanAttributes: { type: "task" /* TASK */ }
+        },
+        INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK
+      )
+    )
+  ) : startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          input,
+          metadata
+        },
+        name: formatAgentSpanName(agent),
+        spanAttributes: { type: "task" /* TASK */ }
       },
-      name: formatAgentSpanName(agent),
-      spanAttributes: { type: "task" /* TASK */ }
-    })
-  ) : startSpan({
-    event: {
-      input,
-      metadata
-    },
-    name: formatAgentSpanName(agent),
-    spanAttributes: { type: "task" /* TASK */ }
-  });
+      INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK
+    )
+  );
   return {
     activeTools: /* @__PURE__ */ new Map(),
     attachmentCache,
@@ -28777,22 +30030,32 @@ function startMultiAgentStream(event, operation, activeChildParents) {
   const input = processStrandsInputAttachments(event.arguments[0]);
   const span = parentSpan ? withCurrent(
     parentSpan,
-    () => startSpan({
-      event: {
-        input,
-        metadata
+    () => startSpan(
+      withSpanInstrumentationName(
+        {
+          event: {
+            input,
+            metadata
+          },
+          name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
+          spanAttributes: { type: "task" /* TASK */ }
+        },
+        INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK
+      )
+    )
+  ) : startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          input,
+          metadata
+        },
+        name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
+        spanAttributes: { type: "task" /* TASK */ }
       },
-      name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
-      spanAttributes: { type: "task" /* TASK */ }
-    })
-  ) : startSpan({
-    event: {
-      input,
-      metadata
-    },
-    name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
-    spanAttributes: { type: "task" /* TASK */ }
-  });
+      INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK
+    )
+  );
   return {
     activeNodes: /* @__PURE__ */ new Map(),
     finalized: false,
@@ -28894,17 +30157,22 @@ function startModelSpan(state, event) {
   };
   const span = withCurrent(
     state.span,
-    () => startSpan({
-      event: {
-        input: Array.isArray(event.agent?.messages) ? processStrandsInputAttachments(
-          event.agent.messages,
-          state.attachmentCache
-        ) : void 0,
-        metadata
-      },
-      name: formatModelSpanName(model),
-      spanAttributes: { type: "llm" /* LLM */ }
-    })
+    () => startSpan(
+      withSpanInstrumentationName(
+        {
+          event: {
+            input: Array.isArray(event.agent?.messages) ? processStrandsInputAttachments(
+              event.agent.messages,
+              state.attachmentCache
+            ) : void 0,
+            metadata
+          },
+          name: formatModelSpanName(model),
+          spanAttributes: { type: "llm" /* LLM */ }
+        },
+        INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK
+      )
+    )
   );
   state.activeModel = {
     metadata,
@@ -28956,20 +30224,25 @@ function startToolSpan2(state, event) {
   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 */ }
-    })
+    () => startSpan(
+      withSpanInstrumentationName(
+        {
+          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 */ }
+        },
+        INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK
+      )
+    )
   );
   state.activeTools.set(key, {
     span,
@@ -29040,11 +30313,16 @@ function startNodeSpan(state, event, activeChildParents) {
   };
   const span = withCurrent(
     state.span,
-    () => startSpan({
-      event: { metadata },
-      name: `node: ${nodeId}`,
-      spanAttributes: { type: "task" /* TASK */ }
-    })
+    () => startSpan(
+      withSpanInstrumentationName(
+        {
+          event: { metadata },
+          name: `node: ${nodeId}`,
+          spanAttributes: { type: "task" /* TASK */ }
+        },
+        INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK
+      )
+    )
   );
   const nodeState = {
     ...child ? { child } : {},
@@ -29753,6 +31031,7 @@ var BraintrustPlugin = class extends BasePlugin {
 var EVE_TRACE_STATE_KEY = "braintrust.eve.tracing";
 var MAX_EVE_CACHE_ENTRIES = 1e4;
 var MAX_STORED_LLM_INPUTS = 100;
+var MAX_STORED_REASONING_BLOCKS = 100;
 var MAX_STORED_SPAN_REFERENCES = 1e4;
 var MAX_STORED_STEP_STARTS = 1e4;
 function braintrustEveHook(options) {
@@ -29791,6 +31070,7 @@ var ResumedEveSpan = class {
     this.reference = reference;
     this.endTime = reference.endTime;
   }
+  reference;
   endTime;
   get rootSpanId() {
     return this.reference.rootSpanId;
@@ -29823,6 +31103,7 @@ var EveBridge = class {
   constructor(state) {
     this.state = state;
   }
+  state;
   eventQueuesBySession = /* @__PURE__ */ new Map();
   completedToolKeys = new LRUCache({
     max: MAX_EVE_CACHE_ENTRIES
@@ -29855,7 +31136,12 @@ var EveBridge = class {
     };
     const span = withCurrent(
       NOOP_SPAN,
-      () => _internalStartSpanWithInitialMerge({ ...args, startTime })
+      () => _internalStartSpanWithInitialMerge(
+        withSpanInstrumentationName(
+          { ...args, startTime },
+          INSTRUMENTATION_NAMES.EVE
+        )
+      )
     );
     if (typeof rowId !== "string") {
       return span;
@@ -30001,6 +31287,9 @@ var EveBridge = class {
       case "step.started":
         await this.handleStepStarted(event, ctx, hookMetadata);
         return true;
+      case "reasoning.completed":
+        this.handleReasoningCompleted(event, ctx);
+        return true;
       case "message.completed":
         this.handleMessageCompleted(event, ctx);
         return true;
@@ -30092,6 +31381,7 @@ var EveBridge = class {
       key,
       metadata,
       metrics: {},
+      sessionId,
       span,
       stepsByIndex: /* @__PURE__ */ new Map(),
       turnId: event.data.turnId
@@ -30122,6 +31412,12 @@ var EveBridge = class {
       const endTime = eventTime2(event);
       existing.span.end(endTime === void 0 ? void 0 : { endTime });
       this.markStepEnded(event.data.turnId, event.data.stepIndex);
+      clearStoredEveReasoning(
+        this.state,
+        sessionId,
+        event.data.turnId,
+        event.data.stepIndex
+      );
     }
     const stepOrdinal = this.stepOrdinal(event);
     const metadata = { ...turn.metadata };
@@ -30131,6 +31427,13 @@ var EveBridge = class {
       event.data.turnId,
       event.data.stepIndex
     );
+    const reasoning = readStoredEveReasoning(
+      this.state,
+      sessionId,
+      event.data.turnId,
+      event.data.stepIndex
+    );
+    const output = mergeEveReasoning(void 0, reasoning);
     const { rowId: eventId, spanId } = await generateEveIds(
       "step",
       sessionId,
@@ -30148,32 +31451,52 @@ var EveBridge = class {
       spanId,
       startTime: eventTime2(event)
     });
-    span.log({ ...input !== void 0 ? { input } : {}, metadata });
+    span.log({
+      ...input !== void 0 ? { input } : {},
+      metadata
+    });
     turn.stepsByIndex.set(event.data.stepIndex, {
       ...input !== void 0 ? { input } : {},
       metadata,
       metrics: {},
+      ...output !== void 0 ? { output } : {},
+      reasoning,
       span
     });
   }
+  handleReasoningCompleted(event, ctx) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const reasoning = storeEveReasoning(this.state, sessionId, event);
+    const step = this.stepForEvent(event, ctx);
+    if (step) {
+      step.reasoning = reasoning;
+      step.output = mergeEveReasoning(step.output, reasoning);
+    }
+  }
   handleMessageCompleted(event, ctx) {
     const step = this.stepForEvent(event, ctx);
     if (!step) {
       return;
     }
-    const existingMessage = Array.isArray(step.output) && isObject(step.output[0]) ? step.output[0].message : void 0;
+    const existingMessage = eveOutputMessage(step.output);
     const existingToolCalls = isObject(existingMessage) ? existingMessage.tool_calls : void 0;
-    step.output = [
-      {
-        finish_reason: normalizedFinishReason(event.data.finishReason),
-        index: 0,
-        message: {
-          content: event.data.message,
-          role: "assistant",
-          ...Array.isArray(existingToolCalls) ? { tool_calls: existingToolCalls } : {}
+    step.output = mergeEveReasoning(
+      [
+        {
+          finish_reason: normalizedFinishReason(event.data.finishReason),
+          index: 0,
+          message: {
+            content: event.data.message,
+            role: "assistant",
+            ...Array.isArray(existingToolCalls) ? { tool_calls: existingToolCalls } : {}
+          }
         }
-      }
-    ];
+      ],
+      step.reasoning
+    );
     const turn = this.turnForEvent(event, ctx);
     if (turn && event.data.finishReason !== "tool-calls") {
       turn.output = event.data.message;
@@ -30182,16 +31505,19 @@ var EveBridge = class {
   handleResultCompleted(event, ctx) {
     const step = this.stepForEvent(event, ctx);
     if (step) {
-      step.output = [
-        {
-          finish_reason: "stop",
-          index: 0,
-          message: {
-            content: event.data.result,
-            role: "assistant"
+      step.output = mergeEveReasoning(
+        [
+          {
+            finish_reason: "stop",
+            index: 0,
+            message: {
+              content: event.data.result,
+              role: "assistant"
+            }
           }
-        }
-      ];
+        ],
+        step.reasoning
+      );
     }
     const turn = this.turnForEvent(event, ctx);
     if (turn) {
@@ -30241,18 +31567,20 @@ var EveBridge = class {
         type: "function"
       });
     }
-    step.output = [
-      {
-        finish_reason: "tool_calls",
-        index: 0,
-        message: {
-          content: null,
-          role: "assistant",
-          tool_calls: [...toolCallsById.values()]
+    step.output = mergeEveReasoning(
+      [
+        {
+          finish_reason: "tool_calls",
+          index: 0,
+          message: {
+            content: null,
+            role: "assistant",
+            tool_calls: [...toolCallsById.values()]
+          }
         }
-      }
-    ];
-    step.span.log({ metadata: step.metadata, output: step.output });
+      ],
+      step.reasoning
+    );
   }
   async handleActionResult(event, ctx, hookMetadata) {
     if (isToolResult(event.data.result)) {
@@ -30430,6 +31758,7 @@ var EveBridge = class {
       ...costUsd !== void 0 ? { estimated_cost: costUsd } : {}
     };
     step.metrics = { ...step.metrics, ...metrics };
+    const sessionId = sessionIdFromContext(ctx);
     if (Array.isArray(step.output) && isObject(step.output[0])) {
       const finishReason = step.output[0].finish_reason;
       if (typeof finishReason !== "string") {
@@ -30454,6 +31783,14 @@ var EveBridge = class {
       turn.stepsByIndex.delete(event.data.stepIndex);
     }
     this.markStepEnded(event.data.turnId, event.data.stepIndex);
+    if (sessionId) {
+      clearStoredEveReasoning(
+        this.state,
+        sessionId,
+        event.data.turnId,
+        event.data.stepIndex
+      );
+    }
   }
   handleStepFailed(event, ctx) {
     const step = this.stepForEvent(event, ctx);
@@ -30471,6 +31808,15 @@ var EveBridge = class {
     const turn = this.turnForEvent(event, ctx);
     turn?.stepsByIndex.delete(event.data.stepIndex);
     this.markStepEnded(event.data.turnId, event.data.stepIndex);
+    const sessionId = sessionIdFromContext(ctx);
+    if (sessionId) {
+      clearStoredEveReasoning(
+        this.state,
+        sessionId,
+        event.data.turnId,
+        event.data.stepIndex
+      );
+    }
   }
   handleTurnCompleted(event, ctx) {
     const turn = this.turnForEvent(event, ctx);
@@ -30568,6 +31914,7 @@ var EveBridge = class {
       key,
       metadata,
       metrics: {},
+      sessionId,
       span,
       stepsByIndex: /* @__PURE__ */ new Map(),
       turnId: event.data.turnId
@@ -30830,6 +32177,9 @@ var EveBridge = class {
       const normalized = normalizeEveTraceState(current);
       return {
         ...normalized,
+        reasoningBlocks: normalized.reasoningBlocks.filter(
+          (entry) => !entry.key.startsWith(`${turn.sessionId}\0${turn.turnId}\0`)
+        ),
         stepStarts: normalized.stepStarts.filter(
           (entry) => entry.turnId !== turn.turnId
         )
@@ -30869,6 +32219,7 @@ function emptyEveTraceState() {
   return {
     llmInputs: [],
     metadata: {},
+    reasoningBlocks: [],
     spanReferences: [],
     stepStarts: []
   };
@@ -30919,6 +32270,21 @@ function normalizeEveTraceState(state) {
     const input = entry["input"];
     return typeof key === "string" && isCapturedModelInput(input) ? [{ input, key }] : [];
   }).slice(-MAX_STORED_LLM_INPUTS) : [];
+  const reasoningBlocks = Array.isArray(state["reasoningBlocks"]) ? state["reasoningBlocks"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const content = entry["content"];
+    const eventAt = entry["eventAt"];
+    const key = entry["key"];
+    return typeof content === "string" && (eventAt === void 0 || typeof eventAt === "string") && typeof key === "string" ? [
+      {
+        content,
+        ...typeof eventAt === "string" ? { eventAt } : {},
+        key
+      }
+    ] : [];
+  }).slice(-MAX_STORED_REASONING_BLOCKS) : [];
   const stepStarts = Array.isArray(state["stepStarts"]) ? state["stepStarts"].flatMap((entry) => {
     if (!isObject(entry)) {
       return [];
@@ -30929,7 +32295,13 @@ function normalizeEveTraceState(state) {
     const turnId = entry["turnId"];
     return typeof ordinal === "number" && Number.isInteger(ordinal) && ordinal >= 0 && typeof open === "boolean" && typeof stepIndex === "number" && Number.isInteger(stepIndex) && typeof turnId === "string" ? [{ open, ordinal, stepIndex, turnId }] : [];
   }).slice(-MAX_STORED_STEP_STARTS) : [];
-  return { llmInputs, metadata: { ...metadata }, spanReferences, stepStarts };
+  return {
+    llmInputs,
+    metadata: { ...metadata },
+    reasoningBlocks,
+    spanReferences,
+    stepStarts
+  };
 }
 function readEveTraceState(state) {
   try {
@@ -30938,23 +32310,85 @@ function readEveTraceState(state) {
     return emptyEveTraceState();
   }
 }
-function captureEveModelInput(state, input) {
-  if (!isObject(input)) {
-    return;
-  }
-  const session = input["session"];
-  const turn = input["turn"];
-  const step = input["step"];
-  if (!isObject(session) || !isObject(turn) || !isObject(step)) {
-    return;
-  }
-  const sessionId = session["id"];
-  const turnId = turn["id"];
-  const stepIndex = step["index"];
-  if (typeof sessionId !== "string" || typeof turnId !== "string" || typeof stepIndex !== "number" || !Number.isInteger(stepIndex)) {
-    return;
+function storeEveReasoning(state, sessionId, event) {
+  const eventAt = event.meta?.at;
+  const key = llmInputKey(sessionId, event.data.turnId, event.data.stepIndex);
+  let stored = [];
+  state.update((current) => {
+    const normalized = normalizeEveTraceState(current);
+    const alreadyStored = normalized.reasoningBlocks.some(
+      (entry) => entry.content === event.data.reasoning && entry.eventAt === eventAt && entry.key === key
+    );
+    const reasoningBlocks = alreadyStored ? normalized.reasoningBlocks : [
+      ...normalized.reasoningBlocks,
+      {
+        content: event.data.reasoning,
+        ...eventAt ? { eventAt } : {},
+        key
+      }
+    ].slice(-MAX_STORED_REASONING_BLOCKS);
+    stored = reasoningBlocks.flatMap(
+      (entry) => entry.key === key ? [
+        {
+          content: entry.content,
+          ...entry.eventAt ? { eventAt: entry.eventAt } : {}
+        }
+      ] : []
+    );
+    return alreadyStored ? normalized : { ...normalized, reasoningBlocks };
+  });
+  return stored;
+}
+function readStoredEveReasoning(state, sessionId, turnId, stepIndex) {
+  const key = llmInputKey(sessionId, turnId, stepIndex);
+  return readEveTraceState(state).reasoningBlocks.flatMap(
+    (entry) => entry.key === key ? [
+      {
+        content: entry.content,
+        ...entry.eventAt ? { eventAt: entry.eventAt } : {}
+      }
+    ] : []
+  );
+}
+function clearStoredEveReasoning(state, sessionId, turnId, stepIndex) {
+  const key = llmInputKey(sessionId, turnId, stepIndex);
+  state.update((current) => {
+    const normalized = normalizeEveTraceState(current);
+    return {
+      ...normalized,
+      reasoningBlocks: normalized.reasoningBlocks.filter(
+        (entry) => entry.key !== key
+      )
+    };
+  });
+}
+function eveOutputMessage(output) {
+  return Array.isArray(output) && isObject(output[0]) ? output[0]["message"] : void 0;
+}
+function mergeEveReasoning(output, reasoning) {
+  if (reasoning.length === 0) {
+    return output;
   }
-  const captured = capturedModelInput(input["modelInput"]);
+  const choice = Array.isArray(output) && isObject(output[0]) ? output[0] : {};
+  const message = isObject(choice["message"]) ? choice["message"] : {};
+  return [
+    {
+      ...choice,
+      index: typeof choice["index"] === "number" ? choice["index"] : 0,
+      message: {
+        ...message,
+        content: "content" in message ? message["content"] : null,
+        reasoning: reasoning.map((block) => ({ content: block.content })),
+        role: typeof message["role"] === "string" ? message["role"] : "assistant"
+      }
+    }
+  ];
+}
+function captureEveModelInput(state, input) {
+  const sessionId = input.session.id;
+  const turnId = input.turn.id;
+  const stepIndex = input.step.index;
+  const captured = capturedModelInput(input.modelInput);
   if (!captured) {
     return;
   }
@@ -30995,18 +32429,14 @@ function consumeCapturedEveModelInput(state, sessionId, turnId, stepIndex) {
   }
 }
 function capturedModelInput(modelInput) {
-  if (!isObject(modelInput)) {
-    return void 0;
-  }
-  const messages = modelInput["messages"];
-  if (!Array.isArray(messages)) {
-    return void 0;
-  }
-  const instructions = modelInput["instructions"];
-  const value = [
-    ...instructions !== void 0 ? [{ content: instructions, role: "system" }] : [],
-    ...messages
-  ];
+  const { instructions, messages } = modelInput;
+  const value = [];
+  if (typeof instructions === "string") {
+    value.push({ content: instructions, role: "system" });
+  } else if (instructions) {
+    value.push(...instructions.map(capturedEveModelMessage));
+  }
+  value.push(...messages.map(capturedEveModelMessage));
   try {
     const cloned = JSON.parse(JSON.stringify(value));
     if (!Array.isArray(cloned)) {
@@ -31017,8 +32447,123 @@ function capturedModelInput(modelInput) {
     return void 0;
   }
 }
+function capturedEveModelMessage(message) {
+  const { content, role } = message;
+  if (typeof content === "string") {
+    return { content, role };
+  }
+  return { content: content.map(capturedEveModelContentPart), role };
+}
+function capturedEveModelContentPart(part) {
+  switch (part.type) {
+    case "text":
+    case "reasoning":
+      return { text: part.text, type: part.type };
+    case "image":
+      return {
+        image: part.image,
+        ...part.mediaType !== void 0 ? { mediaType: part.mediaType } : {},
+        type: "image"
+      };
+    case "file":
+    case "reasoning-file":
+      return {
+        data: part.data,
+        ...part.type === "file" && part.filename !== void 0 ? { filename: part.filename } : {},
+        mediaType: part.mediaType,
+        type: part.type
+      };
+    case "custom":
+      return {
+        ..."kind" in part ? { kind: part.kind } : {},
+        type: "custom"
+      };
+    case "tool-call":
+      return {
+        input: part.input,
+        ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {},
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        type: "tool-call"
+      };
+    case "tool-result": {
+      const output = part.output;
+      let capturedOutput;
+      switch (output.type) {
+        case "text":
+        case "error-text":
+          capturedOutput = { type: output.type, value: output.value };
+          break;
+        case "json":
+        case "error-json":
+          capturedOutput = { type: output.type, value: output.value };
+          break;
+        case "execution-denied":
+          capturedOutput = {
+            ...output.reason !== void 0 ? { reason: output.reason } : {},
+            type: "execution-denied"
+          };
+          break;
+        case "content":
+          capturedOutput = {
+            type: "content",
+            value: output.value.map(capturedEveModelContentPart)
+          };
+          break;
+      }
+      return {
+        output: capturedOutput,
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        type: "tool-result"
+      };
+    }
+    case "tool-approval-request":
+      return {
+        approvalId: part.approvalId,
+        ...part.isAutomatic !== void 0 ? { isAutomatic: part.isAutomatic } : {},
+        ...part.signature !== void 0 ? { signature: part.signature } : {},
+        toolCallId: part.toolCallId,
+        type: "tool-approval-request"
+      };
+    case "tool-approval-response":
+      return {
+        approvalId: part.approvalId,
+        approved: part.approved,
+        ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {},
+        ...part.reason !== void 0 ? { reason: part.reason } : {},
+        type: "tool-approval-response"
+      };
+    case "file-data":
+    case "image-data":
+      return {
+        data: part.data,
+        ...part.type === "file-data" && part.filename !== void 0 ? { filename: part.filename } : {},
+        mediaType: part.mediaType,
+        type: part.type
+      };
+    case "file-url":
+    case "image-url":
+      return {
+        ...part.type === "file-url" && part.mediaType !== void 0 ? { mediaType: part.mediaType } : {},
+        type: part.type,
+        url: part.url
+      };
+    case "file-id":
+    case "image-file-id":
+      return { fileId: part.fileId, type: part.type };
+    case "file-reference":
+    case "image-file-reference":
+      return {
+        providerReference: part.providerReference,
+        type: part.type
+      };
+  }
+}
 function isCapturedModelInput(input) {
-  return Array.isArray(input);
+  return Array.isArray(input) && input.every(
+    (message) => isObject(message) && (message["role"] === "system" || message["role"] === "user" || message["role"] === "assistant" || message["role"] === "tool") && (typeof message["content"] === "string" || Array.isArray(message["content"]) && message["content"].every(isObject))
+  );
 }
 function llmInputKey(sessionId, turnId, stepIndex) {
   return `${sessionId}\0${turnId}\0${stepIndex}`;