braintrust 3.14.0 → 3.16.0

package/dev/dist/index.js

@@ -4021,7 +4021,7 @@ function btStreamParser() {
     },
     async transform(chunk, controller) {
       if (chunk instanceof Uint8Array) {
-        parser.feed(decoder.decode(chunk));
+        parser.feed(decoder.decode(chunk, { stream: true }));
       } else if (typeof chunk === "string") {
         parser.feed(chunk);
       } else {
@@ -4029,6 +4029,10 @@ function btStreamParser() {
       }
     },
     async flush(controller) {
+      const tail = decoder.decode();
+      if (tail) {
+        parser.feed(tail);
+      }
       controller.terminate();
     }
   });
@@ -23430,803 +23434,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 (e50) {
-  }
-  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 = _nullishCoalesce(options.captureTurnSpans, () => ( true));
-  const existingSubscription = context[SUBSCRIBED_FLUE_CONTEXT_EVENTS];
-  if (existingSubscription) {
-    if (existingSubscription.captureTurnSpans || !captureTurnSpans) {
-      return void 0;
-    }
-    try {
-      existingSubscription.unsubscribe();
-    } catch (e51) {
+  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 (e52) {
-    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 (e53) {
+  } 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 {
+      _optionalChain([unsubscribe, 'optionalCall', _579 => _579()]);
+    } 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 (e54) {
+    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 !_optionalChain([ctx, 'optionalAccess', _580 => _580.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();
-      _optionalChain([tracingChannel2, 'access', _579 => _579.end, 'optionalAccess', _580 => _580.publish, 'call', _581 => _581(context)]);
-    } catch (error) {
-      context.error = normalizeError3(error);
-      _optionalChain([tracingChannel2, 'access', _582 => _582.error, 'optionalAccess', _583 => _583.publish, 'call', _584 => _584(context)]);
-      _optionalChain([tracingChannel2, 'access', _585 => _585.end, 'optionalAccess', _586 => _586.publish, 'call', _587 => _587(context)]);
-      throw error;
-    }
-    traced2 = Promise.resolve(originalResult).then(
-      (result) => {
-        context.result = result;
-        _optionalChain([tracingChannel2, 'access', _588 => _588.asyncStart, 'optionalAccess', _589 => _589.publish, 'call', _590 => _590(context)]);
-        _optionalChain([tracingChannel2, 'access', _591 => _591.asyncEnd, 'optionalAccess', _592 => _592.publish, 'call', _593 => _593(context)]);
-        return result;
-      },
-      (error) => {
-        context.error = normalizeError3(error);
-        _optionalChain([tracingChannel2, 'access', _594 => _594.error, 'optionalAccess', _595 => _595.publish, 'call', _596 => _596(context)]);
-        _optionalChain([tracingChannel2, 'access', _597 => _597.asyncStart, 'optionalAccess', _598 => _598.publish, 'call', _599 => _599(context)]);
-        _optionalChain([tracingChannel2, 'access', _600 => _600.asyncEnd, 'optionalAccess', _601 => _601.publish, 'call', _602 => _602(context)]);
-        throw error;
-      }
-    );
-  };
-  if (_optionalChain([tracingChannel2, 'access', _603 => _603.start, 'optionalAccess', _604 => _604.runStores])) {
-    tracingChannel2.start.runStores(context, run);
-  } else {
-    _optionalChain([tracingChannel2, 'access', _605 => _605.start, 'optionalAccess', _606 => _606.publish, 'call', _607 => _607(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 = (_class22 = class extends BasePlugin {constructor(...args6) { super(...args6); _class22.prototype.__init71.call(this);_class22.prototype.__init72.call(this);_class22.prototype.__init73.call(this);_class22.prototype.__init74.call(this);_class22.prototype.__init75.call(this);_class22.prototype.__init76.call(this);_class22.prototype.__init77.call(this); }
-  __init71() {this.activeOperationsById = /* @__PURE__ */ new Map()}
-  __init72() {this.activeOperationsByScope = /* @__PURE__ */ new Map()}
-  __init73() {this.compactionsByScope = /* @__PURE__ */ new Map()}
-  __init74() {this.pendingOperationsByKey = /* @__PURE__ */ new Map()}
+var FlueObserveBridge = (_class22 = class {constructor() { _class22.prototype.__init71.call(this);_class22.prototype.__init72.call(this);_class22.prototype.__init73.call(this);_class22.prototype.__init74.call(this);_class22.prototype.__init75.call(this);_class22.prototype.__init76.call(this);_class22.prototype.__init77.call(this); }
+  __init71() {this.compactionsByKey = /* @__PURE__ */ new Map()}
+  __init72() {this.operationsById = /* @__PURE__ */ new Map()}
+  __init73() {this.runsById = /* @__PURE__ */ new Map()}
+  __init74() {this.seenEvents = /* @__PURE__ */ new WeakSet()}
   __init75() {this.tasksById = /* @__PURE__ */ new Map()}
-  __init76() {this.toolsById = /* @__PURE__ */ new Map()}
-  __init77() {this.turnsByScope = /* @__PURE__ */ new Map()}
-  onEnable() {
-    this.subscribeToContextCreation();
-    this.subscribeToSessionCreation();
-    this.subscribeToContextEvents();
-    this.subscribeToSessionOperations();
-  }
-  onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
+  __init76() {this.toolsByKey = /* @__PURE__ */ new Map()}
+  __init77() {this.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 = _nullishCoalesce(_nullishCoalesce(event.workflowName, () => ( _optionalChain([event, 'access', _581 => _581.owner, 'optionalAccess', _582 => _582.workflowName]))), () => ( (typeof _optionalChain([ctx, 'optionalAccess', _583 => _583.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(_nullishCoalesce(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(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _608 => _608()]);
-      tracingChannel2.unsubscribe(handlers);
+      safeEnd(state.span, eventTime(event.timestamp));
+      this.runsById.delete(event.runId);
+    }
+    void flush().catch((error) => {
+      logInstrumentationError3("Flue flush", error);
     });
   }
-  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;
+  handleOperationStart(event) {
+    if (!event.operationId || !isInstrumentedOperation(event.operationKind)) {
+      return;
+    }
+    const metadata = {
+      ...extractEventMetadata(event),
+      "flue.operation": event.operationKind,
+      provider: "flue"
     };
-    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(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _609 => _609()]);
-      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 = _optionalChain([state, 'optionalAccess', _610 => _610.contextManager]);
-    const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
-    if (!currentSpanStore || !startChannel) {
-      return void 0;
-    }
-    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,
-      _nullishCoalesce(sessionName, () => ( "unknown")),
-      state
-    );
-    return state;
-  }
-  endOperationState(state, result) {
-    if (!state) {
-      return;
-    }
-    const metadata = {
-      ...state.metadata,
-      ...extractPromptResponseMetadata(result)
-    };
-    const metrics = {
-      ...buildDurationMetrics3(state.startTime),
-      ...metricsFromUsage(_optionalChain([result, 'optionalAccess', _611 => _611.usage]))
-    };
-    safeLog3(state.span, {
-      metadata,
-      metrics,
-      output: extractOperationOutput(result)
+    const parent = this.parentSpanForEvent(event);
+    const span = startFlueSpan(parent, {
+      name: `flue.${event.operationKind}`,
+      spanAttributes: { type: "task" /* TASK */ },
+      startTime: eventTime(event.timestamp),
+      event: { metadata }
     });
-    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)) {
-      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,
-      ...extractEventMetadata(event),
-      "flue.operation_id": event.operationId
-    };
-    safeLog3(state.span, { metadata: state.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 = _nullishCoalesce(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 } : {},
+      ..._optionalChain([event, 'access', _584 => _584.input, 'optionalAccess', _585 => _585.systemPrompt]) ? { "flue.system_prompt": event.input.systemPrompt } : {},
+      ..._optionalChain([event, 'access', _586 => _586.input, 'optionalAccess', _587 => _587.tools]) ? { tools: event.input.tools } : {}
     };
+    const parent = this.parentSpanForTurn(event);
     const span = startFlueSpan(parent, {
-      name: "flue.turn",
-      spanAttributes: { type: "llm" /* LLM */ }
+      name: `llm:${_nullishCoalesce(_nullishCoalesce(event.model, () => ( event.purpose)), () => ( "unknown"))}`,
+      spanAttributes: { type: "llm" /* LLM */ },
+      startTime: eventTime(event.timestamp),
+      event: {
+        input: _optionalChain([event, 'access', _588 => _588.input, 'optionalAccess', _589 => _589.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,
+      _nullishCoalesce(_optionalChain([event, 'access', _590 => _590.input, 'optionalAccess', _591 => _591.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 = _nullishCoalesce(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 = _nullishCoalesce(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: ${_nullishCoalesce(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:${_nullishCoalesce(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 = _nullishCoalesce(this.toolsById.get(key), () => ( this.startSyntheticToolState(event, _nullishCoalesce(event.toolName, () => ( "unknown")))));
+    const state = _nullishCoalesce(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);
@@ -24238,426 +23879,372 @@ var FluePlugin = (_class22 = class extends BasePlugin {constructor(...args6) { s
       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 = _nullishCoalesce(_optionalChain([operationState, 'optionalAccess', _612 => _612.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:${_nullishCoalesce(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 = _nullishCoalesce(this.compactionsByScope.get(key), () => ( this.findCompactionState(event)));
-    if (!state) {
-      return;
-    }
+    const key = compactionKey(event);
+    const state = _nullishCoalesce(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 = _nullishCoalesce(this.activeOperationsById.get(event.operationId), () => ( this.promotePendingOperationForEvent(event)));
+      const operation = this.operationsById.get(event.operationId);
       if (operation) {
-        return operation;
+        return operation.span;
       }
     }
-    return _nullishCoalesce(this.activeOperationForEventScope(event), () => ( this.pendingOperationForEventScope(event)));
+    if (event.runId) {
+      return _optionalChain([this, 'access', _592 => _592.runsById, 'access', _593 => _593.get, 'call', _594 => _594(event.runId), 'optionalAccess', _595 => _595.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 _optionalChain([this, 'access', _613 => _613.tasksById, 'access', _614 => _614.get, 'call', _615 => _615(event.taskId), 'optionalAccess', _616 => _616.span]);
+    if (event.runId) {
+      return _optionalChain([this, 'access', _596 => _596.runsById, 'access', _597 => _597.get, 'call', _598 => _598(event.runId), 'optionalAccess', _599 => _599.span]);
     }
-    return _optionalChain([this, 'access', _617 => _617.operationStateForEvent, 'call', _618 => _618(event), 'optionalAccess', _619 => _619.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;
     }
-    const scopePrefixes = operationScopePrefixes(event);
-    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
-      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+    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:${_nullishCoalesce(_nullishCoalesce(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:${_nullishCoalesce(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 = _nullishCoalesce(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;
       }
-      const state = candidateQueue.shift();
-      if (!state) {
-        return void 0;
+      safeEnd(state.span, endTime);
+      this.toolsByKey.delete(key);
+    }
+    for (const [key, state] of this.tasksById) {
+      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;
+      safeEnd(state.span, endTime);
+      this.tasksById.delete(key);
     }
-    return void 0;
-  }
-  activeOperationForEventScope(event) {
-    for (const scope of operationScopeNames(event)) {
-      const operations = this.activeOperationsByScope.get(scope);
-      if (_optionalChain([operations, 'optionalAccess', _620 => _620.length])) {
-        return operations[operations.length - 1];
+    for (const [key, state] of this.compactionsByKey) {
+      if (!stateMatchesOperation(state, event.operationId)) {
+        continue;
       }
+      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;
   }
-  pendingOperationForEventScope(event) {
-    const scopePrefixes = operationScopePrefixes(event);
-    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
-      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+  finishPendingSpansForRun(event) {
+    const endTime = eventTime(event.timestamp);
+    for (const [key, state] of this.toolsByKey) {
+      if (!stateMatchesRun(state, event.runId)) {
         continue;
       }
-      return candidateQueue[0];
+      safeEnd(state.span, endTime);
+      this.toolsByKey.delete(key);
     }
-    return void 0;
-  }
-  takePendingOperationForEvent(event) {
-    const key = operationKey(event.session, event.operationKind);
-    const queue2 = this.pendingOperationsByKey.get(key);
-    if (_optionalChain([queue2, 'optionalAccess', _621 => _621.length])) {
-      return queue2.shift();
+    for (const [key, state] of this.turnsByKey) {
+      if (!stateMatchesRun(state, event.runId)) {
+        continue;
+      }
+      safeEnd(state.span, endTime);
+      this.turnsByKey.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.tasksById) {
+      if (!stateMatchesRun(state, event.runId)) {
+        continue;
       }
+      safeEnd(state.span, endTime);
+      this.tasksById.delete(key);
     }
-    return void 0;
-  }
-  pendingOperationQueue(key) {
-    const existing = this.pendingOperationsByKey.get(key);
-    if (existing) {
-      return existing;
+    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);
+    }
+    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;
   }
 }, _class22);
 function isInstrumentedOperation(operation) {
-  return operation === "prompt" || operation === "skill" || operation === "task" || operation === "compact";
-}
-function getSessionName(session) {
-  return typeof _optionalChain([session, 'optionalAccess', _622 => _622.name]) === "string" ? session.name : void 0;
-}
-function operationKey(sessionName, operation) {
-  return `${_nullishCoalesce(sessionName, () => ( "unknown"))}::${operation}`;
+  return operation === "prompt" || operation === "skill" || operation === "compact";
 }
-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;
-  }
-}
-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 _optionalChain([ctx, 'optionalAccess', _600 => _600.id]) === "string" ? { "flue.context_id": ctx.id } : {},
+    ...typeof _optionalChain([ctx, 'optionalAccess', _601 => _601.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: _optionalChain([getOptionObject, 'call', _623 => _623(args[1]), 'optionalAccess', _624 => _624.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] } : {},
-    ..._optionalChain([options, 'optionalAccess', _625 => _625.model]) ? { model: options.model, "flue.model": options.model } : {},
-    ..._optionalChain([options, 'optionalAccess', _626 => _626.role]) ? { "flue.role": options.role } : {},
-    ..._optionalChain([options, 'optionalAccess', _627 => _627.thinkingLevel]) ? { "flue.thinking_level": options.thinkingLevel } : {},
-    ...typeof _optionalChain([options, 'optionalAccess', _628 => _628.cwd]) === "string" ? { "flue.cwd": options.cwd } : {},
-    ...Array.isArray(_optionalChain([options, 'optionalAccess', _629 => _629.tools])) ? {
-      "flue.tools_count": options.tools.length,
-      tools: summarizeTools(options.tools)
-    } : {},
-    ...Array.isArray(_optionalChain([options, 'optionalAccess', _630 => _630.images])) ? { "flue.images_count": options.images.length } : {},
-    ..._optionalChain([options, 'optionalAccess', _631 => _631.result]) || _optionalChain([options, 'optionalAccess', _632 => _632.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 _nullishCoalesce(event.result, () => ( (event.operationKind === "compact" ? { completed: true } : void 0)));
 }
-function extractPromptResponseMetadata(result) {
-  const modelId = _optionalChain([result, 'optionalAccess', _633 => _633.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 _optionalChain([usage, 'optionalAccess', _634 => _634.input]) === "number" ? { prompt_tokens: usage.input } : {},
-    ...typeof _optionalChain([usage, 'optionalAccess', _635 => _635.output]) === "number" ? { completion_tokens: usage.output } : {},
-    ...typeof _optionalChain([usage, 'optionalAccess', _636 => _636.cacheRead]) === "number" ? { prompt_cached_tokens: usage.cacheRead } : {},
-    ...typeof _optionalChain([usage, 'optionalAccess', _637 => _637.cacheWrite]) === "number" ? { prompt_cache_creation_tokens: usage.cacheWrite } : {},
-    ...typeof _optionalChain([usage, 'optionalAccess', _638 => _638.totalTokens]) === "number" ? { tokens: usage.totalTokens } : {},
-    ...typeof _optionalChain([usage, 'optionalAccess', _639 => _639.cost, 'optionalAccess', _640 => _640.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:${_nullishCoalesce(event.toolCallId, () => ( "unknown"))}`;
+  return `${_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(event.turnId, () => ( event.operationId)), () => ( event.taskId)), () => ( event.runId)), () => ( "unknown"))}:${_nullishCoalesce(event.toolCallId, () => ( "unknown"))}`;
 }
-function toAssistantOutput(text, finishReason, reasoning, toolCalls) {
+function compactionKey(event) {
   return [
-    {
-      finish_reason: _nullishCoalesce(finishReason, () => ( "stop")),
-      index: 0,
-      message: {
-        content: text,
-        ...reasoning ? { reasoning } : {},
-        role: "assistant",
-        ..._optionalChain([toolCalls, 'optionalAccess', _641 => _641.length]) ? {
-          tool_calls: toolCalls.map((toolCall) => ({
-            function: {
-              arguments: toolCall.args === void 0 ? "{}" : JSON.stringify(toolCall.args),
-              name: _nullishCoalesce(toolCall.toolName, () => ( "unknown"))
-            },
-            ...toolCall.toolCallId ? { id: toolCall.toolCallId } : {},
-            type: "function"
-          }))
-        } : {}
-      }
-    }
-  ];
+    _nullishCoalesce(event.instanceId, () => ( "")),
+    _nullishCoalesce(event.runId, () => ( "")),
+    _nullishCoalesce(event.session, () => ( "")),
+    _nullishCoalesce(event.operationId, () => ( "")),
+    _nullishCoalesce(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);
@@ -24669,6 +24256,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;
@@ -24678,7 +24272,7 @@ function errorToString(error) {
   }
   try {
     return JSON.stringify(error);
-  } catch (e55) {
+  } catch (e50) {
     return String(error);
   }
 }
@@ -24699,11 +24293,11 @@ var BraintrustLangChainCallbackHandler = (_class23 = class {
   __init82() {this.firstTokenTimes = /* @__PURE__ */ new Map()}
   __init83() {this.ttftMs = /* @__PURE__ */ new Map()}
   constructor(options) {;_class23.prototype.__init78.call(this);_class23.prototype.__init79.call(this);_class23.prototype.__init80.call(this);_class23.prototype.__init81.call(this);_class23.prototype.__init82.call(this);_class23.prototype.__init83.call(this);
-    this.parent = _optionalChain([options, 'optionalAccess', _642 => _642.parent]);
+    this.parent = _optionalChain([options, 'optionalAccess', _602 => _602.parent]);
     this.options = {
-      debug: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _643 => _643.debug]), () => ( false)),
-      excludeMetadataProps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _644 => _644.excludeMetadataProps]), () => ( /^(l[sc]_|langgraph_|__pregel_|checkpoint_ns)/)),
-      logger: _optionalChain([options, 'optionalAccess', _645 => _645.logger])
+      debug: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _603 => _603.debug]), () => ( false)),
+      excludeMetadataProps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _604 => _604.excludeMetadataProps]), () => ( /^(l[sc]_|langgraph_|__pregel_|checkpoint_ns)/)),
+      logger: _optionalChain([options, 'optionalAccess', _605 => _605.logger])
     };
   }
   startSpan({
@@ -24717,7 +24311,7 @@ var BraintrustLangChainCallbackHandler = (_class23 = class {
     if (!parentRunId) {
       this.rootRunId = runId;
     }
-    const tags = _optionalChain([args, 'access', _646 => _646.event, 'optionalAccess', _647 => _647.tags]);
+    const tags = _optionalChain([args, 'access', _606 => _606.event, 'optionalAccess', _607 => _607.tags]);
     const spanAttributes = args.spanAttributes || {};
     spanAttributes.type = args.type || spanAttributes.type || "task";
     args.type = spanAttributes.type;
@@ -24737,7 +24331,7 @@ var BraintrustLangChainCallbackHandler = (_class23 = class {
       tags: void 0,
       metadata: {
         ...tags ? { tags } : {},
-        ..._optionalChain([args, 'access', _648 => _648.event, 'optionalAccess', _649 => _649.metadata]),
+        ..._optionalChain([args, 'access', _608 => _608.event, 'optionalAccess', _609 => _609.metadata]),
         braintrust: {
           integration_name: "langchain-js",
           sdk_language: "javascript"
@@ -24839,7 +24433,7 @@ var BraintrustLangChainCallbackHandler = (_class23 = class {
     });
   }
   async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, runName) {
-    if (_optionalChain([tags, 'optionalAccess', _650 => _650.includes, 'call', _651 => _651("langsmith:hidden")])) {
+    if (_optionalChain([tags, 'optionalAccess', _610 => _610.includes, 'call', _611 => _611("langsmith:hidden")])) {
       this.skippedRuns.add(runId);
       return;
     }
@@ -24949,7 +24543,7 @@ function getSerializedName(serialized) {
   if (typeof serialized.name === "string") {
     return serialized.name;
   }
-  const lastIdPart = _optionalChain([serialized, 'access', _652 => _652.id, 'optionalAccess', _653 => _653.at, 'call', _654 => _654(-1)]);
+  const lastIdPart = _optionalChain([serialized, 'access', _612 => _612.id, 'optionalAccess', _613 => _613.at, 'call', _614 => _614(-1)]);
   return typeof lastIdPart === "string" ? lastIdPart : void 0;
 }
 function cleanObject(obj) {
@@ -25027,7 +24621,7 @@ function getMetricsFromResponse(response) {
 function safeJsonParse(input) {
   try {
     return JSON.parse(input);
-  } catch (e56) {
+  } catch (e51) {
     return input;
   }
 }
@@ -25048,7 +24642,7 @@ var langChainChannels = defineChannels("@langchain/core", {
 });
 
 // src/instrumentation/plugins/langchain-plugin.ts
-var LangChainPlugin = (_class24 = class extends BasePlugin {constructor(...args7) { super(...args7); _class24.prototype.__init84.call(this); }
+var LangChainPlugin = (_class24 = class extends BasePlugin {constructor(...args6) { super(...args6); _class24.prototype.__init84.call(this); }
   __init84() {this.injectedManagers = /* @__PURE__ */ new WeakSet()}
   onEnable() {
     this.subscribeToConfigure(langChainChannels.configure);
@@ -25086,7 +24680,7 @@ var LangChainPlugin = (_class24 = class extends BasePlugin {constructor(...args7
     try {
       result.addHandler(new BraintrustLangChainCallbackHandler(), true);
       this.injectedManagers.add(result);
-    } catch (e57) {
+    } catch (e52) {
     }
   }
 }, _class24);
@@ -25098,7 +24692,7 @@ function isCallbackManager(value) {
   return typeof maybeManager.addHandler === "function";
 }
 function hasBraintrustHandler(manager) {
-  return _nullishCoalesce(_optionalChain([manager, 'access', _655 => _655.handlers, 'optionalAccess', _656 => _656.some, 'call', _657 => _657((handler) => {
+  return _nullishCoalesce(_optionalChain([manager, 'access', _615 => _615.handlers, 'optionalAccess', _616 => _616.some, 'call', _617 => _617((handler) => {
     if (typeof handler !== "object" || handler === null) {
       return false;
     }
@@ -25409,7 +25003,7 @@ function readDisabledInstrumentationEnvConfig(disabledList) {
   return { integrations };
 }
 function isInstrumentationIntegrationDisabled(integrations, ...names) {
-  return names.some((name) => _optionalChain([integrations, 'optionalAccess', _658 => _658[name]]) === false);
+  return names.some((name) => _optionalChain([integrations, 'optionalAccess', _618 => _618[name]]) === false);
 }
 
 // src/instrumentation/registry.ts
@@ -25769,11 +25363,11 @@ function configureNode() {
   isomorph_default.getPastNAncestors = getPastNAncestors;
   isomorph_default.getEnv = (name) => {
     const value = process.env[name];
-    return name === "BRAINTRUST_API_KEY" && !_optionalChain([value, 'optionalAccess', _659 => _659.trim, 'call', _660 => _660()]) ? void 0 : value;
+    return name === "BRAINTRUST_API_KEY" && !_optionalChain([value, 'optionalAccess', _619 => _619.trim, 'call', _620 => _620()]) ? void 0 : value;
   };
   isomorph_default.getBraintrustApiKey = async () => {
     const value = process.env.BRAINTRUST_API_KEY;
-    if (_optionalChain([value, 'optionalAccess', _661 => _661.trim, 'call', _662 => _662()])) {
+    if (_optionalChain([value, 'optionalAccess', _621 => _621.trim, 'call', _622 => _622()])) {
       return value;
     }
     const envPaths = [];
@@ -25804,7 +25398,7 @@ function configureNode() {
         if ("contents" in nearestResult) {
           const parsed = dotenv.parse(nearestResult.contents);
           const apiKey = parsed.BRAINTRUST_API_KEY;
-          return _optionalChain([apiKey, 'optionalAccess', _663 => _663.trim, 'call', _664 => _664()]) ? apiKey : void 0;
+          return _optionalChain([apiKey, 'optionalAccess', _623 => _623.trim, 'call', _624 => _624()]) ? apiKey : void 0;
         }
         const e = nearestResult.error;
         if (typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT") {
@@ -26913,6 +26507,7 @@ async function invoke(args) {
     mode,
     schema,
     strict,
+    overrides,
     projectId,
     ...functionIdArgs
   } = args;
@@ -26949,7 +26544,8 @@ async function invoke(args) {
     tags,
     stream,
     mode,
-    strict
+    strict,
+    overrides
   };
   const headers = {
     Accept: stream ? "text/event-stream" : "application/json"
@@ -27101,7 +26697,7 @@ var CachedSpanFetcher = (_class28 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType, false);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _665 => _665.span_attributes, 'optionalAccess', _666 => _666.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _625 => _625.span_attributes, 'optionalAccess', _626 => _626.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -27184,11 +26780,11 @@ var LocalTrace = (_class29 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = includeScorers ? cachedSpans : cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _667 => _667.span_attributes, 'optionalAccess', _668 => _668.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _627 => _627.span_attributes, 'optionalAccess', _628 => _628.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _669 => _669.span_attributes, 'optionalAccess', _670 => _670.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _629 => _629.span_attributes, 'optionalAccess', _630 => _630.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -27213,7 +26809,7 @@ var LocalTrace = (_class29 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _671 => _671.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _631 => _631.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -27224,7 +26820,7 @@ var LocalTrace = (_class29 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _672 => _672.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _632 => _632.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -27400,10 +26996,10 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
-    const errorMessages = _optionalChain([validate, 'access', _673 => _673.errors, 'optionalAccess', _674 => _674.map, 'call', _675 => _675((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _633 => _633.errors, 'optionalAccess', _634 => _634.map, 'call', _635 => _635((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _676 => _676.join, 'call', _677 => _677(", ")]);
+    }), 'access', _636 => _636.join, 'call', _637 => _637(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return rehydrateRemoteParameters(parameters, schema);
@@ -27743,7 +27339,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters, st
 }
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _678 => _678.spanCache, 'optionalAccess', _679 => _679.start, 'call', _680 => _680()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _638 => _638.spanCache, 'optionalAccess', _639 => _639.start, 'call', _640 => _640()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -27798,7 +27394,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e58) {
+      } catch (e53) {
         return void 0;
       }
     })() : void 0;
@@ -27854,7 +27450,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _681 => _681.data, 'access', async _682 => _682.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _641 => _641.data, 'access', async _642 => _642.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -27884,10 +27480,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _683 => _683({
+                    _optionalChain([stream, 'optionalCall', _643 => _643({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _684 => _684.event, 'optionalAccess', _685 => _685.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _644 => _644.event, 'optionalAccess', _645 => _645.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -28075,7 +27671,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               tags: tags.length ? tags : void 0,
               metadata,
               error,
-              origin: _optionalChain([baseEvent, 'access', _686 => _686.event, 'optionalAccess', _687 => _687.origin])
+              origin: _optionalChain([baseEvent, 'access', _646 => _646.event, 'optionalAccess', _647 => _647.origin])
             };
             collectedResults.push({
               ...baseResult,
@@ -28115,7 +27711,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _688 => _688.setTotal, 'optionalCall', _689 => _689(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _648 => _648.setTotal, 'optionalCall', _649 => _649(evaluator.evalName, scheduledTrials)]);
           q.pushAsync({ datum, trialIndex }).catch((e) => {
             if (queueErrors.length < 5) {
               queueErrors.push(e);
@@ -28200,9 +27796,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _690 => _690.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _691 => _691.dispose, 'call', _692 => _692()]);
-      _optionalChain([spanCache, 'optionalAccess', _693 => _693.stop, 'call', _694 => _694()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _650 => _650.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _651 => _651.dispose, 'call', _652 => _652()]);
+      _optionalChain([spanCache, 'optionalAccess', _653 => _653.stop, 'call', _654 => _654()]);
     }
   }
 }
@@ -28442,7 +28038,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _695 => _695.ctx, 'optionalAccess', _696 => _696.token])) {
+    if (!_optionalChain([req, 'access', _655 => _655.ctx, 'optionalAccess', _656 => _656.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -28455,7 +28051,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage2));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _697 => _697.ctx, 'optionalAccess', _698 => _698.token]),
+        apiKey: _optionalChain([req, 'access', _657 => _657.ctx, 'optionalAccess', _658 => _658.token]),
         orgName
       });
       req.ctx.state = state;
@@ -29210,7 +28806,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _699 => _699.ctx, 'optionalAccess', _700 => _700.state])) {
+      if (!_optionalChain([req, 'access', _659 => _659.ctx, 'optionalAccess', _660 => _660.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -29261,12 +28857,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: (_nullishCoalesce(evaluator.scores, () => ( []))).concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _701 => _701.map, 'call', _702 => _702(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _661 => _661.map, 'call', _662 => _662(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _703 => _703.ctx, 'optionalAccess', _704 => _704.projectId])
+                  _optionalChain([req, 'access', _663 => _663.ctx, 'optionalAccess', _664 => _664.projectId])
                 )
               )]), () => ( []))
             ),