feat(eve): add braintrustEveProvider for eve's instrumentation bridge

Add a new Braintrust instrumentation provider that consumes eve's
lifecycle event bus (session/turn/step/model-call/action events)
instead of parsing stream events manually. The provider declares
capture: "content" or "metadata" and maps lifecycle events directly
to Braintrust spans, using eve's replay-stable idempotency keys for
deterministic span IDs and ctx.state for durable per-operation state.

Content redaction follows eve's per-destination ContentOptions model:
recordInputs and recordOutputs default to false, so the provider
captures metadata only (structure, identity, usage, timing) unless the
caller opts in. When both are false, the provider declares capture:
"metadata" so eve never builds the content projection at all. When
either is true, the provider declares capture: "content" and
respects its own redaction policy in each handler.

The version branching is internal to the SDK. braintrustEveInstrumentation
detects eve >= 0.34.0 at module scope and delegates to the provider
implementation; braintrustEveHook becomes a no-op on new eve since the
provider handles everything. The user's code does not change — they keep
importing braintrustEveInstrumentation and braintrustEveHook and passing
defineState, and the SDK uses the right path automatically.

New files:
- js/src/vendor-sdk-types/eve-provider.ts: vendored lifecycle event types
- js/src/instrumentation/plugins/eve-provider.ts: provider implementation

Signed-off-by: Chad Hietala <chadhietala@gmail.com>

Author: chadhietala

e2e/scenarios/eve-instrumentation/agent/instrumentation.ts

@@ -5,6 +5,8 @@ import { defineInstrumentation } from "eve/instrumentation";
 export default defineInstrumentation(
   braintrustEveInstrumentation({
     defineState,
+    recordInputs: true,
+    recordOutputs: true,
     setup: ({ agentName }) => {
       initLogger({
         projectName: process.env.BRAINTRUST_E2E_PROJECT_NAME || agentName,

js/src/exports.ts

@@ -200,6 +200,11 @@ export {
   braintrustEveHook,
   braintrustEveInstrumentation,
 } from "./instrumentation/plugins/eve-plugin";
+export {
+  braintrustEveProvider,
+  type EveProviderDefinition,
+  type EveContentOptions,
+} from "./instrumentation/plugins/eve-provider";
 export { collectAnthropicSession } from "./wrappers/anthropic-session-collector";
 export { wrapAnthropic } from "./wrappers/anthropic";
 export {

js/src/instrumentation/index.ts

@@ -27,6 +27,11 @@ export {
   braintrustEveHook,
   braintrustEveInstrumentation,
 } from "./plugins/eve-plugin";
+export {
+  braintrustEveProvider,
+  type EveProviderDefinition,
+  type EveContentOptions,
+} from "./plugins/eve-provider";
 
 // Re-export core types for external instrumentation packages
 export type {

js/src/instrumentation/plugins/eve-plugin.ts

@@ -14,6 +14,7 @@ import {
 } from "../../span-origin";
 import { SpanTypeAttribute, isObject } from "../../../util/index";
 import { getCurrentUnixTimestamp } from "../../util";
+import { braintrustEveProvider } from "./eve-provider";
 import type {
   EveAssistantStepFinishReason,
   EveActionResultError,
@@ -112,18 +113,56 @@ const MAX_STORED_REASONING_BLOCKS = 100;
 const MAX_STORED_SPAN_REFERENCES = 10_000;
 const MAX_STORED_STEP_STARTS = 10_000;
 
+let cachedEveVersion: string | undefined | null = undefined;
+
+function detectEveVersion(): string | undefined {
+  if (cachedEveVersion !== undefined) {
+    return cachedEveVersion === null ? undefined : cachedEveVersion;
+  }
+  try {
+    let req: NodeRequire;
+    try {
+      const { createRequire } =
+        require("node:module") as typeof import("node:module");
+      req = createRequire(`file://${process.cwd()}/`);
+    } catch {
+      req = require;
+    }
+    cachedEveVersion = req("eve/package.json").version as string;
+  } catch {
+    cachedEveVersion = null;
+  }
+  return cachedEveVersion === null ? undefined : cachedEveVersion;
+}
+
+function eveSupportsInstrumentationProviders(): boolean {
+  const version = detectEveVersion();
+  if (!version) return false;
+  const [major, minor] = version.split(".").map(Number);
+  return major > 0 || (major === 0 && minor >= 34);
+}
+
 type CapturedEveModelMessage = {
   content: string | readonly Record<string, unknown>[];
   role: EveModelMessage["role"];
 };
 
 type CapturedEveModelInput = readonly CapturedEveModelMessage[];
 
-/** Manual hook instrumentation for eve runtime stream events. */
+/**
+ * Manual hook instrumentation for eve runtime stream events.
+ *
+ * On eve >= 0.34.0 with `experimental.instrumentationProviders` enabled, the
+ * provider bus supersedes stream-event hooks. This function returns a no-op
+ * hook so the user's `agent/hooks/braintrust.ts` stays valid without changes.
+ */
 export function braintrustEveHook(options: {
   defineState: EveDefineState;
   metadata?: Record<string, unknown>;
 }): EveHookDefinition {
+  if (eveSupportsInstrumentationProviders()) {
+    return { events: {} };
+  }
   const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
   const bridge = new EveBridge(state);
   return {
@@ -135,11 +174,33 @@ export function braintrustEveHook(options: {
   };
 }
 
-/** Eve instrumentation helper for logger setup and durable LLM input capture. */
+/**
+ * Eve instrumentation helper for logger setup and durable LLM input capture.
+ *
+ * On eve >= 0.34.0 with `experimental.instrumentationProviders` enabled, this
+ * internally delegates to {@link braintrustEveProvider} and returns a provider
+ * definition that consumes eve's lifecycle event bus. `defineState` is ignored
+ * on that path — it remains required so the call site does not change across
+ * versions.
+ *
+ * `recordInputs` and `recordOutputs` default to `false` (metadata only). Set
+ * either to `true` to capture prompts, responses, and tool payloads.
+ */
 export function braintrustEveInstrumentation(options: {
   defineState: EveDefineState;
+  recordInputs?: boolean;
+  recordOutputs?: boolean;
   setup?: EveInstrumentationDefinition["setup"];
 }): EveInstrumentationDefinition {
+  if (eveSupportsInstrumentationProviders()) {
+    return braintrustEveProvider({
+      recordInputs: options.recordInputs,
+      recordOutputs: options.recordOutputs,
+      setup: options.setup as Parameters<
+        typeof braintrustEveProvider
+      >[0]["setup"],
+    }) as unknown as EveInstrumentationDefinition;
+  }
   const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
   return {
     events: {
@@ -151,8 +212,8 @@ export function braintrustEveInstrumentation(options: {
         }
       },
     },
-    recordInputs: false,
-    recordOutputs: false,
+    recordInputs: options.recordInputs === true,
+    recordOutputs: options.recordOutputs === true,
     setup: options.setup,
   };
 }