braintrust 3.13.0 → 3.14.0

package/dist/browser.mjs

@@ -3938,6 +3938,76 @@ var LRUCache = class {
   }
 };
 
+// src/prompt-cache/cache-config.ts
+var CACHE_LOCATION_ENV_VAR = "BRAINTRUST_CACHE_LOCATION";
+var DEFAULT_CACHE_MEMORY_MAX = 1 << 10;
+var DEFAULT_CACHE_DISK_MAX = 1 << 20;
+var warnedInvalidCacheModeEnvValue = false;
+var warnedUnavailableDiskCacheMode = false;
+function warnInvalidCacheMode(value) {
+  if (warnedInvalidCacheModeEnvValue) {
+    return;
+  }
+  warnedInvalidCacheModeEnvValue = true;
+  debugLogger.warn(
+    `Invalid ${CACHE_LOCATION_ENV_VAR} value "${value}". Expected "mixed", "memory", "disk", or "none". Falling back to "mixed".`
+  );
+}
+function warnUnavailableDiskCache() {
+  if (warnedUnavailableDiskCacheMode) {
+    return;
+  }
+  warnedUnavailableDiskCacheMode = true;
+  debugLogger.warn(
+    `Disk cache is not supported on this platform, so ${CACHE_LOCATION_ENV_VAR}="disk" disables prompt and parameters caching.`
+  );
+}
+function parseCacheMode() {
+  const value = isomorph_default.getEnv(CACHE_LOCATION_ENV_VAR);
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return "mixed";
+  }
+  if (normalized === "mixed" || normalized === "memory" || normalized === "disk" || normalized === "none") {
+    return normalized;
+  }
+  warnInvalidCacheMode(value ?? "");
+  return "mixed";
+}
+function parsePositiveIntegerEnv(envVar, defaultValue) {
+  const value = Number(isomorph_default.getEnv(envVar));
+  return Number.isInteger(value) && value > 0 ? value : defaultValue;
+}
+function createCacheLayers({
+  memoryMaxEnvVar,
+  diskCacheDirEnvVar,
+  diskMaxEnvVar,
+  getDefaultDiskCacheDir
+}) {
+  const mode = parseCacheMode();
+  const memoryCache = mode === "mixed" || mode === "memory" ? new LRUCache({
+    max: parsePositiveIntegerEnv(
+      memoryMaxEnvVar,
+      DEFAULT_CACHE_MEMORY_MAX
+    )
+  }) : void 0;
+  let diskCache;
+  if (mode === "mixed" || mode === "disk") {
+    if (canUseDiskCache()) {
+      diskCache = new DiskCache({
+        cacheDir: isomorph_default.getEnv(diskCacheDirEnvVar) ?? getDefaultDiskCacheDir(),
+        max: parsePositiveIntegerEnv(diskMaxEnvVar, DEFAULT_CACHE_DISK_MAX)
+      });
+    } else if (mode === "disk") {
+      warnUnavailableDiskCache();
+    }
+  }
+  if (diskCache) {
+    return { memoryCache, diskCache };
+  }
+  return { memoryCache };
+}
+
 // src/prompt-cache/prompt-cache.ts
 function createCacheKey(key) {
   if (key.id) {
@@ -3965,16 +4035,18 @@ var PromptCache = class {
    */
   async get(key) {
     const cacheKey = createCacheKey(key);
-    const memoryPrompt = this.memoryCache.get(cacheKey);
-    if (memoryPrompt !== void 0) {
-      return memoryPrompt;
+    if (this.memoryCache) {
+      const memoryPrompt = this.memoryCache.get(cacheKey);
+      if (memoryPrompt !== void 0) {
+        return memoryPrompt;
+      }
     }
     if (this.diskCache) {
       const diskPrompt = await this.diskCache.get(cacheKey);
       if (!diskPrompt) {
         return void 0;
       }
-      this.memoryCache.set(cacheKey, diskPrompt);
+      this.memoryCache?.set(cacheKey, diskPrompt);
       return diskPrompt;
     }
     return void 0;
@@ -3989,7 +4061,7 @@ var PromptCache = class {
    */
   async set(key, value) {
     const cacheKey = createCacheKey(key);
-    this.memoryCache.set(cacheKey, value);
+    this.memoryCache?.set(cacheKey, value);
     if (this.diskCache) {
       await this.diskCache.set(cacheKey, value);
     }
@@ -4019,23 +4091,25 @@ var ParametersCache = class {
   }
   async get(key) {
     const cacheKey = createCacheKey2(key);
-    const memoryParams = this.memoryCache.get(cacheKey);
-    if (memoryParams !== void 0) {
-      return memoryParams;
+    if (this.memoryCache) {
+      const memoryParams = this.memoryCache.get(cacheKey);
+      if (memoryParams !== void 0) {
+        return memoryParams;
+      }
     }
     if (this.diskCache) {
       const diskParams = await this.diskCache.get(cacheKey);
       if (!diskParams) {
         return void 0;
       }
-      this.memoryCache.set(cacheKey, diskParams);
+      this.memoryCache?.set(cacheKey, diskParams);
       return diskParams;
     }
     return void 0;
   }
   async set(key, value) {
     const cacheKey = createCacheKey2(key);
-    this.memoryCache.set(cacheKey, value);
+    this.memoryCache?.set(cacheKey, value);
     if (this.diskCache) {
       await this.diskCache.set(cacheKey, value);
     }
@@ -4567,21 +4641,22 @@ var BraintrustState = class _BraintrustState {
       setGlobalDebugLogLevel(void 0);
     }
     this.resetLoginInfo();
-    const memoryCache = new LRUCache({
-      max: Number(isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_MEMORY_MAX")) ?? 1 << 10
+    const { memoryCache, diskCache } = createCacheLayers({
+      memoryMaxEnvVar: "BRAINTRUST_PROMPT_CACHE_MEMORY_MAX",
+      diskCacheDirEnvVar: "BRAINTRUST_PROMPT_CACHE_DIR",
+      diskMaxEnvVar: "BRAINTRUST_PROMPT_CACHE_DISK_MAX",
+      getDefaultDiskCacheDir: () => `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/prompt_cache`
     });
-    const diskCache = canUseDiskCache() ? new DiskCache({
-      cacheDir: isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_DIR") ?? `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/prompt_cache`,
-      max: Number(isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_DISK_MAX")) ?? 1 << 20
-    }) : void 0;
     this.promptCache = new PromptCache({ memoryCache, diskCache });
-    const parametersMemoryCache = new LRUCache({
-      max: Number(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX")) ?? 1 << 10
+    const {
+      memoryCache: parametersMemoryCache,
+      diskCache: parametersDiskCache
+    } = createCacheLayers({
+      memoryMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX",
+      diskCacheDirEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DIR",
+      diskMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DISK_MAX",
+      getDefaultDiskCacheDir: () => `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/parameters_cache`
     });
-    const parametersDiskCache = canUseDiskCache() ? new DiskCache({
-      cacheDir: isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_DIR") ?? `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/parameters_cache`,
-      max: Number(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_DISK_MAX")) ?? 1 << 20
-    }) : void 0;
     this.parametersCache = new ParametersCache({
       memoryCache: parametersMemoryCache,
       diskCache: parametersDiskCache
@@ -25598,7 +25673,7 @@ var BraintrustPlugin = class extends BasePlugin {
     this.config = config;
   }
   onEnable() {
-    const integrations = this.config.integrations || {};
+    const integrations = this.config.integrations ?? {};
     if (integrations.openai !== false) {
       this.openaiPlugin = new OpenAIPlugin();
       this.openaiPlugin.enable();
@@ -25663,7 +25738,7 @@ var BraintrustPlugin = class extends BasePlugin {
       this.genkitPlugin = new GenkitPlugin();
       this.genkitPlugin.enable();
     }
-    if (getIntegrationConfig(integrations, "gitHubCopilot") !== false) {
+    if (integrations.gitHubCopilot !== false) {
       this.gitHubCopilotPlugin = new GitHubCopilotPlugin();
       this.gitHubCopilotPlugin.enable();
     }
@@ -25776,6 +25851,7 @@ var envIntegrationAliases = {
   cursorsdk: "cursorSDK",
   flue: "flue",
   "flue-runtime": "flue",
+  mastra: "mastra",
   "openai-agents": "openAIAgents",
   openaiagents: "openAIAgents",
   "openai-agents-core": "openAIAgents",
@@ -25818,6 +25894,7 @@ function getDefaultInstrumentationIntegrations() {
     cursor: true,
     cursorSDK: true,
     flue: true,
+    mastra: true,
     openAIAgents: true,
     openrouter: true,
     openrouterAgent: true,
@@ -26075,6 +26152,7 @@ __export(exports_exports, {
   BaseExperiment: () => BaseExperiment,
   BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
+  BraintrustObservabilityExporter: () => BraintrustObservabilityExporter,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
   CachedSpanFetcher: () => CachedSpanFetcher,
@@ -27691,6 +27769,196 @@ function toolRunnerProxy(toolRunner, anthropic, channel2) {
 }
 
 // src/wrappers/mastra.ts
+var MASTRA_BRAINTRUST_EXPORTER_NAME = "braintrust";
+var SPAN_TYPE_MAP = {
+  agent_run: "task" /* TASK */,
+  model_generation: "llm" /* LLM */,
+  model_step: "llm" /* LLM */,
+  model_chunk: "llm" /* LLM */,
+  tool_call: "tool" /* TOOL */,
+  mcp_tool_call: "tool" /* TOOL */,
+  workflow_run: "task" /* TASK */,
+  workflow_step: "function" /* FUNCTION */,
+  workflow_conditional: "function" /* FUNCTION */,
+  workflow_conditional_eval: "function" /* FUNCTION */,
+  workflow_parallel: "function" /* FUNCTION */,
+  workflow_loop: "function" /* FUNCTION */,
+  workflow_sleep: "function" /* FUNCTION */,
+  workflow_wait_event: "function" /* FUNCTION */,
+  memory_operation: "function" /* FUNCTION */,
+  workspace_action: "function" /* FUNCTION */,
+  rag_ingestion: "task" /* TASK */,
+  rag_embedding: "llm" /* LLM */,
+  rag_vector_operation: "function" /* FUNCTION */,
+  rag_action: "function" /* FUNCTION */,
+  graph_action: "function" /* FUNCTION */,
+  scorer_run: "score" /* SCORE */,
+  scorer_step: "score" /* SCORE */,
+  processor_run: "function" /* FUNCTION */,
+  generic: "function" /* FUNCTION */
+};
+function spanTypeFor(mastraType) {
+  return SPAN_TYPE_MAP[mastraType] ?? "function" /* FUNCTION */;
+}
+function epochSeconds(value) {
+  if (value === void 0) return void 0;
+  const ms = value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(value);
+  return Number.isFinite(ms) ? ms / 1e3 : void 0;
+}
+function modelMetrics(attributes) {
+  if (!isObject(attributes)) return void 0;
+  const usage = isObject(attributes.usage) ? attributes.usage : void 0;
+  if (!usage) return void 0;
+  const out = {};
+  if (typeof usage.inputTokens === "number")
+    out.prompt_tokens = usage.inputTokens;
+  if (typeof usage.outputTokens === "number")
+    out.completion_tokens = usage.outputTokens;
+  if (typeof usage.inputTokens === "number" && typeof usage.outputTokens === "number") {
+    out.tokens = usage.inputTokens + usage.outputTokens;
+  }
+  const inputDetails = isObject(usage.inputDetails) ? usage.inputDetails : void 0;
+  const outputDetails = isObject(usage.outputDetails) ? usage.outputDetails : void 0;
+  if (inputDetails && typeof inputDetails.cacheRead === "number") {
+    out.prompt_cached_tokens = inputDetails.cacheRead;
+  }
+  if (inputDetails && typeof inputDetails.cacheWrite === "number") {
+    out.prompt_cache_creation_tokens = inputDetails.cacheWrite;
+  }
+  if (outputDetails && typeof outputDetails.reasoning === "number") {
+    out.completion_reasoning_tokens = outputDetails.reasoning;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function buildMetadata(exported) {
+  const out = {};
+  if (exported.entityId !== void 0) out.entity_id = exported.entityId;
+  if (exported.entityName !== void 0) out.entity_name = exported.entityName;
+  if (exported.entityType !== void 0) out.entity_type = exported.entityType;
+  if (exported.metadata && isObject(exported.metadata)) {
+    Object.assign(out, exported.metadata);
+  }
+  if (exported.attributes && isObject(exported.attributes)) {
+    for (const [key, value] of Object.entries(exported.attributes)) {
+      if (key === "usage") continue;
+      if (value !== void 0) out[key] = value;
+    }
+  }
+  if (exported.tags && exported.tags.length > 0) {
+    out.tags = exported.tags;
+  }
+  if (exported.requestContext && isObject(exported.requestContext)) {
+    out.request_context = exported.requestContext;
+  }
+  return out;
+}
+var BraintrustObservabilityExporter = class {
+  name = MASTRA_BRAINTRUST_EXPORTER_NAME;
+  spans = /* @__PURE__ */ new Map();
+  // Captured at the first SPAN_STARTED event. Mastra's observability bus may
+  // dispatch later events outside the user's AsyncLocalStorage context, where
+  // `currentSpan()` returns NOOP_SPAN — which would make our `startSpan()`
+  // calls go to a no-op logger and silently drop. Anchoring on the parent
+  // we observe while still in-context keeps the whole Mastra subtree under
+  // the user's traced scenario.
+  capturedParent;
+  constructor() {
+    _internalSetInitialState();
+  }
+  async exportTracingEvent(event) {
+    const exported = event.exportedSpan;
+    if (exported.isInternal === true) return;
+    try {
+      switch (event.type) {
+        case "span_started":
+          this.onStart(exported);
+          break;
+        case "span_updated":
+          this.onUpdate(exported);
+          break;
+        case "span_ended":
+          this.onEnd(exported);
+          break;
+      }
+    } catch (err) {
+      logExporterError(err);
+    }
+  }
+  async flush() {
+    const state = _internalGetGlobalState();
+    if (state) {
+      await state.bgLogger().flush();
+    }
+  }
+  async shutdown() {
+    await this.flush();
+    this.spans.clear();
+  }
+  onStart(exported) {
+    if (this.spans.has(exported.id)) return;
+    const args = {
+      name: exported.name,
+      spanAttributes: { type: spanTypeFor(exported.type) },
+      startTime: epochSeconds(exported.startTime)
+    };
+    const parentRecord = exported.parentSpanId ? this.spans.get(exported.parentSpanId) : void 0;
+    if (!this.capturedParent) {
+      const probe = currentSpan();
+      if (probe && probe.spanId) {
+        this.capturedParent = probe;
+      }
+    }
+    const span = parentRecord ? parentRecord.span.startSpan(args) : this.capturedParent ? this.capturedParent.startSpan(args) : startSpan(args);
+    const record = { span, hasLoggedInput: false };
+    this.logPayload(record, exported);
+    this.spans.set(exported.id, record);
+    if (exported.isEvent === true) {
+      span.end({ endTime: args.startTime });
+      this.spans.delete(exported.id);
+    }
+  }
+  onUpdate(exported) {
+    const record = this.spans.get(exported.id);
+    if (!record) return;
+    this.logPayload(record, exported);
+  }
+  onEnd(exported) {
+    const record = this.spans.get(exported.id);
+    if (!record) return;
+    this.logPayload(record, exported);
+    if (exported.errorInfo) {
+      record.span.log({
+        error: exported.errorInfo.message || exported.errorInfo.name || "Unknown Mastra error"
+      });
+    }
+    record.span.end({ endTime: epochSeconds(exported.endTime) });
+    this.spans.delete(exported.id);
+  }
+  logPayload(record, exported) {
+    const event = {};
+    if (exported.input !== void 0) {
+      event.input = exported.input;
+      record.hasLoggedInput = true;
+    }
+    if (exported.output !== void 0) {
+      event.output = exported.output;
+    }
+    const metadata = buildMetadata(exported);
+    if (Object.keys(metadata).length > 0) {
+      event.metadata = metadata;
+    }
+    const metrics = modelMetrics(exported.attributes);
+    if (metrics) {
+      event.metrics = metrics;
+    }
+    if (Object.keys(event).length > 0) {
+      record.span.log(event);
+    }
+  }
+};
+function logExporterError(err) {
+  debugLogger.warn("Mastra exporter failure:", err);
+}
 function wrapMastraAgent(agent, _options) {
   return agent;
 }
@@ -33189,6 +33457,7 @@ export {
   BaseExperiment,
   BraintrustLangChainCallbackHandler,
   BraintrustMiddleware,
+  BraintrustObservabilityExporter,
   BraintrustState,
   BraintrustStream,
   CachedSpanFetcher,

package/dist/{chunk-26JGOELH.js → chunk-NKD77KGB.js}

@@ -685,6 +685,7 @@ var envIntegrationAliases = {
   cursorsdk: "cursorSDK",
   flue: "flue",
   "flue-runtime": "flue",
+  mastra: "mastra",
   "openai-agents": "openAIAgents",
   openaiagents: "openAIAgents",
   "openai-agents-core": "openAIAgents",
@@ -727,6 +728,7 @@ function getDefaultInstrumentationIntegrations() {
     cursor: true,
     cursorSDK: true,
     flue: true,
+    mastra: true,
     openAIAgents: true,
     openrouter: true,
     openrouterAgent: true,
@@ -755,6 +757,179 @@ function isInstrumentationIntegrationDisabled(integrations, ...names) {
   return names.some((name) => _optionalChain([integrations, 'optionalAccess', _34 => _34[name]]) === false);
 }
 
+// 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/instrumentation/plugins/openai-agents-channels.ts
 var openAIAgentsCoreChannels = defineChannels("@openai/agents-core", {
   onTraceStart: channel({
@@ -814,4 +989,7 @@ var langChainChannels = defineChannels("@langchain/core", {
 
 
 
-exports.__export = __export; exports.patchTracingChannel = patchTracingChannel; exports.isomorph_default = isomorph_default; exports.openAIChannels = openAIChannels; exports.openAICodexChannels = openAICodexChannels; exports.anthropicChannels = anthropicChannels; exports.aiSDKChannels = aiSDKChannels; exports.claudeAgentSDKChannels = claudeAgentSDKChannels; exports.cursorSDKChannels = cursorSDKChannels; exports.openAIAgentsCoreChannels = openAIAgentsCoreChannels; exports.googleGenAIChannels = googleGenAIChannels; exports.huggingFaceChannels = huggingFaceChannels; exports.openRouterAgentChannels = openRouterAgentChannels; exports.openRouterChannels = openRouterChannels; exports.mistralChannels = mistralChannels; exports.googleADKChannels = googleADKChannels; exports.cohereChannels = cohereChannels; exports.groqChannels = groqChannels; exports.genkitChannels = genkitChannels; exports.genkitCoreChannels = genkitCoreChannels; exports.gitHubCopilotChannels = gitHubCopilotChannels; exports.flueChannels = flueChannels; exports.langChainChannels = langChainChannels; exports.getDefaultInstrumentationIntegrations = getDefaultInstrumentationIntegrations; exports.readDisabledInstrumentationEnvConfig = readDisabledInstrumentationEnvConfig; exports.isInstrumentationIntegrationDisabled = isInstrumentationIntegrationDisabled;
+
+
+
+exports.__export = __export; exports.patchTracingChannel = patchTracingChannel; exports.isomorph_default = isomorph_default; exports.openAIChannels = openAIChannels; exports.openAICodexChannels = openAICodexChannels; exports.anthropicChannels = anthropicChannels; exports.aiSDKChannels = aiSDKChannels; exports.claudeAgentSDKChannels = claudeAgentSDKChannels; exports.cursorSDKChannels = cursorSDKChannels; exports.openAIAgentsCoreChannels = openAIAgentsCoreChannels; exports.googleGenAIChannels = googleGenAIChannels; exports.huggingFaceChannels = huggingFaceChannels; exports.openRouterAgentChannels = openRouterAgentChannels; exports.openRouterChannels = openRouterChannels; exports.mistralChannels = mistralChannels; exports.googleADKChannels = googleADKChannels; exports.cohereChannels = cohereChannels; exports.groqChannels = groqChannels; exports.genkitChannels = genkitChannels; exports.genkitCoreChannels = genkitCoreChannels; exports.gitHubCopilotChannels = gitHubCopilotChannels; exports.flueChannels = flueChannels; exports.langChainChannels = langChainChannels; exports.getDefaultInstrumentationIntegrations = getDefaultInstrumentationIntegrations; exports.readDisabledInstrumentationEnvConfig = readDisabledInstrumentationEnvConfig; exports.isInstrumentationIntegrationDisabled = isInstrumentationIntegrationDisabled; exports.installMastraExporterFactory = installMastraExporterFactory; exports.classifyMastraTarget = classifyMastraTarget; exports.patchMastraSource = patchMastraSource;