braintrust 3.26.0 → 3.28.0

package/dist/auto-instrumentations/bundler/esbuild.cjs

@@ -56,8 +56,10 @@ var GLOBAL_INSTRUMENTATION_HOOKS_KEY = "__braintrust_instrumentation_hooks";
 var GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION = 1;
 var GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND = "braintrust.global-instrumentation-hooks.registry";
 var GLOBAL_INSTRUMENTATION_HOOK_BRAND = "braintrust.global-instrumentation-hooks.hook";
+var GLOBAL_INVOCATION_HOOK_BRAND = "braintrust.global-instrumentation-hooks.invocation-hook";
 var registryBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND);
 var hookBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOK_BRAND);
+var invocationHookBrand = Symbol.for(GLOBAL_INVOCATION_HOOK_BRAND);
 var errorReporter;
 function reportError(error) {
   try {
@@ -193,12 +195,69 @@ var traceEvents = [
   "asyncEnd",
   "error"
 ];
+function traceInvocation(hook, operator, target, thisArg, args, additional, callbackIndex = -1) {
+  const context = {
+    ...additional,
+    arguments: args,
+    self: thisArg
+  };
+  const invoke = () => hook.invoke(target, thisArg, args, additional);
+  if (operator === "traceCallback") {
+    return hook.traceCallback(invoke, callbackIndex, context);
+  }
+  if (operator === "tracePromise") {
+    return hook.tracePromise(invoke, context);
+  }
+  return hook.traceSync(invoke, context);
+}
+var InvocationHook = class {
+  interceptors = [];
+  get hasInterceptors() {
+    return this.interceptors.length > 0;
+  }
+  intercept(interceptor) {
+    if (typeof interceptor !== "function") {
+      throw new TypeError("interceptor must be a function");
+    }
+    this.interceptors = [...this.interceptors, interceptor];
+    let active = true;
+    return () => {
+      if (!active) {
+        return;
+      }
+      active = false;
+      const index = this.interceptors.indexOf(interceptor);
+      if (index !== -1) {
+        this.interceptors = [
+          ...this.interceptors.slice(0, index),
+          ...this.interceptors.slice(index + 1)
+        ];
+      }
+    };
+  }
+  invoke(target, thisArg, args, additional) {
+    const interceptors = this.interceptors;
+    if (interceptors.length === 0) {
+      return Reflect.apply(target, thisArg, args);
+    }
+    let next = target;
+    for (let index = interceptors.length - 1; index >= 0; index -= 1) {
+      const interceptor = interceptors[index];
+      const downstream = next;
+      next = function(...nextArgs) {
+        return interceptor(downstream, this, nextArgs, additional);
+      };
+    }
+    return Reflect.apply(next, thisArg, args);
+  }
+};
 var TracingHook = class {
   start;
   end;
   asyncStart;
   asyncEnd;
   error;
+  invocationHook = new InvocationHook();
   constructor(nameOrChannels) {
     Object.defineProperty(this, hookBrand, {
       configurable: false,
@@ -206,6 +265,12 @@ var TracingHook = class {
       value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
       writable: false
     });
+    Object.defineProperty(this, invocationHookBrand, {
+      configurable: false,
+      enumerable: false,
+      value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+      writable: false
+    });
     if (typeof nameOrChannels === "string") {
       this.start = new HookChannel(`tracing:${nameOrChannels}:start`);
       this.end = new HookChannel(`tracing:${nameOrChannels}:end`);
@@ -223,6 +288,26 @@ var TracingHook = class {
   get hasSubscribers() {
     return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
   }
+  get hasInterceptors() {
+    return this.invocationHook.hasInterceptors;
+  }
+  intercept(interceptor) {
+    return this.invocationHook.intercept(interceptor);
+  }
+  invoke(target, thisArg, args, additional) {
+    return this.invocationHook.invoke(target, thisArg, args, additional);
+  }
+  traceInvocation(operator, target, thisArg, args, additional, callbackIndex = -1) {
+    return traceInvocation(
+      this,
+      operator,
+      target,
+      thisArg,
+      args,
+      additional,
+      callbackIndex
+    );
+  }
   subscribe(handlers) {
     for (const eventName of traceEvents) {
       const handler = handlers[eventName];
@@ -444,6 +529,60 @@ function hasTracingHookShape(value) {
     return false;
   }
 }
+function hasInvocationHookShape(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  try {
+    const hook = value;
+    return value[invocationHookBrand] === GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION && typeof hook.hasInterceptors === "boolean" && typeof hook.intercept === "function" && typeof hook.invoke === "function";
+  } catch {
+    return false;
+  }
+}
+function installInvocationHook(value) {
+  const hasInvocationHook = hasInvocationHookShape(value);
+  const invocationHook = new InvocationHook();
+  try {
+    if (!hasInvocationHook) {
+      Object.defineProperties(value, {
+        [invocationHookBrand]: {
+          configurable: false,
+          enumerable: false,
+          value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+          writable: false
+        },
+        hasInterceptors: {
+          configurable: false,
+          enumerable: false,
+          get: () => invocationHook.hasInterceptors
+        },
+        intercept: {
+          configurable: false,
+          enumerable: false,
+          value: invocationHook.intercept.bind(invocationHook),
+          writable: false
+        },
+        invoke: {
+          configurable: false,
+          enumerable: false,
+          value: invocationHook.invoke.bind(invocationHook),
+          writable: false
+        }
+      });
+    }
+    if (typeof value.traceInvocation !== "function") {
+      Object.defineProperty(value, "traceInvocation", {
+        configurable: false,
+        enumerable: false,
+        value: traceInvocation.bind(void 0, value),
+        writable: false
+      });
+    }
+  } catch (error) {
+    reportError(error);
+  }
+}
 function isCompatibleTracingHook(value) {
   try {
     return value[hookBrand] === GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION && hasTracingHookShape(value);
@@ -530,6 +669,7 @@ function newGlobalTracingChannel(nameOrChannels) {
     return inertTracingHook;
   }
   if (isCompatibleTracingHook(existing)) {
+    installInvocationHook(existing);
     return existing;
   }
   if (existing !== void 0) {
@@ -566,8 +706,7 @@ var transforms = {
   tracingHookDeclaration(state, node) {
     const {
       channelName,
-      module: { name },
-      operator
+      module: { name }
     } = state;
     const channelVariable = formatChannelVariable(channelName);
     const channelGetter = formatChannelGetter(channelName);
@@ -580,7 +719,7 @@ var transforms = {
       return;
     }
     const sharedHookLookup = hasSharedHookLookup ? "" : `
-      const ${SHARED_HOOK_LOOKUP} = (__bt$hookName, __bt$operator) => {
+      const ${SHARED_HOOK_LOOKUP} = (__bt$hookName) => {
         try {
           const __bt$hooks = globalThis[${JSON.stringify(
       GLOBAL_INSTRUMENTATION_HOOKS_KEY
@@ -602,8 +741,7 @@ var transforms = {
             __bt$hook[Symbol.for(${JSON.stringify(
       GLOBAL_INSTRUMENTATION_HOOK_BRAND
     )})] !== ${GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION} ||
-            typeof __bt$hook.hasSubscribers !== "boolean" ||
-            typeof __bt$hook[__bt$operator] !== "function"
+            typeof __bt$hook.traceInvocation !== "function"
           ) return undefined;
           return __bt$hook;
         } catch {
@@ -616,8 +754,7 @@ var transforms = {
       let ${channelVariable};
       const ${channelGetter} = () =>
         ${channelVariable} ??= ${SHARED_HOOK_LOOKUP}(
-          ${JSON.stringify(`orchestrion:${name}:${channelName}`)},
-          ${JSON.stringify(operator)}
+          ${JSON.stringify(`orchestrion:${name}:${channelName}`)}
         );
     `;
     const sharedHookLookupIndex = node.body.findIndex(
@@ -692,28 +829,18 @@ function traceInstanceMethod(state, node, program) {
   ctor.value.body.body.push(...ctorBody);
 }
 function wrap(state, node) {
-  const { operator, moduleVersion } = state;
-  const wrapper = operator === "traceCallback" ? wrapCallback(state) : operator === "tracePromise" ? wrapPromise(state) : wrapSync(state);
+  const wrapper = wrapInvocation(state);
   const block = wrapper.body[0].body;
   const common = (0, import_meriyah.parse)(
     node.type === "ArrowFunctionExpression" ? `
-    const __bt$ctx = {
-      arguments,
-      moduleVersion: ${JSON.stringify(moduleVersion)}
-    };
-    const __bt$traced = () => {
+    const __bt$target = (...__bt$args) => {
       const __bt$wrapped = () => {};
-      return __bt$wrapped(...arguments);
+      return __bt$wrapped(...__bt$args);
     };
   ` : `
-    const __bt$ctx = {
-      arguments,
-      self: this,
-      moduleVersion: ${JSON.stringify(moduleVersion)}
-    };
-    const __bt$traced = () => {
+    const __bt$target = function (...__bt$args) {
       const __bt$wrapped = () => {};
-      return __bt$wrapped.apply(this, arguments);
+      return __bt$wrapped.apply(this, __bt$args);
     };
   `
   ).body;
@@ -755,49 +882,25 @@ function wrapSuper(node) {
     node.body.body.unshift((0, import_meriyah.parse)("const __bt$super = {}").body[0]);
   }
 }
-function wrapCallback(state) {
-  const {
-    channelName,
-    functionQuery: { callbackIndex = -1 }
-  } = state;
+function wrapInvocation(state) {
+  const { channelName, moduleVersion, operator, functionQuery } = state;
   const channelGetter = formatChannelGetter(channelName);
+  const callbackIndex = functionQuery.callbackIndex ?? -1;
   return (0, import_meriyah.parse)(`
     function wrapper () {
       const __bt$hook = ${channelGetter}();
-      if (!__bt$hook?.hasSubscribers) return __bt$traced();
-      __bt$ctx.self ??= this;
-      return __bt$hook.traceCallback(
-        __bt$traced,
-        ${callbackIndex},
-        __bt$ctx
+      if (!__bt$hook) return __bt$target.apply(this, arguments);
+      return __bt$hook.traceInvocation(
+        ${JSON.stringify(operator)},
+        __bt$target,
+        this,
+        arguments,
+        { moduleVersion: ${JSON.stringify(moduleVersion)} },
+        ${callbackIndex}
       );
     }
   `);
 }
-function wrapPromise(state) {
-  const { channelName } = state;
-  const channelGetter = formatChannelGetter(channelName);
-  return (0, import_meriyah.parse)(`
-    function wrapper () {
-      const __bt$hook = ${channelGetter}();
-      if (!__bt$hook?.hasSubscribers) return __bt$traced();
-      __bt$ctx.self ??= this;
-      return __bt$hook.tracePromise(__bt$traced, __bt$ctx);
-    }
-  `);
-}
-function wrapSync(state) {
-  const { channelName } = state;
-  const channelGetter = formatChannelGetter(channelName);
-  return (0, import_meriyah.parse)(`
-    function wrapper () {
-      const __bt$hook = ${channelGetter}();
-      if (!__bt$hook?.hasSubscribers) return __bt$traced();
-      __bt$ctx.self ??= this;
-      return __bt$hook.traceSync(__bt$traced, __bt$ctx);
-    }
-  `);
-}
 
 // src/auto-instrumentations/orchestrion-js/transformer.ts
 var Transformer = class {
@@ -1073,6 +1176,7 @@ var envIntegrationAliases = {
   cloudflareaichat: "cloudflareAIChat",
   "cloudflare-ai-chat": "cloudflareAIChat",
   "@cloudflare/ai-chat": "cloudflareAIChat",
+  cloudflarethink: "cloudflareThink",
   cursor: "cursor",
   "cursor-sdk": "cursorSDK",
   cursorsdk: "cursorSDK",
@@ -1093,6 +1197,7 @@ var envIntegrationAliases = {
   openrouteragent: "openrouterAgent",
   "openrouter-agent": "openrouterAgent",
   mistral: "mistral",
+  ollama: "ollama",
   googleadk: "googleADK",
   "google-adk": "googleADK",
   cohere: "cohere",
@@ -1113,7 +1218,10 @@ var envIntegrationAliases = {
   "langchain-js": "langchain",
   "@langchain": "langchain",
   langgraph: "langgraph",
-  langsmith: "langsmith"
+  langsmith: "langsmith",
+  voyage: "voyageai",
+  "voyage-ai": "voyageai",
+  voyageai: "voyageai"
 };
 function readDisabledInstrumentationEnvConfig(disabledList) {
   const integrations = {};
@@ -1178,11 +1286,21 @@ function defineChannels(pkg, channels, options) {
         const tracingChannel2 = () => isomorph_default.newTracingChannel(
           fullChannelName
         );
+        const intercept2 = (interceptor) => {
+          const hook = tracingChannel2();
+          return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+          };
+        };
         return [
           key,
           {
             ...asyncSpec,
             instrumentationName,
+            intercept: intercept2,
+            invoke: (target, thisArg, args, additional) => {
+              const hook = tracingChannel2();
+              return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+            },
             tracingChannel: tracingChannel2,
             tracePromise: (fn, context) => tracingChannel2().tracePromise(
               fn,
@@ -1196,11 +1314,21 @@ function defineChannels(pkg, channels, options) {
       const tracingChannel = () => isomorph_default.newTracingChannel(
         fullChannelName
       );
+      const intercept = (interceptor) => {
+        const hook = tracingChannel();
+        return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+        };
+      };
       return [
         key,
         {
           ...syncSpec,
           instrumentationName,
+          intercept,
+          invoke: (target, thisArg, args, additional) => {
+            const hook = tracingChannel();
+            return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+          },
           tracingChannel,
           traceSync: (fn, context) => tracingChannel().traceSync(
             fn,
@@ -1222,6 +1350,7 @@ var INSTRUMENTATION_NAMES = {
   CLAUDE_AGENT_SDK: "claude-agent-sdk",
   CLOUDFLARE_AI_CHAT: "cloudflare-ai-chat",
   CLOUDFLARE_AGENTS: "cloudflare-agents",
+  CLOUDFLARE_THINK: "cloudflare-think",
   COHERE: "cohere",
   CURSOR_SDK: "cursor-sdk",
   EVE: "eve",
@@ -1236,13 +1365,15 @@ var INSTRUMENTATION_NAMES = {
   LANGSMITH: "langsmith",
   MASTRA: "mastra",
   MISTRAL: "mistral",
+  OLLAMA: "ollama",
   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"
+  STRANDS_AGENT_SDK: "strands-agent-sdk",
+  VOYAGEAI: "voyageai"
 };
 
 // src/instrumentation/plugins/ai-sdk-channels.ts
@@ -1752,6 +1883,14 @@ var anthropicChannels = defineChannels(
     betaMessagesToolRunner: channel({
       channelName: "beta.messages.toolRunner",
       kind: "sync-stream"
+    }),
+    betaSessionsEventsStream: channel({
+      channelName: "beta.sessions.events.stream",
+      kind: "async"
+    }),
+    betaSessionsThreadsEventsStream: channel({
+      channelName: "beta.sessions.threads.events.stream",
+      kind: "async"
     })
   },
   { instrumentationName: INSTRUMENTATION_NAMES.ANTHROPIC }
@@ -1870,7 +2009,40 @@ var anthropicConfigs = [
       methodName: "toolRunner",
       kind: "Sync"
     }
-  }
+  },
+  // Managed Agents Sessions event streams are discovered automatically, but
+  // remain passive until the user calls collectAnthropicSession() on the
+  // returned stream.
+  ...["mjs", "js"].map(
+    (extension) => ({
+      channelName: anthropicChannels.betaSessionsEventsStream.channelName,
+      module: {
+        name: "@anthropic-ai/sdk",
+        versionRange: ">=0.86.0",
+        filePath: `resources/beta/sessions/events.${extension}`
+      },
+      functionQuery: {
+        className: "Events",
+        methodName: "stream",
+        kind: "Async"
+      }
+    })
+  ),
+  ...["mjs", "js"].map(
+    (extension) => ({
+      channelName: anthropicChannels.betaSessionsThreadsEventsStream.channelName,
+      module: {
+        name: "@anthropic-ai/sdk",
+        versionRange: ">=0.86.0",
+        filePath: `resources/beta/sessions/threads/events.${extension}`
+      },
+      functionQuery: {
+        className: "Events",
+        methodName: "stream",
+        kind: "Async"
+      }
+    })
+  )
 ];
 
 // src/instrumentation/plugins/bedrock-runtime-channels.ts
@@ -2067,6 +2239,36 @@ var cloudflareAgentsConfigs = [
   }
 ];
 
+// src/instrumentation/plugins/cloudflare-think-channels.ts
+var cloudflareThinkChannels = defineChannels(
+  "@cloudflare/think",
+  {
+    runInferenceLoop: channel({
+      channelName: "Think.runInferenceLoop",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLOUDFLARE_THINK }
+);
+
+// src/auto-instrumentations/configs/cloudflare-think.ts
+var cloudflareThinkVersionRange = ">=0.13.0 <0.14.0";
+var cloudflareThinkConfigs = [
+  {
+    channelName: cloudflareThinkChannels.runInferenceLoop.channelName,
+    module: {
+      name: "@cloudflare/think",
+      versionRange: cloudflareThinkVersionRange,
+      filePath: "dist/think.js"
+    },
+    functionQuery: {
+      className: "Think",
+      methodName: "_runInferenceLoop",
+      kind: "Async"
+    }
+  }
+];
+
 // src/instrumentation/plugins/cohere-channels.ts
 var cohereChannels = defineChannels(
   "cohere-ai",
@@ -3950,6 +4152,51 @@ var mistralConfigs = [
   }
 ];
 
+// src/instrumentation/plugins/ollama-channels.ts
+var ollamaChannels = defineChannels(
+  "ollama",
+  {
+    chat: channel({
+      channelName: "chat",
+      kind: "async"
+    }),
+    generate: channel({
+      channelName: "generate",
+      kind: "async"
+    }),
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OLLAMA }
+);
+
+// src/auto-instrumentations/configs/ollama.ts
+var methods = [
+  ["chat", ollamaChannels.chat.channelName],
+  ["generate", ollamaChannels.generate.channelName],
+  ["embed", ollamaChannels.embed.channelName]
+];
+var implementationFiles = ["dist/browser.mjs", "dist/browser.cjs"];
+var ollamaConfigs = [
+  ...implementationFiles.flatMap(
+    (filePath) => methods.map(([methodName, channelName]) => ({
+      channelName,
+      module: {
+        name: "ollama",
+        versionRange: ">=0.6.0 <0.7.0",
+        filePath
+      },
+      functionQuery: {
+        className: "Ollama",
+        methodName,
+        kind: "Async"
+      }
+    }))
+  )
+];
+
 // src/instrumentation/plugins/openai-agents-channels.ts
 var openAIAgentsCoreChannels = defineChannels(
   "@openai/agents-core",
@@ -4359,6 +4606,19 @@ var openRouterConfigs = [
       kind: "Async"
     }
   },
+  {
+    channelName: openRouterChannels.betaResponsesSend.channelName,
+    module: {
+      name: "@openrouter/sdk",
+      versionRange: ">=1.1.2 <2.0.0",
+      filePath: "esm/sdk/betaresponses.js"
+    },
+    functionQuery: {
+      className: "BetaResponses",
+      methodName: "send",
+      kind: "Async"
+    }
+  },
   {
     channelName: openRouterChannels.callModel.channelName,
     module: {
@@ -4504,6 +4764,77 @@ var strandsAgentSDKConfigs = [
   }
 ];
 
+// src/instrumentation/plugins/voyageai-channels.ts
+var voyageAIChannels = defineChannels(
+  "voyageai",
+  {
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    }),
+    multimodalEmbed: channel({
+      channelName: "multimodalEmbed",
+      kind: "async"
+    }),
+    rerank: channel({
+      channelName: "rerank",
+      kind: "async"
+    }),
+    contextualizedEmbed: channel({
+      channelName: "contextualizedEmbed",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.VOYAGEAI }
+);
+
+// src/auto-instrumentations/configs/voyageai.ts
+var GENERATED_CLIENT_MODULES = [
+  "dist/cjs/Client.js",
+  "dist/esm/Client.mjs"
+];
+var generatedClientOperations = [
+  {
+    channelName: voyageAIChannels.embed.channelName,
+    methodName: "embed",
+    versionRange: ">=0.2.0 <1.0.0"
+  },
+  {
+    channelName: voyageAIChannels.multimodalEmbed.channelName,
+    methodName: "multimodalEmbed",
+    versionRange: ">=0.2.0 <1.0.0"
+  },
+  {
+    channelName: voyageAIChannels.rerank.channelName,
+    methodName: "rerank",
+    versionRange: ">=0.2.0 <1.0.0"
+  },
+  {
+    channelName: voyageAIChannels.contextualizedEmbed.channelName,
+    methodName: "contextualizedEmbed",
+    versionRange: ">=0.2.0 <1.0.0"
+  }
+];
+var voyageAIConfigs = [
+  ...GENERATED_CLIENT_MODULES.flatMap(
+    (filePath) => generatedClientOperations.map(
+      ({ channelName, methodName, versionRange: versionRange2 }) => ({
+        channelName,
+        module: {
+          name: "voyageai",
+          versionRange: versionRange2,
+          filePath
+        },
+        functionQuery: {
+          className: "VoyageAIClient",
+          methodName,
+          kind: "Async"
+        }
+      })
+    )
+  )
+];
+
 // src/auto-instrumentations/configs/all.ts
 var defaultInstrumentationConfigGroups = [
   { integrations: ["openai"], configs: openaiConfigs },
@@ -4532,6 +4863,10 @@ var defaultInstrumentationConfigGroups = [
     integrations: ["cloudflareAgents"],
     configs: cloudflareAgentsConfigs
   },
+  {
+    integrations: ["cloudflareThink"],
+    configs: cloudflareThinkConfigs
+  },
   { integrations: ["cursor", "cursorSDK"], configs: cursorSDKConfigs },
   {
     integrations: ["openAIAgents"],
@@ -4556,6 +4891,7 @@ var defaultInstrumentationConfigGroups = [
     configs: openRouterAgentConfigs
   },
   { integrations: ["mistral"], configs: mistralConfigs },
+  { integrations: ["ollama"], configs: ollamaConfigs },
   { integrations: ["googleADK"], configs: googleADKConfigs },
   { integrations: ["cohere"], configs: cohereConfigs },
   { integrations: ["groq"], configs: groqConfigs },
@@ -4578,6 +4914,10 @@ var defaultInstrumentationConfigGroups = [
   {
     integrations: ["flue"],
     configs: flueConfigs
+  },
+  {
+    integrations: ["voyageai"],
+    configs: voyageAIConfigs
   }
   // Note: `@mastra/core` is not listed here because its instrumentation
   // doesn't go through the AST `code-transformer` matcher — Mastra's
@@ -4811,6 +5151,49 @@ function applySpecialCasePatch(input) {
   return null;
 }
 
+// src/auto-instrumentations/loader/get-package-version.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var packageNames = /* @__PURE__ */ new Map();
+function readPackageJson(baseDir) {
+  try {
+    const packageJsonPath = (0, import_node_path.join)(baseDir, "package.json");
+    const jsonFile = (0, import_node_fs.readFileSync)(packageJsonPath, "utf8");
+    return JSON.parse(jsonFile);
+  } catch {
+    return void 0;
+  }
+}
+function resolvePackageBaseDir(baseDir) {
+  try {
+    return (0, import_node_fs.realpathSync)(baseDir);
+  } catch {
+    return baseDir;
+  }
+}
+function readPackageJsonWithFallback(baseDir) {
+  const packageJson = readPackageJson(baseDir);
+  if (packageJson) {
+    return packageJson;
+  }
+  const resolvedBaseDir = resolvePackageBaseDir(baseDir);
+  if (resolvedBaseDir === baseDir) {
+    return void 0;
+  }
+  return readPackageJson(resolvedBaseDir);
+}
+function getPackageName(baseDir) {
+  if (packageNames.has(baseDir)) {
+    return packageNames.get(baseDir);
+  }
+  const packageJson = readPackageJsonWithFallback(baseDir);
+  if (typeof packageJson?.name === "string") {
+    packageNames.set(baseDir, packageJson.name);
+    return packageJson.name;
+  }
+  return void 0;
+}
+
 // src/auto-instrumentations/bundler/plugin.ts
 function getModuleVersion(basedir) {
   try {
@@ -4832,6 +5215,20 @@ var unplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   return {
     name: "code-transformer",
     enforce: "pre",
+    transformInclude(id) {
+      const pathWithoutQuery = id.split("?", 1)[0];
+      if (!pathWithoutQuery) {
+        return false;
+      }
+      if (pathWithoutQuery.startsWith("file:")) {
+        try {
+          return (0, import_path.isAbsolute)((0, import_url.fileURLToPath)(pathWithoutQuery));
+        } catch {
+          return false;
+        }
+      }
+      return (0, import_path.isAbsolute)(pathWithoutQuery);
+    },
     transform(code, id) {
       if (!id) {
         return null;
@@ -4848,7 +5245,7 @@ var unplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
       if (!moduleDetails) {
         return null;
       }
-      const moduleName = moduleDetails.name;
+      const moduleName = getPackageName(moduleDetails.basedir) ?? moduleDetails.name;
       const normalizedModulePath = moduleDetails.path.replace(/\\/g, "/");
       const moduleVersion = getModuleVersion(moduleDetails.basedir);
       const patched = applySpecialCasePatch({