braintrust 3.29.0 → 3.30.0

package/dist/index.js

@@ -143,7 +143,7 @@
 
 
 
-var _chunkXLLGRXGRjs = require('./chunk-XLLGRXGR.js');
+var _chunkTWCDSYJNjs = require('./chunk-TWCDSYJN.js');
 
 
 
@@ -177,157 +177,160 @@ var _chunkXLLGRXGRjs = require('./chunk-XLLGRXGR.js');
 
 
 
-var _chunk6Z5S7VOUjs = require('./chunk-6Z5S7VOU.js');
+var _chunk2XDW3UCGjs = require('./chunk-2XDW3UCG.js');
 
 // src/exports.ts
 var exports_exports = {};
-_chunk6Z5S7VOUjs.__export.call(void 0, exports_exports, {
-  Attachment: () => _chunkXLLGRXGRjs.Attachment,
-  AttachmentReference: () => _chunkXLLGRXGRjs.AttachmentReference,
-  BAGGAGE_HEADER: () => _chunkXLLGRXGRjs.BAGGAGE_HEADER,
-  BRAINTRUST_CURRENT_SPAN_STORE: () => _chunkXLLGRXGRjs.BRAINTRUST_CURRENT_SPAN_STORE,
-  BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME: () => _chunkXLLGRXGRjs.BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
-  BRAINTRUST_PARENT_KEY: () => _chunkXLLGRXGRjs.BRAINTRUST_PARENT_KEY,
-  BaseAttachment: () => _chunkXLLGRXGRjs.BaseAttachment,
+_chunk2XDW3UCGjs.__export.call(void 0, exports_exports, {
+  Attachment: () => _chunkTWCDSYJNjs.Attachment,
+  AttachmentReference: () => _chunkTWCDSYJNjs.AttachmentReference,
+  BAGGAGE_HEADER: () => _chunkTWCDSYJNjs.BAGGAGE_HEADER,
+  BRAINTRUST_CURRENT_SPAN_STORE: () => _chunkTWCDSYJNjs.BRAINTRUST_CURRENT_SPAN_STORE,
+  BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME: () => _chunkTWCDSYJNjs.BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
+  BRAINTRUST_PARENT_KEY: () => _chunkTWCDSYJNjs.BRAINTRUST_PARENT_KEY,
+  BaseAttachment: () => _chunkTWCDSYJNjs.BaseAttachment,
   BaseExperiment: () => BaseExperiment,
   BatchScorer: () => BatchScorer,
   BatchTask: () => BatchTask,
-  BraintrustLangChainCallbackHandler: () => _chunkXLLGRXGRjs.BraintrustLangChainCallbackHandler,
+  BraintrustLangChainCallbackHandler: () => _chunkTWCDSYJNjs.BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
-  BraintrustObservabilityExporter: () => _chunkXLLGRXGRjs.BraintrustObservabilityExporter,
-  BraintrustState: () => _chunkXLLGRXGRjs.BraintrustState,
-  BraintrustStream: () => _chunkXLLGRXGRjs.BraintrustStream,
+  BraintrustObservabilityExporter: () => _chunkTWCDSYJNjs.BraintrustObservabilityExporter,
+  BraintrustState: () => _chunkTWCDSYJNjs.BraintrustState,
+  BraintrustStream: () => _chunkTWCDSYJNjs.BraintrustStream,
   CachedSpanFetcher: () => CachedSpanFetcher,
   CodeFunction: () => CodeFunction,
   CodePrompt: () => CodePrompt,
-  ContextManager: () => _chunkXLLGRXGRjs.ContextManager,
-  DEFAULT_FETCH_BATCH_SIZE: () => _chunkXLLGRXGRjs.DEFAULT_FETCH_BATCH_SIZE,
-  DEFAULT_MAX_REQUEST_SIZE: () => _chunkXLLGRXGRjs.DEFAULT_MAX_REQUEST_SIZE,
-  Dataset: () => _chunkXLLGRXGRjs.Dataset,
+  ContextManager: () => _chunkTWCDSYJNjs.ContextManager,
+  DEFAULT_FETCH_BATCH_SIZE: () => _chunkTWCDSYJNjs.DEFAULT_FETCH_BATCH_SIZE,
+  DEFAULT_MAX_REQUEST_SIZE: () => _chunkTWCDSYJNjs.DEFAULT_MAX_REQUEST_SIZE,
+  Dataset: () => _chunkTWCDSYJNjs.Dataset,
   DatasetPipeline: () => DatasetPipeline,
   DurableEvalMemoryStore: () => DurableEvalMemoryStore,
   DurableEvalRedisStore: () => DurableEvalRedisStore,
-  ERR_PERMALINK: () => _chunkXLLGRXGRjs.ERR_PERMALINK,
+  ERR_PERMALINK: () => _chunkTWCDSYJNjs.ERR_PERMALINK,
   Eval: () => Eval,
   EvalResultWithSummary: () => EvalResultWithSummary,
-  Experiment: () => _chunkXLLGRXGRjs.Experiment,
-  ExternalAttachment: () => _chunkXLLGRXGRjs.ExternalAttachment,
-  FailedHTTPResponse: () => _chunkXLLGRXGRjs.FailedHTTPResponse,
-  IDGenerator: () => _chunkXLLGRXGRjs.IDGenerator,
-  JSONAttachment: () => _chunkXLLGRXGRjs.JSONAttachment,
-  LEGACY_CACHED_HEADER: () => _chunkXLLGRXGRjs.LEGACY_CACHED_HEADER,
-  LOGS3_OVERFLOW_REFERENCE_TYPE: () => _chunkXLLGRXGRjs.LOGS3_OVERFLOW_REFERENCE_TYPE,
-  LazyValue: () => _chunkXLLGRXGRjs.LazyValue,
+  Experiment: () => _chunkTWCDSYJNjs.Experiment,
+  ExternalAttachment: () => _chunkTWCDSYJNjs.ExternalAttachment,
+  FailedHTTPResponse: () => _chunkTWCDSYJNjs.FailedHTTPResponse,
+  IDGenerator: () => _chunkTWCDSYJNjs.IDGenerator,
+  JSONAttachment: () => _chunkTWCDSYJNjs.JSONAttachment,
+  LEGACY_CACHED_HEADER: () => _chunkTWCDSYJNjs.LEGACY_CACHED_HEADER,
+  LOGS3_OVERFLOW_REFERENCE_TYPE: () => _chunkTWCDSYJNjs.LOGS3_OVERFLOW_REFERENCE_TYPE,
+  LazyValue: () => _chunkTWCDSYJNjs.LazyValue,
   LocalTrace: () => LocalTrace,
-  Logger: () => _chunkXLLGRXGRjs.Logger,
-  LoginInvalidOrgError: () => _chunkXLLGRXGRjs.LoginInvalidOrgError,
-  NOOP_SPAN: () => _chunkXLLGRXGRjs.NOOP_SPAN,
-  NOOP_SPAN_PERMALINK: () => _chunkXLLGRXGRjs.NOOP_SPAN_PERMALINK,
-  NoopSpan: () => _chunkXLLGRXGRjs.NoopSpan,
-  OTELIDGenerator: () => _chunkXLLGRXGRjs.OTELIDGenerator,
-  ObjectFetcher: () => _chunkXLLGRXGRjs.ObjectFetcher,
+  Logger: () => _chunkTWCDSYJNjs.Logger,
+  LoginInvalidOrgError: () => _chunkTWCDSYJNjs.LoginInvalidOrgError,
+  NOOP_SPAN: () => _chunkTWCDSYJNjs.NOOP_SPAN,
+  NOOP_SPAN_PERMALINK: () => _chunkTWCDSYJNjs.NOOP_SPAN_PERMALINK,
+  NoopSpan: () => _chunkTWCDSYJNjs.NoopSpan,
+  OTELIDGenerator: () => _chunkTWCDSYJNjs.OTELIDGenerator,
+  ObjectFetcher: () => _chunkTWCDSYJNjs.ObjectFetcher,
   Project: () => Project2,
   ProjectNameIdMap: () => ProjectNameIdMap,
-  Prompt: () => _chunkXLLGRXGRjs.Prompt,
+  Prompt: () => _chunkTWCDSYJNjs.Prompt,
   PromptBuilder: () => PromptBuilder,
-  ReadonlyAttachment: () => _chunkXLLGRXGRjs.ReadonlyAttachment,
-  ReadonlyExperiment: () => _chunkXLLGRXGRjs.ReadonlyExperiment,
+  ReadonlyAttachment: () => _chunkTWCDSYJNjs.ReadonlyAttachment,
+  ReadonlyExperiment: () => _chunkTWCDSYJNjs.ReadonlyExperiment,
   Reporter: () => Reporter,
   ScorerBuilder: () => ScorerBuilder,
   SpanFetcher: () => SpanFetcher,
-  SpanImpl: () => _chunkXLLGRXGRjs.SpanImpl,
-  TRACEPARENT_HEADER: () => _chunkXLLGRXGRjs.TRACEPARENT_HEADER,
-  TRACESTATE_HEADER: () => _chunkXLLGRXGRjs.TRACESTATE_HEADER,
-  TestBackgroundLogger: () => _chunkXLLGRXGRjs.TestBackgroundLogger,
+  SpanImpl: () => _chunkTWCDSYJNjs.SpanImpl,
+  TRACEPARENT_HEADER: () => _chunkTWCDSYJNjs.TRACEPARENT_HEADER,
+  TRACESTATE_HEADER: () => _chunkTWCDSYJNjs.TRACESTATE_HEADER,
+  TestBackgroundLogger: () => _chunkTWCDSYJNjs.TestBackgroundLogger,
   ToolBuilder: () => ToolBuilder,
-  UUIDGenerator: () => _chunkXLLGRXGRjs.UUIDGenerator,
-  X_CACHED_HEADER: () => _chunkXLLGRXGRjs.X_CACHED_HEADER,
-  _exportsForTestingOnly: () => _chunkXLLGRXGRjs._exportsForTestingOnly,
-  _internalGetGlobalState: () => _chunkXLLGRXGRjs._internalGetGlobalState,
-  _internalIso: () => _chunk6Z5S7VOUjs.isomorph_default,
-  _internalSetInitialState: () => _chunkXLLGRXGRjs._internalSetInitialState,
-  addAzureBlobHeaders: () => _chunkXLLGRXGRjs.addAzureBlobHeaders,
+  UUIDGenerator: () => _chunkTWCDSYJNjs.UUIDGenerator,
+  X_CACHED_HEADER: () => _chunkTWCDSYJNjs.X_CACHED_HEADER,
+  _exportsForTestingOnly: () => _chunkTWCDSYJNjs._exportsForTestingOnly,
+  _internalGetGlobalState: () => _chunkTWCDSYJNjs._internalGetGlobalState,
+  _internalIso: () => _chunk2XDW3UCGjs.isomorph_default,
+  _internalSetInitialState: () => _chunkTWCDSYJNjs._internalSetInitialState,
+  addAzureBlobHeaders: () => _chunkTWCDSYJNjs.addAzureBlobHeaders,
   agentAssertionScorer: () => agentAssertionScorer,
-  braintrustAISDKTelemetry: () => _chunkXLLGRXGRjs.braintrustAISDKTelemetry,
+  braintrustAISDKTelemetry: () => _chunkTWCDSYJNjs.braintrustAISDKTelemetry,
   braintrustEveHook: () => braintrustEveHook,
   braintrustEveInstrumentation: () => braintrustEveInstrumentation,
-  braintrustFlueInstrumentation: () => _chunkXLLGRXGRjs.braintrustFlueInstrumentation,
-  braintrustFlueObserver: () => _chunkXLLGRXGRjs.braintrustFlueObserver,
-  braintrustStreamChunkSchema: () => _chunkXLLGRXGRjs.braintrustStreamChunkSchema,
+  braintrustFlueInstrumentation: () => _chunkTWCDSYJNjs.braintrustFlueInstrumentation,
+  braintrustFlueObserver: () => _chunkTWCDSYJNjs.braintrustFlueObserver,
+  braintrustStreamChunkSchema: () => _chunkTWCDSYJNjs.braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
-  collectAnthropicSession: () => _chunkXLLGRXGRjs.collectAnthropicSession,
-  configureInstrumentation: () => _chunkXLLGRXGRjs.configureInstrumentation,
-  constructLogs3OverflowRequest: () => _chunkXLLGRXGRjs.constructLogs3OverflowRequest,
-  createFinalValuePassThroughStream: () => _chunkXLLGRXGRjs.createFinalValuePassThroughStream,
-  currentExperiment: () => _chunkXLLGRXGRjs.currentExperiment,
-  currentLogger: () => _chunkXLLGRXGRjs.currentLogger,
-  currentSpan: () => _chunkXLLGRXGRjs.currentSpan,
-  deepCopyEvent: () => _chunkXLLGRXGRjs.deepCopyEvent,
+  collectAnthropicSession: () => _chunkTWCDSYJNjs.collectAnthropicSession,
+  completeOpenAIBatchTrace: () => completeOpenAIBatchTrace,
+  configureInstrumentation: () => _chunkTWCDSYJNjs.configureInstrumentation,
+  constructLogs3OverflowRequest: () => _chunkTWCDSYJNjs.constructLogs3OverflowRequest,
+  createFinalValuePassThroughStream: () => _chunkTWCDSYJNjs.createFinalValuePassThroughStream,
+  currentExperiment: () => _chunkTWCDSYJNjs.currentExperiment,
+  currentLogger: () => _chunkTWCDSYJNjs.currentLogger,
+  currentSpan: () => _chunkTWCDSYJNjs.currentSpan,
+  deepCopyEvent: () => _chunkTWCDSYJNjs.deepCopyEvent,
   defaultErrorScoreHandler: () => defaultErrorScoreHandler,
   defineDurableEval: () => defineDurableEval,
-  deserializePlainStringAsJSON: () => _chunkXLLGRXGRjs.deserializePlainStringAsJSON,
-  devNullWritableStream: () => _chunkXLLGRXGRjs.devNullWritableStream,
+  deserializePlainStringAsJSON: () => _chunkTWCDSYJNjs.deserializePlainStringAsJSON,
+  devNullWritableStream: () => _chunkTWCDSYJNjs.devNullWritableStream,
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema: () => evaluatorDefinitionsSchema,
-  extractTraceContextFromHeaders: () => _chunkXLLGRXGRjs.extractTraceContextFromHeaders,
-  flush: () => _chunkXLLGRXGRjs.flush,
-  getContextManager: () => _chunkXLLGRXGRjs.getContextManager,
-  getIdGenerator: () => _chunkXLLGRXGRjs.getIdGenerator,
-  getPromptVersions: () => _chunkXLLGRXGRjs.getPromptVersions,
-  getSpanParentObject: () => _chunkXLLGRXGRjs.getSpanParentObject,
-  getTemplateRenderer: () => _chunkXLLGRXGRjs.getTemplateRenderer,
+  extractTraceContextFromHeaders: () => _chunkTWCDSYJNjs.extractTraceContextFromHeaders,
+  flush: () => _chunkTWCDSYJNjs.flush,
+  getContextManager: () => _chunkTWCDSYJNjs.getContextManager,
+  getIdGenerator: () => _chunkTWCDSYJNjs.getIdGenerator,
+  getPromptVersions: () => _chunkTWCDSYJNjs.getPromptVersions,
+  getSpanParentObject: () => _chunkTWCDSYJNjs.getSpanParentObject,
+  getTemplateRenderer: () => _chunkTWCDSYJNjs.getTemplateRenderer,
   graph: () => graph_framework_exports,
-  init: () => _chunkXLLGRXGRjs.init,
-  initDataset: () => _chunkXLLGRXGRjs.initDataset,
-  initExperiment: () => _chunkXLLGRXGRjs.initExperiment,
+  init: () => _chunkTWCDSYJNjs.init,
+  initDataset: () => _chunkTWCDSYJNjs.initDataset,
+  initExperiment: () => _chunkTWCDSYJNjs.initExperiment,
   initFunction: () => initFunction,
-  initLogger: () => _chunkXLLGRXGRjs.initLogger,
+  initLogger: () => _chunkTWCDSYJNjs.initLogger,
   initNodeTestSuite: () => initNodeTestSuite,
-  injectTraceContext: () => _chunkXLLGRXGRjs.injectTraceContext,
+  injectTraceContext: () => _chunkTWCDSYJNjs.injectTraceContext,
   invoke: () => invoke,
-  isTemplateFormat: () => _chunkXLLGRXGRjs.isTemplateFormat,
-  loadParameters: () => _chunkXLLGRXGRjs.loadParameters,
-  loadPrompt: () => _chunkXLLGRXGRjs.loadPrompt,
-  log: () => _chunkXLLGRXGRjs.log,
-  logError: () => _chunkXLLGRXGRjs.logError,
-  login: () => _chunkXLLGRXGRjs.login,
-  loginToState: () => _chunkXLLGRXGRjs.loginToState,
-  logs3OverflowUploadSchema: () => _chunkXLLGRXGRjs.logs3OverflowUploadSchema,
-  newId: () => _chunkXLLGRXGRjs.newId,
-  parseCachedHeader: () => _chunkXLLGRXGRjs.parseCachedHeader,
-  parseTemplateFormat: () => _chunkXLLGRXGRjs.parseTemplateFormat,
-  permalink: () => _chunkXLLGRXGRjs.permalink,
-  pickLogs3OverflowObjectIds: () => _chunkXLLGRXGRjs.pickLogs3OverflowObjectIds,
+  isTemplateFormat: () => _chunkTWCDSYJNjs.isTemplateFormat,
+  loadParameters: () => _chunkTWCDSYJNjs.loadParameters,
+  loadPrompt: () => _chunkTWCDSYJNjs.loadPrompt,
+  log: () => _chunkTWCDSYJNjs.log,
+  logError: () => _chunkTWCDSYJNjs.logError,
+  login: () => _chunkTWCDSYJNjs.login,
+  loginToState: () => _chunkTWCDSYJNjs.loginToState,
+  logs3OverflowUploadSchema: () => _chunkTWCDSYJNjs.logs3OverflowUploadSchema,
+  newId: () => _chunkTWCDSYJNjs.newId,
+  openaiBatchesRetrieveTraced: () => openaiBatchesRetrieveTraced,
+  openaiFilesCreateTraced: () => openaiFilesCreateTraced,
+  parseCachedHeader: () => _chunkTWCDSYJNjs.parseCachedHeader,
+  parseTemplateFormat: () => _chunkTWCDSYJNjs.parseTemplateFormat,
+  permalink: () => _chunkTWCDSYJNjs.permalink,
+  pickLogs3OverflowObjectIds: () => _chunkTWCDSYJNjs.pickLogs3OverflowObjectIds,
   projects: () => projects,
   promptContentsSchema: () => promptContentsSchema,
   promptDefinitionSchema: () => promptDefinitionSchema,
   promptDefinitionToPromptData: () => promptDefinitionToPromptData,
   promptDefinitionWithToolsSchema: () => promptDefinitionWithToolsSchema,
-  registerOtelFlush: () => _chunkXLLGRXGRjs.registerOtelFlush,
+  registerOtelFlush: () => _chunkTWCDSYJNjs.registerOtelFlush,
   registerSandbox: () => registerSandbox,
-  registerTemplatePlugin: () => _chunkXLLGRXGRjs.registerTemplatePlugin,
-  renderMessage: () => _chunkXLLGRXGRjs.renderMessage,
-  renderPromptParams: () => _chunkXLLGRXGRjs.renderPromptParams,
-  renderTemplateContent: () => _chunkXLLGRXGRjs.renderTemplateContent,
+  registerTemplatePlugin: () => _chunkTWCDSYJNjs.registerTemplatePlugin,
+  renderMessage: () => _chunkTWCDSYJNjs.renderMessage,
+  renderPromptParams: () => _chunkTWCDSYJNjs.renderPromptParams,
+  renderTemplateContent: () => _chunkTWCDSYJNjs.renderTemplateContent,
   reportFailures: () => reportFailures,
   runEvaluator: () => runEvaluator,
-  setFetch: () => _chunkXLLGRXGRjs.setFetch,
-  setMaskingFunction: () => _chunkXLLGRXGRjs.setMaskingFunction,
-  spanComponentsToObjectId: () => _chunkXLLGRXGRjs.spanComponentsToObjectId,
-  startSpan: () => _chunkXLLGRXGRjs.startSpan,
-  summarize: () => _chunkXLLGRXGRjs.summarize,
-  templateRegistry: () => _chunkXLLGRXGRjs.templateRegistry,
-  toolFunctionDefinitionSchema: () => _chunkXLLGRXGRjs.ToolFunctionDefinition,
-  traceable: () => _chunkXLLGRXGRjs.traceable,
-  traced: () => _chunkXLLGRXGRjs.traced,
-  updateSpan: () => _chunkXLLGRXGRjs.updateSpan,
-  uploadLogs3OverflowPayload: () => _chunkXLLGRXGRjs.uploadLogs3OverflowPayload,
-  utf8ByteLength: () => _chunkXLLGRXGRjs.utf8ByteLength,
-  withCurrent: () => _chunkXLLGRXGRjs.withCurrent,
-  withDataset: () => _chunkXLLGRXGRjs.withDataset,
-  withExperiment: () => _chunkXLLGRXGRjs.withExperiment,
-  withLogger: () => _chunkXLLGRXGRjs.withLogger,
-  withParent: () => _chunkXLLGRXGRjs.withParent,
+  setFetch: () => _chunkTWCDSYJNjs.setFetch,
+  setMaskingFunction: () => _chunkTWCDSYJNjs.setMaskingFunction,
+  spanComponentsToObjectId: () => _chunkTWCDSYJNjs.spanComponentsToObjectId,
+  startSpan: () => _chunkTWCDSYJNjs.startSpan,
+  summarize: () => _chunkTWCDSYJNjs.summarize,
+  templateRegistry: () => _chunkTWCDSYJNjs.templateRegistry,
+  toolFunctionDefinitionSchema: () => _chunkTWCDSYJNjs.ToolFunctionDefinition,
+  traceable: () => _chunkTWCDSYJNjs.traceable,
+  traced: () => _chunkTWCDSYJNjs.traced,
+  updateSpan: () => _chunkTWCDSYJNjs.updateSpan,
+  uploadLogs3OverflowPayload: () => _chunkTWCDSYJNjs.uploadLogs3OverflowPayload,
+  utf8ByteLength: () => _chunkTWCDSYJNjs.utf8ByteLength,
+  withCurrent: () => _chunkTWCDSYJNjs.withCurrent,
+  withDataset: () => _chunkTWCDSYJNjs.withDataset,
+  withExperiment: () => _chunkTWCDSYJNjs.withExperiment,
+  withLogger: () => _chunkTWCDSYJNjs.withLogger,
+  withParent: () => _chunkTWCDSYJNjs.withParent,
   wrapAISDK: () => wrapAISDK,
   wrapAISDKModel: () => wrapAISDKModel,
   wrapAgentClass: () => wrapAgentClass,
@@ -349,7 +352,7 @@ _chunk6Z5S7VOUjs.__export.call(void 0, exports_exports, {
   wrapLangSmithClient: () => wrapLangSmithClient,
   wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
   wrapLangSmithTraceable: () => wrapLangSmithTraceable,
-  wrapMastraAgent: () => _chunkXLLGRXGRjs.wrapMastraAgent,
+  wrapMastraAgent: () => _chunkTWCDSYJNjs.wrapMastraAgent,
   wrapMistral: () => wrapMistral,
   wrapOllama: () => wrapOllama,
   wrapOpenAI: () => wrapOpenAI,
@@ -359,7 +362,7 @@ _chunk6Z5S7VOUjs.__export.call(void 0, exports_exports, {
   wrapOpenRouterAgent: () => wrapOpenRouterAgent,
   wrapPiCodingAgentSDK: () => wrapPiCodingAgentSDK,
   wrapStrandsAgentSDK: () => wrapStrandsAgentSDK,
-  wrapTraced: () => _chunkXLLGRXGRjs.wrapTraced,
+  wrapTraced: () => _chunkTWCDSYJNjs.wrapTraced,
   wrapVitest: () => wrapVitest,
   wrapVoyageAI: () => wrapVoyageAI
 });
@@ -368,7 +371,7 @@ _chunk6Z5S7VOUjs.__export.call(void 0, exports_exports, {
 var _v3 = require('zod/v3');
 var SANDBOX_GROUP_NAME_METADATA_KEY = "_bt_sandbox_group_name";
 async function registerSandbox(options) {
-  const state = _nullishCoalesce(options.state, () => ( _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, )));
+  const state = _nullishCoalesce(options.state, () => ( _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, )));
   await state.login({
     apiKey: options.apiKey,
     appUrl: options.appUrl,
@@ -409,7 +412,7 @@ async function registerSandbox(options) {
     evaluatorDefinitions
   )) {
     const functionName = evalName;
-    const functionSlug = _chunkXLLGRXGRjs.slugify.call(void 0, evalName, { lower: true, strict: true });
+    const functionSlug = _chunkTWCDSYJNjs.slugify.call(void 0, evalName, { lower: true, strict: true });
     const functionDef = {
       project_id: projectId,
       org_name: state.orgName,
@@ -458,6 +461,260 @@ async function registerSandbox(options) {
   };
 }
 
+// src/wrappers/openai-promise-utils.ts
+function splitSpanInfo(allParams) {
+  const { span_info, ...params } = allParams;
+  return {
+    params,
+    span_info
+  };
+}
+function createChannelContext(_channel, params, span_info) {
+  return {
+    arguments: (
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      [params]
+    ),
+    span_info
+  };
+}
+async function tracePromiseWithResponse(channel, traceContext, apiPromise) {
+  let enhancedResponse;
+  const tracePromise = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    channel.tracePromise
+  );
+  const data = await tracePromise(async () => {
+    enhancedResponse = await apiPromise.withResponse();
+    traceContext.response = enhancedResponse.response;
+    return enhancedResponse.data;
+  }, traceContext);
+  if (!enhancedResponse) {
+    throw new Error("Expected withResponse() to provide response");
+  }
+  return {
+    data,
+    response: enhancedResponse.response,
+    request_id: enhancedResponse.request_id
+  };
+}
+async function tracePromiseAsResponse(channel, traceContext, apiPromise) {
+  const tracePromise = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    channel.tracePromise
+  );
+  let response;
+  await tracePromise(async () => {
+    response = await apiPromise.asResponse();
+    traceContext.response = response;
+    return void 0;
+  }, traceContext);
+  if (!response) {
+    throw new Error("Expected asResponse() to provide response");
+  }
+  return response;
+}
+function createLazyAPIPromise(ensureExecuted, ensureResponse, getAPIPromise) {
+  let firstConsumption;
+  let enhancedResponsePromise;
+  let dataPromise;
+  let responsePromise;
+  const withResponse = () => {
+    firstConsumption ??= "data";
+    enhancedResponsePromise ??= firstConsumption === "data" ? ensureExecuted() : getAPIPromise().withResponse();
+    return enhancedResponsePromise;
+  };
+  const asResponse = () => {
+    firstConsumption ??= "response";
+    responsePromise ??= firstConsumption === "response" ? ensureResponse() : getAPIPromise().asResponse();
+    return responsePromise;
+  };
+  return new Proxy({}, {
+    get(target, prop, receiver) {
+      if (prop === "withResponse") {
+        return withResponse;
+      }
+      if (prop === "asResponse") {
+        return asResponse;
+      }
+      if (prop === "then" || prop === "catch" || prop === "finally" || prop in Promise.prototype) {
+        dataPromise ??= withResponse().then((result) => result.data);
+        const value = Reflect.get(dataPromise, prop, receiver);
+        return typeof value === "function" ? value.bind(dataPromise) : value;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// src/openai-batch.ts
+function read(value, key) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return void 0;
+  }
+  try {
+    return Reflect.get(value, key);
+  } catch (e2) {
+    return void 0;
+  }
+}
+function isAsyncIterable(value) {
+  return typeof read(value, Symbol.asyncIterator) === "function";
+}
+function teeAsyncIterable(source) {
+  const iterator = source[Symbol.asyncIterator]();
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        const result = await iterator.next();
+        if (result.done) {
+          controller.close();
+          return;
+        }
+        if (!(result.value instanceof Uint8Array)) {
+          throw new TypeError(
+            "OpenAI upload streams must yield Uint8Array chunks"
+          );
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await _optionalChain([iterator, 'access', _2 => _2.return, 'optionalCall', _3 => _3(reason)]);
+    }
+  });
+  const [uploadStream, trace] = stream.tee();
+  const upload = {
+    async *[Symbol.asyncIterator]() {
+      const reader = uploadStream.getReader();
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) {
+            return;
+          }
+          yield result.value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  };
+  const path = read(source, "path");
+  if (typeof path === "string") {
+    Object.defineProperty(upload, "path", { value: path });
+  }
+  return { upload, trace: new Response(trace) };
+}
+function teeUpload(upload) {
+  if (upload instanceof Blob) {
+    return { upload, trace: new Response(upload) };
+  }
+  if (upload instanceof Response) {
+    return { upload, trace: upload.clone() };
+  }
+  if (isAsyncIterable(upload)) {
+    return teeAsyncIterable(upload);
+  }
+  return void 0;
+}
+function openaiFilesCreateTraced(files) {
+  return (params, options) => {
+    const parent = _chunkTWCDSYJNjs.getSpanParentObject.call(void 0, );
+    const purpose = read(params, "purpose");
+    const file = read(params, "file");
+    if (purpose !== "batch") {
+      return files.create(params, options);
+    }
+    let branches;
+    try {
+      branches = teeUpload(file);
+    } catch (e3) {
+      return files.create(params, options);
+    }
+    if (!branches) {
+      return files.create(params, options);
+    }
+    const tracedParams = {
+      ...Object(params),
+      file: branches.upload
+    };
+    const apiPromise = files.create(tracedParams, options);
+    let enhancedResponse;
+    const tracedResponse = _chunk2XDW3UCGjs.openAIChannels.filesCreateTraced.invoke(
+      async () => {
+        enhancedResponse = await apiPromise.withResponse();
+        return enhancedResponse.data;
+      },
+      files,
+      [{ params, inputFileContent: branches.trace, parent }],
+      {}
+    ).then((data) => {
+      if (!enhancedResponse) {
+        throw new Error(
+          "Expected OpenAI withResponse() to provide a response"
+        );
+      }
+      return { ...enhancedResponse, data };
+    });
+    return createLazyAPIPromise(
+      () => tracedResponse,
+      () => tracedResponse.then(({ response }) => response),
+      () => apiPromise
+    );
+  };
+}
+function openaiBatchesRetrieveTraced(batches) {
+  return (batchId, options) => {
+    const apiPromise = batches.retrieve(batchId, options);
+    let enhancedResponse;
+    const tracedResponse = _chunk2XDW3UCGjs.openAIChannels.batchesRetrieveTraced.invoke(
+      async () => {
+        enhancedResponse = await apiPromise.withResponse();
+        return enhancedResponse.data;
+      },
+      batches,
+      [{ batchId }],
+      {}
+    ).then((data) => {
+      if (!enhancedResponse) {
+        throw new Error(
+          "Expected OpenAI withResponse() to provide a response"
+        );
+      }
+      return { ...enhancedResponse, data };
+    });
+    return createLazyAPIPromise(
+      () => tracedResponse,
+      () => tracedResponse.then(({ response }) => response),
+      () => apiPromise
+    );
+  };
+}
+async function completeOpenAIBatchTrace(args) {
+  const inputFileContent = Promise.resolve(args.inputFileContent);
+  const outputFileContent = args.outputFileContent === void 0 ? void 0 : Promise.resolve(args.outputFileContent);
+  const errorFileContent = args.errorFileContent === void 0 ? void 0 : Promise.resolve(args.errorFileContent);
+  void inputFileContent.catch(() => void 0);
+  void _optionalChain([outputFileContent, 'optionalAccess', _4 => _4.catch, 'call', _5 => _5(() => void 0)]);
+  void _optionalChain([errorFileContent, 'optionalAccess', _6 => _6.catch, 'call', _7 => _7(() => void 0)]);
+  await _chunk2XDW3UCGjs.openAIChannels.batchesCompleteTrace.invoke(
+    async () => void 0,
+    void 0,
+    [
+      {
+        ...args,
+        inputFileContent,
+        outputFileContent,
+        errorFileContent
+      }
+    ],
+    {}
+  );
+}
+
 // src/functions/invoke.ts
 async function invoke(args) {
   const {
@@ -480,7 +737,7 @@ async function invoke(args) {
     projectId,
     ...functionIdArgs
   } = args;
-  const state = _nullishCoalesce(stateArg, () => ( _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, )));
+  const state = _nullishCoalesce(stateArg, () => ( _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, )));
   await state.login({
     orgName,
     apiKey,
@@ -488,8 +745,8 @@ async function invoke(args) {
     forceLogin,
     fetch
   });
-  const parent = parentArg ? typeof parentArg === "string" ? parentArg : await parentArg.export() : await _chunkXLLGRXGRjs.getSpanParentObject.call(void 0, ).export();
-  const functionId = _chunkXLLGRXGRjs.FunctionId.safeParse({
+  const parent = parentArg ? typeof parentArg === "string" ? parentArg : await parentArg.export() : await _chunkTWCDSYJNjs.getSpanParentObject.call(void 0, ).export();
+  const functionId = _chunkTWCDSYJNjs.FunctionId.safeParse({
     function_id: functionIdArgs.function_id,
     project_name: functionIdArgs.projectName,
     slug: functionIdArgs.slug,
@@ -532,7 +789,7 @@ async function invoke(args) {
     if (!resp.body) {
       throw new Error("Received empty stream body");
     }
-    return new (0, _chunkXLLGRXGRjs.BraintrustStream)(resp.body);
+    return new (0, _chunkTWCDSYJNjs.BraintrustStream)(resp.body);
   } else {
     const data = await resp.json();
     return schema ? schema.parse(data) : data;
@@ -544,8 +801,8 @@ function initFunction({
   version,
   state
 }) {
-  const s = _nullishCoalesce(state, () => ( _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, )));
-  _optionalChain([s, 'optionalAccess', _2 => _2.spanCache, 'optionalAccess', _3 => _3.disable, 'call', _4 => _4()]);
+  const s = _nullishCoalesce(state, () => ( _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, )));
+  _optionalChain([s, 'optionalAccess', _8 => _8.spanCache, 'optionalAccess', _9 => _9.disable, 'call', _10 => _10()]);
   const f = async (input) => {
     return await invoke({
       projectName,
@@ -560,58 +817,6 @@ function initFunction({
   return f;
 }
 
-// src/wrappers/openai-promise-utils.ts
-function splitSpanInfo(allParams) {
-  const { span_info, ...params } = allParams;
-  return {
-    params,
-    span_info
-  };
-}
-function createChannelContext(_channel, params, span_info) {
-  return {
-    arguments: (
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      [params]
-    ),
-    span_info
-  };
-}
-async function tracePromiseWithResponse(channel, traceContext, apiPromise) {
-  let enhancedResponse;
-  const tracePromise = (
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    channel.tracePromise
-  );
-  const data = await tracePromise(async () => {
-    enhancedResponse = await apiPromise.withResponse();
-    traceContext.response = enhancedResponse.response;
-    return enhancedResponse.data;
-  }, traceContext);
-  if (!enhancedResponse) {
-    throw new Error("Expected withResponse() to provide response");
-  }
-  return { data, response: enhancedResponse.response };
-}
-function createLazyAPIPromise(ensureExecuted) {
-  let dataPromise = null;
-  return new Proxy({}, {
-    get(target, prop, receiver) {
-      if (prop === "withResponse") {
-        return () => ensureExecuted();
-      }
-      if (prop === "then" || prop === "catch" || prop === "finally" || prop in Promise.prototype) {
-        if (!dataPromise) {
-          dataPromise = ensureExecuted().then((result) => result.data);
-        }
-        const value = Reflect.get(dataPromise, prop, receiver);
-        return typeof value === "function" ? value.bind(dataPromise) : value;
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-
 // src/wrappers/oai_responses.ts
 function responsesProxy(openai) {
   if (!openai.responses) {
@@ -622,22 +827,22 @@ function responsesProxy(openai) {
       if (name === "create" && typeof target.create === "function") {
         return wrapResponsesAsync(
           target.create.bind(target),
-          _chunk6Z5S7VOUjs.openAIChannels.responsesCreate
+          _chunk2XDW3UCGjs.openAIChannels.responsesCreate
         );
       } else if (name === "stream" && typeof target.stream === "function") {
         return wrapResponsesSyncStream(
           target.stream.bind(target),
-          _chunk6Z5S7VOUjs.openAIChannels.responsesStream
+          _chunk2XDW3UCGjs.openAIChannels.responsesStream
         );
       } else if (name === "parse" && typeof target.parse === "function") {
         return wrapResponsesAsync(
           target.parse.bind(target),
-          _chunk6Z5S7VOUjs.openAIChannels.responsesParse
+          _chunk2XDW3UCGjs.openAIChannels.responsesParse
         );
       } else if (name === "compact" && typeof target.compact === "function") {
         return wrapResponsesAsync(
           target.compact.bind(target),
-          _chunk6Z5S7VOUjs.openAIChannels.responsesCompact
+          _chunk2XDW3UCGjs.openAIChannels.responsesCompact
         );
       }
       return Reflect.get(target, name, receiver);
@@ -648,17 +853,33 @@ function wrapResponsesAsync(target, channel) {
   return (allParams, options) => {
     const { span_info, params } = splitSpanInfo(allParams);
     let executionPromise = null;
+    let apiPromise = null;
+    const getAPIPromise = () => {
+      apiPromise ??= target(params, options);
+      return apiPromise;
+    };
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
           const traceContext = createChannelContext(channel, params, span_info);
-          const apiPromise = target(params, options);
-          return tracePromiseWithResponse(channel, traceContext, apiPromise);
+          return tracePromiseWithResponse(
+            channel,
+            traceContext,
+            getAPIPromise()
+          );
         })();
       }
       return executionPromise;
     };
-    return createLazyAPIPromise(ensureExecuted);
+    return createLazyAPIPromise(
+      ensureExecuted,
+      () => tracePromiseAsResponse(
+        channel,
+        createChannelContext(channel, params, span_info),
+        getAPIPromise()
+      ),
+      getAPIPromise
+    );
   };
 }
 function wrapResponsesSyncStream(target, channel) {
@@ -710,9 +931,9 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(typedOpenai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(typedOpenai.moderations, wrapModerations);
   let betaProxy3;
-  if (_optionalChain([typedOpenai, 'access', _5 => _5.beta, 'optionalAccess', _6 => _6.chat, 'optionalAccess', _7 => _7.completions, 'optionalAccess', _8 => _8.stream])) {
+  if (_optionalChain([typedOpenai, 'access', _11 => _11.beta, 'optionalAccess', _12 => _12.chat, 'optionalAccess', _13 => _13.completions, 'optionalAccess', _14 => _14.stream])) {
     const betaChatCompletionProxy = new Proxy(
-      _optionalChain([typedOpenai, 'optionalAccess', _9 => _9.beta, 'optionalAccess', _10 => _10.chat, 'access', _11 => _11.completions]),
+      _optionalChain([typedOpenai, 'optionalAccess', _15 => _15.beta, 'optionalAccess', _16 => _16.chat, 'access', _17 => _17.completions]),
       {
         get(target, name, receiver) {
           const baseVal = Reflect.get(target, name, receiver);
@@ -781,7 +1002,7 @@ function wrapBetaChatCompletionParse(completion) {
     const { span_info, params } = splitSpanInfo(
       allParams
     );
-    return _chunk6Z5S7VOUjs.openAIChannels.betaChatCompletionsParse.tracePromise(
+    return _chunk2XDW3UCGjs.openAIChannels.betaChatCompletionsParse.tracePromise(
       async () => await completion(params),
       { arguments: [params], span_info }
     );
@@ -792,7 +1013,7 @@ function wrapBetaChatCompletionStream(completion) {
     const { span_info, params } = splitSpanInfo(
       allParams
     );
-    return _chunk6Z5S7VOUjs.openAIChannels.betaChatCompletionsStream.traceSync(
+    return _chunk2XDW3UCGjs.openAIChannels.betaChatCompletionsStream.traceSync(
       () => completion(params),
       { arguments: [params], span_info }
     );
@@ -804,41 +1025,58 @@ function wrapChatCompletion(completion) {
       allParams
     );
     let executionPromise = null;
+    let apiPromise = null;
+    const getAPIPromise = () => {
+      apiPromise ??= completion(params, options);
+      return apiPromise;
+    };
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
           const traceContext = createChannelContext(
-            _chunk6Z5S7VOUjs.openAIChannels.chatCompletionsCreate,
+            _chunk2XDW3UCGjs.openAIChannels.chatCompletionsCreate,
             params,
             span_info
           );
           if (params.stream) {
-            const completionPromise = completion(
-              params,
-              options
+            const completionPromise = (
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              getAPIPromise()
             );
-            const { data: data2, response: response2 } = await tracePromiseWithResponse(
-              _chunk6Z5S7VOUjs.openAIChannels.chatCompletionsCreate,
+            const { data: data2, response: response2, request_id: request_id2 } = await tracePromiseWithResponse(
+              _chunk2XDW3UCGjs.openAIChannels.chatCompletionsCreate,
               traceContext,
               completionPromise
             );
-            return { data: data2, response: response2 };
+            return { data: data2, response: response2, request_id: request_id2 };
           }
-          const completionResponse = completion(
-            params,
-            options
+          const completionResponse = (
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            getAPIPromise()
           );
-          const { data, response } = await tracePromiseWithResponse(
-            _chunk6Z5S7VOUjs.openAIChannels.chatCompletionsCreate,
+          const { data, response, request_id } = await tracePromiseWithResponse(
+            _chunk2XDW3UCGjs.openAIChannels.chatCompletionsCreate,
             traceContext,
             completionResponse
           );
-          return { data, response };
+          return { data, response, request_id };
         })();
       }
       return executionPromise;
     };
-    return createLazyAPIPromise(ensureExecuted);
+    return createLazyAPIPromise(
+      ensureExecuted,
+      () => tracePromiseAsResponse(
+        _chunk2XDW3UCGjs.openAIChannels.chatCompletionsCreate,
+        createChannelContext(
+          _chunk2XDW3UCGjs.openAIChannels.chatCompletionsCreate,
+          params,
+          span_info
+        ),
+        getAPIPromise()
+      ),
+      getAPIPromise
+    );
   };
 }
 function createEndpointProxy(target, wrapperFn) {
@@ -856,6 +1094,11 @@ function wrapApiCreateWithChannel(create, channel) {
   return (allParams, options) => {
     const { span_info, params } = splitSpanInfo(allParams);
     let executionPromise = null;
+    let apiPromise = null;
+    const getAPIPromise = () => {
+      apiPromise ??= create(params, options);
+      return apiPromise;
+    };
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
@@ -863,24 +1106,32 @@ function wrapApiCreateWithChannel(create, channel) {
           return tracePromiseWithResponse(
             channel,
             traceContext,
-            create(params, options)
+            getAPIPromise()
           );
         })();
       }
       return executionPromise;
     };
-    return createLazyAPIPromise(ensureExecuted);
+    return createLazyAPIPromise(
+      ensureExecuted,
+      () => tracePromiseAsResponse(
+        channel,
+        createChannelContext(channel, params, span_info),
+        getAPIPromise()
+      ),
+      getAPIPromise
+    );
   };
 }
-var wrapEmbeddings = (create) => wrapApiCreateWithChannel(create, _chunk6Z5S7VOUjs.openAIChannels.embeddingsCreate);
-var wrapModerations = (create) => wrapApiCreateWithChannel(create, _chunk6Z5S7VOUjs.openAIChannels.moderationsCreate);
+var wrapEmbeddings = (create) => wrapApiCreateWithChannel(create, _chunk2XDW3UCGjs.openAIChannels.embeddingsCreate);
+var wrapModerations = (create) => wrapApiCreateWithChannel(create, _chunk2XDW3UCGjs.openAIChannels.moderationsCreate);
 
 // src/wrappers/ai-sdk/ai-sdk.ts
 function isModuleNamespace(obj) {
   if (!obj || typeof obj !== "object") {
     return false;
   }
-  if (_optionalChain([obj, 'access', _12 => _12.constructor, 'optionalAccess', _13 => _13.name]) === "Module") {
+  if (_optionalChain([obj, 'access', _18 => _18.constructor, 'optionalAccess', _19 => _19.name]) === "Module") {
     return true;
   }
   try {
@@ -889,7 +1140,7 @@ function isModuleNamespace(obj) {
     const firstKey = keys[0];
     const descriptor = Object.getOwnPropertyDescriptor(obj, firstKey);
     return descriptor ? !descriptor.configurable && !descriptor.writable : false;
-  } catch (e2) {
+  } catch (e4) {
     return false;
   }
 }
@@ -944,17 +1195,17 @@ function isHarnessAgentInstance(instance) {
     let prototype = Object.getPrototypeOf(instance);
     while (prototype !== null && !visited.has(prototype)) {
       visited.add(prototype);
-      const constructor = _optionalChain([Object, 'access', _14 => _14.getOwnPropertyDescriptor, 'call', _15 => _15(
+      const constructor = _optionalChain([Object, 'access', _20 => _20.getOwnPropertyDescriptor, 'call', _21 => _21(
         prototype,
         "constructor"
-      ), 'optionalAccess', _16 => _16.value]);
-      const constructorName = typeof constructor === "function" ? _optionalChain([Object, 'access', _17 => _17.getOwnPropertyDescriptor, 'call', _18 => _18(constructor, "name"), 'optionalAccess', _19 => _19.value]) : void 0;
+      ), 'optionalAccess', _22 => _22.value]);
+      const constructorName = typeof constructor === "function" ? _optionalChain([Object, 'access', _23 => _23.getOwnPropertyDescriptor, 'call', _24 => _24(constructor, "name"), 'optionalAccess', _25 => _25.value]) : void 0;
       if (constructorName === "HarnessAgent") {
         return true;
       }
       prototype = Object.getPrototypeOf(prototype);
     }
-  } catch (e3) {
+  } catch (e5) {
   }
   return false;
 }
@@ -983,7 +1234,7 @@ var wrapAgentClass = (AgentClass, options = {}) => {
                 return wrapHarnessAgentGenerate(
                   original,
                   harnessAgent,
-                  _chunk6Z5S7VOUjs.harnessAgentChannels.generate,
+                  _chunk2XDW3UCGjs.harnessAgentChannels.generate,
                   "HarnessAgent.generate",
                   options
                 );
@@ -991,7 +1242,7 @@ var wrapAgentClass = (AgentClass, options = {}) => {
                 return wrapHarnessAgentStream(
                   original,
                   harnessAgent,
-                  _chunk6Z5S7VOUjs.harnessAgentChannels.stream,
+                  _chunk2XDW3UCGjs.harnessAgentChannels.stream,
                   "HarnessAgent.stream",
                   options
                 );
@@ -999,7 +1250,7 @@ var wrapAgentClass = (AgentClass, options = {}) => {
                 return wrapHarnessAgentGenerate(
                   original,
                   harnessAgent,
-                  _chunk6Z5S7VOUjs.harnessAgentChannels.continueGenerate,
+                  _chunk2XDW3UCGjs.harnessAgentChannels.continueGenerate,
                   "HarnessAgent.continueGenerate",
                   options
                 );
@@ -1007,7 +1258,7 @@ var wrapAgentClass = (AgentClass, options = {}) => {
                 return wrapHarnessAgentStream(
                   original,
                   harnessAgent,
-                  _chunk6Z5S7VOUjs.harnessAgentChannels.continueStream,
+                  _chunk2XDW3UCGjs.harnessAgentChannels.continueStream,
                   "HarnessAgent.continueStream",
                   options
                 );
@@ -1030,7 +1281,7 @@ var wrapAgentClass = (AgentClass, options = {}) => {
 };
 var wrapHarnessAgentCreateSession = (createSession, instance) => {
   const wrapper = function(params) {
-    return _chunk6Z5S7VOUjs.harnessAgentChannels.createSession.tracePromise(
+    return _chunk2XDW3UCGjs.harnessAgentChannels.createSession.tracePromise(
       () => params === void 0 ? createSession.call(instance) : createSession.call(instance, params),
       createAISDKChannelContext(_nullishCoalesce(params, () => ( {})), { self: instance })
     );
@@ -1076,15 +1327,15 @@ var wrapAgentGenerate = (generate, instance, options = {}) => {
 };
 function generateChannelForAgent(agentName) {
   if (agentName === "ToolLoopAgent") {
-    return _chunk6Z5S7VOUjs.aiSDKChannels.toolLoopAgentGenerate;
+    return _chunk2XDW3UCGjs.aiSDKChannels.toolLoopAgentGenerate;
   }
-  return _chunk6Z5S7VOUjs.aiSDKChannels.agentGenerate;
+  return _chunk2XDW3UCGjs.aiSDKChannels.agentGenerate;
 }
 var wrapAgentStream = (stream, instance, options = {}) => {
   const defaultName = `${instance.constructor.name}.stream`;
   return (params) => {
     const workflowAgent = instance.constructor.name === "WorkflowAgent";
-    if (workflowAgent && _chunkXLLGRXGRjs.currentWorkflowAgentWrapperSpan.call(void 0, )) {
+    if (workflowAgent && _chunkTWCDSYJNjs.currentWorkflowAgentWrapperSpan.call(void 0, )) {
       const { span_info: _spanInfo, ...cleanParams } = params;
       return stream.call(instance, { ...instance.settings, ...cleanParams });
     }
@@ -1103,12 +1354,12 @@ var wrapAgentStream = (stream, instance, options = {}) => {
 };
 function streamChannelForAgent(agentName) {
   if (agentName === "ToolLoopAgent") {
-    return _chunk6Z5S7VOUjs.aiSDKChannels.toolLoopAgentStream;
+    return _chunk2XDW3UCGjs.aiSDKChannels.toolLoopAgentStream;
   }
   if (agentName === "WorkflowAgent") {
-    return _chunk6Z5S7VOUjs.aiSDKChannels.workflowAgentStream;
+    return _chunk2XDW3UCGjs.aiSDKChannels.workflowAgentStream;
   }
-  return _chunk6Z5S7VOUjs.aiSDKChannels.agentStream;
+  return _chunk2XDW3UCGjs.aiSDKChannels.agentStream;
 }
 var makeGenerateTextWrapper = (channel, name, generateText, contextOptions = {}, options = {}) => {
   const wrapper = async function(allParams) {
@@ -1132,7 +1383,7 @@ var makeGenerateTextWrapper = (channel, name, generateText, contextOptions = {},
 };
 var wrapGenerateText = (generateText, options = {}, aiSDK) => {
   return makeGenerateTextWrapper(
-    _chunk6Z5S7VOUjs.aiSDKChannels.generateText,
+    _chunk2XDW3UCGjs.aiSDKChannels.generateText,
     "generateText",
     generateText,
     { aiSDK },
@@ -1141,7 +1392,7 @@ var wrapGenerateText = (generateText, options = {}, aiSDK) => {
 };
 var wrapGenerateObject = (generateObject, options = {}, aiSDK) => {
   return makeGenerateTextWrapper(
-    _chunk6Z5S7VOUjs.aiSDKChannels.generateObject,
+    _chunk2XDW3UCGjs.aiSDKChannels.generateObject,
     "generateObject",
     generateObject,
     { aiSDK },
@@ -1155,7 +1406,7 @@ var makeGenerateImageWrapper = (generateImage, contextOptions = {}, options = {}
   const wrapper = async function(allParams) {
     const { span_info, ...params } = allParams;
     const tracedParams = { ...params };
-    return _chunk6Z5S7VOUjs.aiSDKChannels.generateImage.tracePromise(
+    return _chunk2XDW3UCGjs.aiSDKChannels.generateImage.tracePromise(
       () => generateImage(tracedParams),
       createAISDKChannelContext(tracedParams, {
         aiSDK: contextOptions.aiSDK,
@@ -1196,7 +1447,7 @@ var makeEmbedWrapper = (channel, name, embed, contextOptions = {}, options = {})
 };
 var wrapEmbed = (embed, options = {}, aiSDK) => {
   return makeEmbedWrapper(
-    _chunk6Z5S7VOUjs.aiSDKChannels.embed,
+    _chunk2XDW3UCGjs.aiSDKChannels.embed,
     "embed",
     embed,
     { aiSDK },
@@ -1205,7 +1456,7 @@ var wrapEmbed = (embed, options = {}, aiSDK) => {
 };
 var wrapEmbedMany = (embedMany, options = {}, aiSDK) => {
   return makeEmbedWrapper(
-    _chunk6Z5S7VOUjs.aiSDKChannels.embedMany,
+    _chunk2XDW3UCGjs.aiSDKChannels.embedMany,
     "embedMany",
     embedMany,
     { aiSDK },
@@ -1216,7 +1467,7 @@ var makeRerankWrapper = (rerank, contextOptions = {}, options = {}) => {
   const wrapper = async function(allParams) {
     const { span_info, ...params } = allParams;
     const tracedParams = { ...params };
-    return _chunk6Z5S7VOUjs.aiSDKChannels.rerank.tracePromise(
+    return _chunk2XDW3UCGjs.aiSDKChannels.rerank.tracePromise(
       () => rerank(tracedParams),
       createAISDKChannelContext(tracedParams, {
         aiSDK: contextOptions.aiSDK,
@@ -1255,7 +1506,7 @@ var makeStreamWrapper = (channel, name, streamText, contextOptions = {}, options
 };
 var wrapStreamText = (streamText, options = {}, aiSDK) => {
   return makeStreamWrapper(
-    _chunk6Z5S7VOUjs.aiSDKChannels.streamText,
+    _chunk2XDW3UCGjs.aiSDKChannels.streamText,
     "streamText",
     streamText,
     { aiSDK },
@@ -1264,7 +1515,7 @@ var wrapStreamText = (streamText, options = {}, aiSDK) => {
 };
 var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
   return makeStreamWrapper(
-    _chunk6Z5S7VOUjs.aiSDKChannels.streamObject,
+    _chunk2XDW3UCGjs.aiSDKChannels.streamObject,
     "streamObject",
     streamObject,
     { aiSDK },
@@ -1277,11 +1528,11 @@ function mergeSpanInfo(spanInfo, defaults) {
   }
   return {
     ...spanInfo,
-    ..._optionalChain([spanInfo, 'optionalAccess', _20 => _20.name]) ? {} : defaults.name ? { name: defaults.name } : {},
-    ...defaults.spanType !== void 0 || _optionalChain([spanInfo, 'optionalAccess', _21 => _21.spanAttributes]) ? {
+    ..._optionalChain([spanInfo, 'optionalAccess', _26 => _26.name]) ? {} : defaults.name ? { name: defaults.name } : {},
+    ...defaults.spanType !== void 0 || _optionalChain([spanInfo, 'optionalAccess', _27 => _27.spanAttributes]) ? {
       spanAttributes: {
         ...defaults.spanType !== void 0 ? { type: defaults.spanType } : {},
-        ..._nullishCoalesce(_optionalChain([spanInfo, 'optionalAccess', _22 => _22.spanAttributes]), () => ( {}))
+        ..._nullishCoalesce(_optionalChain([spanInfo, 'optionalAccess', _28 => _28.spanAttributes]), () => ( {}))
       }
     } : {}
   };
@@ -1299,7 +1550,7 @@ function createAISDKChannelContext(params, context = {}) {
 // src/wrappers/ai-sdk/deprecated/wrapAISDKModel.ts
 function wrapAISDKModel(model) {
   const m = model;
-  if (_optionalChain([m, 'optionalAccess', _23 => _23.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _24 => _24.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _25 => _25.modelId]) === "string") {
+  if (_optionalChain([m, 'optionalAccess', _29 => _29.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _30 => _30.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _31 => _31.modelId]) === "string") {
     return new BraintrustLanguageModelWrapper(m);
   } else {
     console.warn("Unsupported AI SDK model. Not wrapping.");
@@ -1336,19 +1587,19 @@ var BraintrustLanguageModelWrapper = class {
   // For the first cut, do not support custom span_info arguments. We can
   // propagate those via async local storage
   async doGenerate(options) {
-    const span = _chunkXLLGRXGRjs.startSpan.call(void 0, 
-      _chunk6Z5S7VOUjs.withSpanInstrumentationName.call(void 0, 
+    const span = _chunkTWCDSYJNjs.startSpan.call(void 0, 
+      _chunk2XDW3UCGjs.withSpanInstrumentationName.call(void 0, 
         {
           name: "Chat Completion",
           spanAttributes: {
             type: "llm"
           }
         },
-        _chunk6Z5S7VOUjs.INSTRUMENTATION_NAMES.AI_SDK
+        _chunk2XDW3UCGjs.INSTRUMENTATION_NAMES.AI_SDK
       )
     );
     const { prompt, mode, ...rest } = options;
-    const startTime = _chunkXLLGRXGRjs.getCurrentUnixTimestamp.call(void 0, );
+    const startTime = _chunkTWCDSYJNjs.getCurrentUnixTimestamp.call(void 0, );
     try {
       const ret = await this.model.doGenerate(options);
       span.log({
@@ -1360,12 +1611,12 @@ var BraintrustLanguageModelWrapper = class {
         },
         output: postProcessOutput(ret.text, ret.toolCalls, ret.finishReason),
         metrics: {
-          time_to_first_token: _chunkXLLGRXGRjs.getCurrentUnixTimestamp.call(void 0, ) - startTime,
-          tokens: !_chunkXLLGRXGRjs.isEmpty.call(void 0, ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: _optionalChain([ret, 'access', _26 => _26.usage, 'optionalAccess', _27 => _27.promptTokens]),
-          completion_tokens: _optionalChain([ret, 'access', _28 => _28.usage, 'optionalAccess', _29 => _29.completionTokens]),
-          cached: _chunkXLLGRXGRjs.parseCachedHeader.call(void 0, 
-            _nullishCoalesce(_optionalChain([ret, 'access', _30 => _30.rawResponse, 'optionalAccess', _31 => _31.headers, 'optionalAccess', _32 => _32[_chunkXLLGRXGRjs.X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _33 => _33.rawResponse, 'optionalAccess', _34 => _34.headers, 'optionalAccess', _35 => _35[_chunkXLLGRXGRjs.LEGACY_CACHED_HEADER]])))
+          time_to_first_token: _chunkTWCDSYJNjs.getCurrentUnixTimestamp.call(void 0, ) - startTime,
+          tokens: !_chunkTWCDSYJNjs.isEmpty.call(void 0, ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
+          prompt_tokens: _optionalChain([ret, 'access', _32 => _32.usage, 'optionalAccess', _33 => _33.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _34 => _34.usage, 'optionalAccess', _35 => _35.completionTokens]),
+          cached: _chunkTWCDSYJNjs.parseCachedHeader.call(void 0, 
+            _nullishCoalesce(_optionalChain([ret, 'access', _36 => _36.rawResponse, 'optionalAccess', _37 => _37.headers, 'optionalAccess', _38 => _38[_chunkTWCDSYJNjs.X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _39 => _39.rawResponse, 'optionalAccess', _40 => _40.headers, 'optionalAccess', _41 => _41[_chunkTWCDSYJNjs.LEGACY_CACHED_HEADER]])))
           )
         }
       });
@@ -1376,16 +1627,16 @@ var BraintrustLanguageModelWrapper = class {
   }
   async doStream(options) {
     const { prompt, mode, ...rest } = options;
-    const startTime = _chunkXLLGRXGRjs.getCurrentUnixTimestamp.call(void 0, );
-    const span = _chunkXLLGRXGRjs.startSpan.call(void 0, 
-      _chunk6Z5S7VOUjs.withSpanInstrumentationName.call(void 0, 
+    const startTime = _chunkTWCDSYJNjs.getCurrentUnixTimestamp.call(void 0, );
+    const span = _chunkTWCDSYJNjs.startSpan.call(void 0, 
+      _chunk2XDW3UCGjs.withSpanInstrumentationName.call(void 0, 
         {
           name: "Chat Completion",
           spanAttributes: {
             type: "llm"
           }
         },
-        _chunk6Z5S7VOUjs.INSTRUMENTATION_NAMES.AI_SDK
+        _chunk2XDW3UCGjs.INSTRUMENTATION_NAMES.AI_SDK
       )
     );
     span.log({
@@ -1416,7 +1667,7 @@ var BraintrustLanguageModelWrapper = class {
           new TransformStream({
             transform(chunk, controller) {
               if (time_to_first_token === void 0) {
-                time_to_first_token = _chunkXLLGRXGRjs.getCurrentUnixTimestamp.call(void 0, ) - startTime;
+                time_to_first_token = _chunkTWCDSYJNjs.getCurrentUnixTimestamp.call(void 0, ) - startTime;
                 span.log({ metrics: { time_to_first_token } });
               }
               switch (chunk.type) {
@@ -1461,11 +1712,11 @@ var BraintrustLanguageModelWrapper = class {
                 ),
                 metrics: {
                   time_to_first_token,
-                  tokens: !_chunkXLLGRXGRjs.isEmpty.call(void 0, usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _36 => _36.promptTokens]),
-                  completion_tokens: _optionalChain([usage, 'optionalAccess', _37 => _37.completionTokens]),
-                  cached: _chunkXLLGRXGRjs.parseCachedHeader.call(void 0, 
-                    _nullishCoalesce(_optionalChain([ret, 'access', _38 => _38.rawResponse, 'optionalAccess', _39 => _39.headers, 'optionalAccess', _40 => _40[_chunkXLLGRXGRjs.X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _41 => _41.rawResponse, 'optionalAccess', _42 => _42.headers, 'optionalAccess', _43 => _43[_chunkXLLGRXGRjs.LEGACY_CACHED_HEADER]])))
+                  tokens: !_chunkTWCDSYJNjs.isEmpty.call(void 0, usage) ? usage.promptTokens + usage.completionTokens : void 0,
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _42 => _42.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _43 => _43.completionTokens]),
+                  cached: _chunkTWCDSYJNjs.parseCachedHeader.call(void 0, 
+                    _nullishCoalesce(_optionalChain([ret, 'access', _44 => _44.rawResponse, 'optionalAccess', _45 => _45.headers, 'optionalAccess', _46 => _46[_chunkTWCDSYJNjs.X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _47 => _47.rawResponse, 'optionalAccess', _48 => _48.headers, 'optionalAccess', _49 => _49[_chunkTWCDSYJNjs.LEGACY_CACHED_HEADER]])))
                   )
                 }
               });
@@ -1509,7 +1760,7 @@ function postProcessPrompt(prompt) {
         return [
           {
             role: "assistant",
-            content: _optionalChain([textPart, 'optionalAccess', _44 => _44.text]),
+            content: _optionalChain([textPart, 'optionalAccess', _50 => _50.text]),
             ...toolCallParts.length > 0 ? {
               tool_calls: toolCallParts.map((part) => ({
                 id: part.toolCallId,
@@ -1582,23 +1833,23 @@ function postProcessOutput(text, toolCalls2, finishReason) {
 
 // src/wrappers/ai-sdk/deprecated/BraintrustMiddleware.ts
 function detectProviderFromResult(result) {
-  if (!_optionalChain([result, 'optionalAccess', _45 => _45.providerMetadata])) {
+  if (!_optionalChain([result, 'optionalAccess', _51 => _51.providerMetadata])) {
     return void 0;
   }
   const keys = Object.keys(result.providerMetadata);
-  return _optionalChain([keys, 'optionalAccess', _46 => _46.at, 'call', _47 => _47(0)]);
+  return _optionalChain([keys, 'optionalAccess', _52 => _52.at, 'call', _53 => _53(0)]);
 }
 function extractModelFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _48 => _48.response, 'optionalAccess', _49 => _49.modelId])) {
+  if (_optionalChain([result, 'optionalAccess', _54 => _54.response, 'optionalAccess', _55 => _55.modelId])) {
     return result.response.modelId;
   }
-  if (_optionalChain([result, 'optionalAccess', _50 => _50.request, 'optionalAccess', _51 => _51.body, 'optionalAccess', _52 => _52.model])) {
+  if (_optionalChain([result, 'optionalAccess', _56 => _56.request, 'optionalAccess', _57 => _57.body, 'optionalAccess', _58 => _58.model])) {
     return result.request.body.model;
   }
   return void 0;
 }
 function extractModelFromWrapGenerateCallback(model) {
-  return _optionalChain([model, 'optionalAccess', _53 => _53.modelId]);
+  return _optionalChain([model, 'optionalAccess', _59 => _59.modelId]);
 }
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
@@ -1643,19 +1894,19 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
-    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _54 => _54.anthropic]);
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _60 => _60.anthropic]);
     if (anthropicMetadata) {
       const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
       const cacheCreationTokens = getNumberProperty(
         anthropicMetadata.usage,
         "cache_creation_input_tokens"
       ) || 0;
-      const cacheTokens = _chunkXLLGRXGRjs.extractAnthropicCacheTokens.call(void 0, 
+      const cacheTokens = _chunkTWCDSYJNjs.extractAnthropicCacheTokens.call(void 0, 
         cacheReadTokens,
         cacheCreationTokens
       );
       Object.assign(metrics, cacheTokens);
-      return _chunkXLLGRXGRjs.toNumericMetrics.call(void 0, _chunkXLLGRXGRjs.finalizeAnthropicTokens.call(void 0, metrics));
+      return _chunkTWCDSYJNjs.toNumericMetrics.call(void 0, _chunkTWCDSYJNjs.finalizeAnthropicTokens.call(void 0, metrics));
     }
   }
   return metrics;
@@ -1669,7 +1920,7 @@ function buildAssistantOutputWithToolCalls(result, toolCalls2) {
     {
       index: 0,
       logprobs: null,
-      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _55 => _55.finishReason])), () => ( (toolCalls2.length ? "tool_calls" : void 0))),
+      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _61 => _61.finishReason])), () => ( (toolCalls2.length ? "tool_calls" : void 0))),
       message: {
         role: "assistant",
         tool_calls: toolCalls2.length > 0 ? toolCalls2 : void 0
@@ -1682,7 +1933,7 @@ function extractToolCallsFromSteps(steps) {
   if (!Array.isArray(steps)) return toolCalls2;
   let idx = 0;
   for (const step of steps) {
-    const blocks = _optionalChain([step, 'optionalAccess', _56 => _56.content]);
+    const blocks = _optionalChain([step, 'optionalAccess', _62 => _62.content]);
     if (!Array.isArray(blocks)) continue;
     for (const block of blocks) {
       if (block && typeof block === "object" && block.type === "tool-call") {
@@ -1705,7 +1956,7 @@ function extractToolCallsFromBlocks(blocks) {
   return extractToolCallsFromSteps([{ content: blocks }]);
 }
 function extractInput(params) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _57 => _57.prompt]), () => ( _optionalChain([params, 'optionalAccess', _58 => _58.messages]))), () => ( _optionalChain([params, 'optionalAccess', _59 => _59.system])));
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _63 => _63.prompt]), () => ( _optionalChain([params, 'optionalAccess', _64 => _64.messages]))), () => ( _optionalChain([params, 'optionalAccess', _65 => _65.system])));
 }
 var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
   "prompt",
@@ -1727,23 +1978,23 @@ function BraintrustMiddleware(config = {}) {
       model: modelFromWrapGenerate
     }) => {
       const rawInput = extractInput(params);
-      const processedInput = _chunkXLLGRXGRjs.processInputAttachments.call(void 0, rawInput);
+      const processedInput = _chunkTWCDSYJNjs.processInputAttachments.call(void 0, rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _60 => _60.spanInfo, 'optionalAccess', _61 => _61.name]) || "ai-sdk.doGenerate",
+        name: _optionalChain([config, 'access', _66 => _66.spanInfo, 'optionalAccess', _67 => _67.name]) || "ai-sdk.doGenerate",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _62 => _62.spanInfo, 'optionalAccess', _63 => _63.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _68 => _68.spanInfo, 'optionalAccess', _69 => _69.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _64 => _64.spanInfo, 'optionalAccess', _65 => _65.metadata]) || {}
+            ..._optionalChain([config, 'access', _70 => _70.spanInfo, 'optionalAccess', _71 => _71.metadata]) || {}
           }
         }
       };
-      const span = _chunkXLLGRXGRjs.startSpan.call(void 0, 
-        _chunk6Z5S7VOUjs.withSpanInstrumentationName.call(void 0, spanArgs, _chunk6Z5S7VOUjs.INSTRUMENTATION_NAMES.AI_SDK)
+      const span = _chunkTWCDSYJNjs.startSpan.call(void 0, 
+        _chunk2XDW3UCGjs.withSpanInstrumentationName.call(void 0, spanArgs, _chunk2XDW3UCGjs.INSTRUMENTATION_NAMES.AI_SDK)
       );
       try {
         const result = await doGenerate();
@@ -1766,12 +2017,12 @@ function BraintrustMiddleware(config = {}) {
             metadata.model = modelId;
           }
         }
-        let toolCalls2 = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _66 => _66.steps]));
+        let toolCalls2 = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _72 => _72.steps]));
         if (!toolCalls2 || toolCalls2.length === 0) {
-          toolCalls2 = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _67 => _67.content]));
+          toolCalls2 = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _73 => _73.content]));
         }
         span.log({
-          output: toolCalls2.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls2) : _optionalChain([result, 'optionalAccess', _68 => _68.content]),
+          output: toolCalls2.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls2) : _optionalChain([result, 'optionalAccess', _74 => _74.content]),
           metadata,
           metrics: normalizeUsageMetrics(
             result.usage,
@@ -1791,23 +2042,23 @@ function BraintrustMiddleware(config = {}) {
     },
     wrapStream: async ({ doStream, params }) => {
       const rawInput = extractInput(params);
-      const processedInput = _chunkXLLGRXGRjs.processInputAttachments.call(void 0, rawInput);
+      const processedInput = _chunkTWCDSYJNjs.processInputAttachments.call(void 0, rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _69 => _69.spanInfo, 'optionalAccess', _70 => _70.name]) || "ai-sdk.doStream",
+        name: _optionalChain([config, 'access', _75 => _75.spanInfo, 'optionalAccess', _76 => _76.name]) || "ai-sdk.doStream",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _71 => _71.spanInfo, 'optionalAccess', _72 => _72.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _77 => _77.spanInfo, 'optionalAccess', _78 => _78.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _73 => _73.spanInfo, 'optionalAccess', _74 => _74.metadata]) || {}
+            ..._optionalChain([config, 'access', _79 => _79.spanInfo, 'optionalAccess', _80 => _80.metadata]) || {}
           }
         }
       };
-      const span = _chunkXLLGRXGRjs.startSpan.call(void 0, 
-        _chunk6Z5S7VOUjs.withSpanInstrumentationName.call(void 0, spanArgs, _chunk6Z5S7VOUjs.INSTRUMENTATION_NAMES.AI_SDK)
+      const span = _chunkTWCDSYJNjs.startSpan.call(void 0, 
+        _chunk2XDW3UCGjs.withSpanInstrumentationName.call(void 0, spanArgs, _chunk2XDW3UCGjs.INSTRUMENTATION_NAMES.AI_SDK)
       );
       try {
         const { stream, ...rest } = await doStream();
@@ -1932,7 +2183,7 @@ function createLegacyEveInstrumentation(options) {
         try {
           captureEveModelInput(state, input);
         } catch (error) {
-          _chunk6Z5S7VOUjs.debugLogger.warn("Error in Eve LLM input capture:", error);
+          _chunk2XDW3UCGjs.debugLogger.warn("Error in Eve LLM input capture:", error);
         }
       }
     },
@@ -1942,7 +2193,7 @@ function createLegacyEveInstrumentation(options) {
   };
 }
 function isEveHandleMessageStreamEvent(event) {
-  return _chunkXLLGRXGRjs.isObject.call(void 0, event) && typeof event["type"] === "string";
+  return _chunkTWCDSYJNjs.isObject.call(void 0, event) && typeof event["type"] === "string";
 }
 var ResumedEveSpan = class {
   constructor(reference) {
@@ -1959,11 +2210,11 @@ var ResumedEveSpan = class {
   }
   log(event) {
     const metrics = {
-      ..._optionalChain([this, 'access', _75 => _75.reference, 'access', _76 => _76.startEvent, 'optionalAccess', _77 => _77.metrics]),
+      ..._optionalChain([this, 'access', _81 => _81.reference, 'access', _82 => _82.startEvent, 'optionalAccess', _83 => _83.metrics]),
       ...this.endTime === void 0 ? {} : { end: this.endTime },
       ...event.metrics
     };
-    _chunkXLLGRXGRjs.updateSpan.call(void 0, {
+    _chunkTWCDSYJNjs.updateSpan.call(void 0, {
       exported: this.reference.exported,
       ...this.reference.startEvent,
       ...event,
@@ -1972,7 +2223,7 @@ var ResumedEveSpan = class {
   }
   end(args) {
     if (this.endTime === void 0) {
-      this.endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _78 => _78.endTime]), () => ( _chunkXLLGRXGRjs.getCurrentUnixTimestamp.call(void 0, )));
+      this.endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _84 => _84.endTime]), () => ( _chunkTWCDSYJNjs.getCurrentUnixTimestamp.call(void 0, )));
       this.log({ metrics: { end: this.endTime } });
     }
     return this.endTime;
@@ -1984,41 +2235,41 @@ var EveBridge = (_class = class {
   }
   
   __init() {this.eventQueuesBySession = /* @__PURE__ */ new Map()}
-  __init2() {this.completedToolKeys = new (0, _chunkXLLGRXGRjs.LRUCache)({
+  __init2() {this.completedToolKeys = new (0, _chunkTWCDSYJNjs.LRUCache)({
     max: MAX_EVE_CACHE_ENTRIES
   })}
-  __init3() {this.toolsByCallKey = new (0, _chunkXLLGRXGRjs.LRUCache)({
+  __init3() {this.toolsByCallKey = new (0, _chunkTWCDSYJNjs.LRUCache)({
     max: MAX_EVE_CACHE_ENTRIES
   })}
-  __init4() {this.turnsByKey = new (0, _chunkXLLGRXGRjs.LRUCache)({
+  __init4() {this.turnsByKey = new (0, _chunkTWCDSYJNjs.LRUCache)({
     max: MAX_EVE_CACHE_ENTRIES
   })}
   async startEveSpan(args) {
-    const rowId = _optionalChain([args, 'optionalAccess', _79 => _79.event, 'optionalAccess', _80 => _80.id]);
+    const rowId = _optionalChain([args, 'optionalAccess', _85 => _85.event, 'optionalAccess', _86 => _86.id]);
     const reference = typeof rowId === "string" && readEveTraceState(this.state).spanReferences.find(
       (candidate) => candidate.rowId === rowId
     );
     if (reference) {
       return new ResumedEveSpan(reference);
     }
-    const startTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _81 => _81.startTime]), () => ( _chunkXLLGRXGRjs.getCurrentUnixTimestamp.call(void 0, )));
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _82 => _82.parentSpanIds]);
+    const startTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _87 => _87.startTime]), () => ( _chunkTWCDSYJNjs.getCurrentUnixTimestamp.call(void 0, )));
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _88 => _88.parentSpanIds]);
     const startEvent = {
       created: (/* @__PURE__ */ new Date()).toISOString(),
       metrics: { start: startTime },
       span_attributes: {
-        ..._optionalChain([args, 'optionalAccess', _83 => _83.name]) ? { name: args.name } : {},
-        ..._optionalChain([args, 'optionalAccess', _84 => _84.type]) ? { type: args.type } : {},
-        ..._optionalChain([args, 'optionalAccess', _85 => _85.spanAttributes])
+        ..._optionalChain([args, 'optionalAccess', _89 => _89.name]) ? { name: args.name } : {},
+        ..._optionalChain([args, 'optionalAccess', _90 => _90.type]) ? { type: args.type } : {},
+        ..._optionalChain([args, 'optionalAccess', _91 => _91.spanAttributes])
       },
       span_parents: parentSpanIds ? "spanId" in parentSpanIds ? [parentSpanIds.spanId] : parentSpanIds.parentSpanIds : []
     };
-    const span = _chunkXLLGRXGRjs.withCurrent.call(void 0, 
-      _chunkXLLGRXGRjs.NOOP_SPAN,
-      () => _chunkXLLGRXGRjs._internalStartSpanWithInitialMerge.call(void 0, 
-        _chunk6Z5S7VOUjs.withSpanInstrumentationName.call(void 0, 
+    const span = _chunkTWCDSYJNjs.withCurrent.call(void 0, 
+      _chunkTWCDSYJNjs.NOOP_SPAN,
+      () => _chunkTWCDSYJNjs._internalStartSpanWithInitialMerge.call(void 0, 
+        _chunk2XDW3UCGjs.withSpanInstrumentationName.call(void 0, 
           { ...args, startTime },
-          _chunk6Z5S7VOUjs.INSTRUMENTATION_NAMES.EVE
+          _chunk2XDW3UCGjs.INSTRUMENTATION_NAMES.EVE
         )
       )
     );
@@ -2046,7 +2297,7 @@ var EveBridge = (_class = class {
         };
       });
     } catch (error) {
-      _chunk6Z5S7VOUjs.debugLogger.warn("Error exporting Eve span for resumption:", error);
+      _chunk2XDW3UCGjs.debugLogger.warn("Error exporting Eve span for resumption:", error);
     }
     return span;
   }
@@ -2066,7 +2317,7 @@ var EveBridge = (_class = class {
       const previous = state.stepStarts.filter(
         (entry) => entry.turnId === event.data.turnId && entry.stepIndex === event.data.stepIndex
       ).at(-1);
-      if (_optionalChain([previous, 'optionalAccess', _86 => _86.open])) {
+      if (_optionalChain([previous, 'optionalAccess', _92 => _92.open])) {
         ordinal = previous.ordinal;
         return state;
       }
@@ -2094,12 +2345,12 @@ var EveBridge = (_class = class {
       let index = -1;
       for (let i = state.stepStarts.length - 1; i >= 0; i--) {
         const entry = state.stepStarts[i];
-        if (_optionalChain([entry, 'optionalAccess', _87 => _87.turnId]) === turnId && entry.stepIndex === stepIndex) {
+        if (_optionalChain([entry, 'optionalAccess', _93 => _93.turnId]) === turnId && entry.stepIndex === stepIndex) {
           index = i;
           break;
         }
       }
-      if (index < 0 || !_optionalChain([state, 'access', _88 => _88.stepStarts, 'access', _89 => _89[index], 'optionalAccess', _90 => _90.open])) {
+      if (index < 0 || !_optionalChain([state, 'access', _94 => _94.stepStarts, 'access', _95 => _95[index], 'optionalAccess', _96 => _96.open])) {
         return state;
       }
       return {
@@ -2133,7 +2384,7 @@ var EveBridge = (_class = class {
           }
         }
       } catch (error) {
-        _chunk6Z5S7VOUjs.debugLogger.warn("Error in Eve hook instrumentation:", error);
+        _chunk2XDW3UCGjs.debugLogger.warn("Error in Eve hook instrumentation:", error);
       }
     };
     const sessionId = event.type === "session.failed" ? event.data.sessionId || sessionIdFromContext(ctx) : sessionIdFromContext(ctx);
@@ -2361,7 +2612,7 @@ var EveBridge = (_class = class {
       return;
     }
     const existingMessage = eveOutputMessage(step.output);
-    const existingToolCalls = _chunkXLLGRXGRjs.isObject.call(void 0, existingMessage) ? existingMessage.tool_calls : void 0;
+    const existingToolCalls = _chunkTWCDSYJNjs.isObject.call(void 0, existingMessage) ? existingMessage.tool_calls : void 0;
     step.output = mergeEveReasoning(
       [
         {
@@ -2425,11 +2676,11 @@ var EveBridge = (_class = class {
       return;
     }
     const toolCallsById = /* @__PURE__ */ new Map();
-    if (Array.isArray(step.output) && _chunkXLLGRXGRjs.isObject.call(void 0, step.output[0])) {
+    if (Array.isArray(step.output) && _chunkTWCDSYJNjs.isObject.call(void 0, step.output[0])) {
       const message = step.output[0]["message"];
-      if (_chunkXLLGRXGRjs.isObject.call(void 0, message) && Array.isArray(message["tool_calls"])) {
+      if (_chunkTWCDSYJNjs.isObject.call(void 0, message) && Array.isArray(message["tool_calls"])) {
         for (const toolCall of message["tool_calls"]) {
-          if (_chunkXLLGRXGRjs.isObject.call(void 0, toolCall) && typeof toolCall["id"] === "string") {
+          if (_chunkTWCDSYJNjs.isObject.call(void 0, toolCall) && typeof toolCall["id"] === "string") {
             toolCallsById.set(toolCall["id"], toolCall);
           }
         }
@@ -2502,7 +2753,7 @@ var EveBridge = (_class = class {
     this.completedToolKeys.set(key, true);
   }
   async handleSubagentCalled(event, ctx, hookMetadata) {
-    if (_optionalChain([event, 'access', _91 => _91.data, 'access', _92 => _92.remote, 'optionalAccess', _93 => _93.url])) {
+    if (_optionalChain([event, 'access', _97 => _97.data, 'access', _98 => _98.remote, 'optionalAccess', _99 => _99.url])) {
       return;
     }
     const turn = await this.ensureTurn(event, ctx, hookMetadata);
@@ -2622,11 +2873,11 @@ var EveBridge = (_class = class {
       return;
     }
     const usage = event.data.usage;
-    const inputTokens = typeof _optionalChain([usage, 'optionalAccess', _94 => _94.inputTokens]) === "number" && Number.isFinite(usage.inputTokens) && usage.inputTokens >= 0 ? usage.inputTokens : void 0;
-    const outputTokens = typeof _optionalChain([usage, 'optionalAccess', _95 => _95.outputTokens]) === "number" && Number.isFinite(usage.outputTokens) && usage.outputTokens >= 0 ? usage.outputTokens : void 0;
-    const cacheReadTokens = typeof _optionalChain([usage, 'optionalAccess', _96 => _96.cacheReadTokens]) === "number" && Number.isFinite(usage.cacheReadTokens) && usage.cacheReadTokens >= 0 ? usage.cacheReadTokens : void 0;
-    const cacheWriteTokens = typeof _optionalChain([usage, 'optionalAccess', _97 => _97.cacheWriteTokens]) === "number" && Number.isFinite(usage.cacheWriteTokens) && usage.cacheWriteTokens >= 0 ? usage.cacheWriteTokens : void 0;
-    const costUsd = typeof _optionalChain([usage, 'optionalAccess', _98 => _98.costUsd]) === "number" && Number.isFinite(usage.costUsd) && usage.costUsd >= 0 ? usage.costUsd : void 0;
+    const inputTokens = typeof _optionalChain([usage, 'optionalAccess', _100 => _100.inputTokens]) === "number" && Number.isFinite(usage.inputTokens) && usage.inputTokens >= 0 ? usage.inputTokens : void 0;
+    const outputTokens = typeof _optionalChain([usage, 'optionalAccess', _101 => _101.outputTokens]) === "number" && Number.isFinite(usage.outputTokens) && usage.outputTokens >= 0 ? usage.outputTokens : void 0;
+    const cacheReadTokens = typeof _optionalChain([usage, 'optionalAccess', _102 => _102.cacheReadTokens]) === "number" && Number.isFinite(usage.cacheReadTokens) && usage.cacheReadTokens >= 0 ? usage.cacheReadTokens : void 0;
+    const cacheWriteTokens = typeof _optionalChain([usage, 'optionalAccess', _103 => _103.cacheWriteTokens]) === "number" && Number.isFinite(usage.cacheWriteTokens) && usage.cacheWriteTokens >= 0 ? usage.cacheWriteTokens : void 0;
+    const costUsd = typeof _optionalChain([usage, 'optionalAccess', _104 => _104.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 } : {},
@@ -2638,7 +2889,7 @@ var EveBridge = (_class = class {
     };
     step.metrics = { ...step.metrics, ...metrics };
     const sessionId = sessionIdFromContext(ctx);
-    if (Array.isArray(step.output) && _chunkXLLGRXGRjs.isObject.call(void 0, step.output[0])) {
+    if (Array.isArray(step.output) && _chunkTWCDSYJNjs.isObject.call(void 0, step.output[0])) {
       const finishReason = step.output[0].finish_reason;
       if (typeof finishReason !== "string") {
         step.output[0].finish_reason = normalizedFinishReason(
@@ -2685,7 +2936,7 @@ var EveBridge = (_class = class {
       step.span.end(endTime === void 0 ? void 0 : { endTime });
     }
     const turn = this.turnForEvent(event, ctx);
-    _optionalChain([turn, 'optionalAccess', _99 => _99.stepsByIndex, 'access', _100 => _100.delete, 'call', _101 => _101(event.data.stepIndex)]);
+    _optionalChain([turn, 'optionalAccess', _105 => _105.stepsByIndex, 'access', _106 => _106.delete, 'call', _107 => _107(event.data.stepIndex)]);
     this.markStepEnded(event.data.turnId, event.data.stepIndex);
     const sessionId = sessionIdFromContext(ctx);
     if (sessionId) {
@@ -2976,10 +3227,10 @@ var EveBridge = (_class = class {
     return state;
   }
   async startTurnSpan(sessionId, event, ctx, metadata) {
-    const session = _chunkXLLGRXGRjs.isObject.call(void 0, ctx) ? ctx["session"] : void 0;
-    const parent = _chunkXLLGRXGRjs.isObject.call(void 0, session) ? session["parent"] : void 0;
-    const parentTurn = _chunkXLLGRXGRjs.isObject.call(void 0, parent) ? parent["turn"] : void 0;
-    const parentLineage = _chunkXLLGRXGRjs.isObject.call(void 0, parent) && typeof parent["callId"] === "string" && typeof parent["sessionId"] === "string" && _chunkXLLGRXGRjs.isObject.call(void 0, parentTurn) && typeof parentTurn["id"] === "string" ? {
+    const session = _chunkTWCDSYJNjs.isObject.call(void 0, ctx) ? ctx["session"] : void 0;
+    const parent = _chunkTWCDSYJNjs.isObject.call(void 0, session) ? session["parent"] : void 0;
+    const parentTurn = _chunkTWCDSYJNjs.isObject.call(void 0, parent) ? parent["turn"] : void 0;
+    const parentLineage = _chunkTWCDSYJNjs.isObject.call(void 0, parent) && typeof parent["callId"] === "string" && typeof parent["sessionId"] === "string" && _chunkTWCDSYJNjs.isObject.call(void 0, parentTurn) && typeof parentTurn["id"] === "string" ? {
       callId: parent["callId"],
       sessionId: parent["sessionId"],
       turnId: parentTurn["id"]
@@ -2988,8 +3239,8 @@ var EveBridge = (_class = class {
       generateEveIds("turn", sessionId, event.data.turnId),
       deterministicEveId(
         "eve:root",
-        _nullishCoalesce(_optionalChain([parentLineage, 'optionalAccess', _102 => _102.sessionId]), () => ( sessionId)),
-        _nullishCoalesce(_optionalChain([parentLineage, 'optionalAccess', _103 => _103.turnId]), () => ( event.data.turnId))
+        _nullishCoalesce(_optionalChain([parentLineage, 'optionalAccess', _108 => _108.sessionId]), () => ( sessionId)),
+        _nullishCoalesce(_optionalChain([parentLineage, 'optionalAccess', _109 => _109.turnId]), () => ( event.data.turnId))
       ),
       parentLineage ? deterministicEveId(
         "eve:subagent",
@@ -3014,7 +3265,7 @@ var EveBridge = (_class = class {
     return sessionId ? this.turnsByKey.get(turnKey(sessionId, event.data.turnId)) : void 0;
   }
   stepForEvent(event, ctx) {
-    return _optionalChain([this, 'access', _104 => _104.turnForEvent, 'call', _105 => _105(event, ctx), 'optionalAccess', _106 => _106.stepsByIndex, 'access', _107 => _107.get, 'call', _108 => _108(
+    return _optionalChain([this, 'access', _110 => _110.turnForEvent, 'call', _111 => _111(event, ctx), 'optionalAccess', _112 => _112.stepsByIndex, 'access', _113 => _113.get, 'call', _114 => _114(
       event.data.stepIndex
     )]);
   }
@@ -3086,10 +3337,10 @@ var EveBridge = (_class = class {
   }
   async flushInstrumentation() {
     try {
-      await _chunkXLLGRXGRjs.flush.call(void 0, );
+      await _chunkTWCDSYJNjs.flush.call(void 0, );
       return true;
     } catch (error) {
-      _chunk6Z5S7VOUjs.debugLogger.warn("Error in Eve flush instrumentation:", error);
+      _chunk2XDW3UCGjs.debugLogger.warn("Error in Eve flush instrumentation:", error);
       return false;
     }
   }
@@ -3104,12 +3355,12 @@ function emptyEveTraceState() {
   };
 }
 function normalizeEveTraceState(state) {
-  if (!_chunkXLLGRXGRjs.isObject.call(void 0, state)) {
+  if (!_chunkTWCDSYJNjs.isObject.call(void 0, state)) {
     return emptyEveTraceState();
   }
-  const metadata = _chunkXLLGRXGRjs.isObject.call(void 0, state["metadata"]) ? state["metadata"] : {};
+  const metadata = _chunkTWCDSYJNjs.isObject.call(void 0, state["metadata"]) ? state["metadata"] : {};
   const spanReferences = Array.isArray(state["spanReferences"]) ? state["spanReferences"].flatMap((entry) => {
-    if (!_chunkXLLGRXGRjs.isObject.call(void 0, entry)) {
+    if (!_chunkTWCDSYJNjs.isObject.call(void 0, entry)) {
       return [];
     }
     const exported = entry["exported"];
@@ -3118,11 +3369,11 @@ function normalizeEveTraceState(state) {
     const rowId = entry["rowId"];
     const spanId = entry["spanId"];
     const startEvent = entry["startEvent"];
-    const startEventCreated = _chunkXLLGRXGRjs.isObject.call(void 0, startEvent) ? startEvent["created"] : void 0;
-    const startEventMetrics = _chunkXLLGRXGRjs.isObject.call(void 0, startEvent) ? startEvent["metrics"] : void 0;
-    const startEventSpanAttributes = _chunkXLLGRXGRjs.isObject.call(void 0, startEvent) ? startEvent["span_attributes"] : void 0;
-    const startEventSpanParents = _chunkXLLGRXGRjs.isObject.call(void 0, startEvent) ? startEvent["span_parents"] : void 0;
-    const normalizedStartEvent = typeof startEventCreated === "string" && _chunkXLLGRXGRjs.isObject.call(void 0, startEventMetrics) && typeof startEventMetrics["start"] === "number" && Number.isFinite(startEventMetrics["start"]) && _chunkXLLGRXGRjs.isObject.call(void 0, startEventSpanAttributes) && Array.isArray(startEventSpanParents) && startEventSpanParents.every(
+    const startEventCreated = _chunkTWCDSYJNjs.isObject.call(void 0, startEvent) ? startEvent["created"] : void 0;
+    const startEventMetrics = _chunkTWCDSYJNjs.isObject.call(void 0, startEvent) ? startEvent["metrics"] : void 0;
+    const startEventSpanAttributes = _chunkTWCDSYJNjs.isObject.call(void 0, startEvent) ? startEvent["span_attributes"] : void 0;
+    const startEventSpanParents = _chunkTWCDSYJNjs.isObject.call(void 0, startEvent) ? startEvent["span_parents"] : void 0;
+    const normalizedStartEvent = typeof startEventCreated === "string" && _chunkTWCDSYJNjs.isObject.call(void 0, startEventMetrics) && typeof startEventMetrics["start"] === "number" && Number.isFinite(startEventMetrics["start"]) && _chunkTWCDSYJNjs.isObject.call(void 0, startEventSpanAttributes) && Array.isArray(startEventSpanParents) && startEventSpanParents.every(
       (parent) => typeof parent === "string"
     ) ? {
       created: startEventCreated,
@@ -3142,7 +3393,7 @@ function normalizeEveTraceState(state) {
     ] : [];
   }).slice(-MAX_STORED_SPAN_REFERENCES) : [];
   const llmInputs = Array.isArray(state["llmInputs"]) ? state["llmInputs"].flatMap((entry) => {
-    if (!_chunkXLLGRXGRjs.isObject.call(void 0, entry)) {
+    if (!_chunkTWCDSYJNjs.isObject.call(void 0, entry)) {
       return [];
     }
     const key = entry["key"];
@@ -3150,7 +3401,7 @@ function normalizeEveTraceState(state) {
     return typeof key === "string" && isCapturedModelInput(input) ? [{ input, key }] : [];
   }).slice(-MAX_STORED_LLM_INPUTS) : [];
   const reasoningBlocks = Array.isArray(state["reasoningBlocks"]) ? state["reasoningBlocks"].flatMap((entry) => {
-    if (!_chunkXLLGRXGRjs.isObject.call(void 0, entry)) {
+    if (!_chunkTWCDSYJNjs.isObject.call(void 0, entry)) {
       return [];
     }
     const content = entry["content"];
@@ -3165,7 +3416,7 @@ function normalizeEveTraceState(state) {
     ] : [];
   }).slice(-MAX_STORED_REASONING_BLOCKS) : [];
   const stepStarts = Array.isArray(state["stepStarts"]) ? state["stepStarts"].flatMap((entry) => {
-    if (!_chunkXLLGRXGRjs.isObject.call(void 0, entry)) {
+    if (!_chunkTWCDSYJNjs.isObject.call(void 0, entry)) {
       return [];
     }
     const ordinal = entry["ordinal"];
@@ -3185,12 +3436,12 @@ function normalizeEveTraceState(state) {
 function readEveTraceState(state) {
   try {
     return normalizeEveTraceState(state.get());
-  } catch (e4) {
+  } catch (e6) {
     return emptyEveTraceState();
   }
 }
 function storeEveReasoning(state, sessionId, event) {
-  const eventAt = _optionalChain([event, 'access', _109 => _109.meta, 'optionalAccess', _110 => _110.at]);
+  const eventAt = _optionalChain([event, 'access', _115 => _115.meta, 'optionalAccess', _116 => _116.at]);
   const key = llmInputKey(sessionId, event.data.turnId, event.data.stepIndex);
   let stored = [];
   state.update((current) => {
@@ -3242,14 +3493,14 @@ function clearStoredEveReasoning(state, sessionId, turnId, stepIndex) {
   });
 }
 function eveOutputMessage(output) {
-  return Array.isArray(output) && _chunkXLLGRXGRjs.isObject.call(void 0, output[0]) ? output[0]["message"] : void 0;
+  return Array.isArray(output) && _chunkTWCDSYJNjs.isObject.call(void 0, output[0]) ? output[0]["message"] : void 0;
 }
 function mergeEveReasoning(output, reasoning) {
   if (reasoning.length === 0) {
     return output;
   }
-  const choice = Array.isArray(output) && _chunkXLLGRXGRjs.isObject.call(void 0, output[0]) ? output[0] : {};
-  const message = _chunkXLLGRXGRjs.isObject.call(void 0, choice["message"]) ? choice["message"] : {};
+  const choice = Array.isArray(output) && _chunkTWCDSYJNjs.isObject.call(void 0, output[0]) ? output[0] : {};
+  const message = _chunkTWCDSYJNjs.isObject.call(void 0, choice["message"]) ? choice["message"] : {};
   return [
     {
       ...choice,
@@ -3293,7 +3544,7 @@ function consumeCapturedEveModelInput(state, sessionId, turnId, stepIndex) {
       if (index < 0) {
         return normalized;
       }
-      input = _optionalChain([normalized, 'access', _111 => _111.llmInputs, 'access', _112 => _112[index], 'optionalAccess', _113 => _113.input]);
+      input = _optionalChain([normalized, 'access', _117 => _117.llmInputs, 'access', _118 => _118[index], 'optionalAccess', _119 => _119.input]);
       return {
         ...normalized,
         llmInputs: normalized.llmInputs.filter(
@@ -3303,7 +3554,7 @@ function consumeCapturedEveModelInput(state, sessionId, turnId, stepIndex) {
     });
     return input;
   } catch (error) {
-    _chunk6Z5S7VOUjs.debugLogger.warn("Error in Eve LLM input consumption:", error);
+    _chunk2XDW3UCGjs.debugLogger.warn("Error in Eve LLM input consumption:", error);
     return void 0;
   }
 }
@@ -3324,7 +3575,7 @@ function capturedModelInput(modelInput) {
       return void 0;
     }
     return cloned;
-  } catch (e5) {
+  } catch (e7) {
     return void 0;
   }
 }
@@ -3443,14 +3694,14 @@ function capturedEveModelContentPart(part) {
 }
 function isCapturedModelInput(input) {
   return Array.isArray(input) && input.every(
-    (message) => _chunkXLLGRXGRjs.isObject.call(void 0, message) && (message["role"] === "system" || message["role"] === "user" || message["role"] === "assistant" || message["role"] === "tool") && (typeof message["content"] === "string" || Array.isArray(message["content"]) && message["content"].every(_chunkXLLGRXGRjs.isObject))
+    (message) => _chunkTWCDSYJNjs.isObject.call(void 0, message) && (message["role"] === "system" || message["role"] === "user" || message["role"] === "assistant" || message["role"] === "tool") && (typeof message["content"] === "string" || Array.isArray(message["content"]) && message["content"].every(_chunkTWCDSYJNjs.isObject))
   );
 }
 function llmInputKey(sessionId, turnId, stepIndex) {
   return `${sessionId}\0${turnId}\0${stepIndex}`;
 }
 function modelMetadataFromRuntime(runtime) {
-  if (!_chunkXLLGRXGRjs.isObject.call(void 0, runtime)) {
+  if (!_chunkTWCDSYJNjs.isObject.call(void 0, runtime)) {
     return {};
   }
   const modelId = runtime["modelId"];
@@ -3473,11 +3724,11 @@ function modelMetadataFromModelId(modelId) {
   };
 }
 function sessionIdFromContext(ctx) {
-  if (!_chunkXLLGRXGRjs.isObject.call(void 0, ctx)) {
+  if (!_chunkTWCDSYJNjs.isObject.call(void 0, ctx)) {
     return void 0;
   }
   const session = ctx["session"];
-  if (!_chunkXLLGRXGRjs.isObject.call(void 0, session)) {
+  if (!_chunkTWCDSYJNjs.isObject.call(void 0, session)) {
     return void 0;
   }
   const id = session["id"];
@@ -3488,19 +3739,19 @@ function toolMetadataFromTurn(turn) {
   return metadata;
 }
 function isToolCallAction(action) {
-  return _chunkXLLGRXGRjs.isObject.call(void 0, action) && action["kind"] === "tool-call" && typeof action["callId"] === "string" && typeof action["toolName"] === "string" && _chunkXLLGRXGRjs.isObject.call(void 0, action["input"]);
+  return _chunkTWCDSYJNjs.isObject.call(void 0, action) && action["kind"] === "tool-call" && typeof action["callId"] === "string" && typeof action["toolName"] === "string" && _chunkTWCDSYJNjs.isObject.call(void 0, action["input"]);
 }
 function isLocalSubagentCallAction(action) {
-  return _chunkXLLGRXGRjs.isObject.call(void 0, action) && action["kind"] === "subagent-call" && typeof action["callId"] === "string" && _chunkXLLGRXGRjs.isObject.call(void 0, action["input"]);
+  return _chunkTWCDSYJNjs.isObject.call(void 0, action) && action["kind"] === "subagent-call" && typeof action["callId"] === "string" && _chunkTWCDSYJNjs.isObject.call(void 0, action["input"]);
 }
 function isTraceableActionRequest(action) {
   return isToolCallAction(action) || isLocalSubagentCallAction(action);
 }
 function isToolResult(result) {
-  return _chunkXLLGRXGRjs.isObject.call(void 0, result) && result["kind"] === "tool-result" && typeof result["callId"] === "string" && typeof result["toolName"] === "string";
+  return _chunkTWCDSYJNjs.isObject.call(void 0, result) && result["kind"] === "tool-result" && typeof result["callId"] === "string" && typeof result["toolName"] === "string";
 }
 function isSubagentResult(result) {
-  return _chunkXLLGRXGRjs.isObject.call(void 0, result) && result["kind"] === "subagent-result" && typeof result["callId"] === "string" && typeof result["subagentName"] === "string";
+  return _chunkTWCDSYJNjs.isObject.call(void 0, result) && result["kind"] === "subagent-result" && typeof result["callId"] === "string" && typeof result["subagentName"] === "string";
 }
 function normalizedFinishReason(finishReason) {
   switch (finishReason) {
@@ -3530,7 +3781,7 @@ function actionResultError(error, output) {
   return result;
 }
 function eventTime(event) {
-  if (!_optionalChain([event, 'access', _114 => _114.meta, 'optionalAccess', _115 => _115.at])) {
+  if (!_optionalChain([event, 'access', _120 => _120.meta, 'optionalAccess', _121 => _121.at])) {
     return void 0;
   }
   const timestamp = Date.parse(event.meta.at);
@@ -3564,7 +3815,15 @@ var MAX_EVE_PROVIDER_CACHE_ENTRIES = 1e4;
 function createEveInstrumentationProvider(options = {}) {
   const bridge = new EveProviderBridge(options.metadata);
   return {
+    // Eve versions before tracePolicy use capture to decide whether provider
+    // events include content. Newer versions prefer tracePolicy when both are
+    // present, so keep the deprecated field for backwards compatibility.
     capture: "content",
+    tracePolicy: () => ({
+      emit: true,
+      recordInputs: true,
+      recordOutputs: true
+    }),
     events: {
       "action.completed": (event, context) => bridge.handleActionTerminal(event, context),
       "action.failed": (event, context) => bridge.handleActionTerminal(event, context),
@@ -3579,7 +3838,7 @@ function createEveInstrumentationProvider(options = {}) {
       "turn.failed": (event, context) => bridge.handleTurnTerminal(event, context),
       "turn.started": (event, context) => bridge.handleTurnStarted(event, context)
     },
-    flush: _chunkXLLGRXGRjs.flush,
+    flush: _chunkTWCDSYJNjs.flush,
     setup: options.setup
   };
 }
@@ -3591,10 +3850,10 @@ var EveProviderBridge = (_class2 = class {
   __init5() {this.activeActions = /* @__PURE__ */ new Map()}
   __init6() {this.activeModels = /* @__PURE__ */ new Map()}
   __init7() {this.modelsByAttempt = /* @__PURE__ */ new Map()}
-  __init8() {this.settledOperations = new (0, _chunkXLLGRXGRjs.LRUCache)({
+  __init8() {this.settledOperations = new (0, _chunkTWCDSYJNjs.LRUCache)({
     max: MAX_EVE_PROVIDER_CACHE_ENTRIES
   })}
-  __init9() {this.turns = new (0, _chunkXLLGRXGRjs.LRUCache)({
+  __init9() {this.turns = new (0, _chunkTWCDSYJNjs.LRUCache)({
     max: MAX_EVE_PROVIDER_CACHE_ENTRIES
   })}
   async handleTurnStarted(event, context) {
@@ -3621,7 +3880,7 @@ var EveProviderBridge = (_class2 = class {
           event.parentLineage.turnId
         );
         const parentTurn = this.turns.get(parentTurnKey);
-        rootSpanId = await _asyncNullishCoalesce(await _asyncOptionalChain([parentTurn, 'optionalAccess', async _116 => _116.rootSpanId]), async () => ( // Eve propagates the root session through every nested subagent. Use
+        rootSpanId = await _asyncNullishCoalesce(await _asyncOptionalChain([parentTurn, 'optionalAccess', async _122 => _122.rootSpanId]), async () => ( // Eve propagates the root session through every nested subagent. Use
         // it instead of the immediate parent session when no ancestor ran
         // in-process.
         (await generateEveIds(
@@ -3652,7 +3911,7 @@ var EveProviderBridge = (_class2 = class {
         },
         rootSpanId
       );
-      _optionalChain([span, 'optionalAccess', _117 => _117.log, 'call', _118 => _118({ metadata })]);
+      _optionalChain([span, 'optionalAccess', _123 => _123.log, 'call', _124 => _124({ metadata })]);
       this.turns.set(key, {
         rootSpanId,
         spanId
@@ -3669,7 +3928,7 @@ var EveProviderBridge = (_class2 = class {
       this.drainActionsForTurn(event.sessionId, event.turnId, error);
       const stored = storedSpan(context);
       if (stored && "exported" in stored) {
-        _chunkXLLGRXGRjs.updateSpan.call(void 0, {
+        _chunkTWCDSYJNjs.updateSpan.call(void 0, {
           exported: stored.exported,
           ...error !== void 0 ? { error } : {},
           metrics: { end: Date.now() / 1e3 }
@@ -3740,7 +3999,7 @@ var EveProviderBridge = (_class2 = class {
       } else {
         const stored = storedSpan(context);
         if (stored && "exported" in stored) {
-          _chunkXLLGRXGRjs.updateSpan.call(void 0, {
+          _chunkTWCDSYJNjs.updateSpan.call(void 0, {
             exported: stored.exported,
             ...event.type === "model.call.failed" ? event.error !== void 0 ? { error: event.error } : {} : { output: modelOutput(event) },
             metrics: {
@@ -3799,7 +4058,7 @@ var EveProviderBridge = (_class2 = class {
         return;
       }
       const stored = storedSpan(context);
-      if (_optionalChain([stored, 'optionalAccess', _119 => _119.skip])) {
+      if (_optionalChain([stored, 'optionalAccess', _125 => _125.skip])) {
         context.state.set(void 0);
         return;
       }
@@ -3822,7 +4081,7 @@ var EveProviderBridge = (_class2 = class {
       } else {
         const stored2 = storedSpan(context);
         if (stored2 && "exported" in stored2) {
-          _chunkXLLGRXGRjs.updateSpan.call(void 0, {
+          _chunkTWCDSYJNjs.updateSpan.call(void 0, {
             exported: stored2.exported,
             ...event.type === "action.failed" ? {
               error: _nullishCoalesce(event.error, () => ( new Error(_nullishCoalesce(event.errorCode, () => ( `Eve action ${event.outcome}`)))))
@@ -3873,10 +4132,10 @@ var EveProviderBridge = (_class2 = class {
     return { rootSpanId, spanId };
   }
   async startSpan(context, args, rootSpanId) {
-    const span = _chunkXLLGRXGRjs.withCurrent.call(void 0, 
-      _chunkXLLGRXGRjs.NOOP_SPAN,
-      () => _chunkXLLGRXGRjs._internalStartSpanWithInitialMerge.call(void 0, 
-        _chunk6Z5S7VOUjs.withSpanInstrumentationName.call(void 0, _nullishCoalesce(args, () => ( {})), _chunk6Z5S7VOUjs.INSTRUMENTATION_NAMES.EVE)
+    const span = _chunkTWCDSYJNjs.withCurrent.call(void 0, 
+      _chunkTWCDSYJNjs.NOOP_SPAN,
+      () => _chunkTWCDSYJNjs._internalStartSpanWithInitialMerge.call(void 0, 
+        _chunk2XDW3UCGjs.withSpanInstrumentationName.call(void 0, _nullishCoalesce(args, () => ( {})), _chunk2XDW3UCGjs.INSTRUMENTATION_NAMES.EVE)
       )
     );
     try {
@@ -3885,7 +4144,7 @@ var EveProviderBridge = (_class2 = class {
         ...rootSpanId ? { rootSpanId } : {}
       });
     } catch (error) {
-      _chunk6Z5S7VOUjs.debugLogger.warn("Error exporting Eve provider span:", error);
+      _chunk2XDW3UCGjs.debugLogger.warn("Error exporting Eve provider span:", error);
     }
     return span;
   }
@@ -3901,8 +4160,8 @@ var EveProviderBridge = (_class2 = class {
   forgetModel(attemptId, idempotencyKey) {
     this.activeModels.delete(idempotencyKey);
     const keys = this.modelsByAttempt.get(attemptId);
-    _optionalChain([keys, 'optionalAccess', _120 => _120.delete, 'call', _121 => _121(idempotencyKey)]);
-    if (_optionalChain([keys, 'optionalAccess', _122 => _122.size]) === 0) this.modelsByAttempt.delete(attemptId);
+    _optionalChain([keys, 'optionalAccess', _126 => _126.delete, 'call', _127 => _127(idempotencyKey)]);
+    if (_optionalChain([keys, 'optionalAccess', _128 => _128.size]) === 0) this.modelsByAttempt.delete(attemptId);
   }
   spanMetadata(sessionId) {
     return {
@@ -3914,13 +4173,13 @@ var EveProviderBridge = (_class2 = class {
     try {
       await fn();
     } catch (error) {
-      _chunk6Z5S7VOUjs.debugLogger.warn(`Error in Eve provider ${operation}:`, error);
+      _chunk2XDW3UCGjs.debugLogger.warn(`Error in Eve provider ${operation}:`, error);
     }
   }
 }, _class2);
 function storedSpan(context) {
   const value = context.state.get();
-  if (!_chunkXLLGRXGRjs.isObject.call(void 0, value)) return void 0;
+  if (!_chunkTWCDSYJNjs.isObject.call(void 0, value)) return void 0;
   if (value["skip"] === true) return { skip: true };
   return typeof value["exported"] === "string" ? {
     exported: value["exported"],
@@ -3965,10 +4224,10 @@ function usageMetrics(usage) {
   const promptTokens = nonNegativeNumber(usage.inputTokens);
   const completionTokens = nonNegativeNumber(usage.outputTokens);
   const cachedTokens = nonNegativeNumber(
-    _optionalChain([usage, 'access', _123 => _123.inputTokenDetails, 'optionalAccess', _124 => _124.cacheReadTokens])
+    _optionalChain([usage, 'access', _129 => _129.inputTokenDetails, 'optionalAccess', _130 => _130.cacheReadTokens])
   );
   const cacheCreationTokens = nonNegativeNumber(
-    _optionalChain([usage, 'access', _125 => _125.inputTokenDetails, 'optionalAccess', _126 => _126.cacheWriteTokens])
+    _optionalChain([usage, 'access', _131 => _131.inputTokenDetails, 'optionalAccess', _132 => _132.cacheWriteTokens])
   );
   return {
     ...promptTokens !== void 0 ? { prompt_tokens: promptTokens } : {},
@@ -3992,7 +4251,7 @@ function normalizeFinishReason2(value) {
 function safeJsonStringify(value) {
   try {
     return _nullishCoalesce(JSON.stringify(value), () => ( "null"));
-  } catch (e6) {
+  } catch (e8) {
     return "null";
   }
 }
@@ -4076,7 +4335,7 @@ function betaSessionEventsProxy(events) {
       if (prop === "stream") {
         return new TypedApplyProxy(target.stream, {
           apply(stream, thisArg, argArray) {
-            return _chunk6Z5S7VOUjs.anthropicChannels.betaSessionsEventsStream.tracePromise(
+            return _chunk2XDW3UCGjs.anthropicChannels.betaSessionsEventsStream.tracePromise(
               () => Reflect.apply(stream, thisArg, argArray),
               { arguments: argArray }
             );
@@ -4103,7 +4362,7 @@ function betaSessionThreadEventsProxy(events) {
       if (prop === "stream") {
         return new TypedApplyProxy(target.stream, {
           apply(stream, thisArg, argArray) {
-            return _chunk6Z5S7VOUjs.anthropicChannels.betaSessionsThreadsEventsStream.tracePromise(
+            return _chunk2XDW3UCGjs.anthropicChannels.betaSessionsThreadsEventsStream.tracePromise(
               () => Reflect.apply(stream, thisArg, argArray),
               { arguments: argArray }
             );
@@ -4118,7 +4377,7 @@ function messagesProxy(messages) {
   return new Proxy(messages, {
     get(target, prop, receiver) {
       if (prop === "create") {
-        return createProxy(target.create, _chunk6Z5S7VOUjs.anthropicChannels.messagesCreate);
+        return createProxy(target.create, _chunk2XDW3UCGjs.anthropicChannels.messagesCreate);
       }
       return Reflect.get(target, prop, receiver);
     }
@@ -4128,7 +4387,7 @@ function betaMessagesProxy(messages, anthropic) {
   return new Proxy(messages, {
     get(target, prop, receiver) {
       if (prop === "create") {
-        return createProxy(target.create, _chunk6Z5S7VOUjs.anthropicChannels.betaMessagesCreate);
+        return createProxy(target.create, _chunk2XDW3UCGjs.anthropicChannels.betaMessagesCreate);
       }
       if (prop === "toolRunner") {
         if (typeof target.toolRunner !== "function") {
@@ -4137,7 +4396,7 @@ function betaMessagesProxy(messages, anthropic) {
         return toolRunnerProxy(
           target.toolRunner,
           anthropic,
-          _chunk6Z5S7VOUjs.anthropicChannels.betaMessagesToolRunner
+          _chunk2XDW3UCGjs.anthropicChannels.betaMessagesToolRunner
         );
       }
       return Reflect.get(target, prop, receiver);
@@ -4194,11 +4453,11 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
         ...params,
         options: {
           ..._nullishCoalesce(params.options, () => ( {})),
-          [_chunkXLLGRXGRjs.CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION]: true
+          [_chunkTWCDSYJNjs.CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION]: true
         }
       };
       const invocationTarget = thisArg === proxy || thisArg === void 0 ? _nullishCoalesce(defaultThis, () => ( thisArg)) : thisArg;
-      return _chunk6Z5S7VOUjs.claudeAgentSDKChannels.query.invoke(
+      return _chunk2XDW3UCGjs.claudeAgentSDKChannels.query.invoke(
         target,
         invocationTarget,
         [wrappedParams],
@@ -4226,7 +4485,7 @@ function wrapClaudeAgentTool(toolFn, localToolMetadataByTool, defaultThis) {
       }
       const localToolMetadata = { toolName };
       const originalHandler = wrappedArgs[handlerIndex];
-      wrappedArgs[handlerIndex] = _chunkXLLGRXGRjs.wrapLocalClaudeToolHandler.call(void 0, 
+      wrappedArgs[handlerIndex] = _chunkTWCDSYJNjs.wrapLocalClaudeToolHandler.call(void 0, 
         originalHandler,
         () => localToolMetadata
       );
@@ -4244,8 +4503,8 @@ function wrapCreateSdkMcpServer(createSdkMcpServerFn, localToolMetadataByTool, d
     apply(target, thisArg, argArray) {
       const invocationTarget = thisArg === proxy || thisArg === void 0 ? _nullishCoalesce(defaultThis, () => ( thisArg)) : thisArg;
       const config = argArray[0];
-      const serverName = _optionalChain([config, 'optionalAccess', _127 => _127.name]);
-      if (typeof serverName === "string" && Array.isArray(_optionalChain([config, 'optionalAccess', _128 => _128.tools]))) {
+      const serverName = _optionalChain([config, 'optionalAccess', _133 => _133.name]);
+      if (typeof serverName === "string" && Array.isArray(_optionalChain([config, 'optionalAccess', _134 => _134.tools]))) {
         for (const tool of config.tools) {
           if (!tool || typeof tool !== "object") {
             continue;
@@ -4333,7 +4592,7 @@ function patchThinkClass(Think) {
     ...descriptor,
     value: function wrappedCloudflareThinkRunInferenceLoop(input) {
       const args = [input];
-      return _chunk6Z5S7VOUjs.cloudflareThinkChannels.runInferenceLoop.tracePromise(
+      return _chunk2XDW3UCGjs.cloudflareThinkChannels.runInferenceLoop.tracePromise(
         () => Reflect.apply(original, this, args),
         {
           arguments: args,
@@ -4385,7 +4644,7 @@ function isModuleNamespace2(obj) {
   if (!obj || typeof obj !== "object") {
     return false;
   }
-  if (_optionalChain([obj, 'access', _129 => _129.constructor, 'optionalAccess', _130 => _130.name]) === "Module") {
+  if (_optionalChain([obj, 'access', _135 => _135.constructor, 'optionalAccess', _136 => _136.name]) === "Module") {
     return true;
   }
   const keys = Object.keys(obj);
@@ -4455,7 +4714,7 @@ function wrapCodexThread(thread) {
       if (prop === "run" && typeof value === "function") {
         return function(input, turnOptions) {
           const args = [input, turnOptions];
-          return _chunk6Z5S7VOUjs.openAICodexChannels.run.tracePromise(
+          return _chunk2XDW3UCGjs.openAICodexChannels.run.tracePromise(
             () => Reflect.apply(value, target, args),
             {
               arguments: args,
@@ -4468,7 +4727,7 @@ function wrapCodexThread(thread) {
       if (prop === "runStreamed" && typeof value === "function") {
         return function(input, turnOptions) {
           const args = [input, turnOptions];
-          return _chunk6Z5S7VOUjs.openAICodexChannels.runStreamed.tracePromise(
+          return _chunk2XDW3UCGjs.openAICodexChannels.runStreamed.tracePromise(
             () => Reflect.apply(value, target, args),
             {
               arguments: args,
@@ -4515,7 +4774,7 @@ function isModuleNamespace3(obj) {
   if (!obj || typeof obj !== "object") {
     return false;
   }
-  if (_optionalChain([obj, 'access', _131 => _131.constructor, 'optionalAccess', _132 => _132.name]) === "Module") {
+  if (_optionalChain([obj, 'access', _137 => _137.constructor, 'optionalAccess', _138 => _138.name]) === "Module") {
     return true;
   }
   const keys = Object.keys(obj);
@@ -4536,7 +4795,7 @@ function wrapCursorAgentClass(Agent) {
       if (prop === "create" && typeof value === "function") {
         const wrapped = async function(options) {
           const args = [options];
-          return _chunk6Z5S7VOUjs.cursorSDKChannels.create.tracePromise(
+          return _chunk2XDW3UCGjs.cursorSDKChannels.create.tracePromise(
             async () => wrapCursorAgent(await Reflect.apply(value, target, args)),
             { arguments: args }
           );
@@ -4547,7 +4806,7 @@ function wrapCursorAgentClass(Agent) {
       if (prop === "resume" && typeof value === "function") {
         const wrapped = async function(agentId, options) {
           const args = [agentId, options];
-          return _chunk6Z5S7VOUjs.cursorSDKChannels.resume.tracePromise(
+          return _chunk2XDW3UCGjs.cursorSDKChannels.resume.tracePromise(
             async () => wrapCursorAgent(await Reflect.apply(value, target, args)),
             { arguments: args }
           );
@@ -4558,7 +4817,7 @@ function wrapCursorAgentClass(Agent) {
       if (prop === "prompt" && typeof value === "function") {
         const wrapped = async function(message, options) {
           const args = [message, options];
-          return _chunk6Z5S7VOUjs.cursorSDKChannels.prompt.tracePromise(
+          return _chunk2XDW3UCGjs.cursorSDKChannels.prompt.tracePromise(
             () => Reflect.apply(value, target, args),
             { arguments: args }
           );
@@ -4591,7 +4850,7 @@ function wrapCursorAgent(agent) {
       if (prop === "send" && typeof value === "function") {
         return function(message, options) {
           const args = [message, options];
-          return _chunk6Z5S7VOUjs.cursorSDKChannels.send.tracePromise(
+          return _chunk2XDW3UCGjs.cursorSDKChannels.send.tracePromise(
             () => Reflect.apply(value, target, args),
             {
               agent: target,
@@ -4641,7 +4900,7 @@ function patchAgentSessionClass(AgentSession) {
     ...descriptor,
     value: function wrappedPiCodingAgentPrompt(text, options) {
       const args = [text, options];
-      return _chunk6Z5S7VOUjs.piCodingAgentChannels.prompt.invoke(originalPrompt, this, args, {
+      return _chunk2XDW3UCGjs.piCodingAgentChannels.prompt.invoke(originalPrompt, this, args, {
         session: this
       });
     }
@@ -4687,7 +4946,7 @@ function wrapCloudflareAgent(Agent) {
       if (ownValue(options, "detached")) {
         return Reflect.apply(originalRunAgentTool, this, args);
       }
-      return _chunk6Z5S7VOUjs.cloudflareAgentsChannels.runAgentTool.tracePromise(
+      return _chunk2XDW3UCGjs.cloudflareAgentsChannels.runAgentTool.tracePromise(
         () => Reflect.apply(originalRunAgentTool, this, args),
         { arguments: args, self: this }
       );
@@ -4711,7 +4970,7 @@ function isObjectLike(value) {
   return typeof value === "object" && value !== null || typeof value === "function";
 }
 function warnUnsupportedAgent() {
-  _chunk6Z5S7VOUjs.debugLogger.warn("Unsupported Cloudflare Agents Agent class. Not wrapping.");
+  _chunk2XDW3UCGjs.debugLogger.warn("Unsupported Cloudflare Agents Agent class. Not wrapping.");
 }
 
 // src/wrappers/strands-agent-sdk.ts
@@ -4755,7 +5014,7 @@ function isModuleNamespace4(obj) {
   if (!obj || typeof obj !== "object") {
     return false;
   }
-  if (_optionalChain([obj, 'access', _133 => _133.constructor, 'optionalAccess', _134 => _134.name]) === "Module") {
+  if (_optionalChain([obj, 'access', _139 => _139.constructor, 'optionalAccess', _140 => _140.name]) === "Module") {
     return true;
   }
   const keys = Object.keys(obj);
@@ -4817,7 +5076,7 @@ function wrapAgentInstance(agent) {
       if (prop === "stream" && typeof value === "function") {
         return function(args, options) {
           const callArgs = [args, options];
-          return _chunk6Z5S7VOUjs.strandsAgentSDKChannels.agentStream.invoke(
+          return _chunk2XDW3UCGjs.strandsAgentSDKChannels.agentStream.invoke(
             value,
             target,
             callArgs,
@@ -4851,7 +5110,7 @@ function wrapMultiAgentInstance(orchestrator, kind) {
       if (prop === "stream" && typeof value === "function") {
         return function(input, options) {
           const callArgs = [input, options];
-          const channel = kind === "graph" ? _chunk6Z5S7VOUjs.strandsAgentSDKChannels.graphStream : _chunk6Z5S7VOUjs.strandsAgentSDKChannels.swarmStream;
+          const channel = kind === "graph" ? _chunk2XDW3UCGjs.strandsAgentSDKChannels.graphStream : _chunk2XDW3UCGjs.strandsAgentSDKChannels.swarmStream;
           return channel.invoke(
             value,
             target,
@@ -4891,11 +5150,11 @@ function wrapCloudflareAIChat(module) {
   try {
     AIChatAgent = Reflect.get(candidate, "AIChatAgent");
   } catch (error) {
-    _chunk6Z5S7VOUjs.debugLogger.debug("Failed to inspect @cloudflare/ai-chat module:", error);
+    _chunk2XDW3UCGjs.debugLogger.debug("Failed to inspect @cloudflare/ai-chat module:", error);
     return module;
   }
   if (typeof AIChatAgent !== "function") {
-    _chunk6Z5S7VOUjs.debugLogger.warn(
+    _chunk2XDW3UCGjs.debugLogger.warn(
       "Unsupported @cloudflare/ai-chat module. AIChatAgent was not found; not wrapping."
     );
     return module;
@@ -4929,7 +5188,7 @@ function wrapAIChatAgentClass(AgentClass) {
         args,
         newTarget
       );
-      return _chunkXLLGRXGRjs.instrumentCloudflareAIChatAgent.call(void 0, instance);
+      return _chunkTWCDSYJNjs.instrumentCloudflareAIChatAgent.call(void 0, instance);
     }
   });
   wrappedClasses.set(AgentClass, wrapped);
@@ -4950,7 +5209,7 @@ function isModuleNamespace5(value) {
     }
     const descriptor = Object.getOwnPropertyDescriptor(value, keys[0]);
     return descriptor ? !descriptor.configurable && !descriptor.writable : false;
-  } catch (e7) {
+  } catch (e9) {
     return false;
   }
 }
@@ -5001,7 +5260,7 @@ function wrapGoogleGenAIInstance(instance) {
       }
       if (prop === "interactions") {
         const interactions = Reflect.get(target, prop, receiver);
-        if (!_chunkXLLGRXGRjs.isObject.call(void 0, interactions) || typeof interactions.create !== "function") {
+        if (!_chunkTWCDSYJNjs.isObject.call(void 0, interactions) || typeof interactions.create !== "function") {
           return interactions;
         }
         if (interactions !== originalInteractions) {
@@ -5015,7 +5274,7 @@ function wrapGoogleGenAIInstance(instance) {
   });
 }
 function patchGoogleGenAIChats(instance, wrappedModels) {
-  if (!_chunkXLLGRXGRjs.isObject.call(void 0, instance.chats) || !("modelsModule" in instance.chats)) {
+  if (!_chunkTWCDSYJNjs.isObject.call(void 0, instance.chats) || !("modelsModule" in instance.chats)) {
     return;
   }
   Reflect.set(instance.chats, "modelsModule", wrappedModels);
@@ -5048,7 +5307,7 @@ function wrapInteractions(interactions) {
 }
 function wrapGenerateContent(original) {
   return function(params) {
-    return _chunk6Z5S7VOUjs.googleGenAIChannels.generateContent.tracePromise(
+    return _chunk2XDW3UCGjs.googleGenAIChannels.generateContent.tracePromise(
       () => original(params),
       { arguments: [params] }
     );
@@ -5056,7 +5315,7 @@ function wrapGenerateContent(original) {
 }
 function wrapGenerateContentStream(original) {
   return function(params) {
-    return _chunk6Z5S7VOUjs.googleGenAIChannels.generateContentStream.tracePromise(
+    return _chunk2XDW3UCGjs.googleGenAIChannels.generateContentStream.tracePromise(
       () => original(params),
       { arguments: [params] }
     );
@@ -5064,7 +5323,7 @@ function wrapGenerateContentStream(original) {
 }
 function wrapEmbedContent(original) {
   return function(params) {
-    return _chunk6Z5S7VOUjs.googleGenAIChannels.embedContent.tracePromise(
+    return _chunk2XDW3UCGjs.googleGenAIChannels.embedContent.tracePromise(
       () => original(params),
       { arguments: [params] }
     );
@@ -5076,7 +5335,7 @@ function wrapInteractionCreate(original) {
       return options === void 0 ? original(params) : original(params, options);
     }
     const traceContext = options === void 0 ? { arguments: [params] } : { arguments: [params, options] };
-    return _chunk6Z5S7VOUjs.googleGenAIChannels.interactionsCreate.tracePromise(
+    return _chunk2XDW3UCGjs.googleGenAIChannels.interactionsCreate.tracePromise(
       () => options === void 0 ? original(params) : original(params, options),
       traceContext
     );
@@ -5137,7 +5396,7 @@ function wrapRunnerInstance(runner) {
 function wrapRunnerRunAsync(runner) {
   const original = runner.runAsync.bind(runner);
   return function(params) {
-    return _chunk6Z5S7VOUjs.googleADKChannels.runnerRunAsync.traceSync(() => original(params), {
+    return _chunk2XDW3UCGjs.googleADKChannels.runnerRunAsync.traceSync(() => original(params), {
       arguments: [params],
       self: runner
     });
@@ -5164,7 +5423,7 @@ function wrapAgentInstance2(agent) {
 function wrapAgentRunAsync(agent) {
   const original = agent.runAsync.bind(agent);
   return function(parentContext) {
-    return _chunk6Z5S7VOUjs.googleADKChannels.agentRunAsync.traceSync(
+    return _chunk2XDW3UCGjs.googleADKChannels.agentRunAsync.traceSync(
       () => original(parentContext),
       { arguments: [parentContext], self: agent }
     );
@@ -5191,7 +5450,7 @@ function wrapToolInstance(tool) {
 function wrapToolRunAsync(tool) {
   const original = tool.runAsync.bind(tool);
   return function(req) {
-    return _chunk6Z5S7VOUjs.googleADKChannels.toolRunAsync.tracePromise(() => original(req), {
+    return _chunk2XDW3UCGjs.googleADKChannels.toolRunAsync.tracePromise(() => original(req), {
       arguments: [req],
       self: tool
     });
@@ -5303,7 +5562,7 @@ function patchGenkitRegistryLookup(registry) {
     Object.defineProperty(registry, PATCHED_GENKIT_REGISTRY, {
       value: true
     });
-  } catch (e8) {
+  } catch (e10) {
   }
 }
 function patchGenkitRegistryConstructor(registry) {
@@ -5334,31 +5593,31 @@ function patchGenkitRegistryConstructor(registry) {
     Object.defineProperty(constructor, PATCHED_GENKIT_REGISTRY_CONSTRUCTOR, {
       value: true
     });
-  } catch (e9) {
+  } catch (e11) {
   }
 }
 function wrapGenerate(generate) {
-  return (input) => _chunk6Z5S7VOUjs.genkitChannels.generate.tracePromise(() => generate(input), {
+  return (input) => _chunk2XDW3UCGjs.genkitChannels.generate.tracePromise(() => generate(input), {
     arguments: [input]
   });
 }
 function wrapGenerateStream(generateStream) {
-  return (input) => _chunk6Z5S7VOUjs.genkitChannels.generateStream.traceSync(() => generateStream(input), {
+  return (input) => _chunk2XDW3UCGjs.genkitChannels.generateStream.traceSync(() => generateStream(input), {
     arguments: [input]
   });
 }
 function wrapEmbed2(embed) {
-  return (params) => _chunk6Z5S7VOUjs.genkitChannels.embed.tracePromise(() => embed(params), {
+  return (params) => _chunk2XDW3UCGjs.genkitChannels.embed.tracePromise(() => embed(params), {
     arguments: [params]
   });
 }
 function wrapEmbedMany2(embedMany) {
-  return (params) => _chunk6Z5S7VOUjs.genkitChannels.embedMany.tracePromise(() => embedMany(params), {
+  return (params) => _chunk2XDW3UCGjs.genkitChannels.embedMany.tracePromise(() => embedMany(params), {
     arguments: [params]
   });
 }
 function wrapRun(run) {
-  return (name, inputOrFn, maybeFn) => _chunk6Z5S7VOUjs.genkitChannels.actionRun.tracePromise(() => run(name, inputOrFn, maybeFn), {
+  return (name, inputOrFn, maybeFn) => _chunk2XDW3UCGjs.genkitChannels.actionRun.tracePromise(() => run(name, inputOrFn, maybeFn), {
     arguments: [name, inputOrFn, maybeFn]
   });
 }
@@ -5397,13 +5656,13 @@ function isGenkitAction(value) {
   return typeof value === "function" && "__action" in value;
 }
 function traceActionRun(action, run) {
-  return (input, options) => _chunk6Z5S7VOUjs.genkitChannels.actionRun.tracePromise(() => run(input, options), {
+  return (input, options) => _chunk2XDW3UCGjs.genkitChannels.actionRun.tracePromise(() => run(input, options), {
     arguments: [input, options],
     self: action
   });
 }
 function traceActionStream(action, stream) {
-  return (input, options) => _chunk6Z5S7VOUjs.genkitChannels.actionStream.traceSync(() => stream(input, options), {
+  return (input, options) => _chunk2XDW3UCGjs.genkitChannels.actionStream.traceSync(() => stream(input, options), {
     arguments: [input, options],
     self: action
   });
@@ -5449,10 +5708,10 @@ function isHuggingFaceConstructorKey(value) {
   return HUGGINGFACE_CONSTRUCTOR_KEY_SET.has(value);
 }
 function hasFunction2(value, methodName) {
-  return _chunkXLLGRXGRjs.isObject.call(void 0, value) && methodName in value && typeof value[methodName] === "function";
+  return _chunkTWCDSYJNjs.isObject.call(void 0, value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedHuggingFaceModule(value) {
-  if (!_chunkXLLGRXGRjs.isObject.call(void 0, value)) {
+  if (!_chunkTWCDSYJNjs.isObject.call(void 0, value)) {
     return false;
   }
   return HUGGINGFACE_CONSTRUCTOR_KEYS.some(
@@ -5560,14 +5819,14 @@ function wrapChatCompletion2(original, endpointUrl) {
     const context = {
       arguments: [traceParams]
     };
-    return _chunk6Z5S7VOUjs.huggingFaceChannels.chatCompletion.tracePromise(
+    return _chunk2XDW3UCGjs.huggingFaceChannels.chatCompletion.tracePromise(
       () => original(params, options),
       context
     );
   };
 }
 function wrapChatCompletionStream(original, endpointUrl) {
-  return (params, options) => _chunk6Z5S7VOUjs.huggingFaceChannels.chatCompletionStream.traceSync(
+  return (params, options) => _chunk2XDW3UCGjs.huggingFaceChannels.chatCompletionStream.traceSync(
     () => original(params, options),
     {
       arguments: [withEndpointUrl(params, endpointUrl)]
@@ -5580,14 +5839,14 @@ function wrapTextGeneration(original, endpointUrl) {
     const context = {
       arguments: [traceParams]
     };
-    return _chunk6Z5S7VOUjs.huggingFaceChannels.textGeneration.tracePromise(
+    return _chunk2XDW3UCGjs.huggingFaceChannels.textGeneration.tracePromise(
       () => original(params, options),
       context
     );
   };
 }
 function wrapTextGenerationStream(original, endpointUrl) {
-  return (params, options) => _chunk6Z5S7VOUjs.huggingFaceChannels.textGenerationStream.traceSync(
+  return (params, options) => _chunk2XDW3UCGjs.huggingFaceChannels.textGenerationStream.traceSync(
     () => original(params, options),
     {
       arguments: [withEndpointUrl(params, endpointUrl)]
@@ -5600,7 +5859,7 @@ function wrapFeatureExtraction(original, endpointUrl) {
     const context = {
       arguments: [traceParams]
     };
-    return _chunk6Z5S7VOUjs.huggingFaceChannels.featureExtraction.tracePromise(
+    return _chunk2XDW3UCGjs.huggingFaceChannels.featureExtraction.tracePromise(
       () => original(params, options),
       context
     );
@@ -5617,8 +5876,8 @@ var PIPELINE_CONSTRUCTOR_KEYS = /* @__PURE__ */ new Set([
 ]);
 var wrappedValues = /* @__PURE__ */ new WeakMap();
 function wrapHuggingFaceTransformers(transformers) {
-  const pipelineTask = _optionalChain([transformers, 'optionalAccess', _135 => _135.task]);
-  if (typeof transformers === "function" && _chunk6Z5S7VOUjs.isSupportedHuggingFaceTransformersTask.call(void 0, pipelineTask)) {
+  const pipelineTask = _optionalChain([transformers, 'optionalAccess', _141 => _141.task]);
+  if (typeof transformers === "function" && _chunk2XDW3UCGjs.isSupportedHuggingFaceTransformersTask.call(void 0, pipelineTask)) {
     return wrapPipeline(transformers);
   }
   if (!isSupportedModule(transformers)) {
@@ -5670,8 +5929,8 @@ function wrapPipelineFactory(factory) {
     const context = {
       arguments: args
     };
-    return _chunk6Z5S7VOUjs.huggingFaceTransformersChannels.pipeline.tracePromise(() => Reflect.apply(factory, this, args), context).then((pipeline) => {
-      if (_chunk6Z5S7VOUjs.isSupportedHuggingFaceTransformersTask.call(void 0, _nullishCoalesce(pipeline.task, () => ( task)))) {
+    return _chunk2XDW3UCGjs.huggingFaceTransformersChannels.pipeline.tracePromise(() => Reflect.apply(factory, this, args), context).then((pipeline) => {
+      if (_chunk2XDW3UCGjs.isSupportedHuggingFaceTransformersTask.call(void 0, _nullishCoalesce(pipeline.task, () => ( task)))) {
         return wrapPipeline(pipeline);
       }
       return pipeline;
@@ -5689,7 +5948,7 @@ function wrapPipelineConstructor(constructor) {
   const proxy = new Proxy(constructor, {
     construct(target, args, newTarget) {
       const pipeline = Reflect.construct(target, args, newTarget);
-      if (_chunk6Z5S7VOUjs.isSupportedHuggingFaceTransformersTask.call(void 0, pipeline.task)) {
+      if (_chunk2XDW3UCGjs.isSupportedHuggingFaceTransformersTask.call(void 0, pipeline.task)) {
         return wrapPipeline(pipeline);
       }
       return pipeline;
@@ -5710,7 +5969,7 @@ function wrapPipeline(pipeline) {
         arguments: args,
         self: target
       };
-      return _chunk6Z5S7VOUjs.huggingFaceTransformersChannels.pipelineCall.tracePromise(
+      return _chunk2XDW3UCGjs.huggingFaceTransformersChannels.pipelineCall.tracePromise(
         () => Reflect.apply(target, thisArg, args),
         context
       );
@@ -5761,7 +6020,7 @@ function wrapCallModel(callModelFn, defaultThis) {
       const request = cloneCallModelRequest(argArray[0]);
       const options = argArray[1];
       const invocationTarget = thisArg === void 0 ? _nullishCoalesce(defaultThis, () => ( thisArg)) : thisArg;
-      return _chunk6Z5S7VOUjs.openRouterAgentChannels.callModel.traceSync(
+      return _chunk2XDW3UCGjs.openRouterAgentChannels.callModel.traceSync(
         () => Reflect.apply(target, invocationTarget, [request, options]),
         {
           arguments: [request]
@@ -5857,24 +6116,24 @@ function rerankProxy(rerank) {
   });
 }
 function wrapChatSend(send) {
-  return (request, options) => _chunk6Z5S7VOUjs.openRouterChannels.chatSend.tracePromise(() => send(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.openRouterChannels.chatSend.tracePromise(() => send(request, options), {
     arguments: [request]
   });
 }
 function wrapEmbeddingsGenerate(generate) {
-  return (request, options) => _chunk6Z5S7VOUjs.openRouterChannels.embeddingsGenerate.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.openRouterChannels.embeddingsGenerate.tracePromise(
     () => generate(request, options),
     { arguments: [request] }
   );
 }
 function wrapResponsesSend(send) {
-  return (request, options) => _chunk6Z5S7VOUjs.openRouterChannels.betaResponsesSend.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.openRouterChannels.betaResponsesSend.tracePromise(
     () => send(request, options),
     { arguments: [request] }
   );
 }
 function wrapRerank2(rerank) {
-  return (request, options) => _chunk6Z5S7VOUjs.openRouterChannels.rerankRerank.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.openRouterChannels.rerankRerank.tracePromise(
     () => rerank(request, options),
     { arguments: [request] }
   );
@@ -5882,7 +6141,7 @@ function wrapRerank2(rerank) {
 function wrapCallModel2(callModel) {
   return (request, options) => {
     const tracedRequest = { ...request };
-    return _chunk6Z5S7VOUjs.openRouterChannels.callModel.traceSync(
+    return _chunk2XDW3UCGjs.openRouterChannels.callModel.traceSync(
       () => callModel(tracedRequest, options),
       {
         arguments: [tracedRequest]
@@ -6015,7 +6274,7 @@ function classifiersProxy(classifiers) {
   });
 }
 function wrapChatComplete(complete) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.chatComplete.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.chatComplete.tracePromise(
     () => complete(request, options),
     {
       arguments: [request]
@@ -6023,52 +6282,52 @@ function wrapChatComplete(complete) {
   );
 }
 function wrapChatStream(stream) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.chatStream.tracePromise(() => stream(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.chatStream.tracePromise(() => stream(request, options), {
     arguments: [request]
   });
 }
 function wrapEmbeddingsCreate(create) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.embeddingsCreate.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.embeddingsCreate.tracePromise(
     () => create(request, options),
     { arguments: [request] }
   );
 }
 function wrapClassifiersModerate(moderate) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.classifiersModerate.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.classifiersModerate.tracePromise(
     () => moderate(request, options),
     { arguments: [request] }
   );
 }
 function wrapClassifiersModerateChat(moderateChat) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.classifiersModerateChat.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.classifiersModerateChat.tracePromise(
     () => moderateChat(request, options),
     { arguments: [request] }
   );
 }
 function wrapClassifiersClassify(classify) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.classifiersClassify.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.classifiersClassify.tracePromise(
     () => classify(request, options),
     { arguments: [request] }
   );
 }
 function wrapClassifiersClassifyChat(classifyChat) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.classifiersClassifyChat.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.classifiersClassifyChat.tracePromise(
     () => classifyChat(request, options),
     { arguments: [request] }
   );
 }
 function wrapFimComplete(complete) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.fimComplete.tracePromise(() => complete(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.fimComplete.tracePromise(() => complete(request, options), {
     arguments: [request]
   });
 }
 function wrapFimStream(stream) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.fimStream.tracePromise(() => stream(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.fimStream.tracePromise(() => stream(request, options), {
     arguments: [request]
   });
 }
 function wrapAgentsComplete(complete) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.agentsComplete.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.agentsComplete.tracePromise(
     () => complete(request, options),
     {
       arguments: [request]
@@ -6076,7 +6335,7 @@ function wrapAgentsComplete(complete) {
   );
 }
 function wrapAgentsStream(stream) {
-  return (request, options) => _chunk6Z5S7VOUjs.mistralChannels.agentsStream.tracePromise(() => stream(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.mistralChannels.agentsStream.tracePromise(() => stream(request, options), {
     arguments: [request]
   });
 }
@@ -6086,12 +6345,12 @@ function wrapOllama(ollama) {
   if (isSupportedOllamaClient(ollama)) {
     return ollamaProxy(ollama);
   }
-  _chunk6Z5S7VOUjs.debugLogger.warn("Unsupported Ollama library. Not wrapping.");
+  _chunk2XDW3UCGjs.debugLogger.warn("Unsupported Ollama library. Not wrapping.");
   return ollama;
 }
 var ollamaProxyCache = /* @__PURE__ */ new WeakMap();
 function isSupportedOllamaClient(value) {
-  return _chunkXLLGRXGRjs.isObject.call(void 0, value) && ["chat", "generate", "embed"].some(
+  return _chunkTWCDSYJNjs.isObject.call(void 0, value) && ["chat", "generate", "embed"].some(
     (name) => typeof value[name] === "function"
   );
 }
@@ -6143,17 +6402,17 @@ function ollamaProxy(ollama) {
   return proxy;
 }
 function wrapChat(chat) {
-  return (request) => _chunk6Z5S7VOUjs.ollamaChannels.chat.tracePromise(() => chat(request), {
+  return (request) => _chunk2XDW3UCGjs.ollamaChannels.chat.tracePromise(() => chat(request), {
     arguments: [request]
   });
 }
 function wrapGenerate2(generate) {
-  return (request) => _chunk6Z5S7VOUjs.ollamaChannels.generate.tracePromise(() => generate(request), {
+  return (request) => _chunk2XDW3UCGjs.ollamaChannels.generate.tracePromise(() => generate(request), {
     arguments: [request]
   });
 }
 function wrapEmbed3(embed) {
-  return (request) => _chunk6Z5S7VOUjs.ollamaChannels.embed.tracePromise(() => embed(request), {
+  return (request) => _chunk2XDW3UCGjs.ollamaChannels.embed.tracePromise(() => embed(request), {
     arguments: [request]
   });
 }
@@ -6206,22 +6465,22 @@ function cohereProxy(cohere) {
   return proxy;
 }
 function wrapChat2(chat) {
-  return (request, options) => _chunk6Z5S7VOUjs.cohereChannels.chat.tracePromise(() => chat(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.cohereChannels.chat.tracePromise(() => chat(request, options), {
     arguments: [request]
   });
 }
 function wrapChatStream2(chatStream) {
-  return (request, options) => _chunk6Z5S7VOUjs.cohereChannels.chatStream.tracePromise(() => chatStream(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.cohereChannels.chatStream.tracePromise(() => chatStream(request, options), {
     arguments: [request]
   });
 }
 function wrapEmbed4(embed) {
-  return (request, options) => _chunk6Z5S7VOUjs.cohereChannels.embed.tracePromise(() => embed(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.cohereChannels.embed.tracePromise(() => embed(request, options), {
     arguments: [request]
   });
 }
 function wrapRerank3(rerank) {
-  return (request, options) => _chunk6Z5S7VOUjs.cohereChannels.rerank.tracePromise(() => rerank(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.cohereChannels.rerank.tracePromise(() => rerank(request, options), {
     arguments: [request]
   });
 }
@@ -6259,7 +6518,7 @@ function voyageAIProxy(client) {
           if (typeof target.embed !== "function") {
             return target.embed;
           }
-          return (request, options) => _chunk6Z5S7VOUjs.voyageAIChannels.embed.invoke(
+          return (request, options) => _chunk2XDW3UCGjs.voyageAIChannels.embed.invoke(
             target.embed,
             target,
             [request, options],
@@ -6269,7 +6528,7 @@ function voyageAIProxy(client) {
           if (typeof target.multimodalEmbed !== "function") {
             return target.multimodalEmbed;
           }
-          return (request, options) => _chunk6Z5S7VOUjs.voyageAIChannels.multimodalEmbed.invoke(
+          return (request, options) => _chunk2XDW3UCGjs.voyageAIChannels.multimodalEmbed.invoke(
             target.multimodalEmbed,
             target,
             [request, options],
@@ -6279,7 +6538,7 @@ function voyageAIProxy(client) {
           if (typeof target.rerank !== "function") {
             return target.rerank;
           }
-          return (request, options) => _chunk6Z5S7VOUjs.voyageAIChannels.rerank.invoke(
+          return (request, options) => _chunk2XDW3UCGjs.voyageAIChannels.rerank.invoke(
             target.rerank,
             target,
             [request, options],
@@ -6289,7 +6548,7 @@ function voyageAIProxy(client) {
           if (typeof target.contextualizedEmbed !== "function") {
             return target.contextualizedEmbed;
           }
-          return (request, options) => _chunk6Z5S7VOUjs.voyageAIChannels.contextualizedEmbed.invoke(
+          return (request, options) => _chunk2XDW3UCGjs.voyageAIChannels.contextualizedEmbed.invoke(
             target.contextualizedEmbed,
             target,
             [request, options],
@@ -6329,7 +6588,7 @@ function isSupportedGroqClient(value) {
 }
 function groqProxy(groq) {
   const privateMethodWorkaroundCache = /* @__PURE__ */ new WeakMap();
-  const completionProxy = _optionalChain([groq, 'access', _136 => _136.chat, 'optionalAccess', _137 => _137.completions]) ? new Proxy(groq.chat.completions, {
+  const completionProxy = _optionalChain([groq, 'access', _142 => _142.chat, 'optionalAccess', _143 => _143.completions]) ? new Proxy(groq.chat.completions, {
     get(target, prop, receiver) {
       if (prop === "create") {
         return wrapChatCompletionsCreate(target.create.bind(target));
@@ -6381,13 +6640,13 @@ function groqProxy(groq) {
   return topLevelProxy;
 }
 function wrapChatCompletionsCreate(create) {
-  return (request, options) => _chunk6Z5S7VOUjs.groqChannels.chatCompletionsCreate.tracePromise(
+  return (request, options) => _chunk2XDW3UCGjs.groqChannels.chatCompletionsCreate.tracePromise(
     () => create(request, options),
     { arguments: [request] }
   );
 }
 function wrapEmbeddingsCreate2(create) {
-  return (request, options) => _chunk6Z5S7VOUjs.groqChannels.embeddingsCreate.tracePromise(() => create(request, options), {
+  return (request, options) => _chunk2XDW3UCGjs.groqChannels.embeddingsCreate.tracePromise(() => create(request, options), {
     arguments: [request]
   });
 }
@@ -6461,16 +6720,16 @@ function bedrockRuntimeProxy(client) {
 }
 function wrapSend(send) {
   return (command, optionsOrCb, cb) => {
-    if (_chunkXLLGRXGRjs.getBedrockRuntimeOperation.call(void 0, command) === void 0 || typeof optionsOrCb === "function" || typeof cb === "function") {
+    if (_chunkTWCDSYJNjs.getBedrockRuntimeOperation.call(void 0, command) === void 0 || typeof optionsOrCb === "function" || typeof cb === "function") {
       return send(command, optionsOrCb, cb);
     }
-    return _chunk6Z5S7VOUjs.bedrockRuntimeChannels.clientSend.tracePromise(
-      () => _chunkXLLGRXGRjs.runWithAutoInstrumentationSuppressed.call(void 0, 
+    return _chunk2XDW3UCGjs.bedrockRuntimeChannels.clientSend.tracePromise(
+      () => _chunkTWCDSYJNjs.runWithAutoInstrumentationSuppressed.call(void 0, 
         () => send(command, optionsOrCb)
       ),
       {
         arguments: [command, optionsOrCb],
-        span_info: _chunkXLLGRXGRjs.buildBedrockRuntimeSpanInfo.call(void 0, command)
+        span_info: _chunkTWCDSYJNjs.buildBedrockRuntimeSpanInfo.call(void 0, command)
       }
     );
   };
@@ -6519,13 +6778,13 @@ function copilotClientProxy(client) {
   return proxy;
 }
 function wrappedCreateSession(client) {
-  return (config) => _chunk6Z5S7VOUjs.gitHubCopilotChannels.createSession.tracePromise(
+  return (config) => _chunk2XDW3UCGjs.gitHubCopilotChannels.createSession.tracePromise(
     () => client.createSession(config),
     { arguments: [config] }
   );
 }
 function wrappedResumeSession(client) {
-  return (sessionId, config) => _chunk6Z5S7VOUjs.gitHubCopilotChannels.resumeSession.tracePromise(
+  return (sessionId, config) => _chunk2XDW3UCGjs.gitHubCopilotChannels.resumeSession.tracePromise(
     () => client.resumeSession(sessionId, config),
     { arguments: [sessionId, config] }
   );
@@ -6630,7 +6889,7 @@ function isModuleNamespace6(value) {
   if (!value || typeof value !== "object") {
     return false;
   }
-  if (_optionalChain([value, 'access', _138 => _138.constructor, 'optionalAccess', _139 => _139.name]) === "Module") {
+  if (_optionalChain([value, 'access', _144 => _144.constructor, 'optionalAccess', _145 => _145.name]) === "Module") {
     return true;
   }
   const firstKey = Object.keys(value)[0];
@@ -6654,7 +6913,7 @@ function wrapTraceable(traceable2) {
     apply(target, thisArg, argArray) {
       const [fn, rawConfig] = argArray;
       const config = rawConfig && typeof rawConfig === "object" ? rawConfig : void 0;
-      const originalOnEnd = _optionalChain([config, 'optionalAccess', _140 => _140.on_end]);
+      const originalOnEnd = _optionalChain([config, 'optionalAccess', _146 => _146.on_end]);
       const wrappedConfig = {
         ...config,
         on_end(runTree) {
@@ -6703,13 +6962,13 @@ function wrapRunTreeInstance(runTree) {
         wrapped = (...args) => wrapRunTreeInstance(Reflect.apply(value, target, args));
       } else if (prop === "postRun") {
         const method = value;
-        wrapped = (...args) => _chunk6Z5S7VOUjs.langSmithChannels.createRun.tracePromise(
+        wrapped = (...args) => _chunk2XDW3UCGjs.langSmithChannels.createRun.tracePromise(
           () => Reflect.apply(method, target, args),
           { arguments: [target] }
         );
       } else if (prop === "patchRun") {
         const method = value;
-        wrapped = (...args) => _chunk6Z5S7VOUjs.langSmithChannels.updateRun.tracePromise(
+        wrapped = (...args) => _chunk2XDW3UCGjs.langSmithChannels.updateRun.tracePromise(
           () => Reflect.apply(method, target, args),
           {
             arguments: [
@@ -6758,19 +7017,19 @@ function wrapClientInstance(client) {
       let wrapped;
       if (prop === "createRun") {
         const method = value;
-        wrapped = (...args) => _chunk6Z5S7VOUjs.langSmithChannels.createRun.tracePromise(
+        wrapped = (...args) => _chunk2XDW3UCGjs.langSmithChannels.createRun.tracePromise(
           () => Reflect.apply(method, target, args),
           { arguments: args }
         );
       } else if (prop === "updateRun") {
         const method = value;
-        wrapped = (...args) => _chunk6Z5S7VOUjs.langSmithChannels.updateRun.tracePromise(
+        wrapped = (...args) => _chunk2XDW3UCGjs.langSmithChannels.updateRun.tracePromise(
           () => Reflect.apply(method, target, args),
           { arguments: args }
         );
       } else if (prop === "batchIngestRuns") {
         const method = value;
-        wrapped = (...args) => _chunk6Z5S7VOUjs.langSmithChannels.batchIngestRuns.tracePromise(
+        wrapped = (...args) => _chunk2XDW3UCGjs.langSmithChannels.batchIngestRuns.tracePromise(
           () => Reflect.apply(method, target, args),
           { arguments: args }
         );
@@ -6786,13 +7045,13 @@ function publishRunUpdate(runTree) {
     return;
   }
   try {
-    void _chunk6Z5S7VOUjs.langSmithChannels.updateRun.tracePromise(() => Promise.resolve(void 0), {
+    void _chunk2XDW3UCGjs.langSmithChannels.updateRun.tracePromise(() => Promise.resolve(void 0), {
       arguments: [runTree.id, runTree]
     }).catch((error) => {
-      _chunk6Z5S7VOUjs.debugLogger.error("LangSmith traceable instrumentation failed:", error);
+      _chunk2XDW3UCGjs.debugLogger.error("LangSmith traceable instrumentation failed:", error);
     });
   } catch (error) {
-    _chunk6Z5S7VOUjs.debugLogger.error("LangSmith traceable instrumentation failed:", error);
+    _chunk2XDW3UCGjs.debugLogger.error("LangSmith traceable instrumentation failed:", error);
   }
 }
 
@@ -6804,7 +7063,7 @@ var VitestContextManager = class {
    */
   
   constructor() {
-    this.contextStorage = _chunk6Z5S7VOUjs.isomorph_default.newAsyncLocalStorage();
+    this.contextStorage = _chunk2XDW3UCGjs.isomorph_default.newAsyncLocalStorage();
   }
   getCurrentContext() {
     return this.contextStorage.getStore();
@@ -6842,7 +7101,7 @@ var FlushCoordinator = (_class3 = class {constructor() { _class3.prototype.__ini
     if (this.activeFlushes.has(experimentId)) {
       return this.activeFlushes.get(experimentId);
     }
-    const flushPromise = _chunkXLLGRXGRjs.summarizeAndFlush.call(void 0, context.experiment, {
+    const flushPromise = _chunkTWCDSYJNjs.summarizeAndFlush.call(void 0, context.experiment, {
       displaySummary: config.displaySummary
     });
     this.activeFlushes.set(experimentId, flushPromise);
@@ -6940,7 +7199,7 @@ async function runTracedEval(args) {
       }
       if (testError) {
         span.log({ scores: { pass: 0 } });
-        _chunkXLLGRXGRjs.logError.call(void 0, span, testError);
+        _chunkTWCDSYJNjs.logError.call(void 0, span, testError);
         throw testError;
       }
       span.log({
@@ -6973,7 +7232,7 @@ function wrapTest(originalTest, config) {
     const wrapped = function(name, configOrFn, maybeFn) {
       const isEnhanced = typeof configOrFn !== "function";
       const testConfig = isEnhanced ? configOrFn : void 0;
-      if (isEnhanced && _optionalChain([testConfig, 'optionalAccess', _141 => _141.data]) && Array.isArray(testConfig.data)) {
+      if (isEnhanced && _optionalChain([testConfig, 'optionalAccess', _147 => _147.data]) && Array.isArray(testConfig.data)) {
         const dataRecords = testConfig.data;
         const testFn2 = maybeFn;
         if (!testFn2) {
@@ -7011,7 +7270,7 @@ function wrapTest(originalTest, config) {
       const registrationContext = getExperimentContext();
       const testImplementation = async (vitestContext) => {
         const experimentContext = _nullishCoalesce(getExperimentContext(), () => ( registrationContext));
-        const experiment = _optionalChain([experimentContext, 'optionalAccess', _142 => _142.experiment]);
+        const experiment = _optionalChain([experimentContext, 'optionalAccess', _148 => _148.experiment]);
         if (config.onProgress) {
           config.onProgress({ type: "test_start", testName: name });
         }
@@ -7043,11 +7302,11 @@ function wrapTest(originalTest, config) {
           const result = await runTracedEval({
             experiment,
             spanName: name,
-            input: _optionalChain([testConfig, 'optionalAccess', _143 => _143.input]),
-            expected: _optionalChain([testConfig, 'optionalAccess', _144 => _144.expected]),
-            metadata: _optionalChain([testConfig, 'optionalAccess', _145 => _145.metadata]),
-            tags: _optionalChain([testConfig, 'optionalAccess', _146 => _146.tags]),
-            scorers: _optionalChain([testConfig, 'optionalAccess', _147 => _147.scorers]),
+            input: _optionalChain([testConfig, 'optionalAccess', _149 => _149.input]),
+            expected: _optionalChain([testConfig, 'optionalAccess', _150 => _150.expected]),
+            metadata: _optionalChain([testConfig, 'optionalAccess', _151 => _151.metadata]),
+            tags: _optionalChain([testConfig, 'optionalAccess', _152 => _152.tags]),
+            scorers: _optionalChain([testConfig, 'optionalAccess', _153 => _153.scorers]),
             fn: async () => {
               if (testConfig && maybeFn) {
                 const params = {
@@ -7114,10 +7373,10 @@ function wrapDescribe(originalDescribe, config, afterAll) {
         const getOrCreateContext = () => {
           if (!context) {
             const experimentName = `${suiteName}-${(/* @__PURE__ */ new Date()).toISOString()}`;
-            const experiment = config.projectId ? _chunkXLLGRXGRjs.initExperiment.call(void 0, {
+            const experiment = config.projectId ? _chunkTWCDSYJNjs.initExperiment.call(void 0, {
               projectId: config.projectId,
               experiment: experimentName
-            }) : _chunkXLLGRXGRjs.initExperiment.call(void 0, config.projectName || suiteName, {
+            }) : _chunkTWCDSYJNjs.initExperiment.call(void 0, config.projectName || suiteName, {
               experiment: experimentName
             });
             context = contextManager.createChildContext(void 0, experiment);
@@ -7161,8 +7420,8 @@ function wrapDescribe(originalDescribe, config, afterAll) {
               config.onProgress({
                 type: "suite_complete",
                 suiteName,
-                passed: _nullishCoalesce(_optionalChain([context, 'optionalAccess', _148 => _148.passed]), () => ( 0)),
-                failed: _nullishCoalesce(_optionalChain([context, 'optionalAccess', _149 => _149.failed]), () => ( 0))
+                passed: _nullishCoalesce(_optionalChain([context, 'optionalAccess', _154 => _154.passed]), () => ( 0)),
+                failed: _nullishCoalesce(_optionalChain([context, 'optionalAccess', _155 => _155.failed]), () => ( 0))
               });
             }
           });
@@ -7224,7 +7483,7 @@ function wrapExpect(originalExpect) {
       return originalExpect(value);
     }
     const assertion = originalExpect(value, message);
-    const span = _chunkXLLGRXGRjs.currentSpan.call(void 0, );
+    const span = _chunkTWCDSYJNjs.currentSpan.call(void 0, );
     if (!span) {
       return assertion;
     }
@@ -7236,16 +7495,16 @@ function wrapExpect(originalExpect) {
 
 // src/wrappers/shared/logging.ts
 function logOutputs(outputs) {
-  _chunkXLLGRXGRjs.currentSpan.call(void 0, ).log({ output: outputs });
+  _chunkTWCDSYJNjs.currentSpan.call(void 0, ).log({ output: outputs });
 }
 function logFeedback(feedback) {
-  _chunkXLLGRXGRjs.currentSpan.call(void 0, ).log({
+  _chunkTWCDSYJNjs.currentSpan.call(void 0, ).log({
     scores: { [feedback.name]: feedback.score },
     metadata: feedback.metadata
   });
 }
 function getCurrentSpan() {
-  return _chunkXLLGRXGRjs.currentSpan.call(void 0, );
+  return _chunkTWCDSYJNjs.currentSpan.call(void 0, );
 }
 
 // src/wrappers/vitest/index.ts
@@ -7293,8 +7552,8 @@ function wrapVitest(vitestMethods, config = {}) {
         );
         return;
       }
-      await _chunkXLLGRXGRjs.summarizeAndFlush.call(void 0, ctx.experiment, {
-        displaySummary: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _150 => _150.displaySummary]), () => ( config.displaySummary))
+      await _chunkTWCDSYJNjs.summarizeAndFlush.call(void 0, ctx.experiment, {
+        displaySummary: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _156 => _156.displaySummary]), () => ( config.displaySummary))
       });
     }
   };
@@ -7308,7 +7567,7 @@ function initNodeTestSuite(config) {
       return experiment;
     }
     const experimentName = config.experimentName || `${config.projectName}-${(/* @__PURE__ */ new Date()).toISOString()}`;
-    experiment = _chunkXLLGRXGRjs.initExperiment.call(void 0, config.projectName, {
+    experiment = _chunkTWCDSYJNjs.initExperiment.call(void 0, config.projectName, {
       experiment: experimentName
     });
     return experiment;
@@ -7357,7 +7616,7 @@ function initNodeTestSuite(config) {
     if (!experiment) {
       return;
     }
-    await _chunkXLLGRXGRjs.summarizeAndFlush.call(void 0, experiment, {
+    await _chunkTWCDSYJNjs.summarizeAndFlush.call(void 0, experiment, {
       displaySummary: config.displaySummary
     });
     experiment = void 0;
@@ -7374,7 +7633,7 @@ function initNodeTestSuite(config) {
 
 // src/graph-framework.ts
 var graph_framework_exports = {};
-_chunk6Z5S7VOUjs.__export.call(void 0, graph_framework_exports, {
+_chunk2XDW3UCGjs.__export.call(void 0, graph_framework_exports, {
   AggregatorNode: () => AggregatorNode,
   GateNode: () => GateNode,
   GraphBuilder: () => GraphBuilder,
@@ -7448,7 +7707,7 @@ var GraphBuilder = (_class4 = class {
     };
   }
   resolveNode(node) {
-    if (node instanceof _chunkXLLGRXGRjs.Prompt) {
+    if (node instanceof _chunkTWCDSYJNjs.Prompt) {
       const cached = this.nodeLikeNodes.get(node);
       if (cached) {
         return [cached, []];
@@ -7498,7 +7757,7 @@ var GraphBuilder = (_class4 = class {
   // }
   // Helper to generate node IDs
   generateId(name) {
-    const uuid = _chunkXLLGRXGRjs.newId.call(void 0, );
+    const uuid = _chunkTWCDSYJNjs.newId.call(void 0, );
     if (name) {
       return `${name}-${uuid.slice(0, 8)}`;
     } else {
@@ -7732,7 +7991,7 @@ function isAsync(fn) {
 function isAsyncGenerator(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable(obj) {
+function isAsyncIterable2(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -7904,7 +8163,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable(obj)) {
+    if (isAsyncIterable2(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -8698,7 +8957,7 @@ function waterfall(tasks, callback) {
 var waterfall$1 = awaitify(waterfall);
 
 // src/trace.ts
-var SpanFetcher = class _SpanFetcher extends _chunkXLLGRXGRjs.ObjectFetcher {
+var SpanFetcher = class _SpanFetcher extends _chunkTWCDSYJNjs.ObjectFetcher {
   constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false, brainstoreRealtime = true) {
     const filterExpr = _SpanFetcher.buildFilter(
       rootSpanId,
@@ -8835,7 +9094,7 @@ var CachedSpanFetcher = (_class6 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType, false);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _151 => _151.span_attributes, 'optionalAccess', _152 => _152.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _157 => _157.span_attributes, 'optionalAccess', _158 => _158.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -8918,11 +9177,11 @@ var LocalTrace = (_class7 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = includeScorers ? cachedSpans : cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _153 => _153.span_attributes, 'optionalAccess', _154 => _154.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _159 => _159.span_attributes, 'optionalAccess', _160 => _160.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _155 => _155.span_attributes, 'optionalAccess', _156 => _156.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _161 => _161.span_attributes, 'optionalAccess', _162 => _162.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -8947,7 +9206,7 @@ var LocalTrace = (_class7 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _157 => _157.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _163 => _163.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -8958,7 +9217,7 @@ var LocalTrace = (_class7 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _158 => _158.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _164 => _164.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -9015,20 +9274,20 @@ var promptContentsSchema = _v3.z.union([
     prompt: _v3.z.string()
   }),
   _v3.z.object({
-    messages: _v3.z.array(_chunkXLLGRXGRjs.ChatCompletionMessageParam)
+    messages: _v3.z.array(_chunkTWCDSYJNjs.ChatCompletionMessageParam)
   })
 ]);
 var promptDefinitionSchema = promptContentsSchema.and(
   _v3.z.object({
     model: _v3.z.string(),
-    params: _chunkXLLGRXGRjs.ModelParams.optional(),
+    params: _chunkTWCDSYJNjs.ModelParams.optional(),
     templateFormat: _v3.z.enum(["mustache", "nunjucks", "none"]).optional(),
     environments: _v3.z.array(_v3.z.string()).optional()
   })
 );
 var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
   _v3.z.object({
-    tools: _v3.z.array(_chunkXLLGRXGRjs.ToolFunctionDefinition).optional()
+    tools: _v3.z.array(_chunkTWCDSYJNjs.ToolFunctionDefinition).optional()
   })
 );
 function promptDefinitionToPromptData(promptDefinition, rawTools) {
@@ -9076,7 +9335,7 @@ async function validateParameters(parameters, parameterSchema) {
   if (resolvedSchema === void 0 || resolvedSchema === null) {
     return parameters;
   }
-  if (_chunkXLLGRXGRjs.RemoteEvalParameters.isParameters(resolvedSchema)) {
+  if (_chunkTWCDSYJNjs.RemoteEvalParameters.isParameters(resolvedSchema)) {
     const mergedParameters = parameters && Object.keys(parameters).length > 0 ? {
       ...resolvedSchema.data,
       ...parameters
@@ -9098,14 +9357,14 @@ function validateParametersWithZod(parameters, parameterSchema) {
       const value = parameters[name];
       try {
         if ("type" in schema && schema.type === "prompt") {
-          const promptData = value ? _chunkXLLGRXGRjs.PromptData.parse(value) : schema.default ? promptDefinitionToPromptData(
+          const promptData = value ? _chunkTWCDSYJNjs.PromptData.parse(value) : schema.default ? promptDefinitionToPromptData(
             schema.default,
             schema.default.tools
           ) : void 0;
           if (!promptData) {
             throw new Error(`Parameter '${name}' is required`);
           }
-          return [name, _chunkXLLGRXGRjs.Prompt.fromPromptData(name, promptData)];
+          return [name, _chunkTWCDSYJNjs.Prompt.fromPromptData(name, promptData)];
         } else if ("type" in schema && schema.type === "model") {
           const model = _nullishCoalesce(value, () => ( schema.default));
           if (model === void 0) {
@@ -9134,10 +9393,10 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
-    const errorMessages = _optionalChain([validate, 'access', _159 => _159.errors, 'optionalAccess', _160 => _160.map, 'call', _161 => _161((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _165 => _165.errors, 'optionalAccess', _166 => _166.map, 'call', _167 => _167((err) => {
       const path = err.instancePath || "root";
       return `${path}: ${err.message}`;
-    }), 'access', _162 => _162.join, 'call', _163 => _163(", ")]);
+    }), 'access', _168 => _168.join, 'call', _169 => _169(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return rehydrateRemoteParameters(parameters, schema);
@@ -9156,7 +9415,7 @@ function rehydrateRemoteParameters(parameters, schema) {
       if (Reflect.get(propertySchema, "x-bt-type") === "prompt") {
         return [
           name,
-          _chunkXLLGRXGRjs.Prompt.fromPromptData(name, _chunkXLLGRXGRjs.PromptData.parse(value))
+          _chunkTWCDSYJNjs.Prompt.fromPromptData(name, _chunkTWCDSYJNjs.PromptData.parse(value))
         ];
       }
       return [name, value];
@@ -9194,7 +9453,7 @@ var EvalResultWithSummary = class {
 async function getPersistedBaseExperimentId(experiment) {
   try {
     return await experiment._getBaseExperimentId();
-  } catch (e10) {
+  } catch (e12) {
     return void 0;
   }
 }
@@ -9206,7 +9465,7 @@ function makeEvalName(projectName, experimentName) {
   return out;
 }
 function initExperiment2(state, options = {}) {
-  return _chunkXLLGRXGRjs.init.call(void 0, {
+  return _chunkTWCDSYJNjs.init.call(void 0, {
     state,
     ...options,
     setCurrent: false
@@ -9217,7 +9476,7 @@ async function getExperimentParametersRef(parameters) {
     return void 0;
   }
   const resolvedParameters = parameters instanceof Promise ? await parameters : parameters;
-  if (!_chunkXLLGRXGRjs.RemoteEvalParameters.isParameters(resolvedParameters)) {
+  if (!_chunkTWCDSYJNjs.RemoteEvalParameters.isParameters(resolvedParameters)) {
     return void 0;
   }
   if (resolvedParameters.id === void 0) {
@@ -9244,7 +9503,7 @@ async function _internalInitEvaluatorExperiment(projectName, evaluator, data, op
     baseExperimentId: evaluator.baseExperimentId,
     gitMetadataSettings: evaluator.gitMetadataSettings,
     repoInfo: evaluator.repoInfo,
-    dataset: _chunkXLLGRXGRjs.Dataset.isDataset(data) ? data : void 0,
+    dataset: _chunkTWCDSYJNjs.Dataset.isDataset(data) ? data : void 0,
     parameters
   });
 }
@@ -9259,7 +9518,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable2(value) {
+function isAsyncIterable3(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -9280,7 +9539,7 @@ async function _internalResolveEvaluatorData(evaluator, experiment) {
       );
     }
     let name = dataResult.name;
-    if (_chunkXLLGRXGRjs.isEmpty.call(void 0, name)) {
+    if (_chunkTWCDSYJNjs.isEmpty.call(void 0, name)) {
       const baseExperiment = await experiment.fetchBaseExperiment();
       if (!baseExperiment) {
         throw new Error("BaseExperiment() failed to fetch base experiment");
@@ -9294,7 +9553,7 @@ async function _internalResolveEvaluatorData(evaluator, experiment) {
     }).asDataset();
   }
   const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
-  if (isAsyncIterable2(resolvedDataResult)) {
+  if (isAsyncIterable3(resolvedDataResult)) {
     return resolvedDataResult;
   }
   if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
@@ -9315,10 +9574,10 @@ globalThis._evals = {
   reporters: {}
 };
 function _initializeSpanContext() {
-  globalThis._spanContext = { currentSpan: _chunkXLLGRXGRjs.currentSpan, withCurrent: _chunkXLLGRXGRjs.withCurrent, startSpan: _chunkXLLGRXGRjs.startSpan, NOOP_SPAN: _chunkXLLGRXGRjs.NOOP_SPAN };
+  globalThis._spanContext = { currentSpan: _chunkTWCDSYJNjs.currentSpan, withCurrent: _chunkTWCDSYJNjs.withCurrent, startSpan: _chunkTWCDSYJNjs.startSpan, NOOP_SPAN: _chunkTWCDSYJNjs.NOOP_SPAN };
 }
 async function Eval(name, evaluator, reporterOrOpts) {
-  const options = _chunkXLLGRXGRjs.isEmpty.call(void 0, reporterOrOpts) ? {} : typeof reporterOrOpts === "string" ? { reporter: reporterOrOpts } : "name" in reporterOrOpts ? { reporter: reporterOrOpts } : reporterOrOpts;
+  const options = _chunkTWCDSYJNjs.isEmpty.call(void 0, reporterOrOpts) ? {} : typeof reporterOrOpts === "string" ? { reporter: reporterOrOpts } : "name" in reporterOrOpts ? { reporter: reporterOrOpts } : reporterOrOpts;
   let evalName = makeEvalName(name, evaluator.experimentName);
   if (globalThis._evals.evaluators[evalName]) {
     evalName = `${evalName}_${Object.keys(_evals).length}`;
@@ -9377,7 +9636,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
       const enableCache = _nullishCoalesce(options.enableCache, () => ( true));
       let ret;
       if (options.parent) {
-        ret = await _chunkXLLGRXGRjs.withParent.call(void 0, 
+        ret = await _chunkTWCDSYJNjs.withParent.call(void 0, 
           options.parent,
           () => runEvaluator(
             null,
@@ -9413,7 +9672,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
       if (experiment) {
         await experiment.flush().catch(console.error);
       } else if (options.parent) {
-        await _chunkXLLGRXGRjs.flush.call(void 0, { state: evaluator.state }).catch(console.error);
+        await _chunkTWCDSYJNjs.flush.call(void 0, { state: evaluator.state }).catch(console.error);
       }
     }
   } finally {
@@ -9496,7 +9755,7 @@ function _internalPrepareEvaluatorScore(scoreValue, name) {
   if (scoreValue === null) return { results: null };
   if (Array.isArray(scoreValue)) {
     for (const score of scoreValue) {
-      if (!(typeof score === "object" && !_chunkXLLGRXGRjs.isEmpty.call(void 0, score))) {
+      if (!(typeof score === "object" && !_chunkTWCDSYJNjs.isEmpty.call(void 0, score))) {
         throw new Error(
           `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(score)}`
         );
@@ -9506,7 +9765,7 @@ function _internalPrepareEvaluatorScore(scoreValue, name) {
   let results;
   if (Array.isArray(scoreValue)) {
     results = scoreValue;
-  } else if (typeof scoreValue === "object" && !_chunkXLLGRXGRjs.isEmpty.call(void 0, scoreValue)) {
+  } else if (typeof scoreValue === "object" && !_chunkTWCDSYJNjs.isEmpty.call(void 0, scoreValue)) {
     results = [scoreValue];
   } else {
     results = [{ name, score: scoreValue }];
@@ -9550,7 +9809,7 @@ function collectScoringResults(runResults, names, onResult) {
   return failing;
 }
 function validateClassificationResult(value, scorerName2) {
-  if (!(typeof value === "object" && value !== null && !_chunkXLLGRXGRjs.isEmpty.call(void 0, value))) {
+  if (!(typeof value === "object" && value !== null && !_chunkTWCDSYJNjs.isEmpty.call(void 0, value))) {
     throw new Error(
       `When returning structured classifier results, each classification must be a non-empty object. Got: ${JSON.stringify(value)}`
     );
@@ -9600,7 +9859,7 @@ function logScoringFailures(kind, failures, metadata, rootSpan, state) {
   );
   metadata[`${kind}_errors`] = errorMap;
   rootSpan.log({ metadata: { [`${kind}_errors`]: errorMap } });
-  _chunk6Z5S7VOUjs.debugLogger.forState(state).warn(
+  _chunk2XDW3UCGjs.debugLogger.forState(state).warn(
     `Found exceptions for the following ${kind}s: ${Object.keys(errorMap).join(", ")}`,
     failures.map((f) => f.error)
   );
@@ -9634,7 +9893,7 @@ var defaultErrorScoreHandler = ({
 };
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, )))), 'optionalAccess', _164 => _164.spanCache, 'optionalAccess', _165 => _165.start, 'call', _166 => _166()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, )))), 'optionalAccess', _170 => _170.spanCache, 'optionalAccess', _171 => _171.start, 'call', _172 => _172()]);
   }
   try {
     parameters = await validateParameters(
@@ -9649,7 +9908,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e11) {
+      } catch (e13) {
         return void 0;
       }
     })() : void 0;
@@ -9665,7 +9924,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         if (cancelled) {
           return;
         }
-        const eventDataset = experiment ? experiment.dataset : _chunkXLLGRXGRjs.Dataset.isDataset(evaluator.data) ? evaluator.data : void 0;
+        const eventDataset = experiment ? experiment.dataset : _chunkTWCDSYJNjs.Dataset.isDataset(evaluator.data) ? evaluator.data : void 0;
         const inlineDatasetOrigin = eventDataset && datum.id && datum._xact_id ? {
           object_type: "dataset",
           object_id: await eventDataset.id,
@@ -9673,8 +9932,8 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           created: datum.created,
           _xact_id: datum._xact_id
         } : void 0;
-        const parsedDatumOrigin = _chunkXLLGRXGRjs.ObjectReference.safeParse(datum.origin);
-        const origin = _nullishCoalesce(inlineDatasetOrigin, () => ( (_optionalChain([parsedDatumOrigin, 'optionalAccess', _167 => _167.success]) ? parsedDatumOrigin.data : void 0)));
+        const parsedDatumOrigin = _chunkTWCDSYJNjs.ObjectReference.safeParse(datum.origin);
+        const origin = _nullishCoalesce(inlineDatasetOrigin, () => ( (_optionalChain([parsedDatumOrigin, 'optionalAccess', _173 => _173.success]) ? parsedDatumOrigin.data : void 0)));
         const baseEvent = {
           name: "eval",
           spanAttributes: {
@@ -9689,26 +9948,26 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           }
         };
         const callback = async (rootSpan) => {
-          const state = _nullishCoalesce(evaluator.state, () => ( _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, )));
+          const state = _nullishCoalesce(evaluator.state, () => ( _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, )));
           const ensureSpansFlushed = async () => {
             if (experiment) {
-              await _chunkXLLGRXGRjs.flush.call(void 0, { state: experiment.loggingState });
+              await _chunkTWCDSYJNjs.flush.call(void 0, { state: experiment.loggingState });
             } else if (state) {
-              await _chunkXLLGRXGRjs.flush.call(void 0, { state });
+              await _chunkTWCDSYJNjs.flush.call(void 0, { state });
             } else {
-              await _chunkXLLGRXGRjs.flush.call(void 0, );
+              await _chunkTWCDSYJNjs.flush.call(void 0, );
             }
             if (state) {
               await state.flushOtel();
             }
           };
           const parentStr = state.currentParent.getStore();
-          const parentComponents = typeof parentStr === "string" ? _chunkXLLGRXGRjs.SpanComponentsV4.fromStr(parentStr) : null;
+          const parentComponents = typeof parentStr === "string" ? _chunkTWCDSYJNjs.SpanComponentsV4.fromStr(parentStr) : null;
           const trace = state ? new LocalTrace({
-            objectType: parentComponents ? _chunkXLLGRXGRjs.spanObjectTypeV3ToTypedString.call(void 0, 
+            objectType: parentComponents ? _chunkTWCDSYJNjs.spanObjectTypeV3ToTypedString.call(void 0, 
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _168 => _168.data, 'access', async _169 => _169.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _174 => _174.data, 'access', async _175 => _175.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -9734,10 +9993,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                 _nullishCoalesce(parameters, () => ( {})),
                 span,
                 (event) => {
-                  _optionalChain([stream, 'optionalCall', _170 => _170({
+                  _optionalChain([stream, 'optionalCall', _176 => _176({
                     ...event,
                     id: rootSpan.id,
-                    origin: _optionalChain([baseEvent, 'access', _171 => _171.event, 'optionalAccess', _172 => _172.origin]),
+                    origin: _optionalChain([baseEvent, 'access', _177 => _177.event, 'optionalAccess', _178 => _178.origin]),
                     name: evaluator.evalName,
                     object_type: "task"
                   })]);
@@ -9770,7 +10029,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               trace
             };
             const { trace: _trace, ...scoringArgsForLogging } = scoringArgs;
-            const propagatedEvent = _chunkXLLGRXGRjs.makeScorerPropagatedEvent.call(void 0, 
+            const propagatedEvent = _chunkTWCDSYJNjs.makeScorerPropagatedEvent.call(void 0, 
               await rootSpan.export()
             );
             const [scoreResults, classificationResults] = await Promise.all([
@@ -9865,7 +10124,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               evaluator.state
             );
           } catch (e) {
-            _chunkXLLGRXGRjs.logError.call(void 0, rootSpan, e);
+            _chunkTWCDSYJNjs.logError.call(void 0, rootSpan, e);
             error = e;
           } finally {
             progressReporter.increment(evaluator.evalName);
@@ -9889,7 +10148,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               tags: tags.length ? tags : void 0,
               metadata,
               error,
-              origin: _optionalChain([baseEvent, 'access', _173 => _173.event, 'optionalAccess', _174 => _174.origin])
+              origin: _optionalChain([baseEvent, 'access', _179 => _179.event, 'optionalAccess', _180 => _180.origin])
             };
             collectedResults.push({
               ...baseResult,
@@ -9899,7 +10158,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           }
         };
         if (!experiment) {
-          return await _chunkXLLGRXGRjs.traced.call(void 0, callback, {
+          return await _chunkTWCDSYJNjs.traced.call(void 0, callback, {
             ...baseEvent,
             state: evaluator.state
           });
@@ -9929,7 +10188,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _175 => _175.setTotal, 'optionalCall', _176 => _176(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _181 => _181.setTotal, 'optionalCall', _182 => _182(evaluator.evalName, scheduledTrials)]);
           q.pushAsync({ datum, trialIndex }).catch((e) => {
             if (queueErrors.length < 5) {
               queueErrors.push(e);
@@ -9953,7 +10212,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const cancel = async () => {
       await new Promise((_, reject2) => {
         if (cancelled) {
-          reject2(new (0, _chunkXLLGRXGRjs.InternalAbortError)("Evaluator already cancelled"));
+          reject2(new (0, _chunkTWCDSYJNjs.InternalAbortError)("Evaluator already cancelled"));
           return;
         }
         const rejectOnce = (error) => {
@@ -9966,12 +10225,12 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         };
         if (evaluator.timeout) {
           timeoutId = setTimeout(() => {
-            rejectOnce(new (0, _chunkXLLGRXGRjs.InternalAbortError)("Evaluator timed out"));
+            rejectOnce(new (0, _chunkTWCDSYJNjs.InternalAbortError)("Evaluator timed out"));
           }, evaluator.timeout);
         }
         if (evaluator.signal) {
           abortHandler = () => {
-            rejectOnce(new (0, _chunkXLLGRXGRjs.InternalAbortError)("Evaluator aborted"));
+            rejectOnce(new (0, _chunkTWCDSYJNjs.InternalAbortError)("Evaluator aborted"));
           };
           evaluator.signal.addEventListener("abort", abortHandler);
         }
@@ -9994,9 +10253,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       }
     } catch (e) {
       q.kill();
-      if (e instanceof _chunkXLLGRXGRjs.InternalAbortError) {
-        if (_chunk6Z5S7VOUjs.isomorph_default.getEnv("BRAINTRUST_VERBOSE")) {
-          _chunk6Z5S7VOUjs.debugLogger.forState(evaluator.state).warn("Evaluator cancelled:", e.message);
+      if (e instanceof _chunkTWCDSYJNjs.InternalAbortError) {
+        if (_chunk2XDW3UCGjs.isomorph_default.getEnv("BRAINTRUST_VERBOSE")) {
+          _chunk2XDW3UCGjs.debugLogger.forState(evaluator.state).warn("Evaluator cancelled:", e.message);
         }
       }
       throw e;
@@ -10021,9 +10280,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, )))), 'optionalAccess', _177 => _177.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _178 => _178.dispose, 'call', _179 => _179()]);
-      _optionalChain([spanCache, 'optionalAccess', _180 => _180.stop, 'call', _181 => _181()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, )))), 'optionalAccess', _183 => _183.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _184 => _184.dispose, 'call', _185 => _185()]);
+      _optionalChain([spanCache, 'optionalAccess', _186 => _186.stop, 'call', _187 => _187()]);
     }
   }
 }
@@ -10116,25 +10375,25 @@ var defaultReporter = {
       reportFailures(evaluator, failingResults, { verbose, jsonl });
     }
     if (jsonl) {
-      _chunk6Z5S7VOUjs.isomorph_default.writeln(JSON.stringify(summary));
+      _chunk2XDW3UCGjs.isomorph_default.writeln(JSON.stringify(summary));
     } else {
-      _chunk6Z5S7VOUjs.isomorph_default.writeln("Experiment summary");
-      _chunk6Z5S7VOUjs.isomorph_default.writeln("==================");
+      _chunk2XDW3UCGjs.isomorph_default.writeln("Experiment summary");
+      _chunk2XDW3UCGjs.isomorph_default.writeln("==================");
       if (summary.comparisonExperimentName) {
-        _chunk6Z5S7VOUjs.isomorph_default.writeln(
+        _chunk2XDW3UCGjs.isomorph_default.writeln(
           `${summary.comparisonExperimentName} (baseline) <- ${summary.experimentName} (comparison)`
         );
-        _chunk6Z5S7VOUjs.isomorph_default.writeln("");
+        _chunk2XDW3UCGjs.isomorph_default.writeln("");
       }
       const hasScores = Object.keys(summary.scores).length > 0;
       const hasMetrics = Object.keys(_nullishCoalesce(summary.metrics, () => ( {}))).length > 0;
       const hasComparison = !!summary.comparisonExperimentName;
       if (hasScores || hasMetrics) {
         if (hasComparison) {
-          _chunk6Z5S7VOUjs.isomorph_default.writeln(
+          _chunk2XDW3UCGjs.isomorph_default.writeln(
             "Name                Value      Change     Improvements Regressions"
           );
-          _chunk6Z5S7VOUjs.isomorph_default.writeln(
+          _chunk2XDW3UCGjs.isomorph_default.writeln(
             "----------------------------------------------------------------"
           );
         }
@@ -10143,18 +10402,18 @@ var defaultReporter = {
           const scoreValue = `${scorePercent}%`;
           if (hasComparison) {
             let diffString = "-";
-            if (!_chunkXLLGRXGRjs.isEmpty.call(void 0, score.diff)) {
+            if (!_chunkTWCDSYJNjs.isEmpty.call(void 0, score.diff)) {
               const diffPercent = (score.diff * 100).toFixed(2);
               const diffSign = score.diff > 0 ? "+" : "";
               diffString = `${diffSign}${diffPercent}%`;
             }
             const improvements = score.improvements > 0 ? score.improvements.toString() : "-";
             const regressions = score.regressions > 0 ? score.regressions.toString() : "-";
-            _chunk6Z5S7VOUjs.isomorph_default.writeln(
+            _chunk2XDW3UCGjs.isomorph_default.writeln(
               `${score.name.padEnd(18)} ${scoreValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
             );
           } else {
-            _chunk6Z5S7VOUjs.isomorph_default.writeln(`${score.name.padEnd(20)} ${scoreValue.padStart(15)}`);
+            _chunk2XDW3UCGjs.isomorph_default.writeln(`${score.name.padEnd(20)} ${scoreValue.padStart(15)}`);
           }
         }
         for (const metric of Object.values(_nullishCoalesce(summary.metrics, () => ( {})))) {
@@ -10163,30 +10422,30 @@ var defaultReporter = {
           const metricValue = metric.unit === "$" ? `${metric.unit}${formattedValue}` : `${formattedValue}${metric.unit}`;
           if (hasComparison) {
             let diffString = "-";
-            if (!_chunkXLLGRXGRjs.isEmpty.call(void 0, metric.diff)) {
+            if (!_chunkTWCDSYJNjs.isEmpty.call(void 0, metric.diff)) {
               const diffPercent = (metric.diff * 100).toFixed(2);
               const diffSign = metric.diff > 0 ? "+" : "";
               diffString = `${diffSign}${diffPercent}%`;
             }
             const improvements = metric.improvements > 0 ? metric.improvements.toString() : "-";
             const regressions = metric.regressions > 0 ? metric.regressions.toString() : "-";
-            _chunk6Z5S7VOUjs.isomorph_default.writeln(
+            _chunk2XDW3UCGjs.isomorph_default.writeln(
               `${metric.name.padEnd(18)} ${metricValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
             );
           } else {
-            _chunk6Z5S7VOUjs.isomorph_default.writeln(
+            _chunk2XDW3UCGjs.isomorph_default.writeln(
               `${metric.name.padEnd(20)} ${metricValue.padStart(15)}`
             );
           }
         }
       }
       if (summary.experimentUrl) {
-        _chunk6Z5S7VOUjs.isomorph_default.writeln("");
-        _chunk6Z5S7VOUjs.isomorph_default.writeln(`View results for ${summary.experimentName}`);
-        _chunk6Z5S7VOUjs.isomorph_default.writeln(`See results at ${summary.experimentUrl}`);
+        _chunk2XDW3UCGjs.isomorph_default.writeln("");
+        _chunk2XDW3UCGjs.isomorph_default.writeln(`View results for ${summary.experimentName}`);
+        _chunk2XDW3UCGjs.isomorph_default.writeln(`See results at ${summary.experimentUrl}`);
       }
     }
-    _chunk6Z5S7VOUjs.isomorph_default.writeln("");
+    _chunk2XDW3UCGjs.isomorph_default.writeln("");
     return failingResults.length === 0;
   },
   async reportRun(evalReports) {
@@ -10203,7 +10462,7 @@ var DEFAULT_BATCH_SIZE = 1e3;
 var DurableEvalMemoryStore = (_class8 = class {constructor() { _class8.prototype.__init21.call(this); }
   __init21() {this.values = /* @__PURE__ */ new Map()}
   async read(key) {
-    return _optionalChain([this, 'access', _182 => _182.values, 'access', _183 => _183.get, 'call', _184 => _184(key), 'optionalAccess', _185 => _185.slice, 'call', _186 => _186()]);
+    return _optionalChain([this, 'access', _188 => _188.values, 'access', _189 => _189.get, 'call', _190 => _190(key), 'optionalAccess', _191 => _191.slice, 'call', _192 => _192()]);
   }
   async write(key, value) {
     this.values.set(key, value.slice());
@@ -10233,13 +10492,13 @@ var DurableEvalRedisStore = class {
     if (typeof value !== "string") {
       throw new Error("DurableEvalRedisStore expected GET to return a string");
     }
-    return _chunkXLLGRXGRjs.base64ToUint8Array.call(void 0, value);
+    return _chunkTWCDSYJNjs.base64ToUint8Array.call(void 0, value);
   }
   async write(key, value) {
     const client = this.client;
     const set = client.set;
     const redisKey = `${this.keyPrefix}${key}`;
-    const encoded = _chunkXLLGRXGRjs.uint8ArrayToBase64.call(void 0, value);
+    const encoded = _chunkTWCDSYJNjs.uint8ArrayToBase64.call(void 0, value);
     if (typeof client.defineCommand === "function") {
       await set.call(client, redisKey, encoded, "PX", this.ttlMs);
     } else if (typeof client.sendCommand === "function") {
@@ -10254,7 +10513,7 @@ var DurableEvalRedisStore = class {
   }
   async getOrSet(key, value) {
     const redisKey = `${this.keyPrefix}${key}`;
-    const encoded = _chunkXLLGRXGRjs.uint8ArrayToBase64.call(void 0, value);
+    const encoded = _chunkTWCDSYJNjs.uint8ArrayToBase64.call(void 0, value);
     const client = this.client;
     const set = client.set;
     let setOptions;
@@ -10276,7 +10535,7 @@ var DurableEvalRedisStore = class {
         "DurableEvalRedisStore expected atomic SET to return a string or null"
       );
     }
-    return { value: _chunkXLLGRXGRjs.base64ToUint8Array.call(void 0, existing), created: false };
+    return { value: _chunkTWCDSYJNjs.base64ToUint8Array.call(void 0, existing), created: false };
   }
 };
 var BatchTask = (_class9 = class {
@@ -10310,7 +10569,7 @@ function defineDurableEval(projectName, evaluator) {
 }
 async function startDurableEval(definition, options) {
   const store = definition.evaluator.store;
-  const runId = _chunkXLLGRXGRjs.newId.call(void 0, );
+  const runId = _chunkTWCDSYJNjs.newId.call(void 0, );
   const key = runKey(definition.projectName, definition.evalName, runId);
   const { data } = callEvaluatorData(definition.evaluator.data);
   const parameters = await validateParameters(
@@ -10358,7 +10617,7 @@ async function startDurableEval(definition, options) {
       cases: [],
       batches: []
     };
-    await _optionalChain([experiment, 'optionalAccess', _187 => _187.flush, 'call', _188 => _188()]);
+    await _optionalChain([experiment, 'optionalAccess', _193 => _193.flush, 'call', _194 => _194()]);
     await writeRunRecord(store, key, state2);
     return currentStatus(definition, state2);
   }
@@ -10523,9 +10782,9 @@ function currentStatus(definition, state) {
   return { status: "waiting", runId: state.runId, pending };
 }
 async function startCaseRoot(definition, state, record, experiment) {
-  if (!experiment) return _chunkXLLGRXGRjs.NOOP_SPAN;
+  if (!experiment) return _chunkTWCDSYJNjs.NOOP_SPAN;
   const datum = record.datum;
-  return _chunkXLLGRXGRjs._internalStartSpanWithInitialMerge.call(void 0, {
+  return _chunkTWCDSYJNjs._internalStartSpanWithInitialMerge.call(void 0, {
     ...definition.evaluator.state ? { state: definition.evaluator.state } : {},
     parent: await experiment.export(),
     name: "eval",
@@ -10591,7 +10850,7 @@ async function logTaskResult(definition, state, record, experiment, task) {
     record.rootSpan = await root.export();
     record.taskLogged = true;
   } catch (error) {
-    _chunkXLLGRXGRjs.logError.call(void 0, root, error);
+    _chunkTWCDSYJNjs.logError.call(void 0, root, error);
     throw error;
   } finally {
     root.end();
@@ -10606,7 +10865,7 @@ async function logCompletedTasks(definition, state, store, key, experiment) {
     changed.push(record);
   }
   if (changed.length > 0) {
-    await _optionalChain([experiment, 'optionalAccess', _189 => _189.flush, 'call', _190 => _190()]);
+    await _optionalChain([experiment, 'optionalAccess', _195 => _195.flush, 'call', _196 => _196()]);
     await writeCaseRecords(store, key, changed);
   }
 }
@@ -10624,7 +10883,7 @@ async function runTaskStage(definition, state, store, key, experiment) {
     changed.push(record);
   }
   if (changed.length > 0) {
-    await _optionalChain([experiment, 'optionalAccess', _191 => _191.flush, 'call', _192 => _192()]);
+    await _optionalChain([experiment, 'optionalAccess', _197 => _197.flush, 'call', _198 => _198()]);
     await writeCaseRecords(store, key, changed);
   }
 }
@@ -10633,7 +10892,7 @@ async function runScoreStages(definition, state, store, key, experiment) {
   const changed = /* @__PURE__ */ new Map();
   const persistChangedCases = async () => {
     if (changed.size === 0) return;
-    await _optionalChain([experiment, 'optionalAccess', _193 => _193.flush, 'call', _194 => _194()]);
+    await _optionalChain([experiment, 'optionalAccess', _199 => _199.flush, 'call', _200 => _200()]);
     await writeCaseRecords(store, key, [...changed.values()]);
     changed.clear();
   };
@@ -10701,11 +10960,11 @@ function scorerArgs(record) {
   };
 }
 function resumeCaseRoot(definition, record, experiment) {
-  if (!experiment) return _chunkXLLGRXGRjs.NOOP_SPAN;
+  if (!experiment) return _chunkTWCDSYJNjs.NOOP_SPAN;
   if (!record.rootSpan) {
     throw new Error(`Durable eval case ${record.caseId} has no root span`);
   }
-  return _chunkXLLGRXGRjs._internalResumeSpan.call(void 0, {
+  return _chunkTWCDSYJNjs._internalResumeSpan.call(void 0, {
     exported: record.rootSpan,
     state: definition.evaluator.state
   });
@@ -10737,14 +10996,14 @@ async function evaluateAndLogScore(definition, state, record, name, experiment,
           type: "score" /* SCORE */,
           purpose: "scorer"
         },
-        propagatedEvent: _chunkXLLGRXGRjs.makeScorerPropagatedEvent.call(void 0, rootExport || void 0),
+        propagatedEvent: _chunkTWCDSYJNjs.makeScorerPropagatedEvent.call(void 0, rootExport || void 0),
         event: { input: scorerArgs(record) }
       }
     );
     if (prepared.scores) root.log({ scores: prepared.scores });
     record.loggedScores[name] = true;
   } catch (error) {
-    _chunkXLLGRXGRjs.logError.call(void 0, root, error);
+    _chunkTWCDSYJNjs.logError.call(void 0, root, error);
     throw error;
   } finally {
     root.end();
@@ -10776,7 +11035,7 @@ async function evaluateAndLogClassification(definition, state, record, name, cla
           type: "classifier" /* CLASSIFIER */,
           purpose: "scorer"
         },
-        propagatedEvent: _chunkXLLGRXGRjs.makeScorerPropagatedEvent.call(void 0, rootExport || void 0),
+        propagatedEvent: _chunkTWCDSYJNjs.makeScorerPropagatedEvent.call(void 0, rootExport || void 0),
         event: { input: scorerArgs(record) }
       }
     );
@@ -10785,7 +11044,7 @@ async function evaluateAndLogClassification(definition, state, record, name, cla
     }
     record.loggedClassifications[name] = true;
   } catch (error) {
-    _chunkXLLGRXGRjs.logError.call(void 0, root, error);
+    _chunkTWCDSYJNjs.logError.call(void 0, root, error);
     throw error;
   } finally {
     root.end();
@@ -10898,9 +11157,9 @@ function processorForStage(definition, kind, scorerName2) {
     }
     return definition.evaluator.task.processor;
   }
-  const scorer = _optionalChain([resolveScorers, 'call', _195 => _195(_nullishCoalesce(definition.evaluator.scores, () => ( []))), 'access', _196 => _196.find, 'call', _197 => _197(
+  const scorer = _optionalChain([resolveScorers, 'call', _201 => _201(_nullishCoalesce(definition.evaluator.scores, () => ( []))), 'access', _202 => _202.find, 'call', _203 => _203(
     ({ name }) => name === scorerName2
-  ), 'optionalAccess', _198 => _198.scorer]);
+  ), 'optionalAccess', _204 => _204.scorer]);
   if (!isBatchScorer(scorer)) {
     throw new Error(`Definition no longer contains scorer ${scorerName2}`);
   }
@@ -11027,7 +11286,7 @@ async function finishExperiment(definition, state, experiment) {
   if (!comparisonExperimentId) {
     try {
       comparisonExperimentId = await experiment._getBaseExperimentId();
-    } catch (e12) {
+    } catch (e14) {
       comparisonExperimentId = void 0;
     }
   }
@@ -11046,7 +11305,7 @@ function runKey(projectName, evalName, runId) {
   return `durable-eval/v1/runs/${contentVersion(encoder.encode(`${projectName}\0${evalName}\0${runId}`))}`;
 }
 function encodedKeyPart(value) {
-  return _chunkXLLGRXGRjs.uint8ArrayToBase64.call(void 0, encoder.encode(value)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+  return _chunkTWCDSYJNjs.uint8ArrayToBase64.call(void 0, encoder.encode(value)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
 }
 function caseRecordKey(key, caseId, kind, ...names) {
   const suffix = names.map(encodedKeyPart).join("/");
@@ -11170,12 +11429,12 @@ async function readCaseRecord(definition, store, key, id) {
   }
   return {
     ...base,
-    metadata: _nullishCoalesce(_optionalChain([task, 'optionalAccess', _199 => _199.metadata]), () => ( base.metadata)),
+    metadata: _nullishCoalesce(_optionalChain([task, 'optionalAccess', _205 => _205.metadata]), () => ( base.metadata)),
     tags: task ? task.tags : base.tags,
     taskComplete: task !== void 0,
     taskLogged: taskLog !== void 0,
-    output: _optionalChain([task, 'optionalAccess', _200 => _200.output]),
-    rootSpan: _optionalChain([taskLog, 'optionalAccess', _201 => _201.rootSpan]),
+    output: _optionalChain([task, 'optionalAccess', _206 => _206.output]),
+    rootSpan: _optionalChain([taskLog, 'optionalAccess', _207 => _207.rootSpan]),
     scores,
     loggedScores,
     classifications,
@@ -11291,7 +11550,7 @@ function deterministicId(value) {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-5${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
 }
 function contentVersion(value) {
-  if (_chunk6Z5S7VOUjs.isomorph_default.hash) return _chunk6Z5S7VOUjs.isomorph_default.hash(decoder.decode(value));
+  if (_chunk2XDW3UCGjs.isomorph_default.hash) return _chunk2XDW3UCGjs.isomorph_default.hash(decoder.decode(value));
   let hash = 2166136261;
   for (const byte of value) {
     hash ^= byte;
@@ -11356,7 +11615,7 @@ function agentAssertionScorer(callback, options = {}) {
     });
     const resources = {};
     if (assertions.some((assertion) => assertion.requiresTrace)) {
-      resources.spans = await _optionalChain([args, 'access', _202 => _202.trace, 'optionalAccess', _203 => _203.getSpans, 'call', _204 => _204({ spanType: ["tool"] })]);
+      resources.spans = await _optionalChain([args, 'access', _208 => _208.trace, 'optionalAccess', _209 => _209.getSpans, 'call', _210 => _210({ spanType: ["tool"] })]);
     }
     const results = await Promise.all(
       assertions.map(async (assertion) => {
@@ -11514,7 +11773,7 @@ async function validateSchema(schema, value) {
   }
 }
 function toolCalls(spans) {
-  return spans.filter((span) => _optionalChain([span, 'access', _205 => _205.span_attributes, 'optionalAccess', _206 => _206.type]) === "tool");
+  return spans.filter((span) => _optionalChain([span, 'access', _211 => _211.span_attributes, 'optionalAccess', _212 => _212.type]) === "tool");
 }
 function matchingToolCalls(spans, toolName, options) {
   return toolCalls(spans).filter((span) => {
@@ -11532,17 +11791,17 @@ function matchingToolCalls(spans, toolName, options) {
   });
 }
 function getToolName(span) {
-  const spanName = [_optionalChain([span, 'access', _207 => _207.span_attributes, 'optionalAccess', _208 => _208.name]), span.name].map(normalizeToolName).find((value) => value !== void 0);
-  if (_optionalChain([spanName, 'optionalAccess', _209 => _209.includes, 'call', _210 => _210("/")])) {
+  const spanName = [_optionalChain([span, 'access', _213 => _213.span_attributes, 'optionalAccess', _214 => _214.name]), span.name].map(normalizeToolName).find((value) => value !== void 0);
+  if (_optionalChain([spanName, 'optionalAccess', _215 => _215.includes, 'call', _216 => _216("/")])) {
     return spanName;
   }
   const metadataName = [
-    _optionalChain([span, 'access', _211 => _211.metadata, 'optionalAccess', _212 => _212.tool_name]),
-    _optionalChain([span, 'access', _213 => _213.metadata, 'optionalAccess', _214 => _214["gen_ai.tool.name"]])
+    _optionalChain([span, 'access', _217 => _217.metadata, 'optionalAccess', _218 => _218.tool_name]),
+    _optionalChain([span, 'access', _219 => _219.metadata, 'optionalAccess', _220 => _220["gen_ai.tool.name"]])
   ].map(normalizeToolName).find((value) => value !== void 0);
   const mcpServer = [
-    _optionalChain([span, 'access', _215 => _215.metadata, 'optionalAccess', _216 => _216["mcp.server"]]),
-    _optionalChain([span, 'access', _217 => _217.metadata, 'optionalAccess', _218 => _218["openai_codex.mcp.server"]])
+    _optionalChain([span, 'access', _221 => _221.metadata, 'optionalAccess', _222 => _222["mcp.server"]]),
+    _optionalChain([span, 'access', _223 => _223.metadata, 'optionalAccess', _224 => _224["openai_codex.mcp.server"]])
   ].find((value) => typeof value === "string" && value !== "");
   if (metadataName && mcpServer) {
     return `${mcpServer}/${metadataName}`;
@@ -11612,7 +11871,7 @@ function formatValue(value) {
       return serialized;
     }
     return formatValueWithUndefined(value, /* @__PURE__ */ new Set());
-  } catch (e13) {
+  } catch (e15) {
     return String(value);
   }
 }
@@ -11771,7 +12030,7 @@ var Project2 = (_class11 = class {
       console.warn("publish() is a no-op when running `braintrust push`.");
       return;
     }
-    await _chunkXLLGRXGRjs.login.call(void 0, );
+    await _chunkTWCDSYJNjs.login.call(void 0, );
     const projectMap = new ProjectNameIdMap();
     const functionDefinitions = [];
     if (this._publishableCodeFunctions.length > 0) {
@@ -11785,7 +12044,7 @@ var Project2 = (_class11 = class {
         functionDefinitions.push(functionDefinition);
       }
     }
-    await _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, ).apiConn().post_json("insert-functions", {
+    await _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, ).apiConn().post_json("insert-functions", {
       functions: functionDefinitions
     });
   }
@@ -11804,12 +12063,12 @@ var ToolBuilder = (_class12 = class {
     const { handler, name, slug, parameters, returns, ...rest } = opts;
     let resolvedName = _nullishCoalesce(name, () => ( handler.name));
     if (resolvedName.trim().length === 0) {
-      resolvedName = `Tool ${_chunk6Z5S7VOUjs.isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+      resolvedName = `Tool ${_chunk2XDW3UCGjs.isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
     }
     const tool = new CodeFunction(this.project, {
       handler,
       name: resolvedName,
-      slug: _nullishCoalesce(slug, () => ( _chunkXLLGRXGRjs.slugify.call(void 0, resolvedName, { lower: true, strict: true }))),
+      slug: _nullishCoalesce(slug, () => ( _chunkTWCDSYJNjs.slugify.call(void 0, resolvedName, { lower: true, strict: true }))),
       type: "tool",
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
       parameters,
@@ -11834,9 +12093,9 @@ var ScorerBuilder = (_class13 = class {
       resolvedName = opts.handler.name;
     }
     if (!resolvedName || resolvedName.trim().length === 0) {
-      resolvedName = `Scorer ${_chunk6Z5S7VOUjs.isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+      resolvedName = `Scorer ${_chunk2XDW3UCGjs.isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
     }
-    const slug = _nullishCoalesce(opts.slug, () => ( _chunkXLLGRXGRjs.slugify.call(void 0, resolvedName, { lower: true, strict: true })));
+    const slug = _nullishCoalesce(opts.slug, () => ( _chunkTWCDSYJNjs.slugify.call(void 0, resolvedName, { lower: true, strict: true })));
     if ("handler" in opts) {
       const scorer = new CodeFunction(this.project, {
         ...opts,
@@ -11891,9 +12150,9 @@ var ClassifierBuilder = (_class14 = class {
     this.taskCounter++;
     let resolvedName = _nullishCoalesce(opts.name, () => ( opts.handler.name));
     if (!resolvedName || resolvedName.trim().length === 0) {
-      resolvedName = `Classifier ${_chunk6Z5S7VOUjs.isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+      resolvedName = `Classifier ${_chunk2XDW3UCGjs.isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
     }
-    const slug = _nullishCoalesce(opts.slug, () => ( _chunkXLLGRXGRjs.slugify.call(void 0, resolvedName, { lower: true, strict: true })));
+    const slug = _nullishCoalesce(opts.slug, () => ( _chunkTWCDSYJNjs.slugify.call(void 0, resolvedName, { lower: true, strict: true })));
     const classifier = new CodeFunction(this.project, {
       ...opts,
       name: resolvedName,
@@ -12022,18 +12281,18 @@ var PromptBuilder = class {
         rawTools.push(tool);
       }
     }
-    const slug = _nullishCoalesce(opts.slug, () => ( _chunkXLLGRXGRjs.slugify.call(void 0, opts.name, { lower: true, strict: true })));
+    const slug = _nullishCoalesce(opts.slug, () => ( _chunkTWCDSYJNjs.slugify.call(void 0, opts.name, { lower: true, strict: true })));
     const promptData = promptDefinitionToPromptData(opts, rawTools);
     const promptRow = {
       id: opts.id,
-      _xact_id: opts.version ? _chunkXLLGRXGRjs.loadPrettyXact.call(void 0, opts.version) : void 0,
+      _xact_id: opts.version ? _chunkTWCDSYJNjs.loadPrettyXact.call(void 0, opts.version) : void 0,
       name: opts.name,
       slug,
       prompt_data: promptData,
       tags: opts.tags,
       ...this.project.id !== void 0 ? { project_id: this.project.id } : {}
     };
-    const prompt = new (0, _chunkXLLGRXGRjs.Prompt)(
+    const prompt = new (0, _chunkTWCDSYJNjs.Prompt)(
       promptRow,
       {},
       // It doesn't make sense to specify defaults here.
@@ -12088,7 +12347,7 @@ var ParametersBuilder = class {
   }
   
   create(opts) {
-    const slug = _nullishCoalesce(opts.slug, () => ( _chunkXLLGRXGRjs.slugify.call(void 0, opts.name, { lower: true, strict: true })));
+    const slug = _nullishCoalesce(opts.slug, () => ( _chunkTWCDSYJNjs.slugify.call(void 0, opts.name, { lower: true, strict: true })));
     const codeParameters = new CodeParameters(this.project, {
       name: opts.name,
       slug,
@@ -12127,7 +12386,7 @@ function serializeEvalParameterstoParametersSchema(parameters) {
         required.push(name);
       }
     } else {
-      const schemaObj = _chunkXLLGRXGRjs.zodToJsonSchema.call(void 0, value);
+      const schemaObj = _chunkTWCDSYJNjs.zodToJsonSchema.call(void 0, value);
       properties[name] = schemaObj;
       if (!("default" in schemaObj)) {
         required.push(name);
@@ -12156,11 +12415,11 @@ var ProjectNameIdMap = (_class15 = class {constructor() { _class15.prototype.__i
   __init31() {this.idToName = {}}
   async getId(projectName) {
     if (!(projectName in this.nameToId)) {
-      const response = await _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, ).appConn().post_json("api/project/register", {
+      const response = await _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, ).appConn().post_json("api/project/register", {
         project_name: projectName
       });
       const result = _v3.z.object({
-        project: _chunkXLLGRXGRjs.Project
+        project: _chunkTWCDSYJNjs.Project
       }).parse(response);
       const projectId = result.project.id;
       this.nameToId[projectName] = projectId;
@@ -12170,10 +12429,10 @@ var ProjectNameIdMap = (_class15 = class {constructor() { _class15.prototype.__i
   }
   async getName(projectId) {
     if (!(projectId in this.idToName)) {
-      const response = await _chunkXLLGRXGRjs._internalGetGlobalState.call(void 0, ).appConn().post_json("api/project/get", {
+      const response = await _chunkTWCDSYJNjs._internalGetGlobalState.call(void 0, ).appConn().post_json("api/project/get", {
         id: projectId
       });
-      const result = _v3.z.array(_chunkXLLGRXGRjs.Project).nonempty().parse(response);
+      const result = _v3.z.array(_chunkTWCDSYJNjs.Project).nonempty().parse(response);
       const projectName = result[0].name;
       this.idToName[projectId] = projectName;
       this.nameToId[projectName] = projectId;
@@ -12193,16 +12452,16 @@ var ProjectNameIdMap = (_class15 = class {constructor() { _class15.prototype.__i
 var evalBodySchema = _v3.z.object({
   name: _v3.z.string(),
   parameters: _v3.z.record(_v3.z.string(), _v3.z.unknown()).nullish(),
-  data: _chunkXLLGRXGRjs.RunEval.shape.data,
+  data: _chunkTWCDSYJNjs.RunEval.shape.data,
   scores: _v3.z.array(
     _v3.z.object({
-      function_id: _chunkXLLGRXGRjs.FunctionId,
+      function_id: _chunkTWCDSYJNjs.FunctionId,
       name: _v3.z.string()
     })
   ).nullish(),
   experiment_name: _v3.z.string().nullish(),
   project_id: _v3.z.string().nullish(),
-  parent: _chunkXLLGRXGRjs.InvokeParent.optional(),
+  parent: _chunkTWCDSYJNjs.InvokeParent.optional(),
   stream: _v3.z.boolean().optional()
 });
 var staticParametersSchema = _v3.z.record(
@@ -12210,7 +12469,7 @@ var staticParametersSchema = _v3.z.record(
   _v3.z.union([
     _v3.z.object({
       type: _v3.z.literal("prompt"),
-      default: _chunkXLLGRXGRjs.PromptData.optional(),
+      default: _chunkTWCDSYJNjs.PromptData.optional(),
       description: _v3.z.string().optional()
     }),
     _v3.z.object({
@@ -12266,7 +12525,10 @@ var evaluatorDefinitionsSchema = _v3.z.record(
 );
 
 // src/node/index.ts
-_chunkXLLGRXGRjs.configureNode.call(void 0, );
+_chunkTWCDSYJNjs.configureNode.call(void 0, );
+
+
+
 
 
 
@@ -12449,4 +12711,4 @@ _chunkXLLGRXGRjs.configureNode.call(void 0, );
 
 
 
-exports.Attachment = _chunkXLLGRXGRjs.Attachment; exports.AttachmentReference = _chunkXLLGRXGRjs.AttachmentReference; exports.BAGGAGE_HEADER = _chunkXLLGRXGRjs.BAGGAGE_HEADER; exports.BRAINTRUST_CURRENT_SPAN_STORE = _chunkXLLGRXGRjs.BRAINTRUST_CURRENT_SPAN_STORE; exports.BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME = _chunkXLLGRXGRjs.BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME; exports.BRAINTRUST_PARENT_KEY = _chunkXLLGRXGRjs.BRAINTRUST_PARENT_KEY; exports.BaseAttachment = _chunkXLLGRXGRjs.BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BatchScorer = BatchScorer; exports.BatchTask = BatchTask; exports.BraintrustLangChainCallbackHandler = _chunkXLLGRXGRjs.BraintrustLangChainCallbackHandler; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustObservabilityExporter = _chunkXLLGRXGRjs.BraintrustObservabilityExporter; exports.BraintrustState = _chunkXLLGRXGRjs.BraintrustState; exports.BraintrustStream = _chunkXLLGRXGRjs.BraintrustStream; exports.CachedSpanFetcher = CachedSpanFetcher; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.ContextManager = _chunkXLLGRXGRjs.ContextManager; exports.DEFAULT_FETCH_BATCH_SIZE = _chunkXLLGRXGRjs.DEFAULT_FETCH_BATCH_SIZE; exports.DEFAULT_MAX_REQUEST_SIZE = _chunkXLLGRXGRjs.DEFAULT_MAX_REQUEST_SIZE; exports.Dataset = _chunkXLLGRXGRjs.Dataset; exports.DatasetPipeline = DatasetPipeline; exports.DurableEvalMemoryStore = DurableEvalMemoryStore; exports.DurableEvalRedisStore = DurableEvalRedisStore; exports.ERR_PERMALINK = _chunkXLLGRXGRjs.ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = _chunkXLLGRXGRjs.Experiment; exports.ExternalAttachment = _chunkXLLGRXGRjs.ExternalAttachment; exports.FailedHTTPResponse = _chunkXLLGRXGRjs.FailedHTTPResponse; exports.IDGenerator = _chunkXLLGRXGRjs.IDGenerator; exports.JSONAttachment = _chunkXLLGRXGRjs.JSONAttachment; exports.LEGACY_CACHED_HEADER = _chunkXLLGRXGRjs.LEGACY_CACHED_HEADER; exports.LOGS3_OVERFLOW_REFERENCE_TYPE = _chunkXLLGRXGRjs.LOGS3_OVERFLOW_REFERENCE_TYPE; exports.LazyValue = _chunkXLLGRXGRjs.LazyValue; exports.LocalTrace = LocalTrace; exports.Logger = _chunkXLLGRXGRjs.Logger; exports.LoginInvalidOrgError = _chunkXLLGRXGRjs.LoginInvalidOrgError; exports.NOOP_SPAN = _chunkXLLGRXGRjs.NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = _chunkXLLGRXGRjs.NOOP_SPAN_PERMALINK; exports.NoopSpan = _chunkXLLGRXGRjs.NoopSpan; exports.OTELIDGenerator = _chunkXLLGRXGRjs.OTELIDGenerator; exports.ObjectFetcher = _chunkXLLGRXGRjs.ObjectFetcher; exports.Project = Project2; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = _chunkXLLGRXGRjs.Prompt; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = _chunkXLLGRXGRjs.ReadonlyAttachment; exports.ReadonlyExperiment = _chunkXLLGRXGRjs.ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanFetcher = SpanFetcher; exports.SpanImpl = _chunkXLLGRXGRjs.SpanImpl; exports.TRACEPARENT_HEADER = _chunkXLLGRXGRjs.TRACEPARENT_HEADER; exports.TRACESTATE_HEADER = _chunkXLLGRXGRjs.TRACESTATE_HEADER; exports.TestBackgroundLogger = _chunkXLLGRXGRjs.TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.UUIDGenerator = _chunkXLLGRXGRjs.UUIDGenerator; exports.X_CACHED_HEADER = _chunkXLLGRXGRjs.X_CACHED_HEADER; exports._exportsForTestingOnly = _chunkXLLGRXGRjs._exportsForTestingOnly; exports._internalGetGlobalState = _chunkXLLGRXGRjs._internalGetGlobalState; exports._internalIso = _chunk6Z5S7VOUjs.isomorph_default; exports._internalSetInitialState = _chunkXLLGRXGRjs._internalSetInitialState; exports.addAzureBlobHeaders = _chunkXLLGRXGRjs.addAzureBlobHeaders; exports.agentAssertionScorer = agentAssertionScorer; exports.braintrustAISDKTelemetry = _chunkXLLGRXGRjs.braintrustAISDKTelemetry; exports.braintrustEveHook = braintrustEveHook; exports.braintrustEveInstrumentation = braintrustEveInstrumentation; exports.braintrustFlueInstrumentation = _chunkXLLGRXGRjs.braintrustFlueInstrumentation; exports.braintrustFlueObserver = _chunkXLLGRXGRjs.braintrustFlueObserver; exports.braintrustStreamChunkSchema = _chunkXLLGRXGRjs.braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.collectAnthropicSession = _chunkXLLGRXGRjs.collectAnthropicSession; exports.configureInstrumentation = _chunkXLLGRXGRjs.configureInstrumentation; exports.constructLogs3OverflowRequest = _chunkXLLGRXGRjs.constructLogs3OverflowRequest; exports.createFinalValuePassThroughStream = _chunkXLLGRXGRjs.createFinalValuePassThroughStream; exports.currentExperiment = _chunkXLLGRXGRjs.currentExperiment; exports.currentLogger = _chunkXLLGRXGRjs.currentLogger; exports.currentSpan = _chunkXLLGRXGRjs.currentSpan; exports.deepCopyEvent = _chunkXLLGRXGRjs.deepCopyEvent; exports.default = exports_exports; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.defineDurableEval = defineDurableEval; exports.deserializePlainStringAsJSON = _chunkXLLGRXGRjs.deserializePlainStringAsJSON; exports.devNullWritableStream = _chunkXLLGRXGRjs.devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.extractTraceContextFromHeaders = _chunkXLLGRXGRjs.extractTraceContextFromHeaders; exports.flush = _chunkXLLGRXGRjs.flush; exports.getContextManager = _chunkXLLGRXGRjs.getContextManager; exports.getIdGenerator = _chunkXLLGRXGRjs.getIdGenerator; exports.getPromptVersions = _chunkXLLGRXGRjs.getPromptVersions; exports.getSpanParentObject = _chunkXLLGRXGRjs.getSpanParentObject; exports.getTemplateRenderer = _chunkXLLGRXGRjs.getTemplateRenderer; exports.graph = graph_framework_exports; exports.init = _chunkXLLGRXGRjs.init; exports.initDataset = _chunkXLLGRXGRjs.initDataset; exports.initExperiment = _chunkXLLGRXGRjs.initExperiment; exports.initFunction = initFunction; exports.initLogger = _chunkXLLGRXGRjs.initLogger; exports.initNodeTestSuite = initNodeTestSuite; exports.injectTraceContext = _chunkXLLGRXGRjs.injectTraceContext; exports.invoke = invoke; exports.isTemplateFormat = _chunkXLLGRXGRjs.isTemplateFormat; exports.loadParameters = _chunkXLLGRXGRjs.loadParameters; exports.loadPrompt = _chunkXLLGRXGRjs.loadPrompt; exports.log = _chunkXLLGRXGRjs.log; exports.logError = _chunkXLLGRXGRjs.logError; exports.login = _chunkXLLGRXGRjs.login; exports.loginToState = _chunkXLLGRXGRjs.loginToState; exports.logs3OverflowUploadSchema = _chunkXLLGRXGRjs.logs3OverflowUploadSchema; exports.newId = _chunkXLLGRXGRjs.newId; exports.parseCachedHeader = _chunkXLLGRXGRjs.parseCachedHeader; exports.parseTemplateFormat = _chunkXLLGRXGRjs.parseTemplateFormat; exports.permalink = _chunkXLLGRXGRjs.permalink; exports.pickLogs3OverflowObjectIds = _chunkXLLGRXGRjs.pickLogs3OverflowObjectIds; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.registerOtelFlush = _chunkXLLGRXGRjs.registerOtelFlush; exports.registerSandbox = registerSandbox; exports.registerTemplatePlugin = _chunkXLLGRXGRjs.registerTemplatePlugin; exports.renderMessage = _chunkXLLGRXGRjs.renderMessage; exports.renderPromptParams = _chunkXLLGRXGRjs.renderPromptParams; exports.renderTemplateContent = _chunkXLLGRXGRjs.renderTemplateContent; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = _chunkXLLGRXGRjs.setFetch; exports.setMaskingFunction = _chunkXLLGRXGRjs.setMaskingFunction; exports.spanComponentsToObjectId = _chunkXLLGRXGRjs.spanComponentsToObjectId; exports.startSpan = _chunkXLLGRXGRjs.startSpan; exports.summarize = _chunkXLLGRXGRjs.summarize; exports.templateRegistry = _chunkXLLGRXGRjs.templateRegistry; exports.toolFunctionDefinitionSchema = _chunkXLLGRXGRjs.ToolFunctionDefinition; exports.traceable = _chunkXLLGRXGRjs.traceable; exports.traced = _chunkXLLGRXGRjs.traced; exports.updateSpan = _chunkXLLGRXGRjs.updateSpan; exports.uploadLogs3OverflowPayload = _chunkXLLGRXGRjs.uploadLogs3OverflowPayload; exports.utf8ByteLength = _chunkXLLGRXGRjs.utf8ByteLength; exports.withCurrent = _chunkXLLGRXGRjs.withCurrent; exports.withDataset = _chunkXLLGRXGRjs.withDataset; exports.withExperiment = _chunkXLLGRXGRjs.withExperiment; exports.withLogger = _chunkXLLGRXGRjs.withLogger; exports.withParent = _chunkXLLGRXGRjs.withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAgentClass = wrapAgentClass; exports.wrapAnthropic = wrapAnthropic; exports.wrapBedrockRuntime = wrapBedrockRuntime; exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK; exports.wrapCloudflareAIChat = wrapCloudflareAIChat; exports.wrapCloudflareAgent = wrapCloudflareAgent; exports.wrapCloudflareThink = wrapCloudflareThink; exports.wrapCohere = wrapCohere; exports.wrapCopilotClient = wrapCopilotClient; exports.wrapCursorSDK = wrapCursorSDK; exports.wrapGenkit = wrapGenkit; exports.wrapGoogleADK = wrapGoogleADK; exports.wrapGoogleGenAI = wrapGoogleGenAI; exports.wrapGroq = wrapGroq; exports.wrapHuggingFace = wrapHuggingFace; exports.wrapHuggingFaceTransformers = wrapHuggingFaceTransformers; exports.wrapLangSmithClient = wrapLangSmithClient; exports.wrapLangSmithRunTrees = wrapLangSmithRunTrees; exports.wrapLangSmithTraceable = wrapLangSmithTraceable; exports.wrapMastraAgent = _chunkXLLGRXGRjs.wrapMastraAgent; exports.wrapMistral = wrapMistral; exports.wrapOllama = wrapOllama; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAICodexSDK = wrapOpenAICodexSDK; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapOpenRouter = wrapOpenRouter; exports.wrapOpenRouterAgent = wrapOpenRouterAgent; exports.wrapPiCodingAgentSDK = wrapPiCodingAgentSDK; exports.wrapStrandsAgentSDK = wrapStrandsAgentSDK; exports.wrapTraced = _chunkXLLGRXGRjs.wrapTraced; exports.wrapVitest = wrapVitest; exports.wrapVoyageAI = wrapVoyageAI;
+exports.Attachment = _chunkTWCDSYJNjs.Attachment; exports.AttachmentReference = _chunkTWCDSYJNjs.AttachmentReference; exports.BAGGAGE_HEADER = _chunkTWCDSYJNjs.BAGGAGE_HEADER; exports.BRAINTRUST_CURRENT_SPAN_STORE = _chunkTWCDSYJNjs.BRAINTRUST_CURRENT_SPAN_STORE; exports.BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME = _chunkTWCDSYJNjs.BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME; exports.BRAINTRUST_PARENT_KEY = _chunkTWCDSYJNjs.BRAINTRUST_PARENT_KEY; exports.BaseAttachment = _chunkTWCDSYJNjs.BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BatchScorer = BatchScorer; exports.BatchTask = BatchTask; exports.BraintrustLangChainCallbackHandler = _chunkTWCDSYJNjs.BraintrustLangChainCallbackHandler; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustObservabilityExporter = _chunkTWCDSYJNjs.BraintrustObservabilityExporter; exports.BraintrustState = _chunkTWCDSYJNjs.BraintrustState; exports.BraintrustStream = _chunkTWCDSYJNjs.BraintrustStream; exports.CachedSpanFetcher = CachedSpanFetcher; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.ContextManager = _chunkTWCDSYJNjs.ContextManager; exports.DEFAULT_FETCH_BATCH_SIZE = _chunkTWCDSYJNjs.DEFAULT_FETCH_BATCH_SIZE; exports.DEFAULT_MAX_REQUEST_SIZE = _chunkTWCDSYJNjs.DEFAULT_MAX_REQUEST_SIZE; exports.Dataset = _chunkTWCDSYJNjs.Dataset; exports.DatasetPipeline = DatasetPipeline; exports.DurableEvalMemoryStore = DurableEvalMemoryStore; exports.DurableEvalRedisStore = DurableEvalRedisStore; exports.ERR_PERMALINK = _chunkTWCDSYJNjs.ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = _chunkTWCDSYJNjs.Experiment; exports.ExternalAttachment = _chunkTWCDSYJNjs.ExternalAttachment; exports.FailedHTTPResponse = _chunkTWCDSYJNjs.FailedHTTPResponse; exports.IDGenerator = _chunkTWCDSYJNjs.IDGenerator; exports.JSONAttachment = _chunkTWCDSYJNjs.JSONAttachment; exports.LEGACY_CACHED_HEADER = _chunkTWCDSYJNjs.LEGACY_CACHED_HEADER; exports.LOGS3_OVERFLOW_REFERENCE_TYPE = _chunkTWCDSYJNjs.LOGS3_OVERFLOW_REFERENCE_TYPE; exports.LazyValue = _chunkTWCDSYJNjs.LazyValue; exports.LocalTrace = LocalTrace; exports.Logger = _chunkTWCDSYJNjs.Logger; exports.LoginInvalidOrgError = _chunkTWCDSYJNjs.LoginInvalidOrgError; exports.NOOP_SPAN = _chunkTWCDSYJNjs.NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = _chunkTWCDSYJNjs.NOOP_SPAN_PERMALINK; exports.NoopSpan = _chunkTWCDSYJNjs.NoopSpan; exports.OTELIDGenerator = _chunkTWCDSYJNjs.OTELIDGenerator; exports.ObjectFetcher = _chunkTWCDSYJNjs.ObjectFetcher; exports.Project = Project2; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = _chunkTWCDSYJNjs.Prompt; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = _chunkTWCDSYJNjs.ReadonlyAttachment; exports.ReadonlyExperiment = _chunkTWCDSYJNjs.ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanFetcher = SpanFetcher; exports.SpanImpl = _chunkTWCDSYJNjs.SpanImpl; exports.TRACEPARENT_HEADER = _chunkTWCDSYJNjs.TRACEPARENT_HEADER; exports.TRACESTATE_HEADER = _chunkTWCDSYJNjs.TRACESTATE_HEADER; exports.TestBackgroundLogger = _chunkTWCDSYJNjs.TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.UUIDGenerator = _chunkTWCDSYJNjs.UUIDGenerator; exports.X_CACHED_HEADER = _chunkTWCDSYJNjs.X_CACHED_HEADER; exports._exportsForTestingOnly = _chunkTWCDSYJNjs._exportsForTestingOnly; exports._internalGetGlobalState = _chunkTWCDSYJNjs._internalGetGlobalState; exports._internalIso = _chunk2XDW3UCGjs.isomorph_default; exports._internalSetInitialState = _chunkTWCDSYJNjs._internalSetInitialState; exports.addAzureBlobHeaders = _chunkTWCDSYJNjs.addAzureBlobHeaders; exports.agentAssertionScorer = agentAssertionScorer; exports.braintrustAISDKTelemetry = _chunkTWCDSYJNjs.braintrustAISDKTelemetry; exports.braintrustEveHook = braintrustEveHook; exports.braintrustEveInstrumentation = braintrustEveInstrumentation; exports.braintrustFlueInstrumentation = _chunkTWCDSYJNjs.braintrustFlueInstrumentation; exports.braintrustFlueObserver = _chunkTWCDSYJNjs.braintrustFlueObserver; exports.braintrustStreamChunkSchema = _chunkTWCDSYJNjs.braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.collectAnthropicSession = _chunkTWCDSYJNjs.collectAnthropicSession; exports.completeOpenAIBatchTrace = completeOpenAIBatchTrace; exports.configureInstrumentation = _chunkTWCDSYJNjs.configureInstrumentation; exports.constructLogs3OverflowRequest = _chunkTWCDSYJNjs.constructLogs3OverflowRequest; exports.createFinalValuePassThroughStream = _chunkTWCDSYJNjs.createFinalValuePassThroughStream; exports.currentExperiment = _chunkTWCDSYJNjs.currentExperiment; exports.currentLogger = _chunkTWCDSYJNjs.currentLogger; exports.currentSpan = _chunkTWCDSYJNjs.currentSpan; exports.deepCopyEvent = _chunkTWCDSYJNjs.deepCopyEvent; exports.default = exports_exports; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.defineDurableEval = defineDurableEval; exports.deserializePlainStringAsJSON = _chunkTWCDSYJNjs.deserializePlainStringAsJSON; exports.devNullWritableStream = _chunkTWCDSYJNjs.devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.extractTraceContextFromHeaders = _chunkTWCDSYJNjs.extractTraceContextFromHeaders; exports.flush = _chunkTWCDSYJNjs.flush; exports.getContextManager = _chunkTWCDSYJNjs.getContextManager; exports.getIdGenerator = _chunkTWCDSYJNjs.getIdGenerator; exports.getPromptVersions = _chunkTWCDSYJNjs.getPromptVersions; exports.getSpanParentObject = _chunkTWCDSYJNjs.getSpanParentObject; exports.getTemplateRenderer = _chunkTWCDSYJNjs.getTemplateRenderer; exports.graph = graph_framework_exports; exports.init = _chunkTWCDSYJNjs.init; exports.initDataset = _chunkTWCDSYJNjs.initDataset; exports.initExperiment = _chunkTWCDSYJNjs.initExperiment; exports.initFunction = initFunction; exports.initLogger = _chunkTWCDSYJNjs.initLogger; exports.initNodeTestSuite = initNodeTestSuite; exports.injectTraceContext = _chunkTWCDSYJNjs.injectTraceContext; exports.invoke = invoke; exports.isTemplateFormat = _chunkTWCDSYJNjs.isTemplateFormat; exports.loadParameters = _chunkTWCDSYJNjs.loadParameters; exports.loadPrompt = _chunkTWCDSYJNjs.loadPrompt; exports.log = _chunkTWCDSYJNjs.log; exports.logError = _chunkTWCDSYJNjs.logError; exports.login = _chunkTWCDSYJNjs.login; exports.loginToState = _chunkTWCDSYJNjs.loginToState; exports.logs3OverflowUploadSchema = _chunkTWCDSYJNjs.logs3OverflowUploadSchema; exports.newId = _chunkTWCDSYJNjs.newId; exports.openaiBatchesRetrieveTraced = openaiBatchesRetrieveTraced; exports.openaiFilesCreateTraced = openaiFilesCreateTraced; exports.parseCachedHeader = _chunkTWCDSYJNjs.parseCachedHeader; exports.parseTemplateFormat = _chunkTWCDSYJNjs.parseTemplateFormat; exports.permalink = _chunkTWCDSYJNjs.permalink; exports.pickLogs3OverflowObjectIds = _chunkTWCDSYJNjs.pickLogs3OverflowObjectIds; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.registerOtelFlush = _chunkTWCDSYJNjs.registerOtelFlush; exports.registerSandbox = registerSandbox; exports.registerTemplatePlugin = _chunkTWCDSYJNjs.registerTemplatePlugin; exports.renderMessage = _chunkTWCDSYJNjs.renderMessage; exports.renderPromptParams = _chunkTWCDSYJNjs.renderPromptParams; exports.renderTemplateContent = _chunkTWCDSYJNjs.renderTemplateContent; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = _chunkTWCDSYJNjs.setFetch; exports.setMaskingFunction = _chunkTWCDSYJNjs.setMaskingFunction; exports.spanComponentsToObjectId = _chunkTWCDSYJNjs.spanComponentsToObjectId; exports.startSpan = _chunkTWCDSYJNjs.startSpan; exports.summarize = _chunkTWCDSYJNjs.summarize; exports.templateRegistry = _chunkTWCDSYJNjs.templateRegistry; exports.toolFunctionDefinitionSchema = _chunkTWCDSYJNjs.ToolFunctionDefinition; exports.traceable = _chunkTWCDSYJNjs.traceable; exports.traced = _chunkTWCDSYJNjs.traced; exports.updateSpan = _chunkTWCDSYJNjs.updateSpan; exports.uploadLogs3OverflowPayload = _chunkTWCDSYJNjs.uploadLogs3OverflowPayload; exports.utf8ByteLength = _chunkTWCDSYJNjs.utf8ByteLength; exports.withCurrent = _chunkTWCDSYJNjs.withCurrent; exports.withDataset = _chunkTWCDSYJNjs.withDataset; exports.withExperiment = _chunkTWCDSYJNjs.withExperiment; exports.withLogger = _chunkTWCDSYJNjs.withLogger; exports.withParent = _chunkTWCDSYJNjs.withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAgentClass = wrapAgentClass; exports.wrapAnthropic = wrapAnthropic; exports.wrapBedrockRuntime = wrapBedrockRuntime; exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK; exports.wrapCloudflareAIChat = wrapCloudflareAIChat; exports.wrapCloudflareAgent = wrapCloudflareAgent; exports.wrapCloudflareThink = wrapCloudflareThink; exports.wrapCohere = wrapCohere; exports.wrapCopilotClient = wrapCopilotClient; exports.wrapCursorSDK = wrapCursorSDK; exports.wrapGenkit = wrapGenkit; exports.wrapGoogleADK = wrapGoogleADK; exports.wrapGoogleGenAI = wrapGoogleGenAI; exports.wrapGroq = wrapGroq; exports.wrapHuggingFace = wrapHuggingFace; exports.wrapHuggingFaceTransformers = wrapHuggingFaceTransformers; exports.wrapLangSmithClient = wrapLangSmithClient; exports.wrapLangSmithRunTrees = wrapLangSmithRunTrees; exports.wrapLangSmithTraceable = wrapLangSmithTraceable; exports.wrapMastraAgent = _chunkTWCDSYJNjs.wrapMastraAgent; exports.wrapMistral = wrapMistral; exports.wrapOllama = wrapOllama; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAICodexSDK = wrapOpenAICodexSDK; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapOpenRouter = wrapOpenRouter; exports.wrapOpenRouterAgent = wrapOpenRouterAgent; exports.wrapPiCodingAgentSDK = wrapPiCodingAgentSDK; exports.wrapStrandsAgentSDK = wrapStrandsAgentSDK; exports.wrapTraced = _chunkTWCDSYJNjs.wrapTraced; exports.wrapVitest = wrapVitest; exports.wrapVoyageAI = wrapVoyageAI;