braintrust 3.12.0 → 3.14.0

package/dist/cli.js

@@ -1232,7 +1232,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "3.12.0",
+      version: "3.14.0",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1370,29 +1370,16 @@ var require_package = __commonJS({
         test: 'vitest run --exclude "src/wrappers/**/*.test.ts" --exclude "src/otel/**/*.test.ts" --exclude "smoke/**/*.test.ts" --exclude "src/zod/**/*.test.ts" --exclude "tests/api-compatibility/**"',
         "test:core": "pnpm prune && pnpm test",
         "test:checks": "pnpm run test:core && pnpm run test:vitest",
-        "test:external": "pnpm run test:external:sequential && node scripts/run-parallel.mjs test:external:ai-sdk-v5 test:external:ai-sdk-v6 test:external:claude-agent-sdk",
-        "test:external:sequential": "pnpm run test:external:openai && pnpm run test:external:anthropic && pnpm run test:external:google-genai",
-        "test:external:openai": "bash scripts/test-provider.sh test:openai openai",
-        "test:external:anthropic": "bash scripts/test-provider.sh test:anthropic @anthropic-ai/sdk",
-        "test:external:google-genai": "bash scripts/test-provider.sh test:google-genai @google/genai",
-        "test:external:ai-sdk": "pnpm run test:external:ai-sdk-v5 && pnpm run test:external:ai-sdk-v6",
-        "test:external:ai-sdk-v5": "cd src/wrappers/ai-sdk/tests/v5 && pnpm install --ignore-workspace && pnpm test",
-        "test:external:ai-sdk-v6": "cd src/wrappers/ai-sdk/tests/v6 && pnpm install --ignore-workspace && pnpm test",
-        "test:external:claude-agent-sdk": "cd src/wrappers/claude-agent-sdk && pnpm install && pnpm test",
-        "test:all": "pnpm run test:checks && pnpm run test:external",
+        "test:all": "pnpm run test:checks",
         "test:api-compat": "vitest run tests/api-compatibility/api-compatibility.test.ts",
-        "test:anthropic": "vitest run src/wrappers/anthropic.test.ts",
-        "test:openai": "vitest run src/wrappers/oai.test.ts",
         "test:otel": "vitest run --dir src/otel",
         "test:otel-no-deps": "vitest run src/otel/otel-no-deps.test.ts --reporter=verbose",
-        "test:google-genai": "vitest run src/wrappers/google-genai.test.ts",
         "test:ai-sdk-v1": "vitest run src/wrappers/ai-sdk-v1.test.ts",
         "test:ai-sdk-v2": "vitest run src/wrappers/ai-sdk-v2.test.ts src/wrappers/ai-sdk-v1.test.ts",
         "test:ai-sdk-v3": "vitest run src/wrappers/ai-sdk-v3.test.ts",
         "test:zod-v3": "vitest run src/zod/zod-v3-serialization.test.ts",
         "test:zod-v4": "vitest run src/zod/zod-v4-serialization.test.ts",
         "test:mastra": "vitest run src/wrappers/mastra.test.ts",
-        "test:claude-agent-sdk": "pnpm --filter @braintrust/claude-agent-sdk-tests test",
         "test:vitest": "pnpm --filter @braintrust/vitest-wrapper-tests test",
         "test:output": "tsx scripts/test-output.ts --with-comparison --with-metrics --with-progress",
         bench: "tsx src/queue.bench.ts",
@@ -1407,28 +1394,22 @@ var require_package = __commonJS({
       author: "",
       license: "MIT",
       devDependencies: {
-        "@ai-sdk/anthropic": "2.0.37",
         "@anthropic-ai/sdk": "^0.60.0",
-        "@google/adk": "^0.6.1",
-        "@google/genai": "^1.25.0",
         "@nodelib/fs.walk": "^1.2.8",
         "@types/argparse": "^2.0.14",
         "@types/async": "^3.2.24",
         "@types/cli-progress": "^3.11.5",
         "@types/cors": "^2.8.17",
         "@types/express": "^5.0.0",
-        "@types/graceful-fs": "^4.1.9",
         "@types/http-errors": "^2.0.4",
         "@types/mustache": "^4.2.5",
         "@types/node": "^20.10.5",
         "@types/pluralize": "^0.0.30",
         "@types/tar": "^6.1.13",
-        "@types/uuid": "^9.0.7",
         "@typescript-eslint/eslint-plugin": "^8.49.0",
         "@typescript-eslint/parser": "^8.49.0",
         ai: "^6.0.0",
         async: "^3.2.5",
-        autoevals: "^0.0.131",
         "cross-env": "^7.0.3",
         "eslint-plugin-node-import": "^1.0.5",
         openai: "6.25.0",
@@ -1460,7 +1441,6 @@ var require_package = __commonJS({
         esbuild: "0.28.0",
         "eventsource-parser": "^1.1.2",
         express: "^5.2.1",
-        "graceful-fs": "^4.2.11",
         "http-errors": "^2.0.0",
         minimatch: "^10.2.5",
         "module-details-from-path": "^1.0.4",
@@ -1470,7 +1450,7 @@ var require_package = __commonJS({
         "source-map": "^0.7.4",
         "termi-link": "^1.0.1",
         unplugin: "^2.3.5",
-        uuid: "^9.0.1",
+        uuid: "^11.1.1",
         "zod-to-json-schema": "^3.25.0"
       },
       peerDependencies: {
@@ -1494,8 +1474,8 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var esbuild = __toESM(require("esbuild"));
-var dotenv2 = __toESM(require("dotenv"));
-var import_node_fs2 = __toESM(require("node:fs"));
+var dotenv3 = __toESM(require("dotenv"));
+var import_node_fs3 = __toESM(require("node:fs"));
 var import_node_os = __toESM(require("node:os"));
 var import_node_path5 = __toESM(require("node:path"));
 var import_node_util5 = __toESM(require("node:util"));
@@ -1593,6 +1573,7 @@ var iso = {
   getRepoInfo: async (_settings) => void 0,
   getPastNAncestors: async () => [],
   getEnv: (_name) => void 0,
+  getBraintrustApiKey: async () => void 0,
   getCallerLocation: () => void 0,
   newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -5456,6 +5437,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) {
@@ -5483,16 +5534,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;
@@ -5507,7 +5560,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);
     }
@@ -5537,23 +5590,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);
     }
@@ -6085,21 +6140,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
@@ -8470,10 +8526,11 @@ async function login(options = {}) {
 async function loginToState(options = {}) {
   const {
     appUrl = isomorph_default.getEnv("BRAINTRUST_APP_URL") || "https://www.braintrust.dev",
-    apiKey = isomorph_default.getEnv("BRAINTRUST_API_KEY"),
+    apiKey: apiKeyArg,
     orgName = isomorph_default.getEnv("BRAINTRUST_ORG_NAME"),
     fetch: fetch2 = globalThis.fetch
   } = options || {};
+  const apiKey = apiKeyArg !== void 0 ? apiKeyArg : await isomorph_default.getBraintrustApiKey();
   const appPublicUrl = isomorph_default.getEnv("BRAINTRUST_APP_PUBLIC_URL") || appUrl;
   const state = new BraintrustState(options);
   state.resetLoginInfo();
@@ -9492,9 +9549,15 @@ var SpanImpl = class _SpanImpl {
       const cachedSpan = {
         input: partialRecord.input,
         output: partialRecord.output,
+        expected: partialRecord.expected,
+        error: partialRecord.error,
+        scores: partialRecord.scores,
+        metrics: partialRecord.metrics,
         metadata: partialRecord.metadata,
+        tags: partialRecord.tags,
         span_id: this._spanId,
         span_parents: this._spanParents,
+        is_root: this._spanId === this._rootSpanId,
         span_attributes: partialRecord.span_attributes
       };
       this._state.spanCache.queueWrite(
@@ -9830,6 +9893,7 @@ var Dataset2 = class extends ObjectFetcher {
     metadata,
     tags,
     output,
+    origin,
     isMerge
   }) {
     return new LazyValue(async () => {
@@ -9844,6 +9908,7 @@ var Dataset2 = class extends ObjectFetcher {
         created: !isMerge ? (/* @__PURE__ */ new Date()).toISOString() : void 0,
         //if we're merging/updating an event we will not add this ts
         metadata,
+        origin,
         ...!!isMerge ? {
           [IS_MERGE_FIELD]: true
         } : {}
@@ -9863,6 +9928,7 @@ var Dataset2 = class extends ObjectFetcher {
    * about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the
    * `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any
    * JSON-serializable type, but its keys must be strings.
+   * @param event.origin (Optional) a reference to the source object this dataset record was derived from.
    * @param event.id (Optional) a unique identifier for the event. If you don't provide one, Braintrust will generate one for you.
    * @param event.output: (Deprecated) The output of your application. Use `expected` instead.
    * @returns The `id` of the logged record.
@@ -9873,7 +9939,8 @@ var Dataset2 = class extends ObjectFetcher {
     metadata,
     tags,
     id,
-    output
+    output,
+    origin
   }) {
     this.validateEvent({ metadata, expected, output, tags });
     const rowId = id || (0, import_uuid2.v4)();
@@ -9885,6 +9952,7 @@ var Dataset2 = class extends ObjectFetcher {
         metadata,
         tags,
         output,
+        origin,
         isMerge: false
       })
     );
@@ -11706,8 +11774,12 @@ async function invoke(args) {
 
 // src/trace.ts
 var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
-  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter) {
-    const filterExpr = _SpanFetcher.buildFilter(rootSpanId, spanTypeFilter);
+  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false) {
+    const filterExpr = _SpanFetcher.buildFilter(
+      rootSpanId,
+      spanTypeFilter,
+      includeScorers
+    );
     super(objectType, void 0, void 0, {
       filter: filterExpr
     });
@@ -11716,16 +11788,17 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     this._state = _state;
     this.spanTypeFilter = spanTypeFilter;
   }
-  static buildFilter(rootSpanId, spanTypeFilter) {
+  static buildFilter(rootSpanId, spanTypeFilter, includeScorers = false) {
     const children = [
       // Base filter: root_span_id = 'value'
       {
         op: "eq",
         left: { op: "ident", name: ["root_span_id"] },
         right: { op: "literal", value: rootSpanId }
-      },
-      // Exclude span_attributes.purpose = 'score'
-      {
+      }
+    ];
+    if (!includeScorers) {
+      children.push({
         op: "or",
         children: [
           {
@@ -11738,8 +11811,8 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
             right: { op: "literal", value: "scorer" }
           }
         ]
-      }
-    ];
+      });
+    }
     if (spanTypeFilter && spanTypeFilter.length > 0) {
       children.push({
         op: "in",
@@ -11765,35 +11838,49 @@ var CachedSpanFetcher = class {
   fetchFn;
   constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {
     if (typeof objectTypeOrFetchFn === "function") {
-      this.fetchFn = objectTypeOrFetchFn;
+      this.fetchFn = (spanType) => objectTypeOrFetchFn(spanType);
     } else {
       const objectType = objectTypeOrFetchFn;
-      this.fetchFn = async (spanType) => {
+      this.fetchFn = async (spanType, includeScorers) => {
         const state = await getState();
         const fetcher = new SpanFetcher(
           objectType,
           objectId,
           rootSpanId,
           state,
-          spanType
+          spanType,
+          includeScorers
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => row.span_attributes?.purpose !== "scorer").map((row) => ({
+        return rows.map((row) => ({
           input: row.input,
           output: row.output,
+          expected: row.expected,
+          error: row.error,
+          scores: row.scores,
+          metrics: row.metrics,
           metadata: row.metadata,
           span_id: row.span_id,
           span_parents: row.span_parents,
+          is_root: row.is_root,
           span_attributes: row.span_attributes,
           id: row.id,
           _xact_id: row._xact_id,
           _pagination_key: row._pagination_key,
-          root_span_id: row.root_span_id
+          root_span_id: row.root_span_id,
+          created: row.created,
+          tags: row.tags
         }));
       };
     }
   }
-  async getSpans({ spanType } = {}) {
+  async getSpans({
+    spanType,
+    includeScorers = false
+  } = {}) {
+    if (includeScorers) {
+      return this.fetchFn(spanType, true);
+    }
     if (this.allFetched) {
       return this.getFromCache(spanType);
     }
@@ -11810,7 +11897,7 @@ var CachedSpanFetcher = class {
     return this.getFromCache(spanType);
   }
   async fetchSpans(spanType) {
-    const spans = await this.fetchFn(spanType);
+    const spans = await this.fetchFn(spanType, false);
     for (const span of spans) {
       const type = span.span_attributes?.type ?? "";
       const existing = this.spanCache.get(type) ?? [];
@@ -11888,10 +11975,13 @@ var LocalTrace = class {
    * First checks the local span cache for recently logged spans, then falls
    * back to CachedSpanFetcher which handles BTQL fetching and caching.
    */
-  async getSpans({ spanType } = {}) {
+  async getSpans({
+    spanType,
+    includeScorers = false
+  } = {}) {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
-      let spans = cachedSpans.filter(
+      let spans = includeScorers ? cachedSpans : cachedSpans.filter(
         (span) => span.span_attributes?.purpose !== "scorer"
       );
       if (spanType && spanType.length > 0) {
@@ -11902,13 +11992,19 @@ var LocalTrace = class {
       return spans.map((span) => ({
         input: span.input,
         output: span.output,
+        expected: span.expected,
+        error: span.error,
+        scores: span.scores,
+        metrics: span.metrics,
         metadata: span.metadata,
         span_id: span.span_id,
         span_parents: span.span_parents,
-        span_attributes: span.span_attributes
+        is_root: span.is_root,
+        span_attributes: span.span_attributes,
+        tags: span.tags
       }));
     }
-    return this.cachedFetcher.getSpans({ spanType });
+    return this.cachedFetcher.getSpans({ spanType, includeScorers });
   }
   /**
    * Get the thread (preprocessed messages) for this trace.
@@ -13353,6 +13449,7 @@ var fsSync = __toESM(require("node:fs"));
 var crypto = __toESM(require("node:crypto"));
 var import_node_util3 = require("node:util");
 var zlib = __toESM(require("node:zlib"));
+var dotenv = __toESM(require("dotenv"));
 
 // src/gitutil.ts
 var import_simple_git = require("simple-git");
@@ -29315,7 +29412,7 @@ var BraintrustPlugin = class extends BasePlugin {
     this.config = config3;
   }
   onEnable() {
-    const integrations = this.config.integrations || {};
+    const integrations = this.config.integrations ?? {};
     if (integrations.openai !== false) {
       this.openaiPlugin = new OpenAIPlugin();
       this.openaiPlugin.enable();
@@ -29380,7 +29477,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();
     }
@@ -29493,6 +29590,7 @@ var envIntegrationAliases = {
   cursorsdk: "cursorSDK",
   flue: "flue",
   "flue-runtime": "flue",
+  mastra: "mastra",
   "openai-agents": "openAIAgents",
   openaiagents: "openAIAgents",
   "openai-agents-core": "openAIAgents",
@@ -29535,6 +29633,7 @@ function getDefaultInstrumentationIntegrations() {
     cursor: true,
     cursorSDK: true,
     flue: true,
+    mastra: true,
     openAIAgents: true,
     openrouter: true,
     openrouterAgent: true,
@@ -29559,6 +29658,9 @@ function readDisabledInstrumentationEnvConfig(disabledList) {
   }
   return { integrations };
 }
+function isInstrumentationIntegrationDisabled(integrations, ...names) {
+  return names.some((name) => integrations?.[name] === false);
+}
 
 // src/instrumentation/registry.ts
 var REGISTRY_STATE_KEY = /* @__PURE__ */ Symbol.for("braintrust.registry");
@@ -29652,12 +29754,318 @@ var PluginRegistry = class {
 };
 var registry = new PluginRegistry();
 
+// 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 EXPORTER_FACTORY_KEY = JSON.stringify(MASTRA_EXPORTER_FACTORY_GLOBAL);
+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) {}
+  }
+})();
+`;
+
+// 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);
+}
+
 // src/node/config.ts
+var BRAINTRUST_ENV_SEARCH_PARENT_LIMIT = 64;
 function configureNode() {
   isomorph_default.buildType = "node";
   isomorph_default.getRepoInfo = getRepoInfo;
   isomorph_default.getPastNAncestors = getPastNAncestors;
-  isomorph_default.getEnv = (name) => process.env[name];
+  isomorph_default.getEnv = (name) => {
+    const value = process.env[name];
+    return name === "BRAINTRUST_API_KEY" && !value?.trim() ? void 0 : value;
+  };
+  isomorph_default.getBraintrustApiKey = async () => {
+    const value = process.env.BRAINTRUST_API_KEY;
+    if (value?.trim()) {
+      return value;
+    }
+    const envPaths = [];
+    for (let dir2 = process.cwd(), depth = 0; depth <= BRAINTRUST_ENV_SEARCH_PARENT_LIMIT; dir2 = path.dirname(dir2), depth++) {
+      envPaths.push(path.join(dir2, ".env.braintrust"));
+      if (path.dirname(dir2) === dir2) {
+        break;
+      }
+    }
+    const pending = /* @__PURE__ */ new Map();
+    envPaths.forEach((envPath, index) => {
+      pending.set(
+        index,
+        fs.readFile(envPath, "utf8").then(
+          (contents) => ({ contents, envPath, index }),
+          (error2) => ({ error: error2, envPath, index })
+        )
+      );
+    });
+    const results = [];
+    let nearestUnresolvedIndex = 0;
+    while (pending.size > 0) {
+      const result = await Promise.race(pending.values());
+      pending.delete(result.index);
+      results[result.index] = result;
+      while (results[nearestUnresolvedIndex]) {
+        const nearestResult = results[nearestUnresolvedIndex];
+        if ("contents" in nearestResult) {
+          const parsed = dotenv.parse(nearestResult.contents);
+          const apiKey = parsed.BRAINTRUST_API_KEY;
+          return apiKey?.trim() ? apiKey : void 0;
+        }
+        const e = nearestResult.error;
+        if (typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT") {
+          nearestUnresolvedIndex++;
+          continue;
+        }
+        return void 0;
+      }
+    }
+    return void 0;
+  };
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new import_node_async_hooks.AsyncLocalStorage();
   isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
@@ -29688,6 +30096,12 @@ function configureNode() {
   isomorph_default.gunzip = (0, import_node_util3.promisify)(zlib.gunzip);
   isomorph_default.hash = (data) => crypto.createHash("sha256").update(data).digest("hex");
   _internalSetInitialState();
+  const disabled = readDisabledInstrumentationEnvConfig(
+    isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION")
+  ).integrations;
+  if (!isInstrumentationIntegrationDisabled(disabled, "mastra")) {
+    installMastraExporterFactory(() => new BraintrustObservabilityExporter());
+  }
   registry.enable();
 }
 
@@ -29695,7 +30109,7 @@ function configureNode() {
 var import_env2 = require("@next/env");
 
 // src/cli/functions/upload.ts
-var import_node_fs = __toESM(require("node:fs"));
+var import_node_fs2 = __toESM(require("node:fs"));
 var import_node_path3 = __toESM(require("node:path"));
 var import_node_zlib = require("node:zlib");
 var import_v312 = require("zod/v3");
@@ -29706,21 +30120,7 @@ var fs2 = __toESM(require("node:fs/promises"));
 
 // src/cli/jest/nodeModulesPaths.ts
 var path2 = __toESM(require("node:path"));
-
-// src/cli/jest/tryRealpath.ts
-var import_graceful_fs = require("graceful-fs");
-function tryRealpath(path8) {
-  try {
-    path8 = import_graceful_fs.realpathSync.native(path8);
-  } catch (error2) {
-    if (error2.code !== "ENOENT" && error2.code !== "EISDIR") {
-      throw error2;
-    }
-  }
-  return path8;
-}
-
-// src/cli/jest/nodeModulesPaths.ts
+var import_node_fs = require("node:fs");
 function nodeModulesPaths(basedir, options) {
   const modules = options && options.moduleDirectory ? Array.from(options.moduleDirectory) : ["node_modules"];
   const basedirAbs = path2.resolve(basedir);
@@ -29732,7 +30132,7 @@ function nodeModulesPaths(basedir, options) {
   }
   let physicalBasedir;
   try {
-    physicalBasedir = tryRealpath(basedirAbs);
+    physicalBasedir = import_node_fs.realpathSync.native(basedirAbs);
   } catch {
     physicalBasedir = basedirAbs;
   }
@@ -30709,7 +31109,7 @@ async function uploadBundles({
     if (!pathInfo) {
       return true;
     }
-    const bundleStream = import_node_fs.default.createReadStream(bundleFile).pipe((0, import_node_zlib.createGzip)());
+    const bundleStream = import_node_fs2.default.createReadStream(bundleFile).pipe((0, import_node_zlib.createGzip)());
     const bundleData = await new Promise((resolve2, reject2) => {
       const chunks = [];
       bundleStream.on("data", (chunk) => {
@@ -30817,7 +31217,7 @@ async function buildBundledFunctionEntry({
 
 // src/cli/util/bundle.ts
 var import_env = require("@next/env");
-var dotenv = __toESM(require("dotenv"));
+var dotenv2 = __toESM(require("dotenv"));
 
 // src/cli/util/debug-logging.ts
 var VERBOSE_DEPRECATION_MESSAGE = "--verbose is deprecated and will be removed in a future version of braintrust. Use --debug-logging debug to see full stack traces and troubleshooting details.";
@@ -30844,7 +31244,7 @@ async function loadCLIEnv(args) {
   normalizeDebugLoggingArgs(args);
   (0, import_env.loadEnvConfig)(process.cwd(), true);
   if (args.env_file) {
-    const loaded = dotenv.config({ path: args.env_file });
+    const loaded = dotenv2.config({ path: args.env_file });
     if (loaded.error) {
       console.error(error(`Error loading ${args.env_file}: ${loaded.error}`));
       process.exit(1);
@@ -32222,7 +32622,7 @@ function checkMatch(pathInput, include_patterns, exclude_patterns) {
 async function collectFiles(inputPath, mode) {
   let pathStat = null;
   try {
-    pathStat = import_node_fs2.default.lstatSync(inputPath);
+    pathStat = import_node_fs3.default.lstatSync(inputPath);
   } catch (e) {
     console.error(error(`Error reading ${inputPath}: ${e}`));
     process.exit(1);
@@ -32395,7 +32795,7 @@ async function run(args) {
   normalizeDebugLoggingArgs(args);
   (0, import_env2.loadEnvConfig)(process.cwd(), true);
   if (args.env_file) {
-    const loaded = dotenv2.config({ path: args.env_file });
+    const loaded = dotenv3.config({ path: args.env_file });
     if (loaded.error) {
       console.error(error(`Error loading ${args.env_file}: ${loaded.error}`));
       process.exit(1);
@@ -32473,7 +32873,7 @@ async function run(args) {
 }
 function addAuthArgs(parser) {
   parser.add_argument("--api-key", {
-    help: "Specify a braintrust api key. If the parameter is not specified, the BRAINTRUST_API_KEY environment variable will be used."
+    help: "Specify a braintrust api key. If the parameter is not specified, BRAINTRUST_API_KEY or the nearest .env.braintrust file will be used."
   });
   parser.add_argument("--org-name", {
     help: "The name of a specific organization to connect to. This is useful if you belong to multiple."