braintrust 3.21.0 → 3.23.0

package/dist/edge-light.js

@@ -93,6 +93,8 @@ __export(edge_light_exports, {
   addAzureBlobHeaders: () => addAzureBlobHeaders,
   agentAssertionScorer: () => agentAssertionScorer,
   braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
+  braintrustEveHook: () => braintrustEveHook,
+  braintrustEveInstrumentation: () => braintrustEveInstrumentation,
   braintrustFlueInstrumentation: () => braintrustFlueInstrumentation,
   braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
@@ -183,6 +185,9 @@ __export(edge_light_exports, {
   wrapGoogleGenAI: () => wrapGoogleGenAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
+  wrapLangSmithClient: () => wrapLangSmithClient,
+  wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
+  wrapLangSmithTraceable: () => wrapLangSmithTraceable,
   wrapMastraAgent: () => wrapMastraAgent,
   wrapMistral: () => wrapMistral,
   wrapOpenAI: () => wrapOpenAI,
@@ -2384,19 +2389,30 @@ var CallEvent = import_v36.z.union([
 var ChatCompletionContentPartTextWithTitle = import_v36.z.object({
   text: import_v36.z.string().default(""),
   type: import_v36.z.literal("text"),
-  cache_control: import_v36.z.object({ type: import_v36.z.literal("ephemeral") }).optional()
+  cache_control: import_v36.z.object({
+    type: import_v36.z.literal("ephemeral"),
+    ttl: import_v36.z.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionContentPartImageWithTitle = import_v36.z.object({
   image_url: import_v36.z.object({
     url: import_v36.z.string(),
     detail: import_v36.z.union([import_v36.z.literal("auto"), import_v36.z.literal("low"), import_v36.z.literal("high")]).optional()
   }),
-  type: import_v36.z.literal("image_url")
+  type: import_v36.z.literal("image_url"),
+  cache_control: import_v36.z.object({
+    type: import_v36.z.literal("ephemeral"),
+    ttl: import_v36.z.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionContentPartFileFile = import_v36.z.object({ file_data: import_v36.z.string(), filename: import_v36.z.string(), file_id: import_v36.z.string() }).partial();
 var ChatCompletionContentPartFileWithTitle = import_v36.z.object({
   file: ChatCompletionContentPartFileFile,
-  type: import_v36.z.literal("file")
+  type: import_v36.z.literal("file"),
+  cache_control: import_v36.z.object({
+    type: import_v36.z.literal("ephemeral"),
+    ttl: import_v36.z.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionContentPart = import_v36.z.union([
   ChatCompletionContentPartTextWithTitle,
@@ -2406,7 +2422,10 @@ var ChatCompletionContentPart = import_v36.z.union([
 var ChatCompletionContentPartText = import_v36.z.object({
   text: import_v36.z.string().default(""),
   type: import_v36.z.literal("text"),
-  cache_control: import_v36.z.object({ type: import_v36.z.literal("ephemeral") }).optional()
+  cache_control: import_v36.z.object({
+    type: import_v36.z.literal("ephemeral"),
+    ttl: import_v36.z.enum(["5m", "1h"]).optional()
+  }).optional()
 });
 var ChatCompletionMessageToolCall = import_v36.z.object({
   id: import_v36.z.string(),
@@ -4441,7 +4460,7 @@ var DiskCache = class {
   }
 };
 
-// src/prompt-cache/lru-cache.ts
+// src/lru-cache.ts
 var LRUCache = class {
   cache;
   maxSize;
@@ -4457,13 +4476,23 @@ var LRUCache = class {
    * @returns The cached value if found, undefined otherwise.
    */
   get(key) {
-    const value = this.cache.get(key);
-    if (value === void 0) {
+    const entry = this.cache.get(key);
+    if (entry === void 0) {
       return void 0;
     }
     this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
+    this.cache.set(key, entry);
+    return entry.value;
+  }
+  /**
+   * Checks whether a key exists and marks it as most recently used.
+   */
+  has(key) {
+    if (!this.cache.has(key)) {
+      return false;
+    }
+    this.get(key);
+    return true;
   }
   /**
    * Stores a value in the cache.
@@ -4480,7 +4509,38 @@ var LRUCache = class {
       const first = this.cache.keys().next().value;
       this.cache.delete(first);
     }
-    this.cache.set(key, value);
+    this.cache.set(key, { value });
+  }
+  /**
+   * Removes an item from the cache.
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Iterates over cache entries from least to most recently used.
+   */
+  *entries() {
+    for (const [key, entry] of this.cache) {
+      yield [key, entry.value];
+    }
+  }
+  /**
+   * Iterates over cache keys from least to most recently used.
+   */
+  keys() {
+    return this.cache.keys();
+  }
+  /**
+   * Iterates over cache values from least to most recently used.
+   */
+  *values() {
+    for (const entry of this.cache.values()) {
+      yield entry.value;
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
   }
   /**
    * Removes all items from the cache.
@@ -5038,6 +5098,9 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
     return `ERROR: Failed to mask field '${fieldName}' - ${errorType}`;
   }
 }
+var INITIAL_SPAN_WRITE_AS_MERGE = /* @__PURE__ */ Symbol(
+  "braintrust.initial-span-write-as-merge"
+);
 var BRAINTRUST_CURRENT_SPAN_STORE = /* @__PURE__ */ Symbol.for(
   "braintrust.currentSpanStore"
 );
@@ -5639,25 +5702,46 @@ var HTTPConnection = class _HTTPConnection {
       })
     );
   }
-  async post(path, params, config) {
+  async post(path, params, config, retries = 0) {
     const { headers, ...rest } = config || {};
     const this_fetch = this.fetch;
     const this_base_url = this.base_url;
     const this_headers = this.headers;
-    return await checkResponse(
-      await this_fetch(_urljoin(this_base_url, path), {
-        method: "POST",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json",
-          ...this_headers,
-          ...headers
-        },
-        body: typeof params === "string" ? params : params ? JSON.stringify(params) : void 0,
-        keepalive: true,
-        ...rest
-      })
-    );
+    const tries = retries + 1;
+    for (let i = 0; i < tries; i++) {
+      try {
+        return await checkResponse(
+          await this_fetch(_urljoin(this_base_url, path), {
+            method: "POST",
+            headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+              ...this_headers,
+              ...headers
+            },
+            body: typeof params === "string" ? params : params ? JSON.stringify(params) : void 0,
+            keepalive: true,
+            ...rest
+          })
+        );
+      } catch (error) {
+        if (config?.signal?.aborted) {
+          throw getAbortReason(config.signal);
+        }
+        if (i === tries - 1 || !isRetryableHTTPError(error)) {
+          throw error;
+        }
+        debugLogger.debug(
+          `Retrying API request ${path} after ${formatHTTPError(error)}`
+        );
+        const sleepTimeMs = HTTP_RETRY_BASE_SLEEP_TIME_S * 1e3 * 2 ** i + Math.random() * HTTP_RETRY_JITTER_MS;
+        debugLogger.info(
+          `Sleeping for ${sleepTimeMs}ms before retrying API request`
+        );
+        await waitForRetry(sleepTimeMs, config?.signal);
+      }
+    }
+    throw new Error("Unexpected retry state");
   }
   async get_json(object_type, args = void 0, retries = 0) {
     const tries = retries + 1;
@@ -6754,6 +6838,45 @@ var TestBackgroundLogger = class {
 };
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
 var HTTP_RETRY_BASE_SLEEP_TIME_S = 1;
+var HTTP_RETRY_JITTER_MS = 200;
+var BTQL_HTTP_RETRIES = 3;
+var RETRYABLE_HTTP_STATUS_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+function isRetryableHTTPError(error) {
+  return !(error instanceof FailedHTTPResponse) || RETRYABLE_HTTP_STATUS_CODES.has(error.status);
+}
+function formatHTTPError(error) {
+  if (error instanceof FailedHTTPResponse) {
+    return `${error.status} ${error.text}`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function getAbortReason(signal) {
+  return signal.reason ?? new Error("Request aborted");
+}
+async function waitForRetry(delayMs, signal) {
+  if (!signal) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    return;
+  }
+  if (signal.aborted) {
+    throw getAbortReason(signal);
+  }
+  await new Promise((resolve, reject2) => {
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", onAbort);
+      reject2(getAbortReason(signal));
+    };
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) {
+      onAbort();
+    }
+  });
+}
 var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
   apiConn;
   queue;
@@ -8492,15 +8615,15 @@ function parentSpanIdsUsable(spanId, rootSpanId) {
   return Boolean(spanId) && Boolean(rootSpanId);
 }
 function logError(span, error) {
-  let errorMessage = "<error>";
+  let errorMessage2 = "<error>";
   let stackTrace = "";
   if (error instanceof Error) {
-    errorMessage = error.message;
+    errorMessage2 = error.message;
     stackTrace = error.stack || "";
   } else {
-    errorMessage = String(error);
+    errorMessage2 = String(error);
   }
-  span.log({ error: `${errorMessage}
+  span.log({ error: `${errorMessage2}
 
 ${stackTrace}` });
 }
@@ -8688,6 +8811,12 @@ var traceable = wrapTraced;
 function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
+function _internalStartSpanWithInitialMerge(args) {
+  return startSpanAndIsLogger({
+    ...args,
+    [INITIAL_SPAN_WRITE_AS_MERGE]: true
+  }).span;
+}
 async function flush(options) {
   const state = options?.state ?? _globalState;
   return await state.bgLogger().flush();
@@ -9081,7 +9210,8 @@ var ObjectFetcher = class {
             version: this.pinnedVersion
           } : {}
         },
-        { headers: { "Accept-Encoding": "gzip" } }
+        { headers: { "Accept-Encoding": "gzip" } },
+        BTQL_HTTP_RETRIES
       );
       const respJson = await resp.json();
       const mutate = this.mutateRecord;
@@ -9598,7 +9728,7 @@ var SpanImpl = class _SpanImpl {
     this._spanId = resolvedIds.spanId;
     this._rootSpanId = resolvedIds.rootSpanId;
     this._spanParents = resolvedIds.spanParents;
-    this.isMerge = false;
+    this.isMerge = args[INITIAL_SPAN_WRITE_AS_MERGE] === true;
     this.logInternal({ event, internalData });
     this.isMerge = true;
   }
@@ -10805,7 +10935,8 @@ async function getPromptVersions(projectId, promptId) {
       use_columnstore: false,
       brainstore_realtime: true
     },
-    { headers: { "Accept-Encoding": "gzip" } }
+    { headers: { "Accept-Encoding": "gzip" } },
+    BTQL_HTTP_RETRIES
   );
   if (!response.ok) {
     throw new Error(
@@ -29389,6 +29520,446 @@ function isBraintrustHandler(handler) {
   return Reflect.get(handler, "name") === BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
 }
 
+// src/instrumentation/plugins/langsmith-channels.ts
+var langSmithChannels = defineChannels("langsmith", {
+  createRun: channel({
+    channelName: "Client.createRun",
+    kind: "async"
+  }),
+  updateRun: channel({
+    channelName: "Client.updateRun",
+    kind: "async"
+  }),
+  batchIngestRuns: channel({
+    channelName: "Client.batchIngestRuns",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/langsmith-plugin.ts
+var MAX_COMPLETED_RUNS = 1e4;
+var BLOCKED_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "usage_metadata"
+]);
+var BLOCKED_METADATA_PREFIXES = ["__pregel_", "langgraph_", "lc_"];
+var LLM_SETTING_KEYS = [
+  "temperature",
+  "top_p",
+  "max_tokens",
+  "frequency_penalty",
+  "presence_penalty",
+  "stop",
+  "response_format"
+];
+var LangSmithPlugin = class extends BasePlugin {
+  activeRuns = /* @__PURE__ */ new Map();
+  completedRuns = new LRUCache({
+    max: MAX_COMPLETED_RUNS
+  });
+  skipLangChainRuns;
+  constructor(options = {}) {
+    super();
+    this.skipLangChainRuns = options.skipLangChainRuns ?? true;
+  }
+  onEnable() {
+    const createChannel = langSmithChannels.createRun.tracingChannel();
+    const createHandlers = {
+      start: (event) => {
+        this.containLifecycleFailure("createRun", () => {
+          this.processCreate(event.arguments[0]);
+        });
+      }
+    };
+    createChannel.subscribe(createHandlers);
+    this.unsubscribers.push(() => createChannel.unsubscribe(createHandlers));
+    const updateChannel = langSmithChannels.updateRun.tracingChannel();
+    const updateHandlers = {
+      start: (event) => {
+        this.containLifecycleFailure("updateRun", () => {
+          this.processUpdate(event.arguments[0], event.arguments[1]);
+        });
+      }
+    };
+    updateChannel.subscribe(updateHandlers);
+    this.unsubscribers.push(() => updateChannel.unsubscribe(updateHandlers));
+    const batchChannel = langSmithChannels.batchIngestRuns.tracingChannel();
+    const batchHandlers = {
+      start: (event) => {
+        this.containLifecycleFailure("batchIngestRuns", () => {
+          this.processBatch(event.arguments[0]);
+        });
+      }
+    };
+    batchChannel.subscribe(batchHandlers);
+    this.unsubscribers.push(() => batchChannel.unsubscribe(batchHandlers));
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+    for (const { span } of this.activeRuns.values()) {
+      span.end();
+    }
+    this.activeRuns.clear();
+    this.completedRuns.clear();
+  }
+  processBatch(batch) {
+    if (!isRecord2(batch)) {
+      return;
+    }
+    const creates = ownValue(batch, "runCreates");
+    if (Array.isArray(creates)) {
+      const parentFirst = [...creates].sort((left, right) => {
+        const leftId = stringValue2(ownValue(left, "id"));
+        const rightId = stringValue2(ownValue(right, "id"));
+        const leftParent = stringValue2(ownValue(left, "parent_run_id"));
+        const rightParent = stringValue2(ownValue(right, "parent_run_id"));
+        if (leftParent && leftParent === rightId) {
+          return 1;
+        }
+        if (rightParent && rightParent === leftId) {
+          return -1;
+        }
+        return dottedOrderDepth(left) - dottedOrderDepth(right);
+      });
+      for (const run of parentFirst) {
+        this.containLifecycleFailure("batchIngestRuns create", () => {
+          this.processCreate(run);
+        });
+      }
+    }
+    const updates = ownValue(batch, "runUpdates");
+    if (Array.isArray(updates)) {
+      for (const run of updates) {
+        this.containLifecycleFailure("batchIngestRuns update", () => {
+          this.processUpdate(stringValue2(ownValue(run, "id")) ?? "", run);
+        });
+      }
+    }
+  }
+  processCreate(run) {
+    const id = stringValue2(ownValue(run, "id"));
+    if (!id || this.completedRuns.get(id)) {
+      return;
+    }
+    if (this.shouldSkipLangChainRun(run)) {
+      this.completedRuns.set(id, true);
+      return;
+    }
+    const active = this.activeRuns.get(id);
+    if (active) {
+      const previous = active.run;
+      active.run = mergeRuns(previous, run);
+      this.logRun(
+        active.span,
+        active.run,
+        previous,
+        timestampSeconds(ownValue(active.run, "end_time")) !== void 0 || errorMessage(ownValue(active.run, "error")) !== void 0
+      );
+      this.endIfComplete(id, active, active.run);
+      return;
+    }
+    const span = this.startRunSpan(id, run);
+    const activeRun = { run, span };
+    this.activeRuns.set(id, activeRun);
+    this.logRun(
+      span,
+      run,
+      void 0,
+      timestampSeconds(ownValue(run, "end_time")) !== void 0 || errorMessage(ownValue(run, "error")) !== void 0
+    );
+    this.endIfComplete(id, activeRun, run);
+  }
+  processUpdate(explicitId, run) {
+    const id = stringValue2(explicitId) ?? stringValue2(ownValue(run, "id"));
+    if (!id || this.completedRuns.get(id)) {
+      return;
+    }
+    if (this.shouldSkipLangChainRun(run)) {
+      const active2 = this.activeRuns.get(id);
+      active2?.span.end();
+      this.activeRuns.delete(id);
+      this.completedRuns.set(id, true);
+      return;
+    }
+    let active = this.activeRuns.get(id);
+    if (!active) {
+      const span = this.startRunSpan(id, run);
+      active = { run, span };
+      this.activeRuns.set(id, active);
+    }
+    const previous = active.run;
+    active.run = mergeRuns(previous, run);
+    this.logRun(active.span, active.run, previous, true);
+    this.endIfComplete(id, active, active.run);
+  }
+  startRunSpan(id, run) {
+    const traceId = stringValue2(ownValue(run, "trace_id")) ?? id;
+    const parentId = stringValue2(ownValue(run, "parent_run_id")) ?? stringValue2(ownValue(ownValue(run, "parent_run"), "id"));
+    const startTime = timestampSeconds(ownValue(run, "start_time"));
+    return startSpan({
+      name: stringValue2(ownValue(run, "name")) ?? "LangSmith run",
+      spanId: id,
+      parentSpanIds: {
+        parentSpanIds: parentId ? [parentId] : [],
+        rootSpanId: traceId
+      },
+      spanAttributes: {
+        type: mapRunType(ownValue(run, "run_type"))
+      },
+      ...startTime === void 0 ? {} : { startTime },
+      event: { id }
+    });
+  }
+  logRun(span, run, previous, includeOutput) {
+    const inputs = preferOwnValue(run, previous, "inputs");
+    const outputs = preferOwnValue(run, previous, "outputs");
+    const error = errorMessage(preferOwnValue(run, previous, "error"));
+    const metadata = extractMetadata(run, previous);
+    const tags = extractTags(preferOwnValue(run, previous, "tags"));
+    const metrics = extractMetrics(run, previous);
+    span.log({
+      ...inputs === void 0 ? {} : { input: sanitizeLoggedValue(inputs) },
+      ...includeOutput && outputs !== void 0 ? { output: sanitizeLoggedValue(outputs) } : {},
+      ...error === void 0 ? {} : { error },
+      ...metadata === void 0 ? {} : { metadata },
+      ...tags === void 0 ? {} : { tags },
+      ...Object.keys(metrics).length === 0 ? {} : { metrics }
+    });
+  }
+  endIfComplete(id, active, run) {
+    const endTime = timestampSeconds(ownValue(run, "end_time"));
+    if (endTime === void 0 && errorMessage(ownValue(run, "error")) === void 0) {
+      return;
+    }
+    active.span.end(endTime === void 0 ? void 0 : { endTime });
+    this.activeRuns.delete(id);
+    this.completedRuns.set(id, true);
+  }
+  shouldSkipLangChainRun(run) {
+    if (!this.skipLangChainRuns) {
+      return false;
+    }
+    const serialized = ownValue(run, "serialized");
+    return isRecord2(serialized) && ownValue(serialized, "lc") === 1;
+  }
+  containLifecycleFailure(operation, fn) {
+    try {
+      fn();
+    } catch (error) {
+      debugLogger.error(
+        `Failed to process LangSmith ${operation} instrumentation:`,
+        error
+      );
+    }
+  }
+};
+function ownValue(value, key) {
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function preferOwnValue(current, previous, key) {
+  const currentDescriptor = isRecord2(current) ? Object.getOwnPropertyDescriptor(current, key) : void 0;
+  if (currentDescriptor && "value" in currentDescriptor) {
+    return currentDescriptor.value;
+  }
+  return ownValue(previous, key);
+}
+function mergeRuns(previous, current) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const value of [previous, current]) {
+    if (!isRecord2(value)) {
+      continue;
+    }
+    for (const [key, descriptor] of Object.entries(
+      Object.getOwnPropertyDescriptors(value)
+    )) {
+      if (descriptor.enumerable && "value" in descriptor) {
+        entries.set(key, descriptor.value);
+      }
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function timestampSeconds(value) {
+  if (value instanceof Date) {
+    const timestamp = value.getTime();
+    return Number.isFinite(timestamp) ? timestamp / 1e3 : void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return value > 1e10 ? value / 1e3 : value;
+  }
+  if (typeof value === "string") {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp / 1e3 : void 0;
+  }
+  return void 0;
+}
+function dottedOrderDepth(run) {
+  const dottedOrder = stringValue2(ownValue(run, "dotted_order"));
+  return dottedOrder ? dottedOrder.split(".").length : Number.MAX_SAFE_INTEGER;
+}
+function mapRunType(runType) {
+  switch (runType) {
+    case "llm":
+    case "embedding":
+      return "llm" /* LLM */;
+    case "tool":
+    case "retriever":
+      return "tool" /* TOOL */;
+    default:
+      return "task" /* TASK */;
+  }
+}
+function extractMetadata(run, previous) {
+  const extra = preferOwnValue(run, previous, "extra");
+  const rawMetadata = ownValue(extra, "metadata");
+  if (!isRecord2(rawMetadata)) {
+    return void 0;
+  }
+  const metadata = {};
+  for (const [key, descriptor] of Object.entries(
+    Object.getOwnPropertyDescriptors(rawMetadata)
+  )) {
+    if (!("value" in descriptor) || !descriptor.enumerable || BLOCKED_METADATA_KEYS.has(key) || BLOCKED_METADATA_PREFIXES.some((prefix) => key.startsWith(prefix)) || key.startsWith("ls_") && key !== "ls_provider" && key !== "ls_model_name" && !LLM_SETTING_KEYS.some((setting) => key === `ls_${setting}`)) {
+      continue;
+    }
+    const normalizedKey = key === "ls_provider" ? "provider" : key === "ls_model_name" ? "model" : key.startsWith("ls_") ? key.slice(3) : key;
+    const sanitized = sanitizeLoggedValue(descriptor.value);
+    if (sanitized !== void 0) {
+      metadata[normalizedKey] = sanitized;
+    }
+  }
+  return Object.keys(metadata).length === 0 ? void 0 : metadata;
+}
+function extractTags(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const tags = value.filter(
+    (tag) => typeof tag === "string" && tag.length > 0
+  );
+  return tags.length > 0 ? tags : void 0;
+}
+function extractMetrics(run, previous) {
+  const outputs = preferOwnValue(run, previous, "outputs");
+  const extra = preferOwnValue(run, previous, "extra");
+  const metadata = ownValue(extra, "metadata");
+  const usage = ownValue(outputs, "usage_metadata") ?? ownValue(metadata, "usage_metadata");
+  const metrics = {};
+  assignFirstMetric(metrics, "prompt_tokens", usage, [
+    "input_tokens",
+    "prompt_tokens"
+  ]);
+  assignFirstMetric(metrics, "completion_tokens", usage, [
+    "output_tokens",
+    "completion_tokens"
+  ]);
+  assignFirstMetric(metrics, "tokens", usage, ["total_tokens", "tokens"]);
+  const inputTokenDetails = ownValue(usage, "input_token_details");
+  assignFirstMetric(metrics, "prompt_cached_tokens", inputTokenDetails, [
+    "cache_read",
+    "cached_tokens"
+  ]);
+  if (metrics.prompt_cached_tokens === void 0) {
+    assignFirstMetric(metrics, "prompt_cached_tokens", usage, [
+      "cache_read_input_tokens",
+      "prompt_cached_tokens"
+    ]);
+  }
+  assignFirstMetric(
+    metrics,
+    "prompt_cache_creation_tokens",
+    inputTokenDetails,
+    ["cache_creation"]
+  );
+  if (metrics.prompt_cache_creation_tokens === void 0) {
+    assignFirstMetric(metrics, "prompt_cache_creation_tokens", usage, [
+      "cache_creation_input_tokens",
+      "prompt_cache_creation_tokens"
+    ]);
+  }
+  if (metrics.tokens === void 0 && (metrics.prompt_tokens !== void 0 || metrics.completion_tokens !== void 0)) {
+    metrics.tokens = (metrics.prompt_tokens ?? 0) + (metrics.completion_tokens ?? 0);
+  }
+  const startTime = timestampSeconds(
+    preferOwnValue(run, previous, "start_time")
+  );
+  const events = preferOwnValue(run, previous, "events");
+  if (startTime !== void 0 && Array.isArray(events)) {
+    for (const event of events) {
+      if (ownValue(event, "name") !== "new_token") {
+        continue;
+      }
+      const eventTime3 = timestampSeconds(ownValue(event, "time"));
+      if (eventTime3 !== void 0 && eventTime3 >= startTime) {
+        metrics.time_to_first_token = eventTime3 - startTime;
+      }
+      break;
+    }
+  }
+  return metrics;
+}
+function assignFirstMetric(metrics, target, source, keys) {
+  for (const key of keys) {
+    const value = ownValue(source, key);
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+      metrics[target] = value;
+      return;
+    }
+  }
+}
+function errorMessage(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.message;
+  }
+  return void 0;
+}
+function sanitizeLoggedValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value.toISOString() : void 0;
+  }
+  if (typeof value !== "object" || depth >= 20) {
+    return void 0;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeLoggedValue(item, seen, depth + 1));
+  }
+  const entries = [];
+  for (const [key, descriptor] of Object.entries(
+    Object.getOwnPropertyDescriptors(value)
+  )) {
+    if (!descriptor.enumerable || !("value" in descriptor) || BLOCKED_METADATA_KEYS.has(key)) {
+      continue;
+    }
+    entries.push([key, sanitizeLoggedValue(descriptor.value, seen, depth + 1)]);
+  }
+  return Object.fromEntries(entries);
+}
+
 // src/instrumentation/plugins/pi-coding-agent-channels.ts
 var piCodingAgentChannels = defineChannels(
   "@earendil-works/pi-coding-agent",
@@ -29768,11 +30339,11 @@ function patchAssistantMessageStream(stream, promptState, llmState) {
 function recordPiAssistantMessageEvent(promptState, llmState, event) {
   recordFirstTokenMetric(llmState, event);
   const message = "message" in event ? event.message : void 0;
-  const errorMessage = "error" in event ? event.error : void 0;
+  const errorMessage2 = "error" in event ? event.error : void 0;
   if (event.type === "done" && isPiAssistantMessage(message)) {
     finishPiLlmSpan(promptState, llmState, message);
-  } else if (event.type === "error" && isPiAssistantMessage(errorMessage)) {
-    finishPiLlmSpan(promptState, llmState, errorMessage);
+  } else if (event.type === "error" && isPiAssistantMessage(errorMessage2)) {
+    finishPiLlmSpan(promptState, llmState, errorMessage2);
   }
 }
 function recordFirstTokenMetric(state, event) {
@@ -30290,6 +30861,7 @@ var strandsAgentSDKChannels = defineChannels("@strands-agents/sdk", {
 });
 
 // src/instrumentation/plugins/strands-agent-sdk-plugin.ts
+var MAX_STRANDS_STRING_ATTACHMENT_CACHE_ENTRIES = 32;
 var StrandsAgentSDKPlugin = class extends BasePlugin {
   activeChildParents = /* @__PURE__ */ new WeakMap();
   onEnable() {
@@ -30434,11 +31006,16 @@ function startAgentStream(event, activeChildParents) {
     ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
   };
   const parentSpan = agent ? getOnlyChildParent(activeChildParents, agent) : void 0;
+  const attachmentCache = createStrandsAttachmentCache();
+  const input = processStrandsInputAttachments(
+    event.arguments[0],
+    attachmentCache
+  );
   const span = parentSpan ? withCurrent(
     parentSpan,
     () => startSpan({
       event: {
-        input: event.arguments[0],
+        input,
         metadata
       },
       name: formatAgentSpanName(agent),
@@ -30446,7 +31023,7 @@ function startAgentStream(event, activeChildParents) {
     })
   ) : startSpan({
     event: {
-      input: event.arguments[0],
+      input,
       metadata
     },
     name: formatAgentSpanName(agent),
@@ -30454,6 +31031,7 @@ function startAgentStream(event, activeChildParents) {
   });
   return {
     activeTools: /* @__PURE__ */ new Map(),
+    attachmentCache,
     finalized: false,
     metadata,
     span,
@@ -30469,11 +31047,12 @@ function startMultiAgentStream(event, operation, activeChildParents) {
     ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
   };
   const parentSpan = orchestrator ? getOnlyChildParent(activeChildParents, orchestrator) : void 0;
+  const input = processStrandsInputAttachments(event.arguments[0]);
   const span = parentSpan ? withCurrent(
     parentSpan,
     () => startSpan({
       event: {
-        input: event.arguments[0],
+        input,
         metadata
       },
       name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -30481,7 +31060,7 @@ function startMultiAgentStream(event, operation, activeChildParents) {
     })
   ) : startSpan({
     event: {
-      input: event.arguments[0],
+      input,
       metadata
     },
     name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -30590,7 +31169,10 @@ function startModelSpan(state, event) {
     state.span,
     () => startSpan({
       event: {
-        input: Array.isArray(event.agent?.messages) ? event.agent.messages : void 0,
+        input: Array.isArray(event.agent?.messages) ? processStrandsInputAttachments(
+          event.agent.messages,
+          state.attachmentCache
+        ) : void 0,
         metadata
       },
       name: formatModelSpanName(model),
@@ -30804,6 +31386,7 @@ function finalizeAgentStream(state, error, output) {
     ...output !== void 0 ? { output } : {}
   });
   state.span.end();
+  state.attachmentCache.strings.clear();
 }
 function finalizeMultiAgentStream(state, activeChildParents, error, output) {
   if (state.finalized) {
@@ -30950,6 +31533,166 @@ function extractNodeResultOutput(result) {
   }
   return result;
 }
+var STRANDS_MEDIA_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  mkv: "video/x-matroska",
+  mov: "video/quicktime",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  flv: "video/x-flv",
+  mpeg: "video/mpeg",
+  mpg: "video/mpeg",
+  wmv: "video/x-ms-wmv",
+  "3gp": "video/3gpp",
+  pdf: "application/pdf",
+  csv: "text/csv",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  html: "text/html",
+  txt: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  xml: "application/xml"
+};
+function createStrandsAttachmentCache() {
+  return {
+    objects: /* @__PURE__ */ new WeakMap(),
+    strings: new LRUCache({
+      max: MAX_STRANDS_STRING_ATTACHMENT_CACHE_ENTRIES
+    })
+  };
+}
+function processStrandsInputAttachments(input, cache = createStrandsAttachmentCache()) {
+  try {
+    return processStrandsInputNode(input, cache);
+  } catch (error) {
+    logInstrumentationError5("Strands Agent SDK input attachments", error);
+    return input;
+  }
+}
+function processStrandsInputNode(value, cache) {
+  if (value instanceof BaseAttachment) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((child) => processStrandsInputNode(child, cache));
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  const directMedia = processDirectStrandsMediaBlock(value, cache);
+  if (directMedia !== void 0) {
+    return directMedia;
+  }
+  const wrappedMedia = processWrappedStrandsMediaBlock(value, cache);
+  if (wrappedMedia !== void 0) {
+    return wrappedMedia;
+  }
+  if (value.type === "message" && Array.isArray(value.content)) {
+    return {
+      role: value.role,
+      content: value.content.map(
+        (child) => processStrandsInputNode(child, cache)
+      ),
+      ...value.metadata !== void 0 ? { metadata: value.metadata } : {}
+    };
+  }
+  if (typeof value.toJSON === "function") {
+    return processStrandsInputNode(value.toJSON(), cache);
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [
+      key,
+      processStrandsInputNode(child, cache)
+    ])
+  );
+}
+function processDirectStrandsMediaBlock(block, cache) {
+  if (!isStrandsMediaBlock(block)) {
+    return void 0;
+  }
+  const mediaKey = block.type === "imageBlock" ? "image" : block.type === "videoBlock" ? "video" : "document";
+  return createStrandsMediaAttachment(mediaKey, block, cache);
+}
+function isStrandsMediaBlock(block) {
+  return (block.type === "imageBlock" || block.type === "videoBlock" || block.type === "documentBlock") && typeof block.format === "string" && isObject(block.source);
+}
+function processWrappedStrandsMediaBlock(block, cache) {
+  for (const mediaKey of ["image", "video", "document"]) {
+    const media = block[mediaKey];
+    if (!Object.hasOwn(block, mediaKey) || !isObject(media)) {
+      continue;
+    }
+    const processed = createStrandsMediaAttachment(mediaKey, media, cache);
+    if (processed !== void 0) {
+      return processed;
+    }
+  }
+  return void 0;
+}
+function createStrandsMediaAttachment(mediaKey, media, cache) {
+  const format = media.format;
+  const source = media.source;
+  if (typeof format !== "string" || !isObject(source) || !Object.hasOwn(source, "bytes")) {
+    return void 0;
+  }
+  const contentType = STRANDS_MEDIA_TYPES[format.toLowerCase()];
+  if (!contentType) {
+    return void 0;
+  }
+  const filename = mediaKey === "document" && typeof media.name === "string" && media.name.length > 0 ? media.name : `${mediaKey}.${format.toLowerCase()}`;
+  const attachment = getOrCreateStrandsAttachment(
+    source.bytes,
+    filename,
+    contentType,
+    cache
+  );
+  if (!attachment) {
+    return void 0;
+  }
+  const { type: _type, ...serializedMedia } = media;
+  const { type: _sourceType, ...serializedSource } = source;
+  return {
+    [mediaKey]: {
+      ...serializedMedia,
+      source: {
+        ...serializedSource,
+        bytes: attachment
+      }
+    }
+  };
+}
+function getOrCreateStrandsAttachment(data, filename, contentType, cache) {
+  const key = `${contentType}\0${filename}`;
+  const attachments = typeof data === "string" ? cache.strings.get(data) : isObject(data) ? cache.objects.get(data) : void 0;
+  const cached = attachments?.get(key);
+  if (cached) {
+    return cached;
+  }
+  const blob = convertDataToBlob(data, contentType);
+  if (!blob) {
+    return void 0;
+  }
+  const attachment = new Attachment({
+    data: blob,
+    filename,
+    contentType
+  });
+  const updatedAttachments = attachments ?? /* @__PURE__ */ new Map();
+  updatedAttachments.set(key, attachment);
+  if (typeof data === "string") {
+    cache.strings.set(data, updatedAttachments);
+  } else if (isObject(data)) {
+    cache.objects.set(data, updatedAttachments);
+  }
+  return attachment;
+}
 function normalizeContentBlocks(blocks) {
   const text = blocks.map((block) => typeof block.text === "string" ? block.text : void 0).filter((part) => Boolean(part)).join("");
   return text.length > 0 ? text : blocks;
@@ -31079,6 +31822,7 @@ var BraintrustPlugin = class extends BasePlugin {
   gitHubCopilotPlugin = null;
   fluePlugin = null;
   langChainPlugin = null;
+  langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
   constructor(config = {}) {
@@ -31175,6 +31919,12 @@ var BraintrustPlugin = class extends BasePlugin {
       this.langChainPlugin = new LangChainPlugin();
       this.langChainPlugin.enable();
     }
+    if (integrations.langsmith !== false) {
+      this.langSmithPlugin = new LangSmithPlugin({
+        skipLangChainRuns: integrations.langchain !== false
+      });
+      this.langSmithPlugin.enable();
+    }
   }
   onDisable() {
     if (this.openaiPlugin) {
@@ -31265,6 +32015,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.langChainPlugin.disable();
       this.langChainPlugin = null;
     }
+    if (this.langSmithPlugin) {
+      this.langSmithPlugin.disable();
+      this.langSmithPlugin = null;
+    }
   }
 };
 
@@ -31329,7 +32083,8 @@ var envIntegrationAliases = {
   langchain: "langchain",
   "langchain-js": "langchain",
   "@langchain": "langchain",
-  langgraph: "langgraph"
+  langgraph: "langgraph",
+  langsmith: "langsmith"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -31360,6 +32115,7 @@ function getDefaultInstrumentationIntegrations() {
     gitHubCopilot: true,
     langchain: true,
     langgraph: true,
+    langsmith: true,
     piCodingAgent: true,
     strandsAgentSDK: true
   };
@@ -31580,6 +32336,8 @@ __export(exports_exports, {
   addAzureBlobHeaders: () => addAzureBlobHeaders,
   agentAssertionScorer: () => agentAssertionScorer,
   braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
+  braintrustEveHook: () => braintrustEveHook,
+  braintrustEveInstrumentation: () => braintrustEveInstrumentation,
   braintrustFlueInstrumentation: () => braintrustFlueInstrumentation,
   braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
@@ -31669,6 +32427,9 @@ __export(exports_exports, {
   wrapGoogleGenAI: () => wrapGoogleGenAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
+  wrapLangSmithClient: () => wrapLangSmithClient,
+  wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
+  wrapLangSmithTraceable: () => wrapLangSmithTraceable,
   wrapMastraAgent: () => wrapMastraAgent,
   wrapMistral: () => wrapMistral,
   wrapOpenAI: () => wrapOpenAI,
@@ -33080,6 +33841,1390 @@ function BraintrustMiddleware(config = {}) {
   };
 }
 
+// src/instrumentation/plugins/eve-plugin.ts
+var EVE_TRACE_STATE_KEY = "braintrust.eve.tracing";
+var MAX_EVE_CACHE_ENTRIES = 1e4;
+var MAX_STORED_LLM_INPUTS = 100;
+var MAX_STORED_SPAN_REFERENCES = 1e4;
+var MAX_STORED_STEP_STARTS = 1e4;
+function braintrustEveHook(options) {
+  const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
+  const bridge = new EveBridge(state);
+  return {
+    events: {
+      "*": async (event, ctx) => {
+        await bridge.handle(event, ctx, options.metadata);
+      }
+    }
+  };
+}
+function braintrustEveInstrumentation(options) {
+  const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
+  return {
+    events: {
+      "step.started": (input) => {
+        try {
+          captureEveModelInput(state, input);
+        } catch (error) {
+          debugLogger.warn("Error in Eve LLM input capture:", error);
+        }
+      }
+    },
+    recordInputs: false,
+    recordOutputs: false,
+    setup: options.setup
+  };
+}
+function isEveHandleMessageStreamEvent(event) {
+  return isObject(event) && typeof event["type"] === "string";
+}
+var ResumedEveSpan = class {
+  constructor(reference) {
+    this.reference = reference;
+    this.endTime = reference.endTime;
+  }
+  endTime;
+  get rootSpanId() {
+    return this.reference.rootSpanId;
+  }
+  get spanId() {
+    return this.reference.spanId;
+  }
+  log(event) {
+    const metrics = {
+      ...this.reference.startEvent?.metrics,
+      ...this.endTime === void 0 ? {} : { end: this.endTime },
+      ...event.metrics
+    };
+    updateSpan({
+      exported: this.reference.exported,
+      ...this.reference.startEvent,
+      ...event,
+      ...Object.keys(metrics).length > 0 ? { metrics } : {}
+    });
+  }
+  end(args) {
+    if (this.endTime === void 0) {
+      this.endTime = args?.endTime ?? getCurrentUnixTimestamp();
+      this.log({ metrics: { end: this.endTime } });
+    }
+    return this.endTime;
+  }
+};
+var EveBridge = class {
+  constructor(state) {
+    this.state = state;
+  }
+  eventQueuesBySession = /* @__PURE__ */ new Map();
+  completedToolKeys = new LRUCache({
+    max: MAX_EVE_CACHE_ENTRIES
+  });
+  toolsByCallKey = new LRUCache({
+    max: MAX_EVE_CACHE_ENTRIES
+  });
+  turnsByKey = new LRUCache({
+    max: MAX_EVE_CACHE_ENTRIES
+  });
+  async startEveSpan(args) {
+    const rowId = args?.event?.id;
+    const reference = typeof rowId === "string" && readEveTraceState(this.state).spanReferences.find(
+      (candidate) => candidate.rowId === rowId
+    );
+    if (reference) {
+      return new ResumedEveSpan(reference);
+    }
+    const startTime = args?.startTime ?? getCurrentUnixTimestamp();
+    const parentSpanIds = args?.parentSpanIds;
+    const startEvent = {
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      metrics: { start: startTime },
+      span_attributes: {
+        ...args?.name ? { name: args.name } : {},
+        ...args?.type ? { type: args.type } : {},
+        ...args?.spanAttributes
+      },
+      span_parents: parentSpanIds ? "spanId" in parentSpanIds ? [parentSpanIds.spanId] : parentSpanIds.parentSpanIds : []
+    };
+    const span = withCurrent(
+      NOOP_SPAN,
+      () => _internalStartSpanWithInitialMerge({ ...args, startTime })
+    );
+    if (typeof rowId !== "string") {
+      return span;
+    }
+    try {
+      const exported = await span.export();
+      const reference2 = {
+        exported,
+        rootSpanId: span.rootSpanId,
+        rowId,
+        spanId: span.spanId,
+        startEvent
+      };
+      this.state.update((current) => {
+        const normalized = normalizeEveTraceState(current);
+        return normalized.spanReferences.some(
+          (candidate) => candidate.rowId === rowId
+        ) ? normalized : {
+          ...normalized,
+          spanReferences: [...normalized.spanReferences, reference2].slice(
+            -MAX_STORED_SPAN_REFERENCES
+          )
+        };
+      });
+    } catch (error) {
+      debugLogger.warn("Error exporting Eve span for resumption:", error);
+    }
+    return span;
+  }
+  async startEveChildSpan(parent, args) {
+    return await this.startEveSpan({
+      ...args,
+      parentSpanIds: {
+        rootSpanId: parent.rootSpanId,
+        spanId: parent.spanId
+      }
+    });
+  }
+  stepOrdinal(event) {
+    let ordinal = 0;
+    this.state.update((current) => {
+      const state = normalizeEveTraceState(current);
+      const previous = state.stepStarts.filter(
+        (entry) => entry.turnId === event.data.turnId && entry.stepIndex === event.data.stepIndex
+      ).at(-1);
+      if (previous?.open) {
+        ordinal = previous.ordinal;
+        return state;
+      }
+      ordinal = state.stepStarts.filter(
+        (entry) => entry.turnId === event.data.turnId
+      ).length;
+      return {
+        ...state,
+        stepStarts: [
+          ...state.stepStarts,
+          {
+            open: true,
+            ordinal,
+            stepIndex: event.data.stepIndex,
+            turnId: event.data.turnId
+          }
+        ].slice(-MAX_STORED_STEP_STARTS)
+      };
+    });
+    return ordinal;
+  }
+  markStepEnded(turnId, stepIndex) {
+    this.state.update((current) => {
+      const state = normalizeEveTraceState(current);
+      let index = -1;
+      for (let i = state.stepStarts.length - 1; i >= 0; i--) {
+        const entry = state.stepStarts[i];
+        if (entry?.turnId === turnId && entry.stepIndex === stepIndex) {
+          index = i;
+          break;
+        }
+      }
+      if (index < 0 || !state.stepStarts[index]?.open) {
+        return state;
+      }
+      return {
+        ...state,
+        stepStarts: state.stepStarts.map(
+          (entry, entryIndex) => entryIndex === index ? { ...entry, open: false } : entry
+        )
+      };
+    });
+  }
+  async handle(event, ctx, hookMetadata) {
+    if (!isEveHandleMessageStreamEvent(event)) {
+      return;
+    }
+    const run = async () => {
+      try {
+        if (!await this.handleEvent(event, ctx, hookMetadata)) {
+          return;
+        }
+        if (event.type === "session.failed") {
+          const sessionId2 = event.data.sessionId || sessionIdFromContext(ctx);
+          await this.flushInstrumentation();
+          if (sessionId2) {
+            this.cleanupSession(sessionId2);
+          }
+        } else if (event.type === "session.completed") {
+          const sessionId2 = sessionIdFromContext(ctx);
+          await this.flushInstrumentation();
+          if (sessionId2) {
+            this.cleanupSession(sessionId2);
+          }
+        }
+      } catch (error) {
+        debugLogger.warn("Error in Eve hook instrumentation:", error);
+      }
+    };
+    const sessionId = event.type === "session.failed" ? event.data.sessionId || sessionIdFromContext(ctx) : sessionIdFromContext(ctx);
+    if (!sessionId) {
+      await run();
+      return;
+    }
+    const previous = this.eventQueuesBySession.get(sessionId);
+    const queued = previous ? previous.then(run) : run();
+    this.eventQueuesBySession.set(sessionId, queued);
+    try {
+      await queued;
+    } finally {
+      if (this.eventQueuesBySession.get(sessionId) === queued) {
+        this.eventQueuesBySession.delete(sessionId);
+      }
+    }
+  }
+  async handleEvent(event, ctx, hookMetadata) {
+    switch (event.type) {
+      case "session.started":
+        this.handleSessionStarted(event, ctx, hookMetadata);
+        return true;
+      case "turn.started":
+        await this.handleTurnStarted(event, ctx, hookMetadata);
+        return true;
+      case "message.received":
+        await this.handleMessageReceived(event, ctx, hookMetadata);
+        return true;
+      case "step.started":
+        await this.handleStepStarted(event, ctx, hookMetadata);
+        return true;
+      case "message.completed":
+        this.handleMessageCompleted(event, ctx);
+        return true;
+      case "result.completed":
+        this.handleResultCompleted(event, ctx);
+        return true;
+      case "actions.requested":
+        await this.handleActionsRequested(event, ctx, hookMetadata);
+        return true;
+      case "action.result":
+        await this.handleActionResult(event, ctx, hookMetadata);
+        return true;
+      case "subagent.called":
+        await this.handleSubagentCalled(event, ctx, hookMetadata);
+        return true;
+      case "subagent.completed":
+        await this.handleSubagentCompleted(event, ctx, hookMetadata);
+        return true;
+      case "step.completed":
+        this.handleStepCompleted(event, ctx);
+        return true;
+      case "step.failed":
+        this.handleStepFailed(event, ctx);
+        return true;
+      case "turn.completed":
+        this.handleTurnCompleted(event, ctx);
+        return true;
+      case "turn.failed":
+        this.handleTurnFailed(event, ctx);
+        return true;
+      case "session.failed":
+        this.handleSessionFailed(event, ctx);
+        return true;
+      case "session.completed":
+        this.handleSessionCompleted(event, ctx);
+        return true;
+      default:
+        return false;
+    }
+  }
+  handleSessionStarted(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const metadata = {
+      ...hookMetadata ?? {},
+      ...modelMetadataFromRuntime(event.data.runtime)
+    };
+    this.state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      return {
+        ...normalized,
+        metadata: { ...normalized.metadata, ...metadata }
+      };
+    });
+    for (const [key, turn] of this.turnsByKey) {
+      if (!key.startsWith(`${sessionId}:`)) {
+        continue;
+      }
+      turn.metadata = { ...turn.metadata, ...metadata };
+      turn.span.log({ metadata: turn.metadata });
+      for (const step of turn.stepsByIndex.values()) {
+        step.metadata = { ...step.metadata, ...metadata };
+        step.span.log({ metadata: step.metadata });
+      }
+    }
+  }
+  async handleTurnStarted(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const key = turnKey2(sessionId, event.data.turnId);
+    const metadata = {
+      ...readEveTraceState(this.state).metadata,
+      ...hookMetadata ?? {},
+      "eve.session_id": sessionId
+    };
+    const existing = this.turnsByKey.get(key);
+    if (existing) {
+      existing.metadata = { ...existing.metadata, ...metadata };
+      existing.span.log({ metadata: existing.metadata });
+      return;
+    }
+    const span = await this.startTurnSpan(sessionId, event, ctx, metadata);
+    span.log({ metadata });
+    this.turnsByKey.set(key, {
+      key,
+      metadata,
+      metrics: {},
+      span,
+      stepsByIndex: /* @__PURE__ */ new Map(),
+      turnId: event.data.turnId
+    });
+  }
+  async handleMessageReceived(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    if (!turn) {
+      return;
+    }
+    const input = [{ content: event.data.message, role: "user" }];
+    turn.span.log({ input });
+  }
+  async handleStepStarted(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return;
+    }
+    const existing = turn.stepsByIndex.get(event.data.stepIndex);
+    if (existing) {
+      existing.span.log({
+        ...existing.input !== void 0 ? { input: existing.input } : {},
+        metadata: existing.metadata,
+        metrics: existing.metrics,
+        output: existing.output
+      });
+      const endTime = eventTime2(event);
+      existing.span.end(endTime === void 0 ? void 0 : { endTime });
+      this.markStepEnded(event.data.turnId, event.data.stepIndex);
+    }
+    const stepOrdinal = this.stepOrdinal(event);
+    const metadata = { ...turn.metadata };
+    const input = consumeCapturedEveModelInput(
+      this.state,
+      sessionId,
+      event.data.turnId,
+      event.data.stepIndex
+    );
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "step",
+      sessionId,
+      event.data.turnId,
+      String(stepOrdinal)
+    );
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        ...input !== void 0 ? { input } : {},
+        metadata
+      },
+      name: "eve.step",
+      spanAttributes: { type: "llm" /* LLM */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ ...input !== void 0 ? { input } : {}, metadata });
+    turn.stepsByIndex.set(event.data.stepIndex, {
+      ...input !== void 0 ? { input } : {},
+      metadata,
+      metrics: {},
+      span
+    });
+  }
+  handleMessageCompleted(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (!step) {
+      return;
+    }
+    const existingMessage = Array.isArray(step.output) && isObject(step.output[0]) ? step.output[0].message : void 0;
+    const existingToolCalls = isObject(existingMessage) ? existingMessage.tool_calls : void 0;
+    step.output = [
+      {
+        finish_reason: normalizedFinishReason(event.data.finishReason),
+        index: 0,
+        message: {
+          content: event.data.message,
+          role: "assistant",
+          ...Array.isArray(existingToolCalls) ? { tool_calls: existingToolCalls } : {}
+        }
+      }
+    ];
+    const turn = this.turnForEvent(event, ctx);
+    if (turn && event.data.finishReason !== "tool-calls") {
+      turn.output = event.data.message;
+    }
+  }
+  handleResultCompleted(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (step) {
+      step.output = [
+        {
+          finish_reason: "stop",
+          index: 0,
+          message: {
+            content: event.data.result,
+            role: "assistant"
+          }
+        }
+      ];
+    }
+    const turn = this.turnForEvent(event, ctx);
+    if (turn) {
+      turn.output = event.data.result;
+    }
+  }
+  async handleActionsRequested(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return;
+    }
+    const traceActions = event.data.actions.filter(isTraceableActionRequest);
+    if (traceActions.length === 0) {
+      return;
+    }
+    for (const action of traceActions) {
+      if (isToolCallAction(action)) {
+        await this.startRequestedTool(event, turn, sessionId, action);
+      } else if (isLocalSubagentCallAction(action)) {
+        await this.startRequestedSubagent(event, turn, sessionId, action);
+      }
+    }
+    const step = turn.stepsByIndex.get(event.data.stepIndex);
+    if (!step) {
+      return;
+    }
+    const toolCallsById = /* @__PURE__ */ new Map();
+    if (Array.isArray(step.output) && isObject(step.output[0])) {
+      const message = step.output[0]["message"];
+      if (isObject(message) && Array.isArray(message["tool_calls"])) {
+        for (const toolCall of message["tool_calls"]) {
+          if (isObject(toolCall) && typeof toolCall["id"] === "string") {
+            toolCallsById.set(toolCall["id"], toolCall);
+          }
+        }
+      }
+    }
+    for (const action of traceActions) {
+      const name = action.kind === "tool-call" ? action.toolName : action.subagentName ?? action.name ?? "agent";
+      toolCallsById.set(action.callId, {
+        function: {
+          arguments: JSON.stringify(action.input),
+          name
+        },
+        id: action.callId,
+        type: "function"
+      });
+    }
+    step.output = [
+      {
+        finish_reason: "tool_calls",
+        index: 0,
+        message: {
+          content: null,
+          role: "assistant",
+          tool_calls: [...toolCallsById.values()]
+        }
+      }
+    ];
+    step.span.log({ metadata: step.metadata, output: step.output });
+  }
+  async handleActionResult(event, ctx, hookMetadata) {
+    if (isToolResult(event.data.result)) {
+      await this.handleToolResult(event, ctx, event.data.result, hookMetadata);
+      return;
+    }
+    if (isSubagentResult(event.data.result)) {
+      await this.handleSubagentResult(
+        event,
+        ctx,
+        event.data.result,
+        hookMetadata
+      );
+    }
+  }
+  async handleToolResult(event, ctx, result, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, result.callId);
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const tool = this.toolsByCallKey.get(key) ?? await this.startSyntheticTool(event, ctx, result, hookMetadata);
+    if (!tool) {
+      return;
+    }
+    const failed = event.data.status === "failed" || result.isError === true || event.data.error !== void 0;
+    tool.span.log({
+      ...failed ? {
+        error: actionResultError(event.data.error, result.output)
+      } : {},
+      metadata: tool.metadata,
+      output: result.output
+    });
+    const endTime = eventTime2(event);
+    tool.span.end(endTime === void 0 ? void 0 : { endTime });
+    this.toolsByCallKey.delete(key);
+    this.completedToolKeys.set(key, true);
+  }
+  async handleSubagentCalled(event, ctx, hookMetadata) {
+    if (event.data.remote?.url) {
+      return;
+    }
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, event.data.callId);
+    const metadata = toolMetadataFromTurn(turn);
+    const existing = this.toolsByCallKey.get(key);
+    if (existing) {
+      existing.metadata = { ...existing.metadata, ...metadata };
+      existing.span.log({ metadata: existing.metadata });
+      return;
+    }
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      event.data.callId
+    );
+    const pending = this.toolsByCallKey.get(key);
+    if (pending || this.completedToolKeys.has(key)) {
+      if (pending) {
+        pending.metadata = { ...pending.metadata, ...metadata };
+        pending.span.log({ metadata: pending.metadata });
+      }
+      return;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: event.data.toolName ?? event.data.name,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    this.toolsByCallKey.set(key, {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    });
+  }
+  async handleSubagentCompleted(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, event.data.callId);
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const subagent = this.toolsByCallKey.get(key) ?? await this.startSyntheticSubagent(event, ctx, hookMetadata);
+    if (!subagent) {
+      return;
+    }
+    subagent.span.log({
+      ...event.data.status === "failed" ? {
+        error: actionResultError(event.data.error, event.data.output)
+      } : {},
+      metadata: subagent.metadata,
+      ...event.data.output !== void 0 ? { output: event.data.output } : {}
+    });
+    const endTime = eventTime2(event);
+    const recordedEndTime = subagent.span.end(
+      endTime === void 0 ? void 0 : { endTime }
+    );
+    this.state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      return {
+        ...normalized,
+        spanReferences: normalized.spanReferences.map(
+          (reference) => reference.spanId === subagent.span.spanId ? { ...reference, endTime: recordedEndTime } : reference
+        )
+      };
+    });
+  }
+  async handleSubagentResult(event, ctx, result, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const key = toolKey3(sessionId, result.callId);
+    if (this.completedToolKeys.has(key)) {
+      return;
+    }
+    const subagent = this.toolsByCallKey.get(key) ?? await this.startSyntheticSubagentResult(
+      event,
+      ctx,
+      result,
+      hookMetadata
+    );
+    if (!subagent) {
+      return;
+    }
+    const isError = event.data.status === "failed" || result.isError === true || event.data.error !== void 0;
+    subagent.span.log({
+      ...isError ? {
+        error: actionResultError(event.data.error, result.output)
+      } : {},
+      metadata: subagent.metadata,
+      output: result.output
+    });
+    const endTime = eventTime2(event);
+    subagent.span.end(endTime === void 0 ? void 0 : { endTime });
+    this.toolsByCallKey.delete(key);
+    this.completedToolKeys.set(key, true);
+  }
+  handleStepCompleted(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (!step) {
+      return;
+    }
+    const usage = event.data.usage;
+    const inputTokens = typeof usage?.inputTokens === "number" && Number.isFinite(usage.inputTokens) && usage.inputTokens >= 0 ? usage.inputTokens : void 0;
+    const outputTokens = typeof usage?.outputTokens === "number" && Number.isFinite(usage.outputTokens) && usage.outputTokens >= 0 ? usage.outputTokens : void 0;
+    const cacheReadTokens = typeof usage?.cacheReadTokens === "number" && Number.isFinite(usage.cacheReadTokens) && usage.cacheReadTokens >= 0 ? usage.cacheReadTokens : void 0;
+    const cacheWriteTokens = typeof usage?.cacheWriteTokens === "number" && Number.isFinite(usage.cacheWriteTokens) && usage.cacheWriteTokens >= 0 ? usage.cacheWriteTokens : void 0;
+    const costUsd = typeof usage?.costUsd === "number" && Number.isFinite(usage.costUsd) && usage.costUsd >= 0 ? usage.costUsd : void 0;
+    const total = inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0;
+    const metrics = {
+      ...inputTokens !== void 0 ? { prompt_tokens: inputTokens } : {},
+      ...outputTokens !== void 0 ? { completion_tokens: outputTokens } : {},
+      ...total !== void 0 ? { tokens: total } : {},
+      ...cacheReadTokens !== void 0 ? { prompt_cached_tokens: cacheReadTokens } : {},
+      ...cacheWriteTokens !== void 0 ? { prompt_cache_creation_tokens: cacheWriteTokens } : {},
+      ...costUsd !== void 0 ? { estimated_cost: costUsd } : {}
+    };
+    step.metrics = { ...step.metrics, ...metrics };
+    if (Array.isArray(step.output) && isObject(step.output[0])) {
+      const finishReason = step.output[0].finish_reason;
+      if (typeof finishReason !== "string") {
+        step.output[0].finish_reason = normalizedFinishReason(
+          event.data.finishReason
+        );
+      }
+    }
+    step.span.log({
+      ...step.input !== void 0 ? { input: step.input } : {},
+      metadata: step.metadata,
+      metrics,
+      output: step.output
+    });
+    const endTime = eventTime2(event);
+    step.span.end(endTime === void 0 ? void 0 : { endTime });
+    const turn = this.turnForEvent(event, ctx);
+    if (turn) {
+      for (const [key, value] of Object.entries(metrics)) {
+        turn.metrics[key] = (turn.metrics[key] ?? 0) + value;
+      }
+      turn.stepsByIndex.delete(event.data.stepIndex);
+    }
+    this.markStepEnded(event.data.turnId, event.data.stepIndex);
+  }
+  handleStepFailed(event, ctx) {
+    const step = this.stepForEvent(event, ctx);
+    if (step) {
+      step.span.log({
+        error: errorFromMessage(
+          event.data.message,
+          event.data.code,
+          event.data.details
+        )
+      });
+      const endTime = eventTime2(event);
+      step.span.end(endTime === void 0 ? void 0 : { endTime });
+    }
+    const turn = this.turnForEvent(event, ctx);
+    turn?.stepsByIndex.delete(event.data.stepIndex);
+    this.markStepEnded(event.data.turnId, event.data.stepIndex);
+  }
+  handleTurnCompleted(event, ctx) {
+    const turn = this.turnForEvent(event, ctx);
+    if (!turn) {
+      return;
+    }
+    this.finalizeTurn(turn, {
+      endTime: eventTime2(event)
+    });
+  }
+  handleTurnFailed(event, ctx) {
+    const turn = this.turnForEvent(event, ctx);
+    if (!turn) {
+      return;
+    }
+    this.finalizeTurn(turn, {
+      endTime: eventTime2(event),
+      error: errorFromMessage(
+        event.data.message,
+        event.data.code,
+        event.data.details
+      )
+    });
+  }
+  handleSessionFailed(event, ctx) {
+    const sessionId = event.data.sessionId || sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    const error = errorFromMessage(
+      event.data.message,
+      event.data.code,
+      event.data.details
+    );
+    for (const [key, turn] of this.turnsByKey) {
+      if (!key.startsWith(`${sessionId}:`)) {
+        continue;
+      }
+      this.finalizeTurn(turn, {
+        endTime: eventTime2(event),
+        error
+      });
+    }
+    for (const [key, tool] of this.toolsByCallKey) {
+      if (key.startsWith(`${sessionId}:`)) {
+        const endTime = eventTime2(event);
+        if (!tool.endedByTurn) {
+          tool.span.log({ metadata: tool.metadata });
+          tool.span.end(endTime === void 0 ? void 0 : { endTime });
+          tool.endedByTurn = true;
+        }
+      }
+    }
+  }
+  handleSessionCompleted(event, ctx) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return;
+    }
+    for (const [key, turn] of this.turnsByKey) {
+      if (!key.startsWith(`${sessionId}:`)) {
+        continue;
+      }
+      this.finalizeTurn(turn, {
+        endTime: eventTime2(event)
+      });
+    }
+    for (const [key, tool] of this.toolsByCallKey) {
+      if (key.startsWith(`${sessionId}:`) && !tool.endedByTurn) {
+        const endTime = eventTime2(event);
+        tool.span.log({ metadata: tool.metadata });
+        tool.span.end(endTime === void 0 ? void 0 : { endTime });
+        tool.endedByTurn = true;
+      }
+    }
+  }
+  async ensureTurn(event, ctx, hookMetadata) {
+    const sessionId = sessionIdFromContext(ctx);
+    if (!sessionId) {
+      return void 0;
+    }
+    const key = turnKey2(sessionId, event.data.turnId);
+    const existing = this.turnsByKey.get(key);
+    if (existing) {
+      return existing;
+    }
+    const metadata = {
+      ...readEveTraceState(this.state).metadata,
+      ...hookMetadata ?? {},
+      "eve.session_id": sessionId
+    };
+    const span = await this.startTurnSpan(sessionId, event, ctx, metadata);
+    span.log({ metadata });
+    const state = {
+      key,
+      metadata,
+      metrics: {},
+      span,
+      stepsByIndex: /* @__PURE__ */ new Map(),
+      turnId: event.data.turnId
+    };
+    this.turnsByKey.set(key, state);
+    return state;
+  }
+  async startRequestedTool(event, turn, sessionId, action) {
+    const key = toolKey3(sessionId, action.callId);
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "tool",
+      sessionId,
+      event.data.turnId,
+      action.callId
+    );
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        input: action.input,
+        metadata
+      },
+      name: action.toolName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ input: action.input, metadata });
+    this.toolsByCallKey.set(key, {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    });
+  }
+  async startRequestedSubagent(event, turn, sessionId, action) {
+    const key = toolKey3(sessionId, action.callId);
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const name = action.subagentName ?? action.name ?? "agent";
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      action.callId
+    );
+    if (this.toolsByCallKey.has(key) || this.completedToolKeys.has(key)) {
+      return;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        input: action.input,
+        metadata
+      },
+      name,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ input: action.input, metadata });
+    this.toolsByCallKey.set(key, {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    });
+  }
+  async startSyntheticTool(event, ctx, result, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return void 0;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "tool",
+      sessionId,
+      event.data.turnId,
+      result.callId
+    );
+    const existing = this.toolsByCallKey.get(toolKey3(sessionId, result.callId));
+    if (existing) {
+      return existing;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: result.toolName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    const state = {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    };
+    this.toolsByCallKey.set(toolKey3(sessionId, result.callId), state);
+    return state;
+  }
+  async startSyntheticSubagent(event, ctx, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return void 0;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      event.data.callId
+    );
+    const existing = this.toolsByCallKey.get(
+      toolKey3(sessionId, event.data.callId)
+    );
+    if (existing) {
+      return existing;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: event.data.subagentName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    const state = {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    };
+    this.toolsByCallKey.set(toolKey3(sessionId, event.data.callId), state);
+    return state;
+  }
+  async startSyntheticSubagentResult(event, ctx, result, hookMetadata) {
+    const turn = await this.ensureTurn(event, ctx, hookMetadata);
+    const sessionId = sessionIdFromContext(ctx);
+    if (!turn || !sessionId) {
+      return void 0;
+    }
+    const metadata = toolMetadataFromTurn(turn);
+    const { rowId: eventId, spanId } = await generateEveIds(
+      "subagent",
+      sessionId,
+      result.callId
+    );
+    const existing = this.toolsByCallKey.get(toolKey3(sessionId, result.callId));
+    if (existing) {
+      return existing;
+    }
+    const span = await this.startEveChildSpan(turn.span, {
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: result.subagentName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+    span.log({ metadata });
+    const state = {
+      metadata,
+      span,
+      turnKey: turnKey2(sessionId, event.data.turnId)
+    };
+    this.toolsByCallKey.set(toolKey3(sessionId, result.callId), state);
+    return state;
+  }
+  async startTurnSpan(sessionId, event, ctx, metadata) {
+    const session = isObject(ctx) ? ctx["session"] : void 0;
+    const parent = isObject(session) ? session["parent"] : void 0;
+    const parentTurn = isObject(parent) ? parent["turn"] : void 0;
+    const parentLineage = isObject(parent) && typeof parent["callId"] === "string" && typeof parent["sessionId"] === "string" && isObject(parentTurn) && typeof parentTurn["id"] === "string" ? {
+      callId: parent["callId"],
+      sessionId: parent["sessionId"],
+      turnId: parentTurn["id"]
+    } : void 0;
+    const [{ rowId: eventId, spanId }, rootSpanId, parentSpanId] = await Promise.all([
+      generateEveIds("turn", sessionId, event.data.turnId),
+      deterministicEveId(
+        "eve:root",
+        parentLineage?.sessionId ?? sessionId,
+        parentLineage?.turnId ?? event.data.turnId
+      ),
+      parentLineage ? deterministicEveId(
+        "eve:subagent",
+        parentLineage.sessionId,
+        parentLineage.callId
+      ) : Promise.resolve(void 0)
+    ]);
+    return await this.startEveSpan({
+      event: {
+        id: eventId,
+        metadata
+      },
+      name: "eve.turn",
+      parentSpanIds: parentSpanId ? { rootSpanId, spanId: parentSpanId } : { parentSpanIds: [], rootSpanId },
+      spanAttributes: { type: "task" /* TASK */ },
+      spanId,
+      startTime: eventTime2(event)
+    });
+  }
+  turnForEvent(event, ctx) {
+    const sessionId = sessionIdFromContext(ctx);
+    return sessionId ? this.turnsByKey.get(turnKey2(sessionId, event.data.turnId)) : void 0;
+  }
+  stepForEvent(event, ctx) {
+    return this.turnForEvent(event, ctx)?.stepsByIndex.get(
+      event.data.stepIndex
+    );
+  }
+  finalizeTurn(turn, args) {
+    const { endTime } = args;
+    for (const step of turn.stepsByIndex.values()) {
+      step.span.log({
+        ...step.input !== void 0 ? { input: step.input } : {},
+        metadata: step.metadata,
+        metrics: step.metrics,
+        output: step.output
+      });
+      step.span.end(endTime === void 0 ? void 0 : { endTime });
+    }
+    turn.stepsByIndex.clear();
+    for (const tool of this.toolsByCallKey.values()) {
+      if (tool.turnKey !== turn.key) {
+        continue;
+      }
+      if (tool.endedByTurn) {
+        continue;
+      }
+      tool.span.log({ metadata: tool.metadata });
+      tool.span.end(endTime === void 0 ? void 0 : { endTime });
+      tool.endedByTurn = true;
+    }
+    if (args.error) {
+      turn.span.log({ error: args.error });
+    } else {
+      turn.span.log({
+        metadata: turn.metadata,
+        metrics: turn.metrics,
+        output: turn.output
+      });
+    }
+    turn.span.end(endTime === void 0 ? void 0 : { endTime });
+    this.turnsByKey.delete(turn.key);
+    this.state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      return {
+        ...normalized,
+        stepStarts: normalized.stepStarts.filter(
+          (entry) => entry.turnId !== turn.turnId
+        )
+      };
+    });
+  }
+  cleanupSession(sessionId) {
+    const keyPrefix = `${sessionId}:`;
+    for (const key of this.turnsByKey.keys()) {
+      if (key.startsWith(keyPrefix)) {
+        this.turnsByKey.delete(key);
+      }
+    }
+    for (const key of this.toolsByCallKey.keys()) {
+      if (key.startsWith(keyPrefix)) {
+        this.toolsByCallKey.delete(key);
+      }
+    }
+    for (const key of this.completedToolKeys.keys()) {
+      if (key.startsWith(keyPrefix)) {
+        this.completedToolKeys.delete(key);
+      }
+    }
+    this.state.update(() => emptyEveTraceState());
+  }
+  async flushInstrumentation() {
+    try {
+      await flush();
+      return true;
+    } catch (error) {
+      debugLogger.warn("Error in Eve flush instrumentation:", error);
+      return false;
+    }
+  }
+};
+function emptyEveTraceState() {
+  return {
+    llmInputs: [],
+    metadata: {},
+    spanReferences: [],
+    stepStarts: []
+  };
+}
+function normalizeEveTraceState(state) {
+  if (!isObject(state)) {
+    return emptyEveTraceState();
+  }
+  const metadata = isObject(state["metadata"]) ? state["metadata"] : {};
+  const spanReferences = Array.isArray(state["spanReferences"]) ? state["spanReferences"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const exported = entry["exported"];
+    const endTime = entry["endTime"];
+    const rootSpanId = entry["rootSpanId"];
+    const rowId = entry["rowId"];
+    const spanId = entry["spanId"];
+    const startEvent = entry["startEvent"];
+    const startEventCreated = isObject(startEvent) ? startEvent["created"] : void 0;
+    const startEventMetrics = isObject(startEvent) ? startEvent["metrics"] : void 0;
+    const startEventSpanAttributes = isObject(startEvent) ? startEvent["span_attributes"] : void 0;
+    const startEventSpanParents = isObject(startEvent) ? startEvent["span_parents"] : void 0;
+    const normalizedStartEvent = typeof startEventCreated === "string" && isObject(startEventMetrics) && typeof startEventMetrics["start"] === "number" && Number.isFinite(startEventMetrics["start"]) && isObject(startEventSpanAttributes) && Array.isArray(startEventSpanParents) && startEventSpanParents.every(
+      (parent) => typeof parent === "string"
+    ) ? {
+      created: startEventCreated,
+      metrics: { start: startEventMetrics["start"] },
+      span_attributes: { ...startEventSpanAttributes },
+      span_parents: [...startEventSpanParents]
+    } : void 0;
+    return typeof exported === "string" && typeof rootSpanId === "string" && typeof rowId === "string" && typeof spanId === "string" ? [
+      {
+        ...typeof endTime === "number" && Number.isFinite(endTime) ? { endTime } : {},
+        exported,
+        rootSpanId,
+        rowId,
+        spanId,
+        ...normalizedStartEvent ? { startEvent: normalizedStartEvent } : {}
+      }
+    ] : [];
+  }).slice(-MAX_STORED_SPAN_REFERENCES) : [];
+  const llmInputs = Array.isArray(state["llmInputs"]) ? state["llmInputs"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const key = entry["key"];
+    const input = entry["input"];
+    return typeof key === "string" && isCapturedModelInput(input) ? [{ input, key }] : [];
+  }).slice(-MAX_STORED_LLM_INPUTS) : [];
+  const stepStarts = Array.isArray(state["stepStarts"]) ? state["stepStarts"].flatMap((entry) => {
+    if (!isObject(entry)) {
+      return [];
+    }
+    const ordinal = entry["ordinal"];
+    const open = entry["open"];
+    const stepIndex = entry["stepIndex"];
+    const turnId = entry["turnId"];
+    return typeof ordinal === "number" && Number.isInteger(ordinal) && ordinal >= 0 && typeof open === "boolean" && typeof stepIndex === "number" && Number.isInteger(stepIndex) && typeof turnId === "string" ? [{ open, ordinal, stepIndex, turnId }] : [];
+  }).slice(-MAX_STORED_STEP_STARTS) : [];
+  return { llmInputs, metadata: { ...metadata }, spanReferences, stepStarts };
+}
+function readEveTraceState(state) {
+  try {
+    return normalizeEveTraceState(state.get());
+  } catch {
+    return emptyEveTraceState();
+  }
+}
+function captureEveModelInput(state, input) {
+  if (!isObject(input)) {
+    return;
+  }
+  const session = input["session"];
+  const turn = input["turn"];
+  const step = input["step"];
+  if (!isObject(session) || !isObject(turn) || !isObject(step)) {
+    return;
+  }
+  const sessionId = session["id"];
+  const turnId = turn["id"];
+  const stepIndex = step["index"];
+  if (typeof sessionId !== "string" || typeof turnId !== "string" || typeof stepIndex !== "number" || !Number.isInteger(stepIndex)) {
+    return;
+  }
+  const captured = capturedModelInput(input["modelInput"]);
+  if (!captured) {
+    return;
+  }
+  const key = llmInputKey(sessionId, turnId, stepIndex);
+  state.update((current) => {
+    const normalized = normalizeEveTraceState(current);
+    const llmInputs = [...normalized.llmInputs, { input: captured, key }];
+    return {
+      ...normalized,
+      llmInputs: llmInputs.slice(-MAX_STORED_LLM_INPUTS)
+    };
+  });
+}
+function consumeCapturedEveModelInput(state, sessionId, turnId, stepIndex) {
+  try {
+    const key = llmInputKey(sessionId, turnId, stepIndex);
+    let input;
+    state.update((current) => {
+      const normalized = normalizeEveTraceState(current);
+      const index = normalized.llmInputs.findIndex(
+        (candidate) => candidate.key === key
+      );
+      if (index < 0) {
+        return normalized;
+      }
+      input = normalized.llmInputs[index]?.input;
+      return {
+        ...normalized,
+        llmInputs: normalized.llmInputs.filter(
+          (_, candidateIndex) => candidateIndex !== index
+        )
+      };
+    });
+    return input;
+  } catch (error) {
+    debugLogger.warn("Error in Eve LLM input consumption:", error);
+    return void 0;
+  }
+}
+function capturedModelInput(modelInput) {
+  if (!isObject(modelInput)) {
+    return void 0;
+  }
+  const messages = modelInput["messages"];
+  if (!Array.isArray(messages)) {
+    return void 0;
+  }
+  const instructions = modelInput["instructions"];
+  const value = [
+    ...instructions !== void 0 ? [{ content: instructions, role: "system" }] : [],
+    ...messages
+  ];
+  try {
+    const cloned = JSON.parse(JSON.stringify(value));
+    if (!Array.isArray(cloned)) {
+      return void 0;
+    }
+    return cloned;
+  } catch {
+    return void 0;
+  }
+}
+function isCapturedModelInput(input) {
+  return Array.isArray(input);
+}
+function llmInputKey(sessionId, turnId, stepIndex) {
+  return `${sessionId}\0${turnId}\0${stepIndex}`;
+}
+function modelMetadataFromRuntime(runtime) {
+  if (!isObject(runtime)) {
+    return {};
+  }
+  const modelId = runtime["modelId"];
+  return typeof modelId === "string" && !modelId.trim().startsWith("dynamic:") ? modelMetadataFromModelId(modelId) : {};
+}
+function modelMetadataFromModelId(modelId) {
+  const normalized = modelId.trim();
+  if (!normalized) {
+    return {};
+  }
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex > 0 && slashIndex < normalized.length - 1) {
+    return {
+      model: normalized.slice(slashIndex + 1),
+      provider: normalized.slice(0, slashIndex)
+    };
+  }
+  return {
+    model: normalized
+  };
+}
+function sessionIdFromContext(ctx) {
+  if (!isObject(ctx)) {
+    return void 0;
+  }
+  const session = ctx["session"];
+  if (!isObject(session)) {
+    return void 0;
+  }
+  const id = session["id"];
+  return typeof id === "string" ? id : void 0;
+}
+function toolMetadataFromTurn(turn) {
+  const { model: _model, provider: _provider, ...metadata } = turn.metadata;
+  return metadata;
+}
+function isToolCallAction(action) {
+  return isObject(action) && action["kind"] === "tool-call" && typeof action["callId"] === "string" && typeof action["toolName"] === "string" && isObject(action["input"]);
+}
+function isLocalSubagentCallAction(action) {
+  return isObject(action) && action["kind"] === "subagent-call" && typeof action["callId"] === "string" && isObject(action["input"]);
+}
+function isTraceableActionRequest(action) {
+  return isToolCallAction(action) || isLocalSubagentCallAction(action);
+}
+function isToolResult(result) {
+  return isObject(result) && result["kind"] === "tool-result" && typeof result["callId"] === "string" && typeof result["toolName"] === "string";
+}
+function isSubagentResult(result) {
+  return isObject(result) && result["kind"] === "subagent-result" && typeof result["callId"] === "string" && typeof result["subagentName"] === "string";
+}
+function normalizedFinishReason(finishReason) {
+  switch (finishReason) {
+    case "content-filter":
+      return "content_filter";
+    case "tool-calls":
+      return "tool_calls";
+    default:
+      return finishReason;
+  }
+}
+function errorFromMessage(message, code, details) {
+  const error = new Error(`${code}: ${message}`);
+  if (details !== void 0) {
+    error.cause = details;
+  }
+  return error;
+}
+function actionResultError(error, output) {
+  if (error) {
+    return errorFromMessage(error.message, error.code);
+  }
+  const result = new Error("Eve action failed");
+  if (output !== void 0) {
+    result.cause = output;
+  }
+  return result;
+}
+function eventTime2(event) {
+  if (!event.meta?.at) {
+    return void 0;
+  }
+  const timestamp = Date.parse(event.meta.at);
+  return Number.isFinite(timestamp) ? timestamp / 1e3 : void 0;
+}
+function turnKey2(sessionId, turnId) {
+  return `${sessionId}:${turnId}`;
+}
+function toolKey3(sessionId, callId) {
+  return `${sessionId}:${callId}`;
+}
+async function generateEveIds(kind, ...parts) {
+  const [rowId, spanId] = await Promise.all([
+    deterministicEveId(`eve:row:${kind}`, ...parts),
+    deterministicEveId(`eve:${kind}`, ...parts)
+  ]);
+  return { rowId, spanId };
+}
+async function deterministicEveId(...parts) {
+  const data = new TextEncoder().encode(
+    parts.map((part) => `${part.length}:${part}`).join("\0")
+  );
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", data);
+  const bytes = Array.from(new Uint8Array(digest, 0, 16));
+  const hex = bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 // src/typed-instrumentation-helpers.ts
 var TypedApplyProxy = Proxy;
 
@@ -33242,6 +35387,15 @@ function modelMetrics(attributes) {
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
+function timeToFirstTokenSeconds(attributes, spanStartSeconds) {
+  if (!isObject(attributes)) return void 0;
+  if (spanStartSeconds === void 0) return void 0;
+  const raw = attributes.completionStartTime;
+  const completionStart = raw instanceof Date || typeof raw === "string" || typeof raw === "number" ? epochSeconds(raw) : void 0;
+  if (completionStart === void 0) return void 0;
+  const ttft = completionStart - spanStartSeconds;
+  return Number.isFinite(ttft) && ttft >= 0 ? ttft : void 0;
+}
 function buildMetadata(exported) {
   const out = {};
   if (exported.entityId !== void 0) out.entity_id = exported.entityId;
@@ -33311,7 +35465,13 @@ var BraintrustObservabilityExporter = class {
     const args = {
       name: exported.name,
       spanAttributes: { type: spanTypeFor(exported.type) },
-      startTime: epochSeconds(exported.startTime)
+      startTime: epochSeconds(exported.startTime),
+      // Use the Mastra span id as the Braintrust row id so that
+      // `logFeedback({ id: <mastra span id> })` (and Mastra's score events)
+      // attach to the right row. Without this, `SpanImpl` auto-generates a
+      // row id (`this._id = eventId ?? idGenerator.getSpanId()`) that no
+      // external caller could know.
+      event: { id: exported.id }
     };
     const parentRecord = exported.parentSpanId ? this.spans.get(exported.parentSpanId) : void 0;
     if (!this.capturedParent) {
@@ -33360,8 +35520,15 @@ var BraintrustObservabilityExporter = class {
       event.metadata = metadata;
     }
     const metrics = modelMetrics(exported.attributes);
-    if (metrics) {
-      event.metrics = metrics;
+    const ttft = timeToFirstTokenSeconds(
+      exported.attributes,
+      epochSeconds(exported.startTime)
+    );
+    if (metrics || ttft !== void 0) {
+      event.metrics = {
+        ...metrics ?? {},
+        ...ttft !== void 0 ? { time_to_first_token: ttft } : {}
+      };
     }
     if (Object.keys(event).length > 0) {
       record.span.log(event);
@@ -34240,17 +36407,17 @@ function wrapGenkit(genkit) {
   console.warn("Unsupported Genkit object. Not wrapping.");
   return genkit;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function isPropertyBag(value) {
-  return isRecord2(value) || typeof value === "function";
+  return isRecord3(value) || typeof value === "function";
 }
 function hasFunction(value, methodName) {
   return isPropertyBag(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isGenkitInstance(value) {
-  return isRecord2(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
+  return isRecord3(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
 }
 function isGenkitModule(value) {
   return hasFunction(value, "genkit");
@@ -34304,7 +36471,7 @@ function patchGenkitRegistry(instance) {
   patchGenkitRegistryConstructor(registry2);
 }
 function patchGenkitRegistryLookup(registry2) {
-  if (!isRecord2(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
+  if (!isRecord3(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
     return;
   }
   const originalLookupAction = registry2.lookupAction;
@@ -34330,7 +36497,7 @@ function patchGenkitRegistryLookup(registry2) {
   }
 }
 function patchGenkitRegistryConstructor(registry2) {
-  if (!isRecord2(registry2)) {
+  if (!isRecord3(registry2)) {
     return;
   }
   const constructor = registry2.constructor;
@@ -34346,7 +36513,7 @@ function patchGenkitRegistryConstructor(registry2) {
       configurable: true,
       value: (...args) => {
         const childRegistry = originalWithParent.apply(constructor, args);
-        if (args.some((arg) => isRecord2(arg) && hasRegistryPatchedFlag(arg))) {
+        if (args.some((arg) => isRecord3(arg) && hasRegistryPatchedFlag(arg))) {
           patchGenkitRegistryLookup(childRegistry);
           patchGenkitRegistryConstructor(childRegistry);
         }
@@ -34445,7 +36612,7 @@ function hasRegistryConstructorPatchedFlag(value) {
   );
 }
 function isPromiseLike2(value) {
-  return isRecord2(value) && "then" in value && typeof value.then === "function";
+  return isRecord3(value) && "then" in value && typeof value.then === "function";
 }
 
 // src/wrappers/huggingface.ts
@@ -34808,14 +36975,14 @@ function wrapMistral(mistral) {
   console.warn("Unsupported Mistral library. Not wrapping.");
   return mistral;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction3(value, methodName) {
-  return isRecord3(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord4(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedMistralClient(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return false;
   }
   return value.chat !== void 0 && hasChat(value.chat) || value.embeddings !== void 0 && hasEmbeddings(value.embeddings) || value.fim !== void 0 && hasFim(value.fim) || value.agents !== void 0 && hasAgents(value.agents) || value.classifiers !== void 0 && hasClassifiers(value.classifiers);
@@ -34999,14 +37166,14 @@ function wrapCohere(cohere) {
   return cohere;
 }
 var cohereProxyCache = /* @__PURE__ */ new WeakMap();
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction4(value, methodName) {
-  return isRecord4(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord5(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedCohereClient(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return false;
   }
   return hasFunction4(value, "chat") || hasFunction4(value, "chatStream") || hasFunction4(value, "embed") || hasFunction4(value, "rerank");
@@ -35066,20 +37233,20 @@ function wrapGroq(groq) {
   console.warn("Unsupported Groq library. Not wrapping.");
   return groq;
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction5(value, methodName) {
-  return isRecord5(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord6(value) && methodName in value && typeof value[methodName] === "function";
 }
 function hasChat2(value) {
-  return isRecord5(value) && isRecord5(value.completions) && hasFunction5(value.completions, "create");
+  return isRecord6(value) && isRecord6(value.completions) && hasFunction5(value.completions, "create");
 }
 function hasEmbeddings2(value) {
   return hasFunction5(value, "create");
 }
 function isSupportedGroqClient(value) {
-  return isRecord5(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
+  return isRecord6(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
 }
 function groqProxy(groq) {
   const privateMethodWorkaroundCache = /* @__PURE__ */ new WeakMap();
@@ -35162,11 +37329,11 @@ var BEDROCK_RUNTIME_OPERATION_METHODS = /* @__PURE__ */ new Set([
   "invokeModelWithBidirectionalStream",
   "invokeModelWithResponseStream"
 ]);
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 function isSupportedBedrockRuntimeClient(value) {
-  return isRecord6(value) && typeof value.send === "function";
+  return isRecord7(value) && typeof value.send === "function";
 }
 function bedrockRuntimeProxy(client) {
   const cached = bedrockRuntimeProxyCache.get(client);
@@ -35285,6 +37452,271 @@ function wrappedResumeSession(client) {
   );
 }
 
+// src/wrappers/langsmith.ts
+var WRAPPED_CLIENT_CLASS = /* @__PURE__ */ Symbol.for(
+  "braintrust.langsmith.wrapped-client-class"
+);
+var WRAPPED_CLIENT_INSTANCE = /* @__PURE__ */ Symbol.for(
+  "braintrust.langsmith.wrapped-client-instance"
+);
+var WRAPPED_CLIENT_NAMESPACE = /* @__PURE__ */ Symbol.for(
+  "braintrust.langsmith.wrapped-client-namespace"
+);
+var WRAPPED_RUN_TREE_CLASS = /* @__PURE__ */ Symbol.for(
+  "braintrust.langsmith.wrapped-run-tree-class"
+);
+var WRAPPED_RUN_TREE_INSTANCE = /* @__PURE__ */ Symbol.for(
+  "braintrust.langsmith.wrapped-run-tree-instance"
+);
+var WRAPPED_RUN_TREES_NAMESPACE = /* @__PURE__ */ Symbol.for(
+  "braintrust.langsmith.wrapped-run-trees-namespace"
+);
+var WRAPPED_TRACEABLE = /* @__PURE__ */ Symbol.for("braintrust.langsmith.wrapped-traceable");
+var WRAPPED_TRACEABLE_NAMESPACE = /* @__PURE__ */ Symbol.for(
+  "braintrust.langsmith.wrapped-traceable-namespace"
+);
+function wrapLangSmithTraceable(namespace) {
+  return wrapNamespaceExport(
+    namespace,
+    "traceable",
+    WRAPPED_TRACEABLE_NAMESPACE,
+    (value) => wrapTraceable(value)
+  );
+}
+function wrapLangSmithRunTrees(namespace) {
+  return wrapNamespaceExport(
+    namespace,
+    "RunTree",
+    WRAPPED_RUN_TREES_NAMESPACE,
+    (value) => wrapRunTreeClass(value)
+  );
+}
+function wrapLangSmithClient(namespace) {
+  return wrapNamespaceExport(
+    namespace,
+    "Client",
+    WRAPPED_CLIENT_NAMESPACE,
+    (value) => wrapClientClass(value)
+  );
+}
+function wrapNamespaceExport(namespace, exportName, marker, wrap2) {
+  if (!namespace || typeof namespace !== "object") {
+    return namespace;
+  }
+  const candidate = namespace;
+  if (candidate[marker] === true) {
+    return namespace;
+  }
+  if (typeof candidate[exportName] !== "function") {
+    console.warn(
+      `Unsupported LangSmith ${exportName} namespace. Not wrapping.`
+    );
+    return namespace;
+  }
+  const target = isModuleNamespace5(namespace) ? Object.setPrototypeOf({}, namespace) : candidate;
+  const moduleNamespace = target !== candidate;
+  let wrappedExport;
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      if (prop === marker) {
+        return true;
+      }
+      const value = Reflect.get(target2, prop, receiver);
+      if (prop !== exportName || typeof value !== "function") {
+        return value;
+      }
+      wrappedExport ??= wrap2(value);
+      return wrappedExport;
+    },
+    getOwnPropertyDescriptor(target2, prop) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target2, prop);
+      if (descriptor || !moduleNamespace) {
+        return descriptor;
+      }
+      const namespaceDescriptor = Reflect.getOwnPropertyDescriptor(
+        candidate,
+        prop
+      );
+      return namespaceDescriptor ? { ...namespaceDescriptor, configurable: true } : void 0;
+    },
+    has(target2, prop) {
+      return Reflect.has(target2, prop) || moduleNamespace && prop in candidate;
+    },
+    ownKeys(target2) {
+      return moduleNamespace ? Reflect.ownKeys(candidate) : Reflect.ownKeys(target2);
+    }
+  });
+}
+function isModuleNamespace5(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value.constructor?.name === "Module") {
+    return true;
+  }
+  const firstKey = Object.keys(value)[0];
+  if (!firstKey) {
+    return false;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, firstKey);
+  return descriptor ? !descriptor.configurable && !descriptor.writable : false;
+}
+function wrapTraceable(traceable2) {
+  if (traceable2[WRAPPED_TRACEABLE]) {
+    return traceable2;
+  }
+  return new Proxy(traceable2, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_TRACEABLE) {
+        return true;
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    apply(target, thisArg, argArray) {
+      const [fn, rawConfig] = argArray;
+      const config = rawConfig && typeof rawConfig === "object" ? rawConfig : void 0;
+      const originalOnEnd = config?.on_end;
+      const wrappedConfig = {
+        ...config,
+        on_end(runTree) {
+          publishRunUpdate(runTree);
+          if (originalOnEnd) {
+            Reflect.apply(originalOnEnd, config, [runTree]);
+          }
+        }
+      };
+      return Reflect.apply(target, thisArg, [fn, wrappedConfig]);
+    }
+  });
+}
+function wrapRunTreeClass(RunTree) {
+  if (RunTree[WRAPPED_RUN_TREE_CLASS]) {
+    return RunTree;
+  }
+  return new Proxy(RunTree, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_RUN_TREE_CLASS) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    construct(target, args, newTarget) {
+      return wrapRunTreeInstance(Reflect.construct(target, args, newTarget));
+    }
+  });
+}
+function wrapRunTreeInstance(runTree) {
+  if (runTree[WRAPPED_RUN_TREE_INSTANCE]) {
+    return runTree;
+  }
+  return new Proxy(runTree, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_RUN_TREE_INSTANCE) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      let wrapped;
+      if (prop === "createChild") {
+        wrapped = (...args) => wrapRunTreeInstance(Reflect.apply(value, target, args));
+      } else if (prop === "postRun") {
+        const method = value;
+        wrapped = (...args) => langSmithChannels.createRun.tracePromise(
+          () => Reflect.apply(method, target, args),
+          { arguments: [target] }
+        );
+      } else if (prop === "patchRun") {
+        const method = value;
+        wrapped = (...args) => langSmithChannels.updateRun.tracePromise(
+          () => Reflect.apply(method, target, args),
+          {
+            arguments: [
+              typeof target.id === "string" ? target.id : "",
+              target
+            ]
+          }
+        );
+      } else {
+        wrapped = value.bind(target);
+      }
+      return wrapped;
+    }
+  });
+}
+function wrapClientClass(Client) {
+  if (Client[WRAPPED_CLIENT_CLASS]) {
+    return Client;
+  }
+  return new Proxy(Client, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_CLIENT_CLASS) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    construct(target, args, newTarget) {
+      return wrapClientInstance(Reflect.construct(target, args, newTarget));
+    }
+  });
+}
+function wrapClientInstance(client) {
+  if (client[WRAPPED_CLIENT_INSTANCE]) {
+    return client;
+  }
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_CLIENT_INSTANCE) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      let wrapped;
+      if (prop === "createRun") {
+        const method = value;
+        wrapped = (...args) => langSmithChannels.createRun.tracePromise(
+          () => Reflect.apply(method, target, args),
+          { arguments: args }
+        );
+      } else if (prop === "updateRun") {
+        const method = value;
+        wrapped = (...args) => langSmithChannels.updateRun.tracePromise(
+          () => Reflect.apply(method, target, args),
+          { arguments: args }
+        );
+      } else if (prop === "batchIngestRuns") {
+        const method = value;
+        wrapped = (...args) => langSmithChannels.batchIngestRuns.tracePromise(
+          () => Reflect.apply(method, target, args),
+          { arguments: args }
+        );
+      } else {
+        wrapped = value.bind(target);
+      }
+      return wrapped;
+    }
+  });
+}
+function publishRunUpdate(runTree) {
+  if (!runTree || typeof runTree.id !== "string" || !runTree.id) {
+    return;
+  }
+  try {
+    void langSmithChannels.updateRun.tracePromise(() => Promise.resolve(void 0), {
+      arguments: [runTree.id, runTree]
+    }).catch((error) => {
+      debugLogger.error("LangSmith traceable instrumentation failed:", error);
+    });
+  } catch (error) {
+    debugLogger.error("LangSmith traceable instrumentation failed:", error);
+  }
+}
+
 // src/wrappers/vitest/context-manager.ts
 var VitestContextManager = class {
   /**