braintrust 3.14.0 → 3.16.0

package/dist/edge-light.js

@@ -60,6 +60,7 @@ __export(edge_light_exports, {
   LEGACY_CACHED_HEADER: () => LEGACY_CACHED_HEADER,
   LOGS3_OVERFLOW_REFERENCE_TYPE: () => LOGS3_OVERFLOW_REFERENCE_TYPE,
   LazyValue: () => LazyValue,
+  LocalTrace: () => LocalTrace,
   Logger: () => Logger,
   LoginInvalidOrgError: () => LoginInvalidOrgError,
   NOOP_SPAN: () => NOOP_SPAN,
@@ -85,6 +86,7 @@ __export(edge_light_exports, {
   _internalIso: () => isomorph_default,
   _internalSetInitialState: () => _internalSetInitialState,
   addAzureBlobHeaders: () => addAzureBlobHeaders,
+  braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
   configureInstrumentation: () => configureInstrumentation,
@@ -165,8 +167,6 @@ __export(edge_light_exports, {
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
-  wrapFlueContext: () => wrapFlueContext,
-  wrapFlueSession: () => wrapFlueSession,
   wrapGenkit: () => wrapGenkit,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
@@ -3880,7 +3880,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 {
@@ -3888,6 +3888,10 @@ function btStreamParser() {
       }
     },
     async flush(controller) {
+      const tail = decoder.decode();
+      if (tail) {
+        parser.feed(tail);
+      }
       controller.terminate();
     }
   });
@@ -24217,825 +24221,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 wrapFlueContext(ctx) {
-  if (!isPlausibleFlueContext(ctx)) {
-    console.warn("Unsupported Flue context. Not wrapping.");
-    return ctx;
+// 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;
-  subscribeFlueContextEvents(context, { captureTurnSpans: true });
-  return patchFlueContextInPlace(context);
-}
-function patchFlueContextInPlace(ctx) {
-  const context = ctx;
-  if (context[WRAPPED_FLUE_CONTEXT]) {
-    return ctx;
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
   }
-  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 {
+};
+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;
   }
-  return ctx;
+  let released = false;
+  return () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    releaseAutoState(state);
+  };
 }
-function wrapFlueSession(session) {
-  if (!isPlausibleFlueSession(session)) {
-    console.warn("Unsupported Flue session. Not wrapping.");
-    return session;
+function getAutoState() {
+  const existing = Reflect.get(globalThis, FLUE_AUTO_STATE);
+  if (isAutoState(existing)) {
+    return existing;
   }
-  return patchFlueSessionInPlace(session);
+  const state = {
+    contexts: /* @__PURE__ */ new WeakSet(),
+    refCount: 0
+  };
+  Reflect.set(globalThis, FLUE_AUTO_STATE, state);
+  return state;
 }
-function subscribeFlueContextEvents(ctx, options = {}) {
-  if (!ctx || typeof ctx !== "object" || typeof ctx.subscribeEvent !== "function") {
-    return void 0;
-  }
-  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 {
-    }
-  }
-  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
-        }
-      });
-    }
-    return unsubscribe;
-  } catch {
-    return void 0;
+function getObserveBridge() {
+  const existing = Reflect.get(globalThis, FLUE_OBSERVE_BRIDGE);
+  if (isFlueObserveBridge(existing)) {
+    return existing;
   }
+  const bridge = new FlueObserveBridge();
+  Reflect.set(globalThis, FLUE_OBSERVE_BRIDGE, bridge);
+  return bridge;
 }
-function wrapFlueHarness(harness) {
-  if (!isPlausibleFlueHarness(harness)) {
-    return harness;
-  }
-  const target = harness;
-  if (target[WRAPPED_FLUE_HARNESS]) {
-    return harness;
-  }
-  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");
-    }
-  } catch {
-  }
-  return harness;
+function isFlueObserveBridge(value) {
+  return isObjectLike(value) && typeof Reflect.get(value, "handle") === "function" && typeof Reflect.get(value, "reset") === "function";
 }
