braintrust 3.12.0 → 3.14.0

package/dist/browser.mjs

@@ -92,6 +92,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
@@ -3937,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) {
@@ -3964,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;
@@ -3988,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);
     }
@@ -4018,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);
     }
@@ -4566,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
@@ -5433,6 +5509,19 @@ var JSONAttachment = class extends Attachment {
    */
   constructor(data, options) {
     const { filename = "data.json", pretty = false, state } = options ?? {};
+    const deferredJsonAttachment = globalThis.__BT_DATASET_PIPELINE_DEFER_JSON_ATTACHMENT__;
+    if (deferredJsonAttachment) {
+      super({
+        data: new Blob([]),
+        filename,
+        contentType: "application/json",
+        state
+      });
+      return deferredJsonAttachment(data, {
+        filename,
+        pretty
+      });
+    }
     const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
     const blob = new Blob([jsonString], { type: "application/json" });
     super({
@@ -7425,10 +7514,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();
@@ -8669,9 +8759,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(
@@ -9007,6 +9103,7 @@ var Dataset2 = class extends ObjectFetcher {
     metadata,
     tags,
     output,
+    origin,
     isMerge
   }) {
     return new LazyValue(async () => {
@@ -9021,6 +9118,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
         } : {}
@@ -9040,6 +9138,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.
@@ -9050,7 +9149,8 @@ var Dataset2 = class extends ObjectFetcher {
     metadata,
     tags,
     id,
-    output
+    output,
+    origin
   }) {
     this.validateEvent({ metadata, expected, output, tags });
     const rowId = id || uuidv42();
@@ -9062,6 +9162,7 @@ var Dataset2 = class extends ObjectFetcher {
         metadata,
         tags,
         output,
+        origin,
         isMerge: false
       })
     );
@@ -25572,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();
@@ -25637,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();
     }
@@ -25750,6 +25851,7 @@ var envIntegrationAliases = {
   cursorsdk: "cursorSDK",
   flue: "flue",
   "flue-runtime": "flue",
+  mastra: "mastra",
   "openai-agents": "openAIAgents",
   openaiagents: "openAIAgents",
   "openai-agents-core": "openAIAgents",
@@ -25792,6 +25894,7 @@ function getDefaultInstrumentationIntegrations() {
     cursor: true,
     cursorSDK: true,
     flue: true,
+    mastra: true,
     openAIAgents: true,
     openrouter: true,
     openrouterAgent: true,
@@ -26019,6 +26122,10 @@ function configureBrowser() {
     }
     return process.env[name];
   };
+  isomorph_default.getBraintrustApiKey = async () => {
+    const value = isomorph_default.getEnv("BRAINTRUST_API_KEY");
+    return value?.trim() ? value : void 0;
+  };
   isomorph_default.hash = (data) => {
     let hash = 0;
     for (let i = 0; i < data.length; i++) {
@@ -26045,6 +26152,7 @@ __export(exports_exports, {
   BaseExperiment: () => BaseExperiment,
   BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
+  BraintrustObservabilityExporter: () => BraintrustObservabilityExporter,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
   CachedSpanFetcher: () => CachedSpanFetcher,
@@ -26054,6 +26162,7 @@ __export(exports_exports, {
   DEFAULT_FETCH_BATCH_SIZE: () => DEFAULT_FETCH_BATCH_SIZE,
   DEFAULT_MAX_REQUEST_SIZE: () => DEFAULT_MAX_REQUEST_SIZE,
   Dataset: () => Dataset2,
+  DatasetPipeline: () => DatasetPipeline,
   ERR_PERMALINK: () => ERR_PERMALINK,
   Eval: () => Eval,
   EvalResultWithSummary: () => EvalResultWithSummary,
@@ -27660,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;
 }
@@ -29312,10 +29611,12 @@ function formatExperimentSummary(summary) {
 // src/wrappers/shared/flush.ts
 async function summarizeAndFlush(experiment, options) {
   const shouldDisplay = options.displaySummary ?? true;
-  const summary = await experiment.summarize();
-  if (shouldDisplay) {
-    console.log(formatExperimentSummary(summary));
+  if (!shouldDisplay) {
+    await experiment.flush();
+    return;
   }
+  const summary = await experiment.summarize();
+  console.log(formatExperimentSummary(summary));
 }
 
 // src/wrappers/vitest/flush-manager.ts
@@ -31179,8 +31480,12 @@ var waterfall$1 = awaitify(waterfall);
 
 // 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
     });
@@ -31189,16 +31494,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: [
           {
@@ -31211,8 +31517,8 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
             right: { op: "literal", value: "scorer" }
           }
         ]
-      }
-    ];
+      });
+    }
     if (spanTypeFilter && spanTypeFilter.length > 0) {
       children.push({
         op: "in",
@@ -31238,35 +31544,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);
     }
@@ -31283,7 +31603,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) ?? [];
@@ -31361,10 +31681,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) {
@@ -31375,13 +31698,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.
@@ -32570,6 +32899,34 @@ var defaultReporter = {
   }
 };
 
+// src/dataset-pipeline.ts
+function DatasetPipeline(definition) {
+  if (!globalThis.__braintrust_dataset_pipelines) {
+    globalThis.__braintrust_dataset_pipelines = [];
+  }
+  const storedDefinition = {
+    name: definition.name,
+    source: {
+      projectId: definition.source.projectId,
+      projectName: definition.source.projectName,
+      orgName: definition.source.orgName,
+      filter: definition.source.filter,
+      scope: definition.source.scope ?? "span"
+    },
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+    transform: definition.transform,
+    target: {
+      projectId: definition.target.projectId,
+      projectName: definition.target.projectName,
+      orgName: definition.target.orgName,
+      datasetName: definition.target.datasetName,
+      description: definition.target.description,
+      metadata: definition.target.metadata
+    }
+  };
+  globalThis.__braintrust_dataset_pipelines.push(storedDefinition);
+}
+
 // src/framework2.ts
 import { z as z12 } from "zod/v3";
 var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
@@ -33100,6 +33457,7 @@ export {
   BaseExperiment,
   BraintrustLangChainCallbackHandler,
   BraintrustMiddleware,
+  BraintrustObservabilityExporter,
   BraintrustState,
   BraintrustStream,
   CachedSpanFetcher,
@@ -33109,6 +33467,7 @@ export {
   DEFAULT_FETCH_BATCH_SIZE,
   DEFAULT_MAX_REQUEST_SIZE,
   Dataset2 as Dataset,
+  DatasetPipeline,
   ERR_PERMALINK,
   Eval,
   EvalResultWithSummary,