braintrust 3.23.1 → 3.25.0

package/dev/dist/index.mjs

@@ -115,6 +115,7 @@ var DefaultChannel = class {
   constructor(name) {
     this.name = name;
   }
+  name;
   hasSubscribers = false;
   subscribe(_subscription) {
   }
@@ -1381,6 +1382,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,
@@ -1892,6 +1894,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,
@@ -5138,6 +5141,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;
@@ -5186,6 +5327,7 @@ var LoginInvalidOrgError = class extends Error {
     super(message);
     this.message = message;
   }
+  message;
 };
 var REDACTION_FIELDS = [
   "input",
@@ -5201,6 +5343,8 @@ var MaskingError = class {
     this.fieldName = fieldName;
     this.errorType = errorType;
   }
+  fieldName;
+  errorType;
   get errorMsg() {
     return `ERROR: Failed to mask field '${this.fieldName}' - ${this.errorType}`;
   }
@@ -5410,7 +5554,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
@@ -5445,6 +5592,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;
@@ -5505,6 +5665,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
     );
@@ -5592,6 +5753,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;
@@ -6256,6 +6418,28 @@ function updateSpanImpl({
   }));
   state.bgLogger().log([record]);
 }
+function updateSpan({
+  exported,
+  state,
+  ...event
+}) {
+  const resolvedState = state ?? _globalState;
+  const components = SpanComponentsV4.fromStr(exported);
+  if (!components.data.row_id) {
+    throw new Error("Exported span must have a row id");
+  }
+  updateSpanImpl({
+    state: resolvedState,
+    parentObjectType: components.data.object_type,
+    parentObjectId: new LazyValue(
+      spanComponentsToObjectIdLambda(resolvedState, components)
+    ),
+    id: components.data.row_id,
+    root_span_id: components.data.root_span_id,
+    span_id: components.data.span_id,
+    event
+  });
+}
 function spanComponentsToObjectIdLambda(state, components) {
   if (components.data.object_id) {
     const ret = components.data.object_id;
@@ -7342,6 +7526,7 @@ function init(projectOrOptions, optionalOptions) {
     throw new Error("Cannot open and update an experiment at the same time");
   }
   const state = stateArg ?? _globalState;
+  state._internalSetTraceContextSigningSecret(apiKey);
   state.enforceQueueSizeLimit(false);
   if (open2) {
     if (isEmpty2(experiment)) {
@@ -7798,6 +7983,7 @@ function initLogger(options = {}) {
     orgName,
     forceLogin,
     debugLogLevel,
+    environment,
     fetch: fetch2,
     state: stateArg
   } = options || {};
@@ -7813,7 +7999,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 () => {
@@ -8241,6 +8429,12 @@ function traced(callback, args) {
 function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
+function _internalStartSpanWithInitialMerge(args) {
+  return startSpanAndIsLogger({
+    ...args,
+    [INITIAL_SPAN_WRITE_AS_MERGE]: true
+  }).span;
+}
 async function flush(options) {
   const state = options?.state ?? _globalState;
   return await state.bgLogger().flush();
@@ -8392,7 +8586,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>`;
@@ -8522,6 +8718,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");
@@ -8960,6 +9161,8 @@ var ReadonlyExperiment = class extends ObjectFetcher {
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
+  state;
+  lazyMetadata;
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).experiment.id;
@@ -9053,6 +9256,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);
@@ -9082,7 +9286,11 @@ var SpanImpl = class _SpanImpl {
       metrics: {
         start: args.startTime ?? getCurrentUnixTimestamp()
       },
-      context: { ...callerLocation },
+      context: mergeSpanOriginContext(
+        { ...callerLocation },
+        instrumentationName,
+        this._state.spanOriginEnvironment
+      ),
       span_attributes: {
         name,
         type,
@@ -9456,6 +9664,7 @@ var Dataset2 = class extends ObjectFetcher {
     this.pinnedEnvironment = pinState?.pinnedEnvironment;
     this.pinnedSnapshotName = pinState?.pinnedSnapshotName;
   }
+  state;
   lazyMetadata;
   __braintrust_dataset_marker = true;
   newRecords = 0;
@@ -9967,6 +10176,9 @@ var Prompt2 = class _Prompt {
     this.noTrace = noTrace;
     void this.__braintrust_prompt_marker;
   }
+  metadata;
+  defaults;
+  noTrace;
   parsedPromptData;
   hasParsedPromptData = false;
   __braintrust_prompt_marker = true;
@@ -10204,6 +10416,7 @@ var RemoteEvalParameters = class {
     this.metadata = metadata;
     void this.__braintrust_parameters_marker;
   }
+  metadata;
   __braintrust_parameters_marker = true;
   get id() {
     return this.metadata.id;
@@ -10961,15 +11174,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(
@@ -11000,7 +11223,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) {
@@ -11009,11 +11232,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(tracingChannel2, states, config, channelName) {
+function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelName, instrumentationName) {
   const state = _internalGetGlobalState();
   const startChannel = tracingChannel2.start;
   const contextManager = state?.contextManager;
@@ -11031,7 +11259,8 @@ function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelNam
         states,
         config,
         event,
-        channelName
+        channelName,
+        instrumentationName
       );
       return spanState ? contextManager.wrapSpanForStore(spanState.span) : currentSpanStore.getStore();
     }
@@ -11040,15 +11269,21 @@ function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelNam
     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) {
@@ -11098,7 +11333,8 @@ function traceAsyncChannel(channel2, config) {
     tracingChannel2,
     states,
     config,
-    channelName
+    channelName,
+    channel2.instrumentationName
   );
   const handlers = {
     start: (event) => {
@@ -11109,7 +11345,8 @@ function traceAsyncChannel(channel2, config) {
         states,
         config,
         event,
-        channelName
+        channelName,
+        channel2.instrumentationName
       );
     },
     asyncEnd: (event) => {
@@ -11146,7 +11383,7 @@ function traceAsyncChannel(channel2, config) {
       }
     },
     error: (event) => {
-      logErrorAndEnd(states, event);
+      logErrorAndEnd(states, event, channelName);
     }
   };
   tracingChannel2.subscribe(handlers);
@@ -11163,7 +11400,8 @@ function traceStreamingChannel(channel2, config) {
     tracingChannel2,
     states,
     config,
-    channelName
+    channelName,
+    channel2.instrumentationName
   );
   const handlers = {
     start: (event) => {
@@ -11174,7 +11412,8 @@ function traceStreamingChannel(channel2, config) {
         states,
         config,
         event,
-        channelName
+        channelName,
+        channel2.instrumentationName
       );
     },
     asyncEnd: (event) => {
@@ -11193,6 +11432,7 @@ function traceStreamingChannel(channel2, config) {
             }
           },
           onComplete: (chunks) => {
+            let completion2;
             try {
               let output;
               let metrics;
@@ -11223,18 +11463,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 } : {},
@@ -11246,11 +11479,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,
@@ -11259,11 +11530,6 @@ function traceStreamingChannel(channel2, config) {
               span,
               startTime
             });
-            span.log({
-              error: error.message
-            });
-            span.end();
-            states.delete(event);
           }
         });
         return;
@@ -11278,6 +11544,7 @@ function traceStreamingChannel(channel2, config) {
         states.delete(event);
         return;
       }
+      let completion;
       try {
         const output = config.extractOutput(
           asyncEndEvent.result,
@@ -11292,17 +11559,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) } : {},
@@ -11311,12 +11572,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,
@@ -11327,7 +11606,6 @@ function traceStreamingChannel(channel2, config) {
           startTime: spanData.startTime
         });
       }
-      logErrorAndEnd(states, event);
     }
   };
   tracingChannel2.subscribe(handlers);
@@ -11344,7 +11622,8 @@ function traceSyncStreamChannel(channel2, config) {
     tracingChannel2,
     states,
     config,
-    channelName
+    channelName,
+    channel2.instrumentationName
   );
   const handlers = {
     start: (event) => {
@@ -11355,7 +11634,8 @@ function traceSyncStreamChannel(channel2, config) {
         states,
         config,
         event,
-        channelName
+        channelName,
+        channel2.instrumentationName
       );
     },
     end: (event) => {
@@ -11449,7 +11729,7 @@ function traceSyncStreamChannel(channel2, config) {
       handleResolvedResult(endEvent.result);
     },
     error: (event) => {
-      logErrorAndEnd(states, event);
+      logErrorAndEnd(states, event, channelName);
     }
   };
   tracingChannel2.subscribe(handlers);
@@ -11628,7 +11908,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}`;
@@ -11641,6 +11922,7 @@ function defineChannels(pkg, channels) {
           key,
           {
             ...asyncSpec,
+            instrumentationName,
             tracingChannel: tracingChannel3,
             tracePromise: (fn, context) => tracingChannel3().tracePromise(
               fn,
@@ -11658,6 +11940,7 @@ function defineChannels(pkg, channels) {
         key,
         {
           ...syncSpec,
+          instrumentationName,
           tracingChannel: tracingChannel2,
           traceSync: (fn, context) => tracingChannel2().traceSync(
             fn,
@@ -11671,44 +11954,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";
@@ -12223,16 +12510,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(
@@ -12320,10 +12611,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,
@@ -12472,7 +12768,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();
 }
@@ -12514,15 +12815,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: [],
@@ -12568,7 +12874,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") {
@@ -12878,20 +13192,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(
@@ -12964,12 +13282,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)
@@ -13110,19 +13433,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
@@ -13717,6 +14043,267 @@ function currentWorkflowAgentWrapperSpan() {
   return void 0;
 }
 
+// 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
+  };
+}
+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(tracingChannel2, parentFromEvent) {
+  const startChannel = tracingChannel2.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 log2 = (event) => {
+    if (typeof parent === "string") {
+      updateSpan({ exported: parent, ...event });
+    } else {
+      parent.log(event);
+    }
+  };
+  try {
+    if (Object.prototype.hasOwnProperty.call(update, "output")) {
+      log2({ output: null });
+    }
+    log2(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();
@@ -13735,14 +14322,17 @@ function braintrustAISDKTelemetry() {
       console.error(`Error in Braintrust AI SDK telemetry ${name}:`, error);
     }
   };
-  const startChildSpan = (operationKey, name, type, event) => {
+  const startChildSpan = (operationKey, name, type, event, parentOverride) => {
     const parent = operations.get(operationKey)?.span;
-    const spanArgs = {
-      name,
-      spanAttributes: { type },
-      ...event ? { event } : {}
-    };
-    const span = parent ? parent.startSpan(spanArgs) : startSpan(spanArgs);
+    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;
@@ -14022,14 +14612,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,
@@ -14270,7 +14876,8 @@ function braintrustAISDKTelemetry() {
               toolCallId,
               ...typeof event.toolCall.toolName === "string" ? { toolName: event.toolCall.toolName } : {}
             }
-          }
+          },
+          state?.harnessTurnParent
         );
         toolSpans.set(toolCallId, { operationKey, span });
       });
@@ -14506,74 +15113,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 = [
@@ -14650,6 +15285,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",
@@ -14842,6 +15488,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",
@@ -14912,6 +15642,8 @@ var AISDKPlugin = class extends BasePlugin {
           defaultDenyOutputPaths: denyOutputPaths,
           endEvent,
           onComplete: () => unregisterWorkflowAgentWrapperSpan(span),
+          onCancel: () => unregisterWorkflowAgentWrapperSpan(span),
+          onError: () => unregisterWorkflowAgentWrapperSpan(span),
           result,
           span,
           startTime
@@ -14920,6 +15652,153 @@ var AISDKPlugin = class extends BasePlugin {
     );
   }
 };
+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();
@@ -15372,6 +16251,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);
@@ -15819,19 +16747,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) {
@@ -15841,19 +16772,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(
@@ -16025,12 +16961,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;
@@ -16054,12 +16995,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(() => {
@@ -16218,7 +17162,10 @@ function patchAISDKStreamingResult(args) {
     defaultDenyOutputPaths,
     endEvent,
     onComplete,
+    onCancel,
+    onError,
     result,
+    resolvePromiseUsage,
     span,
     startTime
   } = args;
@@ -16228,14 +17175,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) => {
@@ -16245,6 +17221,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;
       }
@@ -16253,15 +17245,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 = () => {
@@ -16278,11 +17284,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
     };
@@ -16368,8 +17379,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);
         }
       },
@@ -17158,7 +18179,8 @@ var claudeAgentSDKChannels = defineChannels(
       channelName: "query",
       kind: "sync-stream"
     })
-  }
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK }
 );
 
 // src/instrumentation/plugins/claude-agent-sdk-instrumentation-constants.ts
@@ -17306,22 +18328,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 });
@@ -17646,14 +18673,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,
@@ -17756,25 +18788,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 {};
   };
@@ -18140,14 +19177,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;
 }
