braintrust 3.20.0 → 3.21.0

package/dist/auto-instrumentations/chunk-VT6DDNKM.mjs

@@ -0,0 +1,856 @@
+// src/auto-instrumentations/loader/mastra-observability-patch.ts
+var MASTRA_EXPORTER_FACTORY_GLOBAL = "__braintrustMastraExporterFactory";
+function installMastraExporterFactory(factory) {
+  const globals = globalThis;
+  globals[MASTRA_EXPORTER_FACTORY_GLOBAL] ??= factory;
+}
+var MASTRA_CORE_PACKAGE = "@mastra/core";
+var MASTRA_OBSERVABILITY_PACKAGE = "@mastra/observability";
+var MASTRA_CORE_ENTRY_PATHS = /* @__PURE__ */ new Set([
+  "dist/index.js",
+  "dist/index.cjs",
+  "dist/mastra/index.js",
+  "dist/mastra/index.cjs"
+]);
+var MASTRA_OBSERVABILITY_ENTRY_PATHS = /* @__PURE__ */ new Set([
+  "dist/index.js",
+  "dist/index.cjs"
+]);
+function classifyMastraTarget(packageName, modulePath) {
+  if (packageName === MASTRA_CORE_PACKAGE && MASTRA_CORE_ENTRY_PATHS.has(modulePath)) {
+    return "core";
+  }
+  if (packageName === MASTRA_OBSERVABILITY_PACKAGE && MASTRA_OBSERVABILITY_ENTRY_PATHS.has(modulePath)) {
+    return "observability";
+  }
+  return null;
+}
+function extractChunkPath(source) {
+  const esmMatch = source.match(
+    /export\s*\{\s*Mastra(?:\s+as\s+\w+)?\s*\}\s*from\s*['"]([^'"]+)['"]/
+  );
+  if (esmMatch) return esmMatch[1];
+  const cjsMatch = source.match(
+    /require\s*\(\s*['"]([^'"]+chunk-[^'"]+)['"]\s*\)/
+  );
+  if (cjsMatch) return cjsMatch[1];
+  return null;
+}
+var EXPORTER_FACTORY_KEY = JSON.stringify(MASTRA_EXPORTER_FACTORY_GLOBAL);
+var MASTRA_PROXY_HANDLER_BODY = `
+{
+  construct(target, args, newTarget) {
+    var firstArg = args[0];
+    if (
+      (!firstArg || typeof firstArg !== "object" || !firstArg.observability) &&
+      __braintrustObservabilityClass
+    ) {
+      try {
+        // serviceName is required by Mastra's Observability validator; pass
+        // something sensible by default. Users who want a different name
+        // should construct Observability themselves.
+        var observability = new __braintrustObservabilityClass({
+          configs: { default: { serviceName: "mastra" } },
+        });
+        args = args.slice();
+        args[0] = Object.assign({}, firstArg, { observability: observability });
+      } catch (e) {
+        // Fall through. Mastra will use its own NoOp; user code still works,
+        // just without auto-instrumentation.
+      }
+    }
+    return Reflect.construct(target, args, newTarget);
+  },
+}`;
+function buildMastraEsmWrapper(chunkPath) {
+  const chunk = JSON.stringify(chunkPath);
+  return `import { Mastra as __braintrustOrigMastra } from ${chunk};
+import { createRequire as __braintrustCreateRequire } from "node:module";
+
+let __braintrustObservabilityClass = null;
+try {
+  // Resolve @mastra/observability relative to this module (the Mastra entry),
+  // so it's looked up from the user's node_modules tree.
+  const __braintrustRequire = __braintrustCreateRequire(import.meta.url);
+  __braintrustObservabilityClass =
+    __braintrustRequire("@mastra/observability").Observability;
+} catch (e) {
+  // @mastra/observability isn't installed; the construct trap will skip the
+  // auto-construct branch and Mastra falls back to its own NoOp.
+}
+const Mastra = new Proxy(__braintrustOrigMastra, ${MASTRA_PROXY_HANDLER_BODY});
+export { Mastra };
+`;
+}
+function buildMastraCjsWrapper(chunkPath) {
+  const chunk = JSON.stringify(chunkPath);
+  return `'use strict';
+const __braintrustChunk = require(${chunk});
+
+let __braintrustObservabilityClass = null;
+try {
+  __braintrustObservabilityClass = require("@mastra/observability").Observability;
+} catch (e) {
+  // @mastra/observability isn't installed; same fallback as the ESM wrapper.
+}
+
+const __braintrustWrappedMastra = new Proxy(
+  __braintrustChunk.Mastra,
+  ${MASTRA_PROXY_HANDLER_BODY},
+);
+Object.defineProperty(exports, "Mastra", {
+  enumerable: true,
+  configurable: true,
+  get: function () { return __braintrustWrappedMastra; }
+});
+`;
+}
+var OBSERVABILITY_APPEND_BODY = `
+;(function __braintrustWrapObservability() {
+  // Top-level so we can both read and reassign the var binding the original
+  // entry declared.
+  if (typeof Observability === "undefined") return;
+  if (Observability.__braintrustWrapped) return;
+  function __braintrustEnsureExporter(rawConfig) {
+    try {
+      var factory = globalThis[${EXPORTER_FACTORY_KEY}];
+      if (typeof factory !== "function") return rawConfig;
+      var config = rawConfig && typeof rawConfig === "object" ? rawConfig : {};
+      var configsIn = config.configs && typeof config.configs === "object" ? config.configs : null;
+      var configsOut = {};
+      var hadEntries = false;
+      if (configsIn) {
+        for (var name in configsIn) {
+          if (!Object.prototype.hasOwnProperty.call(configsIn, name)) continue;
+          hadEntries = true;
+          var inst = configsIn[name] || {};
+          var existing = Array.isArray(inst.exporters) ? inst.exporters : [];
+          var hasOurs = existing.some(function (e) { return e && e.name === "braintrust"; });
+          configsOut[name] = Object.assign({}, inst, {
+            exporters: hasOurs ? existing : existing.concat([factory()]),
+          });
+        }
+      }
+      if (!hadEntries) {
+        configsOut.default = {
+          serviceName: "mastra",
+          exporters: [factory()],
+        };
+      }
+      return Object.assign({}, config, { configs: configsOut });
+    } catch (e) {
+      return rawConfig;
+    }
+  }
+  var __OriginalObservability = Observability;
+  Observability = new Proxy(__OriginalObservability, {
+    construct: function (target, args, newTarget) {
+      var nextArgs = args.slice();
+      nextArgs[0] = __braintrustEnsureExporter(nextArgs[0]);
+      return Reflect.construct(target, nextArgs, newTarget);
+    },
+  });
+  Observability.__braintrustWrapped = true;
+  if (typeof exports !== "undefined" && exports && typeof exports === "object") {
+    try {
+      Object.defineProperty(exports, "Observability", {
+        enumerable: true,
+        configurable: true,
+        get: function () { return Observability; },
+      });
+    } catch (e) {}
+  }
+})();
+`;
+function patchMastraSource(source, target, format) {
+  if (target === "core") {
+    const chunkPath = extractChunkPath(source);
+    if (!chunkPath) return source;
+    return format === "esm" ? buildMastraEsmWrapper(chunkPath) : buildMastraCjsWrapper(chunkPath);
+  }
+  return source + OBSERVABILITY_APPEND_BODY;
+}
+
+// src/auto-instrumentations/orchestrion-js/matcher.ts
+import semifies from "semifies";
+
+// src/auto-instrumentations/orchestrion-js/transformer.ts
+import esquery2 from "esquery";
+import { generate } from "astring";
+import { parse as parse2 } from "meriyah";
+import { SourceMapGenerator } from "source-map";
+
+// src/auto-instrumentations/orchestrion-js/transforms.ts
+import esquery from "esquery";
+import { parse } from "meriyah";
+var tracingChannelPredicate = (node) => node.declarations?.[0]?.id?.properties?.[0]?.value?.name === "tr_ch_apm_tracingChannel";
+var CHANNEL_REGEX = /[^\w]/g;
+function formatChannelVariable(channelName) {
+  return `tr_ch_apm$${channelName.replace(CHANNEL_REGEX, "_")}`;
+}
+var transforms = {
+  tracingChannelImport({ dcModule, moduleType }, node) {
+    if (node.body.some(tracingChannelPredicate)) {
+      return;
+    }
+    const options = { module: moduleType === "esm" };
+    const index = node.body.findIndex(
+      (child) => child.directive === "use strict"
+    );
+    const dc = moduleType === "esm" ? `import tr_ch_apm_dc from "${dcModule}"` : `const tr_ch_apm_dc = ${"require"}("${dcModule}")`;
+    const tracingChannel = "const { tracingChannel: tr_ch_apm_tracingChannel } = tr_ch_apm_dc";
+    const hasSubscribers = `const tr_ch_apm_hasSubscribers = ch => ch.start.hasSubscribers
+      || ch.end.hasSubscribers
+      || ch.asyncStart.hasSubscribers
+      || ch.asyncEnd.hasSubscribers
+      || ch.error.hasSubscribers`;
+    node.body.splice(
+      index + 1,
+      0,
+      parse(dc, options).body[0],
+      parse(tracingChannel, options).body[0],
+      parse(hasSubscribers, options).body[0]
+    );
+  },
+  tracingChannelDeclaration(state, node) {
+    const {
+      channelName,
+      module: { name }
+    } = state;
+    const channelVariable = formatChannelVariable(channelName);
+    if (node.body.some(
+      (child) => child.declarations?.[0]?.id?.name === channelVariable
+    )) {
+      return;
+    }
+    transforms.tracingChannelImport(state, node, null, []);
+    const index = node.body.findIndex(tracingChannelPredicate);
+    const code = `
+      const ${channelVariable} = tr_ch_apm_tracingChannel("orchestrion:${name}:${channelName}")
+    `;
+    node.body.splice(index + 1, 0, parse(code).body[0]);
+  },
+  traceCallback: traceAny,
+  tracePromise: traceAny,
+  traceSync: traceAny
+};
+function traceAny(state, node, _parent, ancestry) {
+  const program = ancestry[ancestry.length - 1];
+  if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+    traceInstanceMethod(state, node, program);
+  } else {
+    traceFunction(state, node, program);
+  }
+}
+function traceFunction(state, node, program) {
+  transforms.tracingChannelDeclaration(state, program, null, []);
+  const { functionQuery } = state;
+  const methodName = "methodName" in functionQuery ? functionQuery.methodName : void 0;
+  const privateMethodName = "privateMethodName" in functionQuery ? functionQuery.privateMethodName : void 0;
+  const functionName = "functionName" in functionQuery ? functionQuery.functionName : void 0;
+  const isConstructor = methodName === "constructor" || !methodName && !privateMethodName && !functionName;
+  const type = isConstructor ? "ArrowFunctionExpression" : "FunctionExpression";
+  node.body = wrap(
+    state,
+    {
+      type,
+      params: node.params,
+      body: node.body,
+      async: node.async,
+      expression: false,
+      generator: node.generator
+    },
+    program
+  );
+  node.generator = false;
+  node.async = false;
+  wrapSuper(node);
+}
+function traceInstanceMethod(state, node, program) {
+  const { functionQuery, operator } = state;
+  const { methodName } = functionQuery;
+  if (!methodName) {
+    return;
+  }
+  const classBody = node.body;
+  if (classBody.body.some(({ key }) => key.name === methodName)) {
+    return;
+  }
+  let ctor = classBody.body.find(({ kind }) => kind === "constructor");
+  transforms.tracingChannelDeclaration(state, program, null, []);
+  if (!ctor) {
+    ctor = parse(
+      node.superClass ? "class A extends Object { constructor (...args) { super(...args) } }" : "class A { constructor () {} }"
+    ).body[0].body.body[0];
+    classBody.body.unshift(ctor);
+  }
+  const ctorBody = parse(`
+    const __apm$${methodName} = this["${methodName}"]
+    this["${methodName}"] = function () {}
+  `).body;
+  const fn = ctorBody[1].expression.right;
+  fn.async = operator === "tracePromise";
+  fn.body = wrap(
+    state,
+    { type: "Identifier", name: `__apm$${methodName}` },
+    program
+  );
+  wrapSuper(fn);
+  ctor.value.body.body.push(...ctorBody);
+}
+function wrap(state, node, program) {
+  const { operator, moduleVersion } = state;
+  const wrapper = operator === "traceCallback" ? wrapCallback(state) : operator === "tracePromise" ? wrapPromise(state) : wrapSync(state);
+  const block = wrapper.body[0].body;
+  const common = parse(
+    node.type === "ArrowFunctionExpression" ? `
+    const __apm$ctx = {
+      arguments,
+      moduleVersion: ${JSON.stringify(moduleVersion)}
+    };
+    const __apm$traced = () => {
+      const __apm$wrapped = () => {};
+      return __apm$wrapped(...arguments);
+    };
+  ` : `
+    const __apm$ctx = {
+      arguments,
+      self: this,
+      moduleVersion: ${JSON.stringify(moduleVersion)}
+    };
+    const __apm$traced = () => {
+      const __apm$wrapped = () => {};
+      return __apm$wrapped.apply(this, arguments);
+    };
+  `
+  ).body;
+  block.body.unshift(...common);
+  esquery.query(block, "[id.name=__apm$wrapped]")[0].init = node;
+  return block;
+}
+function wrapSuper(node) {
+  const members = /* @__PURE__ */ new Set();
+  esquery.traverse(
+    node.body,
+    esquery.parse("[object.type=Super]"),
+    (node2, parent) => {
+      const { name } = node2.property;
+      let child;
+      if (parent.callee) {
+        const { expression } = parse(`__apm$super['${name}'].call(this)`).body[0];
+        parent.callee = child = expression.callee;
+        parent.arguments.unshift(...expression.arguments);
+      } else {
+        parent.expression = child = parse(`__apm$super['${name}']`).body[0];
+      }
+      child.computed = parent.callee.computed;
+      child.optional = parent.callee.optional;
+      members.add(name);
+    }
+  );
+  for (const name of members) {
+    const member = parse(`
+      class Wrapper {
+        wrapper () {
+          __apm$super['${name}'] = super['${name}']
+        }
+      }
+    `).body[0].body.body[0].value.body.body[0];
+    node.body.body.unshift(member);
+  }
+  if (members.size > 0) {
+    node.body.body.unshift(parse("const __apm$super = {}").body[0]);
+  }
+}
+function wrapCallback(state) {
+  const {
+    channelName,
+    functionQuery: { callbackIndex = -1 }
+  } = state;
+  const channelVariable = formatChannelVariable(channelName);
+  return parse(`
+    function wrapper () {
+      const __apm$cb = Array.prototype.at.call(arguments, ${callbackIndex});
+
+      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
+
+      function __apm$wrappedCb(err, res) {
+        if (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+        } else {
+          __apm$ctx.result = res;
+        }
+
+        ${channelVariable}.asyncStart.runStores(__apm$ctx, () => {
+          try {
+            if (__apm$cb) {
+              return __apm$cb.apply(this, arguments);
+            }
+          } finally {
+            ${channelVariable}.asyncEnd.publish(__apm$ctx);
+          }
+        });
+      }
+
+      if (typeof __apm$cb !== 'function') {
+        return __apm$traced();
+      }
+      Array.prototype.splice.call(arguments, ${callbackIndex}, 1, __apm$wrappedCb);
+
+      return ${channelVariable}.start.runStores(__apm$ctx, () => {
+        try {
+          return __apm$traced();
+        } catch (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+          throw err;
+        } finally {
+          __apm$ctx.self ??= this;
+          ${channelVariable}.end.publish(__apm$ctx);
+        }
+      });
+    }
+  `);
+}
+function wrapPromise(state) {
+  const { channelName } = state;
+  const channelVariable = formatChannelVariable(channelName);
+  return parse(`
+    function wrapper () {
+      if (!tr_ch_apm_hasSubscribers(${channelVariable})) return __apm$traced();
+
+      return ${channelVariable}.start.runStores(__apm$ctx, () => {
+        try {
+          let promise = __apm$traced();
+          if (typeof promise?.then !== 'function') {
+            __apm$ctx.result = promise;
+            return promise;
+          }
+          // Mirror Node.js core diagnostics_channel behaviour: for native Promise
+          // instances, chain normally (safe since there is no subclass API to
+          // preserve). For Promise subclasses and other thenables, side-chain the
+          // callbacks for event publishing and return the original so that any
+          // subclass-specific methods (e.g. APIPromise.withResponse()) remain
+          // accessible to the caller.
+          if (promise instanceof Promise && promise.constructor === Promise) {
+            return promise.then(
+              result => {
+                __apm$ctx.result = result;
+                ${channelVariable}.asyncStart.publish(__apm$ctx);
+                ${channelVariable}.asyncEnd.publish(__apm$ctx);
+                return result;
+              },
+              err => {
+                __apm$ctx.error = err;
+                ${channelVariable}.error.publish(__apm$ctx);
+                ${channelVariable}.asyncStart.publish(__apm$ctx);
+                ${channelVariable}.asyncEnd.publish(__apm$ctx);
+                throw err;
+              }
+            );
+          }
+          promise.then(
+            result => {
+              __apm$ctx.result = result;
+              ${channelVariable}.asyncStart.publish(__apm$ctx);
+              ${channelVariable}.asyncEnd.publish(__apm$ctx);
+            },
+            err => {
+              __apm$ctx.error = err;
+              ${channelVariable}.error.publish(__apm$ctx);
+              ${channelVariable}.asyncStart.publish(__apm$ctx);
+              ${channelVariable}.asyncEnd.publish(__apm$ctx);
+            }
+          );
+          return promise;
+        } catch (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+          throw err;
+        } finally {
+          __apm$ctx.self ??= this;
+          ${channelVariable}.end.publish(__apm$ctx);
+        }
+      });
+    }
+  `);
+}
+function wrapSync(state) {
+  const { channelName } = state;
+  const channelVariable = formatChannelVariable(channelName);
+  return parse(`
+    function wrapper () {
+      if (!tr_ch_apm_hasSubscribers(${channelVariable})) return __apm$traced();
+
+      return ${channelVariable}.start.runStores(__apm$ctx, () => {
+        try {
+          const result = __apm$traced();
+          __apm$ctx.result = result;
+          return result;
+        } catch (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+          throw err;
+        } finally {
+         __apm$ctx.self ??= this;
+          ${channelVariable}.end.publish(__apm$ctx);
+        }
+      });
+    }
+  `);
+}
+
+// src/auto-instrumentations/orchestrion-js/transformer.ts
+var Transformer = class {
+  moduleName;
+  version;
+  filePath;
+  configs = [];
+  dcModule;
+  constructor(moduleName, version, filePath, configs, dcModule) {
+    this.moduleName = moduleName;
+    this.version = version;
+    this.filePath = filePath;
+    this.configs = configs;
+    this.dcModule = dcModule;
+  }
+  /**
+   * Instruments `code` by injecting diagnostics_channel tracing around the
+   * target functions defined by this transformer's configs.
+   */
+  transform(code, moduleType) {
+    if (Buffer.isBuffer(code)) {
+      code = code.toString();
+    }
+    if (!code) {
+      return { code };
+    }
+    let ast;
+    let aliases = {};
+    let injectionCount = 0;
+    for (const config of this.configs) {
+      const { astQuery, functionQuery } = config;
+      if (!ast) {
+        const options = {
+          loc: true,
+          ranges: true,
+          raw: true,
+          module: moduleType === "esm"
+        };
+        try {
+          ast = parse2(code, options);
+        } catch {
+          ast = parse2(code, { ...options, module: !options.module });
+        }
+        if (moduleType === "esm") {
+          aliases = this.collectExportAliases(ast);
+        }
+      }
+      const resolvedFunctionQuery = this.resolveExportAlias(
+        functionQuery,
+        aliases
+      );
+      const query = astQuery || this.fromFunctionQuery(resolvedFunctionQuery);
+      const state = {
+        ...config,
+        dcModule: this.dcModule,
+        moduleType,
+        moduleVersion: this.version,
+        functionQuery: resolvedFunctionQuery,
+        operator: this.getOperator(resolvedFunctionQuery.kind)
+      };
+      esquery2.traverse(ast, esquery2.parse(query), (...args) => {
+        injectionCount++;
+        this.visit(state, ...args);
+      });
+    }
+    if (injectionCount === 0 && this.configs.length > 0) {
+      const names = this.configs.map(({ astQuery, functionQuery }) => {
+        const resolvedQuery = this.resolveExportAlias(functionQuery, aliases);
+        const queryName = (q) => q.methodName || q.privateMethodName || q.functionName || q.propertyName || astQuery || "unknown";
+        const originalName = queryName(functionQuery);
+        const originalAlias = functionQuery.className || functionQuery.functionName;
+        const resolvedAlias = resolvedQuery.className || resolvedQuery.functionName;
+        if (originalAlias && originalAlias !== resolvedAlias) {
+          return `${originalAlias} (local name: ${resolvedAlias})`;
+        }
+        return originalName;
+      });
+      throw new Error(
+        `Failed to find injection points for: ${JSON.stringify(names)}`
+      );
+    }
+    if (ast) {
+      const file = `${this.moduleName}/${this.filePath}`;
+      const sourceMap = new SourceMapGenerator({ file });
+      const transformedCode = generate(ast, { sourceMap });
+      const map = sourceMap.toString();
+      return { code: transformedCode, map };
+    }
+    return { code };
+  }
+  free() {
+  }
+  visit(state, ...args) {
+    const transform = transforms[state.operator];
+    const { index = 0 } = state.functionQuery;
+    const [node] = args;
+    const type = node.init?.type || node.type;
+    if (type !== "ClassDeclaration" && type !== "ClassExpression") {
+      if (node.type === "VariableDeclarator") {
+        return;
+      }
+      state.functionIndex = state.functionIndex === void 0 ? 0 : state.functionIndex + 1;
+      if (index !== null && index !== state.functionIndex) {
+        return;
+      }
+    }
+    transform(state, ...args);
+  }
+  getOperator(kind) {
+    switch (kind) {
+      case "Async":
+        return "tracePromise";
+      case "Callback":
+        return "traceCallback";
+      case "Sync":
+        return "traceSync";
+    }
+  }
+  collectExportAliases(ast) {
+    const aliases = {};
+    for (const node of ast.body) {
+      if (node.type === "ExportNamedDeclaration" && !node.source) {
+        for (const spec of node.specifiers) {
+          if (spec.exported && spec.local) {
+            const exportedName = spec.exported.name ?? spec.exported.value;
+            const localName = spec.local.name ?? spec.local.value;
+            if (exportedName && localName) {
+              aliases[exportedName] = localName;
+            }
+          }
+        }
+      }
+    }
+    return aliases;
+  }
+  resolveExportAlias(functionQuery, aliases) {
+    if (!("isExportAlias" in functionQuery) || !functionQuery.isExportAlias) {
+      return functionQuery;
+    }
+    if ("className" in functionQuery && aliases[functionQuery.className]) {
+      return {
+        ...functionQuery,
+        className: aliases[functionQuery.className]
+      };
+    }
+    if ("functionName" in functionQuery && aliases[functionQuery.functionName]) {
+      return {
+        ...functionQuery,
+        functionName: aliases[functionQuery.functionName]
+      };
+    }
+    return functionQuery;
+  }
+  functionQueryLabel(functionQuery) {
+    if ("methodName" in functionQuery) {
+      return functionQuery.methodName;
+    }
+    if ("privateMethodName" in functionQuery) {
+      return functionQuery.privateMethodName;
+    }
+    if ("functionName" in functionQuery) {
+      return functionQuery.functionName;
+    }
+    if ("propertyName" in functionQuery) {
+      return functionQuery.propertyName;
+    }
+    return "unknown";
+  }
+  fromFunctionQuery(functionQuery) {
+    const queries = [];
+    if ("className" in functionQuery) {
+      const { className } = functionQuery;
+      const methodName = this.functionQueryLabel(functionQuery);
+      const keyType = "privateMethodName" in functionQuery ? "PrivateIdentifier" : "Identifier";
+      queries.push(
+        `[id.name="${className}"]`,
+        `[id.name="${className}"] > ClassExpression`,
+        `[id.name="${className}"] > ClassBody > [key.name="${methodName}"][key.type=${keyType}] > [async]`,
+        `[id.name="${className}"] > ClassExpression > ClassBody > [key.name="${methodName}"][key.type=${keyType}] > [async]`
+      );
+    } else if ("methodName" in functionQuery) {
+      const { methodName } = functionQuery;
+      queries.push(
+        `ClassBody > [key.name="${methodName}"][key.type=Identifier] > [async]`,
+        `Property[key.name="${methodName}"][key.type=Identifier] > [async]`
+      );
+    }
+    if ("functionName" in functionQuery) {
+      const { functionName } = functionQuery;
+      queries.push(`FunctionDeclaration[id.name="${functionName}"][async]`);
+    }
+    if ("objectName" in functionQuery) {
+      const { objectName, propertyName } = functionQuery;
+      const objectSelector = objectName === "this" ? "left.object.type=ThisExpression" : `left.object.name="${objectName}"`;
+      queries.push(
+        `AssignmentExpression[${objectSelector}][left.property.name="${propertyName}"] > [async]`
+      );
+    }
+    return queries.join(", ");
+  }
+};
+
+// src/auto-instrumentations/orchestrion-js/matcher.ts
+var InstrumentationMatcher = class {
+  configs = [];
+  dcModule;
+  transformers = {};
+  constructor(configs, dcModule) {
+    this.configs = configs;
+    this.dcModule = dcModule || "diagnostics_channel";
+  }
+  /**
+   * Returns a Transformer for the given module/file/version, or undefined if no
+   * registered config matches.
+   */
+  getTransformer(moduleName, version, filePath) {
+    filePath = filePath.replace(/\\/g, "/");
+    const id = `${moduleName}/${filePath}@${version}`;
+    if (this.transformers[id]) {
+      return this.transformers[id];
+    }
+    const configs = this.configs.filter(
+      ({ module: mod }) => mod.name === moduleName && mod.filePath === filePath && semifies(version, mod.versionRange)
+    );
+    if (configs.length === 0) {
+      return void 0;
+    }
+    this.transformers[id] = new Transformer(
+      moduleName,
+      version,
+      filePath,
+      configs,
+      this.dcModule
+    );
+    return this.transformers[id];
+  }
+  free() {
+    this.transformers = {};
+  }
+};
+
+// src/auto-instrumentations/orchestrion-js/index.ts
+function create(configs, dcModule) {
+  return new InstrumentationMatcher(configs, dcModule);
+}
+
+// src/auto-instrumentations/loader/get-package-version.ts
+import { readFileSync, realpathSync } from "fs";
+import { join } from "path";
+var packageVersions = /* @__PURE__ */ new Map();
+var packageNames = /* @__PURE__ */ new Map();
+function readPackageJson(baseDir) {
+  try {
+    const packageJsonPath = join(baseDir, "package.json");
+    const jsonFile = readFileSync(packageJsonPath, "utf8");
+    return JSON.parse(jsonFile);
+  } catch {
+    return void 0;
+  }
+}
+function resolvePackageBaseDir(baseDir) {
+  try {
+    return 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 getPackageVersion(baseDir) {
+  if (packageVersions.has(baseDir)) {
+    return packageVersions.get(baseDir);
+  }
+  const packageJson = readPackageJsonWithFallback(baseDir);
+  if (typeof packageJson?.version === "string") {
+    packageVersions.set(baseDir, packageJson.version);
+    return packageJson.version;
+  }
+  return process.version.slice(1);
+}
+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/loader/openai-api-promise-patch.ts
+var OPENAI_API_PROMISE_PATCH = `
+;(function __btPatchAPIPromise() {
+  if (typeof APIPromise === "undefined" || APIPromise.prototype.__btParsePatched) return;
+  APIPromise.prototype.__btParsePatched = true;
+  var _origThen = APIPromise.prototype.then;
+  APIPromise.prototype.then = function __btThen(onfulfilled, onrejected) {
+    if (!this.__btParseWrapped && Object.prototype.hasOwnProperty.call(this, "parseResponse")) {
+      this.__btParseWrapped = true;
+      var _origParse = this.parseResponse;
+      var _cached;
+      this.parseResponse = function() {
+        if (!_cached) _cached = _origParse.apply(this, arguments);
+        return _cached;
+      };
+    }
+    return _origThen.call(this, onfulfilled, onrejected);
+  };
+})();
+`;
+
+// src/auto-instrumentations/loader/special-case-patches.ts
+function applySpecialCasePatch(input) {
+  if (input.packageName === "openai" && input.modulePath.includes("api-promise")) {
+    return input.source + OPENAI_API_PROMISE_PATCH;
+  }
+  const mastraTarget = classifyMastraTarget(
+    input.packageName,
+    input.modulePath
+  );
+  if (mastraTarget) {
+    return patchMastraSource(input.source, mastraTarget, input.format);
+  }
+  return null;
+}
+function isSpecialCaseTarget(packageName, modulePath) {
+  if (packageName === "openai" && modulePath.includes("api-promise")) {
+    return true;
+  }
+  if (classifyMastraTarget(packageName, modulePath) !== null) {
+    return true;
+  }
+  return false;
+}
+
+export {
+  installMastraExporterFactory,
+  create,
+  getPackageVersion,
+  getPackageName,
+  applySpecialCasePatch,
+  isSpecialCaseTarget
+};