braintrust 3.13.0 → 3.14.0

package/dist/browser.js

@@ -38,6 +38,7 @@ __export(browser_exports, {
   BaseExperiment: () => BaseExperiment,
   BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
+  BraintrustObservabilityExporter: () => BraintrustObservabilityExporter,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
   CachedSpanFetcher: () => CachedSpanFetcher,
@@ -4115,6 +4116,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) {
@@ -4142,16 +4213,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;
@@ -4166,7 +4239,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);
     }
@@ -4196,23 +4269,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);
     }
@@ -4744,21 +4819,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
@@ -25775,7 +25851,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();
@@ -25840,7 +25916,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();
     }
@@ -25953,6 +26029,7 @@ var envIntegrationAliases = {
   cursorsdk: "cursorSDK",
   flue: "flue",
   "flue-runtime": "flue",
+  mastra: "mastra",
   "openai-agents": "openAIAgents",
   openaiagents: "openAIAgents",
   "openai-agents-core": "openAIAgents",
@@ -25995,6 +26072,7 @@ function getDefaultInstrumentationIntegrations() {
     cursor: true,
     cursorSDK: true,
     flue: true,
+    mastra: true,
     openAIAgents: true,
     openrouter: true,
     openrouterAgent: true,
@@ -26252,6 +26330,7 @@ __export(exports_exports, {
   BaseExperiment: () => BaseExperiment,
   BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
+  BraintrustObservabilityExporter: () => BraintrustObservabilityExporter,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
   CachedSpanFetcher: () => CachedSpanFetcher,
@@ -27868,6 +27947,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;
 }