@@ -18168,14 +19210,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;
 }
@@ -18444,12 +19491,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({
@@ -18614,24 +19666,28 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
 };
 
 // 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"
-  })
-});
+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");
@@ -18683,10 +19739,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),
@@ -18748,10 +19809,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),
@@ -19198,29 +20264,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 };
 }
@@ -19479,24 +20555,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) {
@@ -19612,16 +20692,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: {
@@ -19672,10 +20755,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();
   }
@@ -19940,24 +21028,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 = {
@@ -19995,13 +21087,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()
@@ -20014,13 +21111,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()
@@ -20096,13 +21198,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()
@@ -20115,13 +21222,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()
@@ -20232,16 +21344,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;
   };
@@ -21009,28 +22126,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([
@@ -21457,20 +22578,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 {
@@ -22240,38 +23365,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 {
@@ -23311,52 +24438,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 {
@@ -23976,20 +25107,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 {
@@ -24014,12 +25149,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);
@@ -24105,18 +25245,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 = {
@@ -24209,22 +25354,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 });
@@ -24623,24 +25773,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 {
@@ -25309,18 +26463,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 {
@@ -25423,15 +26579,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 = {
@@ -26065,38 +27233,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 {
@@ -26281,12 +27457,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,
@@ -26647,20 +27828,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__";
@@ -26751,11 +27936,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 });
@@ -26786,11 +27976,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,
@@ -26816,11 +28011,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
@@ -26856,11 +28056,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,
@@ -27086,10 +28291,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;
@@ -27177,12 +28387,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");
@@ -27525,15 +28739,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) {
@@ -27553,12 +28772,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) {
@@ -28197,7 +29421,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();
@@ -28287,9 +29518,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);
   }
@@ -28502,6 +29737,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 || [];
@@ -28548,7 +29793,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,
@@ -28558,7 +29803,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
@@ -28576,16 +29821,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 {
@@ -28673,20 +29922,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;
@@ -28850,19 +30103,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");
@@ -29120,7 +30378,8 @@ var piCodingAgentChannels = defineChannels(
       channelName: "AgentSession.prompt",
       kind: "async"
     })
-  }
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.PI_CODING_AGENT }
 );
 
 // src/instrumentation/plugins/pi-coding-agent-plugin.ts
@@ -29204,14 +30463,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];
@@ -29381,15 +30645,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,
@@ -29557,15 +30826,20 @@ async function startPiToolSpan(state, event) {
     "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 */ }
-    });
+    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
@@ -29997,20 +31271,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;
@@ -30165,22 +31443,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,
@@ -30202,22 +31490,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,
@@ -30319,17 +31617,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,
@@ -30381,20 +31684,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,
@@ -30465,11 +31773,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 } : {},
@@ -31583,17 +32896,20 @@ var BraintrustObservabilityExporter = class {
   }
   onStart(exported) {
     if (this.spans.has(exported.id)) return;
-    const args = {
-      name: exported.name,
-      spanAttributes: { type: spanTypeFor(exported.type) },
-      startTime: epochSeconds(exported.startTime),
-      // Use the Mastra span id as the Braintrust row id so that
-      // `logFeedback({ id: <mastra span id> })` (and Mastra's score events)
-      // attach to the right row. Without this, `SpanImpl` auto-generates a
-      // row id (`this._id = eventId ?? idGenerator.getSpanId()`) that no
-      // external caller could know.
-      event: { id: exported.id }
-    };
+    const args = withSpanInstrumentationName(
+      {
+        name: exported.name,
+        spanAttributes: { type: spanTypeFor(exported.type) },
+        startTime: epochSeconds(exported.startTime),
+        // Use the Mastra span id as the Braintrust row id so that
+        // `logFeedback({ id: <mastra span id> })` (and Mastra's score events)
+        // attach to the right row. Without this, `SpanImpl` auto-generates a
+        // row id (`this._id = eventId ?? idGenerator.getSpanId()`) that no
+        // external caller could know.
+        event: { id: exported.id }
+      },
+      INSTRUMENTATION_NAMES.MASTRA
+    );
     const parentRecord = exported.parentSpanId ? this.spans.get(exported.parentSpanId) : void 0;
     if (!this.capturedParent) {
       const probe = currentSpan();
@@ -31668,7 +32984,13 @@ function configureNode() {
   isomorph_default.getPastNAncestors = getPastNAncestors;
   isomorph_default.getEnv = (name) => {
     const value = process.env[name];
-    return name === "BRAINTRUST_API_KEY" && !value?.trim() ? void 0 : value;
+    if (name === "BRAINTRUST_API_KEY") {
+      return value?.trim() ? value : void 0;
+    }
+    if ((name === "BRAINTRUST_ENVIRONMENT_TYPE" || name === "BRAINTRUST_ENVIRONMENT_NAME") && !value?.trim()) {
+      return getNearestBraintrustEnvValue(name);
+    }
+    return value;
   };
   isomorph_default.getBraintrustApiKey = async () => {
     const value = process.env.BRAINTRUST_API_KEY;
@@ -31744,6 +33066,12 @@ function configureNode() {
   isomorph_default.gzip = promisify(zlib.gzip);
   isomorph_default.gunzip = promisify(zlib.gunzip);
   isomorph_default.hash = (data) => crypto.createHash("sha256").update(data).digest("hex");
+  isomorph_default.hmacSha256 = (key, data) => crypto.createHmac("sha256", key).update(data).digest("hex");
+  isomorph_default.timingSafeEqual = (left, right) => {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    return leftBuffer.length === rightBuffer.length && crypto.timingSafeEqual(leftBuffer, rightBuffer);
+  };
   _internalSetInitialState();
   const disabled = readDisabledInstrumentationEnvConfig(
     isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION")
@@ -31753,6 +33081,24 @@ function configureNode() {
   }
   registry.enable();
 }
+function getNearestBraintrustEnvValue(name) {
+  for (let dir2 = process.cwd(), depth = 0; depth <= BRAINTRUST_ENV_SEARCH_PARENT_LIMIT; dir2 = path.dirname(dir2), depth++) {
+    const envPath = path.join(dir2, ".env.braintrust");
+    try {
+      const parsed = dotenv.parse(fsSync.readFileSync(envPath, "utf8"));
+      const value = parsed[name];
+      return value?.trim() ? value : void 0;
+    } catch (e) {
+      if (typeof e !== "object" || e === null || !("code" in e) || e.code !== "ENOENT") {
+        return void 0;
+      }
+    }
+    if (path.dirname(dir2) === dir2) {
+      break;
+    }
+  }
+  return void 0;
+}
 
 // dev/server.ts
 import express from "express";
@@ -32897,6 +34243,10 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     this._state = _state;
     this.spanTypeFilter = spanTypeFilter;
   }
+  _objectId;
+  rootSpanId;
+  _state;
+  spanTypeFilter;
   static buildFilter(rootSpanId, spanTypeFilter, includeScorers = false) {
     const children = [
       // Base filter: root_span_id = 'value'
@@ -33344,6 +34694,8 @@ var EvalResultWithSummary = class {
     this.summary = summary;
     this.results = results;
   }
+  summary;
+  results;
   /**
    * @deprecated Use `summary` instead.
    */
@@ -34042,26 +35394,30 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         }
       }
     })();
+    let timeoutId;
+    let abortHandler;
+    const cleanupCancellation = () => {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      if (abortHandler && evaluator.signal) {
+        evaluator.signal.removeEventListener("abort", abortHandler);
+        abortHandler = void 0;
+      }
+    };
     const cancel = async () => {
       await new Promise((_, reject2) => {
         if (cancelled) {
           reject2(new InternalAbortError("Evaluator already cancelled"));
           return;
         }
-        let timeoutId;
-        let abortHandler;
         const rejectOnce = (error) => {
           if (cancelled) {
             return;
           }
           cancelled = true;
-          if (timeoutId) {
-            clearTimeout(timeoutId);
-            timeoutId = void 0;
-          }
-          if (abortHandler && evaluator.signal) {
-            evaluator.signal.removeEventListener("abort", abortHandler);
-          }
+          cleanupCancellation();
           reject2(error);
         };
         if (evaluator.timeout) {
@@ -34101,6 +35457,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       }
       throw e;
     } finally {
+      cleanupCancellation();
       if (!collectResults) {
         collectedResults.length = 0;
       }
@@ -34636,6 +35993,7 @@ var ToolBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   taskCounter = 0;
   // This type definition is just a catch all so that the implementation can be
   // less specific than the two more specific declarations above.
@@ -34666,6 +36024,7 @@ var ScorerBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   taskCounter = 0;
   create(opts) {
     this.taskCounter++;
@@ -34725,6 +36084,7 @@ var ClassifierBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   taskCounter = 0;
   create(opts) {
     this.taskCounter++;
@@ -34760,6 +36120,7 @@ var CodeFunction = class {
       throw new Error("parameters are required if return type is defined");
     }
   }
+  project;
   handler;
   name;
   slug;
@@ -34847,6 +36208,7 @@ var PromptBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   create(opts) {
     const toolFunctions = [];
     const rawTools = [];
@@ -34923,6 +36285,7 @@ var ParametersBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   create(opts) {
     const slug = opts.slug ?? slugify(opts.name, { lower: true, strict: true });
     const codeParameters = new CodeParameters(this.project, {