braintrust 3.11.0 → 3.12.0

package/dist/browser.js

@@ -33,8 +33,10 @@ __export(browser_exports, {
   Attachment: () => Attachment,
   AttachmentReference: () => AttachmentReference,
   BRAINTRUST_CURRENT_SPAN_STORE: () => BRAINTRUST_CURRENT_SPAN_STORE,
+  BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME: () => BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
   BaseAttachment: () => BaseAttachment,
   BaseExperiment: () => BaseExperiment,
+  BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
@@ -161,6 +163,8 @@ __export(browser_exports, {
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
+  wrapFlueContext: () => wrapFlueContext,
+  wrapFlueSession: () => wrapFlueSession,
   wrapGenkit: () => wrapGenkit,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
@@ -1098,6 +1102,11 @@ function isPromiseLike(value) {
 
 // util/object_util.ts
 var SET_UNION_FIELDS = /* @__PURE__ */ new Set(["tags"]);
+var FORBIDDEN_MERGE_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
 function mergeDictsWithPaths({
   mergeInto,
   mergeFrom,
@@ -1120,6 +1129,7 @@ function mergeDictsWithPathsHelper({
   mergePaths
 }) {
   Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
+    if (FORBIDDEN_MERGE_KEYS.has(k)) return;
     const fullPath = path.concat([k]);
     const fullPathSerialized = JSON.stringify(fullPath);
     const mergeIntoV = recordFind(mergeInto, k);
@@ -5191,6 +5201,13 @@ var HTTPConnection = class _HTTPConnection {
           debugLogger.debug(
             `Retrying API request ${object_type} ${JSON.stringify(args)} ${e.status} ${e.text}`
           );
+          const sleepTimeS = HTTP_RETRY_BASE_SLEEP_TIME_S * 2 ** i;
+          debugLogger.info(
+            `Sleeping for ${sleepTimeS}s before retrying API request`
+          );
+          await new Promise(
+            (resolve) => setTimeout(resolve, sleepTimeS * 1e3)
+          );
           continue;
         }
         throw e;
@@ -5840,20 +5857,7 @@ function startSpanParentArgs(args) {
         `Mismatch between expected span parent object type ${args.parentObjectType} and provided type ${parentComponents.data.object_type}`
       );
     }
-    const parentComponentsObjectIdLambda = spanComponentsToObjectIdLambda(
-      args.state,
-      parentComponents
-    );
-    const computeParentObjectId = async () => {
-      const parentComponentsObjectId = await parentComponentsObjectIdLambda();
-      if (await args.parentObjectId.get() !== parentComponentsObjectId) {
-        throw new Error(
-          `Mismatch between expected span parent object id ${await args.parentObjectId.get()} and provided id ${parentComponentsObjectId}`
-        );
-      }
-      return await args.parentObjectId.get();
-    };
-    argParentObjectId = new LazyValue(computeParentObjectId);
+    argParentObjectId = args.parentObjectId;
     if (parentComponents.data.row_id) {
       argParentSpanIds = {
         spanId: parentComponents.data.span_id,
@@ -6239,6 +6243,7 @@ var TestBackgroundLogger = class {
   }
 };
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
+var HTTP_RETRY_BASE_SLEEP_TIME_S = 1;
 var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
   apiConn;
   queue;
@@ -6869,17 +6874,10 @@ function init(projectOrOptions, optionalOptions) {
         if (repoInfo) {
           return repoInfo;
         }
-        let mergedGitMetadataSettings = {
-          ...state.gitMetadataSettings || {
-            collect: "all"
-          }
-        };
-        if (gitMetadataSettings) {
-          mergedGitMetadataSettings = mergeGitMetadataSettings(
-            mergedGitMetadataSettings,
-            gitMetadataSettings
-          );
-        }
+        const mergedGitMetadataSettings = state.gitMetadataSettings == null ? gitMetadataSettings ?? { collect: "none" } : mergeGitMetadataSettings(
+          state.gitMetadataSettings,
+          gitMetadataSettings ?? { collect: "all" }
+        );
         return await isomorph_default.getRepoInfo(mergedGitMetadataSettings);
       })();
       if (repoInfoArg) {
@@ -13575,11 +13573,11 @@ function resolveDenyOutputPaths(event, defaultDenyOutputPaths) {
   if (Array.isArray(event?.denyOutputPaths)) {
     return event.denyOutputPaths;
   }
-  const firstArgument = event?.arguments && event.arguments.length > 0 ? event.arguments[0] : void 0;
-  if (!firstArgument || typeof firstArgument !== "object") {
+  const firstArgument2 = event?.arguments && event.arguments.length > 0 ? event.arguments[0] : void 0;
+  if (!firstArgument2 || typeof firstArgument2 !== "object") {
     return defaultDenyOutputPaths;
   }
-  const runtimeDenyOutputPaths = firstArgument[RUNTIME_DENY_OUTPUT_PATHS];
+  const runtimeDenyOutputPaths = firstArgument2[RUNTIME_DENY_OUTPUT_PATHS];
   if (Array.isArray(runtimeDenyOutputPaths) && runtimeDenyOutputPaths.every((path) => typeof path === "string")) {
     return runtimeDenyOutputPaths;
   }
@@ -17238,6 +17236,467 @@ function cleanMetrics2(metrics) {
   return cleaned;
 }
 
+// src/instrumentation/plugins/openai-agents-channels.ts
+var openAIAgentsCoreChannels = defineChannels("@openai/agents-core", {
+  onTraceStart: channel({
+    channelName: "tracing.processor.onTraceStart",
+    kind: "async"
+  }),
+  onTraceEnd: channel({
+    channelName: "tracing.processor.onTraceEnd",
+    kind: "async"
+  }),
+  onSpanStart: channel({
+    channelName: "tracing.processor.onSpanStart",
+    kind: "async"
+  }),
+  onSpanEnd: channel({
+    channelName: "tracing.processor.onSpanEnd",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/openai-agents-trace-processor.ts
+function isSpanData(spanData, type) {
+  return spanData.type === type;
+}
+function spanTypeFromAgents(span) {
+  const spanType = span.spanData.type;
+  if (spanType === "function" || spanType === "guardrail" || spanType === "mcp_tools") {
+    return "tool" /* TOOL */;
+  }
+  if (spanType === "generation" || spanType === "response" || spanType === "transcription" || spanType === "speech") {
+    return "llm" /* LLM */;
+  }
+  return "task" /* TASK */;
+}
+function spanNameFromAgents(span) {
+  const spanData = span.spanData;
+  if ("name" in spanData && spanData.name) {
+    return spanData.name;
+  }
+  switch (spanData.type) {
+    case "generation":
+      return "Generation";
+    case "response":
+      return "Response";
+    case "handoff":
+      return "Handoff";
+    case "mcp_tools":
+      return isSpanData(spanData, "mcp_tools") && spanData.server ? `List Tools (${spanData.server})` : "MCP List Tools";
+    case "transcription":
+      return "Transcription";
+    case "speech":
+      return "Speech";
+    case "speech_group":
+      return "Speech Group";
+    default:
+      return "Unknown";
+  }
+}
+function getTimeElapsed(end, start) {
+  if (!start || !end) {
+    return void 0;
+  }
+  const startTime = new Date(start).getTime();
+  const endTime = new Date(end).getTime();
+  if (Number.isNaN(startTime) || Number.isNaN(endTime)) {
+    return void 0;
+  }
+  return (endTime - startTime) / 1e3;
+}
+function getNumberProperty2(obj, key) {
+  if (!isObject(obj) || !(key in obj)) {
+    return void 0;
+  }
+  const value = obj[key];
+  return typeof value === "number" ? value : void 0;
+}
+function parseUsageMetrics(usage) {
+  const metrics = {};
+  if (!isObject(usage)) {
+    return metrics;
+  }
+  const promptTokens = getNumberProperty2(usage, "prompt_tokens") ?? getNumberProperty2(usage, "input_tokens") ?? getNumberProperty2(usage, "promptTokens") ?? getNumberProperty2(usage, "inputTokens");
+  const completionTokens = getNumberProperty2(usage, "completion_tokens") ?? getNumberProperty2(usage, "output_tokens") ?? getNumberProperty2(usage, "completionTokens") ?? getNumberProperty2(usage, "outputTokens");
+  const totalTokens = getNumberProperty2(usage, "total_tokens") ?? getNumberProperty2(usage, "totalTokens");
+  if (promptTokens !== void 0) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  if (completionTokens !== void 0) {
+    metrics.completion_tokens = completionTokens;
+  }
+  if (totalTokens !== void 0) {
+    metrics.tokens = totalTokens;
+  } else if (promptTokens !== void 0 && completionTokens !== void 0) {
+    metrics.tokens = promptTokens + completionTokens;
+  }
+  const inputDetails = usage.input_tokens_details;
+  const cachedTokens = getNumberProperty2(inputDetails, "cached_tokens");
+  const cacheWriteTokens = getNumberProperty2(
+    inputDetails,
+    "cache_write_tokens"
+  );
+  if (cachedTokens !== void 0) {
+    metrics.prompt_cached_tokens = cachedTokens;
+  }
+  if (cacheWriteTokens !== void 0) {
+    metrics.prompt_cache_creation_tokens = cacheWriteTokens;
+  }
+  return metrics;
+}
+var OpenAIAgentsTraceProcessor = class _OpenAIAgentsTraceProcessor {
+  static DEFAULT_MAX_TRACES = 1e4;
+  logger;
+  maxTraces;
+  traceSpans = /* @__PURE__ */ new Map();
+  traceOrder = [];
+  _traceSpans = this.traceSpans;
+  constructor(options = {}) {
+    this.logger = options.logger;
+    this.maxTraces = options.maxTraces ?? _OpenAIAgentsTraceProcessor.DEFAULT_MAX_TRACES;
+  }
+  evictOldestTrace() {
+    const oldestTraceId = this.traceOrder.shift();
+    if (oldestTraceId) {
+      this.traceSpans.delete(oldestTraceId);
+    }
+  }
+  onTraceStart(trace) {
+    if (!trace?.traceId) {
+      return Promise.resolve();
+    }
+    if (this.traceOrder.length >= this.maxTraces) {
+      this.evictOldestTrace();
+    }
+    const current = currentSpan();
+    const span = current && current !== NOOP_SPAN ? current.startSpan({
+      name: trace.name,
+      type: "task" /* TASK */
+    }) : this.logger ? this.logger.startSpan({
+      name: trace.name,
+      type: "task" /* TASK */
+    }) : startSpan({
+      name: trace.name,
+      type: "task" /* TASK */
+    });
+    span.log({
+      input: "Agent workflow started",
+      metadata: {
+        group_id: trace.groupId,
+        ...trace.metadata || {}
+      }
+    });
+    this.traceSpans.set(trace.traceId, {
+      rootSpan: span,
+      childSpans: /* @__PURE__ */ new Map(),
+      metadata: {
+        firstInput: null,
+        lastOutput: null
+      }
+    });
+    this.traceOrder.push(trace.traceId);
+    return Promise.resolve();
+  }
+  async onTraceEnd(trace) {
+    const traceData = this.traceSpans.get(trace?.traceId);
+    if (!traceData) {
+      return;
+    }
+    try {
+      traceData.rootSpan.log({
+        input: traceData.metadata.firstInput,
+        output: traceData.metadata.lastOutput
+      });
+      traceData.rootSpan.end();
+      await traceData.rootSpan.flush();
+    } finally {
+      this.traceSpans.delete(trace.traceId);
+      const orderIndex = this.traceOrder.indexOf(trace.traceId);
+      if (orderIndex > -1) {
+        this.traceOrder.splice(orderIndex, 1);
+      }
+    }
+  }
+  onSpanStart(span) {
+    if (!span?.spanId || !span.traceId) {
+      return Promise.resolve();
+    }
+    const traceData = this.traceSpans.get(span.traceId);
+    if (!traceData) {
+      return Promise.resolve();
+    }
+    const parentSpan = span.parentId ? traceData.childSpans.get(span.parentId) : traceData.rootSpan;
+    if (!parentSpan) {
+      return Promise.resolve();
+    }
+    const childSpan = parentSpan.startSpan({
+      name: spanNameFromAgents(span),
+      type: spanTypeFromAgents(span)
+    });
+    traceData.childSpans.set(span.spanId, childSpan);
+    return Promise.resolve();
+  }
+  onSpanEnd(span) {
+    if (!span?.spanId || !span.traceId) {
+      return Promise.resolve();
+    }
+    const traceData = this.traceSpans.get(span.traceId);
+    if (!traceData) {
+      return Promise.resolve();
+    }
+    const braintrustSpan = traceData.childSpans.get(span.spanId);
+    if (!braintrustSpan) {
+      return Promise.resolve();
+    }
+    const logData = this.extractLogData(span);
+    braintrustSpan.log({
+      error: span.error,
+      ...logData
+    });
+    braintrustSpan.end();
+    traceData.childSpans.delete(span.spanId);
+    const input = logData.input;
+    const output = logData.output;
+    if (traceData.metadata.firstInput === null && input != null) {
+      traceData.metadata.firstInput = input;
+    }
+    if (output != null) {
+      traceData.metadata.lastOutput = output;
+    }
+    return Promise.resolve();
+  }
+  async shutdown() {
+    if (this.logger && typeof this.logger.flush === "function") {
+      await this.logger.flush();
+    }
+  }
+  async forceFlush() {
+    if (this.logger && typeof this.logger.flush === "function") {
+      await this.logger.flush();
+    }
+  }
+  extractLogData(span) {
+    const spanData = span.spanData;
+    switch (spanData.type) {
+      case "agent":
+        return this.extractAgentLogData(spanData);
+      case "response":
+        return this.extractResponseLogData(spanData, span);
+      case "function":
+        return this.extractFunctionLogData(spanData);
+      case "handoff":
+        return this.extractHandoffLogData(spanData);
+      case "guardrail":
+        return this.extractGuardrailLogData(spanData);
+      case "generation":
+        return this.extractGenerationLogData(spanData, span);
+      case "custom":
+        return this.extractCustomLogData(spanData);
+      case "mcp_tools":
+        return this.extractMCPListToolsLogData(spanData);
+      case "transcription":
+        return this.extractTranscriptionLogData(spanData);
+      case "speech":
+        return this.extractSpeechLogData(spanData);
+      case "speech_group":
+        return this.extractSpeechGroupLogData(spanData);
+      default:
+        return {};
+    }
+  }
+  extractAgentLogData(spanData) {
+    return {
+      metadata: {
+        tools: spanData.tools,
+        handoffs: spanData.handoffs,
+        output_type: spanData.output_type
+      }
+    };
+  }
+  extractResponseLogData(spanData, span) {
+    const response = spanData._response;
+    const output = isObject(response) ? response.output : void 0;
+    const usage = isObject(response) ? response.usage : void 0;
+    const metrics = {
+      ...this.extractTimingMetrics(span),
+      ...parseUsageMetrics(usage)
+    };
+    return {
+      input: spanData._input,
+      output,
+      metadata: isObject(response) ? this.omitKeys(response, ["output", "usage"]) : {},
+      metrics
+    };
+  }
+  extractFunctionLogData(spanData) {
+    return {
+      input: spanData.input,
+      output: spanData.output
+    };
+  }
+  extractHandoffLogData(spanData) {
+    return {
+      metadata: {
+        from_agent: spanData.from_agent,
+        to_agent: spanData.to_agent
+      }
+    };
+  }
+  extractGuardrailLogData(spanData) {
+    return {
+      metadata: {
+        triggered: spanData.triggered
+      }
+    };
+  }
+  extractGenerationLogData(spanData, span) {
+    return {
+      input: spanData.input,
+      output: spanData.output,
+      metadata: {
+        model: spanData.model,
+        model_config: spanData.model_config
+      },
+      metrics: {
+        ...this.extractTimingMetrics(span),
+        ...parseUsageMetrics(spanData.usage)
+      }
+    };
+  }
+  extractCustomLogData(spanData) {
+    return spanData.data || {};
+  }
+  extractMCPListToolsLogData(spanData) {
+    return {
+      output: spanData.result,
+      metadata: {
+        server: spanData.server
+      }
+    };
+  }
+  extractTranscriptionLogData(spanData) {
+    return {
+      input: spanData.input,
+      output: spanData.output,
+      metadata: {
+        model: spanData.model,
+        model_config: spanData.model_config
+      }
+    };
+  }
+  extractSpeechLogData(spanData) {
+    return {
+      input: spanData.input,
+      output: spanData.output,
+      metadata: {
+        model: spanData.model,
+        model_config: spanData.model_config
+      }
+    };
+  }
+  extractSpeechGroupLogData(spanData) {
+    return {
+      input: spanData.input
+    };
+  }
+  extractTimingMetrics(span) {
+    const timeToFirstToken = getTimeElapsed(
+      span.endedAt ?? void 0,
+      span.startedAt ?? void 0
+    );
+    return timeToFirstToken === void 0 ? {} : { time_to_first_token: timeToFirstToken };
+  }
+  omitKeys(value, keys) {
+    const result = {};
+    for (const [key, fieldValue] of Object.entries(value)) {
+      if (!keys.includes(key)) {
+        result[key] = fieldValue;
+      }
+    }
+    return result;
+  }
+};
+
+// src/instrumentation/plugins/openai-agents-plugin.ts
+function firstArgument(args) {
+  if (Array.isArray(args)) {
+    return args[0];
+  }
+  if (isObject(args) && "length" in args && typeof args.length === "number" && Number.isInteger(args.length) && args.length >= 0) {
+    return Array.from(args)[0];
+  }
+  return void 0;
+}
+function isOpenAIAgentsTrace(value) {
+  return isObject(value) && value.type === "trace" && typeof value.traceId === "string";
+}
+function isOpenAIAgentsSpan(value) {
+  return isObject(value) && value.type === "trace.span" && typeof value.traceId === "string" && typeof value.spanId === "string";
+}
+var OpenAIAgentsPlugin = class extends BasePlugin {
+  processor = new OpenAIAgentsTraceProcessor();
+  onEnable() {
+    this.subscribeToTraceLifecycle();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+    void this.processor.shutdown();
+  }
+  subscribeToTraceLifecycle() {
+    const traceStartChannel = openAIAgentsCoreChannels.onTraceStart.tracingChannel();
+    const traceStartHandlers = {
+      start: (event) => {
+        const trace = firstArgument(event.arguments);
+        if (isOpenAIAgentsTrace(trace)) {
+          void this.processor.onTraceStart(trace);
+        }
+      }
+    };
+    traceStartChannel.subscribe(traceStartHandlers);
+    this.unsubscribers.push(
+      () => traceStartChannel.unsubscribe(traceStartHandlers)
+    );
+    const traceEndChannel = openAIAgentsCoreChannels.onTraceEnd.tracingChannel();
+    const traceEndHandlers = {
+      start: (event) => {
+        const trace = firstArgument(event.arguments);
+        if (isOpenAIAgentsTrace(trace)) {
+          void this.processor.onTraceEnd(trace);
+        }
+      }
+    };
+    traceEndChannel.subscribe(traceEndHandlers);
+    this.unsubscribers.push(
+      () => traceEndChannel.unsubscribe(traceEndHandlers)
+    );
+    const spanStartChannel = openAIAgentsCoreChannels.onSpanStart.tracingChannel();
+    const spanStartHandlers = {
+      start: (event) => {
+        const span = firstArgument(event.arguments);
+        if (isOpenAIAgentsSpan(span)) {
+          void this.processor.onSpanStart(span);
+        }
+      }
+    };
+    spanStartChannel.subscribe(spanStartHandlers);
+    this.unsubscribers.push(
+      () => spanStartChannel.unsubscribe(spanStartHandlers)
+    );
+    const spanEndChannel = openAIAgentsCoreChannels.onSpanEnd.tracingChannel();
+    const spanEndHandlers = {
+      start: (event) => {
+        const span = firstArgument(event.arguments);
+        if (isOpenAIAgentsSpan(span)) {
+          void this.processor.onSpanEnd(span);
+        }
+      }
+    };
+    spanEndChannel.subscribe(spanEndHandlers);
+    this.unsubscribers.push(() => spanEndChannel.unsubscribe(spanEndHandlers));
+  }
+};
+
 // src/instrumentation/plugins/google-genai-channels.ts
 var googleGenAIChannels = defineChannels("@google/genai", {
   generateContent: channel({
@@ -23530,41 +23989,1773 @@ var GitHubCopilotPlugin = class extends BasePlugin {
   }
 };
 
-// src/instrumentation/braintrust-plugin.ts
-function getIntegrationConfig(integrations, key) {
-  return integrations[key];
+// src/instrumentation/plugins/flue-channels.ts
+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;
+  }
+  const context = ctx;
+  subscribeFlueContextEvents(context, { captureTurnSpans: true });
+  return patchFlueContextInPlace(context);
 }
-var BraintrustPlugin = class extends BasePlugin {
-  config;
-  openaiPlugin = null;
-  openAICodexPlugin = null;
-  anthropicPlugin = null;
-  aiSDKPlugin = null;
-  claudeAgentSDKPlugin = null;
-  cursorSDKPlugin = null;
-  googleGenAIPlugin = null;
-  huggingFacePlugin = null;
-  openRouterPlugin = null;
-  openRouterAgentPlugin = null;
-  mistralPlugin = null;
-  googleADKPlugin = null;
-  coherePlugin = null;
-  groqPlugin = null;
-  genkitPlugin = null;
-  gitHubCopilotPlugin = null;
-  constructor(config = {}) {
-    super();
-    this.config = config;
+function patchFlueContextInPlace(ctx) {
+  const context = ctx;
+  if (context[WRAPPED_FLUE_CONTEXT]) {
+    return ctx;
   }
-  onEnable() {
-    const integrations = this.config.integrations || {};
-    if (integrations.openai !== false) {
-      this.openaiPlugin = new OpenAIPlugin();
-      this.openaiPlugin.enable();
+  const originalInit = context.init.bind(context);
+  try {
+    Object.defineProperty(context, WRAPPED_FLUE_CONTEXT, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    Object.defineProperty(context, "init", {
+      configurable: true,
+      value: async function wrappedFlueInit(options) {
+        const harness = await originalInit(options);
+        return wrapFlueHarness(harness);
+      },
+      writable: true
+    });
+  } catch {
+  }
+  return ctx;
+}
+function wrapFlueSession(session) {
+  if (!isPlausibleFlueSession(session)) {
+    console.warn("Unsupported Flue session. Not wrapping.");
+    return session;
+  }
+  return patchFlueSessionInPlace(session);
+}
+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;
     }
-    if (integrations.openaiCodexSDK !== false) {
-      this.openAICodexPlugin = new OpenAICodexPlugin();
-      this.openAICodexPlugin.enable();
+    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 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 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 patchFlueSessionFactory(sessions, method) {
+  const original = sessions[method];
+  if (typeof original !== "function") {
+    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;
+  }
+  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;
+  }
+  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 = () => {
+    try {
+      originalResult = args.run();
+      tracingChannel2.end?.publish(context);
+    } catch (error) {
+      context.error = normalizeError3(error);
+      tracingChannel2.error?.publish(context);
+      tracingChannel2.end?.publish(context);
+      throw error;
+    }
+    traced2 = Promise.resolve(originalResult).then(
+      (result) => {
+        context.result = result;
+        tracingChannel2.asyncStart?.publish(context);
+        tracingChannel2.asyncEnd?.publish(context);
+        return result;
+      },
+      (error) => {
+        context.error = normalizeError3(error);
+        tracingChannel2.error?.publish(context);
+        tracingChannel2.asyncStart?.publish(context);
+        tracingChannel2.asyncEnd?.publish(context);
+        throw error;
+      }
+    );
+  };
+  if (tracingChannel2.start?.runStores) {
+    tracingChannel2.start.runStores(context, run);
+  } else {
+    tracingChannel2.start?.publish(context);
+    run();
+  }
+  return { originalResult, traced: traced2 };
+}
+function normalizeError3(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function preserveCallHandle(originalHandle, traced2) {
+  if (!isFlueCallHandle(originalHandle)) {
+    return traced2;
+  }
+  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;
+}
+function isPlausibleFlueContext(value) {
+  return !!value && typeof value === "object" && typeof value.init === "function";
+}
+function isPlausibleFlueHarness(value) {
+  return !!value && typeof value === "object" && typeof value.session === "function";
+}
+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 isFlueCallHandle(value) {
+  return !!value && typeof value === "object" && typeof value.then === "function" && typeof value.abort === "function" && "signal" in 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();
+  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();
+    }
+    this.unsubscribers = [];
+    this.activeOperationsById.clear();
+    this.activeOperationsByScope.clear();
+    this.compactionsByScope.clear();
+    this.pendingOperationsByKey.clear();
+    this.tasksById.clear();
+    this.toolsById.clear();
+    this.turnsByScope.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);
+    });
+  }
+  subscribeToSessionCreation() {
+    const channel2 = flueChannels.openSession.tracingChannel();
+    const handlers = {
+      asyncEnd: (event) => {
+        if (event.result) {
+          patchFlueSessionInPlace(
+            event.result
+          );
+        }
+        if (event.harness) {
+          wrapFlueHarness(event.harness);
+        }
+      },
+      error: () => {
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.unsubscribe(handlers);
+    });
+  }
+  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
+      });
+      states.set(event, state);
+      return state;
+    };
+    const unbindCurrentSpanStore = this.bindCurrentSpanStoreToOperationStart(
+      tracingChannel2,
+      ensureState2
+    );
+    const handlers = {
+      start: (event) => {
+        ensureState2(event);
+      },
+      asyncEnd: (event) => {
+        this.endOperationState(states.get(event), event.result);
+        states.delete(event);
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (state && event.error) {
+          safeLog3(state.span, { error: errorToString(event.error) });
+          this.finishOperationState(state);
+        }
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToCompact() {
+    const tracingChannel2 = flueChannels.compact.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const ensureState2 = (event) => {
+      const existing = states.get(event);
+      if (existing) {
+        return existing;
+      }
+      const state = this.startOperationState({
+        args: [],
+        moduleVersion: typeof event.moduleVersion === "string" ? event.moduleVersion : void 0,
+        operation: event.operation,
+        session: event.session
+      });
+      states.set(event, state);
+      return state;
+    };
+    const unbindCurrentSpanStore = this.bindCurrentSpanStoreToOperationStart(
+      tracingChannel2,
+      ensureState2
+    );
+    const handlers = {
+      start: (event) => {
+        ensureState2(event);
+      },
+      asyncEnd: (event) => {
+        this.endOperationState(states.get(event), void 0);
+        states.delete(event);
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (state && event.error) {
+          safeLog3(state.span, { error: errorToString(event.error) });
+          this.finishOperationState(state);
+        }
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToContextEvents() {
+    const channel2 = flueChannels.contextEvent.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        const flueEvent = event.arguments[0];
+        if (!flueEvent) {
+          return;
+        }
+        try {
+          this.handleFlueEvent(flueEvent, {
+            captureTurnSpans: event.captureTurnSpans !== false
+          });
+        } catch (error) {
+          logInstrumentationError3("Flue event", error);
+        }
+      },
+      error: () => {
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.unsubscribe(handlers);
+    });
+  }
+  bindCurrentSpanStoreToOperationStart(tracingChannel2, ensureState2) {
+    const state = _internalGetGlobalState();
+    const startChannel = tracingChannel2.start;
+    const contextManager = state?.contextManager;
+    const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+    if (!currentSpanStore || !startChannel) {
+      return void 0;
+    }
+    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) {
+      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 });
+  }
+  handleOperation(event) {
+    const state = event.operationId ? this.activeOperationsById.get(event.operationId) : void 0;
+    if (!state) {
+      return;
+    }
+    const metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      ...typeof event.durationMs === "number" ? { "flue.duration_ms": event.durationMs } : {},
+      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
+    };
+    const metrics = metricsFromUsage(event.usage);
+    safeLog3(state.span, {
+      ...event.error ? { error: errorToString(event.error) } : {},
+      metadata,
+      ...Object.keys(metrics).length ? { metrics } : {}
+    });
+  }
+  ensureTurnState(event) {
+    const scope = scopeKey(event);
+    const existing = this.turnsByScope.get(scope);
+    if (existing) {
+      return existing;
+    }
+    const parent = this.parentSpanForEvent(event);
+    const metadata = {
+      ...extractEventMetadata(event),
+      provider: "flue"
+    };
+    const span = startFlueSpan(parent, {
+      name: "flue.turn",
+      spanAttributes: { type: "llm" /* LLM */ }
+    });
+    const state = {
+      metadata,
+      span,
+      hasThinking: false,
+      startTime: getCurrentUnixTimestamp(),
+      text: [],
+      thinking: [],
+      toolCalls: []
+    };
+    safeLog3(span, { metadata });
+    this.turnsByScope.set(scope, state);
+    return state;
+  }
+  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 metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      ...event.model ? { model: event.model, "flue.model": event.model } : {},
+      ...event.stopReason ? { "flue.stop_reason": event.stopReason } : {},
+      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {},
+      provider: "flue"
+    };
+    safeLog3(state.span, {
+      ...event.error ? { error: errorToString(event.error) } : {},
+      metadata,
+      metrics: {
+        ...durationMsMetrics(event.durationMs),
+        ...metricsFromUsage(event.usage)
+      },
+      output: toAssistantOutput(
+        text,
+        event.stopReason,
+        outputReasoning,
+        state.toolCalls
+      )
+    });
+    state.span.end();
+    this.turnsByScope.delete(scope);
+  }
+  handleThinkingDelta(event) {
+    const delta = event.delta;
+    if (typeof delta !== "string" || !delta) {
+      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,
+      provider: "flue"
+    };
+    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()
+    });
+  }
+  handleToolCall(event) {
+    const key = toolKey(event);
+    const state = this.toolsById.get(key) ?? this.startSyntheticToolState(event, event.toolName ?? "unknown");
+    const metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      ...event.toolName ? { "flue.tool_name": event.toolName } : {},
+      ...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),
+      output: event.result
+    });
+    state.span.end();
+    this.toolsById.delete(key);
+  }
+  handleTaskStart(event) {
+    const parent = this.parentSpanForEvent(event);
+    const metadata = {
+      ...extractEventMetadata(event),
+      ...event.role ? { "flue.role": event.role } : {},
+      ...event.cwd ? { "flue.cwd": event.cwd } : {},
+      "flue.task_id": event.taskId,
+      provider: "flue"
+    };
+    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()
+    });
+  }
+  handleTask(event) {
+    const state = this.tasksById.get(event.taskId);
+    if (!state) {
+      return;
+    }
+    safeLog3(state.span, {
+      ...event.isError ? { error: errorToString(event.result) } : {},
+      metadata: {
+        ...state.metadata,
+        ...extractEventMetadata(event),
+        ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
+      },
+      metrics: durationMsMetrics(event.durationMs),
+      output: event.result
+    });
+    state.span.end();
+    this.tasksById.delete(event.taskId);
+  }
+  handleCompactionStart(event) {
+    const operationState = this.operationStateForEvent(event);
+    const parent = operationState?.span ?? this.parentSpanForEvent(event);
+    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 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()
+    });
+  }
+  handleCompaction(event) {
+    const key = scopeKey(event);
+    const state = this.compactionsByScope.get(key) ?? this.findCompactionState(event);
+    if (!state) {
+      return;
+    }
+    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 } : {}
+      },
+      metrics: {
+        ...durationMsMetrics(event.durationMs),
+        ...metricsFromUsage(event.usage)
+      },
+      output: {
+        messagesAfter: event.messagesAfter,
+        messagesBefore: event.messagesBefore
+      }
+    });
+    state.span.end();
+    this.deleteCompactionState(state);
+  }
+  findCompactionState(event) {
+    const operationState = this.operationStateForEvent(event);
+    for (const state of this.compactionsByScope.values()) {
+      if (operationState && state.operationState === operationState) {
+        return state;
+      }
+    }
+    return void 0;
+  }
+  finishCompactionsForOperation(operationState) {
+    for (const state of [...this.compactionsByScope.values()]) {
+      if (state.operationState !== operationState) {
+        continue;
+      }
+      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;
+      }
+      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);
+      if (operation) {
+        return operation;
+      }
+    }
+    return this.activeOperationForEventScope(event) ?? this.pendingOperationForEventScope(event);
+  }
+  parentSpanForEvent(event) {
+    if (event.operationId) {
+      const operation = this.operationStateForEvent(event);
+      if (operation) {
+        return operation.span;
+      }
+    }
+    if (event.taskId) {
+      return this.tasksById.get(event.taskId)?.span;
+    }
+    return this.operationStateForEvent(event)?.span;
+  }
+  promotePendingOperationForEvent(event) {
+    if (!event.operationId) {
+      return void 0;
+    }
+    const scopePrefixes = operationScopePrefixes(event);
+    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
+      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+        continue;
+      }
+      const state = candidateQueue.shift();
+      if (!state) {
+        return void 0;
+      }
+      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;
+    }
+    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];
+      }
+    }
+    return void 0;
+  }
+  pendingOperationForEventScope(event) {
+    const scopePrefixes = operationScopePrefixes(event);
+    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
+      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+        continue;
+      }
+      return candidateQueue[0];
+    }
+    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 [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
+      if (candidateKey.endsWith(`::${event.operationKind}`) && candidateQueue.length) {
+        return candidateQueue.shift();
+      }
+    }
+    return void 0;
+  }
+  pendingOperationQueue(key) {
+    const existing = this.pendingOperationsByKey.get(key);
+    if (existing) {
+      return existing;
+    }
+    const queue2 = [];
+    this.pendingOperationsByKey.set(key, queue2);
+    return queue2;
+  }
+};
+function isInstrumentedOperation(operation) {
+  return operation === "prompt" || operation === "skill" || operation === "task" || operation === "compact";
+}
+function getSessionName(session) {
+  return typeof session?.name === "string" ? session.name : void 0;
+}
+function operationKey(sessionName, operation) {
+  return `${sessionName ?? "unknown"}::${operation}`;
+}
+function operationScopePrefixes(event) {
+  const scopes = /* @__PURE__ */ new Set();
+  for (const scope of operationScopeNames(event)) {
+    scopes.add(`${scope}::`);
+  }
+  return scopes;
+}
+function operationKeyMatchesScopes(key, scopes) {
+  for (const scope of scopes) {
+    if (key.startsWith(scope)) {
+      return true;
+    }
+  }
+  return false;
+}
+function operationScopeNames(event) {
+  const scopes = /* @__PURE__ */ new Set();
+  if (event.session) {
+    scopes.add(event.session);
+  }
+  if (event.parentSession) {
+    scopes.add(event.parentSession);
+  }
+  if (!scopes.size) {
+    scopes.add("unknown");
+  }
+  return scopes;
+}
+function addScopedOperation(operationsByScope, event, state) {
+  for (const scope of operationScopeNames(event)) {
+    addOperationToScope(operationsByScope, scope, state);
+  }
+}
+function addOperationToScope(operationsByScope, scope, state) {
+  const operations = operationsByScope.get(scope);
+  if (operations) {
+    if (!operations.includes(state)) {
+      operations.push(state);
+    }
+  } else {
+    operationsByScope.set(scope, [state]);
+  }
+}
+function removeScopedOperation(operationsByScope, state) {
+  for (const [scope, operations] of operationsByScope) {
+    const index = operations.indexOf(state);
+    if (index === -1) {
+      continue;
+    }
+    operations.splice(index, 1);
+    if (operations.length === 0) {
+      operationsByScope.delete(scope);
+    }
+  }
+}
+function removePendingOperation(pendingOperationsByKey, state) {
+  for (const [key, queue2] of pendingOperationsByKey) {
+    const index = queue2.indexOf(state);
+    if (index === -1) {
+      continue;
+    }
+    queue2.splice(index, 1);
+    if (queue2.length === 0) {
+      pendingOperationsByKey.delete(key);
+    }
+    return;
+  }
+}
+function extractSessionMetadata(session) {
+  const sessionName = getSessionName(session);
+  return sessionName ? { "flue.session": sessionName } : {};
+}
+function extractEventMetadata(event) {
+  return {
+    ...event.runId ? { "flue.run_id": event.runId } : {},
+    ...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 } : {}
+  };
+}
+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 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 extractPromptResponseMetadata(result) {
+  const modelId = result?.model && typeof result.model.id === "string" ? result.model.id : void 0;
+  return modelId ? {
+    model: modelId,
+    "flue.model": modelId
+  } : {};
+}
+function extractOperationOutput(result) {
+  if (!result) {
+    return void 0;
+  }
+  if ("data" in result) {
+    return result.data;
+  }
+  if ("text" in result) {
+    return result.text;
+  }
+  return result;
+}
+function metricsFromUsage(usage) {
+  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)
+  };
+}
+function durationMsMetrics(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}`;
+  }
+  return "flue:unknown";
+}
+function toolKey(event) {
+  return `${scopeKey(event)}::tool:${event.toolCallId ?? "unknown"}`;
+}
+function toAssistantOutput(text, finishReason, reasoning, toolCalls) {
+  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"
+          }))
+        } : {}
+      }
+    }
+  ];
+}
+function startFlueSpan(parent, args) {
+  return parent ? withCurrent(parent, () => startSpan(args)) : startSpan(args);
+}
+function safeLog3(span, event) {
+  try {
+    span.log(event);
+  } catch (error) {
+    logInstrumentationError3("Flue span log", error);
+  }
+}
+function errorToString(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function logInstrumentationError3(label, error) {
+  console.error(`Error in ${label} instrumentation:`, error);
+}
+
+// src/wrappers/langchain/callback-handler.ts
+var BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME = "BraintrustCallbackHandler";
+var BraintrustLangChainCallbackHandler = class {
+  name = BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
+  spans = /* @__PURE__ */ new Map();
+  skippedRuns = /* @__PURE__ */ new Set();
+  parent;
+  rootRunId;
+  options;
+  startTimes = /* @__PURE__ */ new Map();
+  firstTokenTimes = /* @__PURE__ */ new Map();
+  ttftMs = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.parent = options?.parent;
+    this.options = {
+      debug: options?.debug ?? false,
+      excludeMetadataProps: options?.excludeMetadataProps ?? /^(l[sc]_|langgraph_|__pregel_|checkpoint_ns)/,
+      logger: options?.logger
+    };
+  }
+  startSpan({
+    runId,
+    parentRunId,
+    ...args
+  }) {
+    if (this.spans.has(runId)) {
+      return;
+    }
+    if (!parentRunId) {
+      this.rootRunId = runId;
+    }
+    const tags = args.event?.tags;
+    const spanAttributes = args.spanAttributes || {};
+    spanAttributes.type = args.type || spanAttributes.type || "task";
+    args.type = spanAttributes.type;
+    const currentParent = (typeof this.parent === "function" ? this.parent() : this.parent) ?? currentSpan();
+    let parentSpan;
+    if (parentRunId && this.spans.has(parentRunId)) {
+      parentSpan = this.spans.get(parentRunId);
+    } else if (!Object.is(currentParent, NOOP_SPAN)) {
+      parentSpan = currentParent;
+    } else if (this.options.logger) {
+      parentSpan = this.options.logger;
+    } else {
+      parentSpan = { startSpan };
+    }
+    args.event = {
+      ...args.event,
+      tags: void 0,
+      metadata: {
+        ...tags ? { tags } : {},
+        ...args.event?.metadata,
+        braintrust: {
+          integration_name: "langchain-js",
+          sdk_language: "javascript"
+        },
+        run_id: runId,
+        parent_run_id: parentRunId,
+        ...this.options.debug ? { runId, parentRunId } : {}
+      }
+    };
+    let span = parentSpan.startSpan(args);
+    if (!Object.is(this.options.logger, NOOP_SPAN) && Object.is(span, NOOP_SPAN)) {
+      span = initLogger().startSpan(args);
+    }
+    this.spans.set(runId, span);
+  }
+  endSpan({
+    runId,
+    parentRunId,
+    tags,
+    metadata,
+    ...args
+  }) {
+    if (!this.spans.has(runId)) {
+      return;
+    }
+    if (this.skippedRuns.has(runId)) {
+      this.skippedRuns.delete(runId);
+      return;
+    }
+    const span = this.spans.get(runId);
+    this.spans.delete(runId);
+    if (runId === this.rootRunId) {
+      this.rootRunId = void 0;
+    }
+    span.log({ ...args, metadata: { tags, ...metadata } });
+    span.end();
+  }
+  async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, runName) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(llm) ?? "LLM",
+      type: "llm",
+      event: {
+        input: prompts,
+        tags,
+        metadata: {
+          serialized: llm,
+          name: runName,
+          metadata,
+          ...extraParams
+        }
+      }
+    });
+  }
+  async handleLLMError(err, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, error: err, tags });
+  }
+  async handleLLMEnd(output, runId, parentRunId, tags) {
+    const metrics = getMetricsFromResponse(output);
+    const modelName2 = getModelNameFromResponse(output);
+    const ttft = this.ttftMs.get(runId);
+    if (ttft !== void 0) {
+      metrics.time_to_first_token = ttft;
+    }
+    this.startTimes.delete(runId);
+    this.firstTokenTimes.delete(runId);
+    this.ttftMs.delete(runId);
+    this.endSpan({
+      runId,
+      parentRunId,
+      output,
+      metrics,
+      tags,
+      metadata: {
+        model: modelName2
+      }
+    });
+  }
+  async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, runName) {
+    this.startTimes.set(runId, Date.now());
+    this.firstTokenTimes.delete(runId);
+    this.ttftMs.delete(runId);
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(llm) ?? "Chat Model",
+      type: "llm",
+      event: {
+        input: messages,
+        tags,
+        metadata: {
+          serialized: llm,
+          name: runName,
+          metadata,
+          ...extraParams
+        }
+      }
+    });
+  }
+  async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, runName) {
+    if (tags?.includes("langsmith:hidden")) {
+      this.skippedRuns.add(runId);
+      return;
+    }
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(chain) ?? "Chain",
+      event: {
+        input: inputs,
+        tags,
+        metadata: {
+          serialized: chain,
+          name: runName,
+          metadata,
+          run_type: runType
+        }
+      }
+    });
+  }
+  async handleChainError(err, runId, parentRunId, tags, kwargs) {
+    this.endSpan({ runId, parentRunId, error: err, tags, metadata: kwargs });
+  }
+  async handleChainEnd(outputs, runId, parentRunId, tags, kwargs) {
+    this.endSpan({
+      runId,
+      parentRunId,
+      tags,
+      output: outputs,
+      metadata: { ...kwargs }
+    });
+  }
+  async handleToolStart(tool, input, runId, parentRunId, tags, metadata, runName) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(tool) ?? "Tool",
+      type: "llm",
+      event: {
+        input: safeJsonParse(input),
+        tags,
+        metadata: {
+          metadata,
+          serialized: tool,
+          input_str: input,
+          input: safeJsonParse(input),
+          name: runName
+        }
+      }
+    });
+  }
+  async handleToolError(err, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, error: err, tags });
+  }
+  async handleToolEnd(output, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, output, tags });
+  }
+  async handleAgentAction(action, runId, parentRunId, tags) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      type: "llm",
+      name: typeof action.tool === "string" ? action.tool : "Agent",
+      event: {
+        input: action,
+        tags
+      }
+    });
+  }
+  async handleAgentEnd(action, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, output: action, tags });
+  }
+  async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: name ?? getSerializedName(retriever) ?? "Retriever",
+      type: "function",
+      event: {
+        input: query,
+        tags,
+        metadata: {
+          serialized: retriever,
+          metadata,
+          name
+        }
+      }
+    });
+  }
+  async handleRetrieverEnd(documents, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, output: documents, tags });
+  }
+  async handleRetrieverError(err, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, error: err, tags });
+  }
+  async handleLLMNewToken(_token, _idx, runId, _parentRunId, _tags) {
+    if (!this.firstTokenTimes.has(runId)) {
+      const now2 = Date.now();
+      this.firstTokenTimes.set(runId, now2);
+      const start = this.startTimes.get(runId);
+      if (start !== void 0) {
+        this.ttftMs.set(runId, (now2 - start) / 1e3);
+      }
+    }
+  }
+};
+function getSerializedName(serialized) {
+  if (typeof serialized.name === "string") {
+    return serialized.name;
+  }
+  const lastIdPart = serialized.id?.at(-1);
+  return typeof lastIdPart === "string" ? lastIdPart : void 0;
+}
+function cleanObject(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, value]) => {
+      if (typeof value !== "number") {
+        return false;
+      }
+      return Number.isFinite(value);
+    })
+  );
+}
+function walkGenerations(response) {
+  const result = [];
+  const generations = response.generations || [];
+  for (const batch of generations) {
+    if (Array.isArray(batch)) {
+      for (const generation of batch) {
+        if (isRecord(generation)) {
+          result.push(generation);
+        }
+      }
+    } else if (isRecord(batch)) {
+      result.push(batch);
+    }
+  }
+  return result;
+}
+function getModelNameFromResponse(response) {
+  for (const generation of walkGenerations(response)) {
+    const message = generation.message;
+    if (!isRecord(message)) {
+      continue;
+    }
+    const responseMetadata = message.response_metadata;
+    if (!isRecord(responseMetadata)) {
+      continue;
+    }
+    const modelName3 = responseMetadata.model_name ?? responseMetadata.model;
+    if (typeof modelName3 === "string") {
+      return modelName3;
+    }
+  }
+  const llmOutput = response.llmOutput || {};
+  const modelName2 = llmOutput.model_name ?? llmOutput.model;
+  return typeof modelName2 === "string" ? modelName2 : void 0;
+}
+function getMetricsFromResponse(response) {
+  for (const generation of walkGenerations(response)) {
+    const message = generation.message;
+    if (!isRecord(message)) {
+      continue;
+    }
+    const usageMetadata = message.usage_metadata;
+    if (!isRecord(usageMetadata)) {
+      continue;
+    }
+    const inputTokenDetails = usageMetadata.input_token_details;
+    return cleanObject({
+      total_tokens: usageMetadata.total_tokens,
+      prompt_tokens: usageMetadata.input_tokens,
+      completion_tokens: usageMetadata.output_tokens,
+      prompt_cache_creation_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_creation : void 0,
+      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0
+    });
+  }
+  const llmOutput = response.llmOutput || {};
+  const tokenUsage = isRecord(llmOutput.tokenUsage) ? llmOutput.tokenUsage : isRecord(llmOutput.estimatedTokens) ? llmOutput.estimatedTokens : {};
+  return cleanObject({
+    total_tokens: tokenUsage.totalTokens,
+    prompt_tokens: tokenUsage.promptTokens,
+    completion_tokens: tokenUsage.completionTokens
+  });
+}
+function safeJsonParse(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return input;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/instrumentation/plugins/langchain-channels.ts
+var langChainChannels = defineChannels("@langchain/core", {
+  configure: channel({
+    channelName: "CallbackManager.configure",
+    kind: "sync-stream"
+  }),
+  configureSync: channel({
+    channelName: "CallbackManager._configureSync",
+    kind: "sync-stream"
+  })
+});
+
+// src/instrumentation/plugins/langchain-plugin.ts
+var LangChainPlugin = class extends BasePlugin {
+  injectedManagers = /* @__PURE__ */ new WeakSet();
+  onEnable() {
+    this.subscribeToConfigure(langChainChannels.configure);
+    this.subscribeToConfigure(langChainChannels.configureSync);
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    this.injectedManagers = /* @__PURE__ */ new WeakSet();
+  }
+  subscribeToConfigure(channel2) {
+    const tracingChannel2 = channel2.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        injectHandlerIntoArguments(event.arguments);
+      },
+      end: (event) => {
+        this.injectHandler(event.result);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  injectHandler(result) {
+    if (!isCallbackManager(result)) {
+      return;
+    }
+    if (this.injectedManagers.has(result) || hasBraintrustHandler(result)) {
+      return;
+    }
+    try {
+      result.addHandler(new BraintrustLangChainCallbackHandler(), true);
+      this.injectedManagers.add(result);
+    } catch {
+    }
+  }
+};
+function isCallbackManager(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const maybeManager = value;
+  return typeof maybeManager.addHandler === "function";
+}
+function hasBraintrustHandler(manager) {
+  return manager.handlers?.some((handler) => {
+    if (typeof handler !== "object" || handler === null) {
+      return false;
+    }
+    const name = Reflect.get(handler, "name");
+    return name === BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
+  }) ?? false;
+}
+function injectHandlerIntoArguments(args) {
+  if (!isWritableArgumentsObject(args)) {
+    return;
+  }
+  const inheritedHandlers = Reflect.get(args, "0");
+  const handler = new BraintrustLangChainCallbackHandler();
+  if (inheritedHandlers === void 0 || inheritedHandlers === null) {
+    Reflect.set(args, "0", [handler]);
+    return;
+  }
+  if (Array.isArray(inheritedHandlers)) {
+    if (!inheritedHandlers.some(isBraintrustHandler)) {
+      inheritedHandlers.push(handler);
+    }
+  }
+}
+function isWritableArgumentsObject(args) {
+  return typeof args === "object" && args !== null;
+}
+function isBraintrustHandler(handler) {
+  if (typeof handler !== "object" || handler === null) {
+    return false;
+  }
+  return Reflect.get(handler, "name") === BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
+}
+
+// src/instrumentation/braintrust-plugin.ts
+function getIntegrationConfig(integrations, key) {
+  return integrations[key];
+}
+var BraintrustPlugin = class extends BasePlugin {
+  config;
+  openaiPlugin = null;
+  openAICodexPlugin = null;
+  anthropicPlugin = null;
+  aiSDKPlugin = null;
+  claudeAgentSDKPlugin = null;
+  cursorSDKPlugin = null;
+  openAIAgentsPlugin = null;
+  googleGenAIPlugin = null;
+  huggingFacePlugin = null;
+  openRouterPlugin = null;
+  openRouterAgentPlugin = null;
+  mistralPlugin = null;
+  googleADKPlugin = null;
+  coherePlugin = null;
+  groqPlugin = null;
+  genkitPlugin = null;
+  gitHubCopilotPlugin = null;
+  fluePlugin = null;
+  langChainPlugin = null;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  onEnable() {
+    const integrations = this.config.integrations || {};
+    if (integrations.openai !== false) {
+      this.openaiPlugin = new OpenAIPlugin();
+      this.openaiPlugin.enable();
+    }
+    if (integrations.openaiCodexSDK !== false) {
+      this.openAICodexPlugin = new OpenAICodexPlugin();
+      this.openAICodexPlugin.enable();
     }
     if (integrations.anthropic !== false) {
       this.anthropicPlugin = new AnthropicPlugin();
@@ -23582,6 +25773,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.cursorSDKPlugin = new CursorSDKPlugin();
       this.cursorSDKPlugin.enable();
     }
+    if (integrations.openAIAgents !== false) {
+      this.openAIAgentsPlugin = new OpenAIAgentsPlugin();
+      this.openAIAgentsPlugin.enable();
+    }
     if (integrations.googleGenAI !== false && integrations.google !== false) {
       this.googleGenAIPlugin = new GoogleGenAIPlugin();
       this.googleGenAIPlugin.enable();
@@ -23622,6 +25817,14 @@ var BraintrustPlugin = class extends BasePlugin {
       this.gitHubCopilotPlugin = new GitHubCopilotPlugin();
       this.gitHubCopilotPlugin.enable();
     }
+    if (getIntegrationConfig(integrations, "flue") !== false) {
+      this.fluePlugin = new FluePlugin();
+      this.fluePlugin.enable();
+    }
+    if (integrations.langchain !== false && integrations.langgraph !== false) {
+      this.langChainPlugin = new LangChainPlugin();
+      this.langChainPlugin.enable();
+    }
   }
   onDisable() {
     if (this.openaiPlugin) {
@@ -23648,6 +25851,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.cursorSDKPlugin.disable();
       this.cursorSDKPlugin = null;
     }
+    if (this.openAIAgentsPlugin) {
+      this.openAIAgentsPlugin.disable();
+      this.openAIAgentsPlugin = null;
+    }
     if (this.googleGenAIPlugin) {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
@@ -23688,9 +25895,104 @@ var BraintrustPlugin = class extends BasePlugin {
       this.gitHubCopilotPlugin.disable();
       this.gitHubCopilotPlugin = null;
     }
+    if (this.fluePlugin) {
+      this.fluePlugin.disable();
+      this.fluePlugin = null;
+    }
+    if (this.langChainPlugin) {
+      this.langChainPlugin.disable();
+      this.langChainPlugin = null;
+    }
   }
 };
 
+// src/instrumentation/config.ts
+var envIntegrationAliases = {
+  openai: "openai",
+  "openai-codex": "openaiCodexSDK",
+  "openai-codex-sdk": "openaiCodexSDK",
+  openaicodexsdk: "openaiCodexSDK",
+  codex: "openaiCodexSDK",
+  "codex-sdk": "openaiCodexSDK",
+  anthropic: "anthropic",
+  aisdk: "aisdk",
+  "ai-sdk": "aisdk",
+  "vercel-ai": "aisdk",
+  vercel: "vercel",
+  claudeagentsdk: "claudeAgentSDK",
+  "claude-agent-sdk": "claudeAgentSDK",
+  cursor: "cursor",
+  "cursor-sdk": "cursorSDK",
+  cursorsdk: "cursorSDK",
+  flue: "flue",
+  "flue-runtime": "flue",
+  "openai-agents": "openAIAgents",
+  openaiagents: "openAIAgents",
+  "openai-agents-core": "openAIAgents",
+  openaiagentscore: "openAIAgents",
+  google: "google",
+  "google-genai": "googleGenAI",
+  googlegenai: "googleGenAI",
+  huggingface: "huggingface",
+  openrouter: "openrouter",
+  openrouteragent: "openrouterAgent",
+  "openrouter-agent": "openrouterAgent",
+  mistral: "mistral",
+  googleadk: "googleADK",
+  "google-adk": "googleADK",
+  cohere: "cohere",
+  groq: "groq",
+  "groq-sdk": "groq",
+  genkit: "genkit",
+  "firebase-genkit": "genkit",
+  githubcopilot: "gitHubCopilot",
+  "github-copilot": "gitHubCopilot",
+  "copilot-sdk": "gitHubCopilot",
+  langchain: "langchain",
+  "langchain-js": "langchain",
+  "@langchain": "langchain",
+  langgraph: "langgraph"
+};
+function getDefaultInstrumentationIntegrations() {
+  return {
+    openai: true,
+    openaiCodexSDK: true,
+    anthropic: true,
+    vercel: true,
+    aisdk: true,
+    google: true,
+    googleGenAI: true,
+    googleADK: true,
+    huggingface: true,
+    claudeAgentSDK: true,
+    cursor: true,
+    cursorSDK: true,
+    flue: true,
+    openAIAgents: true,
+    openrouter: true,
+    openrouterAgent: true,
+    mistral: true,
+    cohere: true,
+    groq: true,
+    genkit: true,
+    gitHubCopilot: true,
+    langchain: true,
+    langgraph: true
+  };
+}
+function readDisabledInstrumentationEnvConfig(disabledList) {
+  const integrations = {};
+  if (disabledList) {
+    for (const value of disabledList.split(",")) {
+      const sdk = value.trim().toLowerCase();
+      if (sdk.length > 0) {
+        integrations[envIntegrationAliases[sdk] ?? sdk] = false;
+      }
+    }
+  }
+  return { integrations };
+}
+
 // src/instrumentation/registry.ts
 var REGISTRY_STATE_KEY = /* @__PURE__ */ Symbol.for("braintrust.registry");
 function getSharedState() {
@@ -23769,50 +26071,16 @@ var PluginRegistry = class {
    * Get default configuration (all integrations enabled).
    */
   getDefaultConfig() {
-    return {
-      openai: true,
-      openaiCodexSDK: true,
-      anthropic: true,
-      vercel: true,
-      aisdk: true,
-      google: true,
-      googleGenAI: true,
-      googleADK: true,
-      huggingface: true,
-      claudeAgentSDK: true,
-      cursor: true,
-      cursorSDK: true,
-      openrouter: true,
-      openrouterAgent: true,
-      mistral: true,
-      cohere: true,
-      groq: true,
-      genkit: true,
-      gitHubCopilot: true
-    };
+    return getDefaultInstrumentationIntegrations();
   }
   /**
    * Read configuration from environment variables.
    * Supports: BRAINTRUST_DISABLE_INSTRUMENTATION=openai,anthropic,...
    */
   readEnvConfig() {
-    const integrations = {};
-    const disabledList = isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION");
-    if (disabledList) {
-      const disabled = disabledList.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
-      for (const sdk of disabled) {
-        if (sdk === "cursor-sdk") {
-          integrations.cursorSDK = false;
-        } else if (sdk === "githubcopilot" || sdk === "github-copilot" || sdk === "copilot-sdk") {
-          integrations.gitHubCopilot = false;
-        } else if (sdk === "openai-codex-sdk") {
-          integrations.openaiCodexSDK = false;
-        } else {
-          integrations[sdk] = false;
-        }
-      }
-    }
-    return { integrations };
+    return readDisabledInstrumentationEnvConfig(
+      isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION")
+    );
   }
 };
 var registry = new PluginRegistry();
@@ -23948,8 +26216,10 @@ __export(exports_exports, {
   Attachment: () => Attachment,
   AttachmentReference: () => AttachmentReference,
   BRAINTRUST_CURRENT_SPAN_STORE: () => BRAINTRUST_CURRENT_SPAN_STORE,
+  BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME: () => BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
   BaseAttachment: () => BaseAttachment,
   BaseExperiment: () => BaseExperiment,
+  BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
@@ -24075,6 +26345,8 @@ __export(exports_exports, {
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
+  wrapFlueContext: () => wrapFlueContext,
+  wrapFlueSession: () => wrapFlueSession,
   wrapGenkit: () => wrapGenkit,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
@@ -25174,7 +27446,7 @@ function extractModelParameters(params, excludeKeys) {
   }
   return modelParams;
 }
-function getNumberProperty2(obj, key) {
+function getNumberProperty3(obj, key) {
   if (!obj || typeof obj !== "object" || !(key in obj)) {
     return void 0;
   }
@@ -25183,31 +27455,31 @@ function getNumberProperty2(obj, key) {
 }
 function normalizeUsageMetrics(usage, provider, providerMetadata) {
   const metrics = {};
-  const inputTokens = getNumberProperty2(usage, "inputTokens");
+  const inputTokens = getNumberProperty3(usage, "inputTokens");
   if (inputTokens !== void 0) {
     metrics.prompt_tokens = inputTokens;
   }
-  const outputTokens = getNumberProperty2(usage, "outputTokens");
+  const outputTokens = getNumberProperty3(usage, "outputTokens");
   if (outputTokens !== void 0) {
     metrics.completion_tokens = outputTokens;
   }
-  const totalTokens = getNumberProperty2(usage, "totalTokens");
+  const totalTokens = getNumberProperty3(usage, "totalTokens");
   if (totalTokens !== void 0) {
     metrics.tokens = totalTokens;
   }
-  const reasoningTokens = getNumberProperty2(usage, "reasoningTokens");
+  const reasoningTokens = getNumberProperty3(usage, "reasoningTokens");
   if (reasoningTokens !== void 0) {
     metrics.completion_reasoning_tokens = reasoningTokens;
   }
-  const cachedInputTokens = getNumberProperty2(usage, "cachedInputTokens");
+  const cachedInputTokens = getNumberProperty3(usage, "cachedInputTokens");
   if (cachedInputTokens !== void 0) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
     const anthropicMetadata = providerMetadata?.anthropic;
     if (anthropicMetadata) {
-      const cacheReadTokens = getNumberProperty2(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
-      const cacheCreationTokens = getNumberProperty2(
+      const cacheReadTokens = getNumberProperty3(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
+      const cacheCreationTokens = getNumberProperty3(
         anthropicMetadata.usage,
         "cache_creation_input_tokens"
       ) || 0;
@@ -26182,17 +28454,17 @@ function wrapGenkit(genkit) {
   console.warn("Unsupported Genkit object. Not wrapping.");
   return genkit;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isPropertyBag(value) {
-  return isRecord(value) || typeof value === "function";
+  return isRecord2(value) || typeof value === "function";
 }
 function hasFunction(value, methodName) {
   return isPropertyBag(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isGenkitInstance(value) {
-  return isRecord(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
+  return isRecord2(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
 }
 function isGenkitModule(value) {
   return hasFunction(value, "genkit");
@@ -26246,7 +28518,7 @@ function patchGenkitRegistry(instance) {
   patchGenkitRegistryConstructor(registry2);
 }
 function patchGenkitRegistryLookup(registry2) {
-  if (!isRecord(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
+  if (!isRecord2(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
     return;
   }
   const originalLookupAction = registry2.lookupAction;
@@ -26272,7 +28544,7 @@ function patchGenkitRegistryLookup(registry2) {
   }
 }
 function patchGenkitRegistryConstructor(registry2) {
-  if (!isRecord(registry2)) {
+  if (!isRecord2(registry2)) {
     return;
   }
   const constructor = registry2.constructor;
@@ -26288,7 +28560,7 @@ function patchGenkitRegistryConstructor(registry2) {
       configurable: true,
       value: (...args) => {
         const childRegistry = originalWithParent.apply(constructor, args);
-        if (args.some((arg) => isRecord(arg) && hasRegistryPatchedFlag(arg))) {
+        if (args.some((arg) => isRecord2(arg) && hasRegistryPatchedFlag(arg))) {
           patchGenkitRegistryLookup(childRegistry);
           patchGenkitRegistryConstructor(childRegistry);
         }
@@ -26387,7 +28659,7 @@ function hasRegistryConstructorPatchedFlag(value) {
   );
 }
 function isPromiseLike2(value) {
-  return isRecord(value) && "then" in value && typeof value.then === "function";
+  return isRecord2(value) && "then" in value && typeof value.then === "function";
 }
 
 // src/wrappers/huggingface.ts
@@ -26750,14 +29022,14 @@ function wrapMistral(mistral) {
   console.warn("Unsupported Mistral library. Not wrapping.");
   return mistral;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction3(value, methodName) {
-  return isRecord2(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord3(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedMistralClient(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return false;
   }
   return value.chat !== void 0 && hasChat(value.chat) || value.embeddings !== void 0 && hasEmbeddings(value.embeddings) || value.fim !== void 0 && hasFim(value.fim) || value.agents !== void 0 && hasAgents(value.agents) || value.classifiers !== void 0 && hasClassifiers(value.classifiers);
@@ -26941,14 +29213,14 @@ function wrapCohere(cohere) {
   return cohere;
 }
 var cohereProxyCache = /* @__PURE__ */ new WeakMap();
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction4(value, methodName) {
-  return isRecord3(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord4(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedCohereClient(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return false;
   }
   return hasFunction4(value, "chat") || hasFunction4(value, "chatStream") || hasFunction4(value, "embed") || hasFunction4(value, "rerank");
@@ -27008,20 +29280,20 @@ function wrapGroq(groq) {
   console.warn("Unsupported Groq library. Not wrapping.");
   return groq;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction5(value, methodName) {
-  return isRecord4(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord5(value) && methodName in value && typeof value[methodName] === "function";
 }
 function hasChat2(value) {
-  return isRecord4(value) && isRecord4(value.completions) && hasFunction5(value.completions, "create");
+  return isRecord5(value) && isRecord5(value.completions) && hasFunction5(value.completions, "create");
 }
 function hasEmbeddings2(value) {
   return hasFunction5(value, "create");
 }
 function isSupportedGroqClient(value) {
-  return isRecord4(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
+  return isRecord5(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
 }
 function groqProxy(groq) {
   const privateMethodWorkaroundCache = /* @__PURE__ */ new WeakMap();