braintrust 3.28.0 → 3.29.0

package/dist/instrumentation/index.mjs

@@ -653,8 +653,6 @@ function newGlobalTracingChannel(nameOrChannels) {
 var DefaultAsyncLocalStorage = class {
   constructor() {
   }
-  enterWith(_) {
-  }
   run(_, callback) {
     return callback();
   }
@@ -2576,7 +2574,9 @@ var AclObjectType = z6.union([
     "project_log",
     "org_project",
     "org_audit_logs",
-    "project_group"
+    "project_group",
+    "ai_secret",
+    "org_ai_secret"
   ]),
   z6.null()
 ]);
@@ -3409,7 +3409,7 @@ var PromptParserNullish = z6.union([
   }),
   z6.null()
 ]);
-var PreprocessorSavedFunctionId = z6.union([
+var PreprocessorId = z6.union([
   z6.object({
     type: z6.literal("function"),
     id: z6.string(),
@@ -3420,6 +3420,7 @@ var PreprocessorSavedFunctionId = z6.union([
     name: z6.string(),
     function_type: z6.literal("preprocessor").optional().default("preprocessor")
   }),
+  z6.object({ type: z6.literal("inline"), code: z6.string().min(1) }),
   z6.null()
 ]);
 var PromptDataNullish = z6.union([
@@ -3427,7 +3428,7 @@ var PromptDataNullish = z6.union([
     prompt: PromptBlockDataNullish,
     options: PromptOptionsNullish,
     parser: PromptParserNullish,
-    preprocessor: PreprocessorSavedFunctionId,
+    preprocessor: PreprocessorId,
     tool_functions: z6.union([z6.array(SavedFunctionId), z6.null()]),
     template_format: z6.union([
       z6.enum(["mustache", "nunjucks", "none"]),
@@ -3629,7 +3630,7 @@ var PromptData = z6.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
   parser: PromptParserNullish,
-  preprocessor: PreprocessorSavedFunctionId,
+  preprocessor: PreprocessorId,
   tool_functions: z6.union([z6.array(SavedFunctionId), z6.null()]),
   template_format: z6.union([
     z6.enum(["mustache", "nunjucks", "none"]),
@@ -4573,6 +4574,7 @@ var View = z6.object({
   ]),
   name: z6.string(),
   description: z6.union([z6.string(), z6.null()]).optional(),
+  starred: z6.boolean().optional(),
   created: z6.union([z6.string(), z6.null()]).optional(),
   updated_at: z6.union([z6.string(), z6.null()]).optional(),
   view_data: ViewData.optional(),
@@ -4662,6 +4664,34 @@ var registerTemplatePlugin = templateRegistry.register.bind(templateRegistry);
 var getTemplateRenderer = templateRegistry.get.bind(templateRegistry);
 registerTemplatePlugin(mustachePlugin);
 
+// src/template/renderer.ts
+function isTemplateFormat(v) {
+  return v === "mustache" || v === "nunjucks" || v === "none";
+}
+function parseTemplateFormat(value, defaultFormat = "mustache") {
+  return isTemplateFormat(value) ? value : defaultFormat;
+}
+function renderTemplateContent(template, variables, escape, options) {
+  const strict = !!options.strict;
+  const templateFormat = parseTemplateFormat(options.templateFormat);
+  if (templateFormat === "none") {
+    return template;
+  }
+  const renderer = getTemplateRenderer(templateFormat);
+  if (!renderer) {
+    if (templateFormat === "nunjucks") {
+      throw new Error(
+        "Nunjucks templating requires @braintrust/template-nunjucks. Install and import it to enable templateFormat: 'nunjucks'."
+      );
+    }
+    throw new Error(`No template renderer registered for ${templateFormat}`);
+  }
+  if (strict && renderer.lint) {
+    renderer.lint(template, variables);
+  }
+  return renderer.render(template, variables, escape, strict);
+}
+
 // src/logger.ts
 import { z as z8, ZodError } from "zod/v3";
 
@@ -5248,44 +5278,72 @@ function createCacheLayers({
 }
 
 // src/prompt-cache/prompt-cache.ts
-function createCacheKey(key) {
+function createCacheKey(key, namespace) {
+  let cacheKey;
   if (key.id) {
-    return `id:${key.id}`;
-  }
-  const prefix = key.projectId ?? key.projectName;
-  if (!prefix) {
-    throw new Error("Either projectId or projectName must be provided");
-  }
-  if (!key.slug) {
-    throw new Error("Slug must be provided when not using ID");
+    cacheKey = `id:${key.id}`;
+  } else {
+    const prefix = key.projectId ?? key.projectName;
+    if (!prefix) {
+      throw new Error("Either projectId or projectName must be provided");
+    }
+    if (!key.slug) {
+      throw new Error("Slug must be provided when not using ID");
+    }
+    cacheKey = `${prefix}:${key.slug}:${key.version ?? "latest"}`;
   }
-  return `${prefix}:${key.slug}:${key.version ?? "latest"}`;
+  return namespace === void 0 ? cacheKey : `${namespace.length}:${namespace}:${cacheKey}`;
 }
-var PromptCache = class {
+var PromptCache = class _PromptCache {
   memoryCache;
   diskCache;
+  namespace;
+  expectedResolvedOrgIdentity;
   constructor(options) {
     this.memoryCache = options.memoryCache;
     this.diskCache = options.diskCache;
+    this.namespace = options.namespace;
+    this.expectedResolvedOrgIdentity = options.expectedResolvedOrgIdentity;
+  }
+  /**
+   * Returns a cache view that shares the same storage layers but isolates all
+   * entries under the provided namespace.
+   */
+  withNamespace(namespace, expectedResolvedOrgIdentity) {
+    return new _PromptCache({
+      memoryCache: this.memoryCache,
+      diskCache: this.diskCache,
+      namespace,
+      expectedResolvedOrgIdentity
+    });
   }
   /**
    * Retrieves a prompt from the cache.
    * First checks the in-memory LRU cache, then falls back to checking the disk cache if available.
    */
   async get(key) {
-    const cacheKey = createCacheKey(key);
+    const cacheKey = createCacheKey(key, this.namespace);
     if (this.memoryCache) {
-      const memoryPrompt = this.memoryCache.get(cacheKey);
-      if (memoryPrompt !== void 0) {
-        return memoryPrompt;
+      const memoryEntry = this.memoryCache.get(cacheKey);
+      if (memoryEntry !== void 0 && (this.expectedResolvedOrgIdentity === void 0 || memoryEntry.resolvedOrgIdentity === this.expectedResolvedOrgIdentity)) {
+        return memoryEntry.value;
       }
     }
     if (this.diskCache) {
-      const diskPrompt = await this.diskCache.get(cacheKey);
-      if (!diskPrompt) {
+      const diskEntry = await this.diskCache.get(cacheKey);
+      if (!diskEntry || this.expectedResolvedOrgIdentity !== void 0 && diskEntry.resolvedOrgIdentity !== this.expectedResolvedOrgIdentity) {
         return void 0;
       }
-      this.memoryCache?.set(cacheKey, diskPrompt);
+      const serializedPrompt = diskEntry.value;
+      const diskPrompt = new Prompt2(
+        serializedPrompt.metadata,
+        serializedPrompt.defaults,
+        serializedPrompt.noTrace
+      );
+      this.memoryCache?.set(cacheKey, {
+        value: diskPrompt,
+        resolvedOrgIdentity: diskEntry.resolvedOrgIdentity
+      });
       return diskPrompt;
     }
     return void 0;
@@ -5299,58 +5357,91 @@ var PromptCache = class {
    * @throws If there is an error writing to the disk cache.
    */
   async set(key, value) {
-    const cacheKey = createCacheKey(key);
-    this.memoryCache?.set(cacheKey, value);
+    const cacheKey = createCacheKey(key, this.namespace);
+    const memoryEntry = {
+      value,
+      resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+    };
+    this.memoryCache?.set(cacheKey, memoryEntry);
     if (this.diskCache) {
-      await this.diskCache.set(cacheKey, value);
+      await this.diskCache.set(cacheKey, {
+        value: value._internalSerializeForCache(),
+        resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+      });
     }
   }
 };
 
 // src/prompt-cache/parameters-cache.ts
-function createCacheKey2(key) {
+function createCacheKey2(key, namespace) {
+  let cacheKey;
   if (key.id) {
-    return `parameters:id:${key.id}`;
-  }
-  const prefix = key.projectId ?? key.projectName;
-  if (!prefix) {
-    throw new Error("Either projectId or projectName must be provided");
-  }
-  if (!key.slug) {
-    throw new Error("Slug must be provided when not using ID");
+    cacheKey = `parameters:id:${key.id}`;
+  } else {
+    const prefix = key.projectId ?? key.projectName;
+    if (!prefix) {
+      throw new Error("Either projectId or projectName must be provided");
+    }
+    if (!key.slug) {
+      throw new Error("Slug must be provided when not using ID");
+    }
+    cacheKey = `parameters:${prefix}:${key.slug}:${key.version ?? "latest"}`;
   }
-  return `parameters:${prefix}:${key.slug}:${key.version ?? "latest"}`;
+  return namespace === void 0 ? cacheKey : `${namespace.length}:${namespace}:${cacheKey}`;
 }
-var ParametersCache = class {
+var ParametersCache = class _ParametersCache {
   memoryCache;
   diskCache;
+  namespace;
+  expectedResolvedOrgIdentity;
   constructor(options) {
     this.memoryCache = options.memoryCache;
     this.diskCache = options.diskCache;
+    this.namespace = options.namespace;
+    this.expectedResolvedOrgIdentity = options.expectedResolvedOrgIdentity;
+  }
+  withNamespace(namespace, expectedResolvedOrgIdentity) {
+    return new _ParametersCache({
+      memoryCache: this.memoryCache,
+      diskCache: this.diskCache,
+      namespace,
+      expectedResolvedOrgIdentity
+    });
   }
   async get(key) {
-    const cacheKey = createCacheKey2(key);
+    const cacheKey = createCacheKey2(key, this.namespace);
     if (this.memoryCache) {
-      const memoryParams = this.memoryCache.get(cacheKey);
-      if (memoryParams !== void 0) {
-        return memoryParams;
+      const memoryEntry = this.memoryCache.get(cacheKey);
+      if (memoryEntry !== void 0 && (this.expectedResolvedOrgIdentity === void 0 || memoryEntry.resolvedOrgIdentity === this.expectedResolvedOrgIdentity)) {
+        return memoryEntry.value;
       }
     }
     if (this.diskCache) {
-      const diskParams = await this.diskCache.get(cacheKey);
-      if (!diskParams) {
+      const diskEntry = await this.diskCache.get(cacheKey);
+      if (!diskEntry || this.expectedResolvedOrgIdentity !== void 0 && diskEntry.resolvedOrgIdentity !== this.expectedResolvedOrgIdentity) {
         return void 0;
       }
-      this.memoryCache?.set(cacheKey, diskParams);
-      return diskParams;
+      const diskParameters = new RemoteEvalParameters(diskEntry.value.metadata);
+      this.memoryCache?.set(cacheKey, {
+        value: diskParameters,
+        resolvedOrgIdentity: diskEntry.resolvedOrgIdentity
+      });
+      return diskParameters;
     }
     return void 0;
   }
   async set(key, value) {
-    const cacheKey = createCacheKey2(key);
-    this.memoryCache?.set(cacheKey, value);
+    const cacheKey = createCacheKey2(key, this.namespace);
+    const memoryEntry = {
+      value,
+      resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+    };
+    this.memoryCache?.set(cacheKey, memoryEntry);
     if (this.diskCache) {
-      await this.diskCache.set(cacheKey, value);
+      await this.diskCache.set(cacheKey, {
+        value: value._internalSerializeForCache(),
+        resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+      });
     }
   }
 };
@@ -5654,6 +5745,7 @@ var INSTRUMENTATION_NAMES = {
   CLOUDFLARE_THINK: "cloudflare-think",
   COHERE: "cohere",
   CURSOR_SDK: "cursor-sdk",
+  DEEPSEEK_HARNESS: "deepseek-harness",
   EVE: "eve",
   FLUE: "flue",
   GENKIT: "genkit",
@@ -5679,7 +5771,7 @@ var INSTRUMENTATION_NAMES = {
 var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
   "braintrust.spanInstrumentationName"
 );
-var SDK_VERSION = true ? "3.28.0" : "0.0.0";
+var SDK_VERSION = true ? "3.29.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -5798,6 +5890,16 @@ var datasetSnapshotRegisterResponseSchema = z8.object({
   dataset_snapshot: DatasetSnapshot,
   found_existing: z8.boolean().optional()
 });
+var datasetObjectInfoSchema = z8.object({
+  object_id: z8.string(),
+  object_name: z8.string(),
+  parent_cols: z8.object({
+    project: z8.object({
+      id: z8.string(),
+      name: z8.string()
+    })
+  })
+});
 var datasetRestorePreviewResultSchema = z8.object({
   rows_to_restore: z8.number(),
   rows_to_delete: z8.number()
@@ -6011,12 +6113,53 @@ var loginSchema = z8.strictObject({
 });
 var stateNonce = 0;
 var V1_PROXY_SUFFIX = "/v1/proxy";
+var LOADER_LOGIN_CACHE_MAX = 16;
 function normalizeProxyConnUrl(proxyUrl) {
   return proxyUrl.endsWith(V1_PROXY_SUFFIX) ? proxyUrl.slice(0, proxyUrl.length - V1_PROXY_SUFFIX.length) : proxyUrl;
 }
 var BraintrustState = class _BraintrustState {
+  id;
+  currentExperiment;
+  // Note: the value of IsAsyncFlush doesn't really matter here, since we
+  // (safely) dynamically cast it whenever retrieving the logger.
+  currentLogger;
+  currentParent;
+  currentSpan;
+  // Any time we re-log in, we directly update the apiConn inside the logger.
+  // This is preferable to replacing the whole logger, which would create the
+  // possibility of multiple loggers floating around, which may not log in a
+  // deterministic order.
+  _bgLogger;
+  _overrideBgLogger = null;
+  appUrl = null;
+  appPublicUrl = null;
+  loginToken = null;
+  orgId = null;
+  orgName = null;
+  apiUrl = null;
+  proxyUrl = null;
+  loggedIn = false;
+  gitMetadataSettings;
+  debugLogLevel;
+  debugLogLevelConfigured = false;
+  fetch = globalThis.fetch;
+  _appConn = null;
+  _apiConn = null;
+  _proxyConn = null;
+  promptCache;
+  parametersCache;
+  spanCache;
+  _idGenerator = null;
+  _contextManager = null;
+  _otelFlushCallback = null;
+  spanOriginEnvironment;
+  traceContextSigningSecret;
+  loaderLoginCache = /* @__PURE__ */ new WeakMap();
+  loginParams;
+  activeLoginOrgNameSelector;
   constructor(loginParams) {
-    this.loginParams = loginParams;
+    this.loginParams = { ...loginParams };
+    this.activeLoginOrgNameSelector = loginParams.orgName ?? isomorph_default.getEnv("BRAINTRUST_ORG_NAME");
     this.id = `${(/* @__PURE__ */ new Date()).toLocaleString()}-${stateNonce++}`;
     this.currentExperiment = void 0;
     this.currentLogger = void 0;
@@ -6053,12 +6196,14 @@ var BraintrustState = class _BraintrustState {
     const {
       memoryCache: parametersMemoryCache,
       diskCache: parametersDiskCache
-    } = createCacheLayers({
-      memoryMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX",
-      diskCacheDirEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DIR",
-      diskMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DISK_MAX",
-      getDefaultDiskCacheDir: () => `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/parameters_cache`
-    });
+    } = createCacheLayers(
+      {
+        memoryMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX",
+        diskCacheDirEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DIR",
+        diskMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DISK_MAX",
+        getDefaultDiskCacheDir: () => `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/parameters_cache`
+      }
+    );
     this.parametersCache = new ParametersCache({
       memoryCache: parametersMemoryCache,
       diskCache: parametersDiskCache
@@ -6067,43 +6212,6 @@ var BraintrustState = class _BraintrustState {
     this.spanOriginEnvironment = detectSpanOriginEnvironment();
     this._internalSetTraceContextSigningSecret(loginParams.apiKey);
   }
-  loginParams;
-  id;
-  currentExperiment;
-  // Note: the value of IsAsyncFlush doesn't really matter here, since we
-  // (safely) dynamically cast it whenever retrieving the logger.
-  currentLogger;
-  currentParent;
-  currentSpan;
-  // Any time we re-log in, we directly update the apiConn inside the logger.
-  // This is preferable to replacing the whole logger, which would create the
-  // possibility of multiple loggers floating around, which may not log in a
-  // deterministic order.
-  _bgLogger;
-  _overrideBgLogger = null;
-  appUrl = null;
-  appPublicUrl = null;
-  loginToken = null;
-  orgId = null;
-  orgName = null;
-  apiUrl = null;
-  proxyUrl = null;
-  loggedIn = false;
-  gitMetadataSettings;
-  debugLogLevel;
-  debugLogLevelConfigured = false;
-  fetch = globalThis.fetch;
-  _appConn = null;
-  _apiConn = null;
-  _proxyConn = null;
-  promptCache;
-  parametersCache;
-  spanCache;
-  _idGenerator = null;
-  _contextManager = null;
-  _otelFlushCallback = null;
-  spanOriginEnvironment;
-  traceContextSigningSecret;
   /** @internal */
   _internalSetTraceContextSigningSecret(secret) {
     const normalizedSecret = secret?.trim();
@@ -6128,6 +6236,101 @@ var BraintrustState = class _BraintrustState {
     this._appConn = null;
     this._apiConn = null;
     this._proxyConn = null;
+    this.loaderLoginCache = /* @__PURE__ */ new WeakMap();
+  }
+  /** @internal */
+  async _internalResolveLoaderLoginOptions({
+    apiKey,
+    appUrl,
+    orgName,
+    fetch: fetch2,
+    forceLogin
+  }) {
+    const resolvedAppUrl = appUrl ?? (this.loggedIn ? this.appUrl ?? void 0 : void 0) ?? this.loginParams.appUrl ?? isomorph_default.getEnv("BRAINTRUST_APP_URL") ?? "https://www.braintrust.dev";
+    const resolvedApiKey = apiKey ?? (this.loggedIn ? this.loginToken ?? void 0 : void 0) ?? this.loginParams.apiKey ?? await isomorph_default.getBraintrustApiKey();
+    if (!resolvedApiKey) {
+      throw new Error(
+        "Please specify an api key (e.g. by setting BRAINTRUST_API_KEY)."
+      );
+    }
+    const normalizedApiKey = HTTPConnection.sanitize_token(resolvedApiKey);
+    const usesActiveCredential = this.loggedIn && normalizedApiKey === this.loginToken;
+    const requestedOrgName = orgName ?? (usesActiveCredential ? this.activeLoginOrgNameSelector : void 0) ?? this.loginParams.orgName ?? isomorph_default.getEnv("BRAINTRUST_ORG_NAME");
+    const resolvedOrgName = orgName ?? (usesActiveCredential ? this.orgName ?? void 0 : void 0) ?? requestedOrgName;
+    const resolvedFetch = fetch2 ?? (this.loggedIn ? this.fetch : void 0) ?? this.loginParams.fetch ?? globalThis.fetch;
+    const credentialCacheNamespace = JSON.stringify([
+      "loader-credential",
+      resolvedAppUrl,
+      requestedOrgName,
+      normalizedApiKey
+    ]);
+    return {
+      apiKey: normalizedApiKey,
+      appUrl: resolvedAppUrl,
+      orgName: resolvedOrgName,
+      fetch: resolvedFetch,
+      forceLogin,
+      credentialCacheNamespace,
+      existingState: !forceLogin && usesActiveCredential && resolvedAppUrl === this.appUrl && resolvedOrgName === this.orgName && resolvedFetch === this.fetch ? this : void 0
+    };
+  }
+  /** @internal */
+  _internalGetLoaderCacheViews(loginOptions, requestState) {
+    const expectedResolvedOrgIdentity = requestState?.orgId && requestState.appUrl ? JSON.stringify([
+      "loader-org",
+      requestState.appUrl,
+      requestState.orgId
+    ]) : void 0;
+    return {
+      promptCache: this.promptCache.withNamespace(
+        loginOptions.credentialCacheNamespace,
+        expectedResolvedOrgIdentity
+      ),
+      parametersCache: this.parametersCache.withNamespace(
+        loginOptions.credentialCacheNamespace,
+        expectedResolvedOrgIdentity
+      )
+    };
+  }
+  /** @internal */
+  async _internalGetLoaderState({
+    apiKey,
+    appUrl,
+    orgName,
+    fetch: fetch2,
+    forceLogin,
+    existingState
+  }) {
+    if (existingState) {
+      return existingState;
+    }
+    let cache = this.loaderLoginCache.get(fetch2);
+    if (!cache) {
+      cache = new LRUCache({ max: LOADER_LOGIN_CACHE_MAX });
+      this.loaderLoginCache.set(fetch2, cache);
+    }
+    const cacheKey = JSON.stringify([appUrl, orgName, apiKey]);
+    if (!forceLogin) {
+      const cachedState = cache.get(cacheKey);
+      if (cachedState) {
+        return cachedState;
+      }
+    }
+    const statePromise = loginToLoaderRequestState({
+      orgName,
+      apiKey,
+      appUrl,
+      fetch: fetch2
+    });
+    cache.set(cacheKey, statePromise);
+    try {
+      return await statePromise;
+    } catch (error) {
+      if (cache.get(cacheKey) === statePromise) {
+        cache.delete(cacheKey);
+      }
+      throw error;
+    }
   }
   resetIdGenState() {
     this._idGenerator = null;
@@ -6176,6 +6379,8 @@ var BraintrustState = class _BraintrustState {
     this.debugLogLevel = other.debugLogLevel;
     this.debugLogLevelConfigured = other.debugLogLevelConfigured;
     this.traceContextSigningSecret = other.traceContextSigningSecret;
+    this.fetch = other.fetch;
+    this.activeLoginOrgNameSelector = other.activeLoginOrgNameSelector;
     setGlobalDebugLogLevel(
       this.debugLogLevelConfigured ? this.debugLogLevel ?? false : void 0
     );
@@ -6370,36 +6575,76 @@ var FailedHTTPResponse = class extends Error {
   status;
   text;
   data;
-  constructor(status, text, data) {
+  cause;
+  constructor(status, text, data, cause) {
     super(`${status}: ${text} (${data})`);
     this.status = status;
     this.text = text;
     this.data = data;
+    this.cause = cause;
+  }
+};
+var HTTPTransportError = class extends Error {
+  cause;
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.name = "HTTPTransportError";
+    this.cause = cause;
   }
 };
+var httpTransportErrorCauses = /* @__PURE__ */ new WeakSet();
+function recordHTTPTransportError(error) {
+  if (typeof error === "object" && error !== null || typeof error === "function") {
+    httpTransportErrorCauses.add(error);
+  }
+}
+function rethrowHTTPTransportError(error, classifyTransportErrors) {
+  if (classifyTransportErrors) {
+    throw new HTTPTransportError(error);
+  }
+  recordHTTPTransportError(error);
+  throw error;
+}
+async function readJSONResponse(response, classifyTransportErrors = false) {
+  let data;
+  try {
+    data = await response.text();
+  } catch (error) {
+    rethrowHTTPTransportError(error, classifyTransportErrors);
+  }
+  return JSON.parse(data);
+}
 async function checkResponse(resp) {
   if (resp.ok) {
     return resp;
-  } else {
+  }
+  let data;
+  try {
+    data = await resp.text();
+  } catch (error) {
     throw new FailedHTTPResponse(
       resp.status,
       resp.statusText,
-      await resp.text()
+      "Unable to read response body",
+      error
     );
   }
+  throw new FailedHTTPResponse(resp.status, resp.statusText, data);
 }
 var HTTPConnection = class _HTTPConnection {
-  base_url;
-  token;
-  headers;
-  fetch;
-  constructor(base_url, fetch2) {
+  constructor(base_url, fetch2, classifyTransportErrors = false) {
+    this.classifyTransportErrors = classifyTransportErrors;
     this.base_url = base_url;
     this.token = null;
     this.headers = {};
     this._reset();
     this.fetch = fetch2;
   }
+  classifyTransportErrors;
+  base_url;
+  token;
+  headers;
+  fetch;
   setFetch(fetch2) {
     this.fetch = fetch2;
   }
@@ -6439,9 +6684,9 @@ var HTTPConnection = class _HTTPConnection {
     ).toString();
     const this_fetch = this.fetch;
     const this_headers = this.headers;
-    return await checkResponse(
-      // Using toString() here makes it work with isomorphic fetch
-      await this_fetch(url.toString(), {
+    let response;
+    try {
+      response = await this_fetch(url.toString(), {
         headers: {
           Accept: "application/json",
           ...this_headers,
@@ -6449,8 +6694,14 @@ var HTTPConnection = class _HTTPConnection {
         },
         keepalive: true,
         ...rest
-      })
-    );
+      });
+    } catch (error) {
+      if (config?.signal?.aborted) {
+        throw getAbortReason(config.signal);
+      }
+      rethrowHTTPTransportError(error, this.classifyTransportErrors);
+    }
+    return await checkResponse(response);
   }
   async post(path, params, config, retries = 0) {
     const { headers, ...rest } = config || {};
@@ -6460,8 +6711,9 @@ var HTTPConnection = class _HTTPConnection {
     const tries = retries + 1;
     for (let i = 0; i < tries; i++) {
       try {
-        return await checkResponse(
-          await this_fetch(_urljoin(this_base_url, path), {
+        let response;
+        try {
+          response = await this_fetch(_urljoin(this_base_url, path), {
             method: "POST",
             headers: {
               Accept: "application/json",
@@ -6472,8 +6724,14 @@ var HTTPConnection = class _HTTPConnection {
             body: typeof params === "string" ? params : params ? JSON.stringify(params) : void 0,
             keepalive: true,
             ...rest
-          })
-        );
+          });
+        } catch (error) {
+          if (config?.signal?.aborted) {
+            throw getAbortReason(config.signal);
+          }
+          rethrowHTTPTransportError(error, this.classifyTransportErrors);
+        }
+        return await checkResponse(response);
       } catch (error) {
         if (config?.signal?.aborted) {
           throw getAbortReason(config.signal);
@@ -6498,7 +6756,7 @@ var HTTPConnection = class _HTTPConnection {
     for (let i = 0; i < tries; i++) {
       try {
         const resp = await this.get(`${object_type}`, args);
-        return await resp.json();
+        return await readJSONResponse(resp, this.classifyTransportErrors);
       } catch (e) {
         if (i < tries - 1) {
           debugLogger.debug(
@@ -6521,7 +6779,7 @@ var HTTPConnection = class _HTTPConnection {
     const resp = await this.post(`${object_type}`, args, {
       headers: { "Content-Type": "application/json" }
     });
-    return await resp.json();
+    return await readJSONResponse(resp, this.classifyTransportErrors);
   }
   // Custom inspect for Node.js console.log
   [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
@@ -8076,6 +8334,52 @@ function initLogger(options = {}) {
   }
   return ret;
 }
+async function loginToLoaderRequestState({
+  appUrl,
+  apiKey,
+  orgName,
+  fetch: fetch2
+}) {
+  let orgId;
+  let apiUrl;
+  if (apiKey === TEST_API_KEY) {
+    orgId = "test-org-id";
+    apiUrl = "https://braintrust.dev/fake-api-url";
+  } else {
+    let loginResponse;
+    try {
+      loginResponse = await fetch2(_urljoin(appUrl, `/api/apikey/login`), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+    } catch (error) {
+      throw new HTTPTransportError(error);
+    }
+    const info = await readJSONResponse(
+      await checkResponse(loginResponse),
+      true
+    );
+    const org = selectLoginOrg(info.org_info, orgName);
+    orgId = org.id;
+    apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
+    if (!apiUrl) {
+      throw new Error(
+        orgName ? `Unable to log into organization '${orgName}'. Are you sure this credential is scoped to the organization?` : "Unable to log into any organization with the provided credential."
+      );
+    }
+  }
+  const apiConnection = new HTTPConnection(apiUrl, fetch2, true);
+  apiConnection.set_token(apiKey);
+  apiConnection.make_long_lived();
+  return {
+    appUrl,
+    orgId,
+    apiConn: () => apiConnection
+  };
+}
 async function loginToState(options = {}) {
   const {
     appUrl = isomorph_default.getEnv("BRAINTRUST_APP_URL") || "https://www.braintrust.dev",
@@ -8107,16 +8411,18 @@ async function loginToState(options = {}) {
     _saveOrgInfo(state, testOrgInfo, testOrgInfo[0].name);
     return state;
   } else {
-    const resp = await checkResponse(
-      await fetch2(_urljoin(state.appUrl, `/api/apikey/login`), {
+    const loginResponse = await fetch2(
+      _urljoin(state.appUrl, `/api/apikey/login`),
+      {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${apiKey}`
         }
-      })
+      }
     );
-    const info = await resp.json();
+    const resp = await checkResponse(loginResponse);
+    const info = await readJSONResponse(resp);
     _saveOrgInfo(state, info.org_info, orgName);
     if (!state.apiUrl) {
       if (orgName) {
@@ -8484,27 +8790,28 @@ function withCurrent(span, callback, state = void 0) {
   const currentState = state ?? _globalState;
   return currentState.contextManager.runInContext(span, () => callback(span));
 }
-function _saveOrgInfo(state, org_info, org_name) {
-  if (org_info.length === 0) {
+function _saveOrgInfo(state, orgInfo, orgName) {
+  const org = selectLoginOrg(orgInfo, orgName);
+  state.orgId = org.id;
+  state.orgName = org.name;
+  state.apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
+  state.proxyUrl = isomorph_default.getEnv("BRAINTRUST_PROXY_URL") ?? org.proxy_url;
+  state.gitMetadataSettings = org.git_metadata || void 0;
+}
+function selectLoginOrg(orgInfo, orgName) {
+  if (orgInfo.length === 0) {
     throw new LoginInvalidOrgError(
       "This user is not part of any organizations."
     );
   }
-  for (const org of org_info) {
-    if (org_name === void 0 || org.name === org_name) {
-      state.orgId = org.id;
-      state.orgName = org.name;
-      state.apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
-      state.proxyUrl = isomorph_default.getEnv("BRAINTRUST_PROXY_URL") ?? org.proxy_url;
-      state.gitMetadataSettings = org.git_metadata || void 0;
-      break;
+  for (const org of orgInfo) {
+    if (orgName === void 0 || org.name === orgName) {
+      return org;
     }
   }
-  if (state.orgId === void 0) {
-    throw new LoginInvalidOrgError(
-      `Organization ${org_name} not found. Must be one of ${org_info.map((x) => x.name).join(", ")}`
-    );
-  }
+  throw new LoginInvalidOrgError(
+    `Organization ${orgName} not found. Must be one of ${orgInfo.map((org) => org.name).join(", ")}`
+  );
 }
 function validateTags(tags) {
   const seen = /* @__PURE__ */ new Set();
@@ -8669,6 +8976,19 @@ function enrichAttachments(event, state) {
   }
   return event;
 }
+async function resolveAttachmentsToBase64(event, state) {
+  for (const [key, value] of Object.entries(event)) {
+    if (value instanceof ReadonlyAttachment) {
+      event[key] = await value.asBase64Url();
+      continue;
+    }
+    if (!(value instanceof Object)) {
+      continue;
+    }
+    await resolveAttachmentsToBase64(value, state);
+  }
+  return event;
+}
 function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
   if ("input" in event && !isEmpty2(event.input) && "inputs" in event && !isEmpty2(event.inputs) || !("input" in event) && !("inputs" in event)) {
     throw new Error(
@@ -9958,6 +10278,473 @@ var Dataset2 = class extends ObjectFetcher {
     return typeof data === "object" && data !== null && "__braintrust_dataset_marker" in data;
   }
 };
+function isAttachmentObject(value) {
+  return BraintrustAttachmentReference.safeParse(value).success || InlineAttachmentReferenceSchema.safeParse(value).success || ExternalAttachmentReference.safeParse(value).success;
+}
+function isURL(url) {
+  try {
+    const parsedUrl = new URL(url.trim());
+    return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function expandAttachmentArrayPreTemplate(content, variables) {
+  if (typeof content !== "string") return null;
+  const match = content.match(/^\{\{\s*([\w.]+)\s*\}\}$/);
+  if (!match) return null;
+  const varPath = match[1];
+  const value = varPath.includes(".") ? getObjValueByPath(variables, varPath.split(".")) : variables[varPath];
+  if (!Array.isArray(value)) return null;
+  const allValid = value.every(
+    (v) => isAttachmentObject(v) || typeof v === "string" && isURL(v)
+  );
+  if (!allValid) return null;
+  return value.map((item) => ({
+    type: "image_url",
+    image_url: { url: item }
+  }));
+}
+function renderMessageImpl(render, message, variables) {
+  return {
+    ...message,
+    ..."content" in message ? {
+      content: isEmpty2(message.content) ? void 0 : typeof message.content === "string" ? render(message.content) : message.content.flatMap((c) => {
+        switch (c.type) {
+          case "text":
+            return [{ ...c, text: render(c.text) }];
+          case "image_url":
+            if (isObject(c.image_url.url)) {
+              throw new Error(
+                "Attachments must be replaced with URLs before calling `build()`"
+              );
+            }
+            if (variables) {
+              const expanded = expandAttachmentArrayPreTemplate(
+                c.image_url.url,
+                variables
+              );
+              if (expanded) {
+                return expanded;
+              }
+            }
+            return [
+              {
+                ...c,
+                image_url: {
+                  ...c.image_url,
+                  url: render(c.image_url.url)
+                }
+              }
+            ];
+          case "file":
+            return [
+              {
+                ...c,
+                file: {
+                  ...c.file.file_data && {
+                    file_data: render(c.file.file_data)
+                  },
+                  ...c.file.file_id && {
+                    file_id: render(c.file.file_id)
+                  },
+                  ...c.file.filename && {
+                    filename: render(c.file.filename)
+                  }
+                }
+              }
+            ];
+          default:
+            const _exhaustiveCheck = c;
+            return _exhaustiveCheck;
+        }
+      })
+    } : {},
+    ..."tool_calls" in message ? {
+      tool_calls: isEmpty2(message.tool_calls) ? void 0 : message.tool_calls.map((t) => {
+        return {
+          type: t.type,
+          id: render(t.id),
+          function: {
+            name: render(t.function.name),
+            arguments: render(t.function.arguments)
+          }
+        };
+      })
+    } : {},
+    ..."tool_call_id" in message ? {
+      tool_call_id: render(message.tool_call_id)
+    } : {}
+  };
+}
+function deserializePlainStringAsJSON(s) {
+  if (s.trim() === "") {
+    return { value: null, error: void 0 };
+  }
+  try {
+    return { value: JSON.parse(s), error: void 0 };
+  } catch (e) {
+    return { value: s, error: e };
+  }
+}
+function renderTemplatedObject(obj, args, options) {
+  if (typeof obj === "string") {
+    return renderTemplateContent(
+      obj,
+      args,
+      (value) => typeof value === "string" ? value : JSON.stringify(value),
+      {
+        strict: options.strict,
+        templateFormat: options.templateFormat
+      }
+    );
+  } else if (isArray(obj)) {
+    return obj.map((item) => renderTemplatedObject(item, args, options));
+  } else if (isObject(obj)) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        renderTemplatedObject(value, args, options)
+      ])
+    );
+  }
+  return obj;
+}
+function renderPromptParams(params, args, options = {}) {
+  const templateFormat = parseTemplateFormat(options.templateFormat);
+  const strict = !!options.strict;
+  const schemaParsed = z8.object({
+    response_format: z8.object({
+      type: z8.literal("json_schema"),
+      json_schema: ResponseFormatJsonSchema.omit({ schema: true }).extend({
+        schema: z8.unknown()
+      })
+    })
+  }).safeParse(params);
+  if (schemaParsed.success) {
+    const rawSchema = schemaParsed.data.response_format.json_schema.schema;
+    const templatedSchema = renderTemplatedObject(rawSchema, args, {
+      strict,
+      templateFormat
+    });
+    const parsedSchema = typeof templatedSchema === "string" ? deserializePlainStringAsJSON(templatedSchema).value : templatedSchema;
+    return {
+      ...params,
+      response_format: {
+        ...schemaParsed.data.response_format,
+        json_schema: {
+          ...schemaParsed.data.response_format.json_schema,
+          schema: parsedSchema
+        }
+      }
+    };
+  }
+  return params;
+}
+var Prompt2 = class _Prompt {
+  constructor(metadata, defaults, noTrace) {
+    this.metadata = metadata;
+    this.defaults = defaults;
+    this.noTrace = noTrace;
+    void this.__braintrust_prompt_marker;
+  }
+  metadata;
+  defaults;
+  noTrace;
+  parsedPromptData;
+  hasParsedPromptData = false;
+  __braintrust_prompt_marker = true;
+  get id() {
+    return this.metadata.id;
+  }
+  get projectId() {
+    return this.metadata.project_id;
+  }
+  get name() {
+    return "name" in this.metadata ? this.metadata.name : `Playground function ${this.metadata.id}`;
+  }
+  get slug() {
+    return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
+  }
+  get prompt() {
+    return this.getParsedPromptData()?.prompt;
+  }
+  get version() {
+    return this.metadata[TRANSACTION_ID_FIELD];
+  }
+  get options() {
+    return this.getParsedPromptData()?.options || {};
+  }
+  get templateFormat() {
+    return this.getParsedPromptData()?.template_format;
+  }
+  get promptData() {
+    return this.getParsedPromptData();
+  }
+  /**
+   * Build the prompt with the given formatting options. The args you pass in will
+   * be forwarded to the mustache template that defines the prompt and rendered with
+   * the `mustache-js` library.
+   *
+   * @param buildArgs Args to forward along to the prompt template.
+   */
+  build(buildArgs, options = {}) {
+    return this.runBuild(buildArgs, {
+      flavor: options.flavor ?? "chat",
+      messages: options.messages,
+      strict: options.strict,
+      templateFormat: options.templateFormat
+    });
+  }
+  /**
+   * This is a special build method that first resolves attachment references, and then
+   * calls the regular build method. You should use this if you are building prompts from
+   * dataset rows that contain attachments.
+   *
+   * @param buildArgs Args to forward along to the prompt template.
+   */
+  async buildWithAttachments(buildArgs, options = {}) {
+    const hydrated = buildArgs instanceof Object ? await resolveAttachmentsToBase64(buildArgs, options.state) : buildArgs;
+    return this.runBuild(hydrated, {
+      flavor: options.flavor ?? "chat",
+      messages: options.messages,
+      strict: options.strict,
+      templateFormat: options.templateFormat
+    });
+  }
+  runBuild(buildArgs, options) {
+    const { flavor } = options;
+    const params = Object.fromEntries(
+      Object.entries({
+        ...this.defaults,
+        ...Object.fromEntries(
+          Object.entries(this.options.params || {}).filter(
+            ([k, _v]) => !BRAINTRUST_PARAMS.includes(k)
+          )
+        ),
+        ...!isEmpty2(this.options.model) ? {
+          model: this.options.model
+        } : {}
+      }).filter(([key, value]) => key !== "response_format" || value !== null)
+    );
+    if (!("model" in params) || isEmpty2(params.model)) {
+      throw new Error(
+        "No model specified. Either specify it in the prompt or as a default"
+      );
+    }
+    const spanInfo = this.noTrace ? {} : {
+      span_info: {
+        metadata: {
+          prompt: this.id ? {
+            variables: buildArgs,
+            id: this.id,
+            project_id: this.projectId,
+            version: this.version,
+            ..."prompt_session_id" in this.metadata ? { prompt_session_id: this.metadata.prompt_session_id } : {}
+          } : void 0
+        }
+      }
+    };
+    const prompt = this.prompt;
+    if (!prompt) {
+      throw new Error("Empty prompt");
+    }
+    const dictArgParsed = z8.record(z8.unknown()).safeParse(buildArgs);
+    const variables = {
+      input: buildArgs,
+      ...dictArgParsed.success ? dictArgParsed.data : {}
+    };
+    const promptDataTemplateFormat = this.templateFormat;
+    const resolvedTemplateFormat = parseTemplateFormat(
+      options.templateFormat ?? promptDataTemplateFormat
+    );
+    const renderedPrompt = _Prompt.renderPrompt({
+      prompt,
+      buildArgs,
+      options: { ...options, templateFormat: resolvedTemplateFormat }
+    });
+    if (flavor === "chat") {
+      if (renderedPrompt.type !== "chat") {
+        throw new Error(
+          "Prompt is a completion prompt. Use buildCompletion() instead"
+        );
+      }
+      return {
+        ...renderPromptParams(params, variables, {
+          strict: options.strict,
+          templateFormat: resolvedTemplateFormat
+        }),
+        ...spanInfo,
+        messages: renderedPrompt.messages,
+        ...renderedPrompt.tools ? {
+          tools: ChatCompletionTool.array().parse(JSON.parse(renderedPrompt.tools))
+        } : void 0
+      };
+    } else if (flavor === "completion") {
+      if (renderedPrompt.type !== "completion") {
+        throw new Error(`Prompt is a chat prompt. Use flavor: 'chat' instead`);
+      }
+      return {
+        ...renderPromptParams(params, variables, {
+          strict: options.strict,
+          templateFormat: resolvedTemplateFormat
+        }),
+        ...spanInfo,
+        prompt: renderedPrompt.content
+      };
+    } else {
+      throw new Error("never!");
+    }
+  }
+  static renderPrompt({
+    prompt,
+    buildArgs,
+    options
+  }) {
+    const escape = (v) => {
+      if (v === void 0) {
+        throw new Error("Missing!");
+      } else if (typeof v === "string") {
+        return v;
+      } else if (v instanceof ReadonlyAttachment) {
+        throw new Error(
+          "Use buildWithAttachments() to build prompts with attachments"
+        );
+      } else {
+        return JSON.stringify(v);
+      }
+    };
+    const dictArgParsed = z8.record(z8.unknown()).safeParse(buildArgs);
+    const variables = {
+      input: buildArgs,
+      ...dictArgParsed.success ? dictArgParsed.data : {}
+    };
+    const templateFormat = parseTemplateFormat(options.templateFormat);
+    if (prompt.type === "chat") {
+      const render = (template) => renderTemplateContent(template, variables, escape, {
+        strict: options.strict,
+        templateFormat
+      });
+      const baseMessages = (prompt.messages || []).map(
+        (m) => renderMessageImpl(render, m, variables)
+      );
+      const hasSystemPrompt = baseMessages.some((m) => m.role === "system");
+      const messages = [
+        ...baseMessages,
+        ...(options.messages ?? []).filter(
+          (m) => !(hasSystemPrompt && m.role === "system")
+        )
+      ];
+      return {
+        type: "chat",
+        messages,
+        ...prompt.tools?.trim() ? {
+          tools: render(prompt.tools)
+        } : void 0
+      };
+    } else if (prompt.type === "completion") {
+      if (options.messages) {
+        throw new Error(
+          "extra messages are not supported for completion prompts"
+        );
+      }
+      const content = renderTemplateContent(prompt.content, variables, escape, {
+        strict: options.strict,
+        templateFormat
+      });
+      return {
+        type: "completion",
+        content
+      };
+    } else {
+      const _ = prompt;
+      throw new Error(`Invalid prompt type: ${_}`);
+    }
+  }
+  getParsedPromptData() {
+    if (!this.hasParsedPromptData) {
+      this.parsedPromptData = PromptData.parse(this.metadata.prompt_data);
+      this.hasParsedPromptData = true;
+    }
+    return this.parsedPromptData;
+  }
+  static isPrompt(data) {
+    return typeof data === "object" && data !== null && "__braintrust_prompt_marker" in data;
+  }
+  /** @internal */
+  _internalSerializeForCache() {
+    return {
+      metadata: this.metadata,
+      defaults: this.defaults,
+      noTrace: this.noTrace
+    };
+  }
+  static fromPromptData(name, promptData) {
+    return new _Prompt(
+      {
+        name,
+        slug: name,
+        prompt_data: promptData
+      },
+      {},
+      false
+    );
+  }
+};
+var RemoteEvalParameters = class {
+  constructor(metadata) {
+    this.metadata = metadata;
+    void this.__braintrust_parameters_marker;
+  }
+  metadata;
+  __braintrust_parameters_marker = true;
+  get id() {
+    return this.metadata.id;
+  }
+  get projectId() {
+    return this.metadata.project_id;
+  }
+  get name() {
+    return this.metadata.name;
+  }
+  get slug() {
+    return this.metadata.slug;
+  }
+  get version() {
+    return this.metadata[TRANSACTION_ID_FIELD];
+  }
+  get schema() {
+    return this.metadata.function_data.__schema;
+  }
+  get data() {
+    return this.metadata.function_data.data ?? {};
+  }
+  /** @internal */
+  _internalSerializeForCache() {
+    return { metadata: this.metadata };
+  }
+  validate(data) {
+    if (typeof data !== "object" || data === null) {
+      return false;
+    }
+    const schemaProps = this.schema.properties;
+    if (typeof schemaProps !== "object" || schemaProps === null) {
+      return true;
+    }
+    for (const key of Object.keys(schemaProps)) {
+      if (!(key in data)) {
+        const required = Array.isArray(this.schema.required) ? this.schema.required : [];
+        if (required.includes(key)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  static isParameters(x) {
+    return typeof x === "object" && x !== null && "__braintrust_parameters_marker" in x && x.__braintrust_parameters_marker === true;
+  }
+};
 var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
 
 // src/instrumentation/core/channel-tracing-utils.ts
@@ -10403,56 +11190,14 @@ function suppressionStore() {
   autoInstrumentationSuppressionStore ??= isomorph_default.newAsyncLocalStorage();
   return autoInstrumentationSuppressionStore;
 }
-function currentFrames() {
-  return suppressionStore().getStore()?.frames ?? [];
-}
 function isAutoInstrumentationSuppressed() {
-  const frames = currentFrames();
-  return frames[frames.length - 1]?.mode === "suppress";
+  return suppressionStore().getStore() === true;
 }
 function runWithAutoInstrumentationSuppressed(callback) {
-  const frame = {
-    id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-suppress"),
-    mode: "suppress"
-  };
-  return suppressionStore().run(
-    { frames: [...currentFrames(), frame] },
-    callback
-  );
+  return suppressionStore().run(true, callback);
 }
-function bindAutoInstrumentationSuppressionToStart(tracingChannel) {
-  const startChannel = tracingChannel.start;
-  if (!startChannel) {
-    return void 0;
-  }
-  const store = suppressionStore();
-  startChannel.bindStore(store, () => ({
-    frames: [
-      ...currentFrames(),
-      {
-        id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-suppress"),
-        mode: "suppress"
-      }
-    ]
-  }));
-  return () => {
-    startChannel.unbindStore(store);
-  };
-}
-function enterAutoInstrumentationAllowed() {
-  const frame = {
-    id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-allow"),
-    mode: "allow"
-  };
-  suppressionStore().enterWith({
-    frames: [...currentFrames(), frame]
-  });
-  return () => {
-    const frames = currentFrames().filter(
-      (candidate) => candidate.id !== frame.id
-    );
-    suppressionStore().enterWith(frames.length > 0 ? { frames } : void 0);
-  };
+function runWithAutoInstrumentationAllowed(callback) {
+  return suppressionStore().run(void 0, callback);
 }
 
 // src/instrumentation/core/channel-tracing.ts
@@ -11741,13 +12486,33 @@ function aggregateChatLogprobs(existing, incoming) {
   }
   return aggregated;
 }
+function createAggregatedChatChoice(index) {
+  return {
+    index,
+    role: void 0,
+    content: void 0,
+    refusal: void 0,
+    toolCallsByIndex: /* @__PURE__ */ new Map(),
+    logprobs: void 0,
+    finish_reason: void 0
+  };
+}
+function toChatChoice(choice) {
+  const toolCalls = Array.from(choice.toolCallsByIndex.entries()).sort(([left], [right]) => left - right).map(([, toolCall]) => toolCall);
+  return {
+    index: choice.index,
+    message: {
+      role: choice.role,
+      content: choice.content,
+      ...choice.refusal !== void 0 ? { refusal: choice.refusal } : {},
+      tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+    },
+    logprobs: choice.logprobs ?? null,
+    finish_reason: choice.finish_reason
+  };
+}
 function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
-  let role = void 0;
-  let content = void 0;
-  let refusal = void 0;
-  let tool_calls = void 0;
-  let logprobs = void 0;
-  let finish_reason = void 0;
+  const choicesByIndex = /* @__PURE__ */ new Map();
   let metrics = {};
   for (const chunk of chunks) {
     if (chunk.usage) {
@@ -11756,62 +12521,75 @@ function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
         ...parseMetricsFromUsage(chunk.usage)
       };
     }
-    const choice = chunk.choices?.[0];
-    if (!choice) {
-      continue;
-    }
-    if (choice.finish_reason) {
-      finish_reason = choice.finish_reason;
-    }
-    logprobs = aggregateChatLogprobs(logprobs, choice.logprobs);
-    const delta = choice.delta;
-    if (!delta) {
+    const choices = chunk.choices;
+    if (!choices?.length) {
       continue;
     }
-    if (delta.finish_reason) {
-      finish_reason = delta.finish_reason;
-    }
-    if (!role && delta.role) {
-      role = delta.role;
-    }
-    if (delta.content) {
-      content = (content || "") + delta.content;
-    }
-    if (delta.refusal) {
-      refusal = (refusal || "") + delta.refusal;
-    }
-    if (delta.tool_calls) {
-      const toolDelta = delta.tool_calls[0];
-      if (!tool_calls || toolDelta.id && tool_calls[tool_calls.length - 1].id !== toolDelta.id) {
-        tool_calls = [
-          ...tool_calls || [],
-          {
-            id: toolDelta.id,
-            type: toolDelta.type,
-            function: toolDelta.function
+    for (const choice of choices) {
+      const choiceIndex = choice.index;
+      let aggregatedChoice = choicesByIndex.get(choiceIndex);
+      if (!aggregatedChoice) {
+        aggregatedChoice = createAggregatedChatChoice(choiceIndex);
+        choicesByIndex.set(choiceIndex, aggregatedChoice);
+      }
+      if (choice.finish_reason) {
+        aggregatedChoice.finish_reason = choice.finish_reason;
+      }
+      aggregatedChoice.logprobs = aggregateChatLogprobs(
+        aggregatedChoice.logprobs,
+        choice.logprobs
+      );
+      const delta = choice.delta;
+      if (!delta) {
+        continue;
+      }
+      if (delta.finish_reason) {
+        aggregatedChoice.finish_reason = delta.finish_reason;
+      }
+      if (!aggregatedChoice.role && delta.role) {
+        aggregatedChoice.role = delta.role;
+      }
+      if (delta.content) {
+        aggregatedChoice.content = (aggregatedChoice.content || "") + delta.content;
+      }
+      if (delta.refusal) {
+        aggregatedChoice.refusal = (aggregatedChoice.refusal || "") + delta.refusal;
+      }
+      if (delta.tool_calls) {
+        for (const toolDelta of delta.tool_calls) {
+          let aggregatedToolCall = aggregatedChoice.toolCallsByIndex.get(
+            toolDelta.index
+          );
+          if (!aggregatedToolCall) {
+            aggregatedToolCall = {
+              function: { arguments: "" }
+            };
+            aggregatedChoice.toolCallsByIndex.set(
+              toolDelta.index,
+              aggregatedToolCall
+            );
           }
-        ];
-      } else {
-        tool_calls[tool_calls.length - 1].function.arguments += toolDelta.function.arguments;
+          if (toolDelta.id !== void 0) {
+            aggregatedToolCall.id = toolDelta.id;
+          }
+          if (toolDelta.type !== void 0) {
+            aggregatedToolCall.type = toolDelta.type;
+          }
+          if (toolDelta.function?.name !== void 0) {
+            aggregatedToolCall.function.name = toolDelta.function.name;
+          }
+          if (toolDelta.function?.arguments !== void 0) {
+            aggregatedToolCall.function.arguments += toolDelta.function.arguments;
+          }
+        }
       }
     }
   }
   metrics = withCachedMetric(metrics, streamResult, endEvent);
+  const output = Array.from(choicesByIndex.values()).sort((left, right) => left.index - right.index).map(toChatChoice);
   return {
     metrics,
-    output: [
-      {
-        index: 0,
-        message: {
-          role,
-          content,
-          ...refusal !== void 0 ? { refusal } : {},
-          tool_calls
-        },
-        logprobs: logprobs ?? null,
-        finish_reason
-      }
-    ]
+    output: output.length > 0 ? output : [toChatChoice(createAggregatedChatChoice(0))]
   };
 }
 function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
@@ -13134,6 +13912,12 @@ function parseMetricsFromUsage2(usage) {
       }
     }
   }
+  if (isObject(usage.output_tokens_details)) {
+    const thinkingTokens = usage.output_tokens_details.thinking_tokens;
+    if (typeof thinkingTokens === "number") {
+      metrics.completion_reasoning_tokens = thinkingTokens;
+    }
+  }
   if (isObject(usage.server_tool_use)) {
     for (const [name, value] of Object.entries(usage.server_tool_use)) {
       if (typeof value === "number") {
@@ -14090,7 +14874,6 @@ function endHarnessTurn(parent) {
 function braintrustAISDKTelemetry() {
   const operations = /* @__PURE__ */ new Map();
   const operationKeysByCallId = /* @__PURE__ */ new Map();
-  const workflowOperationKeyStore = isomorph_default.newAsyncLocalStorage();
   const modelSpans = /* @__PURE__ */ new Map();
   const objectSpans = /* @__PURE__ */ new Map();
   const embedSpans = /* @__PURE__ */ new Map();
@@ -14133,9 +14916,6 @@ function braintrustAISDKTelemetry() {
       return;
     }
     operations.delete(operationKey);
-    if (workflowOperationKeyStore.getStore() === operationKey) {
-      workflowOperationKeyStore.enterWith(void 0);
-    }
     const keys = operationKeysByCallId.get(state.callId);
     if (!keys) {
       return;
@@ -14183,14 +14963,7 @@ function braintrustAISDKTelemetry() {
         return key;
       }
     }
-    const workflowOperationKey = workflowOperationKeyStore.getStore();
-    if (workflowOperationKey && keys.includes(workflowOperationKey)) {
-      return workflowOperationKey;
-    }
-    if (callId === "workflow-agent") {
-      return void 0;
-    }
-    return mode === "finish" ? keys[0] : keys[keys.length - 1];
+    return callId === "workflow-agent" || mode === "active" ? keys[keys.length - 1] : keys[0];
   };
   const operationKeyFromEvent = (event, mode = "active") => {
     const explicit = explicitOperationKey(event);
@@ -14204,17 +14977,13 @@ function braintrustAISDKTelemetry() {
         if (operationKey) {
           return operationKey;
         }
-        const workflowOperationKey2 = workflowOperationKeyStore.getStore();
-        if (workflowOperationKey2 && operations.has(workflowOperationKey2)) {
-          return workflowOperationKey2;
+        const workflowAgentKeys2 = operationKeysByCallId.get("workflow-agent");
+        if (workflowAgentKeys2?.length) {
+          return workflowAgentKeys2[workflowAgentKeys2.length - 1];
         }
         return callId === "workflow-agent" ? void 0 : callId;
       }
     }
-    const workflowOperationKey = workflowOperationKeyStore.getStore();
-    if (workflowOperationKey && operations.has(workflowOperationKey)) {
-      return workflowOperationKey;
-    }
     const wrapperSpan = currentWorkflowAgentWrapperSpan();
     if (wrapperSpan?.spanId) {
       for (const [operationKey, state] of operations) {
@@ -14224,8 +14993,8 @@ function braintrustAISDKTelemetry() {
       }
     }
     const workflowAgentKeys = operationKeysByCallId.get("workflow-agent");
-    if (workflowAgentKeys?.length === 1) {
-      return workflowAgentKeys[0];
+    if (workflowAgentKeys?.length) {
+      return workflowAgentKeys[workflowAgentKeys.length - 1];
     }
     if (operations.size === 1) {
       return operations.keys().next().value;
@@ -14428,9 +15197,6 @@ function braintrustAISDKTelemetry() {
         if (!ownsSpan) {
           return;
         }
-        if (workflowAgent) {
-          workflowOperationKeyStore.enterWith(operationKey);
-        }
         let metadata = metadataFromEvent(event);
         const logPayload = { metadata };
         const workflowAgentCallInput = workflowAgent ? operationInput(event, operationName) : void 0;
@@ -14902,6 +15668,10 @@ var aiSDKChannels = defineChannels(
       channelName: "generateText",
       kind: "async"
     }),
+    generateImage: channel({
+      channelName: "generateImage",
+      kind: "async"
+    }),
     streamText: channel({
       channelName: "streamText",
       kind: "async"
@@ -15089,7 +15859,7 @@ var AISDKPlugin = class extends BasePlugin {
   }
   subscribeToAISDK() {
     const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
-    this.unsubscribers.push(subscribeToAISDKV7TelemetryDispatcher());
+    this.unsubscribers.push(interceptAISDKV7TelemetryDispatcher());
     this.unsubscribers.push(subscribeToHarnessAgentCreateSession());
     this.unsubscribers.push(
       subscribeToHarnessContinuation(
@@ -15117,6 +15887,18 @@ var AISDKPlugin = class extends BasePlugin {
         aggregateChunks: aggregateAISDKChunks
       })
     );
+    this.unsubscribers.push(
+      traceAsyncChannel(aiSDKChannels.generateImage, {
+        name: "generateImage",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event) => prepareAISDKGenerateImageInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKGenerateImageOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result) => extractTokenMetrics(result)
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.streamText, {
         name: "streamText",
@@ -15606,26 +16388,29 @@ function subscribeToHarnessContinuation(continuationChannel, defaultDenyOutputPa
     channel2.unsubscribe(handlers);
   };
 }
-function subscribeToAISDKV7TelemetryDispatcher() {
-  const channel2 = aiSDKChannels.v7CreateTelemetryDispatcher.tracingChannel();
+function interceptAISDKV7TelemetryDispatcher() {
   const telemetry = braintrustAISDKTelemetry();
-  const handlers = {
-    end: (event) => {
-      const telemetryOptions = event.arguments?.[0]?.telemetry;
-      if (telemetryOptions?.isEnabled === false) {
-        return;
+  return aiSDKChannels.v7CreateTelemetryDispatcher.intercept(
+    (target, thisArg, args) => {
+      const dispatcher = Reflect.apply(target, thisArg, args);
+      const telemetryOptions = args[0]?.telemetry;
+      if (telemetryOptions?.isEnabled !== false) {
+        try {
+          patchAISDKV7TelemetryDispatcher(
+            dispatcher,
+            telemetry,
+            telemetryOptions
+          );
+        } catch (error) {
+          debugLogger.error(
+            "Error instrumenting AI SDK v7 telemetry dispatcher:",
+            error
+          );
+        }
       }
-      patchAISDKV7TelemetryDispatcher(
-        event.result,
-        telemetry,
-        telemetryOptions
-      );
+      return dispatcher;
     }
-  };
-  channel2.subscribe(handlers);
-  return () => {
-    channel2.unsubscribe(handlers);
-  };
+  );
 }
 function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry, telemetryOptions) {
   if (!isObject(dispatcher)) {
@@ -15950,16 +16735,10 @@ var convertImageToAttachment = (image, explicitMimeType) => {
       }
     }
     if (explicitMimeType) {
-      if (image instanceof Uint8Array) {
-        return new Attachment({
-          data: new Blob([image], { type: explicitMimeType }),
-          filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
-          contentType: explicitMimeType
-        });
-      }
-      if (typeof Buffer !== "undefined" && Buffer.isBuffer(image)) {
+      const blob = convertDataToBlob(image, explicitMimeType);
+      if (blob) {
         return new Attachment({
-          data: new Blob([image], { type: explicitMimeType }),
+          data: blob,
           filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
           contentType: explicitMimeType
         });
@@ -16013,6 +16792,25 @@ var convertDataToAttachment = (data, mimeType, filename) => {
 function processAISDKCallInput(params) {
   return processInputAttachmentsSync(params);
 }
+function processAISDKGenerateImageInput(params) {
+  const prompt = params.prompt;
+  if (!isObject(prompt) || Array.isArray(prompt)) {
+    return processAISDKCallInput(params);
+  }
+  const processedPrompt = { ...prompt };
+  if (Array.isArray(prompt.images)) {
+    processedPrompt.images = prompt.images.map(
+      (image) => convertImageToAttachment(image, "image/png") ?? image
+    );
+  }
+  if (prompt.mask !== void 0) {
+    processedPrompt.mask = convertImageToAttachment(prompt.mask, "image/png") ?? prompt.mask;
+  }
+  return processAISDKCallInput({
+    ...params,
+    prompt: processedPrompt
+  });
+}
 function processAISDKWorkflowAgentCallInput(params) {
   const processed = processAISDKCallInput(params);
   return {
@@ -16151,6 +16949,12 @@ function prepareAISDKEmbedInput(params, self) {
     metadata: extractMetadataFromEmbedParams(params, self)
   };
 }
+function prepareAISDKGenerateImageInput(params, self) {
+  return {
+    input: processAISDKGenerateImageInput(params).input,
+    metadata: extractMetadataFromCallParams(params, self)
+  };
+}
 function prepareAISDKRerankInput(params, self) {
   const { documents, query } = params;
   return {
@@ -17526,6 +18330,57 @@ function processAISDKOutput(output, denyOutputPaths) {
   }
   return normalizeAISDKLoggedOutput(sanitized);
 }
+function processAISDKGenerateImageOutput(output, denyOutputPaths) {
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const summarized = {};
+  for (const field of [
+    "usage",
+    "warnings",
+    "providerMetadata",
+    "experimental_providerMetadata",
+    "responses"
+  ]) {
+    const value = safeSerializableFieldRead(output, field);
+    if (value !== void 0 && isSerializableOutputValue(value)) {
+      summarized[field] = value;
+    }
+  }
+  const images = safeSerializableFieldRead(output, "images");
+  const image = safeSerializableFieldRead(output, "image");
+  const generatedFiles = Array.isArray(images) && images.length > 0 ? images : image !== void 0 ? [image] : [];
+  const loggedOutput = normalizeAISDKLoggedOutput(
+    omit(summarized, denyOutputPaths)
+  );
+  if (generatedFiles.length > 0) {
+    loggedOutput.images = generatedFiles.map(
+      (file, index) => convertAISDKGeneratedFileToAttachment(file, index)
+    );
+  }
+  return loggedOutput;
+}
+function convertAISDKGeneratedFileToAttachment(file, index) {
+  if (!file || typeof file !== "object") {
+    return file;
+  }
+  const generatedFile = file;
+  const generatedMediaType = safeSerializableFieldRead(
+    generatedFile,
+    "mediaType"
+  );
+  const mediaType = typeof generatedMediaType === "string" ? generatedMediaType : "application/octet-stream";
+  const data = safeSerializableFieldRead(generatedFile, "base64") ?? safeSerializableFieldRead(generatedFile, "uint8Array");
+  const blob = convertDataToBlob(data, mediaType);
+  if (blob) {
+    return new Attachment({
+      data: blob,
+      filename: `generated_image_${index}.${getExtensionFromMediaType(mediaType)}`,
+      contentType: mediaType
+    });
+  }
+  return file;
+}
 function processAISDKEmbeddingOutput(output, denyOutputPaths) {
   if (!output || typeof output !== "object") {
     return output;
@@ -18026,118 +18881,22 @@ var claudeAgentSDKChannels = defineChannels(
 var CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION = "__braintrust_skip_local_tool_hooks";
 
 // src/instrumentation/plugins/claude-agent-sdk-local-tool-context.ts
-var LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED = /* @__PURE__ */ Symbol.for(
-  "braintrust.claude_agent_sdk.local_tool_context_async_iterator_patched"
-);
-function createLocalToolContextStore() {
-  const maybeIsoWithAsyncLocalStorage = isomorph_default;
-  if (typeof maybeIsoWithAsyncLocalStorage.newAsyncLocalStorage === "function") {
-    return maybeIsoWithAsyncLocalStorage.newAsyncLocalStorage();
-  }
-  let currentStore;
-  return {
-    enterWith(store) {
-      currentStore = store;
-    },
-    getStore() {
-      return currentStore;
-    },
-    run(store, callback) {
-      const previousStore = currentStore;
-      currentStore = store;
-      try {
-        return callback();
-      } finally {
-        currentStore = previousStore;
-      }
-    }
-  };
-}
-var localToolContextStore = createLocalToolContextStore();
-var fallbackLocalToolParentResolver;
-function createClaudeLocalToolContext() {
-  return {};
-}
-function runWithClaudeLocalToolContext(callback, context) {
-  return localToolContextStore.run(
-    context ?? createClaudeLocalToolContext(),
-    callback
-  );
+var localToolContextStore = isomorph_default.newAsyncLocalStorage();
+var localToolParentResolversByToolUseId = /* @__PURE__ */ new Map();
+function runWithClaudeLocalToolContext(callback, resolver) {
+  return localToolContextStore.run(resolver, callback);
 }
-function ensureClaudeLocalToolContext() {
-  const existing = localToolContextStore.getStore();
-  if (existing) {
-    return existing;
-  }
-  const created = {};
-  localToolContextStore.enterWith(created);
-  return created;
+function registerClaudeLocalToolParentResolver(toolUseId, resolver) {
+  localToolParentResolversByToolUseId.set(toolUseId, resolver);
 }
-function setClaudeLocalToolParentResolver(resolver) {
-  fallbackLocalToolParentResolver = resolver;
-  const context = ensureClaudeLocalToolContext();
-  if (!context) {
-    return;
+function getClaudeLocalToolParentResolver(toolUseId) {
+  const currentResolver = localToolContextStore.getStore();
+  if (!toolUseId) {
+    return currentResolver;
   }
-  context.resolveLocalToolParent = resolver;
-}
-function getClaudeLocalToolParentResolver() {
-  return localToolContextStore.getStore()?.resolveLocalToolParent ?? fallbackLocalToolParentResolver;
-}
-function isAsyncIterable3(value) {
-  return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
-}
-function bindClaudeLocalToolContextToAsyncIterable(result, localToolContext) {
-  if (!isAsyncIterable3(result) || Object.isFrozen(result) || Object.isSealed(result)) {
-    return result;
-  }
-  const stream = result;
-  const originalAsyncIterator = stream[Symbol.asyncIterator];
-  if (originalAsyncIterator[LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED]) {
-    return result;
-  }
-  const patchedAsyncIterator = function() {
-    return runWithClaudeLocalToolContext(() => {
-      const iterator = Reflect.apply(originalAsyncIterator, this, []);
-      if (!iterator || typeof iterator !== "object") {
-        return iterator;
-      }
-      const patchMethod = (methodName) => {
-        const originalMethod = Reflect.get(iterator, methodName);
-        if (typeof originalMethod !== "function") {
-          return;
-        }
-        Reflect.set(
-          iterator,
-          methodName,
-          (...args) => runWithClaudeLocalToolContext(
-            () => Reflect.apply(
-              originalMethod,
-              iterator,
-              args
-            ),
-            localToolContext
-          )
-        );
-      };
-      patchMethod("next");
-      patchMethod("return");
-      patchMethod("throw");
-      return iterator;
-    }, localToolContext);
-  };
-  Object.defineProperty(
-    patchedAsyncIterator,
-    LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED,
-    {
-      configurable: false,
-      enumerable: false,
-      value: true,
-      writable: false
-    }
-  );
-  Reflect.set(stream, Symbol.asyncIterator, patchedAsyncIterator);
-  return result;
+  const registeredResolver = localToolParentResolversByToolUseId.get(toolUseId);
+  localToolParentResolversByToolUseId.delete(toolUseId);
+  return currentResolver ?? registeredResolver;
 }
 
 // src/instrumentation/plugins/claude-agent-sdk-local-tool-spans.ts
@@ -18163,7 +18922,7 @@ function wrapLocalClaudeToolHandler(handler, getMetadata) {
     const metadata = getMetadata();
     const rawToolName = metadata.serverName ? `mcp__${metadata.serverName}__${metadata.toolName}` : metadata.toolName;
     const toolUseId = getToolUseIdFromExtra(handlerArgs[1]);
-    const localToolParentResolver = getClaudeLocalToolParentResolver();
+    const localToolParentResolver = getClaudeLocalToolParentResolver(toolUseId);
     const spanName = metadata.serverName ? `tool: ${metadata.serverName}/${metadata.toolName}` : `tool: ${metadata.toolName}`;
     const runWithResolvedParent = async () => {
       const parent = toolUseId && localToolParentResolver ? await localToolParentResolver(toolUseId).catch(() => void 0) : void 0;
@@ -18690,6 +19449,7 @@ function createToolTracingHooks(resolveParentSpan, taskIdToToolUseId, toolUseToP
       }
     }
     if (skipLocalToolHooks && (isLocalToolUse(input.tool_name, mcpServers) || localToolHookNames.has(input.tool_name))) {
+      registerClaudeLocalToolParentResolver(toolUseID, resolveParentSpan);
       return {};
     }
     const parsed = parseToolName(input.tool_name);
@@ -19400,7 +20160,7 @@ async function finalizeQuerySpan(state) {
 }
 var ClaudeAgentSDKPlugin = class extends BasePlugin {
   onEnable() {
-    this.subscribeToQuery();
+    this.interceptQuery();
   }
   onDisable() {
     for (const unsubscribe of this.unsubscribers) {
@@ -19408,211 +20168,218 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
     }
     this.unsubscribers = [];
   }
-  subscribeToQuery() {
-    const channel2 = claudeAgentSDKChannels.query.tracingChannel();
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const params = event.arguments[0] ?? {};
-        const originalPrompt = params.prompt;
-        const options = params.options ?? {};
-        const promptIsAsyncIterable = isAsyncIterable(originalPrompt);
-        let promptStarted = false;
-        let capturedPromptMessages;
-        let resolvePromptDone;
-        const promptDone = new Promise((resolve) => {
-          resolvePromptDone = resolve;
-        });
-        if (promptIsAsyncIterable) {
-          capturedPromptMessages = [];
-          const promptStream = originalPrompt;
-          params.prompt = (async function* () {
-            promptStarted = true;
-            try {
-              for await (const message of promptStream) {
-                capturedPromptMessages.push(message);
-                yield message;
-              }
-            } finally {
-              resolvePromptDone?.();
+  interceptQuery() {
+    const startQuery = (params) => {
+      const originalPrompt = params.prompt;
+      const options = params.options ?? {};
+      const promptIsAsyncIterable = isAsyncIterable(originalPrompt);
+      let promptStarted = false;
+      let capturedPromptMessages;
+      let resolvePromptDone;
+      const promptDone = new Promise((resolve) => {
+        resolvePromptDone = resolve;
+      });
+      if (promptIsAsyncIterable) {
+        capturedPromptMessages = [];
+        const promptStream = originalPrompt;
+        params.prompt = (async function* () {
+          promptStarted = true;
+          try {
+            for await (const message of promptStream) {
+              capturedPromptMessages.push(message);
+              yield message;
             }
-          })();
-        }
-        const span = startSpan(
-          withSpanInstrumentationName(
-            {
-              name: "Claude Agent",
-              spanAttributes: {
-                type: "task" /* TASK */
-              }
-            },
-            INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
-          )
-        );
-        const startTime = getCurrentUnixTimestamp();
-        try {
-          span.log({
-            input: typeof originalPrompt === "string" ? originalPrompt : promptIsAsyncIterable ? void 0 : originalPrompt !== void 0 ? String(originalPrompt) : void 0,
-            metadata: filterSerializableOptions(options)
-          });
-        } catch (error) {
-          console.error("Error extracting input for Claude Agent SDK:", error);
-        }
-        const activeToolSpans = /* @__PURE__ */ new Map();
-        const activeLlmSpansByParentToolUse = /* @__PURE__ */ new Map();
-        const conversationHistoryByParentKey = /* @__PURE__ */ new Map();
-        const subAgentSpans = /* @__PURE__ */ new Map();
-        const endedSubAgentSpans = /* @__PURE__ */ new Set();
-        const toolUseToParent = /* @__PURE__ */ new Map();
-        const latestLlmParentBySubAgentToolUse = /* @__PURE__ */ new Map();
-        const latestRootLlmParentRef = {
-          value: void 0
-        };
-        const subAgentDetailsByToolUseId = /* @__PURE__ */ new Map();
-        const taskIdToToolUseId = /* @__PURE__ */ new Map();
-        const promptMessagesByParentKey = /* @__PURE__ */ new Map();
-        const promptSourcePriorityByParentKey = /* @__PURE__ */ new Map();
-        const localToolContext = createClaudeLocalToolContext();
-        const { hasLocalToolHandlers, localToolHookNames } = prepareLocalToolHandlersInMcpServers(options.mcpServers);
-        const skipLocalToolHooks = options[CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION] === true || hasLocalToolHandlers;
-        const resolveToolUseParentSpan = async (toolUseID, context) => {
-          const trackedParentToolUseId = toolUseToParent.get(toolUseID);
-          const parentToolUseId = trackedParentToolUseId ?? (context?.agentId ? taskIdToToolUseId.get(context.agentId) ?? null : null);
-          const parentKey = llmParentKey(parentToolUseId);
-          const activeLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
-          const latestLlmParent = parentToolUseId ? latestLlmParentBySubAgentToolUse.get(parentToolUseId) : latestRootLlmParentRef.value;
-          if (!activeLlmSpan && !latestLlmParent) {
-            await ensureActiveLlmSpanForParentToolUse(
-              span,
-              activeLlmSpansByParentToolUse,
-              subAgentDetailsByToolUseId,
-              activeToolSpans,
-              subAgentSpans,
-              parentToolUseId,
-              getCurrentUnixTimestamp()
-            );
-          }
-          if (parentToolUseId) {
-            const subAgentSpan = await ensureSubAgentSpan(
-              subAgentDetailsByToolUseId,
-              span,
-              activeToolSpans,
-              subAgentSpans,
-              parentToolUseId
-            );
-            return subAgentSpan.export();
+          } finally {
+            resolvePromptDone?.();
           }
-          return span.export();
-        };
-        localToolContext.resolveLocalToolParent = resolveToolUseParentSpan;
-        setClaudeLocalToolParentResolver(resolveToolUseParentSpan);
-        const optionsWithHooks = injectTracingHooks(
-          options,
-          resolveToolUseParentSpan,
-          taskIdToToolUseId,
-          toolUseToParent,
-          activeToolSpans,
-          localToolHookNames,
-          skipLocalToolHooks,
-          subAgentDetailsByToolUseId,
-          subAgentSpans,
-          endedSubAgentSpans
-        );
-        params.options = optionsWithHooks;
-        event.arguments[0] = params;
-        spans.set(event, {
-          activeLlmSpansByParentToolUse,
-          activePartialMessageIdByParentKey: /* @__PURE__ */ new Map(),
-          activeToolSpans,
-          conversationHistoryByParentKey,
-          capturedPromptMessages,
-          currentMessageId: void 0,
-          currentMessageStartTime: startTime,
-          currentMessages: [],
-          endedSubAgentSpans,
-          finalOutputUsageMessageIds: /* @__PURE__ */ new Set(),
-          finalResults: [],
-          options: optionsWithHooks,
-          originalPrompt,
-          processing: Promise.resolve(),
-          promptDone,
-          promptMessagesByParentKey,
-          promptStarted: () => promptStarted,
-          promptSourcePriorityByParentKey,
-          span,
-          subAgentDetailsByToolUseId,
-          subAgentSpans,
-          taskIdToToolUseId,
-          latestLlmParentBySubAgentToolUse,
-          latestRootLlmParentRef,
-          toolUseToParent,
-          usageByMessageId: /* @__PURE__ */ new Map(),
-          localToolContext
+        })();
+      }
+      const span = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: "Claude Agent",
+            spanAttributes: {
+              type: "task" /* TASK */
+            }
+          },
+          INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+        )
+      );
+      const startTime = getCurrentUnixTimestamp();
+      try {
+        span.log({
+          input: typeof originalPrompt === "string" ? originalPrompt : promptIsAsyncIterable ? void 0 : originalPrompt !== void 0 ? String(originalPrompt) : void 0,
+          metadata: filterSerializableOptions(options)
         });
-      },
-      end: (event) => {
-        const state = spans.get(event);
-        if (!state) {
-          return;
-        }
-        const eventResult = bindClaudeLocalToolContextToAsyncIterable(
-          event.result,
-          state.localToolContext
-        );
-        if (eventResult === void 0) {
-          state.span.end();
-          spans.delete(event);
-          return;
-        }
-        if (isAsyncIterable(eventResult)) {
-          patchStreamIfNeeded(eventResult, {
-            onChunk: (message) => {
-              maybeTrackToolUseContext(state, message);
-              state.processing = state.processing.then(() => handleStreamMessage(state, message)).catch((error) => {
-                console.error(
-                  "Error processing Claude Agent SDK stream chunk:",
-                  error
-                );
-              });
-            },
-            onComplete: () => state.processing.then(() => finalizeQuerySpan(state)).finally(() => {
-              spans.delete(event);
-            }),
-            onError: (error) => state.processing.then(() => {
-              state.span.log({
-                error: error.message
-              });
-            }).then(() => finalizeQuerySpan(state)).finally(() => {
-              spans.delete(event);
-            })
-          });
-          return;
-        }
-        try {
-          state.span.log({ output: eventResult });
-        } catch (error) {
-          console.error("Error extracting output for Claude Agent SDK:", error);
-        } finally {
-          state.span.end();
-          spans.delete(event);
+      } catch (error) {
+        console.error("Error extracting input for Claude Agent SDK:", error);
+      }
+      const activeToolSpans = /* @__PURE__ */ new Map();
+      const activeLlmSpansByParentToolUse = /* @__PURE__ */ new Map();
+      const conversationHistoryByParentKey = /* @__PURE__ */ new Map();
+      const subAgentSpans = /* @__PURE__ */ new Map();
+      const endedSubAgentSpans = /* @__PURE__ */ new Set();
+      const toolUseToParent = /* @__PURE__ */ new Map();
+      const latestLlmParentBySubAgentToolUse = /* @__PURE__ */ new Map();
+      const latestRootLlmParentRef = {
+        value: void 0
+      };
+      const subAgentDetailsByToolUseId = /* @__PURE__ */ new Map();
+      const taskIdToToolUseId = /* @__PURE__ */ new Map();
+      const promptMessagesByParentKey = /* @__PURE__ */ new Map();
+      const promptSourcePriorityByParentKey = /* @__PURE__ */ new Map();
+      const { hasLocalToolHandlers, localToolHookNames } = prepareLocalToolHandlersInMcpServers(options.mcpServers);
+      const skipLocalToolHooks = options[CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION] === true || hasLocalToolHandlers;
+      const resolveToolUseParentSpan = async (toolUseID, context) => {
+        const trackedParentToolUseId = toolUseToParent.get(toolUseID);
+        const parentToolUseId = trackedParentToolUseId ?? (context?.agentId ? taskIdToToolUseId.get(context.agentId) ?? null : null);
+        const parentKey = llmParentKey(parentToolUseId);
+        const activeLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+        const latestLlmParent = parentToolUseId ? latestLlmParentBySubAgentToolUse.get(parentToolUseId) : latestRootLlmParentRef.value;
+        if (!activeLlmSpan && !latestLlmParent) {
+          await ensureActiveLlmSpanForParentToolUse(
+            span,
+            activeLlmSpansByParentToolUse,
+            subAgentDetailsByToolUseId,
+            activeToolSpans,
+            subAgentSpans,
+            parentToolUseId,
+            getCurrentUnixTimestamp()
+          );
         }
-      },
-      error: (event) => {
-        const state = spans.get(event);
-        if (!state || !event.error) {
-          return;
+        if (parentToolUseId) {
+          const subAgentSpan = await ensureSubAgentSpan(
+            subAgentDetailsByToolUseId,
+            span,
+            activeToolSpans,
+            subAgentSpans,
+            parentToolUseId
+          );
+          return subAgentSpan.export();
         }
-        state.span.log({
-          error: event.error.message
+        return span.export();
+      };
+      const optionsWithHooks = injectTracingHooks(
+        options,
+        resolveToolUseParentSpan,
+        taskIdToToolUseId,
+        toolUseToParent,
+        activeToolSpans,
+        localToolHookNames,
+        skipLocalToolHooks,
+        subAgentDetailsByToolUseId,
+        subAgentSpans,
+        endedSubAgentSpans
+      );
+      params.options = optionsWithHooks;
+      return {
+        activeLlmSpansByParentToolUse,
+        activePartialMessageIdByParentKey: /* @__PURE__ */ new Map(),
+        activeToolSpans,
+        conversationHistoryByParentKey,
+        capturedPromptMessages,
+        currentMessageId: void 0,
+        currentMessageStartTime: startTime,
+        currentMessages: [],
+        endedSubAgentSpans,
+        finalOutputUsageMessageIds: /* @__PURE__ */ new Set(),
+        finalResults: [],
+        options: optionsWithHooks,
+        originalPrompt,
+        processing: Promise.resolve(),
+        promptDone,
+        promptMessagesByParentKey,
+        promptStarted: () => promptStarted,
+        promptSourcePriorityByParentKey,
+        span,
+        subAgentDetailsByToolUseId,
+        subAgentSpans,
+        taskIdToToolUseId,
+        latestLlmParentBySubAgentToolUse,
+        latestRootLlmParentRef,
+        toolUseToParent,
+        usageByMessageId: /* @__PURE__ */ new Map(),
+        localToolParentResolver: resolveToolUseParentSpan
+      };
+    };
+    const finishQuery = (state, result) => {
+      if (isAsyncIterable(result)) {
+        patchStreamIfNeeded(result, {
+          aroundNext: (callback) => runWithClaudeLocalToolContext(
+            callback,
+            state.localToolParentResolver
+          ),
+          onChunk: (message) => {
+            maybeTrackToolUseContext(state, message);
+            state.processing = state.processing.then(() => handleStreamMessage(state, message)).catch((error) => {
+              console.error(
+                "Error processing Claude Agent SDK stream chunk:",
+                error
+              );
+            });
+          },
+          onComplete: () => state.processing.then(() => finalizeQuerySpan(state)),
+          onError: (error) => state.processing.then(() => {
+            state.span.log({ error: error.message });
+          }).then(() => finalizeQuerySpan(state))
         });
+        return;
+      }
+      try {
+        state.span.log({ output: result });
+      } catch (error) {
+        console.error("Error extracting output for Claude Agent SDK:", error);
+      } finally {
         state.span.end();
-        spans.delete(event);
       }
     };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
-    });
+    this.unsubscribers.push(
+      claudeAgentSDKChannels.query.intercept((target, thisArg, args) => {
+        let state;
+        try {
+          args[0] ??= {};
+          state = startQuery(args[0]);
+        } catch (error) {
+          debugLogger.error(
+            "Error starting Claude Agent SDK instrumentation:",
+            error
+          );
+        }
+        const invokeTarget = () => Reflect.apply(target, thisArg, args);
+        try {
+          const result = state ? runWithClaudeLocalToolContext(
+            invokeTarget,
+            state.localToolParentResolver
+          ) : invokeTarget();
+          if (state) {
+            try {
+              finishQuery(state, result);
+            } catch (error) {
+              debugLogger.error(
+                "Error finalizing Claude Agent SDK instrumentation:",
+                error
+              );
+            }
+          }
+          return result;
+        } catch (error) {
+          if (state) {
+            try {
+              state.span.log({
+                error: error instanceof Error ? error.message : String(error)
+              });
+              state.span.end();
+            } catch (instrumentationError) {
+              debugLogger.error(
+                "Error handling Claude Agent SDK instrumentation failure:",
+                instrumentationError
+              );
+            }
+          }
+          throw error;
+        }
+      })
+    );
   }
 };
 
@@ -23726,7 +24493,7 @@ function patchOpenRouterCallModelResult(args) {
         span,
         () => originalMethod.apply(resultLike, args2)
       );
-      if (!isAsyncIterable4(stream)) {
+      if (!isAsyncIterable3(stream)) {
         return stream;
       }
       return wrapAsyncIterableWithSpan({
@@ -23921,7 +24688,7 @@ function wrapAsyncIterableWithSpan(args) {
     }
   };
 }
-function isAsyncIterable4(value) {
+function isAsyncIterable3(value) {
   return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function normalizeError(error) {
@@ -24799,7 +25566,7 @@ function patchOpenRouterCallModelResult2(args) {
         span,
         () => originalMethod.apply(resultLike, args2)
       );
-      if (!isAsyncIterable5(stream)) {
+      if (!isAsyncIterable4(stream)) {
         return stream;
       }
       return wrapAsyncIterableWithSpan2({
@@ -24994,7 +25761,7 @@ function wrapAsyncIterableWithSpan2(args) {
     }
   };
 }
-function isAsyncIterable5(value) {
+function isAsyncIterable4(value) {
   return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function normalizeError2(error) {
@@ -30986,12 +31753,14 @@ function getMetricsFromResponse(response) {
       continue;
     }
     const inputTokenDetails = usageMetadata.input_token_details;
+    const outputTokenDetails = usageMetadata.output_token_details;
     return normalizeTokenMetrics({
       total_tokens: usageMetadata.total_tokens,
       prompt_tokens: usageMetadata.input_tokens,
       completion_tokens: usageMetadata.output_tokens,
       prompt_cache_creation_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_creation : void 0,
-      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0
+      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0,
+      completion_reasoning_tokens: isRecord(outputTokenDetails) ? outputTokenDetails.reasoning : void 0
     });
   }
   const llmOutput = response.llmOutput || {};
@@ -31578,6 +32347,9 @@ var piCodingAgentChannels = defineChannels(
 // src/instrumentation/plugins/pi-coding-agent-plugin.ts
 var piAgentPatchStates = /* @__PURE__ */ new WeakMap();
 var piAgentEventSubscriptions = /* @__PURE__ */ new WeakSet();
+var PI_TOOL_EXECUTE_WRAPPED = /* @__PURE__ */ Symbol.for(
+  "braintrust.pi_coding_agent.tool_execute_wrapped"
+);
 var piPromptContextStore;
 var PiCodingAgentPlugin = class extends BasePlugin {
   activePromptStates = /* @__PURE__ */ new Set();
@@ -31658,6 +32430,7 @@ function startPiPromptRun(event, onFinalize) {
     return void 0;
   }
   installPiAgentInstrumentation(agent);
+  wrapPiToolExecutors(agent.state?.tools);
   const metadata = {
     ...extractSessionMetadata(session),
     ...extractPromptOptionsMetadata(event.arguments[1]),
@@ -31754,6 +32527,7 @@ function makeInstrumentedStreamFn(agent, originalStreamFn) {
     if (!state || state.agent !== agent || state.finalized) {
       return invokeOriginal();
     }
+    wrapPiToolExecutors(context.tools);
     const llmState = await startPiLlmSpan(state, model, context, options);
     try {
       const stream = await runWithAutoInstrumentationSuppressed(invokeOriginal);
@@ -31764,6 +32538,33 @@ function makeInstrumentedStreamFn(agent, originalStreamFn) {
     }
   };
 }
+function wrapPiToolExecutors(tools) {
+  if (!tools) {
+    return;
+  }
+  for (const tool of tools) {
+    try {
+      const execute = tool.execute;
+      if (typeof execute !== "function" || execute[PI_TOOL_EXECUTE_WRAPPED]) {
+        continue;
+      }
+      const wrappedExecute = function(...args) {
+        return runWithAutoInstrumentationAllowed(
+          () => Reflect.apply(execute, this, args)
+        );
+      };
+      Object.defineProperty(wrappedExecute, PI_TOOL_EXECUTE_WRAPPED, {
+        configurable: false,
+        enumerable: false,
+        value: true,
+        writable: false
+      });
+      tool.execute = wrappedExecute;
+    } catch (error) {
+      logInstrumentationError4("Pi Coding Agent tool wrapping", error);
+    }
+  }
+}
 async function startPiLlmSpan(state, model, context, options) {
   const metadata = {
     ...extractModelMetadata2(model),
@@ -31935,35 +32736,26 @@ async function startPiToolSpan(state, event) {
   if (!event.toolCallId || state.activeToolSpans.has(event.toolCallId)) {
     return;
   }
-  const restoreAutoInstrumentation = enterAutoInstrumentationAllowed();
   const metadata = {
     "gen_ai.tool.call.id": event.toolCallId,
     "gen_ai.tool.name": event.toolName,
     "pi_coding_agent.tool.name": event.toolName
   };
-  try {
-    const span = startSpan(
-      withSpanInstrumentationName(
-        {
-          event: {
-            input: event.args,
-            metadata
-          },
-          name: event.toolName || "tool",
-          parent: await state.span.export(),
-          spanAttributes: { type: "tool" /* TOOL */ }
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          input: event.args,
+          metadata
         },
-        INSTRUMENTATION_NAMES.PI_CODING_AGENT
-      )
-    );
-    state.activeToolSpans.set(event.toolCallId, {
-      restoreAutoInstrumentation,
-      span
-    });
-  } catch (error) {
-    restoreAutoInstrumentation();
-    throw error;
-  }
+        name: event.toolName || "tool",
+        parent: await state.span.export(),
+        spanAttributes: { type: "tool" /* TOOL */ }
+      },
+      INSTRUMENTATION_NAMES.PI_CODING_AGENT
+    )
+  );
+  state.activeToolSpans.set(event.toolCallId, { span });
 }
 function finishPiToolSpan(state, event) {
   const toolState = state.activeToolSpans.get(event.toolCallId);
@@ -31984,11 +32776,7 @@ function finishPiToolSpan(state, event) {
       output: event.result
     });
   } finally {
-    try {
-      toolState.span.end();
-    } finally {
-      toolState.restoreAutoInstrumentation?.();
-    }
+    toolState.span.end();
   }
 }
 function finishPiPromptRun(state, error) {
@@ -32038,10 +32826,10 @@ function finishPiLlmSpan(promptState, llmState, message, error) {
     ...cleanMetrics5(llmState.metrics),
     ...buildDurationMetrics3(llmState.startTime)
   };
-  const usageMetrics = extractUsageMetrics2(message?.usage);
-  if (Object.keys(usageMetrics).length > 0) {
+  const usageMetrics2 = extractUsageMetrics2(message?.usage);
+  if (Object.keys(usageMetrics2).length > 0) {
     promptState.collectedLlmUsageMetrics = true;
-    addMetrics(promptState.metrics, usageMetrics);
+    addMetrics(promptState.metrics, usageMetrics2);
   }
   try {
     safeLog4(llmState.span, {
@@ -32059,14 +32847,10 @@ function finishPiLlmSpan(promptState, llmState, message, error) {
 }
 function finishOpenToolSpans(state, error) {
   for (const [, toolState] of state.activeToolSpans) {
-    try {
-      safeLog4(toolState.span, {
-        error: error ? toLoggedError(error) : "Pi tool did not complete"
-      });
-      toolState.span.end();
-    } finally {
-      toolState.restoreAutoInstrumentation?.();
-    }
+    safeLog4(toolState.span, {
+      error: error ? toLoggedError(error) : "Pi tool did not complete"
+    });
+    toolState.span.end();
   }
   state.activeToolSpans.clear();
 }
@@ -32385,12 +33169,12 @@ var MAX_STRANDS_STRING_ATTACHMENT_CACHE_ENTRIES = 32;
 var StrandsAgentSDKPlugin = class extends BasePlugin {
   activeChildParents = /* @__PURE__ */ new WeakMap();
   onEnable() {
-    this.subscribeToAgentStream();
-    this.subscribeToMultiAgentStream(
+    this.interceptAgentStream();
+    this.interceptMultiAgentStream(
       strandsAgentSDKChannels.graphStream,
       "Graph.stream"
     );
-    this.subscribeToMultiAgentStream(
+    this.interceptMultiAgentStream(
       strandsAgentSDKChannels.swarmStream,
       "Swarm.stream"
     );
@@ -32401,122 +33185,92 @@ var StrandsAgentSDKPlugin = class extends BasePlugin {
     }
     this.unsubscribers = [];
   }
-  subscribeToAgentStream() {
-    const channel2 = strandsAgentSDKChannels.agentStream.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(channel2);
-    const handlers = {
-      start: (event) => {
-        const state = startAgentStream(event, this.activeChildParents);
-        if (state) {
-          states.set(event, state);
-        }
-      },
-      end: (event) => {
-        const state = states.get(event);
-        if (!state) {
-          return;
-        }
-        const result = event.result;
-        if (isAsyncIterable(result)) {
-          patchStreamIfNeeded(result, {
-            aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
-            onChunk: (chunk) => handleAgentStreamEvent(state, chunk),
-            onComplete: () => {
-              finalizeAgentStream(state);
-              states.delete(event);
-            },
-            onError: (error) => {
-              finalizeAgentStream(state, error);
-              states.delete(event);
-            }
-          });
-          return;
-        }
-        finalizeAgentStream(state, void 0, result);
-        states.delete(event);
-      },
-      error: (event) => {
-        const state = states.get(event);
-        if (!state || !event.error) {
-          return;
-        }
-        finalizeAgentStream(state, event.error);
-        states.delete(event);
-      }
-    };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      unbindAutoInstrumentationSuppression?.();
-      channel2.unsubscribe(handlers);
-    });
+  interceptAgentStream() {
+    this.unsubscribers.push(
+      strandsAgentSDKChannels.agentStream.intercept(
+        (target, thisArg, args, additional) => instrumentStrandsStreamInvocation({
+          finalize: finalizeAgentStream,
+          handleChunk: handleAgentStreamEvent,
+          invoke: () => Reflect.apply(target, thisArg, args),
+          name: "Strands Agent SDK",
+          start: () => startAgentStream(
+            args[0],
+            extractAgent(additional.agent, thisArg),
+            this.activeChildParents
+          )
+        })
+      )
+    );
   }
-  subscribeToMultiAgentStream(channel2, operation) {
-    const tracingChannel = channel2.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(tracingChannel);
-    const handlers = {
-      start: (event) => {
-        const state = startMultiAgentStream(
-          event,
-          operation,
-          this.activeChildParents
-        );
-        if (state) {
-          states.set(event, state);
-        }
-      },
-      end: (event) => {
-        const state = states.get(event);
-        if (!state) {
-          return;
-        }
-        const result = event.result;
-        if (isAsyncIterable(result)) {
-          patchStreamIfNeeded(result, {
-            aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
-            onChunk: (chunk) => handleMultiAgentStreamEvent(
-              state,
-              chunk,
-              this.activeChildParents
-            ),
-            onComplete: () => {
-              finalizeMultiAgentStream(state, this.activeChildParents);
-              states.delete(event);
-            },
-            onError: (error) => {
-              finalizeMultiAgentStream(state, this.activeChildParents, error);
-              states.delete(event);
-            }
-          });
-          return;
-        }
-        finalizeMultiAgentStream(
-          state,
-          this.activeChildParents,
-          void 0,
-          result
+  interceptMultiAgentStream(channel2, operation) {
+    this.unsubscribers.push(
+      channel2.intercept(
+        (target, thisArg, args, additional) => instrumentStrandsStreamInvocation({
+          finalize: (state, error, output) => finalizeMultiAgentStream(
+            state,
+            this.activeChildParents,
+            error,
+            output
+          ),
+          handleChunk: (state, chunk) => handleMultiAgentStreamEvent(state, chunk, this.activeChildParents),
+          invoke: () => Reflect.apply(target, thisArg, args),
+          name: "Strands multi-agent",
+          start: () => startMultiAgentStream(
+            args[0],
+            extractOrchestrator(additional.orchestrator, thisArg),
+            operation,
+            this.activeChildParents
+          )
+        })
+      )
+    );
+  }
+};
+function instrumentStrandsStreamInvocation(options) {
+  let state;
+  try {
+    state = options.start();
+  } catch (error) {
+    debugLogger.error(`Error starting ${options.name} instrumentation:`, error);
+  }
+  let result;
+  try {
+    result = runWithAutoInstrumentationSuppressed(options.invoke);
+  } catch (error) {
+    if (state) {
+      try {
+        options.finalize(state, error);
+      } catch (instrumentationError) {
+        debugLogger.error(
+          `Error handling ${options.name} instrumentation failure:`,
+          instrumentationError
         );
-        states.delete(event);
-      },
-      error: (event) => {
-        const state = states.get(event);
-        if (!state || !event.error) {
-          return;
-        }
-        finalizeMultiAgentStream(state, this.activeChildParents, event.error);
-        states.delete(event);
       }
-    };
-    tracingChannel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      unbindAutoInstrumentationSuppression?.();
-      tracingChannel.unsubscribe(handlers);
-    });
+    }
+    throw error;
   }
-};
-function startAgentStream(event, activeChildParents) {
-  const agent = extractAgent(event);
+  if (state) {
+    try {
+      if (isAsyncIterable(result)) {
+        patchStreamIfNeeded(result, {
+          aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
+          onChunk: (chunk) => options.handleChunk(state, chunk),
+          onComplete: () => options.finalize(state),
+          onError: (error) => options.finalize(state, error)
+        });
+      } else {
+        options.finalize(state, void 0, result);
+      }
+    } catch (error) {
+      debugLogger.error(
+        `Error finalizing ${options.name} instrumentation:`,
+        error
+      );
+    }
+  }
+  return result;
+}
+function startAgentStream(input, agent, activeChildParents) {
   const model = agent?.model;
   const metadata = {
     ...extractAgentMetadata2(agent),
@@ -32526,17 +33280,14 @@ function startAgentStream(event, activeChildParents) {
   };
   const parentSpan = agent ? getOnlyChildParent(activeChildParents, agent) : void 0;
   const attachmentCache = createStrandsAttachmentCache();
-  const input = processStrandsInputAttachments(
-    event.arguments[0],
-    attachmentCache
-  );
+  const processedInput = processStrandsInputAttachments(input, attachmentCache);
   const span = parentSpan ? withCurrent(
     parentSpan,
     () => startSpan(
       withSpanInstrumentationName(
         {
           event: {
-            input,
+            input: processedInput,
             metadata
           },
           name: formatAgentSpanName(agent),
@@ -32549,7 +33300,7 @@ function startAgentStream(event, activeChildParents) {
     withSpanInstrumentationName(
       {
         event: {
-          input,
+          input: processedInput,
           metadata
         },
         name: formatAgentSpanName(agent),
@@ -32567,22 +33318,21 @@ function startAgentStream(event, activeChildParents) {
     startTime: getCurrentUnixTimestamp()
   };
 }
-function startMultiAgentStream(event, operation, activeChildParents) {
-  const orchestrator = extractOrchestrator(event);
+function startMultiAgentStream(input, orchestrator, operation, activeChildParents) {
   const metadata = {
     "strands.operation": operation,
     provider: "strands",
     ...orchestrator?.id ? { "strands.orchestrator.id": orchestrator.id } : {}
   };
   const parentSpan = orchestrator ? getOnlyChildParent(activeChildParents, orchestrator) : void 0;
-  const input = processStrandsInputAttachments(event.arguments[0]);
+  const processedInput = processStrandsInputAttachments(input);
   const span = parentSpan ? withCurrent(
     parentSpan,
     () => startSpan(
       withSpanInstrumentationName(
         {
           event: {
-            input,
+            input: processedInput,
             metadata
           },
           name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -32595,7 +33345,7 @@ function startMultiAgentStream(event, operation, activeChildParents) {
     withSpanInstrumentationName(
       {
         event: {
-          input,
+          input: processedInput,
           metadata
         },
         name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -32966,12 +33716,12 @@ function finalizeMultiAgentStream(state, activeChildParents, error, output) {
   });
   state.span.end();
 }
-function extractAgent(event) {
-  const candidate = event.agent ?? event.self;
+function extractAgent(agent, self) {
+  const candidate = agent ?? self;
   return isObject(candidate) && typeof candidate.stream === "function" ? candidate : void 0;
 }
-function extractOrchestrator(event) {
-  const candidate = event.orchestrator ?? event.self;
+function extractOrchestrator(orchestrator, self) {
+  const candidate = orchestrator ?? self;
   return isObject(candidate) && typeof candidate.stream === "function" ? candidate : void 0;
 }
 function extractAgentMetadata2(agent) {
@@ -34491,7 +35241,7 @@ function braintrustEveHook(options) {
     }
   };
 }
-function braintrustEveInstrumentation(options) {
+function createLegacyEveInstrumentation(options) {
   const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
   return {
     events: {
@@ -35879,8 +36629,10 @@ function capturedModelInput(modelInput) {
   const value = [];
   if (typeof instructions === "string") {
     value.push({ content: instructions, role: "system" });
-  } else if (instructions) {
+  } else if (Array.isArray(instructions)) {
     value.push(...instructions.map(capturedEveModelMessage));
+  } else if (instructions) {
+    value.push(capturedEveModelMessage(instructions));
   }
   value.push(...messages.map(capturedEveModelMessage));
   try {
@@ -36124,6 +36876,464 @@ async function deterministicEveId(...parts) {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
+// src/instrumentation/plugins/eve-provider.ts
+var MAX_EVE_PROVIDER_CACHE_ENTRIES = 1e4;
+function createEveInstrumentationProvider(options = {}) {
+  const bridge = new EveProviderBridge(options.metadata);
+  return {
+    capture: "content",
+    events: {
+      "action.completed": (event, context) => bridge.handleActionTerminal(event, context),
+      "action.failed": (event, context) => bridge.handleActionTerminal(event, context),
+      "action.started": (event, context) => bridge.handleActionStarted(event, context),
+      "model.call.completed": (event, context) => bridge.handleModelTerminal(event, context),
+      "model.call.failed": (event, context) => bridge.handleModelTerminal(event, context),
+      "model.call.started": (event, context) => bridge.handleModelStarted(event, context),
+      "step.attempt.completed": (event) => bridge.handleStepAttemptTerminal(event),
+      "step.attempt.failed": (event) => bridge.handleStepAttemptTerminal(event),
+      "turn.cancelled": (event, context) => bridge.handleTurnTerminal(event, context),
+      "turn.completed": (event, context) => bridge.handleTurnTerminal(event, context),
+      "turn.failed": (event, context) => bridge.handleTurnTerminal(event, context),
+      "turn.started": (event, context) => bridge.handleTurnStarted(event, context)
+    },
+    flush,
+    setup: options.setup
+  };
+}
+var EveProviderBridge = class {
+  constructor(metadata) {
+    this.metadata = metadata;
+  }
+  metadata;
+  activeActions = /* @__PURE__ */ new Map();
+  activeModels = /* @__PURE__ */ new Map();
+  modelsByAttempt = /* @__PURE__ */ new Map();
+  settledOperations = new LRUCache({
+    max: MAX_EVE_PROVIDER_CACHE_ENTRIES
+  });
+  turns = new LRUCache({
+    max: MAX_EVE_PROVIDER_CACHE_ENTRIES
+  });
+  async handleTurnStarted(event, context) {
+    await this.contain("turn start", async () => {
+      if (this.settledOperations.has(event.idempotencyKey)) {
+        context.state.set({ skip: true });
+        return;
+      }
+      const { rowId, spanId } = await generateEveIds(
+        "turn",
+        event.idempotencyKey
+      );
+      const key = turnKey3(event.sessionId, event.turnId);
+      const stored = storedSpan(context);
+      if (stored && "exported" in stored && stored.rootSpanId) {
+        this.turns.set(key, { rootSpanId: stored.rootSpanId, spanId });
+        return;
+      }
+      let rootSpanId = spanId;
+      let parentSpanId;
+      if (event.parentLineage) {
+        const parentTurnKey = turnKey3(
+          event.parentLineage.sessionId,
+          event.parentLineage.turnId
+        );
+        const parentTurn = this.turns.get(parentTurnKey);
+        rootSpanId = parentTurn?.rootSpanId ?? // 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(
+          "turn",
+          turnIdempotencyKey(
+            event.rootSessionId,
+            event.parentLineage.turnId
+          )
+        )).spanId;
+        parentSpanId = (await generateEveIds(
+          "subagent",
+          actionIdempotencyKey(
+            event.parentLineage.sessionId,
+            event.parentLineage.turnId,
+            event.parentLineage.callId
+          )
+        )).spanId;
+      }
+      const metadata = this.spanMetadata(event.sessionId);
+      const span = await this.startSpan(
+        context,
+        {
+          event: { id: rowId, metadata },
+          name: "eve.turn",
+          parentSpanIds: parentSpanId ? { rootSpanId, spanId: parentSpanId } : { parentSpanIds: [], rootSpanId },
+          spanAttributes: { type: "task" /* TASK */ },
+          spanId
+        },
+        rootSpanId
+      );
+      span?.log({ metadata });
+      this.turns.set(key, {
+        rootSpanId,
+        spanId
+      });
+    });
+  }
+  async handleTurnTerminal(event, context) {
+    await this.contain("turn terminal", async () => {
+      if (this.settledOperations.has(event.idempotencyKey)) {
+        context.state.set(void 0);
+        return;
+      }
+      const error = event.type === "turn.failed" ? event.error : void 0;
+      this.drainActionsForTurn(event.sessionId, event.turnId, error);
+      const stored = storedSpan(context);
+      if (stored && "exported" in stored) {
+        updateSpan({
+          exported: stored.exported,
+          ...error !== void 0 ? { error } : {},
+          metrics: { end: Date.now() / 1e3 }
+        });
+      }
+      this.settledOperations.set(event.idempotencyKey, true);
+      context.state.set(void 0);
+      this.turns.delete(turnKey3(event.sessionId, event.turnId));
+    });
+  }
+  async handleModelStarted(event, context) {
+    await this.contain("model start", async () => {
+      if (this.settledOperations.has(event.idempotencyKey)) {
+        context.state.set({ skip: true });
+        return;
+      }
+      const parent = await this.parentForScope(event.scope);
+      const { rowId, spanId } = await generateEveIds(
+        "step",
+        event.idempotencyKey
+      );
+      const input = event.input ? capturedModelInput(event.input) : void 0;
+      const metadata = {
+        ...this.spanMetadata(event.scope.sessionId),
+        model: event.model.modelId,
+        provider: event.model.provider
+      };
+      const span = await this.startSpan(context, {
+        event: {
+          id: rowId,
+          ...input !== void 0 ? { input } : {},
+          metadata
+        },
+        name: "eve.step",
+        parentSpanIds: parent,
+        spanAttributes: { type: "llm" /* LLM */ },
+        spanId
+      });
+      if (!span) return;
+      span.log({ ...input !== void 0 ? { input } : {}, metadata });
+      this.activeModels.set(event.idempotencyKey, {
+        span,
+        turnKey: turnKey3(event.scope.sessionId, event.scope.turnId)
+      });
+      const keys = this.modelsByAttempt.get(event.scope.attemptId) ?? /* @__PURE__ */ new Set();
+      keys.add(event.idempotencyKey);
+      this.modelsByAttempt.set(event.scope.attemptId, keys);
+    });
+  }
+  async handleModelTerminal(event, context) {
+    await this.contain("model terminal", async () => {
+      if (this.settledOperations.has(event.idempotencyKey)) {
+        context.state.set(void 0);
+        return;
+      }
+      const active = this.activeModels.get(event.idempotencyKey);
+      if (active) {
+        const span = active.span;
+        if (event.type === "model.call.failed") {
+          if (event.error !== void 0) span.log({ error: event.error });
+        } else {
+          span.log({
+            metrics: usageMetrics(event.usage),
+            output: modelOutput(event)
+          });
+        }
+        span.end();
+      } else {
+        const stored = storedSpan(context);
+        if (stored && "exported" in stored) {
+          updateSpan({
+            exported: stored.exported,
+            ...event.type === "model.call.failed" ? event.error !== void 0 ? { error: event.error } : {} : { output: modelOutput(event) },
+            metrics: {
+              ...event.type === "model.call.completed" ? usageMetrics(event.usage) : {},
+              end: Date.now() / 1e3
+            }
+          });
+        }
+      }
+      this.settledOperations.set(event.idempotencyKey, true);
+      this.forgetModel(event.scope.attemptId, event.idempotencyKey);
+      context.state.set(void 0);
+    });
+  }
+  async handleActionStarted(event, context) {
+    await this.contain("action start", async () => {
+      if (event.kind === "load-skill" || this.settledOperations.has(event.idempotencyKey)) {
+        context.state.set({ skip: true });
+        return;
+      }
+      const parent = await this.parentForScope(event.scope);
+      const { rowId, spanId } = await generateEveIds(
+        event.kind === "subagent-call" ? "subagent" : "tool",
+        event.idempotencyKey
+      );
+      const metadata = {
+        ...this.spanMetadata(event.scope.sessionId),
+        "eve.action_kind": event.kind
+      };
+      const span = await this.startSpan(context, {
+        event: {
+          id: rowId,
+          ...event.input !== void 0 ? { input: event.input } : {},
+          metadata
+        },
+        name: event.name,
+        parentSpanIds: parent,
+        spanAttributes: { type: "tool" /* TOOL */ },
+        spanId
+      });
+      if (!span) return;
+      span.log({
+        ...event.input !== void 0 ? { input: event.input } : {},
+        metadata
+      });
+      this.activeActions.set(event.idempotencyKey, {
+        span,
+        turnKey: turnKey3(event.scope.sessionId, event.scope.turnId)
+      });
+    });
+  }
+  async handleActionTerminal(event, context) {
+    await this.contain("action terminal", async () => {
+      if (this.settledOperations.has(event.idempotencyKey)) {
+        context.state.set(void 0);
+        return;
+      }
+      const stored = storedSpan(context);
+      if (stored?.skip) {
+        context.state.set(void 0);
+        return;
+      }
+      const active = this.activeActions.get(event.idempotencyKey);
+      const end = finiteTimestamp(event.acceptedAtMs) ?? Date.now();
+      if (active) {
+        const span = active.span;
+        if (event.type === "action.failed") {
+          span.log({
+            error: event.error ?? new Error(event.errorCode ?? `Eve action ${event.outcome}`)
+          });
+        } else if (event.output.type === "error") {
+          span.log({
+            error: event.output.error ?? new Error("Eve action returned an error")
+          });
+        } else {
+          span.log({ output: event.output.output });
+        }
+        span.end({ endTime: end / 1e3 });
+      } else {
+        const stored2 = storedSpan(context);
+        if (stored2 && "exported" in stored2) {
+          updateSpan({
+            exported: stored2.exported,
+            ...event.type === "action.failed" ? {
+              error: event.error ?? new Error(event.errorCode ?? `Eve action ${event.outcome}`)
+            } : event.output.type === "error" ? {
+              error: event.output.error ?? new Error("Eve action returned an error")
+            } : { output: event.output.output },
+            metrics: { end: end / 1e3 }
+          });
+        }
+      }
+      this.settledOperations.set(event.idempotencyKey, true);
+      this.activeActions.delete(event.idempotencyKey);
+      context.state.set(void 0);
+    });
+  }
+  handleStepAttemptTerminal(event) {
+    void this.contain("step attempt terminal", () => {
+      const keys = this.modelsByAttempt.get(event.scope.attemptId);
+      if (!keys) return;
+      for (const key of keys) {
+        const active = this.activeModels.get(key);
+        if (!active) continue;
+        if (event.type === "step.attempt.failed" && event.error !== void 0) {
+          active.span.log({ error: event.error });
+        }
+        active.span.end();
+        this.activeModels.delete(key);
+      }
+      this.modelsByAttempt.delete(event.scope.attemptId);
+    });
+  }
+  async parentForScope(scope) {
+    const key = turnKey3(scope.sessionId, scope.turnId);
+    const known = this.turns.get(key);
+    if (known) {
+      return { rootSpanId: known.rootSpanId, spanId: known.spanId };
+    }
+    const [{ spanId }, { spanId: rootSpanId }] = await Promise.all([
+      generateEveIds("turn", turnIdempotencyKey(scope.sessionId, scope.turnId)),
+      generateEveIds(
+        "turn",
+        turnIdempotencyKey(
+          scope.rootSessionId ?? scope.sessionId,
+          scope.turnId
+        )
+      )
+    ]);
+    return { rootSpanId, spanId };
+  }
+  async startSpan(context, args, rootSpanId) {
+    const span = withCurrent(
+      NOOP_SPAN,
+      () => _internalStartSpanWithInitialMerge(
+        withSpanInstrumentationName(args ?? {}, INSTRUMENTATION_NAMES.EVE)
+      )
+    );
+    try {
+      context.state.set({
+        exported: await span.export(),
+        ...rootSpanId ? { rootSpanId } : {}
+      });
+    } catch (error) {
+      debugLogger.warn("Error exporting Eve provider span:", error);
+    }
+    return span;
+  }
+  drainActionsForTurn(sessionId, turnId, error) {
+    const key = turnKey3(sessionId, turnId);
+    for (const [idempotencyKey, active] of this.activeActions) {
+      if (active.turnKey !== key) continue;
+      if (error !== void 0) active.span.log({ error });
+      active.span.end();
+      this.activeActions.delete(idempotencyKey);
+    }
+  }
+  forgetModel(attemptId, idempotencyKey) {
+    this.activeModels.delete(idempotencyKey);
+    const keys = this.modelsByAttempt.get(attemptId);
+    keys?.delete(idempotencyKey);
+    if (keys?.size === 0) this.modelsByAttempt.delete(attemptId);
+  }
+  spanMetadata(sessionId) {
+    return {
+      ...this.metadata ?? {},
+      "eve.session_id": sessionId
+    };
+  }
+  async contain(operation, fn) {
+    try {
+      await fn();
+    } catch (error) {
+      debugLogger.warn(`Error in Eve provider ${operation}:`, error);
+    }
+  }
+};
+function storedSpan(context) {
+  const value = context.state.get();
+  if (!isObject(value)) return void 0;
+  if (value["skip"] === true) return { skip: true };
+  return typeof value["exported"] === "string" ? {
+    exported: value["exported"],
+    ...typeof value["rootSpanId"] === "string" && value["rootSpanId"].length > 0 ? { rootSpanId: value["rootSpanId"] } : {}
+  } : void 0;
+}
+function modelOutput(event) {
+  const content = event.content ?? [];
+  let text = "";
+  const reasoning = [];
+  const toolCalls = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      text += part.text;
+    } else if (part.type === "reasoning" && part.text.trim().length > 0) {
+      reasoning.push({ content: part.text });
+    } else if (part.type === "tool-call") {
+      toolCalls.push({
+        function: {
+          arguments: safeJsonStringify(part.input),
+          name: part.toolName
+        },
+        id: part.callId,
+        type: "function"
+      });
+    }
+  }
+  return [
+    {
+      finish_reason: normalizeFinishReason2(event.finishReason),
+      index: 0,
+      message: {
+        content: text || null,
+        ...reasoning.length > 0 ? { reasoning } : {},
+        role: "assistant",
+        ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+      }
+    }
+  ];
+}
+function usageMetrics(usage) {
+  const promptTokens = nonNegativeNumber(usage.inputTokens);
+  const completionTokens = nonNegativeNumber(usage.outputTokens);
+  const cachedTokens = nonNegativeNumber(
+    usage.inputTokenDetails?.cacheReadTokens
+  );
+  const cacheCreationTokens = nonNegativeNumber(
+    usage.inputTokenDetails?.cacheWriteTokens
+  );
+  return {
+    ...promptTokens !== void 0 ? { prompt_tokens: promptTokens } : {},
+    ...completionTokens !== void 0 ? { completion_tokens: completionTokens } : {},
+    ...promptTokens !== void 0 && completionTokens !== void 0 ? { tokens: promptTokens + completionTokens } : {},
+    ...cachedTokens !== void 0 ? { prompt_cached_tokens: cachedTokens } : {},
+    ...cacheCreationTokens !== void 0 ? { prompt_cache_creation_tokens: cacheCreationTokens } : {}
+  };
+}
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function finiteTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function normalizeFinishReason2(value) {
+  if (value === "content-filter") return "content_filter";
+  if (value === "tool-calls") return "tool_calls";
+  return value;
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "null";
+  } catch {
+    return "null";
+  }
+}
+function turnKey3(sessionId, turnId) {
+  return `${sessionId}:${turnId}`;
+}
+function turnIdempotencyKey(sessionId, turnId) {
+  return `turn:${sessionId}:${turnId}`;
+}
+function actionIdempotencyKey(sessionId, turnId, callId) {
+  return `action:${sessionId}:${turnId}:${callId}`;
+}
+
+// src/instrumentation/plugins/eve-instrumentation.ts
+var EVE_INSTRUMENTATION_PROVIDER = /* @__PURE__ */ Symbol.for("eve.instrumentation.provider");
+function braintrustEveInstrumentation(options) {
+  const definition = "defineState" in options ? createLegacyEveInstrumentation(options) : createEveInstrumentationProvider(options);
+  const declaration = {
+    ...definition,
+    [EVE_INSTRUMENTATION_PROVIDER]: true
+  };
+  return declaration;
+}
+
 // src/instrumentation/config.ts
 var envIntegrationAliases = {
   openai: "openai",