-function patchFlueSessionInPlace(session) {
-  if (session[WRAPPED_FLUE_SESSION]) {
-    return session;
-  }
-  try {
-    Object.defineProperty(session, WRAPPED_FLUE_SESSION, {
-      configurable: false,
-      enumerable: false,
-      value: true
-    });
-    patchCallHandleMethod(session, "prompt", flueChannels.prompt);
-    patchCallHandleMethod(session, "skill", flueChannels.skill);
-    patchCallHandleMethod(session, "task", flueChannels.task);
-    patchCompact(session);
-  } catch {
-  }
-  return session;
+function isAutoState(value) {
+  return isObjectLike(value) && Reflect.get(value, "contexts") instanceof WeakSet && typeof Reflect.get(value, "refCount") === "number";
 }
-function patchFlueSessionFactory(sessions, method) {
-  const original = sessions[method];
-  if (typeof original !== "function") {
+function releaseAutoState(state) {
+  state.refCount -= 1;
+  if (state.refCount > 0) {
     return;
   }
-  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;
+  try {
+    if (state.channel && state.handlers) {
+      state.channel.unsubscribe(state.handlers);
+    }
+  } finally {
+    Reflect.deleteProperty(globalThis, FLUE_AUTO_STATE);
   }
-  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") {
+function subscribeToFlueContext(value, state) {
+  if (!isObservableFlueContext(value) || state.contexts.has(value)) {
     return;
   }
-  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
-  });
-}
-function traceFlueOperation(channel2, args) {
-  const tracingChannel2 = channel2.tracingChannel();
-  const context = args.context;
-  let originalResult;
-  let traced2;
-  const run = () => {
+  const ctx = flueContextFromUnknown(value);
+  let released = false;
+  let unsubscribe;
+  const release = () => {
+    if (released) {
+      return;
+    }
+    released = true;
     try {
-      originalResult = args.run();
-      tracingChannel2.end?.publish(context);
+      unsubscribe?.();
     } catch (error) {
-      context.error = normalizeError3(error);
-      tracingChannel2.error?.publish(context);
-      tracingChannel2.end?.publish(context);
-      throw error;
+      logInstrumentationError3("Flue context unsubscribe", 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();
+  try {
+    unsubscribe = value.subscribeEvent((event) => {
+      if (state.refCount <= 0) {
+        release();
+        return;
+      }
+      braintrustFlueObserver(event, ctx);
+      if (isAutoContextTerminalEvent(event, ctx)) {
+        release();
+      }
+    });
+    state.contexts.add(value);
+  } catch (error) {
+    logInstrumentationError3("Flue context subscription", error);
   }
-  return { originalResult, traced: traced2 };
 }
-function normalizeError3(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function preserveCallHandle(originalHandle, traced2) {
-  if (!isFlueCallHandle(originalHandle)) {
-    return traced2;
+function isAutoContextTerminalEvent(event, ctx) {
+  if (!isObjectLike(event)) {
+    return false;
   }
-  const handle = originalHandle;
-  const wrapped = {
-    get signal() {
-      return handle.signal;
-    },
-    abort(reason) {
-      return handle.abort(reason);
-    },
-    then(onfulfilled, onrejected) {
-      return traced2.then(onfulfilled, onrejected);
-    }
-  };
-  return wrapped;
+  const type = Reflect.get(event, "type");
+  if (type === "run_end") {
+    return true;
+  }
+  if (type !== "operation") {
+    return false;
+  }
+  return !ctx?.runId && typeof Reflect.get(event, "runId") !== "string";
 }
-function isPlausibleFlueContext(value) {
-  return !!value && typeof value === "object" && typeof value.init === "function";
+function isObservableFlueContext(value) {
+  return isObjectLike(value) && typeof Reflect.get(value, "subscribeEvent") === "function";
 }
-function isPlausibleFlueHarness(value) {
-  return !!value && typeof value === "object" && typeof value.session === "function";
+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 isPlausibleFlueSession(value) {
-  return !!value && typeof value === "object" && typeof value.prompt === "function" && typeof value.skill === "function" && typeof value.task === "function" && typeof value.compact === "function";
+function flueContextFromUnknown(ctx) {
+  if (!isObjectLike(ctx)) {
+    return void 0;
+  }
+  const id = Reflect.get(ctx, "id");
+  const runId = Reflect.get(ctx, "runId");
+  return {
+    ...typeof id === "string" ? { id } : {},
+    ...typeof runId === "string" ? { runId } : {}
+  };
 }
-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);
+      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;
-    };
-    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;
-    }
-    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)
-    });
-    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) {
+    if (!event.operationId || !isInstrumentedOperation(event.operationKind)) {
       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);
@@ -25047,426 +24666,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 scopePrefixes = operationScopePrefixes(event);
-    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
-      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+    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;
       }
-      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 (operations?.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 (queue2?.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;
   }
 };
 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;
+  return operation === "prompt" || operation === "skill" || operation === "compact";
 }
-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 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);
@@ -25478,6 +25043,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;
@@ -26387,6 +25959,7 @@ __export(exports_exports, {
   LEGACY_CACHED_HEADER: () => LEGACY_CACHED_HEADER,
   LOGS3_OVERFLOW_REFERENCE_TYPE: () => LOGS3_OVERFLOW_REFERENCE_TYPE,
   LazyValue: () => LazyValue,
+  LocalTrace: () => LocalTrace,
   Logger: () => Logger,
   LoginInvalidOrgError: () => LoginInvalidOrgError,
   NOOP_SPAN: () => NOOP_SPAN,
@@ -26412,6 +25985,7 @@ __export(exports_exports, {
   _internalIso: () => isomorph_default,
   _internalSetInitialState: () => _internalSetInitialState,
   addAzureBlobHeaders: () => addAzureBlobHeaders,
+  braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
   configureInstrumentation: () => configureInstrumentation,
@@ -26491,8 +26065,6 @@ __export(exports_exports, {
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
-  wrapFlueContext: () => wrapFlueContext,
-  wrapFlueSession: () => wrapFlueSession,
   wrapGenkit: () => wrapGenkit,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
@@ -26621,6 +26193,7 @@ async function invoke(args) {
     mode,
     schema,
     strict,
+    overrides,
     projectId,
     ...functionIdArgs
   } = args;
@@ -26657,7 +26230,8 @@ async function invoke(args) {
     tags,
     stream,
     mode,
-    strict
+    strict,
+    overrides
   };
   const headers = {
     Accept: stream ? "text/event-stream" : "application/json"