braintrust 3.16.0 → 3.18.0

package/dist/edge-light.js

@@ -86,6 +86,7 @@ __export(edge_light_exports, {
   _internalIso: () => isomorph_default,
   _internalSetInitialState: () => _internalSetInitialState,
   addAzureBlobHeaders: () => addAzureBlobHeaders,
+  braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
   braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
@@ -179,6 +180,7 @@ __export(edge_light_exports, {
   wrapOpenAIv4: () => wrapOpenAIv4,
   wrapOpenRouter: () => wrapOpenRouter,
   wrapOpenRouterAgent: () => wrapOpenRouterAgent,
+  wrapPiCodingAgentSDK: () => wrapPiCodingAgentSDK,
   wrapTraced: () => wrapTraced,
   wrapVitest: () => wrapVitest
 });
@@ -5132,14 +5134,18 @@ function useTestBackgroundLogger() {
 function clearTestBackgroundLogger() {
   _internalGetGlobalState()?.setOverrideBgLogger(null);
 }
-function initTestExperiment(experimentName, projectName) {
+function initTestExperiment(experimentName, projectName, experimentFullInfo = {}) {
   setInitialTestState();
   const state = _internalGetGlobalState();
   const project = projectName ?? experimentName;
   const lazyMetadata = new LazyValue(
     async () => ({
       project: { id: project, name: project, fullInfo: {} },
-      experiment: { id: experimentName, name: experimentName, fullInfo: {} }
+      experiment: {
+        id: experimentName,
+        name: experimentName,
+        fullInfo: experimentFullInfo
+      }
     })
   );
   return new Experiment2(state, lazyMetadata);
@@ -8504,6 +8510,10 @@ var Experiment2 = class extends ObjectFetcher {
       return (await this.lazyMetadata.get()).project;
     })();
   }
+  async _getBaseExperimentId() {
+    const baseExperimentId = (await this.lazyMetadata.get()).experiment.fullInfo["base_exp_id"];
+    return typeof baseExperimentId === "string" && baseExperimentId ? baseExperimentId : void 0;
+  }
   parentObjectType() {
     return 1 /* EXPERIMENT */;
   }
@@ -8644,6 +8654,14 @@ var Experiment2 = class extends ObjectFetcher {
           comparisonExperimentId = baseExperiment.id;
           comparisonExperimentName = baseExperiment.name;
         }
+      } else {
+        try {
+          const comparisonExperiment = await state.apiConn().get_json(`v1/experiment/${comparisonExperimentId}`);
+          if (typeof comparisonExperiment["name"] === "string") {
+            comparisonExperimentName = comparisonExperiment["name"];
+          }
+        } catch {
+        }
       }
       try {
         const results = await state.apiConn().get_json(
@@ -10808,6 +10826,64 @@ var BasePlugin = class {
   }
 };
 
+// src/instrumentation/auto-instrumentation-suppression.ts
+var autoInstrumentationSuppressionStore;
+function suppressionStore() {
+  autoInstrumentationSuppressionStore ??= isomorph_default.newAsyncLocalStorage();
+  return autoInstrumentationSuppressionStore;
+}
+function currentFrames() {
+  return suppressionStore().getStore()?.frames ?? [];
+}
+function isAutoInstrumentationSuppressed() {
+  const frames = currentFrames();
+  return frames[frames.length - 1]?.mode === "suppress";
+}
+function runWithAutoInstrumentationSuppressed(callback) {
+  const frame = {
+    id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-suppress"),
+    mode: "suppress"
+  };
+  return suppressionStore().run(
+    { frames: [...currentFrames(), frame] },
+    callback
+  );
+}
+function bindAutoInstrumentationSuppressionToStart(tracingChannel2) {
+  const startChannel = tracingChannel2.start;
+  if (!startChannel) {
+    return void 0;
+  }
+  const store = suppressionStore();
+  startChannel.bindStore(store, () => ({
+    frames: [
+      ...currentFrames(),
+      {
+        id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-suppress"),
+        mode: "suppress"
+      }
+    ]
+  }));
+  return () => {
+    startChannel.unbindStore(store);
+  };
+}
+function enterAutoInstrumentationAllowed() {
+  const frame = {
+    id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-allow"),
+    mode: "allow"
+  };
+  suppressionStore().enterWith({
+    frames: [...currentFrames(), frame]
+  });
+  return () => {
+    const frames = currentFrames().filter(
+      (candidate) => candidate.id !== frame.id
+    );
+    suppressionStore().enterWith(frames.length > 0 ? { frames } : void 0);
+  };
+}
+
 // src/instrumentation/core/channel-tracing.ts
 function isSyncStreamLike(value) {
   return !!value && typeof value === "object" && typeof value.on === "function";
@@ -10839,16 +10915,33 @@ function startSpanForEvent(config, event, channelName) {
       metadata: mergeInputMetadata(metadata, spanInfoMetadata)
     });
   } catch (error) {
-    console.error(`Error extracting input for ${channelName}:`, error);
+    debugLogger.error(`Error extracting input for ${channelName}:`, error);
   }
   return { span, startTime };
 }
+function shouldTraceEvent(config, event, channelName) {
+  if (!config.shouldTrace) {
+    return true;
+  }
+  try {
+    return config.shouldTrace(event.arguments, event);
+  } catch (error) {
+    debugLogger.error(
+      `Error checking trace predicate for ${channelName}:`,
+      error
+    );
+    return true;
+  }
+}
 function ensureSpanStateForEvent(states, config, event, channelName) {
   const key = event;
   const existing = states.get(key);
   if (existing) {
     return existing;
   }
+  if (!shouldTraceEvent(config, event, channelName)) {
+    return void 0;
+  }
   const created = startSpanForEvent(config, event, channelName);
   states.set(key, created);
   return created;
@@ -10864,13 +10957,16 @@ function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelNam
   startChannel.bindStore(
     currentSpanStore,
     (event) => {
-      const span = ensureSpanStateForEvent(
+      if (isAutoInstrumentationSuppressed()) {
+        return currentSpanStore.getStore();
+      }
+      const spanState = ensureSpanStateForEvent(
         states,
         config,
         event,
         channelName
-      ).span;
-      return contextManager.wrapSpanForStore(span);
+      );
+      return spanState ? contextManager.wrapSpanForStore(spanState.span) : currentSpanStore.getStore();
     }
   );
   return () => {
@@ -10905,7 +11001,10 @@ function runStreamingCompletionHook(args) {
       startTime: args.startTime
     });
   } catch (error) {
-    console.error(`Error in onComplete hook for ${args.channelName}:`, error);
+    debugLogger.error(
+      `Error in onComplete hook for ${args.channelName}:`,
+      error
+    );
   }
 }
 function traceAsyncChannel(channel2, config) {
@@ -10920,6 +11019,9 @@ function traceAsyncChannel(channel2, config) {
   );
   const handlers = {
     start: (event) => {
+      if (isAutoInstrumentationSuppressed()) {
+        return;
+      }
       ensureSpanStateForEvent(
         states,
         config,
@@ -10954,7 +11056,7 @@ function traceAsyncChannel(channel2, config) {
           metrics
         });
       } catch (error) {
-        console.error(`Error extracting output for ${channelName}:`, error);
+        debugLogger.error(`Error extracting output for ${channelName}:`, error);
       } finally {
         span.end();
         states.delete(event);
@@ -10982,6 +11084,9 @@ function traceStreamingChannel(channel2, config) {
   );
   const handlers = {
     start: (event) => {
+      if (isAutoInstrumentationSuppressed()) {
+        return;
+      }
       ensureSpanStateForEvent(
         states,
         config,
@@ -11053,7 +11158,7 @@ function traceStreamingChannel(channel2, config) {
                 metrics
               });
             } catch (error) {
-              console.error(
+              debugLogger.error(
                 `Error extracting output for ${channelName}:`,
                 error
               );
@@ -11113,7 +11218,7 @@ function traceStreamingChannel(channel2, config) {
           metrics
         });
       } catch (error) {
-        console.error(`Error extracting output for ${channelName}:`, error);
+        debugLogger.error(`Error extracting output for ${channelName}:`, error);
       } finally {
         span.end();
         states.delete(event);
@@ -11141,6 +11246,9 @@ function traceSyncStreamChannel(channel2, config) {
   );
   const handlers = {
     start: (event) => {
+      if (isAutoInstrumentationSuppressed()) {
+        return;
+      }
       ensureSpanStateForEvent(
         states,
         config,
@@ -11194,7 +11302,7 @@ function traceSyncStreamChannel(channel2, config) {
               });
             }
           } catch (error) {
-            console.error(
+            debugLogger.error(
               `Error extracting chatCompletion for ${channelName}:`,
               error
             );
@@ -11218,7 +11326,10 @@ function traceSyncStreamChannel(channel2, config) {
               span.log(extracted);
             }
           } catch (error) {
-            console.error(`Error extracting event for ${channelName}:`, error);
+            debugLogger.error(
+              `Error extracting event for ${channelName}:`,
+              error
+            );
           }
         });
         stream.on("end", () => {
@@ -12747,6 +12858,9 @@ var AnthropicPlugin = class extends BasePlugin {
     const states = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        if (isAutoInstrumentationSuppressed()) {
+          return;
+        }
         const params = event.arguments[0] ?? {};
         const span = startSpan({
           name: "anthropic.beta.messages.toolRunner",
@@ -13476,6 +13590,520 @@ function serializeAISDKToolsForLogging(tools) {
   return serialized;
 }
 
+// src/wrappers/ai-sdk/telemetry.ts
+function braintrustAISDKTelemetry() {
+  const operations = /* @__PURE__ */ new Map();
+  const modelSpans = /* @__PURE__ */ new Map();
+  const objectSpans = /* @__PURE__ */ new Map();
+  const embedSpans = /* @__PURE__ */ new Map();
+  const rerankSpans = /* @__PURE__ */ new Map();
+  const toolSpans = /* @__PURE__ */ new Map();
+  const runSafely = (name, callback) => {
+    try {
+      callback();
+    } catch (error) {
+      console.error(`Error in Braintrust AI SDK telemetry ${name}:`, error);
+    }
+  };
+  const startChildSpan = (callId, name, type, event) => {
+    const parent = operations.get(callId)?.span;
+    const spanArgs = {
+      name,
+      spanAttributes: { type },
+      ...event ? { event } : {}
+    };
+    const span = parent ? parent.startSpan(spanArgs) : startSpan(spanArgs);
+    const state = operations.get(callId);
+    if (state && type === "llm" /* LLM */) {
+      state.hadModelChild = true;
+    }
+    return span;
+  };
+  return {
+    onStart(event) {
+      runSafely("onStart", () => {
+        const operationName = operationNameFromId(event.operationId);
+        const span = startSpan({
+          name: operationName,
+          spanAttributes: { type: "function" /* FUNCTION */ }
+        });
+        operations.set(event.callId, {
+          hadModelChild: false,
+          operationName,
+          span,
+          startTime: getCurrentUnixTimestamp()
+        });
+        const metadata = metadataFromEvent(event);
+        const logPayload = { metadata };
+        if (shouldRecordInputs(event)) {
+          const { input, outputPromise } = processAISDKCallInput(
+            operationInput(event, operationName)
+          );
+          logPayload.input = input;
+          if (outputPromise && input && typeof input === "object") {
+            outputPromise.then((resolvedData) => {
+              span.log({
+                input: {
+                  ...input,
+                  ...resolvedData
+                }
+              });
+            }).catch(() => {
+            });
+          }
+        }
+        span.log(logPayload);
+      });
+    },
+    onLanguageModelCallStart(event) {
+      runSafely("onLanguageModelCallStart", () => {
+        const state = operations.get(event.callId);
+        const openSpans = modelSpans.get(event.callId);
+        if (openSpans) {
+          for (const span2 of openSpans) {
+            span2.end();
+          }
+          modelSpans.delete(event.callId);
+        }
+        const span = startChildSpan(
+          event.callId,
+          state?.operationName === "streamText" ? "doStream" : "doGenerate",
+          "llm" /* LLM */,
+          {
+            ...shouldRecordInputs(event) ? {
+              input: processAISDKCallInput(
+                operationInput(
+                  event,
+                  state?.operationName ?? "generateText"
+                )
+              ).input
+            } : {},
+            metadata: metadataFromEvent(event)
+          }
+        );
+        const spans = modelSpans.get(event.callId) ?? [];
+        spans.push(span);
+        modelSpans.set(event.callId, spans);
+      });
+    },
+    onLanguageModelCallEnd(event) {
+      runSafely("onLanguageModelCallEnd", () => {
+        const span = shiftModelSpan(modelSpans, event.callId);
+        if (!span) {
+          return;
+        }
+        const result = {
+          ...event,
+          response: event.responseId ? { id: event.responseId } : void 0
+        };
+        span.log({
+          ...shouldRecordOutputs(event) ? {
+            output: processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS)
+          } : {},
+          metrics: extractTokenMetrics(result)
+        });
+        span.end();
+      });
+    },
+    onObjectStepStart(event) {
+      runSafely("onObjectStepStart", () => {
+        const state = operations.get(event.callId);
+        const openSpan = objectSpans.get(event.callId);
+        if (openSpan) {
+          openSpan.end();
+          objectSpans.delete(event.callId);
+        }
+        const span = startChildSpan(
+          event.callId,
+          state?.operationName === "streamObject" ? "doStream" : "doGenerate",
+          "llm" /* LLM */,
+          {
+            ...shouldRecordInputs(event) ? {
+              input: {
+                prompt: event.promptMessages
+              }
+            } : {},
+            metadata: metadataFromEvent(event)
+          }
+        );
+        objectSpans.set(event.callId, span);
+      });
+    },
+    onObjectStepFinish(event) {
+      runSafely("onObjectStepFinish", () => {
+        const span = objectSpans.get(event.callId);
+        if (!span) {
+          return;
+        }
+        const result = {
+          ...event,
+          text: event.objectText
+        };
+        span.log({
+          ...shouldRecordOutputs(event) ? {
+            output: processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS)
+          } : {},
+          metrics: extractTokenMetrics(result)
+        });
+        span.end();
+        objectSpans.delete(event.callId);
+      });
+    },
+    onEmbedStart(event) {
+      runSafely("onEmbedStart", () => {
+        const state = operations.get(event.callId);
+        for (const [embedCallId, embedState] of embedSpans) {
+          if (embedState.callId === event.callId && (state?.operationName === "embed" || embedState.values === event.values)) {
+            embedState.span.end();
+            embedSpans.delete(embedCallId);
+          }
+        }
+        const span = startChildSpan(
+          event.callId,
+          "doEmbed",
+          "llm" /* LLM */,
+          {
+            ...shouldRecordInputs(event) ? {
+              input: {
+                values: event.values
+              }
+            } : {},
+            metadata: metadataFromEvent(event)
+          }
+        );
+        embedSpans.set(event.embedCallId, {
+          callId: event.callId,
+          span,
+          values: event.values
+        });
+      });
+    },
+    onEmbedFinish(event) {
+      runSafely("onEmbedFinish", () => {
+        const state = embedSpans.get(event.embedCallId);
+        if (!state) {
+          return;
+        }
+        const result = {
+          ...event,
+          embeddings: event.embeddings
+        };
+        state.span.log({
+          ...shouldRecordOutputs(event) ? {
+            output: processAISDKEmbeddingOutput(
+              result,
+              DEFAULT_DENY_OUTPUT_PATHS
+            )
+          } : {},
+          metrics: extractTokenMetrics(result)
+        });
+        state.span.end();
+        embedSpans.delete(event.embedCallId);
+      });
+    },
+    onRerankStart(event) {
+      runSafely("onRerankStart", () => {
+        const openSpan = rerankSpans.get(event.callId);
+        if (openSpan) {
+          openSpan.end();
+          rerankSpans.delete(event.callId);
+        }
+        const span = startChildSpan(
+          event.callId,
+          "doRerank",
+          "llm" /* LLM */,
+          {
+            ...shouldRecordInputs(event) ? {
+              input: {
+                documents: event.documents,
+                query: event.query,
+                topN: event.topN
+              }
+            } : {},
+            metadata: metadataFromEvent(event)
+          }
+        );
+        rerankSpans.set(event.callId, span);
+      });
+    },
+    onRerankFinish(event) {
+      runSafely("onRerankFinish", () => {
+        const span = rerankSpans.get(event.callId);
+        if (!span) {
+          return;
+        }
+        const result = {
+          ranking: event.ranking?.map((entry) => ({
+            originalIndex: entry.index,
+            score: entry.relevanceScore
+          }))
+        };
+        span.log({
+          ...shouldRecordOutputs(event) ? {
+            output: processAISDKRerankOutput(
+              result,
+              DEFAULT_DENY_OUTPUT_PATHS
+            )
+          } : {}
+        });
+        span.end();
+        rerankSpans.delete(event.callId);
+      });
+    },
+    onToolExecutionStart(event) {
+      runSafely("onToolExecutionStart", () => {
+        const toolCallId = event.toolCall.toolCallId;
+        if (!toolCallId) {
+          return;
+        }
+        const span = startChildSpan(
+          event.callId,
+          event.toolCall.toolName || "tool",
+          "tool" /* TOOL */,
+          {
+            ...shouldRecordInputs(event) ? {
+              input: event.toolCall.input
+            } : {},
+            metadata: {
+              ...createAISDKIntegrationMetadata(),
+              toolCallId,
+              ...typeof event.toolCall.toolName === "string" ? { toolName: event.toolCall.toolName } : {}
+            }
+          }
+        );
+        toolSpans.set(toolCallId, { callId: event.callId, span });
+      });
+    },
+    onToolExecutionEnd(event) {
+      runSafely("onToolExecutionEnd", () => {
+        const toolCallId = event.toolCall.toolCallId;
+        const state = toolCallId ? toolSpans.get(toolCallId) : void 0;
+        if (!toolCallId || !state) {
+          return;
+        }
+        const toolOutput = event.toolOutput;
+        if (toolOutput?.type === "tool-error") {
+          state.span.log({
+            error: toolOutput.error instanceof Error ? toolOutput.error.message : String(toolOutput?.error),
+            metrics: typeof event.durationMs === "number" ? { duration_ms: event.durationMs } : {}
+          });
+        } else {
+          state.span.log({
+            ...shouldRecordOutputs(event) ? { output: toolOutput?.output } : {},
+            metrics: typeof event.durationMs === "number" ? { duration_ms: event.durationMs } : {}
+          });
+        }
+        state.span.end();
+        toolSpans.delete(toolCallId);
+      });
+    },
+    onChunk(event) {
+      runSafely("onChunk", () => {
+        const callId = event.chunk?.callId;
+        if (!callId) {
+          return;
+        }
+        const state = operations.get(callId);
+        if (!state || state.firstChunkTime !== void 0) {
+          return;
+        }
+        state.firstChunkTime = getCurrentUnixTimestamp();
+      });
+    },
+    onFinish(event) {
+      runSafely("onFinish", () => {
+        const state = operations.get(event.callId);
+        if (!state) {
+          return;
+        }
+        const result = finishResult(event, state.operationName);
+        const metrics = state.hadModelChild ? {} : extractTokenMetrics(result);
+        if (state.firstChunkTime !== void 0) {
+          metrics.time_to_first_token = state.firstChunkTime - state.startTime;
+        }
+        state.span.log({
+          ...shouldRecordOutputs(event) ? {
+            output: finishOutput(result, state.operationName)
+          } : {},
+          metrics
+        });
+        state.span.end();
+        operations.delete(event.callId);
+      });
+    },
+    onError(event) {
+      runSafely("onError", () => {
+        const errorEvent = isObject(event) ? event : {};
+        const callId = typeof errorEvent.callId === "string" ? errorEvent.callId : void 0;
+        if (!callId) {
+          return;
+        }
+        const state = operations.get(callId);
+        if (!state) {
+          return;
+        }
+        const error = errorEvent.error ?? event;
+        const openModelSpans = modelSpans.get(callId);
+        if (openModelSpans) {
+          for (const span of openModelSpans) {
+            logError(span, error);
+            span.end();
+          }
+          modelSpans.delete(callId);
+        }
+        const openObjectSpan = objectSpans.get(callId);
+        if (openObjectSpan) {
+          logError(openObjectSpan, error);
+          openObjectSpan.end();
+          objectSpans.delete(callId);
+        }
+        for (const [embedCallId, embedState] of embedSpans) {
+          if (embedState.callId === callId) {
+            logError(embedState.span, error);
+            embedState.span.end();
+            embedSpans.delete(embedCallId);
+          }
+        }
+        const openRerankSpan = rerankSpans.get(callId);
+        if (openRerankSpan) {
+          logError(openRerankSpan, error);
+          openRerankSpan.end();
+          rerankSpans.delete(callId);
+        }
+        for (const [toolCallId, toolState] of toolSpans) {
+          if (toolState.callId === callId) {
+            logError(toolState.span, error);
+            toolState.span.end();
+            toolSpans.delete(toolCallId);
+          }
+        }
+        logError(state.span, error);
+        state.span.end();
+        operations.delete(callId);
+      });
+    },
+    executeTool({ toolCallId, execute }) {
+      const state = toolSpans.get(toolCallId);
+      return state ? withCurrent(state.span, () => execute()) : execute();
+    }
+  };
+}
+function shouldRecordInputs(event) {
+  return event.recordInputs !== false;
+}
+function shouldRecordOutputs(event) {
+  return event.recordOutputs !== false;
+}
+function operationNameFromId(operationId) {
+  return operationId?.startsWith("ai.") ? operationId.slice("ai.".length) : operationId || "ai-sdk";
+}
+function modelFromEvent(event) {
+  return event.modelId ? {
+    modelId: event.modelId,
+    ...event.provider ? { provider: event.provider } : {}
+  } : void 0;
+}
+function metadataFromEvent(event) {
+  const metadata = createAISDKIntegrationMetadata();
+  const { model, provider } = serializeModelWithProvider(modelFromEvent(event));
+  if (model) {
+    metadata.model = model;
+  }
+  if (provider) {
+    metadata.provider = provider;
+  }
+  if (typeof event.functionId === "string") {
+    metadata.functionId = event.functionId;
+  }
+  return metadata;
+}
+function operationInput(event, operationName) {
+  if (operationName === "embed") {
+    return {
+      model: modelFromEvent(event),
+      value: event.value
+    };
+  }
+  if (operationName === "embedMany") {
+    return {
+      model: modelFromEvent(event),
+      values: Array.isArray(event.value) ? event.value ?? [] : void 0
+    };
+  }
+  if (operationName === "rerank") {
+    return {
+      model: modelFromEvent(event),
+      documents: event.documents,
+      query: event.query,
+      topN: event.topN
+    };
+  }
+  return {
+    model: modelFromEvent(event),
+    system: event.system,
+    prompt: event.prompt,
+    messages: event.messages,
+    tools: event.tools,
+    toolChoice: event.toolChoice,
+    activeTools: event.activeTools,
+    output: event.output,
+    schema: event.schema,
+    schemaName: event.schemaName,
+    schemaDescription: event.schemaDescription,
+    maxOutputTokens: event.maxOutputTokens,
+    temperature: event.temperature,
+    topP: event.topP,
+    topK: event.topK,
+    presencePenalty: event.presencePenalty,
+    frequencyPenalty: event.frequencyPenalty,
+    seed: event.seed,
+    maxRetries: event.maxRetries,
+    headers: event.headers,
+    providerOptions: event.providerOptions
+  };
+}
+function shiftModelSpan(modelSpans, callId) {
+  const spans = modelSpans.get(callId);
+  const span = spans?.shift();
+  if (spans && spans.length === 0) {
+    modelSpans.delete(callId);
+  }
+  return span;
+}
+function finishResult(event, operationName) {
+  if (operationName === "embed") {
+    return {
+      ...event,
+      embedding: event.embedding
+    };
+  }
+  if (operationName === "embedMany") {
+    return {
+      ...event,
+      embeddings: event.embedding
+    };
+  }
+  if (operationName === "rerank") {
+    return event;
+  }
+  return event;
+}
+function finishOutput(result, operationName) {
+  if (operationName === "embed" || operationName === "embedMany") {
+    return processAISDKEmbeddingOutput(
+      result,
+      DEFAULT_DENY_OUTPUT_PATHS
+    );
+  }
+  if (operationName === "rerank") {
+    return processAISDKRerankOutput(
+      result,
+      DEFAULT_DENY_OUTPUT_PATHS
+    );
+  }
+  return processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS);
+}
+
 // src/instrumentation/plugins/ai-sdk-channels.ts
 var aiSDKChannels = defineChannels("ai", {
   generateText: channel({
@@ -13535,6 +14163,10 @@ var aiSDKChannels = defineChannels("ai", {
   toolLoopAgentStream: channel({
     channelName: "ToolLoopAgent.stream",
     kind: "async"
+  }),
+  v7CreateTelemetryDispatcher: channel({
+    channelName: "createTelemetryDispatcher",
+    kind: "sync-stream"
   })
 });
 
@@ -13555,9 +14187,30 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
 ];
 var AUTO_PATCHED_MODEL = /* @__PURE__ */ Symbol.for("braintrust.ai-sdk.auto-patched-model");
 var AUTO_PATCHED_TOOL = /* @__PURE__ */ Symbol.for("braintrust.ai-sdk.auto-patched-tool");
+var AUTO_PATCHED_V7_TELEMETRY_DISPATCHER = /* @__PURE__ */ Symbol.for(
+  "braintrust.ai-sdk.v7.auto-patched-telemetry-dispatcher"
+);
 var RUNTIME_DENY_OUTPUT_PATHS = /* @__PURE__ */ Symbol.for(
   "braintrust.ai-sdk.deny-output-paths"
 );
+var AI_SDK_V7_TELEMETRY_CALLBACKS = [
+  "onStart",
+  "onStepStart",
+  "onLanguageModelCallStart",
+  "onLanguageModelCallEnd",
+  "onToolExecutionStart",
+  "onToolExecutionEnd",
+  "onChunk",
+  "onStepFinish",
+  "onObjectStepStart",
+  "onObjectStepFinish",
+  "onEmbedStart",
+  "onEmbedFinish",
+  "onRerankStart",
+  "onRerankFinish",
+  "onFinish",
+  "onError"
+];
 var AISDKPlugin = class extends BasePlugin {
   config;
   constructor(config = {}) {
@@ -13572,6 +14225,7 @@ var AISDKPlugin = class extends BasePlugin {
   }
   subscribeToAISDK() {
     const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
+    this.unsubscribers.push(subscribeToAISDKV7TelemetryDispatcher());
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.generateText, {
         name: "generateText",
@@ -13796,6 +14450,57 @@ var AISDKPlugin = class extends BasePlugin {
     );
   }
 };
+function subscribeToAISDKV7TelemetryDispatcher() {
+  const channel2 = aiSDKChannels.v7CreateTelemetryDispatcher.tracingChannel();
+  const telemetry = braintrustAISDKTelemetry();
+  const handlers = {
+    end: (event) => {
+      const telemetryOptions = event.arguments?.[0]?.telemetry;
+      if (telemetryOptions?.isEnabled === false) {
+        return;
+      }
+      patchAISDKV7TelemetryDispatcher(event.result, telemetry);
+    }
+  };
+  channel2.subscribe(handlers);
+  return () => {
+    channel2.unsubscribe(handlers);
+  };
+}
+function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry) {
+  if (!isObject(dispatcher)) {
+    return;
+  }
+  const dispatcherRecord = dispatcher;
+  if (dispatcherRecord[AUTO_PATCHED_V7_TELEMETRY_DISPATCHER]) {
+    return;
+  }
+  dispatcherRecord[AUTO_PATCHED_V7_TELEMETRY_DISPATCHER] = true;
+  for (const key of AI_SDK_V7_TELEMETRY_CALLBACKS) {
+    const braintrustCallback = telemetry[key];
+    if (typeof braintrustCallback !== "function") {
+      continue;
+    }
+    const existingCallback = dispatcherRecord[key];
+    dispatcherRecord[key] = (event) => {
+      const existingResult = typeof existingCallback === "function" ? existingCallback.call(dispatcher, event) : void 0;
+      const braintrustResult = braintrustCallback.call(telemetry, event);
+      const pending = [existingResult, braintrustResult].filter(isPromiseLike);
+      if (pending.length > 0) {
+        return Promise.allSettled(pending).then(() => void 0);
+      }
+    };
+  }
+  const braintrustExecuteTool = telemetry.executeTool;
+  if (typeof braintrustExecuteTool !== "function") {
+    return;
+  }
+  const existingExecuteTool = dispatcherRecord.executeTool;
+  dispatcherRecord.executeTool = (args) => braintrustExecuteTool.call(telemetry, {
+    ...args,
+    execute: () => typeof existingExecuteTool === "function" ? existingExecuteTool.call(dispatcher, args) : args.execute()
+  });
+}
 function resolveDenyOutputPaths(event, defaultDenyOutputPaths) {
   if (Array.isArray(event?.denyOutputPaths)) {
     return event.denyOutputPaths;
@@ -14247,11 +14952,11 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
             metadata: baseMetadata
           }
         });
+        const streamStartTime = getCurrentUnixTimestamp();
         const result = await withCurrent(
           span,
           () => Reflect.apply(originalDoStream, resolvedModel, [options])
         );
-        const streamStartTime = getCurrentUnixTimestamp();
         let firstChunkTime;
         const output = {};
         let text = "";
@@ -14260,7 +14965,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
         let object = void 0;
         const transformStream = new TransformStream({
           transform(chunk, controller) {
-            if (firstChunkTime === void 0) {
+            if (firstChunkTime === void 0 && isAISDKContentStreamChunk(chunk)) {
               firstChunkTime = getCurrentUnixTimestamp();
             }
             switch (chunk.type) {
@@ -14452,6 +15157,78 @@ function finalizeAISDKChildTracing(event) {
     delete event.__braintrust_ai_sdk_cleanup;
   }
 }
+function extractAISDKStreamPart(chunk) {
+  if (!isObject(chunk) || !isObject(chunk.part)) {
+    return chunk;
+  }
+  return chunk.part;
+}
+function stringContent(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function rawValueHasAISDKContent(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (!isObject(value)) {
+    return true;
+  }
+  const delta = value.delta;
+  if (stringContent(value.content) || stringContent(value.text) || stringContent(value.delta) || stringContent(value.arguments) || stringContent(value.partial_json) || isObject(delta) && (stringContent(delta.content) || stringContent(delta.text) || stringContent(delta.arguments) || stringContent(delta.partial_json) || stringContent(delta.thinking)) || Array.isArray(value.choices) && value.choices.some((choice) => {
+    if (!isObject(choice) || !isObject(choice.delta)) {
+      return false;
+    }
+    const choiceDelta = choice.delta;
+    if (stringContent(choiceDelta.content) || stringContent(choiceDelta.text)) {
+      return true;
+    }
+    if (isObject(choiceDelta.function_call) && stringContent(choiceDelta.function_call.arguments)) {
+      return true;
+    }
+    return Array.isArray(choiceDelta.tool_calls) && choiceDelta.tool_calls.some(
+      (toolCall) => isObject(toolCall) && isObject(toolCall.function) && stringContent(toolCall.function.arguments)
+    );
+  })) {
+    return true;
+  }
+  return false;
+}
+function isAISDKContentStreamChunk(chunk) {
+  const part = extractAISDKStreamPart(chunk);
+  if (typeof part === "string") {
+    return part.length > 0;
+  }
+  if (!isObject(part) || typeof part.type !== "string") {
+    return false;
+  }
+  switch (part.type) {
+    case "text-delta":
+      return stringContent(part.textDelta) !== void 0 || stringContent(part.delta) !== void 0 || stringContent(part.text) !== void 0 || stringContent(part.content) !== void 0;
+    case "reasoning-delta":
+      return stringContent(part.delta) !== void 0 || stringContent(part.text) !== void 0 || stringContent(part.content) !== void 0;
+    case "tool-call":
+    case "object":
+    case "file":
+      return true;
+    case "tool-input-delta":
+    case "tool-call-delta":
+      return stringContent(part.argsTextDelta) !== void 0 || stringContent(part.inputTextDelta) !== void 0 || stringContent(part.delta) !== void 0 || stringContent(part.text) !== void 0 || stringContent(part.content) !== void 0;
+    case "raw":
+      return rawValueHasAISDKContent(part.rawValue);
+    default:
+      return false;
+  }
+}
+function isAISDKContentAsyncIterableChunk(chunk) {
+  if (isAISDKContentStreamChunk(chunk)) {
+    return true;
+  }
+  const part = extractAISDKStreamPart(chunk);
+  return isObject(part) && typeof part.type !== "string";
+}
 function patchAISDKStreamingResult(args) {
   const { defaultDenyOutputPaths, endEvent, result, span, startTime } = args;
   if (!result || typeof result !== "object") {
@@ -14464,7 +15241,7 @@ function patchAISDKStreamingResult(args) {
     const wrappedBaseStream = resultRecord.baseStream.pipeThrough(
       new TransformStream({
         transform(chunk, controller) {
-          if (firstChunkTime2 === void 0) {
+          if (firstChunkTime2 === void 0 && isAISDKContentStreamChunk(chunk)) {
             firstChunkTime2 = getCurrentUnixTimestamp();
           }
           controller.enqueue(chunk);
@@ -14508,8 +15285,8 @@ function patchAISDKStreamingResult(args) {
   }
   let firstChunkTime;
   const wrappedStream = createPatchedAsyncIterable(streamField.stream, {
-    onChunk: () => {
-      if (firstChunkTime === void 0) {
+    onChunk: (chunk) => {
+      if (firstChunkTime === void 0 && isAISDKContentAsyncIterableChunk(chunk)) {
         firstChunkTime = getCurrentUnixTimestamp();
       }
     },
@@ -15481,15 +16258,17 @@ function collectLocalMcpServerToolHookNames(serverName, serverConfig) {
 
 // src/instrumentation/plugins/claude-agent-sdk-plugin.ts
 var ROOT_LLM_PARENT_KEY = "__root__";
+var SUB_AGENT_PROMPT_SOURCE_PRIORITY = {
+  delegation: 0,
+  lifecycle: 1,
+  sidechain: 2
+};
 function llmParentKey(parentToolUseId) {
   return parentToolUseId ?? ROOT_LLM_PARENT_KEY;
 }
 function isSubAgentDelegationToolName(toolName) {
   return toolName === "Agent" || toolName === "Task";
 }
-function shouldParentToolAsTaskSibling(toolName) {
-  return toolName === "Agent" || toolName === "Task" || toolName === "Bash";
-}
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -15626,26 +16405,39 @@ function extractUsageFromMessage(message) {
   }
   return metrics;
 }
-function buildLLMInput(prompt, conversationHistory, capturedPromptMessages) {
-  const promptMessages = [];
-  if (typeof prompt === "string") {
-    promptMessages.push({ content: prompt, role: "user" });
-  } else if (capturedPromptMessages && capturedPromptMessages.length > 0) {
-    for (const msg of capturedPromptMessages) {
-      const role = msg.message?.role;
-      const content = msg.message?.content;
-      if (role && content !== void 0) {
-        promptMessages.push({ content, role });
-      }
-    }
-  }
+function buildLLMInput(promptMessages, conversationHistory) {
   const inputParts = [...promptMessages, ...conversationHistory];
   return inputParts.length > 0 ? inputParts : void 0;
 }
+function conversationMessageFromSDKMessage(message) {
+  const role = message.message?.role;
+  const content = message.message?.content;
+  if (role && content !== void 0) {
+    return { content, role };
+  }
+  return void 0;
+}
+function messageContentHasBlockType(message, blockType) {
+  const content = message.message?.content;
+  return Array.isArray(content) && content.some(
+    (block) => typeof block === "object" && block !== null && "type" in block && block.type === blockType
+  );
+}
+function buildRootPromptMessages(prompt, capturedPromptMessages) {
+  if (typeof prompt === "string") {
+    return [{ content: prompt, role: "user" }];
+  }
+  if (!capturedPromptMessages || capturedPromptMessages.length === 0) {
+    return [];
+  }
+  return capturedPromptMessages.map(conversationMessageFromSDKMessage).filter(
+    (message) => message !== void 0
+  );
+}
 function formatCapturedMessages(messages) {
   return messages.length > 0 ? messages : [];
 }
-async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, capturedPromptMessages, parentSpan, existingSpan) {
+async function createLLMSpanForMessages(messages, promptMessages, conversationHistory, options, startTime, parentSpan, existingSpan) {
   if (messages.length === 0) {
     return void 0;
   }
@@ -15655,11 +16447,7 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
   }
   const model = lastMessage.message.model || options.model;
   const usage = extractUsageFromMessage(lastMessage);
-  const input = buildLLMInput(
-    prompt,
-    conversationHistory,
-    capturedPromptMessages
-  );
+  const input = buildLLMInput(promptMessages, conversationHistory);
   const outputs = messages.map(
     (m) => m.message?.content && m.message?.role ? { content: m.message.content, role: m.message.role } : void 0
   ).filter(
@@ -15790,8 +16578,7 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
       },
       name: parsed.displayName,
       parent: await resolveParentSpan(toolUseID, {
-        agentId: input.agent_id,
-        preferTaskSiblingParent: shouldParentToolAsTaskSibling(parsed.toolName)
+        agentId: input.agent_id
       }),
       spanAttributes: { type: "tool" /* TOOL */ }
     });
@@ -16037,12 +16824,37 @@ function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localTo
     }
   };
 }
+function setSubAgentPromptMessages(state, parentToolUseId, promptMessages, source) {
+  if (promptMessages.length === 0) {
+    return;
+  }
+  const parentKey = llmParentKey(parentToolUseId);
+  const sourcePriority = SUB_AGENT_PROMPT_SOURCE_PRIORITY[source];
+  const currentPriority = state.promptSourcePriorityByParentKey.get(parentKey) ?? -1;
+  if (sourcePriority > currentPriority) {
+    state.promptMessagesByParentKey.set(parentKey, promptMessages);
+    state.promptSourcePriorityByParentKey.set(parentKey, sourcePriority);
+  }
+}
+function getConversationHistory(state, parentKey) {
+  let conversationHistory = state.conversationHistoryByParentKey.get(parentKey);
+  if (!conversationHistory) {
+    conversationHistory = [];
+    state.conversationHistoryByParentKey.set(parentKey, conversationHistory);
+  }
+  return conversationHistory;
+}
 async function finalizeCurrentMessageGroup(state) {
   if (state.currentMessages.length === 0) {
     return;
   }
   const parentToolUseId = state.currentMessages[0]?.parent_tool_use_id ?? null;
   const parentKey = llmParentKey(parentToolUseId);
+  const conversationHistory = getConversationHistory(state, parentKey);
+  const promptMessages = parentToolUseId ? state.promptMessagesByParentKey.get(parentKey) ?? [] : buildRootPromptMessages(
+    state.originalPrompt,
+    state.capturedPromptMessages
+  );
   let parentSpan = await state.span.export();
   if (parentToolUseId) {
     const subAgentSpan = state.subAgentSpans.get(parentToolUseId);
@@ -16053,11 +16865,10 @@ async function finalizeCurrentMessageGroup(state) {
   const existingLlmSpan = state.activeLlmSpansByParentToolUse.get(parentKey);
   const llmSpanResult = await createLLMSpanForMessages(
     state.currentMessages,
-    state.originalPrompt,
-    state.finalResults,
+    promptMessages,
+    conversationHistory,
     state.options,
     state.currentMessageStartTime,
-    state.capturedPromptMessages,
     parentSpan,
     existingLlmSpan
   );
@@ -16071,6 +16882,7 @@ async function finalizeCurrentMessageGroup(state) {
       state.latestRootLlmParentRef.value = llmSpanResult.spanExport;
     }
     if (llmSpanResult.finalMessage) {
+      conversationHistory.push(llmSpanResult.finalMessage);
       state.finalResults.push(llmSpanResult.finalMessage);
     }
   }
@@ -16098,6 +16910,15 @@ function maybeTrackToolUseContext(state, message) {
         description: getStringProperty(block.input, "description"),
         toolUseId: block.id
       });
+      const prompt = getStringProperty(block.input, "prompt");
+      if (prompt) {
+        setSubAgentPromptMessages(
+          state,
+          block.id,
+          [{ content: prompt, role: "user" }],
+          "delegation"
+        );
+      }
     }
   }
 }
@@ -16216,6 +17037,14 @@ async function maybeHandleTaskLifecycleMessage(state, message) {
   };
   if (message.subtype === "task_started") {
     const prompt = getStringProperty(message, "prompt");
+    if (prompt) {
+      setSubAgentPromptMessages(
+        state,
+        toolUseId,
+        [{ content: prompt, role: "user" }],
+        "lifecycle"
+      );
+    }
     subAgentSpan.log({
       input: prompt,
       metadata
@@ -16266,6 +17095,28 @@ async function handleStreamMessage(state, message) {
     return;
   }
   await maybeStartSubAgentSpan(state, message);
+  const messageParentToolUseId = message.parent_tool_use_id;
+  if (messageParentToolUseId && message.type === "user") {
+    const conversationMessage = conversationMessageFromSDKMessage(message);
+    if (conversationMessage?.role === "user") {
+      await finalizeCurrentMessageGroup(state);
+      const parentKey = llmParentKey(messageParentToolUseId);
+      const conversationHistory = getConversationHistory(state, parentKey);
+      const currentPromptSourcePriority = state.promptSourcePriorityByParentKey.get(parentKey) ?? -1;
+      const canUseAsInitialSidechainPrompt = conversationHistory.length === 0 && currentPromptSourcePriority < SUB_AGENT_PROMPT_SOURCE_PRIORITY.sidechain && !messageContentHasBlockType(message, "tool_result");
+      if (!canUseAsInitialSidechainPrompt) {
+        conversationHistory.push(conversationMessage);
+        return;
+      }
+      setSubAgentPromptMessages(
+        state,
+        messageParentToolUseId,
+        [conversationMessage],
+        "sidechain"
+      );
+      return;
+    }
+  }
   const messageId = message.message?.id;
   if (messageId && messageId !== state.currentMessageId) {
     await finalizeCurrentMessageGroup(state);
@@ -16417,6 +17268,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         }
         const activeToolSpans = /* @__PURE__ */ new Map();
         const activeLlmSpansByParentToolUse = /* @__PURE__ */ new Map();
+        const conversationHistoryByParentKey = /* @__PURE__ */ new Map();
         const subAgentSpans = /* @__PURE__ */ new Map();
         const endedSubAgentSpans = /* @__PURE__ */ new Set();
         const toolUseToParent = /* @__PURE__ */ new Map();
@@ -16426,6 +17278,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         };
         const subAgentDetailsByToolUseId = /* @__PURE__ */ new Map();
         const taskIdToToolUseId = /* @__PURE__ */ new Map();
+        const promptMessagesByParentKey = /* @__PURE__ */ new Map();
+        const promptSourcePriorityByParentKey = /* @__PURE__ */ new Map();
         const localToolContext = createClaudeLocalToolContext();
         const { hasLocalToolHandlers, localToolHookNames } = prepareLocalToolHandlersInMcpServers(options.mcpServers);
         const skipLocalToolHooks = options[CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION] === true || hasLocalToolHandlers;
@@ -16434,38 +17288,19 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           const parentToolUseId = trackedParentToolUseId ?? (context?.agentId ? taskIdToToolUseId.get(context.agentId) ?? null : null);
           const parentKey = llmParentKey(parentToolUseId);
           const activeLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
-          if (context?.preferTaskSiblingParent) {
-            if (!activeLlmSpan) {
-              await ensureActiveLlmSpanForParentToolUse(
-                span,
-                activeLlmSpansByParentToolUse,
-                subAgentDetailsByToolUseId,
-                activeToolSpans,
-                subAgentSpans,
-                parentToolUseId,
-                getCurrentUnixTimestamp()
-              );
-            }
-            if (parentToolUseId) {
-              const subAgentSpan = await ensureSubAgentSpan(
-                subAgentDetailsByToolUseId,
-                span,
-                activeToolSpans,
-                subAgentSpans,
-                parentToolUseId
-              );
-              return subAgentSpan.export();
-            }
-            return span.export();
-          }
-          if (activeLlmSpan) {
-            return activeLlmSpan.export();
+          const latestLlmParent = parentToolUseId ? latestLlmParentBySubAgentToolUse.get(parentToolUseId) : latestRootLlmParentRef.value;
+          if (!activeLlmSpan && !latestLlmParent) {
+            await ensureActiveLlmSpanForParentToolUse(
+              span,
+              activeLlmSpansByParentToolUse,
+              subAgentDetailsByToolUseId,
+              activeToolSpans,
+              subAgentSpans,
+              parentToolUseId,
+              getCurrentUnixTimestamp()
+            );
           }
           if (parentToolUseId) {
-            const parentLlm = latestLlmParentBySubAgentToolUse.get(parentToolUseId);
-            if (parentLlm) {
-              return parentLlm;
-            }
             const subAgentSpan = await ensureSubAgentSpan(
               subAgentDetailsByToolUseId,
               span,
@@ -16475,9 +17310,6 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
             );
             return subAgentSpan.export();
           }
-          if (latestRootLlmParentRef.value) {
-            return latestRootLlmParentRef.value;
-          }
           return span.export();
         };
         localToolContext.resolveLocalToolParent = resolveToolUseParentSpan;
@@ -16498,6 +17330,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           accumulatedOutputTokens: 0,
           activeLlmSpansByParentToolUse,
           activeToolSpans,
+          conversationHistoryByParentKey,
           capturedPromptMessages,
           currentMessageId: void 0,
           currentMessageStartTime: startTime,
@@ -16508,7 +17341,9 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           originalPrompt,
           processing: Promise.resolve(),
           promptDone,
+          promptMessagesByParentKey,
           promptStarted: () => promptStarted,
+          promptSourcePriorityByParentKey,
           span,
           subAgentDetailsByToolUseId,
           subAgentSpans,
@@ -17937,6 +18772,10 @@ var googleGenAIChannels = defineChannels("@google/genai", {
   embedContent: channel({
     channelName: "models.embedContent",
     kind: "async"
+  }),
+  interactionsCreate: channel({
+    channelName: "interactions.create",
+    kind: "async"
   })
 });
 
@@ -17964,6 +18803,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     this.subscribeToGenerateContentChannel();
     this.subscribeToGenerateContentStreamChannel();
     this.subscribeToEmbedContentChannel();
+    this.subscribeToInteractionsCreateChannel();
   }
   subscribeToGenerateContentChannel() {
     const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
@@ -18136,7 +18976,30 @@ var GoogleGenAIPlugin = class extends BasePlugin {
       tracingChannel2.unsubscribe(handlers);
     });
   }
+  subscribeToInteractionsCreateChannel() {
+    this.unsubscribers.push(
+      traceStreamingChannel(
+        googleGenAIChannels.interactionsCreate,
+        {
+          name: "create_interaction",
+          shouldTrace: ([params]) => !isBackgroundInteractionCreate(params),
+          type: "llm" /* LLM */,
+          extractInput: ([params]) => ({
+            input: serializeInteractionInput(params),
+            metadata: extractInteractionMetadata(params)
+          }),
+          extractOutput: (result) => serializeInteractionValue(result),
+          extractMetadata: (result) => extractInteractionResponseMetadata(result),
+          extractMetrics: (result, startTime) => cleanMetrics3(extractInteractionMetrics(result, startTime)),
+          aggregateChunks: (chunks, _result, _event, startTime) => aggregateInteractionEvents(chunks, startTime)
+        }
+      )
+    );
+  }
 };
+function isBackgroundInteractionCreate(params) {
+  return tryToDict(params)?.background === true;
+}
 function ensureSpanState(states, event, create) {
   const existing = states.get(event);
   if (existing) {
@@ -18344,6 +19207,60 @@ function serializeEmbedContentInput(params) {
   }
   return input;
 }
+function serializeInteractionInput(params) {
+  const input = {
+    input: serializeInteractionValue(params.input)
+  };
+  for (const key of [
+    "model",
+    "agent",
+    "agent_config",
+    "api_version",
+    "background",
+    "environment",
+    "generation_config",
+    "previous_interaction_id",
+    "response_format",
+    "response_mime_type",
+    "response_modalities",
+    "service_tier",
+    "store",
+    "stream",
+    "system_instruction",
+    "webhook_config"
+  ]) {
+    const value = params[key];
+    if (value !== void 0) {
+      input[key] = serializeInteractionValue(value);
+    }
+  }
+  return input;
+}
+function extractInteractionMetadata(params) {
+  const metadata = {};
+  for (const key of [
+    "model",
+    "agent",
+    "agent_config",
+    "generation_config",
+    "system_instruction",
+    "response_format",
+    "response_mime_type",
+    "response_modalities",
+    "service_tier"
+  ]) {
+    const value = params[key];
+    if (value !== void 0) {
+      metadata[key] = serializeInteractionValue(value);
+    }
+  }
+  if (Array.isArray(params.tools)) {
+    metadata.tools = params.tools.map(
+      (tool) => serializeInteractionValue(tool)
+    );
+  }
+  return metadata;
+}
 function serializeContentCollection(contents) {
   if (contents === null || contents === void 0) {
     return null;
@@ -18374,21 +19291,8 @@ function serializePart(part) {
   }
   if (part.inlineData && part.inlineData.data) {
     const { data, mimeType } = part.inlineData;
-    if (data instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(data) || typeof data === "string") {
-      const extension = mimeType ? mimeType.split("/")[1] : "bin";
-      const filename = `file.${extension}`;
-      const buffer = typeof data === "string" ? typeof Buffer !== "undefined" ? Buffer.from(data, "base64") : new Uint8Array(
-        atob(data).split("").map((c) => c.charCodeAt(0))
-      ) : typeof Buffer !== "undefined" ? Buffer.from(data) : new Uint8Array(data);
-      const arrayBuffer = buffer instanceof Uint8Array ? buffer.buffer.slice(
-        buffer.byteOffset,
-        buffer.byteOffset + buffer.byteLength
-      ) : buffer;
-      const attachment = new Attachment({
-        data: arrayBuffer,
-        filename,
-        contentType: mimeType || "application/octet-stream"
-      });
+    const attachment = createAttachmentFromInlineData(data, mimeType);
+    if (attachment) {
       return {
         image_url: { url: attachment }
       };
@@ -18396,6 +19300,59 @@ function serializePart(part) {
   }
   return part;
 }
+function serializeInteractionValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || value === void 0 || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeInteractionValue(item, seen));
+  }
+  const dict = tryToDict(value);
+  if (dict === null || dict === void 0 || typeof dict !== "object") {
+    return dict;
+  }
+  if (Array.isArray(dict)) {
+    return dict.map((item) => serializeInteractionValue(item, seen));
+  }
+  if (seen.has(dict)) {
+    return "[Circular]";
+  }
+  seen.add(dict);
+  try {
+    const serialized = {};
+    const mimeType = "mime_type" in dict && typeof dict.mime_type === "string" ? dict.mime_type : "mimeType" in dict && typeof dict.mimeType === "string" ? dict.mimeType : void 0;
+    const attachment = mimeType && "data" in dict && dict.data !== void 0 ? createAttachmentFromInlineData(dict.data, mimeType) : null;
+    for (const [key, entry] of Object.entries(dict)) {
+      if (key === "data" && attachment) {
+        serialized[key] = attachment;
+      } else {
+        serialized[key] = serializeInteractionValue(entry, seen);
+      }
+    }
+    return serialized;
+  } finally {
+    seen.delete(dict);
+  }
+}
+function createAttachmentFromInlineData(data, mimeType) {
+  if (!(data instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(data) || typeof data === "string")) {
+    return null;
+  }
+  const extension = mimeType ? mimeType.split("/")[1] : "bin";
+  const filename = `file.${extension}`;
+  const buffer = typeof data === "string" ? typeof Buffer !== "undefined" ? Buffer.from(data, "base64") : new Uint8Array(
+    atob(data).split("").map((c) => c.charCodeAt(0))
+  ) : typeof Buffer !== "undefined" ? Buffer.from(data) : new Uint8Array(data);
+  const arrayBuffer = buffer instanceof Uint8Array ? buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength
+  ) : buffer;
+  return new Attachment({
+    data: arrayBuffer,
+    filename,
+    contentType: mimeType || "application/octet-stream"
+  });
+}
 function serializeGenerateContentTools(params) {
   const config = params.config ? tryToDict(params.config) : null;
   const tools = config?.tools;
@@ -18480,6 +19437,33 @@ function extractEmbedContentMetrics(response, startTime) {
   }
   return metrics;
 }
+function extractInteractionMetrics(response, startTime) {
+  const metrics = {};
+  if (startTime !== void 0) {
+    const end = getCurrentUnixTimestamp();
+    metrics.start = startTime;
+    metrics.end = end;
+    metrics.duration = end - startTime;
+  }
+  if (response?.usage) {
+    populateInteractionUsageMetrics(metrics, response.usage);
+  }
+  return metrics;
+}
+function extractInteractionResponseMetadata(response) {
+  const responseDict = tryToDict(response);
+  if (!responseDict) {
+    return void 0;
+  }
+  const metadata = {};
+  if (typeof responseDict.id === "string") {
+    metadata.interaction_id = responseDict.id;
+  }
+  if (typeof responseDict.status === "string") {
+    metadata.status = responseDict.status;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
 function extractEmbedPromptTokenCount(response) {
   if (!response) {
     return void 0;
@@ -18542,6 +19526,23 @@ function populateUsageMetrics(metrics, usage) {
     metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
   }
 }
+function populateInteractionUsageMetrics(metrics, usage) {
+  if (typeof usage.total_input_tokens === "number") {
+    metrics.prompt_tokens = usage.total_input_tokens;
+  }
+  if (typeof usage.total_output_tokens === "number") {
+    metrics.completion_tokens = usage.total_output_tokens;
+  }
+  if (typeof usage.total_tokens === "number") {
+    metrics.tokens = usage.total_tokens;
+  }
+  if (typeof usage.total_cached_tokens === "number") {
+    metrics.prompt_cached_tokens = usage.total_cached_tokens;
+  }
+  if (typeof usage.total_thought_tokens === "number") {
+    metrics.completion_reasoning_tokens = usage.total_thought_tokens;
+  }
+}
 function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
   const end = getCurrentUnixTimestamp();
   const metrics = {
@@ -18639,6 +19640,146 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
   }
   return { aggregated, metrics };
 }
+function aggregateInteractionEvents(chunks, startTime) {
+  const end = getCurrentUnixTimestamp();
+  const metrics = {};
+  if (startTime !== void 0) {
+    metrics.start = startTime;
+    metrics.end = end;
+    metrics.duration = end - startTime;
+  }
+  let latestInteraction;
+  let latestUsage;
+  let status;
+  let outputText = "";
+  const steps = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const event = tryToDict(chunk);
+    if (!event) {
+      continue;
+    }
+    const usage = extractInteractionUsageFromEvent(event);
+    if (usage) {
+      latestUsage = usage;
+    }
+    const interaction = tryToDict(event.interaction);
+    if (interaction) {
+      latestInteraction = serializeInteractionValue(interaction);
+      if (typeof interaction.status === "string") {
+        status = interaction.status;
+      }
+    }
+    if (typeof event.status === "string") {
+      status = event.status;
+    }
+    const index = typeof event.index === "number" ? event.index : void 0;
+    if (index === void 0) {
+      continue;
+    }
+    if (event.event_type === "step.start") {
+      const compact = compactInteractionStep(event.step);
+      compact.index = index;
+      steps.set(index, compact);
+      continue;
+    }
+    if (event.event_type === "step.delta") {
+      const step = steps.get(index) ?? { index };
+      const textDelta = applyInteractionDelta(step, event.delta);
+      if (textDelta) {
+        outputText += textDelta;
+      }
+      steps.set(index, step);
+    }
+  }
+  if (latestUsage) {
+    populateInteractionUsageMetrics(metrics, latestUsage);
+  }
+  const output = latestInteraction ? { ...latestInteraction } : {};
+  if (status) {
+    output.status = status;
+  }
+  if (outputText) {
+    output.output_text = outputText;
+  }
+  if (latestUsage) {
+    output.usage = serializeInteractionValue(latestUsage);
+  }
+  const compactSteps = Array.from(steps.values()).sort(
+    (left, right) => Number(left.index ?? 0) - Number(right.index ?? 0)
+  );
+  if (compactSteps.length > 0) {
+    output.steps = compactSteps;
+  }
+  const metadata = {};
+  if (typeof output.id === "string") {
+    metadata.interaction_id = output.id;
+  }
+  if (typeof output.status === "string") {
+    metadata.status = output.status;
+  }
+  return {
+    output,
+    metrics: cleanMetrics3(metrics),
+    ...Object.keys(metadata).length > 0 ? { metadata } : {}
+  };
+}
+function extractInteractionUsageFromEvent(event) {
+  const metadata = tryToDict(event.metadata);
+  const metadataUsage = tryToDict(metadata?.usage);
+  if (metadataUsage) {
+    return metadataUsage;
+  }
+  const metadataTotalUsage = tryToDict(metadata?.total_usage);
+  if (metadataTotalUsage) {
+    return metadataTotalUsage;
+  }
+  const interaction = tryToDict(event.interaction);
+  const interactionUsage = tryToDict(interaction?.usage);
+  return interactionUsage ? interactionUsage : void 0;
+}
+function compactInteractionStep(step) {
+  const stepDict = tryToDict(step);
+  if (!stepDict) {
+    return {};
+  }
+  const compact = {};
+  for (const key of [
+    "type",
+    "content",
+    "name",
+    "server_name",
+    "arguments",
+    "result",
+    "is_error"
+  ]) {
+    if (stepDict[key] !== void 0) {
+      compact[key] = serializeInteractionValue(stepDict[key]);
+    }
+  }
+  return Object.keys(compact).length > 0 ? compact : serializeInteractionValue(stepDict);
+}
+function applyInteractionDelta(step, delta) {
+  const deltaDict = tryToDict(delta);
+  if (!deltaDict) {
+    return void 0;
+  }
+  const deltaType = deltaDict.type;
+  if (typeof deltaType === "string" && typeof step.type !== "string") {
+    step.type = deltaType === "text" ? "model_output" : deltaType;
+  }
+  if (deltaType === "text" && typeof deltaDict.text === "string") {
+    step.text = `${typeof step.text === "string" ? step.text : ""}${deltaDict.text}`;
+    return deltaDict.text;
+  }
+  if (deltaType === "arguments_delta" && typeof deltaDict.arguments === "string") {
+    step.arguments = `${typeof step.arguments === "string" ? step.arguments : ""}${deltaDict.arguments}`;
+    return void 0;
+  }
+  const deltas = Array.isArray(step.deltas) ? step.deltas : [];
+  deltas.push(serializeInteractionValue(deltaDict));
+  step.deltas = deltas;
+  return void 0;
+}
 function cleanMetrics3(metrics) {
   const cleaned = {};
   for (const [key, value] of Object.entries(metrics)) {
@@ -24465,7 +25606,8 @@ var FlueObserveBridge = class {
         metadata
       }
     });
-    this.runsById.set(event.runId, { metadata, span });
+    const activeContext = enterCurrentFlueSpan(span);
+    this.runsById.set(event.runId, { activeContext, metadata, span });
   }
   handleRunEnd(event) {
     const state = this.runsById.get(event.runId);
@@ -24483,6 +25625,7 @@ var FlueObserveBridge = class {
       });
       safeEnd(state.span, eventTime(event.timestamp));
       this.runsById.delete(event.runId);
+      restoreCurrentFlueSpan(state.activeContext);
     }
     void flush().catch((error) => {
       logInstrumentationError3("Flue flush", error);
@@ -24609,7 +25752,8 @@ var FlueObserveBridge = class {
         metadata
       }
     });
-    this.toolsByKey.set(toolKey(event), { metadata, span });
+    const activeContext = enterCurrentFlueSpan(span);
+    this.toolsByKey.set(toolKey(event), { activeContext, metadata, span });
   }
   handleToolCall(event) {
     if (!event.toolCallId) {
@@ -24632,6 +25776,7 @@ var FlueObserveBridge = class {
     });
     safeEnd(state.span, eventTime(event.timestamp));
     this.toolsByKey.delete(key);
+    restoreCurrentFlueSpan(state.activeContext);
   }
   handleTaskStart(event) {
     if (!event.taskId) {
@@ -25036,6 +26181,34 @@ function stateMatchesRun(state, runId) {
 function startFlueSpan(parent, args) {
   return parent ? withCurrent(parent, () => startSpan(args)) : startSpan(args);
 }
+function enterCurrentFlueSpan(span) {
+  const contextManager = _internalGetGlobalState()?.contextManager;
+  const store = contextManager ? Reflect.get(contextManager, BRAINTRUST_CURRENT_SPAN_STORE) : void 0;
+  if (!contextManager || !isCurrentSpanStore(store)) {
+    return void 0;
+  }
+  const previous = store.getStore();
+  try {
+    store.enterWith(contextManager.wrapSpanForStore(span));
+    return { previous, store };
+  } catch (error) {
+    logInstrumentationError3("Flue context propagation", error);
+    return void 0;
+  }
+}
+function isCurrentSpanStore(value) {
+  return isObjectLike(value) && typeof Reflect.get(value, "enterWith") === "function" && typeof Reflect.get(value, "getStore") === "function";
+}
+function restoreCurrentFlueSpan(activeContext) {
+  if (!activeContext) {
+    return;
+  }
+  try {
+    activeContext.store.enterWith(activeContext.previous);
+  } catch (error) {
+    logInstrumentationError3("Flue context restoration", error);
+  }
+}
 function safeLog3(span, event) {
   try {
     span.log(event);
@@ -25513,6 +26686,890 @@ function isBraintrustHandler(handler) {
   return Reflect.get(handler, "name") === BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
 }
 
+// src/instrumentation/plugins/pi-coding-agent-channels.ts
+var piCodingAgentChannels = defineChannels(
+  "@earendil-works/pi-coding-agent",
+  {
+    prompt: channel({
+      channelName: "AgentSession.prompt",
+      kind: "async"
+    })
+  }
+);
+
+// src/instrumentation/plugins/pi-coding-agent-plugin.ts
+var piStreamPatchStates = /* @__PURE__ */ new WeakMap();
+var piPromptContextStore;
+var PiCodingAgentPlugin = class extends BasePlugin {
+  activePromptStates = /* @__PURE__ */ new Set();
+  onEnable() {
+    this.subscribeToPrompt();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    for (const state of [...this.activePromptStates]) {
+      void finalizePiPromptRun(state).catch((error) => {
+        logInstrumentationError4("Pi Coding Agent disable cleanup", error);
+      });
+    }
+  }
+  subscribeToPrompt() {
+    const channel2 = piCodingAgentChannels.prompt.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(channel2);
+    const handlers = {
+      start: (event) => {
+        const state = startPiPromptRun(event, (state2) => {
+          this.activePromptStates.delete(state2);
+        });
+        if (state) {
+          this.activePromptStates.add(state);
+          states.set(event, state);
+        }
+      },
+      asyncEnd: async (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        states.delete(event);
+        state.promptCallEnded = true;
+        if (!state.finalized && state.deferCompletionUntilTurnEnd && !state.turnEnded) {
+          if (!state.sawStreamFn) {
+            state.queued = true;
+            if (!state.streamPatchState.queuedPromptStates.includes(state)) {
+              state.streamPatchState.queuedPromptStates.push(state);
+            }
+          }
+          return;
+        }
+        await finalizePiPromptRun(state);
+      },
+      error: async (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        states.delete(event);
+        await finalizePiPromptRun(state, event.error);
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindAutoInstrumentationSuppression?.();
+      channel2.unsubscribe(handlers);
+    });
+  }
+};
+function startPiPromptRun(event, onFinalize) {
+  const session = extractSession(event);
+  const agent = session?.agent;
+  if (!session || !isPiAgent(agent)) {
+    return void 0;
+  }
+  const metadata = {
+    ...extractSessionMetadata(session),
+    ...extractPromptOptionsMetadata(event.arguments[1]),
+    "pi_coding_agent.operation": "AgentSession.prompt",
+    provider: session.model?.provider ?? agent.state?.model?.provider ?? "pi",
+    ...session.model?.id || agent.state?.model?.id ? { model: session.model?.id ?? agent.state?.model?.id } : {},
+    ...event.moduleVersion ? { "pi_coding_agent.version": event.moduleVersion } : {}
+  };
+  const span = startSpan({
+    event: {
+      input: extractPromptInput(event.arguments[0], event.arguments[1]),
+      metadata
+    },
+    name: "AgentSession.prompt",
+    spanAttributes: { type: "task" /* TASK */ }
+  });
+  const streamPatchState = installPiStreamPatch(agent);
+  const options = event.arguments[1];
+  const promptText = event.arguments[0];
+  const state = {
+    activeLlmSpans: /* @__PURE__ */ new Set(),
+    activeToolSpans: /* @__PURE__ */ new Map(),
+    agent,
+    collectedLlmUsageMetrics: false,
+    deferCompletionUntilTurnEnd: options?.streamingBehavior === "followUp" || options?.streamingBehavior === "steer",
+    finalized: false,
+    metadata,
+    metrics: {},
+    onFinalize,
+    promptCallEnded: false,
+    ...typeof promptText === "string" ? { promptText } : {},
+    queued: false,
+    span,
+    sawStreamFn: false,
+    startTime: getCurrentUnixTimestamp(),
+    streamPatchState,
+    turnEnded: false
+  };
+  state.restorePromptContext = enterPiPromptContext(state);
+  streamPatchState.activePromptStates.add(state);
+  try {
+    state.unsubscribeAgent = agent.subscribe(async (agentEvent) => {
+      try {
+        await runWithAutoInstrumentationSuppressed(
+          () => handlePiAgentEvent(state, agentEvent)
+        );
+      } catch (error) {
+        logInstrumentationError4("Pi Coding Agent event", error);
+      }
+    });
+  } catch (error) {
+    logInstrumentationError4("Pi Coding Agent event subscription", error);
+  }
+  return state;
+}
+function extractSession(event) {
+  const candidate = event.session ?? event.self;
+  return isObject(candidate) && typeof candidate.prompt === "function" ? candidate : void 0;
+}
+function isPiAgent(value) {
+  return isObject(value) && typeof value.streamFn === "function" && typeof value.subscribe === "function";
+}
+function promptContextStore() {
+  piPromptContextStore ??= isomorph_default.newAsyncLocalStorage();
+  return piPromptContextStore;
+}
+function currentPromptContextFrames() {
+  return promptContextStore().getStore()?.frames ?? [];
+}
+function currentPiPromptState() {
+  const frames = currentPromptContextFrames();
+  return frames[frames.length - 1]?.state;
+}
+function enterPiPromptContext(state) {
+  const frame = {
+    id: /* @__PURE__ */ Symbol("braintrust.pi-coding-agent.prompt"),
+    state
+  };
+  promptContextStore().enterWith({
+    frames: [...currentPromptContextFrames(), frame]
+  });
+  return () => {
+    const frames = currentPromptContextFrames().filter(
+      (candidate) => candidate.id !== frame.id
+    );
+    promptContextStore().enterWith(frames.length > 0 ? { frames } : void 0);
+  };
+}
+function installPiStreamPatch(agent) {
+  const existing = piStreamPatchStates.get(agent);
+  if (existing) {
+    if (agent.streamFn !== existing.wrappedStreamFn) {
+      debugLogger.debug(
+        "Pi Coding Agent streamFn changed while Braintrust instrumentation was active; preserving existing patch state."
+      );
+    }
+    return existing;
+  }
+  const patchState = {
+    activePromptStates: /* @__PURE__ */ new Set(),
+    agent,
+    originalStreamFn: agent.streamFn,
+    queuedPromptStates: [],
+    wrappedStreamFn: agent.streamFn
+  };
+  patchState.wrappedStreamFn = makeSharedInstrumentedStreamFn(patchState);
+  agent.streamFn = patchState.wrappedStreamFn;
+  piStreamPatchStates.set(agent, patchState);
+  return patchState;
+}
+function resolveStreamPromptState(patchState, context) {
+  let lastUserText;
+  if (Array.isArray(context.messages)) {
+    for (let i = context.messages.length - 1; i >= 0; i--) {
+      const message = context.messages[i];
+      if (isPiUserMessage(message)) {
+        if (typeof message.content === "string") {
+          lastUserText = message.content;
+        } else {
+          lastUserText = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+        }
+        break;
+      }
+    }
+  }
+  if (lastUserText !== void 0) {
+    const queuedMatch = patchState.queuedPromptStates.find(
+      (state) => state.promptText === lastUserText
+    );
+    if (queuedMatch) {
+      return queuedMatch;
+    }
+    const matches = [...patchState.activePromptStates].filter(
+      (state) => state.promptText === lastUserText
+    );
+    if (matches.length === 1) {
+      return matches[0];
+    }
+  }
+  const contextState = currentPiPromptState();
+  if (contextState && patchState.activePromptStates.has(contextState) && (!contextState.queued || lastUserText !== void 0 && contextState.promptText === lastUserText)) {
+    return contextState;
+  }
+  if (patchState.activePromptStates.size === 1) {
+    return [...patchState.activePromptStates][0];
+  }
+  return void 0;
+}
+function makeSharedInstrumentedStreamFn(patchState) {
+  return async function instrumentedPiStreamFn(model, context, options) {
+    const state = resolveStreamPromptState(patchState, context);
+    if (!state) {
+      const invokeOriginal = () => Reflect.apply(patchState.originalStreamFn, this, [
+        model,
+        context,
+        options
+      ]);
+      return patchState.activePromptStates.size > 0 ? runWithAutoInstrumentationSuppressed(invokeOriginal) : invokeOriginal();
+    }
+    state.sawStreamFn = true;
+    removeQueuedPromptState(state);
+    state.streamPatchState.eventPromptState = state;
+    const llmState = await startPiLlmSpan(state, model, context, options);
+    try {
+      const stream = await runWithAutoInstrumentationSuppressed(
+        () => Reflect.apply(patchState.originalStreamFn, this, [
+          model,
+          context,
+          options
+        ])
+      );
+      return patchAssistantMessageStream(stream, state, llmState);
+    } catch (error) {
+      finishPiLlmSpan(state, llmState, void 0, error);
+      throw error;
+    }
+  };
+}
+async function startPiLlmSpan(state, model, context, options) {
+  const metadata = {
+    ...extractModelMetadata2(model),
+    ...extractStreamOptionsMetadata(options),
+    ...extractToolMetadata(context.tools),
+    "pi_coding_agent.operation": "agent.streamFn"
+  };
+  const span = startSpan({
+    event: {
+      input: processInputAttachments(normalizePiContextInput(context)),
+      metadata
+    },
+    name: getLlmSpanName(model),
+    parent: await state.span.export(),
+    spanAttributes: { type: "llm" /* LLM */ }
+  });
+  const llmState = {
+    finalized: false,
+    metadata,
+    metrics: {},
+    span,
+    startTime: getCurrentUnixTimestamp()
+  };
+  state.activeLlmSpans.add(llmState);
+  return llmState;
+}
+function patchAssistantMessageStream(stream, promptState, llmState) {
+  if (!isObject(stream)) {
+    return stream;
+  }
+  const streamRecord = stream;
+  const originalResult = stream.result;
+  if (typeof originalResult === "function") {
+    streamRecord.result = function patchedPiResult() {
+      return Promise.resolve(Reflect.apply(originalResult, this, [])).then(
+        (message) => {
+          finishPiLlmSpan(promptState, llmState, message);
+          return message;
+        },
+        (error) => {
+          finishPiLlmSpan(promptState, llmState, void 0, error);
+          throw error;
+        }
+      );
+    };
+  }
+  const originalIterator = stream[Symbol.asyncIterator];
+  if (typeof originalIterator === "function") {
+    streamRecord[Symbol.asyncIterator] = function patchedPiIterator() {
+      const iterator = Reflect.apply(
+        originalIterator,
+        this,
+        []
+      );
+      return {
+        async next() {
+          try {
+            const result = await iterator.next();
+            if (result.done) {
+              finishPiLlmSpan(promptState, llmState);
+              return result;
+            }
+            recordPiAssistantMessageEvent(promptState, llmState, result.value);
+            return result;
+          } catch (error) {
+            finishPiLlmSpan(promptState, llmState, void 0, error);
+            if (typeof iterator.return === "function") {
+              try {
+                await iterator.return();
+              } catch (cleanupError) {
+                logInstrumentationError4(
+                  "Pi Coding Agent stream cleanup",
+                  cleanupError
+                );
+              }
+            }
+            throw error;
+          }
+        },
+        async return(value) {
+          try {
+            if (typeof iterator.return === "function") {
+              return await iterator.return(value);
+            }
+            return {
+              done: true,
+              value
+            };
+          } catch (error) {
+            finishPiLlmSpan(promptState, llmState, void 0, error);
+            throw error;
+          } finally {
+            finishPiLlmSpan(promptState, llmState);
+          }
+        },
+        async throw(error) {
+          try {
+            if (typeof iterator.throw === "function") {
+              return await iterator.throw(error);
+            }
+            throw error;
+          } catch (thrownError) {
+            finishPiLlmSpan(promptState, llmState, void 0, thrownError);
+            throw thrownError;
+          }
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    };
+  }
+  return stream;
+}
+function recordPiAssistantMessageEvent(promptState, llmState, event) {
+  recordFirstTokenMetric(llmState, event);
+  const message = "message" in event ? event.message : void 0;
+  const errorMessage2 = "error" in event ? event.error : void 0;
+  if (event.type === "done" && isPiAssistantMessage(message)) {
+    finishPiLlmSpan(promptState, llmState, message);
+  } else if (event.type === "error" && isPiAssistantMessage(errorMessage2)) {
+    finishPiLlmSpan(promptState, llmState, errorMessage2);
+  }
+}
+function recordFirstTokenMetric(state, event) {
+  if (state.metrics.time_to_first_token !== void 0 || event.type === "start") {
+    return;
+  }
+  state.metrics.time_to_first_token = getCurrentUnixTimestamp() - state.startTime;
+}
+async function handlePiAgentEvent(state, event) {
+  if (state.finalized) {
+    return;
+  }
+  const eventPromptState = state.streamPatchState.eventPromptState;
+  if (eventPromptState && eventPromptState !== state) {
+    return;
+  }
+  if (!eventPromptState && (state.queued || state.streamPatchState.activePromptStates.size > 1 && currentPiPromptState() !== state)) {
+    return;
+  }
+  switch (event.type) {
+    case "message_end":
+      if (isPiAssistantMessage(event.message)) {
+        state.output = extractAssistantOutput(event.message);
+      }
+      return;
+    case "turn_end":
+      state.turnEnded = true;
+      if (isPiAssistantMessage(event.message)) {
+        state.output = extractAssistantOutput(event.message);
+        if (!state.collectedLlmUsageMetrics) {
+          addMetrics(state.metrics, extractUsageMetrics2(event.message.usage));
+        }
+      }
+      if (state.streamPatchState.eventPromptState === state) {
+        state.streamPatchState.eventPromptState = void 0;
+      }
+      if (state.promptCallEnded && state.deferCompletionUntilTurnEnd) {
+        await finalizePiPromptRun(state);
+      }
+      return;
+    case "tool_execution_start":
+      await startPiToolSpan(state, event);
+      return;
+    case "tool_execution_end":
+      finishPiToolSpan(state, event);
+      return;
+    default:
+      return;
+  }
+}
+async function startPiToolSpan(state, event) {
+  if (!event.toolCallId || state.activeToolSpans.has(event.toolCallId)) {
+    return;
+  }
+  const restoreAutoInstrumentation = enterAutoInstrumentationAllowed();
+  const metadata = {
+    "gen_ai.tool.call.id": event.toolCallId,
+    "gen_ai.tool.name": event.toolName,
+    "pi_coding_agent.tool.name": event.toolName
+  };
+  try {
+    const span = startSpan({
+      event: {
+        input: event.args,
+        metadata
+      },
+      name: event.toolName || "tool",
+      parent: await state.span.export(),
+      spanAttributes: { type: "tool" /* TOOL */ }
+    });
+    state.activeToolSpans.set(event.toolCallId, {
+      restoreAutoInstrumentation,
+      span
+    });
+  } catch (error) {
+    restoreAutoInstrumentation();
+    throw error;
+  }
+}
+function finishPiToolSpan(state, event) {
+  const toolState = state.activeToolSpans.get(event.toolCallId);
+  if (!toolState) {
+    return;
+  }
+  state.activeToolSpans.delete(event.toolCallId);
+  const metadata = {
+    "gen_ai.tool.call.id": event.toolCallId,
+    "gen_ai.tool.name": event.toolName,
+    "pi_coding_agent.tool.name": event.toolName,
+    "pi_coding_agent.tool.is_error": event.isError
+  };
+  try {
+    safeLog4(toolState.span, {
+      ...event.isError ? { error: stringifyUnknown2(event.result) } : {},
+      metadata,
+      output: event.result
+    });
+  } finally {
+    try {
+      toolState.span.end();
+    } finally {
+      toolState.restoreAutoInstrumentation?.();
+    }
+  }
+}
+async function finalizePiPromptRun(state, error) {
+  if (state.finalized) {
+    return;
+  }
+  state.finalized = true;
+  state.onFinalize?.(state);
+  restorePiStreamFn(state);
+  try {
+    state.unsubscribeAgent?.();
+  } catch (unsubscribeError) {
+    logInstrumentationError4("Pi Coding Agent unsubscribe", unsubscribeError);
+  }
+  await finishOpenLlmSpans(state, error);
+  finishOpenToolSpans(state, error);
+  const metadata = {
+    ...state.metadata,
+    ...extractModelMetadata2(state.agent.state?.model)
+  };
+  try {
+    safeLog4(state.span, {
+      ...error ? { error: stringifyUnknown2(error) } : {},
+      metadata,
+      metrics: {
+        ...cleanMetrics5(state.metrics),
+        ...buildDurationMetrics3(state.startTime)
+      },
+      output: state.output
+    });
+  } finally {
+    state.span.end();
+  }
+}
+function restorePiStreamFn(state) {
+  const patchState = state.streamPatchState;
+  patchState.activePromptStates.delete(state);
+  removeQueuedPromptState(state);
+  if (patchState.eventPromptState === state) {
+    patchState.eventPromptState = void 0;
+  }
+  state.restorePromptContext?.();
+  if (patchState.activePromptStates.size > 0) {
+    return;
+  }
+  if (patchState.agent.streamFn === patchState.wrappedStreamFn) {
+    patchState.agent.streamFn = patchState.originalStreamFn;
+  }
+  piStreamPatchStates.delete(patchState.agent);
+}
+function removeQueuedPromptState(state) {
+  state.queued = false;
+  const queuedPromptStates = state.streamPatchState.queuedPromptStates;
+  const index = queuedPromptStates.indexOf(state);
+  if (index >= 0) {
+    queuedPromptStates.splice(index, 1);
+  }
+}
+async function finishOpenLlmSpans(state, error) {
+  for (const llmState of [...state.activeLlmSpans]) {
+    finishPiLlmSpan(state, llmState, void 0, error);
+  }
+}
+function finishPiLlmSpan(promptState, llmState, message, error) {
+  if (llmState.finalized) {
+    return;
+  }
+  llmState.finalized = true;
+  promptState.activeLlmSpans.delete(llmState);
+  const messageError = message?.stopReason === "error" && message.errorMessage;
+  const metrics = {
+    ...extractUsageMetrics2(message?.usage),
+    ...cleanMetrics5(llmState.metrics),
+    ...buildDurationMetrics3(llmState.startTime)
+  };
+  const usageMetrics = extractUsageMetrics2(message?.usage);
+  if (Object.keys(usageMetrics).length > 0) {
+    promptState.collectedLlmUsageMetrics = true;
+    addMetrics(promptState.metrics, usageMetrics);
+  }
+  try {
+    safeLog4(llmState.span, {
+      ...error || messageError ? { error: stringifyUnknown2(error ?? messageError) } : {},
+      metadata: {
+        ...llmState.metadata,
+        ...message ? extractAssistantMetadata(message) : {}
+      },
+      metrics,
+      ...message ? { output: extractAssistantOutput(message) } : {}
+    });
+  } finally {
+    llmState.span.end();
+  }
+}
+function finishOpenToolSpans(state, error) {
+  for (const [, toolState] of state.activeToolSpans) {
+    try {
+      safeLog4(toolState.span, {
+        error: error ? stringifyUnknown2(error) : "Pi tool did not complete"
+      });
+      toolState.span.end();
+    } finally {
+      toolState.restoreAutoInstrumentation?.();
+    }
+  }
+  state.activeToolSpans.clear();
+}
+function normalizePiContextInput(context) {
+  const messages = context.messages.flatMap(
+    (message) => normalizePiMessage(message)
+  );
+  if (context.systemPrompt) {
+    return [{ role: "system", content: context.systemPrompt }, ...messages];
+  }
+  return messages;
+}
+function normalizePiMessage(message) {
+  if (isPiUserMessage(message)) {
+    return [
+      {
+        role: "user",
+        content: normalizeUserContent(message.content)
+      }
+    ];
+  }
+  if (isPiAssistantMessage(message)) {
+    return [normalizeAssistantMessage(message)];
+  }
+  if (isPiToolResultMessage(message)) {
+    return [normalizeToolResultMessage(message)];
+  }
+  return [];
+}
+function normalizeAssistantMessage(message) {
+  const text = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+  const thinking = message.content.flatMap(
+    (part) => part.type === "thinking" && !part.redacted ? [part.thinking] : []
+  ).join("");
+  const toolCalls = message.content.flatMap(
+    (part) => part.type === "toolCall" ? [normalizeToolCall(part)] : []
+  );
+  return {
+    role: "assistant",
+    content: text || (toolCalls.length > 0 ? null : ""),
+    ...thinking ? { reasoning: thinking } : {},
+    ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+  };
+}
+function normalizeToolResultMessage(message) {
+  return {
+    role: "tool",
+    tool_call_id: message.toolCallId,
+    content: normalizeUserContent(message.content)
+  };
+}
+function normalizeUserContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return { type: "text", text: part.text };
+    }
+    if (part.type === "image") {
+      return {
+        type: "image_url",
+        image_url: {
+          url: `data:${part.mimeType};base64,${part.data}`
+        }
+      };
+    }
+    return part;
+  });
+}
+function normalizeToolCall(toolCall) {
+  return {
+    id: toolCall.id,
+    type: "function",
+    function: {
+      name: toolCall.name,
+      arguments: stringifyArguments(toolCall.arguments)
+    }
+  };
+}
+function extractAssistantOutput(message) {
+  return processInputAttachments([
+    {
+      finish_reason: normalizeStopReason(message.stopReason),
+      index: 0,
+      message: normalizeAssistantMessage(message)
+    }
+  ]);
+}
+function isPiUserMessage(message) {
+  return message.role === "user" && "content" in message;
+}
+function isPiAssistantMessage(message) {
+  return isObject(message) && message.role === "assistant" && Array.isArray(message.content);
+}
+function isPiToolResultMessage(message) {
+  return message.role === "toolResult" && Array.isArray(message.content);
+}
+function normalizeStopReason(reason) {
+  switch (reason) {
+    case "toolUse":
+      return "tool_calls";
+    case "length":
+    case "stop":
+      return reason;
+    default:
+      return reason ?? "stop";
+  }
+}
+function extractPromptInput(text, options) {
+  const images = options?.images;
+  if (!images || images.length === 0) {
+    return text;
+  }
+  return processInputAttachments([
+    {
+      role: "user",
+      content: [
+        { type: "text", text: text ?? "" },
+        ...images.map((image) => ({
+          type: "image_url",
+          image_url: {
+            url: `data:${image.mimeType};base64,${image.data}`
+          }
+        }))
+      ]
+    }
+  ]);
+}
+function extractToolMetadata(tools) {
+  if (!tools || tools.length === 0) {
+    return {};
+  }
+  return {
+    tools: tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        ...tool.description ? { description: tool.description } : {},
+        ...tool.parameters ? { parameters: tool.parameters } : {}
+      }
+    }))
+  };
+}
+function extractModelMetadata2(model) {
+  if (!model) {
+    return {};
+  }
+  return {
+    ...model.provider ? { provider: model.provider } : {},
+    ...model.id ? { model: model.id, "pi_coding_agent.model": model.id } : {},
+    ...model.api ? { "pi_coding_agent.api": model.api } : {},
+    ...model.name ? { "pi_coding_agent.model_name": model.name } : {}
+  };
+}
+function extractAssistantMetadata(message) {
+  return {
+    ...message.provider ? { provider: message.provider } : {},
+    ...message.responseModel || message.model ? { model: message.responseModel ?? message.model } : {},
+    ...message.api ? { "pi_coding_agent.api": message.api } : {},
+    ...message.model ? { "pi_coding_agent.model": message.model } : {},
+    ...message.responseModel ? { "pi_coding_agent.response_model": message.responseModel } : {},
+    ...message.responseId ? { "pi_coding_agent.response_id": message.responseId } : {},
+    ...message.stopReason ? { "pi_coding_agent.stop_reason": message.stopReason } : {}
+  };
+}
+function extractSessionMetadata(session) {
+  return {
+    ...extractModelMetadata2(session.model),
+    ...session.sessionId ? { "pi_coding_agent.session_id": session.sessionId } : {},
+    ...session.sessionName ? { "pi_coding_agent.session_name": session.sessionName } : {},
+    ...session.thinkingLevel ? { "pi_coding_agent.thinking_level": session.thinkingLevel } : {},
+    ...typeof session.getActiveToolNames === "function" ? { "pi_coding_agent.active_tools": session.getActiveToolNames() } : {}
+  };
+}
+function extractPromptOptionsMetadata(options) {
+  if (!options) {
+    return {};
+  }
+  return {
+    ...options.source ? { "pi_coding_agent.source": options.source } : {},
+    ...options.streamingBehavior ? { "pi_coding_agent.streaming_behavior": options.streamingBehavior } : {},
+    ...options.expandPromptTemplates !== void 0 ? {
+      "pi_coding_agent.expand_prompt_templates": options.expandPromptTemplates
+    } : {}
+  };
+}
+function extractStreamOptionsMetadata(options) {
+  if (!options) {
+    return {};
+  }
+  return {
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    ...options.maxTokens !== void 0 ? { max_tokens: options.maxTokens } : {},
+    ...options.reasoning ? { "pi_coding_agent.reasoning": options.reasoning } : {},
+    ...options.transport ? { "pi_coding_agent.transport": options.transport } : {},
+    ...options.cacheRetention ? { "pi_coding_agent.cache_retention": options.cacheRetention } : {},
+    ...options.sessionId ? { "pi_coding_agent.session_id": options.sessionId } : {},
+    ...options.timeoutMs !== void 0 ? { "pi_coding_agent.timeout_ms": options.timeoutMs } : {},
+    ...options.maxRetries !== void 0 ? { "pi_coding_agent.max_retries": options.maxRetries } : {},
+    ...options.maxRetryDelayMs !== void 0 ? { "pi_coding_agent.max_retry_delay_ms": options.maxRetryDelayMs } : {},
+    ...options.metadata ? { "pi_coding_agent.metadata": options.metadata } : {}
+  };
+}
+function getLlmSpanName(model) {
+  switch (model.api) {
+    case "anthropic-messages":
+      return "anthropic.messages.create";
+    case "openai-completions":
+      return "Chat Completion";
+    case "openai-responses":
+    case "azure-openai-responses":
+    case "openai-codex-responses":
+      return "openai.responses.create";
+    case "google-generative-ai":
+    case "google-vertex":
+      return "generate_content";
+    case "mistral-conversations":
+      return "mistral.chat.stream";
+    case "bedrock-converse-stream":
+      return "bedrock.converse_stream";
+    default:
+      return "pi_ai.streamSimple";
+  }
+}
+function extractUsageMetrics2(usage) {
+  if (!usage) {
+    return {};
+  }
+  return cleanMetrics5({
+    completion_tokens: usage.output,
+    prompt_cache_creation_tokens: usage.cacheWrite,
+    prompt_cached_tokens: usage.cacheRead,
+    prompt_tokens: usage.input,
+    tokens: usage.totalTokens ?? usage.tokens
+  });
+}
+function addMetrics(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    target[key] = (target[key] ?? 0) + value;
+  }
+}
+function buildDurationMetrics3(startTime) {
+  const end = getCurrentUnixTimestamp();
+  return {
+    duration: end - startTime,
+    end,
+    start: startTime
+  };
+}
+function cleanMetrics5(metrics) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(metrics)) {
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function stringifyArguments(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return stringifyUnknown2(value);
+  }
+}
+function stringifyUnknown2(value) {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function safeLog4(span, event) {
+  try {
+    span.log(event);
+  } catch (error) {
+    logInstrumentationError4("Pi Coding Agent span log", error);
+  }
+}
+function logInstrumentationError4(context, error) {
+  debugLogger.debug(`${context}:`, error);
+}
+
 // src/instrumentation/braintrust-plugin.ts
 function getIntegrationConfig(integrations, key) {
   return integrations[key];
@@ -25538,6 +27595,7 @@ var BraintrustPlugin = class extends BasePlugin {
   gitHubCopilotPlugin = null;
   fluePlugin = null;
   langChainPlugin = null;
+  piCodingAgentPlugin = null;
   constructor(config = {}) {
     super();
     this.config = config;
@@ -25612,6 +27670,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.gitHubCopilotPlugin = new GitHubCopilotPlugin();
       this.gitHubCopilotPlugin.enable();
     }
+    if (integrations.piCodingAgent !== false) {
+      this.piCodingAgentPlugin = new PiCodingAgentPlugin();
+      this.piCodingAgentPlugin.enable();
+    }
     if (getIntegrationConfig(integrations, "flue") !== false) {
       this.fluePlugin = new FluePlugin();
       this.fluePlugin.enable();
@@ -25690,6 +27752,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.gitHubCopilotPlugin.disable();
       this.gitHubCopilotPlugin = null;
     }
+    if (this.piCodingAgentPlugin) {
+      this.piCodingAgentPlugin.disable();
+      this.piCodingAgentPlugin = null;
+    }
     if (this.fluePlugin) {
       this.fluePlugin.disable();
       this.fluePlugin = null;
@@ -25709,6 +27775,11 @@ var envIntegrationAliases = {
   openaicodexsdk: "openaiCodexSDK",
   codex: "openaiCodexSDK",
   "codex-sdk": "openaiCodexSDK",
+  "pi-coding-agent": "piCodingAgent",
+  "pi-coding-agent-sdk": "piCodingAgent",
+  picodingagent: "piCodingAgent",
+  picodingagentsdk: "piCodingAgent",
+  "@earendil-works/pi-coding-agent": "piCodingAgent",
   anthropic: "anthropic",
   aisdk: "aisdk",
   "ai-sdk": "aisdk",
@@ -25774,7 +27845,8 @@ function getDefaultInstrumentationIntegrations() {
     genkit: true,
     gitHubCopilot: true,
     langchain: true,
-    langgraph: true
+    langgraph: true,
+    piCodingAgent: true
   };
 }
 function readDisabledInstrumentationEnvConfig(disabledList) {
@@ -25985,6 +28057,7 @@ __export(exports_exports, {
   _internalIso: () => isomorph_default,
   _internalSetInitialState: () => _internalSetInitialState,
   addAzureBlobHeaders: () => addAzureBlobHeaders,
+  braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
   braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
@@ -26077,6 +28150,7 @@ __export(exports_exports, {
   wrapOpenAIv4: () => wrapOpenAIv4,
   wrapOpenRouter: () => wrapOpenRouter,
   wrapOpenRouterAgent: () => wrapOpenRouterAgent,
+  wrapPiCodingAgentSDK: () => wrapPiCodingAgentSDK,
   wrapTraced: () => wrapTraced,
   wrapVitest: () => wrapVitest
 });
@@ -28137,6 +30211,54 @@ function wrapCursorAgent(agent) {
   return proxy;
 }
 
+// src/wrappers/pi-coding-agent.ts
+var WRAPPED_PROMPT = /* @__PURE__ */ Symbol.for("braintrust.pi-coding-agent.wrapped-prompt");
+function wrapPiCodingAgentSDK(sdk) {
+  if (!sdk || typeof sdk !== "object") {
+    return sdk;
+  }
+  const maybeSDK = sdk;
+  if (!maybeSDK.AgentSession || typeof maybeSDK.AgentSession !== "function") {
+    console.warn("Unsupported Pi Coding Agent SDK. Not wrapping.");
+    return sdk;
+  }
+  patchAgentSessionClass(
+    maybeSDK.AgentSession
+  );
+  return sdk;
+}
+function patchAgentSessionClass(AgentSession) {
+  const prototype = AgentSession.prototype;
+  if (!prototype || prototype[WRAPPED_PROMPT]) {
+    return;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(prototype, "prompt");
+  if (!descriptor || typeof descriptor.value !== "function") {
+    console.warn("Unsupported Pi Coding Agent SDK. Not wrapping.");
+    return;
+  }
+  const originalPrompt = descriptor.value;
+  Object.defineProperty(prototype, "prompt", {
+    ...descriptor,
+    value: function wrappedPiCodingAgentPrompt(text, options) {
+      const args = [text, options];
+      return piCodingAgentChannels.prompt.tracePromise(
+        () => Reflect.apply(originalPrompt, this, args),
+        {
+          arguments: args,
+          self: this,
+          session: this
+        }
+      );
+    }
+  });
+  Object.defineProperty(prototype, WRAPPED_PROMPT, {
+    configurable: false,
+    enumerable: false,
+    value: true
+  });
+}
+
 // src/wrappers/google-genai.ts
 function wrapGoogleGenAI(googleGenAI) {
   if (!googleGenAI || typeof googleGenAI !== "object") {
@@ -28173,12 +30295,25 @@ function wrapGoogleGenAIClass(OriginalGoogleGenAI) {
 }
 function wrapGoogleGenAIInstance(instance) {
   const wrappedModels = wrapModels(instance.models);
+  let originalInteractions;
+  let wrappedInteractions;
   patchGoogleGenAIChats(instance, wrappedModels);
   return new Proxy(instance, {
     get(target, prop, receiver) {
       if (prop === "models") {
         return wrappedModels;
       }
+      if (prop === "interactions") {
+        const interactions = Reflect.get(target, prop, receiver);
+        if (!isObject(interactions) || typeof interactions.create !== "function") {
+          return interactions;
+        }
+        if (interactions !== originalInteractions) {
+          originalInteractions = interactions;
+          wrappedInteractions = wrapInteractions(interactions);
+        }
+        return wrappedInteractions;
+      }
       return Reflect.get(target, prop, receiver);
     }
   });
@@ -28205,6 +30340,16 @@ function wrapModels(models) {
     }
   });
 }
+function wrapInteractions(interactions) {
+  return new Proxy(interactions, {
+    get(target, prop, receiver) {
+      if (prop === "create") {
+        return wrapInteractionCreate(target.create.bind(target));
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
 function wrapGenerateContent(original) {
   return function(params) {
     return googleGenAIChannels.generateContent.tracePromise(
@@ -28229,6 +30374,18 @@ function wrapEmbedContent(original) {
     );
   };
 }
+function wrapInteractionCreate(original) {
+  return function(params, options) {
+    if (params.background === true) {
+      return options === void 0 ? original(params) : original(params, options);
+    }
+    const traceContext = options === void 0 ? { arguments: [params] } : { arguments: [params, options] };
+    return googleGenAIChannels.interactionsCreate.tracePromise(
+      () => options === void 0 ? original(params) : original(params, options),
+      traceContext
+    );
+  };
+}
 
 // src/wrappers/google-adk.ts
 function wrapGoogleADK(adkModule) {
@@ -31746,6 +33903,13 @@ var EvalResultWithSummary = class {
     };
   }
 };
+async function getPersistedBaseExperimentId(experiment) {
+  try {
+    return await experiment._getBaseExperimentId();
+  } catch {
+    return void 0;
+  }
+}
 function makeEvalName(projectName, experimentName) {
   let out = projectName;
   if (experimentName) {
@@ -32128,6 +34292,14 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           return;
         }
         const eventDataset = experiment ? experiment.dataset : Dataset2.isDataset(evaluator.data) ? evaluator.data : void 0;
+        const inlineOrigin = datum.origin === void 0 ? void 0 : ObjectReference.parse(datum.origin);
+        const origin = inlineOrigin ?? (eventDataset && datum.id && datum._xact_id ? {
+          object_type: "dataset",
+          object_id: await eventDataset.id,
+          id: datum.id,
+          created: datum.created,
+          _xact_id: datum._xact_id
+        } : void 0);
         const baseEvent = {
           name: "eval",
           spanAttributes: {
@@ -32137,13 +34309,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             input: datum.input,
             expected: "expected" in datum ? datum.expected : void 0,
             tags: datum.tags,
-            origin: eventDataset && datum.id && datum._xact_id ? {
-              object_type: "dataset",
-              object_id: await eventDataset.id,
-              id: datum.id,
-              created: datum.created,
-              _xact_id: datum._xact_id
-            } : void 0,
+            origin,
             ...datum.upsert_id ? { id: datum.upsert_id } : {}
           }
         };
@@ -32500,8 +34666,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         collectedResults.length = 0;
       }
     }
+    const comparisonExperimentId = experiment ? evaluator.baseExperimentId ?? await getPersistedBaseExperimentId(experiment) : void 0;
     const summary = experiment ? await experiment.summarize({
-      summarizeScores: evaluator.summarizeScores
+      summarizeScores: evaluator.summarizeScores,
+      ...comparisonExperimentId !== void 0 ? { comparisonExperimentId } : {}
     }) : buildLocalSummary(
       evaluator,
       collectResults ? collectedResults : [],
@@ -32730,6 +34898,7 @@ var Project2 = class {
   prompts;
   parameters;
   scorers;
+  classifiers;
   _publishableCodeFunctions = [];
   _publishablePrompts = [];
   _publishableParameters = [];
@@ -32741,6 +34910,7 @@ var Project2 = class {
     this.prompts = new PromptBuilder(this);
     this.parameters = new ParametersBuilder(this);
     this.scorers = new ScorerBuilder(this);
+    this.classifiers = new ClassifierBuilder(this);
   }
   addPrompt(prompt) {
     this._publishablePrompts.push(prompt);
@@ -32875,6 +35045,28 @@ var ScorerBuilder = class {
     }
   }
 };
+var ClassifierBuilder = class {
+  constructor(project) {
+    this.project = project;
+  }
+  taskCounter = 0;
+  create(opts) {
+    this.taskCounter++;
+    let resolvedName = opts.name ?? opts.handler.name;
+    if (!resolvedName || resolvedName.trim().length === 0) {
+      resolvedName = `Classifier ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+    }
+    const slug = opts.slug ?? slugify(resolvedName, { lower: true, strict: true });
+    const classifier = new CodeFunction(this.project, {
+      ...opts,
+      name: resolvedName,
+      slug,
+      type: "classifier"
+    });
+    this.project.addCodeFunction(classifier);
+    return classifier;
+  }
+};
 var CodeFunction = class {
   constructor(project, opts) {
     this.project = project;
@@ -33224,7 +35416,7 @@ var serializedParametersContainerSchema = import_v313.z.union([
   staticParametersSchema
 ]);
 var evaluatorDefinitionSchema = import_v313.z.object({
-  parameters: serializedParametersContainerSchema.optional(),
+  parameters: serializedParametersContainerSchema.nullish(),
   scores: import_v313.z.array(import_v313.z.object({ name: import_v313.z.string() })).optional(),
   classifiers: import_v313.z.array(import_v313.z.object({ name: import_v313.z.string() })).optional()
 });