braintrust 3.23.1 → 3.25.0

package/dist/auto-instrumentations/{chunk-YXLNSAMJ.mjs → chunk-CZ24KNHT.mjs}

@@ -15,6 +15,7 @@ var DefaultChannel = class {
   constructor(name) {
     this.name = name;
   }
+  name;
   hasSubscribers = false;
   subscribe(_subscription) {
   }
@@ -100,7 +101,8 @@ var isomorph_default = iso;
 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}`;
@@ -113,6 +115,7 @@ function defineChannels(pkg, channels) {
           key,
           {
             ...asyncSpec,
+            instrumentationName,
             tracingChannel: tracingChannel2,
             tracePromise: (fn, context) => tracingChannel2().tracePromise(
               fn,
@@ -130,6 +133,7 @@ function defineChannels(pkg, channels) {
         key,
         {
           ...syncSpec,
+          instrumentationName,
           tracingChannel,
           traceSync: (fn, context) => tracingChannel().traceSync(
             fn,
@@ -142,45 +146,79 @@ function defineChannels(pkg, channels) {
   );
 }
 
+// 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"
+};
+
 // 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/auto-instrumentations/configs/openai.ts
 var openaiConfigs = [
@@ -362,16 +400,20 @@ var openaiConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/openai-codex.ts
 var openAICodexVersionRange = ">=0.128.0 <1.0.0";
@@ -405,20 +447,24 @@ var openAICodexConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/anthropic.ts
 var anthropicConfigs = [
@@ -541,15 +587,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/auto-instrumentations/configs/bedrock-runtime.ts
 var bedrockRuntimeConfigs = [
@@ -608,77 +666,127 @@ var bedrockRuntimeConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/ai-sdk.ts
 var aiSDKConfigs = [
+  // HarnessAgent turn methods are published only from the package's ESM
+  // `./agent` entrypoint. The compiled class expression is anonymous, so match
+  // the first async method with each public name instead of a class name.
+  ...[
+    ["createSession", harnessAgentChannels.createSession.channelName],
+    ["generate", harnessAgentChannels.generate.channelName],
+    ["stream", harnessAgentChannels.stream.channelName],
+    ["continueGenerate", harnessAgentChannels.continueGenerate.channelName],
+    ["continueStream", harnessAgentChannels.continueStream.channelName]
+  ].map(([methodName, channelName]) => ({
+    channelName,
+    module: {
+      name: "@ai-sdk/harness",
+      versionRange: ">=1.0.0 <2.0.0",
+      filePath: "dist/agent/index.js"
+    },
+    functionQuery: {
+      methodName,
+      kind: "Async",
+      index: 0
+    }
+  })),
   // generateText - async function
   {
     channelName: aiSDKChannels.generateText.channelName,
@@ -1057,7 +1165,8 @@ var claudeAgentSDKChannels = defineChannels(
       channelName: "query",
       kind: "sync-stream"
     })
-  }
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK }
 );
 
 // src/auto-instrumentations/configs/claude-agent-sdk.ts
@@ -1092,24 +1201,28 @@ var claudeAgentSDKConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/cursor-sdk.ts
 var cursorSDKVersionRange = ">=1.0.7 <2.0.0";
@@ -1157,24 +1270,28 @@ var cursorSDKConfigs = cursorSDKEntrypoints.flatMap((filePath) => [
 ]);
 
 // 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/auto-instrumentations/configs/openai-agents.ts
 var lifecycleMethods = [
@@ -1202,24 +1319,28 @@ var openAIAgentsCoreConfigs = lifecycleMethods.flatMap(
 );
 
 // 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/auto-instrumentations/configs/google-genai.ts
 var googleGenAIConfigs = [
@@ -1299,28 +1420,32 @@ var googleGenAIConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/huggingface.ts
 var huggingFaceConfigs = [
@@ -1567,20 +1692,24 @@ var huggingFaceConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/openrouter-agent.ts
 var openRouterAgentConfigs = [
@@ -1599,38 +1728,40 @@ var openRouterAgentConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/openrouter.ts
 var openRouterConfigs = [
@@ -1638,7 +1769,7 @@ var openRouterConfigs = [
     channelName: openRouterChannels.chatSend.channelName,
     module: {
       name: "@openrouter/sdk",
-      versionRange: ">=0.9.11 <1.0.0",
+      versionRange: ">=0.9.11 <2.0.0",
       filePath: "esm/sdk/chat.js"
     },
     functionQuery: {
@@ -1651,7 +1782,7 @@ var openRouterConfigs = [
     channelName: openRouterChannels.embeddingsGenerate.channelName,
     module: {
       name: "@openrouter/sdk",
-      versionRange: ">=0.9.11 <1.0.0",
+      versionRange: ">=0.9.11 <2.0.0",
       filePath: "esm/sdk/embeddings.js"
     },
     functionQuery: {
@@ -1664,7 +1795,7 @@ var openRouterConfigs = [
     channelName: openRouterChannels.rerankRerank.channelName,
     module: {
       name: "@openrouter/sdk",
-      versionRange: ">=0.12.0 <1.0.0",
+      versionRange: ">=0.12.0 <2.0.0",
       filePath: "esm/sdk/rerank.js"
     },
     functionQuery: {
@@ -1677,7 +1808,7 @@ var openRouterConfigs = [
     channelName: openRouterChannels.betaResponsesSend.channelName,
     module: {
       name: "@openrouter/sdk",
-      versionRange: ">=0.9.11 <1.0.0",
+      versionRange: ">=0.9.11 <2.0.0",
       filePath: "esm/sdk/responses.js"
     },
     functionQuery: {
@@ -1690,7 +1821,7 @@ var openRouterConfigs = [
     channelName: openRouterChannels.callModel.channelName,
     module: {
       name: "@openrouter/sdk",
-      versionRange: ">=0.9.11 <1.0.0",
+      versionRange: ">=0.9.11 <2.0.0",
       filePath: "esm/sdk/sdk.js"
     },
     functionQuery: {
@@ -1702,52 +1833,56 @@ var openRouterConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/mistral.ts
 var mistralConfigs = [
@@ -2040,20 +2175,24 @@ var mistralConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/google-adk.ts
 var googleADKVersionRange = ">=0.1.0";
@@ -2284,24 +2423,28 @@ var googleADKConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/cohere.ts
 var cohereConfigs = [
@@ -2568,18 +2711,20 @@ var cohereConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/groq.ts
 var groqConfigs = [
@@ -2612,38 +2757,46 @@ var groqConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/genkit.ts
 var genkitVersionRange = ">=1.0.0 <2.0.0";
@@ -2805,20 +2958,24 @@ var genkitConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/github-copilot.ts
 var gitHubCopilotConfigs = [
@@ -2909,16 +3066,20 @@ var gitHubCopilotConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/langchain.ts
 var langChainCoreVersionRange = ">=0.3.42";
@@ -2953,20 +3114,24 @@ var langchainConfigs = [
 ];
 
 // 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/auto-instrumentations/configs/langsmith.ts
 var versionRange = ">=0.3.30 <1.0.0";
@@ -3010,11 +3175,12 @@ var piCodingAgentChannels = defineChannels(
       channelName: "AgentSession.prompt",
       kind: "async"
     })
-  }
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.PI_CODING_AGENT }
 );
 
 // src/auto-instrumentations/configs/pi-coding-agent.ts
-var piCodingAgentVersionRange = ">=0.79.0 <0.80.0";
+var piCodingAgentVersionRange = ">=0.79.0 <0.82.0";
 var piCodingAgentConfigs = [
   {
     channelName: piCodingAgentChannels.prompt.channelName,
@@ -3034,6 +3200,7 @@ var piCodingAgentConfigs = [
 export {
   channel,
   defineChannels,
+  INSTRUMENTATION_NAMES,
   openaiConfigs,
   openAICodexConfigs,
   anthropicConfigs,