braintrust 3.13.0 → 3.15.0

package/dev/dist/index.mjs

@@ -4254,6 +4254,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) {
@@ -4281,16 +4351,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;
@@ -4305,7 +4377,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);
     }
@@ -4335,23 +4407,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);
     }
@@ -4883,21 +4957,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
@@ -23355,803 +23430,440 @@ var flueChannels = defineChannels("@flue/runtime", {
   createContext: channel({
     channelName: "createFlueContext",
     kind: "sync-stream"
-  }),
-  openSession: channel({
-    channelName: "Harness.openSession",
-    kind: "async"
-  }),
-  contextEvent: channel({
-    channelName: "context.event",
-    kind: "sync-stream"
-  }),
-  prompt: channel({
-    channelName: "session.prompt",
-    kind: "async"
-  }),
-  skill: channel({
-    channelName: "session.skill",
-    kind: "async"
-  }),
-  task: channel({
-    channelName: "session.task",
-    kind: "async"
-  }),
-  compact: channel({
-    channelName: "session.compact",
-    kind: "async"
   })
 });
 
-// src/wrappers/flue.ts
-var WRAPPED_FLUE_CONTEXT = /* @__PURE__ */ Symbol.for("braintrust.flue.wrapped-context");
-var WRAPPED_FLUE_HARNESS = /* @__PURE__ */ Symbol.for("braintrust.flue.wrapped-harness");
-var WRAPPED_FLUE_SESSION = /* @__PURE__ */ Symbol.for("braintrust.flue.wrapped-session");
-var SUBSCRIBED_FLUE_CONTEXT_EVENTS = /* @__PURE__ */ Symbol.for(
-  "braintrust.flue.subscribed-context-events"
-);
-function patchFlueContextInPlace(ctx) {
-  const context = ctx;
-  if (context[WRAPPED_FLUE_CONTEXT]) {
-    return ctx;
-  }
-  const originalInit = context.init.bind(context);
-  try {
-    Object.defineProperty(context, WRAPPED_FLUE_CONTEXT, {
-      configurable: false,
-      enumerable: false,
-      value: true
-    });
-    Object.defineProperty(context, "init", {
-      configurable: true,
-      value: async function wrappedFlueInit(options) {
-        const harness = await originalInit(options);
-        return wrapFlueHarness(harness);
-      },
-      writable: true
-    });
-  } catch {
-  }
-  return ctx;
-}
-function subscribeFlueContextEvents(ctx, options = {}) {
-  if (!ctx || typeof ctx !== "object" || typeof ctx.subscribeEvent !== "function") {
-    return void 0;
+// src/instrumentation/plugins/flue-plugin.ts
+var FLUE_AUTO_STATE = /* @__PURE__ */ Symbol.for("braintrust.flue.auto-state");
+var FLUE_OBSERVE_BRIDGE = /* @__PURE__ */ Symbol.for("braintrust.flue.observe-bridge");
+var braintrustFlueObserver = (event, ctx) => {
+  getObserveBridge().handle(event, ctx);
+};
+var FluePlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(enableFlueAutoInstrumentation());
   }
-  const context = ctx;
-  const captureTurnSpans = options.captureTurnSpans ?? true;
-  const existingSubscription = context[SUBSCRIBED_FLUE_CONTEXT_EVENTS];
-  if (existingSubscription) {
-    if (existingSubscription.captureTurnSpans || !captureTurnSpans) {
-      return void 0;
-    }
-    try {
-      existingSubscription.unsubscribe();
-    } catch {
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
     }
+    this.unsubscribers = [];
   }
-  try {
-    const unsubscribe = ctx.subscribeEvent((event) => {
-      flueChannels.contextEvent.traceSync(() => void 0, {
-        arguments: [event],
-        captureTurnSpans,
-        context: ctx
-      });
-    });
-    if (existingSubscription) {
-      existingSubscription.captureTurnSpans = captureTurnSpans;
-      existingSubscription.unsubscribe = unsubscribe;
-    } else {
-      Object.defineProperty(context, SUBSCRIBED_FLUE_CONTEXT_EVENTS, {
-        configurable: false,
-        enumerable: false,
-        value: {
-          captureTurnSpans,
-          unsubscribe
-        }
-      });
+};
+function enableFlueAutoInstrumentation() {
+  const state = getAutoState();
+  state.refCount += 1;
+  if (!state.handlers) {
+    const channel2 = flueChannels.createContext.tracingChannel();
+    const handlers = {
+      end: (event) => {
+        subscribeToFlueContext(event.result, state);
+      }
+    };
+    channel2.subscribe(handlers);
+    state.channel = channel2;
+    state.handlers = handlers;
+  }
+  let released = false;
+  return () => {
+    if (released) {
+      return;
     }
-    return unsubscribe;
-  } catch {
-    return void 0;
+    released = true;
+    releaseAutoState(state);
+  };
+}
+function getAutoState() {
+  const existing = Reflect.get(globalThis, FLUE_AUTO_STATE);
+  if (isAutoState(existing)) {
+    return existing;
   }
+  const state = {
+    contexts: /* @__PURE__ */ new WeakSet(),
+    refCount: 0
+  };
+  Reflect.set(globalThis, FLUE_AUTO_STATE, state);
+  return state;
 }
-function wrapFlueHarness(harness) {
-  if (!isPlausibleFlueHarness(harness)) {
-    return harness;
+function getObserveBridge() {
+  const existing = Reflect.get(globalThis, FLUE_OBSERVE_BRIDGE);
+  if (isFlueObserveBridge(existing)) {
+    return existing;
   }
-  const target = harness;
-  if (target[WRAPPED_FLUE_HARNESS]) {
-    return harness;
+  const bridge = new FlueObserveBridge();
+  Reflect.set(globalThis, FLUE_OBSERVE_BRIDGE, bridge);
+  return bridge;
+}
+function isFlueObserveBridge(value) {
+  return isObjectLike(value) && typeof Reflect.get(value, "handle") === "function" && typeof Reflect.get(value, "reset") === "function";
+}
+function isAutoState(value) {
+  return isObjectLike(value) && Reflect.get(value, "contexts") instanceof WeakSet && typeof Reflect.get(value, "refCount") === "number";
+}
+function releaseAutoState(state) {
+  state.refCount -= 1;
+  if (state.refCount > 0) {
+    return;
   }
-  const originalSession = target.session.bind(target);
   try {
-    Object.defineProperty(target, WRAPPED_FLUE_HARNESS, {
-      configurable: false,
-      enumerable: false,
-      value: true
-    });
-    Object.defineProperty(target, "session", {
-      configurable: true,
-      value: async function wrappedFlueHarnessSession(name, options) {
-        const session = await originalSession(name, options);
-        return patchFlueSessionInPlace(session);
-      },
-      writable: true
-    });
-    const sessions = target.sessions;
-    if (sessions && typeof sessions === "object") {
-      patchFlueSessionFactory(sessions, "get");
-      patchFlueSessionFactory(sessions, "create");
+    if (state.channel && state.handlers) {
+      state.channel.unsubscribe(state.handlers);
     }
-  } catch {
+  } finally {
+    Reflect.deleteProperty(globalThis, FLUE_AUTO_STATE);
   }
-  return harness;
 }
-function patchFlueSessionInPlace(session) {
-  if (session[WRAPPED_FLUE_SESSION]) {
-    return session;
+function subscribeToFlueContext(value, state) {
+  if (!isObservableFlueContext(value) || state.contexts.has(value)) {
+    return;
   }
+  const ctx = flueContextFromUnknown(value);
+  let released = false;
+  let unsubscribe;
+  const release = () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    try {
+      unsubscribe?.();
+    } catch (error) {
+      logInstrumentationError3("Flue context unsubscribe", error);
+    }
+  };
   try {
-    Object.defineProperty(session, WRAPPED_FLUE_SESSION, {
-      configurable: false,
-      enumerable: false,
-      value: true
+    unsubscribe = value.subscribeEvent((event) => {
+      if (state.refCount <= 0) {
+        release();
+        return;
+      }
+      braintrustFlueObserver(event, ctx);
+      if (isAutoContextTerminalEvent(event, ctx)) {
+        release();
+      }
     });
-    patchCallHandleMethod(session, "prompt", flueChannels.prompt);
-    patchCallHandleMethod(session, "skill", flueChannels.skill);
-    patchCallHandleMethod(session, "task", flueChannels.task);
-    patchCompact(session);
-  } catch {
+    state.contexts.add(value);
+  } catch (error) {
+    logInstrumentationError3("Flue context subscription", error);
   }
-  return session;
 }
-function patchFlueSessionFactory(sessions, method) {
-  const original = sessions[method];
-  if (typeof original !== "function") {
-    return;
+function isAutoContextTerminalEvent(event, ctx) {
+  if (!isObjectLike(event)) {
+    return false;
   }
-  const bound = original.bind(sessions);
-  Object.defineProperty(sessions, method, {
-    configurable: true,
-    value: async function wrappedFlueSessionFactory(name, options) {
-      const session = await bound(name, options);
-      return patchFlueSessionInPlace(session);
-    },
-    writable: true
-  });
-}
-function patchCallHandleMethod(session, method, channel2) {
-  const original = session[method];
-  if (typeof original !== "function") {
-    return;
+  const type = Reflect.get(event, "type");
+  if (type === "run_end") {
+    return true;
   }
-  const bound = original.bind(session);
-  Object.defineProperty(session, method, {
-    configurable: true,
-    value(input, options) {
-      const args = [input, options];
-      const { originalResult, traced: traced2 } = traceFlueOperation(channel2, {
-        context: {
-          arguments: args,
-          operation: method,
-          session
-        },
-        run: () => bound(input, options)
-      });
-      return preserveCallHandle(originalResult, traced2);
-    },
-    writable: true
-  });
-}
-function patchCompact(session) {
-  const original = session.compact;
-  if (typeof original !== "function") {
-    return;
+  if (type !== "operation") {
+    return false;
   }
-  const bound = original.bind(session);
-  Object.defineProperty(session, "compact", {
-    configurable: true,
-    value() {
-      const context = {
-        arguments: [],
-        operation: "compact",
-        session
-      };
-      return flueChannels.compact.tracePromise(() => bound(), context);
-    },
-    writable: true
-  });
+  return !ctx?.runId && typeof Reflect.get(event, "runId") !== "string";
 }
-function traceFlueOperation(channel2, args) {
-  const tracingChannel2 = channel2.tracingChannel();
-  const context = args.context;
-  let originalResult;
-  let traced2;
-  const run = () => {
-    try {
-      originalResult = args.run();
-      tracingChannel2.end?.publish(context);
-    } catch (error) {
-      context.error = normalizeError3(error);
-      tracingChannel2.error?.publish(context);
-      tracingChannel2.end?.publish(context);
-      throw error;
-    }
-    traced2 = Promise.resolve(originalResult).then(
-      (result) => {
-        context.result = result;
-        tracingChannel2.asyncStart?.publish(context);
-        tracingChannel2.asyncEnd?.publish(context);
-        return result;
-      },
-      (error) => {
-        context.error = normalizeError3(error);
-        tracingChannel2.error?.publish(context);
-        tracingChannel2.asyncStart?.publish(context);
-        tracingChannel2.asyncEnd?.publish(context);
-        throw error;
-      }
-    );
-  };
-  if (tracingChannel2.start?.runStores) {
-    tracingChannel2.start.runStores(context, run);
-  } else {
-    tracingChannel2.start?.publish(context);
-    run();
-  }
-  return { originalResult, traced: traced2 };
+function isObservableFlueContext(value) {
+  return isObjectLike(value) && typeof Reflect.get(value, "subscribeEvent") === "function";
 }
-function normalizeError3(error) {
-  return error instanceof Error ? error : new Error(String(error));
+function isFlueEvent(event) {
+  const type = Reflect.get(event, "type");
+  return type === "run_start" || type === "run_end" || type === "operation_start" || type === "operation" || type === "turn_request" || type === "turn" || type === "tool_start" || type === "tool_call" || type === "task_start" || type === "task" || type === "compaction_start" || type === "compaction";
 }
-function preserveCallHandle(originalHandle, traced2) {
-  if (!isFlueCallHandle(originalHandle)) {
-    return traced2;
+function flueContextFromUnknown(ctx) {
+  if (!isObjectLike(ctx)) {
+    return void 0;
   }
-  const handle = originalHandle;
-  const wrapped = {
-    get signal() {
-      return handle.signal;
-    },
-    abort(reason) {
-      return handle.abort(reason);
-    },
-    then(onfulfilled, onrejected) {
-      return traced2.then(onfulfilled, onrejected);
-    }
+  const id = Reflect.get(ctx, "id");
+  const runId = Reflect.get(ctx, "runId");
+  return {
+    ...typeof id === "string" ? { id } : {},
+    ...typeof runId === "string" ? { runId } : {}
   };
-  return wrapped;
 }
-function isPlausibleFlueHarness(value) {
-  return !!value && typeof value === "object" && typeof value.session === "function";
-}
-function isFlueCallHandle(value) {
-  return !!value && typeof value === "object" && typeof value.then === "function" && typeof value.abort === "function" && "signal" in value;
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
-// src/instrumentation/plugins/flue-plugin.ts
-var FluePlugin = class extends BasePlugin {
-  activeOperationsById = /* @__PURE__ */ new Map();
-  activeOperationsByScope = /* @__PURE__ */ new Map();
-  compactionsByScope = /* @__PURE__ */ new Map();
-  pendingOperationsByKey = /* @__PURE__ */ new Map();
+var FlueObserveBridge = class {
+  compactionsByKey = /* @__PURE__ */ new Map();
+  operationsById = /* @__PURE__ */ new Map();
+  runsById = /* @__PURE__ */ new Map();
+  seenEvents = /* @__PURE__ */ new WeakSet();
   tasksById = /* @__PURE__ */ new Map();
-  toolsById = /* @__PURE__ */ new Map();
-  turnsByScope = /* @__PURE__ */ new Map();
-  onEnable() {
-    this.subscribeToContextCreation();
-    this.subscribeToSessionCreation();
-    this.subscribeToContextEvents();
-    this.subscribeToSessionOperations();
-  }
-  onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
+  toolsByKey = /* @__PURE__ */ new Map();
+  turnsByKey = /* @__PURE__ */ new Map();
+  handle(event, ctx) {
+    if (!isObjectLike(event) || !isFlueEvent(event)) {
+      return;
     }
-    this.unsubscribers = [];
-    this.activeOperationsById.clear();
-    this.activeOperationsByScope.clear();
-    this.compactionsByScope.clear();
-    this.pendingOperationsByKey.clear();
+    if (this.seenEvents.has(event)) {
+      return;
+    }
+    this.seenEvents.add(event);
+    try {
+      this.handleEvent(event, flueContextFromUnknown(ctx));
+    } catch (error) {
+      logInstrumentationError3("Flue observe", error);
+    }
+  }
+  reset() {
+    this.compactionsByKey.clear();
+    this.operationsById.clear();
+    this.runsById.clear();
+    this.seenEvents = /* @__PURE__ */ new WeakSet();
     this.tasksById.clear();
-    this.toolsById.clear();
-    this.turnsByScope.clear();
+    this.toolsByKey.clear();
+    this.turnsByKey.clear();
   }
-  subscribeToContextCreation() {
-    const channel2 = flueChannels.createContext.tracingChannel();
-    const handlers = {
-      end: (event) => {
-        const ctx = event.result;
-        if (!ctx) {
-          return;
-        }
-        subscribeFlueContextEvents(ctx, { captureTurnSpans: false });
-        patchFlueContextInPlace(ctx);
-      },
-      error: () => {
-      }
-    };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
-    });
+  handleEvent(event, ctx) {
+    switch (event.type) {
+      case "run_start":
+        this.handleRunStart(event, ctx);
+        return;
+      case "run_end":
+        this.handleRunEnd(event);
+        return;
+      case "operation_start":
+        this.handleOperationStart(event);
+        return;
+      case "operation":
+        this.handleOperation(event);
+        return;
+      case "turn_request":
+        this.handleTurnRequest(event);
+        return;
+      case "turn":
+        this.handleTurn(event);
+        return;
+      case "tool_start":
+        this.handleToolStart(event);
+        return;
+      case "tool_call":
+        this.handleToolCall(event);
+        return;
+      case "task_start":
+        this.handleTaskStart(event);
+        return;
+      case "task":
+        this.handleTask(event);
+        return;
+      case "compaction_start":
+        this.handleCompactionStart(event);
+        return;
+      case "compaction":
+        this.handleCompaction(event);
+        return;
+      default:
+        return;
+    }
   }
-  subscribeToSessionCreation() {
-    const channel2 = flueChannels.openSession.tracingChannel();
-    const handlers = {
-      asyncEnd: (event) => {
-        if (event.result) {
-          patchFlueSessionInPlace(
-            event.result
-          );
-        }
-        if (event.harness) {
-          wrapFlueHarness(event.harness);
-        }
-      },
-      error: () => {
-      }
+  handleRunStart(event, ctx) {
+    if (!event.runId) {
+      return;
+    }
+    const workflowName = event.workflowName ?? event.owner?.workflowName ?? (typeof ctx?.id === "string" ? ctx.id : "unknown");
+    const metadata = {
+      ...extractPayloadMetadata(event.payload),
+      ...extractEventMetadata(event, ctx),
+      ...workflowName ? { "flue.workflow_name": workflowName } : {},
+      provider: "flue"
     };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+    const span = startSpan({
+      name: `workflow:${workflowName}`,
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.startedAt ?? event.timestamp),
+      event: {
+        input: event.payload,
+        metadata
+      }
     });
+    this.runsById.set(event.runId, { metadata, span });
   }
-  subscribeToSessionOperations() {
-    this.subscribeToSessionOperation(flueChannels.prompt);
-    this.subscribeToSessionOperation(flueChannels.skill);
-    this.subscribeToSessionOperation(flueChannels.task);
-    this.subscribeToCompact();
-  }
-  subscribeToSessionOperation(channel2) {
-    const tracingChannel2 = channel2.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const ensureState2 = (event) => {
-      const existing = states.get(event);
-      if (existing) {
-        return existing;
-      }
-      const state = this.startOperationState({
-        args: event.arguments,
-        moduleVersion: typeof event.moduleVersion === "string" ? event.moduleVersion : void 0,
-        operation: event.operation,
-        session: event.session
+  handleRunEnd(event) {
+    const state = this.runsById.get(event.runId);
+    this.finishPendingSpansForRun(event);
+    if (state) {
+      safeLog3(state.span, {
+        ...event.isError ? { error: errorToString(event.error) } : {},
+        metadata: {
+          ...state.metadata,
+          ...extractEventMetadata(event),
+          ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
+        },
+        metrics: durationMetrics2(event.durationMs),
+        output: event.result
       });
-      states.set(event, state);
-      return state;
-    };
-    const unbindCurrentSpanStore = this.bindCurrentSpanStoreToOperationStart(
-      tracingChannel2,
-      ensureState2
-    );
-    const handlers = {
-      start: (event) => {
-        ensureState2(event);
-      },
-      asyncEnd: (event) => {
-        this.endOperationState(states.get(event), event.result);
-        states.delete(event);
-      },
-      error: (event) => {
-        const state = states.get(event);
-        if (state && event.error) {
-          safeLog3(state.span, { error: errorToString(event.error) });
-          this.finishOperationState(state);
-        }
-        states.delete(event);
-      }
-    };
-    tracingChannel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
-    });
-  }
-  subscribeToCompact() {
-    const tracingChannel2 = flueChannels.compact.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const ensureState2 = (event) => {
-      const existing = states.get(event);
-      if (existing) {
-        return existing;
-      }
-      const state = this.startOperationState({
-        args: [],
-        moduleVersion: typeof event.moduleVersion === "string" ? event.moduleVersion : void 0,
-        operation: event.operation,
-        session: event.session
-      });
-      states.set(event, state);
-      return state;
-    };
-    const unbindCurrentSpanStore = this.bindCurrentSpanStoreToOperationStart(
-      tracingChannel2,
-      ensureState2
-    );
-    const handlers = {
-      start: (event) => {
-        ensureState2(event);
-      },
-      asyncEnd: (event) => {
-        this.endOperationState(states.get(event), void 0);
-        states.delete(event);
-      },
-      error: (event) => {
-        const state = states.get(event);
-        if (state && event.error) {
-          safeLog3(state.span, { error: errorToString(event.error) });
-          this.finishOperationState(state);
-        }
-        states.delete(event);
-      }
-    };
-    tracingChannel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
-    });
-  }
-  subscribeToContextEvents() {
-    const channel2 = flueChannels.contextEvent.tracingChannel();
-    const handlers = {
-      start: (event) => {
-        const flueEvent = event.arguments[0];
-        if (!flueEvent) {
-          return;
-        }
-        try {
-          this.handleFlueEvent(flueEvent, {
-            captureTurnSpans: event.captureTurnSpans !== false
-          });
-        } catch (error) {
-          logInstrumentationError3("Flue event", error);
-        }
-      },
-      error: () => {
-      }
-    };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
-    });
-  }
-  bindCurrentSpanStoreToOperationStart(tracingChannel2, ensureState2) {
-    const state = _internalGetGlobalState();
-    const startChannel = tracingChannel2.start;
-    const contextManager = state?.contextManager;
-    const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
-    if (!currentSpanStore || !startChannel) {
-      return void 0;
+      safeEnd(state.span, eventTime(event.timestamp));
+      this.runsById.delete(event.runId);
     }
-    startChannel.bindStore(currentSpanStore, (event) => {
-      const operationState = ensureState2(event);
-      return contextManager.wrapSpanForStore(operationState.span);
-    });
-    return () => {
-      startChannel.unbindStore(currentSpanStore);
-    };
-  }
-  startOperationState(args) {
-    const sessionName = getSessionName(args.session);
-    const metadata = {
-      ...extractOperationInputMetadata(args.operation, args.args),
-      ...extractSessionMetadata(args.session),
-      "flue.operation": args.operation,
-      provider: "flue",
-      ...args.moduleVersion ? { "flue.version": args.moduleVersion } : {}
-    };
-    const span = startSpan({
-      name: `flue.session.${args.operation}`,
-      spanAttributes: { type: "task" /* TASK */ }
-    });
-    const state = {
-      metadata,
-      operation: args.operation,
-      sessionName,
-      span,
-      startTime: getCurrentUnixTimestamp()
-    };
-    safeLog3(span, {
-      input: extractOperationInput(args.operation, args.args),
-      metadata
-    });
-    this.pendingOperationQueue(operationKey(sessionName, args.operation)).push(
-      state
-    );
-    addOperationToScope(
-      this.activeOperationsByScope,
-      sessionName ?? "unknown",
-      state
-    );
-    return state;
-  }
-  endOperationState(state, result) {
-    if (!state) {
-      return;
-    }
-    const metadata = {
-      ...state.metadata,
-      ...extractPromptResponseMetadata(result)
-    };
-    const metrics = {
-      ...buildDurationMetrics3(state.startTime),
-      ...metricsFromUsage(result?.usage)
-    };
-    safeLog3(state.span, {
-      metadata,
-      metrics,
-      output: extractOperationOutput(result)
+    void flush().catch((error) => {
+      logInstrumentationError3("Flue flush", error);
     });
-    this.finishCompactionsForOperation(state);
-    this.finishOperationState(state);
-  }
-  finishOperationState(state) {
-    removePendingOperation(this.pendingOperationsByKey, state);
-    if (state.operationId) {
-      this.activeOperationsById.delete(state.operationId);
-    }
-    removeScopedOperation(this.activeOperationsByScope, state);
-    state.span.end();
-  }
-  handleFlueEvent(event, options) {
-    switch (event.type) {
-      case "operation_start":
-        this.handleOperationStart(event);
-        return;
-      case "operation":
-        this.handleOperation(event);
-        return;
-      case "text_delta":
-        if (!options.captureTurnSpans) {
-          return;
-        }
-        this.ensureTurnState(event).text.push(
-          typeof event.text === "string" ? event.text : ""
-        );
-        return;
-      case "thinking_start":
-        if (!options.captureTurnSpans) {
-          return;
-        }
-        this.handleThinkingStart(event);
-        return;
-      case "thinking_delta":
-        if (!options.captureTurnSpans) {
-          return;
-        }
-        this.handleThinkingDelta(event);
-        return;
-      case "thinking_end":
-        if (!options.captureTurnSpans) {
-          return;
-        }
-        this.handleThinkingEnd(event);
-        return;
-      case "turn":
-        if (!options.captureTurnSpans) {
-          return;
-        }
-        this.handleTurn(event);
-        return;
-      case "tool_start":
-        this.handleToolStart(event, options);
-        return;
-      case "tool_call":
-        this.handleToolCall(event);
-        return;
-      case "task_start":
-        this.handleTaskStart(event);
-        return;
-      case "task":
-        this.handleTask(event);
-        return;
-      case "compaction_start":
-        this.handleCompactionStart(event);
-        return;
-      case "compaction":
-        this.handleCompaction(event);
-        return;
-      default:
-        return;
-    }
   }
   handleOperationStart(event) {
-    if (!isInstrumentedOperation(event.operationKind)) {
+    if (!event.operationId || !isInstrumentedOperation(event.operationKind)) {
       return;
     }
-    const state = this.takePendingOperationForEvent(event);
-    if (!state) {
-      return;
-    }
-    state.operationId = event.operationId;
-    this.activeOperationsById.set(event.operationId, state);
-    addScopedOperation(this.activeOperationsByScope, event, state);
-    state.metadata = {
-      ...state.metadata,
+    const metadata = {
       ...extractEventMetadata(event),
-      "flue.operation_id": event.operationId
+      "flue.operation": event.operationKind,
+      provider: "flue"
     };
-    safeLog3(state.span, { metadata: state.metadata });
+    const parent = this.parentSpanForEvent(event);
+    const span = startFlueSpan(parent, {
+      name: `flue.${event.operationKind}`,
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.timestamp),
+      event: { metadata }
+    });
+    this.operationsById.set(event.operationId, { metadata, span });
   }
   handleOperation(event) {
-    const state = event.operationId ? this.activeOperationsById.get(event.operationId) : void 0;
-    if (!state) {
+    if (!isInstrumentedOperation(event.operationKind)) {
       return;
     }
+    const state = this.operationsById.get(event.operationId) ?? this.startSyntheticOperation(event);
+    const output = operationOutput(event);
     const metadata = {
       ...state.metadata,
       ...extractEventMetadata(event),
-      ...typeof event.durationMs === "number" ? { "flue.duration_ms": event.durationMs } : {},
-      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
+      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {},
+      ...event.usage ? { "flue.usage": event.usage } : {}
     };
-    const metrics = metricsFromUsage(event.usage);
+    this.finishPendingChildrenForOperation(event, output);
     safeLog3(state.span, {
-      ...event.error ? { error: errorToString(event.error) } : {},
+      ...event.isError ? { error: errorToString(event.error) } : {},
       metadata,
-      ...Object.keys(metrics).length ? { metrics } : {}
+      metrics: durationMetrics2(event.durationMs),
+      output
     });
+    safeEnd(state.span, eventTime(event.timestamp));
+    this.operationsById.delete(event.operationId);
   }
-  ensureTurnState(event) {
-    const scope = scopeKey(event);
-    const existing = this.turnsByScope.get(scope);
-    if (existing) {
-      return existing;
+  handleTurnRequest(event) {
+    const key = turnKey(event);
+    if (!key) {
+      return;
     }
-    const parent = this.parentSpanForEvent(event);
     const metadata = {
       ...extractEventMetadata(event),
-      provider: "flue"
+      ...event.api ? { "flue.api": event.api } : {},
+      ...event.model ? { model: event.model, "flue.model": event.model } : {},
+      ...event.provider ? { provider: event.provider } : { provider: "flue" },
+      ...event.provider ? { "flue.provider": event.provider } : {},
+      ...event.purpose ? { "flue.turn_purpose": event.purpose } : {},
+      ...event.reasoning ? { reasoning: event.reasoning } : {},
+      ...event.input?.systemPrompt ? { "flue.system_prompt": event.input.systemPrompt } : {},
+      ...event.input?.tools ? { tools: event.input.tools } : {}
     };
+    const parent = this.parentSpanForTurn(event);
     const span = startFlueSpan(parent, {
-      name: "flue.turn",
-      spanAttributes: { type: "llm" /* LLM */ }
+      name: `llm:${event.model ?? event.purpose ?? "unknown"}`,
+      spanAttributes: { type: "llm" /* LLM */ },
+      startTime: eventTime(event.timestamp),
+      event: {
+        input: event.input?.messages,
+        metadata
+      }
     });
-    const state = {
-      metadata,
-      span,
-      hasThinking: false,
-      startTime: getCurrentUnixTimestamp(),
-      text: [],
-      thinking: [],
-      toolCalls: []
-    };
-    safeLog3(span, { metadata });
-    this.turnsByScope.set(scope, state);
-    return state;
+    this.logOperationInput(
+      event.operationId,
+      event.input?.messages ?? event.input
+    );
+    this.turnsByKey.set(key, { metadata, span });
   }
   handleTurn(event) {
-    const scope = scopeKey(event);
-    const state = this.ensureTurnState(event);
-    const text = state.text.join("");
-    const reasoning = state.finalThinking ?? state.thinking.join("");
-    const outputReasoning = reasoning || (state.hasThinking ? "[reasoning stream present; content unavailable]" : void 0);
+    const key = turnKey(event);
+    if (!key) {
+      return;
+    }
+    const state = this.turnsByKey.get(key) ?? this.startSyntheticTurn(event);
     const metadata = {
       ...state.metadata,
       ...extractEventMetadata(event),
+      ...event.api ? { "flue.api": event.api } : {},
       ...event.model ? { model: event.model, "flue.model": event.model } : {},
+      ...event.provider ? { provider: event.provider } : {},
+      ...event.provider ? { "flue.provider": event.provider } : {},
+      ...event.purpose ? { "flue.turn_purpose": event.purpose } : {},
       ...event.stopReason ? { "flue.stop_reason": event.stopReason } : {},
-      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {},
-      provider: "flue"
+      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
     };
     safeLog3(state.span, {
-      ...event.error ? { error: errorToString(event.error) } : {},
+      ...event.isError ? { error: errorToString(event.error) } : {},
       metadata,
       metrics: {
-        ...durationMsMetrics(event.durationMs),
+        ...durationMetrics2(event.durationMs),
         ...metricsFromUsage(event.usage)
       },
-      output: toAssistantOutput(
-        text,
-        event.stopReason,
-        outputReasoning,
-        state.toolCalls
-      )
+      output: event.output
     });
-    state.span.end();
-    this.turnsByScope.delete(scope);
+    safeEnd(state.span, eventTime(event.timestamp));
+    this.turnsByKey.delete(key);
   }
-  handleThinkingDelta(event) {
-    const delta = event.delta;
-    if (typeof delta !== "string" || !delta) {
+  handleToolStart(event) {
+    if (!event.toolCallId) {
       return;
     }
-    const state = this.ensureTurnState(event);
-    state.hasThinking = true;
-    state.metadata["flue.thinking"] = true;
-    state.thinking.push(delta);
-  }
-  handleThinkingStart(event) {
-    const state = this.ensureTurnState(event);
-    state.hasThinking = true;
-    state.metadata["flue.thinking"] = true;
-  }
-  handleThinkingEnd(event) {
-    const state = this.ensureTurnState(event);
-    state.hasThinking = true;
-    state.metadata["flue.thinking"] = true;
-    if (typeof event.content === "string" && event.content) {
-      state.finalThinking = event.content;
-    }
-  }
-  handleToolStart(event, options) {
-    const toolCallId = event.toolCallId;
-    if (!toolCallId) {
-      return;
-    }
-    const parent = this.parentSpanForEvent(event);
-    const scope = scopeKey(event);
-    let turnState = this.turnsByScope.get(scope);
-    if (!turnState && parent && options.captureTurnSpans) {
-      turnState = this.ensureTurnState(event);
-    }
     const metadata = {
       ...extractEventMetadata(event),
       ...event.toolName ? { "flue.tool_name": event.toolName } : {},
-      "flue.tool_call_id": toolCallId,
+      "flue.tool_call_id": event.toolCallId,
       provider: "flue"
     };
+    const parent = this.parentSpanForTool(event);
     const span = startFlueSpan(parent, {
-      name: `tool: ${event.toolName ?? "unknown"}`,
-      spanAttributes: { type: "tool" /* TOOL */ }
-    });
-    if (turnState) {
-      turnState.toolCalls.push({
-        args: event.args,
-        toolCallId,
-        toolName: event.toolName
-      });
-    }
-    safeLog3(span, {
-      input: event.args,
-      metadata
-    });
-    this.toolsById.set(toolKey(event), {
-      metadata,
-      span,
-      startTime: getCurrentUnixTimestamp()
+      name: `tool:${event.toolName ?? "unknown"}`,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      startTime: eventTime(event.timestamp),
+      event: {
+        input: event.args,
+        metadata
+      }
     });
+    this.toolsByKey.set(toolKey(event), { metadata, span });
   }
   handleToolCall(event) {
+    if (!event.toolCallId) {
+      return;
+    }
     const key = toolKey(event);
-    const state = this.toolsById.get(key) ?? this.startSyntheticToolState(event, event.toolName ?? "unknown");
+    const state = this.toolsByKey.get(key) ?? this.startSyntheticTool(event);
     const metadata = {
       ...state.metadata,
       ...extractEventMetadata(event),
       ...event.toolName ? { "flue.tool_name": event.toolName } : {},
-      ...event.toolCallId ? { "flue.tool_call_id": event.toolCallId } : {},
+      "flue.tool_call_id": event.toolCallId,
       ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
     };
     safeLog3(state.span, {
       ...event.isError ? { error: errorToString(event.result) } : {},
       metadata,
-      metrics: durationMsMetrics(event.durationMs),
+      metrics: durationMetrics2(event.durationMs),
       output: event.result
     });
-    state.span.end();
-    this.toolsById.delete(key);
+    safeEnd(state.span, eventTime(event.timestamp));
+    this.toolsByKey.delete(key);
   }
   handleTaskStart(event) {
-    const parent = this.parentSpanForEvent(event);
+    if (!event.taskId) {
+      return;
+    }
     const metadata = {
       ...extractEventMetadata(event),
-      ...event.role ? { "flue.role": event.role } : {},
+      ...event.agent ? { "flue.agent": event.agent } : {},
       ...event.cwd ? { "flue.cwd": event.cwd } : {},
       "flue.task_id": event.taskId,
       provider: "flue"
     };
+    const parent = this.parentSpanForEvent(event);
     const span = startFlueSpan(parent, {
-      name: "flue.task",
-      spanAttributes: { type: "task" /* TASK */ }
-    });
-    safeLog3(span, {
-      input: event.prompt,
-      metadata
-    });
-    this.tasksById.set(event.taskId, {
-      metadata,
-      span,
-      startTime: getCurrentUnixTimestamp()
+      name: event.agent ? `task:${event.agent}` : "flue.task",
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.timestamp),
+      event: {
+        input: event.prompt,
+        metadata
+      }
     });
+    this.tasksById.set(event.taskId, { metadata, span });
   }
   handleTask(event) {
     const state = this.tasksById.get(event.taskId);
@@ -24163,426 +23875,372 @@ var FluePlugin = class extends BasePlugin {
       metadata: {
         ...state.metadata,
         ...extractEventMetadata(event),
+        ...event.agent ? { "flue.agent": event.agent } : {},
         ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
       },
-      metrics: durationMsMetrics(event.durationMs),
+      metrics: durationMetrics2(event.durationMs),
       output: event.result
     });
-    state.span.end();
+    safeEnd(state.span, eventTime(event.timestamp));
     this.tasksById.delete(event.taskId);
   }
   handleCompactionStart(event) {
-    const operationState = this.operationStateForEvent(event);
-    const parent = operationState?.span ?? this.parentSpanForEvent(event);
+    const key = compactionKey(event);
+    const input = {
+      ...event.estimatedTokens !== void 0 ? { estimatedTokens: event.estimatedTokens } : {},
+      ...event.reason ? { reason: event.reason } : {}
+    };
     const metadata = {
       ...extractEventMetadata(event),
       ...event.reason ? { "flue.compaction_reason": event.reason } : {},
       provider: "flue"
     };
-    const input = {
-      ...typeof event.estimatedTokens === "number" ? { estimatedTokens: event.estimatedTokens } : {},
-      ...event.reason ? { reason: event.reason } : {}
-    };
+    const parent = this.parentSpanForEvent(event);
     const span = startFlueSpan(parent, {
-      name: "flue.compaction",
-      spanAttributes: { type: "task" /* TASK */ }
-    });
-    safeLog3(span, {
-      input,
-      metadata
-    });
-    this.compactionsByScope.set(scopeKey(event), {
-      input,
-      metadata,
-      operationState,
-      span,
-      startTime: getCurrentUnixTimestamp()
+      name: `compaction:${event.reason ?? "unknown"}`,
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.timestamp),
+      event: {
+        input,
+        metadata
+      }
     });
+    this.logOperationInput(event.operationId, input);
+    this.compactionsByKey.set(key, { metadata, span });
   }
   handleCompaction(event) {
-    const key = scopeKey(event);
-    const state = this.compactionsByScope.get(key) ?? this.findCompactionState(event);
-    if (!state) {
-      return;
-    }
+    const key = compactionKey(event);
+    const state = this.compactionsByKey.get(key) ?? this.startSyntheticCompaction(event);
+    const metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      ...event.usage ? { "flue.usage": event.usage } : {}
+    };
     safeLog3(state.span, {
-      metadata: {
-        ...state.metadata,
-        ...extractEventMetadata(event),
-        ...typeof event.messagesBefore === "number" ? { "flue.messages_before": event.messagesBefore } : {},
-        ...typeof event.messagesAfter === "number" ? { "flue.messages_after": event.messagesAfter } : {}
-      },
+      metadata,
       metrics: {
-        ...durationMsMetrics(event.durationMs),
-        ...metricsFromUsage(event.usage)
+        ...durationMetrics2(event.durationMs),
+        ...typeof event.messagesBefore === "number" ? { messages_before: event.messagesBefore } : {},
+        ...typeof event.messagesAfter === "number" ? { messages_after: event.messagesAfter } : {}
       },
       output: {
         messagesAfter: event.messagesAfter,
         messagesBefore: event.messagesBefore
       }
     });
-    state.span.end();
-    this.deleteCompactionState(state);
+    safeEnd(state.span, eventTime(event.timestamp));
+    this.compactionsByKey.delete(key);
   }
-  findCompactionState(event) {
-    const operationState = this.operationStateForEvent(event);
-    for (const state of this.compactionsByScope.values()) {
-      if (operationState && state.operationState === operationState) {
-        return state;
+  parentSpanForTurn(event) {
+    if (event.purpose === "compaction" || event.purpose === "compaction_prefix") {
+      const compaction = this.compactionsByKey.get(compactionKey(event));
+      if (compaction) {
+        return compaction.span;
       }
     }
-    return void 0;
+    return this.parentSpanForEvent(event);
   }
-  finishCompactionsForOperation(operationState) {
-    for (const state of [...this.compactionsByScope.values()]) {
-      if (state.operationState !== operationState) {
-        continue;
+  parentSpanForEvent(event) {
+    const turn = turnKey(event);
+    if (turn) {
+      const turnState = this.turnsByKey.get(turn);
+      if (turnState) {
+        return turnState.span;
       }
-      safeLog3(state.span, {
-        input: state.input,
-        metadata: state.metadata,
-        metrics: {
-          ...buildDurationMetrics3(state.startTime)
-        },
-        output: { completed: true }
-      });
-      state.span.end();
-      this.deleteCompactionState(state);
     }
-  }
-  deleteCompactionState(state) {
-    for (const [key, candidate] of this.compactionsByScope) {
-      if (candidate !== state) {
-        continue;
+    if (event.taskId) {
+      const task = this.tasksById.get(event.taskId);
+      if (task) {
+        return task.span;
       }
-      this.compactionsByScope.delete(key);
-      return;
     }
-  }
-  startSyntheticToolState(event, toolName) {
-    const parent = this.parentSpanForEvent(event);
-    const metadata = {
-      ...extractEventMetadata(event),
-      ...event.toolCallId ? { "flue.tool_call_id": event.toolCallId } : {},
-      "flue.tool_name": toolName,
-      provider: "flue"
-    };
-    const span = startFlueSpan(parent, {
-      name: `tool: ${toolName}`,
-      spanAttributes: { type: "tool" /* TOOL */ }
-    });
-    safeLog3(span, { metadata });
-    return { metadata, span, startTime: getCurrentUnixTimestamp() };
-  }
-  operationStateForEvent(event) {
     if (event.operationId) {
-      const operation = this.activeOperationsById.get(event.operationId) ?? this.promotePendingOperationForEvent(event);
+      const operation = this.operationsById.get(event.operationId);
       if (operation) {
-        return operation;
+        return operation.span;
       }
     }
-    return this.activeOperationForEventScope(event) ?? this.pendingOperationForEventScope(event);
+    if (event.runId) {
+      return this.runsById.get(event.runId)?.span;
+    }
+    return void 0;
   }
-  parentSpanForEvent(event) {
+  parentSpanForTool(event) {
+    if (event.taskId) {
+      const task = this.tasksById.get(event.taskId);
+      if (task) {
+        return task.span;
+      }
+    }
     if (event.operationId) {
-      const operation = this.operationStateForEvent(event);
+      const operation = this.operationsById.get(event.operationId);
       if (operation) {
         return operation.span;
       }
     }
-    if (event.taskId) {
-      return this.tasksById.get(event.taskId)?.span;
+    if (event.runId) {
+      return this.runsById.get(event.runId)?.span;
     }
-    return this.operationStateForEvent(event)?.span;
+    return void 0;
   }
-  promotePendingOperationForEvent(event) {
-    if (!event.operationId) {
-      return void 0;
+  logOperationInput(operationId, input) {
+    if (!operationId || input === void 0) {
+      return;
+    }
+    const operation = this.operationsById.get(operationId);
+    if (!operation || operation.loggedInput) {
+      return;
+    }
+    safeLog3(operation.span, { input });
+    operation.loggedInput = true;
+  }
+  startSyntheticOperation(event) {
+    const metadata = {
+      ...extractEventMetadata(event),
+      "flue.operation": event.operationKind,
+      provider: "flue"
+    };
+    const span = startFlueSpan(this.parentSpanForEvent(event), {
+      name: `flue.${event.operationKind}`,
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.timestamp),
+      event: { metadata }
+    });
+    return { metadata, span };
+  }
+  startSyntheticTurn(event) {
+    const metadata = {
+      ...extractEventMetadata(event),
+      ...event.api ? { "flue.api": event.api } : {},
+      ...event.model ? { model: event.model, "flue.model": event.model } : {},
+      ...event.provider ? { provider: event.provider } : { provider: "flue" },
+      ...event.provider ? { "flue.provider": event.provider } : {},
+      ...event.purpose ? { "flue.turn_purpose": event.purpose } : {}
+    };
+    const span = startFlueSpan(this.parentSpanForEvent(event), {
+      name: `llm:${event.model ?? event.purpose ?? "unknown"}`,
+      spanAttributes: { type: "llm" /* LLM */ },
+      startTime: eventTime(event.timestamp),
+      event: { metadata }
+    });
+    return { metadata, span };
+  }
+  startSyntheticTool(event) {
+    const metadata = {
+      ...extractEventMetadata(event),
+      ...event.toolName ? { "flue.tool_name": event.toolName } : {},
+      "flue.tool_call_id": event.toolCallId,
+      provider: "flue"
+    };
+    const span = startFlueSpan(this.parentSpanForTool(event), {
+      name: `tool:${event.toolName ?? "unknown"}`,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      startTime: eventTime(event.timestamp),
+      event: { metadata }
+    });
+    return { metadata, span };
+  }
+  startSyntheticCompaction(event) {
+    const metadata = {
+      ...extractEventMetadata(event),
+      provider: "flue"
+    };
+    const span = startFlueSpan(this.parentSpanForEvent(event), {
+      name: "compaction:unknown",
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.timestamp),
+      event: { metadata }
+    });
+    return { metadata, span };
+  }
+  finishPendingChildrenForOperation(event, operationOutput2) {
+    const endTime = eventTime(event.timestamp);
+    const usage = event.usage ?? usageFromOperationResult(event.result);
+    const turnEntries = [...this.turnsByKey].filter(
+      ([, state]) => stateMatchesOperation(state, event.operationId)
+    );
+    turnEntries.forEach(([key, state], index) => {
+      const shouldLogOperationOutput = (event.operationKind === "prompt" || event.operationKind === "skill") && index === turnEntries.length - 1 && operationOutput2 !== void 0;
+      safeLog3(state.span, {
+        metadata: state.metadata,
+        metrics: metricsFromUsage(usage),
+        ...shouldLogOperationOutput ? { output: operationOutput2 } : {}
+      });
+      safeEnd(state.span, endTime);
+      this.turnsByKey.delete(key);
+    });
+    for (const [key, state] of this.toolsByKey) {
+      if (!stateMatchesOperation(state, event.operationId)) {
+        continue;
+      }
+      safeEnd(state.span, endTime);
+      this.toolsByKey.delete(key);
     }
-    const scopePrefixes = operationScopePrefixes(event);
-    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
-      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+    for (const [key, state] of this.tasksById) {
+      if (!stateMatchesOperation(state, event.operationId)) {
         continue;
       }
-      const state = candidateQueue.shift();
-      if (!state) {
-        return void 0;
+      safeEnd(state.span, endTime);
+      this.tasksById.delete(key);
+    }
+    for (const [key, state] of this.compactionsByKey) {
+      if (!stateMatchesOperation(state, event.operationId)) {
+        continue;
       }
-      state.operationId = event.operationId;
-      this.activeOperationsById.set(event.operationId, state);
-      addScopedOperation(this.activeOperationsByScope, event, state);
-      state.metadata = {
-        ...state.metadata,
-        ...extractEventMetadata(event),
-        "flue.operation_id": event.operationId
-      };
-      safeLog3(state.span, { metadata: state.metadata });
-      return state;
+      safeLog3(state.span, {
+        metadata: state.metadata,
+        metrics: durationMetrics2(event.durationMs),
+        output: { completed: true }
+      });
+      safeEnd(state.span, eventTime(event.timestamp));
+      this.compactionsByKey.delete(key);
     }
-    return void 0;
   }
-  activeOperationForEventScope(event) {
-    for (const scope of operationScopeNames(event)) {
-      const operations = this.activeOperationsByScope.get(scope);
-      if (operations?.length) {
-        return operations[operations.length - 1];
+  finishPendingSpansForRun(event) {
+    const endTime = eventTime(event.timestamp);
+    for (const [key, state] of this.toolsByKey) {
+      if (!stateMatchesRun(state, event.runId)) {
+        continue;
       }
+      safeEnd(state.span, endTime);
+      this.toolsByKey.delete(key);
     }
-    return void 0;
-  }
-  pendingOperationForEventScope(event) {
-    const scopePrefixes = operationScopePrefixes(event);
-    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
-      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+    for (const [key, state] of this.turnsByKey) {
+      if (!stateMatchesRun(state, event.runId)) {
         continue;
       }
-      return candidateQueue[0];
+      safeEnd(state.span, endTime);
+      this.turnsByKey.delete(key);
     }
-    return void 0;
-  }
-  takePendingOperationForEvent(event) {
-    const key = operationKey(event.session, event.operationKind);
-    const queue2 = this.pendingOperationsByKey.get(key);
-    if (queue2?.length) {
-      return queue2.shift();
+    for (const [key, state] of this.tasksById) {
+      if (!stateMatchesRun(state, event.runId)) {
+        continue;
+      }
+      safeEnd(state.span, endTime);
+      this.tasksById.delete(key);
     }
-    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
-      if (candidateKey.endsWith(`::${event.operationKind}`) && candidateQueue.length) {
-        return candidateQueue.shift();
+    for (const [key, state] of this.compactionsByKey) {
+      if (!stateMatchesRun(state, event.runId)) {
+        continue;
       }
+      safeLog3(state.span, {
+        metadata: state.metadata,
+        output: { completed: true }
+      });
+      safeEnd(state.span, endTime);
+      this.compactionsByKey.delete(key);
     }
-    return void 0;
-  }
-  pendingOperationQueue(key) {
-    const existing = this.pendingOperationsByKey.get(key);
-    if (existing) {
-      return existing;
+    for (const [key, state] of this.operationsById) {
+      if (!stateMatchesRun(state, event.runId)) {
+        continue;
+      }
+      safeLog3(state.span, {
+        metadata: state.metadata,
+        ...state.metadata["flue.operation"] === "compact" ? { output: { completed: true } } : {}
+      });
+      safeEnd(state.span, endTime);
+      this.operationsById.delete(key);
     }
-    const queue2 = [];
-    this.pendingOperationsByKey.set(key, queue2);
-    return queue2;
   }
 };
 function isInstrumentedOperation(operation) {
-  return operation === "prompt" || operation === "skill" || operation === "task" || operation === "compact";
-}
-function getSessionName(session) {
-  return typeof session?.name === "string" ? session.name : void 0;
-}
-function operationKey(sessionName, operation) {
-  return `${sessionName ?? "unknown"}::${operation}`;
-}
-function operationScopePrefixes(event) {
-  const scopes = /* @__PURE__ */ new Set();
-  for (const scope of operationScopeNames(event)) {
-    scopes.add(`${scope}::`);
-  }
-  return scopes;
-}
-function operationKeyMatchesScopes(key, scopes) {
-  for (const scope of scopes) {
-    if (key.startsWith(scope)) {
-      return true;
-    }
-  }
-  return false;
-}
-function operationScopeNames(event) {
-  const scopes = /* @__PURE__ */ new Set();
-  if (event.session) {
-    scopes.add(event.session);
-  }
-  if (event.parentSession) {
-    scopes.add(event.parentSession);
-  }
-  if (!scopes.size) {
-    scopes.add("unknown");
-  }
-  return scopes;
-}
-function addScopedOperation(operationsByScope, event, state) {
-  for (const scope of operationScopeNames(event)) {
-    addOperationToScope(operationsByScope, scope, state);
-  }
-}
-function addOperationToScope(operationsByScope, scope, state) {
-  const operations = operationsByScope.get(scope);
-  if (operations) {
-    if (!operations.includes(state)) {
-      operations.push(state);
-    }
-  } else {
-    operationsByScope.set(scope, [state]);
-  }
-}
-function removeScopedOperation(operationsByScope, state) {
-  for (const [scope, operations] of operationsByScope) {
-    const index = operations.indexOf(state);
-    if (index === -1) {
-      continue;
-    }
-    operations.splice(index, 1);
-    if (operations.length === 0) {
-      operationsByScope.delete(scope);
-    }
-  }
-}
-function removePendingOperation(pendingOperationsByKey, state) {
-  for (const [key, queue2] of pendingOperationsByKey) {
-    const index = queue2.indexOf(state);
-    if (index === -1) {
-      continue;
-    }
-    queue2.splice(index, 1);
-    if (queue2.length === 0) {
-      pendingOperationsByKey.delete(key);
-    }
-    return;
-  }
+  return operation === "prompt" || operation === "skill" || operation === "compact";
 }
-function extractSessionMetadata(session) {
-  const sessionName = getSessionName(session);
-  return sessionName ? { "flue.session": sessionName } : {};
-}
-function extractEventMetadata(event) {
+function extractEventMetadata(event, ctx) {
   return {
     ...event.runId ? { "flue.run_id": event.runId } : {},
+    ...event.instanceId ? { "flue.instance_id": event.instanceId } : {},
+    ...event.dispatchId ? { "flue.dispatch_id": event.dispatchId } : {},
     ...typeof event.eventIndex === "number" ? { "flue.event_index": event.eventIndex } : {},
     ...event.session ? { "flue.session": event.session } : {},
     ...event.parentSession ? { "flue.parent_session": event.parentSession } : {},
     ...event.harness ? { "flue.harness": event.harness } : {},
     ...event.taskId ? { "flue.task_id": event.taskId } : {},
-    ...event.operationId ? { "flue.operation_id": event.operationId } : {}
+    ...event.operationId ? { "flue.operation_id": event.operationId } : {},
+    ...event.turnId ? { "flue.turn_id": event.turnId } : {},
+    ...typeof ctx?.id === "string" ? { "flue.context_id": ctx.id } : {},
+    ...typeof ctx?.runId === "string" ? { "flue.context_run_id": ctx.runId } : {}
   };
 }
-function extractOperationInput(operation, args) {
-  switch (operation) {
-    case "prompt":
-    case "task":
-      return args[0];
-    case "skill":
-      return {
-        args: getOptionObject(args[1])?.args,
-        name: args[0]
-      };
-    case "compact":
-      return void 0;
+function extractPayloadMetadata(payload) {
+  if (!isObjectLike(payload)) {
+    return {};
   }
+  const metadata = Reflect.get(payload, "metadata");
+  if (!isObjectLike(metadata)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(metadata));
 }
-function extractOperationInputMetadata(operation, args) {
-  const options = getOptionObject(args[1]);
-  return {
-    ...operation === "skill" && typeof args[0] === "string" ? { "flue.skill_name": args[0] } : {},
-    ...options?.model ? { model: options.model, "flue.model": options.model } : {},
-    ...options?.role ? { "flue.role": options.role } : {},
-    ...options?.thinkingLevel ? { "flue.thinking_level": options.thinkingLevel } : {},
-    ...typeof options?.cwd === "string" ? { "flue.cwd": options.cwd } : {},
-    ...Array.isArray(options?.tools) ? {
-      "flue.tools_count": options.tools.length,
-      tools: summarizeTools(options.tools)
-    } : {},
-    ...Array.isArray(options?.images) ? { "flue.images_count": options.images.length } : {},
-    ...options?.result || options?.schema ? { "flue.result_schema": true } : {}
-  };
-}
-function getOptionObject(value) {
-  return isObject(value) ? value : void 0;
-}
-function summarizeTools(tools) {
-  return tools.flatMap((tool) => {
-    if (!isObject(tool)) {
-      return [];
-    }
-    const name = typeof tool.name === "string" ? tool.name : void 0;
-    if (!name) {
-      return [];
-    }
-    return [
-      {
-        function: {
-          description: typeof tool.description === "string" ? tool.description : void 0,
-          name,
-          parameters: tool.parameters
-        },
-        type: "function"
-      }
-    ];
-  });
+function operationOutput(event) {
+  if (event.operationKind === "prompt" || event.operationKind === "skill") {
+    return llmResultFromOperationResult(event.result);
+  }
+  return event.result ?? (event.operationKind === "compact" ? { completed: true } : void 0);
 }
-function extractPromptResponseMetadata(result) {
-  const modelId = result?.model && typeof result.model.id === "string" ? result.model.id : void 0;
-  return modelId ? {
-    model: modelId,
-    "flue.model": modelId
-  } : {};
+function llmResultFromOperationResult(result) {
+  if (!isObjectLike(result)) {
+    return result;
+  }
+  const text = Reflect.get(result, "text");
+  return text === void 0 ? result : text;
 }
-function extractOperationOutput(result) {
-  if (!result) {
+function usageFromOperationResult(result) {
+  if (!isObjectLike(result)) {
     return void 0;
   }
-  if ("data" in result) {
-    return result.data;
-  }
-  if ("text" in result) {
-    return result.text;
-  }
-  return result;
+  return Reflect.get(result, "usage");
 }
 function metricsFromUsage(usage) {
+  if (!isObjectLike(usage)) {
+    return {};
+  }
+  const cacheRead = Reflect.get(usage, "cacheRead");
+  const cacheWrite = Reflect.get(usage, "cacheWrite");
+  const cost = Reflect.get(usage, "cost");
+  const input = Reflect.get(usage, "input");
+  const output = Reflect.get(usage, "output");
+  const totalTokens = Reflect.get(usage, "totalTokens");
+  const totalCost = isObjectLike(cost) ? Reflect.get(cost, "total") : void 0;
   return {
-    ...typeof usage?.input === "number" ? { prompt_tokens: usage.input } : {},
-    ...typeof usage?.output === "number" ? { completion_tokens: usage.output } : {},
-    ...typeof usage?.cacheRead === "number" ? { prompt_cached_tokens: usage.cacheRead } : {},
-    ...typeof usage?.cacheWrite === "number" ? { prompt_cache_creation_tokens: usage.cacheWrite } : {},
-    ...typeof usage?.totalTokens === "number" ? { tokens: usage.totalTokens } : {},
-    ...typeof usage?.cost?.total === "number" ? { estimated_cost: usage.cost.total } : {}
-  };
-}
-function buildDurationMetrics3(startTime) {
-  return {
-    duration_ms: Math.max(0, (getCurrentUnixTimestamp() - startTime) * 1e3)
+    ...typeof input === "number" ? { prompt_tokens: input } : {},
+    ...typeof output === "number" ? { completion_tokens: output } : {},
+    ...typeof cacheRead === "number" ? { prompt_cached_tokens: cacheRead } : {},
+    ...typeof cacheWrite === "number" ? { prompt_cache_creation_tokens: cacheWrite } : {},
+    ...typeof totalTokens === "number" ? { tokens: totalTokens } : {},
+    ...typeof totalCost === "number" ? { estimated_cost: totalCost } : {}
   };
 }
-function durationMsMetrics(durationMs) {
+function durationMetrics2(durationMs) {
   return typeof durationMs === "number" ? { duration_ms: durationMs } : {};
 }
-function scopeKey(event) {
-  if (event.operationId) {
-    return `operation:${event.operationId}`;
-  }
-  if (event.taskId) {
-    return `task:${event.taskId}`;
-  }
-  if (event.session) {
-    return `session:${event.session}`;
+function eventTime(value) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  return "flue:unknown";
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp / 1e3 : void 0;
+}
+function turnKey(event) {
+  return event.turnId;
 }
 function toolKey(event) {
-  return `${scopeKey(event)}::tool:${event.toolCallId ?? "unknown"}`;
+  return `${event.turnId ?? event.operationId ?? event.taskId ?? event.runId ?? "unknown"}:${event.toolCallId ?? "unknown"}`;
 }
-function toAssistantOutput(text, finishReason, reasoning, toolCalls) {
+function compactionKey(event) {
   return [
-    {
-      finish_reason: finishReason ?? "stop",
-      index: 0,
-      message: {
-        content: text,
-        ...reasoning ? { reasoning } : {},
-        role: "assistant",
-        ...toolCalls?.length ? {
-          tool_calls: toolCalls.map((toolCall) => ({
-            function: {
-              arguments: toolCall.args === void 0 ? "{}" : JSON.stringify(toolCall.args),
-              name: toolCall.toolName ?? "unknown"
-            },
-            ...toolCall.toolCallId ? { id: toolCall.toolCallId } : {},
-            type: "function"
-          }))
-        } : {}
-      }
-    }
-  ];
+    event.instanceId ?? "",
+    event.runId ?? "",
+    event.session ?? "",
+    event.operationId ?? "",
+    event.taskId ?? ""
+  ].join(":");
+}
+function stateMatchesOperation(state, operationId) {
+  return state.metadata["flue.operation_id"] === operationId;
+}
+function stateMatchesRun(state, runId) {
+  return state.metadata["flue.run_id"] === runId;
 }
 function startFlueSpan(parent, args) {
   return parent ? withCurrent(parent, () => startSpan(args)) : startSpan(args);
@@ -24594,6 +24252,13 @@ function safeLog3(span, event) {
     logInstrumentationError3("Flue span log", error);
   }
 }
+function safeEnd(span, endTime) {
+  try {
+    span.end(endTime === void 0 ? void 0 : { endTime });
+  } catch (error) {
+    logInstrumentationError3("Flue span end", error);
+  }
+}
 function errorToString(error) {
   if (error instanceof Error) {
     return error.message;
@@ -25087,7 +24752,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();
@@ -25152,7 +24817,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();
     }
@@ -25265,6 +24930,7 @@ var envIntegrationAliases = {
   cursorsdk: "cursorSDK",
   flue: "flue",
   "flue-runtime": "flue",
+  mastra: "mastra",
   "openai-agents": "openAIAgents",
   openaiagents: "openAIAgents",
   "openai-agents-core": "openAIAgents",
@@ -25307,6 +24973,7 @@ function getDefaultInstrumentationIntegrations() {
     cursor: true,
     cursorSDK: true,
     flue: true,
+    mastra: true,
     openAIAgents: true,
     openrouter: true,
     openrouterAgent: true,
@@ -25331,6 +24998,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");
@@ -25424,6 +25094,263 @@ 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() {
@@ -25509,6 +25436,12 @@ function configureNode() {
   isomorph_default.gunzip = 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();
 }