braintrust 3.23.0 → 3.24.0

package/dist/edge-light.mjs

@@ -21,6 +21,7 @@ var DefaultChannel = class {
   constructor(name) {
     this.name = name;
   }
+  name;
   hasSubscribers = false;
   subscribe(_subscription) {
   }
@@ -1077,6 +1078,7 @@ var SpanComponentsV3 = class _SpanComponentsV3 {
   constructor(data) {
     this.data = data;
   }
+  data;
   toStr() {
     const jsonObj = {
       compute_object_metadata_args: this.data.compute_object_metadata_args || void 0,
@@ -1584,6 +1586,7 @@ var SpanComponentsV4 = class _SpanComponentsV4 {
   constructor(data) {
     this.data = data;
   }
+  data;
   toStr() {
     const jsonObj = {
       compute_object_metadata_args: this.data.compute_object_metadata_args || void 0,
@@ -4819,6 +4822,97 @@ var SpanCache = class {
   }
 };
 
+// src/span-origin.ts
+var SDK_VERSION = true ? "3.24.0" : "0.0.0";
+function detectSpanOriginEnvironment(explicit) {
+  if (explicit) return explicit;
+  const envType = isomorph_default.getEnv("BRAINTRUST_ENVIRONMENT_TYPE");
+  const envName = isomorph_default.getEnv("BRAINTRUST_ENVIRONMENT_NAME");
+  if (envType || envName) {
+    return {
+      ...envType ? { type: envType } : {},
+      ...envName ? { name: envName } : {}
+    };
+  }
+  const ci = firstPresent([
+    ["GITHUB_ACTIONS", "github_actions"],
+    ["GITLAB_CI", "gitlab_ci"],
+    ["CIRCLECI", "circleci"],
+    ["BUILDKITE", "buildkite"],
+    ["JENKINS_URL", "jenkins"],
+    ["JENKINS_HOME", "jenkins"],
+    ["TF_BUILD", "azure_pipelines"],
+    ["TEAMCITY_VERSION", "teamcity"],
+    ["TRAVIS", "travis"],
+    ["BITBUCKET_BUILD_NUMBER", "bitbucket"]
+  ]);
+  if (ci) return { type: "ci", name: ci };
+  if (isomorph_default.getEnv("CI")) return { type: "ci", name: "ci" };
+  const earlyServer = firstPresent([
+    ["VERCEL", "vercel"],
+    ["NETLIFY", "netlify"]
+  ]);
+  if (earlyServer) return { type: "server", name: earlyServer };
+  if (isomorph_default.getEnv("ECS_CONTAINER_METADATA_URI") || isomorph_default.getEnv("ECS_CONTAINER_METADATA_URI_V4")) {
+    return { type: "server", name: "ecs" };
+  }
+  const awsExecutionEnv = isomorph_default.getEnv("AWS_EXECUTION_ENV");
+  if (awsExecutionEnv?.startsWith("AWS_ECS_")) {
+    return { type: "server", name: "ecs" };
+  }
+  if (awsExecutionEnv?.startsWith("AWS_Lambda_")) {
+    return { type: "server", name: "aws_lambda" };
+  }
+  if (isomorph_default.getEnv("AWS_LAMBDA_FUNCTION_NAME")) {
+    return { type: "server", name: "aws_lambda" };
+  }
+  const server = firstPresent([
+    ["K_SERVICE", "cloud_run"],
+    ["FUNCTION_TARGET", "gcp_functions"],
+    ["KUBERNETES_SERVICE_HOST", "kubernetes"],
+    ["DYNO", "heroku"],
+    ["FLY_APP_NAME", "fly"],
+    ["RAILWAY_ENVIRONMENT", "railway"],
+    ["RENDER_SERVICE_NAME", "render"]
+  ]);
+  if (server) return { type: "server", name: server };
+  return deploymentModeEnvironment("NODE_ENV", isomorph_default.getEnv("NODE_ENV"));
+}
+function makeSpanOrigin(instrumentationName, environment) {
+  return {
+    name: "braintrust.sdk.javascript",
+    version: SDK_VERSION,
+    instrumentation: { name: instrumentationName },
+    ...environment ? { environment } : {}
+  };
+}
+function mergeSpanOriginContext(context, instrumentationName, environment) {
+  const next = { ...context ?? {} };
+  const current = isObject2(next.span_origin) ? { ...next.span_origin } : {};
+  next.span_origin = {
+    ...makeSpanOrigin(instrumentationName, environment),
+    ...current
+  };
+  return next;
+}
+function firstPresent(entries) {
+  return entries.find(([key]) => Boolean(isomorph_default.getEnv(key)))?.[1];
+}
+function deploymentModeEnvironment(_key, value) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "production" || normalized === "staging") {
+    return { type: "server", name: normalized };
+  }
+  if (normalized === "development" || normalized === "local") {
+    return { type: "local", name: normalized };
+  }
+  return { name: value };
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/logger.ts
 var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
@@ -4867,6 +4961,7 @@ var LoginInvalidOrgError = class extends Error {
     super(message);
     this.message = message;
   }
+  message;
 };
 var REDACTION_FIELDS = [
   "input",
@@ -4882,6 +4977,8 @@ var MaskingError = class {
     this.fieldName = fieldName;
     this.errorType = errorType;
   }
+  fieldName;
+  errorType;
   get errorMsg() {
     return `ERROR: Failed to mask field '${this.fieldName}' - ${this.errorType}`;
   }
@@ -5091,7 +5188,9 @@ var BraintrustState = class _BraintrustState {
       diskCache: parametersDiskCache
     });
     this.spanCache = new SpanCache({ disabled: loginParams.disableSpanCache });
+    this.spanOriginEnvironment = detectSpanOriginEnvironment();
   }
+  loginParams;
   id;
   currentExperiment;
   // Note: the value of IsAsyncFlush doesn't really matter here, since we
@@ -5126,6 +5225,7 @@ var BraintrustState = class _BraintrustState {
   _idGenerator = null;
   _contextManager = null;
   _otelFlushCallback = null;
+  spanOriginEnvironment;
   resetLoginInfo() {
     this.appUrl = null;
     this.appPublicUrl = null;
@@ -7744,6 +7844,7 @@ function initLogger(options = {}) {
     orgName,
     forceLogin,
     debugLogLevel,
+    environment,
     fetch: fetch2,
     state: stateArg
   } = options || {};
@@ -7760,6 +7861,7 @@ function initLogger(options = {}) {
   };
   const state = stateArg ?? _globalState;
   state.setDebugLogLevel(debugLogLevel);
+  state.spanOriginEnvironment = detectSpanOriginEnvironment(environment);
   state.enforceQueueSizeLimit(true);
   const lazyMetadata = new LazyValue(
     async () => {
@@ -8951,6 +9053,11 @@ var ObjectFetcher = class {
     this._internal_btql = _internal_btql;
     this._internalBrainstoreRealtime = _internalBrainstoreRealtime;
   }
+  objectType;
+  pinnedVersion;
+  mutateRecord;
+  _internal_btql;
+  _internalBrainstoreRealtime;
   _fetchedData = void 0;
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
@@ -9389,6 +9496,8 @@ var ReadonlyExperiment = class extends ObjectFetcher {
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
+  state;
+  lazyMetadata;
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).experiment.id;
@@ -9511,7 +9620,11 @@ var SpanImpl = class _SpanImpl {
       metrics: {
         start: args.startTime ?? getCurrentUnixTimestamp()
       },
-      context: { ...callerLocation },
+      context: mergeSpanOriginContext(
+        { ...callerLocation },
+        "braintrust-js-logger",
+        this._state.spanOriginEnvironment
+      ),
       span_attributes: {
         name,
         type,
@@ -9885,6 +9998,7 @@ var Dataset2 = class extends ObjectFetcher {
     this.pinnedEnvironment = pinState?.pinnedEnvironment;
     this.pinnedSnapshotName = pinState?.pinnedSnapshotName;
   }
+  state;
   lazyMetadata;
   __braintrust_dataset_marker = true;
   newRecords = 0;
@@ -10399,6 +10513,9 @@ var Prompt2 = class _Prompt {
     this.noTrace = noTrace;
     void this.__braintrust_prompt_marker;
   }
+  metadata;
+  defaults;
+  noTrace;
   parsedPromptData;
   hasParsedPromptData = false;
   __braintrust_prompt_marker = true;
@@ -10636,6 +10753,7 @@ var RemoteEvalParameters = class {
     this.metadata = metadata;
     void this.__braintrust_parameters_marker;
   }
+  metadata;
   __braintrust_parameters_marker = true;
   get id() {
     return this.metadata.id;
@@ -15224,6 +15342,24 @@ var aiSDKChannels = defineChannels("ai", {
     kind: "sync-stream"
   })
 });
+var harnessAgentChannels = defineChannels("@ai-sdk/harness", {
+  generate: channel({
+    channelName: "HarnessAgent.generate",
+    kind: "async"
+  }),
+  stream: channel({
+    channelName: "HarnessAgent.stream",
+    kind: "async"
+  }),
+  continueGenerate: channel({
+    channelName: "HarnessAgent.continueGenerate",
+    kind: "async"
+  }),
+  continueStream: channel({
+    channelName: "HarnessAgent.continueStream",
+    kind: "async"
+  })
+});
 
 // src/instrumentation/plugins/ai-sdk-plugin.ts
 var DEFAULT_DENY_OUTPUT_PATHS = [
@@ -15492,6 +15628,84 @@ var AISDKPlugin = class extends BasePlugin {
         })
       })
     );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.generate, {
+        name: "HarnessAgent.generate",
+        type: "task" /* TASK */,
+        extractInput: ([params], event) => prepareAISDKHarnessAgentInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result) => extractTokenMetrics(result),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.stream, {
+        name: "HarnessAgent.stream",
+        type: "task" /* TASK */,
+        extractInput: ([params], event) => prepareAISDKHarnessAgentInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result, startTime) => ({
+          ...extractTokenMetrics(result),
+          ...startTime === void 0 ? {} : {
+            time_to_first_token: getCurrentUnixTimestamp() - startTime
+          }
+        }),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          result,
+          resolvePromiseUsage: true,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.continueGenerate, {
+        name: "HarnessAgent.continueGenerate",
+        type: "task" /* TASK */,
+        extractInput: ([params], event) => prepareAISDKHarnessAgentInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result) => extractTokenMetrics(result),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(harnessAgentChannels.continueStream, {
+        name: "HarnessAgent.continueStream",
+        type: "task" /* TASK */,
+        extractInput: ([params], event) => prepareAISDKHarnessAgentInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result, startTime) => ({
+          ...extractTokenMetrics(result),
+          ...startTime === void 0 ? {} : {
+            time_to_first_token: getCurrentUnixTimestamp() - startTime
+          }
+        }),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          result,
+          resolvePromiseUsage: true,
+          span,
+          startTime
+        })
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.toolLoopAgentGenerate, {
         name: "ToolLoopAgent.generate",
@@ -16022,6 +16236,45 @@ function prepareAISDKCallInput(params, event, span, defaultDenyOutputPaths, chil
     metadata
   };
 }
+function prepareAISDKHarnessAgentInput(params, self) {
+  if (isObject(self)) {
+    try {
+      if (isObject(self.settings)) {
+        const settings = self.settings;
+        if (settings.telemetry === void 0) {
+          Reflect.set(self, "settings", { ...settings, telemetry: {} });
+        }
+      }
+    } catch {
+    }
+  }
+  const selectedInput = {};
+  if (params.prompt !== void 0) {
+    selectedInput.prompt = params.prompt;
+  }
+  if (params.messages !== void 0) {
+    selectedInput.messages = params.messages;
+  }
+  if (params.toolApprovalContinuations !== void 0) {
+    selectedInput.toolApprovalContinuations = params.toolApprovalContinuations;
+  }
+  const metadata = extractMetadataFromCallParams({}, self);
+  if (isObject(params.session) && typeof params.session.sessionId === "string") {
+    metadata.sessionId = params.session.sessionId;
+  }
+  if (isObject(self)) {
+    if (typeof self.harnessId === "string") {
+      metadata.harnessId = self.harnessId;
+    }
+    if (typeof self.permissionMode === "string") {
+      metadata.permissionMode = self.permissionMode;
+    }
+  }
+  return {
+    input: processAISDKCallInput(selectedInput).input,
+    metadata
+  };
+}
 function prepareAISDKWorkflowAgentStreamInput(params, event, span, defaultDenyOutputPaths) {
   registerWorkflowAgentWrapperSpan(span);
   const { input } = processAISDKWorkflowAgentCallInput(params);
@@ -16869,6 +17122,7 @@ function patchAISDKStreamingResult(args) {
     endEvent,
     onComplete,
     result,
+    resolvePromiseUsage,
     span,
     startTime
   } = args;
@@ -16895,6 +17149,22 @@ function patchAISDKStreamingResult(args) {
     outputLogged = true;
     try {
       const metrics = extractTopLevelAISDKMetrics(result, endEvent);
+      if (resolvePromiseUsage) {
+        try {
+          const resultRecord2 = result;
+          const pendingUsage = resultRecord2.totalUsage ?? resultRecord2.usage;
+          if (isPromiseLike(pendingUsage)) {
+            const usage = await Promise.resolve(pendingUsage);
+            if (isObject(usage)) {
+              Object.assign(
+                metrics,
+                extractTokenMetrics({ usage })
+              );
+            }
+          }
+        } catch {
+        }
+      }
       if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
         metrics.time_to_first_token = firstChunkTime - startTime;
       }
@@ -18125,8 +18395,6 @@ function filterSerializableOptions(options) {
     "additionalDirectories",
     "permissionMode",
     "debug",
-    "apiKey",
-    "apiKeySource",
     "agentName",
     "instructions"
   ];
@@ -29154,6 +29422,16 @@ function cleanObject(obj) {
     })
   );
 }
+function normalizeTokenMetrics(obj) {
+  const metrics = cleanObject(obj);
+  if (metrics.total_tokens !== void 0) {
+    metrics.tokens = metrics.total_tokens;
+  } else if (metrics.prompt_tokens !== void 0 && metrics.completion_tokens !== void 0) {
+    metrics.tokens = metrics.prompt_tokens + metrics.completion_tokens;
+  }
+  delete metrics.total_tokens;
+  return metrics;
+}
 function walkGenerations(response) {
   const result = [];
   const generations = response.generations || [];
@@ -29200,7 +29478,7 @@ function getMetricsFromResponse(response) {
       continue;
     }
     const inputTokenDetails = usageMetadata.input_token_details;
-    return cleanObject({
+    return normalizeTokenMetrics({
       total_tokens: usageMetadata.total_tokens,
       prompt_tokens: usageMetadata.input_tokens,
       completion_tokens: usageMetadata.output_tokens,
@@ -29210,7 +29488,7 @@ function getMetricsFromResponse(response) {
   }
   const llmOutput = response.llmOutput || {};
   const tokenUsage = isRecord(llmOutput.tokenUsage) ? llmOutput.tokenUsage : isRecord(llmOutput.estimatedTokens) ? llmOutput.estimatedTokens : {};
-  return cleanObject({
+  return normalizeTokenMetrics({
     total_tokens: tokenUsage.totalTokens,
     prompt_tokens: tokenUsage.promptTokens,
     completion_tokens: tokenUsage.completionTokens
@@ -32814,6 +33092,26 @@ function wrapAISDK(aiSDK, options = {}) {
     }
   });
 }
+function isHarnessAgentInstance(instance) {
+  try {
+    const visited = /* @__PURE__ */ new Set();
+    let prototype = Object.getPrototypeOf(instance);
+    while (prototype !== null && !visited.has(prototype)) {
+      visited.add(prototype);
+      const constructor = Object.getOwnPropertyDescriptor(
+        prototype,
+        "constructor"
+      )?.value;
+      const constructorName = typeof constructor === "function" ? Object.getOwnPropertyDescriptor(constructor, "name")?.value : void 0;
+      if (constructorName === "HarnessAgent") {
+        return true;
+      }
+      prototype = Object.getPrototypeOf(prototype);
+    }
+  } catch {
+  }
+  return false;
+}
 var wrapAgentClass = (AgentClass, options = {}) => {
   const typedAgentClass = AgentClass;
   return new Proxy(typedAgentClass, {
@@ -32823,9 +33121,46 @@ var wrapAgentClass = (AgentClass, options = {}) => {
         args,
         newTarget
       );
+      const harnessAgent = isHarnessAgentInstance(instance) ? instance : null;
       return new Proxy(instance, {
         get(instanceTarget, prop, instanceReceiver) {
           const original = Reflect.get(instanceTarget, prop, instanceTarget);
+          if (harnessAgent && typeof original === "function") {
+            switch (prop) {
+              case "generate":
+                return wrapHarnessAgentGenerate(
+                  original,
+                  harnessAgent,
+                  harnessAgentChannels.generate,
+                  "HarnessAgent.generate",
+                  options
+                );
+              case "stream":
+                return wrapHarnessAgentStream(
+                  original,
+                  harnessAgent,
+                  harnessAgentChannels.stream,
+                  "HarnessAgent.stream",
+                  options
+                );
+              case "continueGenerate":
+                return wrapHarnessAgentGenerate(
+                  original,
+                  harnessAgent,
+                  harnessAgentChannels.continueGenerate,
+                  "HarnessAgent.continueGenerate",
+                  options
+                );
+              case "continueStream":
+                return wrapHarnessAgentStream(
+                  original,
+                  harnessAgent,
+                  harnessAgentChannels.continueStream,
+                  "HarnessAgent.continueStream",
+                  options
+                );
+            }
+          }
           if (prop === "generate" && typeof original === "function" && instanceTarget.constructor.name !== "WorkflowAgent") {
             return wrapAgentGenerate(original, instanceTarget, options);
           }
@@ -32841,6 +33176,26 @@ var wrapAgentClass = (AgentClass, options = {}) => {
     }
   });
 };
+var wrapHarnessAgentGenerate = (generate, instance, channel2, name, options) => makeGenerateTextWrapper(
+  channel2,
+  name,
+  generate.bind(instance),
+  {
+    self: instance,
+    spanType: "task" /* TASK */
+  },
+  options
+);
+var wrapHarnessAgentStream = (stream, instance, channel2, name, options) => makeStreamWrapper(
+  channel2,
+  name,
+  stream.bind(instance),
+  {
+    self: instance,
+    spanType: "task" /* TASK */
+  },
+  options
+);
 var wrapAgentGenerate = (generate, instance, options = {}) => {
   const defaultName = `${instance.constructor.name}.generate`;
   return async (params) => makeGenerateTextWrapper(
@@ -33067,6 +33422,7 @@ var BraintrustLanguageModelWrapper = class {
       this.supportsUrl = (url) => this.model.supportsUrl(url);
     }
   }
+  model;
   supportsUrl;
   get specificationVersion() {
     return this.model.specificationVersion;
@@ -33649,6 +34005,7 @@ function BraintrustMiddleware(config = {}) {
 var EVE_TRACE_STATE_KEY = "braintrust.eve.tracing";
 var MAX_EVE_CACHE_ENTRIES = 1e4;
 var MAX_STORED_LLM_INPUTS = 100;
+var MAX_STORED_REASONING_BLOCKS = 100;
 var MAX_STORED_SPAN_REFERENCES = 1e4;
 var MAX_STORED_STEP_STARTS = 1e4;
 function braintrustEveHook(options) {
@@ -33687,6 +34044,7 @@ var ResumedEveSpan = class {
     this.reference = reference;
     this.endTime = reference.endTime;
   }
+  reference;
   endTime;
   get rootSpanId() {
     return this.reference.rootSpanId;
@@ -33719,6 +34077,7 @@ var EveBridge = class {
   constructor(state) {
     this.state = state;
   }
+  state;
   eventQueuesBySession = /* @__PURE__ */ new Map();
   completedToolKeys = new LRUCache({
     max: MAX_EVE_CACHE_ENTRIES
@@ -33897,6 +34256,9 @@ var EveBridge = class {
       case "step.started":
         await this.handleStepStarted(event, ctx, hookMetadata);
         return true;
+      case "reasoning.completed":
+        this.handleReasoningCompleted(event, ctx);
+        return true;
       case "message.completed":
         this.handleMessageCompleted(event, ctx);
         return true;
@@ -33988,6 +34350,7 @@ var EveBridge = class {
       key,
       metadata,
       metrics: {},
+      sessionId,
       span,
       stepsByIndex: /* @__PURE__ */ new Map(),
       turnId: event.data.turnId
@@ -34018,6 +34381,12 @@ var EveBridge = class {
       const endTime = eventTime2(event);
       existing.span.end(endTime === void 0 ? void 0 : { endTime });
       this.markStepEnded(event.data.turnId, event.data.stepIndex);
+      clearStoredEveReasoning(
+        this.state,
+        sessionId,
+        event.data.turnId,
+        event.data.stepIndex
+      );
     }
     const stepOrdinal = this.stepOrdinal(event);
     const metadata = { ...turn.metadata };
@@ -34027,6 +34396,13 @@ var EveBridge = class {
       event.data.turnId,
       event.data.stepIndex
     );
+    const reasoning = readStoredEveReasoning(
+      this.state,
+      sessionId,
+      event.data.turnId,
+      event.data.stepIndex
+    );
+    const output = mergeEveReasoning(void 0, reasoning);
     const { rowId: eventId, spanId } = await generateEveIds(
       "step",
       sessionId,
@@ -34044,32 +34420,52 @@ var EveBridge = class {
       spanId,
       startTime: eventTime2(event)
     });
-    span.log({ ...input !== void 0 ? { input } : {}, metadata });
+    span.log({
+      ...input !== void 0 ? { input } : {},
+      metadata
+    });
     turn.stepsByIndex.set(event.data.stepIndex, {
       ...input !== void 0 ? { input } : {},
       metadata,
       metrics: {},
+      ...output !== void 0 ? { output } : {},
+      reasoning,
       span
     });
   }
+  handleReasoningCompleted(event, ctx) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const reasoning = storeEveReasoning(this.state, sessionId, event);
+    const step = this.stepForEvent(event, ctx);
+    if (step) {
+      step.reasoning = reasoning;
+      step.output = mergeEveReasoning(step.output, reasoning);
+    }
+  }
   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 existingMessage = eveOutputMessage(step.output);
     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 } : {}
+    step.output = mergeEveReasoning(
+      [
+        {
+          finish_reason: normalizedFinishReason(event.data.finishReason),
+          index: 0,
+          message: {
+            content: event.data.message,
+            role: "assistant",
+            ...Array.isArray(existingToolCalls) ? { tool_calls: existingToolCalls } : {}
+          }
         }
-      }
-    ];
+      ],
+      step.reasoning
+    );
     const turn = this.turnForEvent(event, ctx);
     if (turn && event.data.finishReason !== "tool-calls") {
       turn.output = event.data.message;
@@ -34078,16 +34474,19 @@ var EveBridge = class {
   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"
+      step.output = mergeEveReasoning(
+        [
+          {
+            finish_reason: "stop",
+            index: 0,
+            message: {
+              content: event.data.result,
+              role: "assistant"
+            }
           }
-        }
-      ];
+        ],
+        step.reasoning
+      );
     }
     const turn = this.turnForEvent(event, ctx);
     if (turn) {
@@ -34137,18 +34536,20 @@ var EveBridge = class {
         type: "function"
       });
     }
-    step.output = [
-      {
-        finish_reason: "tool_calls",
-        index: 0,
-        message: {
-          content: null,
-          role: "assistant",
-          tool_calls: [...toolCallsById.values()]
+    step.output = mergeEveReasoning(
+      [
+        {
+          finish_reason: "tool_calls",
+          index: 0,
+          message: {
+            content: null,
+            role: "assistant",
+            tool_calls: [...toolCallsById.values()]
+          }
         }
-      }
-    ];
-    step.span.log({ metadata: step.metadata, output: step.output });
+      ],
+      step.reasoning
+    );
   }
   async handleActionResult(event, ctx, hookMetadata) {
     if (isToolResult(event.data.result)) {
@@ -34326,6 +34727,7 @@ var EveBridge = class {
       ...costUsd !== void 0 ? { estimated_cost: costUsd } : {}
     };
     step.metrics = { ...step.metrics, ...metrics };
+    const sessionId = sessionIdFromContext(ctx);
     if (Array.isArray(step.output) && isObject(step.output[0])) {
       const finishReason = step.output[0].finish_reason;
       if (typeof finishReason !== "string") {
@@ -34350,6 +34752,14 @@ var EveBridge = class {
       turn.stepsByIndex.delete(event.data.stepIndex);
     }
     this.markStepEnded(event.data.turnId, event.data.stepIndex);
+    if (sessionId) {
+      clearStoredEveReasoning(
+        this.state,
+        sessionId,
+        event.data.turnId,
+        event.data.stepIndex
+      );
+    }
   }
   handleStepFailed(event, ctx) {
     const step = this.stepForEvent(event, ctx);
@@ -34367,6 +34777,15 @@ var EveBridge = class {
     const turn = this.turnForEvent(event, ctx);
     turn?.stepsByIndex.delete(event.data.stepIndex);
     this.markStepEnded(event.data.turnId, event.data.stepIndex);
+    const sessionId = sessionIdFromContext(ctx);
+    if (sessionId) {
+      clearStoredEveReasoning(
+        this.state,
+        sessionId,
+        event.data.turnId,
+        event.data.stepIndex
+      );
+    }
   }
   handleTurnCompleted(event, ctx) {
     const turn = this.turnForEvent(event, ctx);
@@ -34464,6 +34883,7 @@ var EveBridge = class {
       key,
       metadata,
       metrics: {},
+      sessionId,
       span,
       stepsByIndex: /* @__PURE__ */ new Map(),
       turnId: event.data.turnId
@@ -34726,6 +35146,9 @@ var EveBridge = class {
       const normalized = normalizeEveTraceState(current);
       return {
         ...normalized,
+        reasoningBlocks: normalized.reasoningBlocks.filter(
+          (entry) => !entry.key.startsWith(`${turn.sessionId}\0${turn.turnId}\0`)
+        ),
         stepStarts: normalized.stepStarts.filter(
           (entry) => entry.turnId !== turn.turnId
         )
@@ -34765,6 +35188,7 @@ function emptyEveTraceState() {
   return {
     llmInputs: [],
     metadata: {},
+    reasoningBlocks: [],
     spanReferences: [],
     stepStarts: []
   };
@@ -34815,6 +35239,21 @@ function normalizeEveTraceState(state) {
     const input = entry["input"];
     return typeof key === "string" && isCapturedModelInput(input) ? [{ input, key }] : [];
   }).slice(-MAX_STORED_LLM_INPUTS) : [];
+  const reasoningBlocks = Array.isArray(state["reasoningBlocks"]) ? state["reasoningBlocks"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const content = entry["content"];
+    const eventAt = entry["eventAt"];
+    const key = entry["key"];
+    return typeof content === "string" && (eventAt === void 0 || typeof eventAt === "string") && typeof key === "string" ? [
+      {
+        content,
+        ...typeof eventAt === "string" ? { eventAt } : {},
+        key
+      }
+    ] : [];
+  }).slice(-MAX_STORED_REASONING_BLOCKS) : [];
   const stepStarts = Array.isArray(state["stepStarts"]) ? state["stepStarts"].flatMap((entry) => {
     if (!isObject(entry)) {
       return [];
@@ -34825,7 +35264,13 @@ function normalizeEveTraceState(state) {
     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 };
+  return {
+    llmInputs,
+    metadata: { ...metadata },
+    reasoningBlocks,
+    spanReferences,
+    stepStarts
+  };
 }
 function readEveTraceState(state) {
   try {
@@ -34834,23 +35279,85 @@ function readEveTraceState(state) {
     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;
+function storeEveReasoning(state, sessionId, event) {
+  const eventAt = event.meta?.at;
+  const key = llmInputKey(sessionId, event.data.turnId, event.data.stepIndex);
+  let stored = [];
+  state.update((current) => {
+    const normalized = normalizeEveTraceState(current);
+    const alreadyStored = normalized.reasoningBlocks.some(
+      (entry) => entry.content === event.data.reasoning && entry.eventAt === eventAt && entry.key === key
+    );
+    const reasoningBlocks = alreadyStored ? normalized.reasoningBlocks : [
+      ...normalized.reasoningBlocks,
+      {
+        content: event.data.reasoning,
+        ...eventAt ? { eventAt } : {},
+        key
+      }
+    ].slice(-MAX_STORED_REASONING_BLOCKS);
+    stored = reasoningBlocks.flatMap(
+      (entry) => entry.key === key ? [
+        {
+          content: entry.content,
+          ...entry.eventAt ? { eventAt: entry.eventAt } : {}
+        }
+      ] : []
+    );
+    return alreadyStored ? normalized : { ...normalized, reasoningBlocks };
+  });
+  return stored;
+}
+function readStoredEveReasoning(state, sessionId, turnId, stepIndex) {
+  const key = llmInputKey(sessionId, turnId, stepIndex);
+  return readEveTraceState(state).reasoningBlocks.flatMap(
+    (entry) => entry.key === key ? [
+      {
+        content: entry.content,
+        ...entry.eventAt ? { eventAt: entry.eventAt } : {}
+      }
+    ] : []
+  );
+}
+function clearStoredEveReasoning(state, sessionId, turnId, stepIndex) {
+  const key = llmInputKey(sessionId, turnId, stepIndex);
+  state.update((current) => {
+    const normalized = normalizeEveTraceState(current);
+    return {
+      ...normalized,
+      reasoningBlocks: normalized.reasoningBlocks.filter(
+        (entry) => entry.key !== key
+      )
+    };
+  });
+}
+function eveOutputMessage(output) {
+  return Array.isArray(output) && isObject(output[0]) ? output[0]["message"] : void 0;
+}
+function mergeEveReasoning(output, reasoning) {
+  if (reasoning.length === 0) {
+    return output;
   }
-  const captured = capturedModelInput(input["modelInput"]);
+  const choice = Array.isArray(output) && isObject(output[0]) ? output[0] : {};
+  const message = isObject(choice["message"]) ? choice["message"] : {};
+  return [
+    {
+      ...choice,
+      index: typeof choice["index"] === "number" ? choice["index"] : 0,
+      message: {
+        ...message,
+        content: "content" in message ? message["content"] : null,
+        reasoning: reasoning.map((block) => ({ content: block.content })),
+        role: typeof message["role"] === "string" ? message["role"] : "assistant"
+      }
+    }
+  ];
+}
+function captureEveModelInput(state, input) {
+  const sessionId = input.session.id;
+  const turnId = input.turn.id;
+  const stepIndex = input.step.index;
+  const captured = capturedModelInput(input.modelInput);
   if (!captured) {
     return;
   }
@@ -34891,18 +35398,14 @@ function consumeCapturedEveModelInput(state, sessionId, turnId, stepIndex) {
   }
 }
 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
-  ];
+  const { instructions, messages } = modelInput;
+  const value = [];
+  if (typeof instructions === "string") {
+    value.push({ content: instructions, role: "system" });
+  } else if (instructions) {
+    value.push(...instructions.map(capturedEveModelMessage));
+  }
+  value.push(...messages.map(capturedEveModelMessage));
   try {
     const cloned = JSON.parse(JSON.stringify(value));
     if (!Array.isArray(cloned)) {
@@ -34913,8 +35416,123 @@ function capturedModelInput(modelInput) {
     return void 0;
   }
 }
+function capturedEveModelMessage(message) {
+  const { content, role } = message;
+  if (typeof content === "string") {
+    return { content, role };
+  }
+  return { content: content.map(capturedEveModelContentPart), role };
+}
+function capturedEveModelContentPart(part) {
+  switch (part.type) {
+    case "text":
+    case "reasoning":
+      return { text: part.text, type: part.type };
+    case "image":
+      return {
+        image: part.image,
+        ...part.mediaType !== void 0 ? { mediaType: part.mediaType } : {},
+        type: "image"
+      };
+    case "file":
+    case "reasoning-file":
+      return {
+        data: part.data,
+        ...part.type === "file" && part.filename !== void 0 ? { filename: part.filename } : {},
+        mediaType: part.mediaType,
+        type: part.type
+      };
+    case "custom":
+      return {
+        ..."kind" in part ? { kind: part.kind } : {},
+        type: "custom"
+      };
+    case "tool-call":
+      return {
+        input: part.input,
+        ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {},
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        type: "tool-call"
+      };
+    case "tool-result": {
+      const output = part.output;
+      let capturedOutput;
+      switch (output.type) {
+        case "text":
+        case "error-text":
+          capturedOutput = { type: output.type, value: output.value };
+          break;
+        case "json":
+        case "error-json":
+          capturedOutput = { type: output.type, value: output.value };
+          break;
+        case "execution-denied":
+          capturedOutput = {
+            ...output.reason !== void 0 ? { reason: output.reason } : {},
+            type: "execution-denied"
+          };
+          break;
+        case "content":
+          capturedOutput = {
+            type: "content",
+            value: output.value.map(capturedEveModelContentPart)
+          };
+          break;
+      }
+      return {
+        output: capturedOutput,
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        type: "tool-result"
+      };
+    }
+    case "tool-approval-request":
+      return {
+        approvalId: part.approvalId,
+        ...part.isAutomatic !== void 0 ? { isAutomatic: part.isAutomatic } : {},
+        ...part.signature !== void 0 ? { signature: part.signature } : {},
+        toolCallId: part.toolCallId,
+        type: "tool-approval-request"
+      };
+    case "tool-approval-response":
+      return {
+        approvalId: part.approvalId,
+        approved: part.approved,
+        ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {},
+        ...part.reason !== void 0 ? { reason: part.reason } : {},
+        type: "tool-approval-response"
+      };
+    case "file-data":
+    case "image-data":
+      return {
+        data: part.data,
+        ...part.type === "file-data" && part.filename !== void 0 ? { filename: part.filename } : {},
+        mediaType: part.mediaType,
+        type: part.type
+      };
+    case "file-url":
+    case "image-url":
+      return {
+        ...part.type === "file-url" && part.mediaType !== void 0 ? { mediaType: part.mediaType } : {},
+        type: part.type,
+        url: part.url
+      };
+    case "file-id":
+    case "image-file-id":
+      return { fileId: part.fileId, type: part.type };
+    case "file-reference":
+    case "image-file-reference":
+      return {
+        providerReference: part.providerReference,
+        type: part.type
+      };
+  }
+}
 function isCapturedModelInput(input) {
-  return Array.isArray(input);
+  return Array.isArray(input) && input.every(
+    (message) => isObject(message) && (message["role"] === "system" || message["role"] === "user" || message["role"] === "assistant" || message["role"] === "tool") && (typeof message["content"] === "string" || Array.isArray(message["content"]) && message["content"].every(isObject))
+  );
 }
 function llmInputKey(sessionId, turnId, stepIndex) {
   return `${sessionId}\0${turnId}\0${stepIndex}`;
@@ -38309,6 +38927,8 @@ var BaseNode = class {
     this.graph = graph;
     this.id = id;
   }
+  graph;
+  id;
   __type = "node";
   dependencies = [];
   addDependency(dependency) {
@@ -38342,6 +38962,7 @@ var PromptNode = class extends BaseNode {
     super(graph, id);
     this.prompt = prompt;
   }
+  prompt;
   async build(context) {
     return {
       type: "function",
@@ -38354,6 +38975,7 @@ var GateNode = class extends BaseNode {
     super(graph, id);
     this.condition = condition;
   }
+  condition;
   async build(context) {
     return {
       type: "gate",
@@ -38378,6 +39000,7 @@ var PromptTemplateNode = class extends BaseNode {
     super(graph, id);
     this.prompt = prompt;
   }
+  prompt;
   async build(context) {
     return {
       type: "prompt_template",
@@ -38390,6 +39013,7 @@ var LiteralNode = class extends BaseNode {
     super(graph, id);
     this.value = value;
   }
+  value;
   async build(context) {
     return {
       type: "literal",
@@ -39483,6 +40107,10 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     this._state = _state;
     this.spanTypeFilter = spanTypeFilter;
   }
+  _objectId;
+  rootSpanId;
+  _state;
+  spanTypeFilter;
   static buildFilter(rootSpanId, spanTypeFilter, includeScorers = false) {
     const children = [
       // Base filter: root_span_id = 'value'
@@ -39933,6 +40561,8 @@ var EvalResultWithSummary = class {
     this.summary = summary;
     this.results = results;
   }
+  summary;
+  results;
   /**
    * @deprecated Use `summary` instead.
    */
@@ -41351,6 +41981,7 @@ var ToolBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   taskCounter = 0;
   // This type definition is just a catch all so that the implementation can be
   // less specific than the two more specific declarations above.
@@ -41381,6 +42012,7 @@ var ScorerBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   taskCounter = 0;
   create(opts) {
     this.taskCounter++;
@@ -41440,6 +42072,7 @@ var ClassifierBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   taskCounter = 0;
   create(opts) {
     this.taskCounter++;
@@ -41475,6 +42108,7 @@ var CodeFunction = class {
       throw new Error("parameters are required if return type is defined");
     }
   }
+  project;
   handler;
   name;
   slug;
@@ -41562,6 +42196,7 @@ var PromptBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   create(opts) {
     const toolFunctions = [];
     const rawTools = [];
@@ -41638,6 +42273,7 @@ var ParametersBuilder = class {
   constructor(project) {
     this.project = project;
   }
+  project;
   create(opts) {
     const slug = opts.slug ?? slugify(opts.name, { lower: true, strict: true });
     const codeParameters = new CodeParameters(this.project, {