braintrust 3.21.0 → 3.22.0

package/dist/browser.mjs

@@ -2194,19 +2194,30 @@ var CallEvent = z6.union([
 var ChatCompletionContentPartTextWithTitle = z6.object({
   text: z6.string().default(""),
   type: z6.literal("text"),
-  cache_control: z6.object({ type: z6.literal("ephemeral") }).optional()
+  cache_control: z6.object({
+    type: z6.literal("ephemeral"),
+    ttl: z6.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionContentPartImageWithTitle = z6.object({
   image_url: z6.object({
     url: z6.string(),
     detail: z6.union([z6.literal("auto"), z6.literal("low"), z6.literal("high")]).optional()
   }),
-  type: z6.literal("image_url")
+  type: z6.literal("image_url"),
+  cache_control: z6.object({
+    type: z6.literal("ephemeral"),
+    ttl: z6.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionContentPartFileFile = z6.object({ file_data: z6.string(), filename: z6.string(), file_id: z6.string() }).partial();
 var ChatCompletionContentPartFileWithTitle = z6.object({
   file: ChatCompletionContentPartFileFile,
-  type: z6.literal("file")
+  type: z6.literal("file"),
+  cache_control: z6.object({
+    type: z6.literal("ephemeral"),
+    ttl: z6.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionContentPart = z6.union([
   ChatCompletionContentPartTextWithTitle,
@@ -2216,7 +2227,10 @@ var ChatCompletionContentPart = z6.union([
 var ChatCompletionContentPartText = z6.object({
   text: z6.string().default(""),
   type: z6.literal("text"),
-  cache_control: z6.object({ type: z6.literal("ephemeral") }).optional()
+  cache_control: z6.object({
+    type: z6.literal("ephemeral"),
+    ttl: z6.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionMessageToolCall = z6.object({
   id: z6.string(),
@@ -4269,13 +4283,23 @@ var LRUCache = class {
    * @returns The cached value if found, undefined otherwise.
    */
   get(key) {
-    const value = this.cache.get(key);
-    if (value === void 0) {
+    const entry = this.cache.get(key);
+    if (entry === void 0) {
       return void 0;
     }
     this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
+    this.cache.set(key, entry);
+    return entry.value;
+  }
+  /**
+   * Checks whether a key exists and marks it as most recently used.
+   */
+  has(key) {
+    if (!this.cache.has(key)) {
+      return false;
+    }
+    this.get(key);
+    return true;
   }
   /**
    * Stores a value in the cache.
@@ -4292,7 +4316,38 @@ var LRUCache = class {
       const first = this.cache.keys().next().value;
       this.cache.delete(first);
     }
-    this.cache.set(key, value);
+    this.cache.set(key, { value });
+  }
+  /**
+   * Removes an item from the cache.
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Iterates over cache entries from least to most recently used.
+   */
+  *entries() {
+    for (const [key, entry] of this.cache) {
+      yield [key, entry.value];
+    }
+  }
+  /**
+   * Iterates over cache keys from least to most recently used.
+   */
+  keys() {
+    return this.cache.keys();
+  }
+  /**
+   * Iterates over cache values from least to most recently used.
+   */
+  *values() {
+    for (const entry of this.cache.values()) {
+      yield entry.value;
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
   }
   /**
    * Removes all items from the cache.
@@ -4850,6 +4905,9 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
     return `ERROR: Failed to mask field '${fieldName}' - ${errorType}`;
   }
 }
+var INITIAL_SPAN_WRITE_AS_MERGE = /* @__PURE__ */ Symbol(
+  "braintrust.initial-span-write-as-merge"
+);
 var BRAINTRUST_CURRENT_SPAN_STORE = /* @__PURE__ */ Symbol.for(
   "braintrust.currentSpanStore"
 );
@@ -8500,6 +8558,12 @@ var traceable = wrapTraced;
 function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
+function _internalStartSpanWithInitialMerge(args) {
+  return startSpanAndIsLogger({
+    ...args,
+    [INITIAL_SPAN_WRITE_AS_MERGE]: true
+  }).span;
+}
 async function flush(options) {
   const state = options?.state ?? _globalState;
   return await state.bgLogger().flush();
@@ -9410,7 +9474,7 @@ var SpanImpl = class _SpanImpl {
     this._spanId = resolvedIds.spanId;
     this._rootSpanId = resolvedIds.rootSpanId;
     this._spanParents = resolvedIds.spanParents;
-    this.isMerge = false;
+    this.isMerge = args[INITIAL_SPAN_WRITE_AS_MERGE] === true;
     this.logInternal({ event, internalData });
     this.isMerge = true;
   }
@@ -31354,6 +31418,8 @@ __export(exports_exports, {
   addAzureBlobHeaders: () => addAzureBlobHeaders,
   agentAssertionScorer: () => agentAssertionScorer,
   braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
+  braintrustEveHook: () => braintrustEveHook,
+  braintrustEveInstrumentation: () => braintrustEveInstrumentation,
   braintrustFlueInstrumentation: () => braintrustFlueInstrumentation,
   braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
@@ -32854,6 +32920,1469 @@ function BraintrustMiddleware(config = {}) {
   };
 }
 
+// src/instrumentation/plugins/eve-plugin.ts
+var EVE_TRACE_STATE_KEY = "braintrust.eve.tracing";
+var MAX_EVE_CACHE_ENTRIES = 1e4;
+var MAX_STORED_LLM_INPUTS = 100;
+var MAX_STORED_SPAN_REFERENCES = 1e4;
+var MAX_STORED_STEP_STARTS = 1e4;
+function braintrustEveHook(options) {
+  const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
+  const bridge = new EveBridge(state);
+  return {
+    events: {
+      "*": async (event, ctx) => {
+        await bridge.handle(event, ctx, options.metadata);
+      }
+    }
+  };
+}
+function braintrustEveInstrumentation(options) {
+  const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
+  return {
+    events: {
+      "step.started": (input) => {
+        try {
+          captureEveModelInput(state, input);
+        } catch (error) {
+          debugLogger.warn("Error in Eve LLM input capture:", error);
+        }
+      }
+    },
+    recordInputs: false,
+    recordOutputs: false,
+    setup: options.setup
+  };
+}
+function isEveHandleMessageStreamEvent(event) {
+  return isObject(event) && typeof event["type"] === "string";
+}
+var ResumedEveSpan = class {
+  constructor(reference) {
+    this.reference = reference;
+    this.endTime = reference.endTime;
+  }
+  endTime;
+  get rootSpanId() {
+    return this.reference.rootSpanId;
+  }
+  get spanId() {
+    return this.reference.spanId;
+  }
+  log(event) {
+    const metrics = {
+      ...this.reference.startEvent?.metrics,
+      ...this.endTime === void 0 ? {} : { end: this.endTime },
+      ...event.metrics
+    };
+    updateSpan({
+      exported: this.reference.exported,
+      ...this.reference.startEvent,
+      ...event,
+      ...Object.keys(metrics).length > 0 ? { metrics } : {}
+    });
+  }
+  end(args) {
+    if (this.endTime === void 0) {
+      this.endTime = args?.endTime ?? getCurrentUnixTimestamp();
+      this.log({ metrics: { end: this.endTime } });
+    }
+    return this.endTime;
+  }
+};
+var EveBridge = class {
+  constructor(state) {
+    this.state = state;
+  }
+  eventQueuesBySession = /* @__PURE__ */ new Map();
+  sessionsById = new LRUCache({
+    max: MAX_EVE_CACHE_ENTRIES
+  });
+  completedToolKeys = new LRUCache({
+    max: MAX_EVE_CACHE_ENTRIES
+  });
+  toolsByCallKey = new LRUCache({
+    max: MAX_EVE_CACHE_ENTRIES
+  });
+  turnsByKey = new LRUCache({
+    max: MAX_EVE_CACHE_ENTRIES
+  });
+  async startEveSpan(args) {
+    const rowId = args?.event?.id;
+    const reference = typeof rowId === "string" && readEveTraceState(this.state).spanReferences.find(
+      (candidate) => candidate.rowId === rowId
+    );
+    if (reference) {
+      return new ResumedEveSpan(reference);
+    }
+    const startTime = args?.startTime ?? getCurrentUnixTimestamp();
+    const parentSpanIds = args?.parentSpanIds;
+    const startEvent = {
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      metrics: { start: startTime },
+      span_attributes: {
+        ...args?.name ? { name: args.name } : {},
+        ...args?.type ? { type: args.type } : {},
+        ...args?.spanAttributes
+      },
+      span_parents: parentSpanIds ? "spanId" in parentSpanIds ? [parentSpanIds.spanId] : parentSpanIds.parentSpanIds : []
+    };
+    const span = withCurrent(
+      NOOP_SPAN,
+      () => _internalStartSpanWithInitialMerge({ ...args, startTime })
+    );
+    if (typeof rowId !== "string") {
+      return span;
+    }
+    try {
+      const exported = await span.export();
+      const reference2 = {
+        exported,
+        rootSpanId: span.rootSpanId,
+        rowId,
+        spanId: span.spanId,
+        startEvent
+      };
+      this.state.update((current) => {
+        const normalized = normalizeEveTraceState(current);
+        return normalized.spanReferences.some(
+          (candidate) => candidate.rowId === rowId
+        ) ? normalized : {
+          ...normalized,
+          spanReferences: [...normalized.spanReferences, reference2].slice(
+            -MAX_STORED_SPAN_REFERENCES
+          )
+        };
+      });
+    } catch (error) {
+      debugLogger.warn("Error exporting Eve span for resumption:", error);
+    }
+    return span;
+  }
+  async startEveChildSpan(parent, args) {
+    return await this.startEveSpan({
+      ...args,
+      parentSpanIds: {
+        rootSpanId: parent.rootSpanId,
+        spanId: parent.spanId
+      }
+    });
+  }
+  stepOrdinal(event) {
+    let ordinal = 0;
+    this.state.update((current) => {
+      const state = normalizeEveTraceState(current);
+      const previous = state.stepStarts.filter(
+        (entry) => entry.turnId === event.data.turnId && entry.stepIndex === event.data.stepIndex
+      ).at(-1);
+      if (previous?.open) {
+        ordinal = previous.ordinal;
+        return state;
+      }
+      ordinal = state.stepStarts.filter(
+        (entry) => entry.turnId === event.data.turnId
+      ).length;
+      return {
+        ...state,
+        stepStarts: [
+          ...state.stepStarts,
+          {
+            open: true,
+            ordinal,
+            stepIndex: event.data.stepIndex,
+            turnId: event.data.turnId
+          }
+        ].slice(-MAX_STORED_STEP_STARTS)
+      };
+    });
+    return ordinal;
+  }
+  markStepEnded(turnId, stepIndex) {
+    this.state.update((current) => {
+      const state = normalizeEveTraceState(current);
+      let index = -1;
+      for (let i = state.stepStarts.length - 1; i >= 0; i--) {
+        const entry = state.stepStarts[i];
+        if (entry?.turnId === turnId && entry.stepIndex === stepIndex) {
+          index = i;
+          break;
+        }
+      }
+      if (index < 0 || !state.stepStarts[index]?.open) {
+        return state;
+      }
+      return {
+        ...state,
+        stepStarts: state.stepStarts.map(
+          (entry, entryIndex) => entryIndex === index ? { ...entry, open: false } : entry
+        )
+      };
+    });
+  }
+  async handle(event, ctx, hookMetadata) {
+    if (!isEveHandleMessageStreamEvent(event)) {
+      return;
+    }
+    const run = async () => {
+      try {
+        if (!await this.handleEvent(event, ctx, hookMetadata)) {
+          return;
+        }
+        if (event.type === "session.failed") {
+          const sessionId2 = event.data.sessionId || sessionIdFromContext(ctx);
+          await this.flushInstrumentation();
+          if (sessionId2) {
+            this.cleanupSession(sessionId2);
+          }
+        } else if (event.type === "session.completed") {
+          const sessionId2 = sessionIdFromContext(ctx);
+          await this.flushInstrumentation();
+          if (sessionId2) {
+            this.cleanupSession(sessionId2);
+          }
+        }
+      } catch (error) {
+        debugLogger.warn("Error in Eve hook instrumentation:", error);
+      }
+    };
+    const sessionId = event.type === "session.failed" ? event.data.sessionId || sessionIdFromContext(ctx) : sessionIdFromContext(ctx);
+    if (!sessionId) {
+      await run();
+      return;
+    }
+    const previous = this.eventQueuesBySession.get(sessionId);
+    const queued = previous ? previous.then(run) : run();
+    this.eventQueuesBySession.set(sessionId, queued);
+    try {
+      await queued;
+    } finally {
+      if (this.eventQueuesBySession.get(sessionId) === queued) {
+        this.eventQueuesBySession.delete(sessionId);
+      }
+    }
+  }
+  async handleEvent(event, ctx, hookMetadata) {
+    switch (event.type) {
+      case "session.started":
+        await this.handleSessionStarted(event, ctx, hookMetadata);
+        return true;
+      case "turn.started":
+        await this.handleTurnStarted(event, ctx, hookMetadata);
+        return true;
+      case "message.received":
+        await this.handleMessageReceived(event, ctx, hookMetadata);
+        return true;
+      case "step.started":
+        await this.handleStepStarted(event, ctx, hookMetadata);
+        return true;
+      case "message.completed":
+        this.handleMessageCompleted(event, ctx);
+        return true;
+      case "result.completed":
+        this.handleResultCompleted(event, ctx);
+        return true;
+      case "actions.requested":
+        await this.handleActionsRequested(event, ctx, hookMetadata);
+        return true;
+      case "action.result":
+        await this.handleActionResult(event, ctx, hookMetadata);
+        return true;
+      case "subagent.called":
+        await this.handleSubagentCalled(event, ctx, hookMetadata);
+        return true;
+      case "subagent.completed":
+        await this.handleSubagentCompleted(event, ctx, hookMetadata);
+        return true;
+      case "step.completed":
+        this.handleStepCompleted(event, ctx);
+        return true;
+      case "step.failed":
+        this.handleStepFailed(event, ctx);
+        return true;
+      case "turn.completed":
+        await this.handleTurnCompleted(event, ctx);
+        return true;
+      case "turn.failed":
+        await this.handleTurnFailed(event, ctx);
+        return true;
+      case "session.failed":
+        await this.handleSessionFailed(event, ctx);
+        return true;
+      case "session.completed":
+        await this.handleSessionCompleted(event, ctx);
+        return true;
+      default:
+        return false;
+    }
+  }
+  async handleSessionStarted(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const metadata = {
+      ...hookMetadata ?? {},
+      ...modelMetadataFromRuntime(event.data.runtime)
+    };
+    this.state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      return {
+        ...normalized,
+        metadata: { ...normalized.metadata, ...metadata }
+      };
+    });
+    await this.ensureSession(sessionId, ctx, metadata, eventTime2(event));
+    for (const [key, turn] of this.turnsByKey) {
+      if (!key.startsWith(`${sessionId}:`)) {
+        continue;
+      }
+      turn.metadata = { ...turn.metadata, ...metadata };
+      turn.span.log({ metadata: turn.metadata });
+      for (const step of turn.stepsByIndex.values()) {
+        step.metadata = { ...step.metadata, ...metadata };
+        step.span.log({ metadata: step.metadata });
+      }
+    }
+  }
+  async handleTurnStarted(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const session = await this.ensureSession(
+      sessionId,
+      ctx,
+      hookMetadata ?? {},
+      eventTime2(event)
+    );
+    const key = turnKey2(sessionId, event.data.turnId);
+    const metadata = { ...session.metadata };
+    const existing = this.turnsByKey.get(key);
+    if (existing) {
+      existing.metadata = { ...existing.metadata, ...metadata };
+      existing.span.log({ metadata: existing.metadata });
+      return;
+    }
+    const span = await this.startTurnSpan(session, event, metadata);
+    span.log({ metadata });
+    this.turnsByKey.set(key, {
+      key,
+      metadata,
+      metrics: {},
+      span,
+      stepsByIndex: /* @__PURE__ */ new Map(),
+      turnId: event.data.turnId
+    });
+  }
+  async handleMessageReceived(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    if (!turn) {
+      return;
+    }
+    const input = [{ content: event.data.message, role: "user" }];
+    turn.span.log({ input });
+  }
+  async handleStepStarted(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return;
+    }
+    const existing = turn.stepsByIndex.get(event.data.stepIndex);
+    if (existing) {
+      existing.span.log({
+        ...existing.input !== void 0 ? { input: existing.input } : {},
+        metadata: existing.metadata,
+        metrics: existing.metrics,
+        output: existing.output
+      });
+      const endTime = eventTime2(event);
+      existing.span.end(endTime === void 0 ? void 0 : { endTime });
+      this.markStepEnded(event.data.turnId, event.data.stepIndex);
+    }
+    const stepOrdinal = this.stepOrdinal(event);
+    const metadata = {
+      ...turn.metadata,
+      ...this.sessionsById.get(sessionId)?.metadata ?? {}
+    };
+    const input = consumeCapturedEveModelInput(
+      this.state,
+      sessionId,
+      event.data.turnId,
+      event.data.stepIndex
+    );
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "step",
+      sessionId,
+      event.data.turnId,
+      String(stepOrdinal)
+    );
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        ...input !== void 0 ? { input } : {},
+        metadata
+      },
+      name: "eve.step",
+      spanAttributes: { type: "llm" /* LLM */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ ...input !== void 0 ? { input } : {}, metadata });
+    turn.stepsByIndex.set(event.data.stepIndex, {
+      ...input !== void 0 ? { input } : {},
+      metadata,
+      metrics: {},
+      span
+    });
+  }
+  handleMessageCompleted(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (!step) {
+      return;
+    }
+    const existingMessage = Array.isArray(step.output) && isObject(step.output[0]) ? step.output[0].message : void 0;
+    const existingToolCalls = isObject(existingMessage) ? existingMessage.tool_calls : void 0;
+    step.output = [
+      {
+        finish_reason: normalizedFinishReason(event.data.finishReason),
+        index: 0,
+        message: {
+          content: event.data.message,
+          role: "assistant",
+          ...Array.isArray(existingToolCalls) ? { tool_calls: existingToolCalls } : {}
+        }
+      }
+    ];
+    const turn = this.turnForEvent(event, ctx);
+    if (turn && event.data.finishReason !== "tool-calls") {
+      turn.output = event.data.message;
+    }
+  }
+  handleResultCompleted(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (step) {
+      step.output = [
+        {
+          finish_reason: "stop",
+          index: 0,
+          message: {
+            content: event.data.result,
+            role: "assistant"
+          }
+        }
+      ];
+    }
+    const turn = this.turnForEvent(event, ctx);
+    if (turn) {
+      turn.output = event.data.result;
+    }
+  }
+  async handleActionsRequested(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return;
+    }
+    const traceActions = event.data.actions.filter(isTraceableActionRequest);
+    if (traceActions.length === 0) {
+      return;
+    }
+    for (const action of traceActions) {
+      if (isToolCallAction(action)) {
+        await this.startRequestedTool(event, turn, sessionId, action);
+      } else if (isLocalSubagentCallAction(action)) {
+        await this.startRequestedSubagent(event, turn, sessionId, action);
+      }
+    }
+    const step = turn.stepsByIndex.get(event.data.stepIndex);
+    if (!step) {
+      return;
+    }
+    step.output = [
+      {
+        finish_reason: "tool_calls",
+        index: 0,
+        message: {
+          content: null,
+          role: "assistant",
+          tool_calls: traceActions.map((action) => {
+            const name = action.kind === "tool-call" ? action.toolName : action.subagentName ?? action.name ?? "agent";
+            return {
+              function: {
+                arguments: JSON.stringify(action.input),
+                name
+              },
+              id: action.callId,
+              type: "function"
+            };
+          })
+        }
+      }
+    ];
+    step.span.log({ metadata: step.metadata, output: step.output });
+  }
+  async handleActionResult(event, ctx, hookMetadata) {
+    if (isToolResult(event.data.result)) {
+      await this.handleToolResult(event, ctx, event.data.result, hookMetadata);
+      return;
+    }
+    if (isSubagentResult(event.data.result)) {
+      await this.handleSubagentResult(
+        event,
+        ctx,
+        event.data.result,
+        hookMetadata
+      );
+    }
+  }
+  async handleToolResult(event, ctx, result, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, result.callId);
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const tool = this.toolsByCallKey.get(key) ?? await this.startSyntheticTool(event, ctx, result, hookMetadata);
+    if (!tool) {
+      return;
+    }
+    const failed = event.data.status === "failed" || result.isError === true || event.data.error !== void 0;
+    tool.span.log({
+      ...failed ? {
+        error: actionResultError(event.data.error, result.output)
+      } : {},
+      metadata: tool.metadata,
+      output: result.output
+    });
+    const endTime = eventTime2(event);
+    tool.span.end(endTime === void 0 ? void 0 : { endTime });
+    this.toolsByCallKey.delete(key);
+    this.completedToolKeys.set(key, true);
+  }
+  async handleSubagentCalled(event, ctx, hookMetadata) {
+    if (event.data.remote?.url) {
+      return;
+    }
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, event.data.callId);
+    const metadata = toolMetadataFromTurn(turn);
+    const existing = this.toolsByCallKey.get(key);
+    if (existing) {
+      existing.metadata = { ...existing.metadata, ...metadata };
+      existing.span.log({ metadata: existing.metadata });
+      return;
+    }
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      event.data.callId
+    );
+    const pending = this.toolsByCallKey.get(key);
+    if (pending || this.completedToolKeys.has(key)) {
+      if (pending) {
+        pending.metadata = { ...pending.metadata, ...metadata };
+        pending.span.log({ metadata: pending.metadata });
+      }
+      return;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: event.data.toolName ?? event.data.name,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    this.toolsByCallKey.set(key, {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    });
+  }
+  async handleSubagentCompleted(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, event.data.callId);
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const subagent = this.toolsByCallKey.get(key) ?? await this.startSyntheticSubagent(event, ctx, hookMetadata);
+    if (!subagent) {
+      return;
+    }
+    subagent.span.log({
+      ...event.data.status === "failed" ? {
+        error: actionResultError(event.data.error, event.data.output)
+      } : {},
+      metadata: subagent.metadata,
+      ...event.data.output !== void 0 ? { output: event.data.output } : {}
+    });
+    const endTime = eventTime2(event);
+    const recordedEndTime = subagent.span.end(
+      endTime === void 0 ? void 0 : { endTime }
+    );
+    this.state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      return {
+        ...normalized,
+        spanReferences: normalized.spanReferences.map(
+          (reference) => reference.spanId === subagent.span.spanId ? { ...reference, endTime: recordedEndTime } : reference
+        )
+      };
+    });
+  }
+  async handleSubagentResult(event, ctx, result, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, result.callId);
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const subagent = this.toolsByCallKey.get(key) ?? await this.startSyntheticSubagentResult(
+      event,
+      ctx,
+      result,
+      hookMetadata
+    );
+    if (!subagent) {
+      return;
+    }
+    const isError = event.data.status === "failed" || result.isError === true || event.data.error !== void 0;
+    subagent.span.log({
+      ...isError ? {
+        error: actionResultError(event.data.error, result.output)
+      } : {},
+      metadata: subagent.metadata,
+      output: result.output
+    });
+    const endTime = eventTime2(event);
+    subagent.span.end(endTime === void 0 ? void 0 : { endTime });
+    this.toolsByCallKey.delete(key);
+    this.completedToolKeys.set(key, true);
+  }
+  handleStepCompleted(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (!step) {
+      return;
+    }
+    const usage = event.data.usage;
+    const inputTokens = typeof usage?.inputTokens === "number" && Number.isFinite(usage.inputTokens) && usage.inputTokens >= 0 ? usage.inputTokens : void 0;
+    const outputTokens = typeof usage?.outputTokens === "number" && Number.isFinite(usage.outputTokens) && usage.outputTokens >= 0 ? usage.outputTokens : void 0;
+    const cacheReadTokens = typeof usage?.cacheReadTokens === "number" && Number.isFinite(usage.cacheReadTokens) && usage.cacheReadTokens >= 0 ? usage.cacheReadTokens : void 0;
+    const cacheWriteTokens = typeof usage?.cacheWriteTokens === "number" && Number.isFinite(usage.cacheWriteTokens) && usage.cacheWriteTokens >= 0 ? usage.cacheWriteTokens : void 0;
+    const costUsd = typeof usage?.costUsd === "number" && Number.isFinite(usage.costUsd) && usage.costUsd >= 0 ? usage.costUsd : void 0;
+    const total = inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0;
+    const metrics = {
+      ...inputTokens !== void 0 ? { prompt_tokens: inputTokens } : {},
+      ...outputTokens !== void 0 ? { completion_tokens: outputTokens } : {},
+      ...total !== void 0 ? { tokens: total } : {},
+      ...cacheReadTokens !== void 0 ? { prompt_cached_tokens: cacheReadTokens } : {},
+      ...cacheWriteTokens !== void 0 ? { prompt_cache_creation_tokens: cacheWriteTokens } : {},
+      ...costUsd !== void 0 ? { estimated_cost: costUsd } : {}
+    };
+    step.metrics = { ...step.metrics, ...metrics };
+    if (Array.isArray(step.output) && isObject(step.output[0])) {
+      const finishReason = step.output[0].finish_reason;
+      if (typeof finishReason !== "string") {
+        step.output[0].finish_reason = normalizedFinishReason(
+          event.data.finishReason
+        );
+      }
+    }
+    step.span.log({
+      ...step.input !== void 0 ? { input: step.input } : {},
+      metadata: step.metadata,
+      metrics,
+      output: step.output
+    });
+    const endTime = eventTime2(event);
+    step.span.end(endTime === void 0 ? void 0 : { endTime });
+    const turn = this.turnForEvent(event, ctx);
+    if (turn) {
+      for (const [key, value] of Object.entries(metrics)) {
+        turn.metrics[key] = (turn.metrics[key] ?? 0) + value;
+      }
+      turn.stepsByIndex.delete(event.data.stepIndex);
+    }
+    this.markStepEnded(event.data.turnId, event.data.stepIndex);
+  }
+  handleStepFailed(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (step) {
+      step.span.log({
+        error: errorFromMessage(
+          event.data.message,
+          event.data.code,
+          event.data.details
+        )
+      });
+      const endTime = eventTime2(event);
+      step.span.end(endTime === void 0 ? void 0 : { endTime });
+    }
+    const turn = this.turnForEvent(event, ctx);
+    turn?.stepsByIndex.delete(event.data.stepIndex);
+    this.markStepEnded(event.data.turnId, event.data.stepIndex);
+  }
+  handleTurnCompleted(event, ctx) {
+    const turn = this.turnForEvent(event, ctx);
+    if (!turn) {
+      return;
+    }
+    this.finalizeTurn(turn, {
+      endTime: eventTime2(event)
+    });
+  }
+  handleTurnFailed(event, ctx) {
+    const turn = this.turnForEvent(event, ctx);
+    if (!turn) {
+      return;
+    }
+    this.finalizeTurn(turn, {
+      endTime: eventTime2(event),
+      error: errorFromMessage(
+        event.data.message,
+        event.data.code,
+        event.data.details
+      )
+    });
+  }
+  async handleSessionFailed(event, ctx) {
+    const sessionId = event.data.sessionId || sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const session = await this.ensureSession(
+      sessionId,
+      ctx,
+      {},
+      eventTime2(event)
+    );
+    const error = errorFromMessage(
+      event.data.message,
+      event.data.code,
+      event.data.details
+    );
+    for (const [key, turn] of this.turnsByKey) {
+      if (!key.startsWith(`${sessionId}:`)) {
+        continue;
+      }
+      this.finalizeTurn(turn, {
+        endTime: eventTime2(event),
+        error
+      });
+    }
+    for (const [key, tool] of this.toolsByCallKey) {
+      if (key.startsWith(`${sessionId}:`)) {
+        const endTime2 = eventTime2(event);
+        if (!tool.endedByTurn) {
+          tool.span.log({ metadata: tool.metadata });
+          tool.span.end(endTime2 === void 0 ? void 0 : { endTime: endTime2 });
+          tool.endedByTurn = true;
+        }
+      }
+    }
+    session.span.log({ error });
+    const endTime = eventTime2(event);
+    session.span.end(endTime === void 0 ? void 0 : { endTime });
+  }
+  async handleSessionCompleted(event, ctx) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const session = await this.ensureSession(
+      sessionId,
+      ctx,
+      {},
+      eventTime2(event)
+    );
+    for (const [key, turn] of this.turnsByKey) {
+      if (!key.startsWith(`${sessionId}:`)) {
+        continue;
+      }
+      this.finalizeTurn(turn, {
+        endTime: eventTime2(event)
+      });
+    }
+    for (const [key, tool] of this.toolsByCallKey) {
+      if (key.startsWith(`${sessionId}:`) && !tool.endedByTurn) {
+        const endTime2 = eventTime2(event);
+        tool.span.log({ metadata: tool.metadata });
+        tool.span.end(endTime2 === void 0 ? void 0 : { endTime: endTime2 });
+        tool.endedByTurn = true;
+      }
+    }
+    session.span.log({ metadata: session.metadata });
+    const endTime = eventTime2(event);
+    session.span.end(endTime === void 0 ? void 0 : { endTime });
+  }
+  async ensureSession(sessionId, ctx, metadata, startTime) {
+    metadata = {
+      ...readEveTraceState(this.state).metadata,
+      ...metadata
+    };
+    const existing = this.sessionsById.get(sessionId);
+    if (existing) {
+      existing.metadata = { ...existing.metadata, ...metadata };
+      existing.span.log({ metadata: existing.metadata });
+      return existing;
+    }
+    const lineage = parentLineageFromContext(ctx);
+    const parentSubagent = lineage ? this.toolsByCallKey.get(toolKey3(lineage.sessionId, lineage.callId)) : void 0;
+    const activeParent = currentSpan();
+    const [
+      { rowId: eventId, spanId },
+      parentSubagentSpanId,
+      fallbackRootSpanId
+    ] = await Promise.all([
+      generateEveIds("session", sessionId),
+      lineage ? spanIdForSubagent(lineage.sessionId, lineage.callId) : Promise.resolve(void 0),
+      lineage ? rootSpanIdForSession(lineage.rootSessionId) : rootSpanIdForSession(sessionId)
+    ]);
+    const span = await this.startEveSpan({
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: "eve.session",
+      parentSpanIds: lineage && parentSubagentSpanId ? {
+        rootSpanId: parentSubagent?.span.rootSpanId ?? fallbackRootSpanId,
+        spanId: parentSubagentSpanId
+      } : !Object.is(activeParent, NOOP_SPAN) ? {
+        rootSpanId: activeParent.rootSpanId,
+        spanId: activeParent.spanId
+      } : {
+        parentSpanIds: [],
+        rootSpanId: fallbackRootSpanId
+      },
+      spanAttributes: { type: "task" /* TASK */ },
+      spanId,
+      startTime
+    });
+    span.log({ metadata });
+    const session = { metadata, sessionId, span };
+    this.sessionsById.set(sessionId, session);
+    return session;
+  }
+  async ensureTurn(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return void 0;
+    }
+    const session = await this.ensureSession(
+      sessionId,
+      ctx,
+      hookMetadata ?? {},
+      eventTime2(event)
+    );
+    const key = turnKey2(sessionId, event.data.turnId);
+    const existing = this.turnsByKey.get(key);
+    if (existing) {
+      return existing;
+    }
+    const metadata = { ...session.metadata };
+    const span = await this.startTurnSpan(session, event, metadata);
+    span.log({ metadata });
+    const state = {
+      key,
+      metadata,
+      metrics: {},
+      span,
+      stepsByIndex: /* @__PURE__ */ new Map(),
+      turnId: event.data.turnId
+    };
+    this.turnsByKey.set(key, state);
+    return state;
+  }
+  async startRequestedTool(event, turn, sessionId, action) {
+    const key = toolKey3(sessionId, action.callId);
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "tool",
+      sessionId,
+      event.data.turnId,
+      action.callId
+    );
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        input: action.input,
+        metadata
+      },
+      name: action.toolName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ input: action.input, metadata });
+    this.toolsByCallKey.set(key, {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    });
+  }
+  async startRequestedSubagent(event, turn, sessionId, action) {
+    const key = toolKey3(sessionId, action.callId);
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const name = action.subagentName ?? action.name ?? "agent";
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      action.callId
+    );
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        input: action.input,
+        metadata
+      },
+      name,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ input: action.input, metadata });
+    this.toolsByCallKey.set(key, {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    });
+  }
+  async startSyntheticTool(event, ctx, result, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return void 0;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "tool",
+      sessionId,
+      event.data.turnId,
+      result.callId
+    );
+    const existing = this.toolsByCallKey.get(toolKey3(sessionId, result.callId));
+    if (existing) {
+      return existing;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: result.toolName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    const state = {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    };
+    this.toolsByCallKey.set(toolKey3(sessionId, result.callId), state);
+    return state;
+  }
+  async startSyntheticSubagent(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return void 0;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      event.data.callId
+    );
+    const existing = this.toolsByCallKey.get(
+      toolKey3(sessionId, event.data.callId)
+    );
+    if (existing) {
+      return existing;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: event.data.subagentName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    const state = {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    };
+    this.toolsByCallKey.set(toolKey3(sessionId, event.data.callId), state);
+    return state;
+  }
+  async startSyntheticSubagentResult(event, ctx, result, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return void 0;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      result.callId
+    );
+    const existing = this.toolsByCallKey.get(toolKey3(sessionId, result.callId));
+    if (existing) {
+      return existing;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: result.subagentName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    const state = {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    };
+    this.toolsByCallKey.set(toolKey3(sessionId, result.callId), state);
+    return state;
+  }
+  async startTurnSpan(session, event, metadata) {
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "turn",
+      session.sessionId,
+      event.data.turnId
+    );
+    return await this.startEveSpan({
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: "eve.turn",
+      parentSpanIds: {
+        rootSpanId: session.span.rootSpanId,
+        spanId: session.span.spanId
+      },
+      spanAttributes: { type: "task" /* TASK */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+  }
+  turnForEvent(event, ctx) {
+    const sessionId = sessionIdFromContext(ctx);
+    return sessionId ? this.turnsByKey.get(turnKey2(sessionId, event.data.turnId)) : void 0;
+  }
+  stepForEvent(event, ctx) {
+    return this.turnForEvent(event, ctx)?.stepsByIndex.get(
+      event.data.stepIndex
+    );
+  }
+  finalizeTurn(turn, args) {
+    const { endTime } = args;
+    for (const step of turn.stepsByIndex.values()) {
+      step.span.log({
+        ...step.input !== void 0 ? { input: step.input } : {},
+        metadata: step.metadata,
+        metrics: step.metrics,
+        output: step.output
+      });
+      step.span.end(endTime === void 0 ? void 0 : { endTime });
+    }
+    turn.stepsByIndex.clear();
+    for (const tool of this.toolsByCallKey.values()) {
+      if (tool.turnKey !== turn.key) {
+        continue;
+      }
+      if (tool.endedByTurn) {
+        continue;
+      }
+      tool.span.log({ metadata: tool.metadata });
+      tool.span.end(endTime === void 0 ? void 0 : { endTime });
+      tool.endedByTurn = true;
+    }
+    if (args.error) {
+      turn.span.log({ error: args.error });
+    } else {
+      turn.span.log({
+        metadata: turn.metadata,
+        metrics: turn.metrics,
+        output: turn.output
+      });
+    }
+    turn.span.end(endTime === void 0 ? void 0 : { endTime });
+    this.turnsByKey.delete(turn.key);
+    this.state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      return {
+        ...normalized,
+        stepStarts: normalized.stepStarts.filter(
+          (entry) => entry.turnId !== turn.turnId
+        )
+      };
+    });
+  }
+  cleanupSession(sessionId) {
+    const keyPrefix = `${sessionId}:`;
+    this.sessionsById.delete(sessionId);
+    for (const key of this.turnsByKey.keys()) {
+      if (key.startsWith(keyPrefix)) {
+        this.turnsByKey.delete(key);
+      }
+    }
+    for (const key of this.toolsByCallKey.keys()) {
+      if (key.startsWith(keyPrefix)) {
+        this.toolsByCallKey.delete(key);
+      }
+    }
+    for (const key of this.completedToolKeys.keys()) {
+      if (key.startsWith(keyPrefix)) {
+        this.completedToolKeys.delete(key);
+      }
+    }
+    this.state.update(() => emptyEveTraceState());
+  }
+  async flushInstrumentation() {
+    try {
+      await flush();
+      return true;
+    } catch (error) {
+      debugLogger.warn("Error in Eve flush instrumentation:", error);
+      return false;
+    }
+  }
+};
+function emptyEveTraceState() {
+  return {
+    llmInputs: [],
+    metadata: {},
+    spanReferences: [],
+    stepStarts: []
+  };
+}
+function normalizeEveTraceState(state) {
+  if (!isObject(state)) {
+    return emptyEveTraceState();
+  }
+  const metadata = isObject(state["metadata"]) ? state["metadata"] : {};
+  const spanReferences = Array.isArray(state["spanReferences"]) ? state["spanReferences"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const exported = entry["exported"];
+    const endTime = entry["endTime"];
+    const rootSpanId = entry["rootSpanId"];
+    const rowId = entry["rowId"];
+    const spanId = entry["spanId"];
+    const startEvent = entry["startEvent"];
+    const startEventCreated = isObject(startEvent) ? startEvent["created"] : void 0;
+    const startEventMetrics = isObject(startEvent) ? startEvent["metrics"] : void 0;
+    const startEventSpanAttributes = isObject(startEvent) ? startEvent["span_attributes"] : void 0;
+    const startEventSpanParents = isObject(startEvent) ? startEvent["span_parents"] : void 0;
+    const normalizedStartEvent = typeof startEventCreated === "string" && isObject(startEventMetrics) && typeof startEventMetrics["start"] === "number" && Number.isFinite(startEventMetrics["start"]) && isObject(startEventSpanAttributes) && Array.isArray(startEventSpanParents) && startEventSpanParents.every(
+      (parent) => typeof parent === "string"
+    ) ? {
+      created: startEventCreated,
+      metrics: { start: startEventMetrics["start"] },
+      span_attributes: { ...startEventSpanAttributes },
+      span_parents: [...startEventSpanParents]
+    } : void 0;
+    return typeof exported === "string" && typeof rootSpanId === "string" && typeof rowId === "string" && typeof spanId === "string" ? [
+      {
+        ...typeof endTime === "number" && Number.isFinite(endTime) ? { endTime } : {},
+        exported,
+        rootSpanId,
+        rowId,
+        spanId,
+        ...normalizedStartEvent ? { startEvent: normalizedStartEvent } : {}
+      }
+    ] : [];
+  }).slice(-MAX_STORED_SPAN_REFERENCES) : [];
+  const llmInputs = Array.isArray(state["llmInputs"]) ? state["llmInputs"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const key = entry["key"];
+    const input = entry["input"];
+    return typeof key === "string" && isCapturedModelInput(input) ? [{ input, key }] : [];
+  }).slice(-MAX_STORED_LLM_INPUTS) : [];
+  const stepStarts = Array.isArray(state["stepStarts"]) ? state["stepStarts"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const ordinal = entry["ordinal"];
+    const open = entry["open"];
+    const stepIndex = entry["stepIndex"];
+    const turnId = entry["turnId"];
+    return typeof ordinal === "number" && Number.isInteger(ordinal) && ordinal >= 0 && typeof open === "boolean" && typeof stepIndex === "number" && Number.isInteger(stepIndex) && typeof turnId === "string" ? [{ open, ordinal, stepIndex, turnId }] : [];
+  }).slice(-MAX_STORED_STEP_STARTS) : [];
+  return { llmInputs, metadata: { ...metadata }, spanReferences, stepStarts };
+}
+function readEveTraceState(state) {
+  try {
+    return normalizeEveTraceState(state.get());
+  } catch {
+    return emptyEveTraceState();
+  }
+}
+function captureEveModelInput(state, input) {
+  if (!isObject(input)) {
+    return;
+  }
+  const session = input["session"];
+  const turn = input["turn"];
+  const step = input["step"];
+  if (!isObject(session) || !isObject(turn) || !isObject(step)) {
+    return;
+  }
+  const sessionId = session["id"];
+  const turnId = turn["id"];
+  const stepIndex = step["index"];
+  if (typeof sessionId !== "string" || typeof turnId !== "string" || typeof stepIndex !== "number" || !Number.isInteger(stepIndex)) {
+    return;
+  }
+  const captured = capturedModelInput(input["modelInput"]);
+  if (!captured) {
+    return;
+  }
+  const key = llmInputKey(sessionId, turnId, stepIndex);
+  state.update((current) => {
+    const normalized = normalizeEveTraceState(current);
+    const llmInputs = [...normalized.llmInputs, { input: captured, key }];
+    return {
+      ...normalized,
+      llmInputs: llmInputs.slice(-MAX_STORED_LLM_INPUTS)
+    };
+  });
+}
+function consumeCapturedEveModelInput(state, sessionId, turnId, stepIndex) {
+  try {
+    const key = llmInputKey(sessionId, turnId, stepIndex);
+    let input;
+    state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      const index = normalized.llmInputs.findIndex(
+        (candidate) => candidate.key === key
+      );
+      if (index < 0) {
+        return normalized;
+      }
+      input = normalized.llmInputs[index]?.input;
+      return {
+        ...normalized,
+        llmInputs: normalized.llmInputs.filter(
+          (_, candidateIndex) => candidateIndex !== index
+        )
+      };
+    });
+    return input;
+  } catch (error) {
+    debugLogger.warn("Error in Eve LLM input consumption:", error);
+    return void 0;
+  }
+}
+function capturedModelInput(modelInput) {
+  if (!isObject(modelInput)) {
+    return void 0;
+  }
+  const messages = modelInput["messages"];
+  if (!Array.isArray(messages)) {
+    return void 0;
+  }
+  const instructions = modelInput["instructions"];
+  const value = [
+    ...instructions !== void 0 ? [{ content: instructions, role: "system" }] : [],
+    ...messages
+  ];
+  try {
+    const cloned = JSON.parse(JSON.stringify(value));
+    if (!Array.isArray(cloned)) {
+      return void 0;
+    }
+    return cloned;
+  } catch {
+    return void 0;
+  }
+}
+function isCapturedModelInput(input) {
+  return Array.isArray(input);
+}
+function llmInputKey(sessionId, turnId, stepIndex) {
+  return `${sessionId}\0${turnId}\0${stepIndex}`;
+}
+function modelMetadataFromRuntime(runtime) {
+  if (!isObject(runtime)) {
+    return {};
+  }
+  const modelId = runtime["modelId"];
+  return typeof modelId === "string" ? modelMetadataFromModelId(modelId) : {};
+}
+function modelMetadataFromModelId(modelId) {
+  const normalized = modelId.trim();
+  if (!normalized) {
+    return {};
+  }
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex > 0 && slashIndex < normalized.length - 1) {
+    return {
+      model: normalized.slice(slashIndex + 1),
+      provider: normalized.slice(0, slashIndex)
+    };
+  }
+  return {
+    model: normalized
+  };
+}
+function sessionIdFromContext(ctx) {
+  if (!isObject(ctx)) {
+    return void 0;
+  }
+  const session = ctx["session"];
+  if (!isObject(session)) {
+    return void 0;
+  }
+  const id = session["id"];
+  return typeof id === "string" ? id : void 0;
+}
+function toolMetadataFromTurn(turn) {
+  const { model: _model, provider: _provider, ...metadata } = turn.metadata;
+  return metadata;
+}
+function parentLineageFromContext(ctx) {
+  if (!isObject(ctx)) {
+    return void 0;
+  }
+  const session = ctx.session;
+  if (!isObject(session)) {
+    return void 0;
+  }
+  const parent = session["parent"];
+  if (!isObject(parent)) {
+    return void 0;
+  }
+  const callId = parent["callId"];
+  const rootSessionId = parent["rootSessionId"];
+  const sessionId = parent["sessionId"];
+  if (typeof callId !== "string" || typeof rootSessionId !== "string" || typeof sessionId !== "string") {
+    return void 0;
+  }
+  return { callId, rootSessionId, sessionId };
+}
+function isToolCallAction(action) {
+  return isObject(action) && action["kind"] === "tool-call" && typeof action["callId"] === "string" && typeof action["toolName"] === "string" && isObject(action["input"]);
+}
+function isLocalSubagentCallAction(action) {
+  return isObject(action) && action["kind"] === "subagent-call" && typeof action["callId"] === "string" && isObject(action["input"]);
+}
+function isTraceableActionRequest(action) {
+  return isToolCallAction(action) || isLocalSubagentCallAction(action);
+}
+function isToolResult(result) {
+  return isObject(result) && result["kind"] === "tool-result" && typeof result["callId"] === "string" && typeof result["toolName"] === "string";
+}
+function isSubagentResult(result) {
+  return isObject(result) && result["kind"] === "subagent-result" && typeof result["callId"] === "string" && typeof result["subagentName"] === "string";
+}
+function normalizedFinishReason(finishReason) {
+  switch (finishReason) {
+    case "content-filter":
+      return "content_filter";
+    case "tool-calls":
+      return "tool_calls";
+    default:
+      return finishReason;
+  }
+}
+function errorFromMessage(message, code, details) {
+  const error = new Error(`${code}: ${message}`);
+  if (details !== void 0) {
+    error.cause = details;
+  }
+  return error;
+}
+function actionResultError(error, output) {
+  if (error) {
+    return errorFromMessage(error.message, error.code);
+  }
+  const result = new Error("Eve action failed");
+  if (output !== void 0) {
+    result.cause = output;
+  }
+  return result;
+}
+function eventTime2(event) {
+  if (!event.meta?.at) {
+    return void 0;
+  }
+  const timestamp = Date.parse(event.meta.at);
+  return Number.isFinite(timestamp) ? timestamp / 1e3 : void 0;
+}
+function turnKey2(sessionId, turnId) {
+  return `${sessionId}:${turnId}`;
+}
+function toolKey3(sessionId, callId) {
+  return `${sessionId}:${callId}`;
+}
+async function rootSpanIdForSession(sessionId) {
+  return deterministicEveId("eve:root", sessionId);
+}
+async function generateEveIds(kind, ...parts) {
+  const [rowId, spanId] = await Promise.all([
+    deterministicEveId(`eve:row:${kind}`, ...parts),
+    deterministicEveId(`eve:${kind}`, ...parts)
+  ]);
+  return { rowId, spanId };
+}
+async function spanIdForSubagent(sessionId, callId) {
+  return deterministicEveId("eve:subagent", sessionId, callId);
+}
+async function deterministicEveId(...parts) {
+  const data = new TextEncoder().encode(
+    parts.map((part) => `${part.length}:${part}`).join("\0")
+  );
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", data);
+  const bytes = Array.from(new Uint8Array(digest, 0, 16));
+  const hex = bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 // src/typed-instrumentation-helpers.ts
 var TypedApplyProxy = Proxy;
 
@@ -33085,7 +34614,13 @@ var BraintrustObservabilityExporter = class {
     const args = {
       name: exported.name,
       spanAttributes: { type: spanTypeFor(exported.type) },
-      startTime: epochSeconds(exported.startTime)
+      startTime: epochSeconds(exported.startTime),
+      // Use the Mastra span id as the Braintrust row id so that
+      // `logFeedback({ id: <mastra span id> })` (and Mastra's score events)
+      // attach to the right row. Without this, `SpanImpl` auto-generates a
+      // row id (`this._id = eventId ?? idGenerator.getSpanId()`) that no
+      // external caller could know.
+      event: { id: exported.id }
     };
     const parentRecord = exported.parentSpanId ? this.spans.get(exported.parentSpanId) : void 0;
     if (!this.capturedParent) {
@@ -39420,6 +40955,8 @@ export {
   addAzureBlobHeaders,
   agentAssertionScorer,
   braintrustAISDKTelemetry,
+  braintrustEveHook,
+  braintrustEveInstrumentation,
   braintrustFlueInstrumentation,
   braintrustFlueObserver,
   braintrustStreamChunkSchema,