braintrust 3.22.0 → 3.23.0

package/dist/workerd.mjs

@@ -4264,7 +4264,7 @@ var DiskCache = class {
   }
 };
 
-// src/prompt-cache/lru-cache.ts
+// src/lru-cache.ts
 var LRUCache = class {
   cache;
   maxSize;
@@ -5506,25 +5506,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;
@@ -6621,6 +6642,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;
@@ -8359,15 +8419,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}` });
 }
@@ -8954,7 +9014,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;
@@ -10678,7 +10739,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(
@@ -29262,6 +29324,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",
@@ -29641,11 +30143,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) {
@@ -30163,6 +30665,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() {
@@ -30307,11 +30810,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),
@@ -30319,7 +30827,7 @@ function startAgentStream(event, activeChildParents) {
     })
   ) : startSpan({
     event: {
-      input: event.arguments[0],
+      input,
       metadata
     },
     name: formatAgentSpanName(agent),
@@ -30327,6 +30835,7 @@ function startAgentStream(event, activeChildParents) {
   });
   return {
     activeTools: /* @__PURE__ */ new Map(),
+    attachmentCache,
     finalized: false,
     metadata,
     span,
@@ -30342,11 +30851,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",
@@ -30354,7 +30864,7 @@ function startMultiAgentStream(event, operation, activeChildParents) {
     })
   ) : startSpan({
     event: {
-      input: event.arguments[0],
+      input,
       metadata
     },
     name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -30463,7 +30973,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),
@@ -30677,6 +31190,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) {
@@ -30823,6 +31337,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;
@@ -30952,6 +31626,7 @@ var BraintrustPlugin = class extends BasePlugin {
   gitHubCopilotPlugin = null;
   fluePlugin = null;
   langChainPlugin = null;
+  langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
   constructor(config = {}) {
@@ -31048,6 +31723,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) {
@@ -31138,6 +31819,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.langChainPlugin.disable();
       this.langChainPlugin = null;
     }
+    if (this.langSmithPlugin) {
+      this.langSmithPlugin.disable();
+      this.langSmithPlugin = null;
+    }
   }
 };
 
@@ -31202,7 +31887,8 @@ var envIntegrationAliases = {
   langchain: "langchain",
   "langchain-js": "langchain",
   "@langchain": "langchain",
-  langgraph: "langgraph"
+  langgraph: "langgraph",
+  langsmith: "langsmith"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -31233,6 +31919,7 @@ function getDefaultInstrumentationIntegrations() {
     gitHubCopilot: true,
     langchain: true,
     langgraph: true,
+    langsmith: true,
     piCodingAgent: true,
     strandsAgentSDK: true
   };
@@ -31544,6 +32231,9 @@ __export(exports_exports, {
   wrapGoogleGenAI: () => wrapGoogleGenAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
+  wrapLangSmithClient: () => wrapLangSmithClient,
+  wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
+  wrapLangSmithTraceable: () => wrapLangSmithTraceable,
   wrapMastraAgent: () => wrapMastraAgent,
   wrapMistral: () => wrapMistral,
   wrapOpenAI: () => wrapOpenAI,
@@ -33030,9 +33720,6 @@ var EveBridge = class {
     this.state = state;
   }
   eventQueuesBySession = /* @__PURE__ */ new Map();
-  sessionsById = new LRUCache({
-    max: MAX_EVE_CACHE_ENTRIES
-  });
   completedToolKeys = new LRUCache({
     max: MAX_EVE_CACHE_ENTRIES
   });
@@ -33199,7 +33886,7 @@ var EveBridge = class {
   async handleEvent(event, ctx, hookMetadata) {
     switch (event.type) {
       case "session.started":
-        await this.handleSessionStarted(event, ctx, hookMetadata);
+        this.handleSessionStarted(event, ctx, hookMetadata);
         return true;
       case "turn.started":
         await this.handleTurnStarted(event, ctx, hookMetadata);
@@ -33235,22 +33922,22 @@ var EveBridge = class {
         this.handleStepFailed(event, ctx);
         return true;
       case "turn.completed":
-        await this.handleTurnCompleted(event, ctx);
+        this.handleTurnCompleted(event, ctx);
         return true;
       case "turn.failed":
-        await this.handleTurnFailed(event, ctx);
+        this.handleTurnFailed(event, ctx);
         return true;
       case "session.failed":
-        await this.handleSessionFailed(event, ctx);
+        this.handleSessionFailed(event, ctx);
         return true;
       case "session.completed":
-        await this.handleSessionCompleted(event, ctx);
+        this.handleSessionCompleted(event, ctx);
         return true;
       default:
         return false;
     }
   }
-  async handleSessionStarted(event, ctx, hookMetadata) {
+  handleSessionStarted(event, ctx, hookMetadata) {
     const sessionId = sessionIdFromContext(ctx);
     if (!sessionId) {
       return;
@@ -33266,7 +33953,6 @@ var EveBridge = class {
         metadata: { ...normalized.metadata, ...metadata }
       };
     });
-    await this.ensureSession(sessionId, ctx, metadata, eventTime2(event));
     for (const [key, turn] of this.turnsByKey) {
       if (!key.startsWith(`${sessionId}:`)) {
         continue;
@@ -33284,21 +33970,19 @@ var EveBridge = class {
     if (!sessionId) {
       return;
     }
-    const session = await this.ensureSession(
-      sessionId,
-      ctx,
-      hookMetadata ?? {},
-      eventTime2(event)
-    );
     const key = turnKey2(sessionId, event.data.turnId);
-    const metadata = { ...session.metadata };
+    const 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(session, event, metadata);
+    const span = await this.startTurnSpan(sessionId, event, ctx, metadata);
     span.log({ metadata });
     this.turnsByKey.set(key, {
       key,
@@ -33336,10 +34020,7 @@ var EveBridge = class {
       this.markStepEnded(event.data.turnId, event.data.stepIndex);
     }
     const stepOrdinal = this.stepOrdinal(event);
-    const metadata = {
-      ...turn.metadata,
-      ...this.sessionsById.get(sessionId)?.metadata ?? {}
-    };
+    const metadata = { ...turn.metadata };
     const input = consumeCapturedEveModelInput(
       this.state,
       sessionId,
@@ -33434,6 +34115,28 @@ var EveBridge = class {
     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",
@@ -33441,17 +34144,7 @@ var EveBridge = class {
         message: {
           content: null,
           role: "assistant",
-          tool_calls: traceActions.map((action) => {
-            const name = action.kind === "tool-call" ? action.toolName : action.subagentName ?? action.name ?? "agent";
-            return {
-              function: {
-                arguments: JSON.stringify(action.input),
-                name
-              },
-              id: action.callId,
-              type: "function"
-            };
-          })
+          tool_calls: [...toolCallsById.values()]
         }
       }
     ];
@@ -33698,17 +34391,11 @@ var EveBridge = class {
       )
     });
   }
-  async handleSessionFailed(event, ctx) {
+  handleSessionFailed(event, ctx) {
     const sessionId = event.data.sessionId || sessionIdFromContext(ctx);
     if (!sessionId) {
       return;
     }
-    const session = await this.ensureSession(
-      sessionId,
-      ctx,
-      {},
-      eventTime2(event)
-    );
     const error = errorFromMessage(
       event.data.message,
       event.data.code,
@@ -33725,29 +34412,20 @@ var EveBridge = class {
     }
     for (const [key, tool] of this.toolsByCallKey) {
       if (key.startsWith(`${sessionId}:`)) {
-        const endTime2 = eventTime2(event);
+        const endTime = eventTime2(event);
         if (!tool.endedByTurn) {
           tool.span.log({ metadata: tool.metadata });
-          tool.span.end(endTime2 === void 0 ? void 0 : { endTime: endTime2 });
+          tool.span.end(endTime === void 0 ? void 0 : { endTime });
           tool.endedByTurn = true;
         }
       }
     }
-    session.span.log({ error });
-    const endTime = eventTime2(event);
-    session.span.end(endTime === void 0 ? void 0 : { endTime });
   }
-  async handleSessionCompleted(event, ctx) {
+  handleSessionCompleted(event, ctx) {
     const sessionId = sessionIdFromContext(ctx);
     if (!sessionId) {
       return;
     }
-    const session = await this.ensureSession(
-      sessionId,
-      ctx,
-      {},
-      eventTime2(event)
-    );
     for (const [key, turn] of this.turnsByKey) {
       if (!key.startsWith(`${sessionId}:`)) {
         continue;
@@ -33758,82 +34436,29 @@ var EveBridge = class {
     }
     for (const [key, tool] of this.toolsByCallKey) {
       if (key.startsWith(`${sessionId}:`) && !tool.endedByTurn) {
-        const endTime2 = eventTime2(event);
+        const endTime = eventTime2(event);
         tool.span.log({ metadata: tool.metadata });
-        tool.span.end(endTime2 === void 0 ? void 0 : { endTime: endTime2 });
+        tool.span.end(endTime === void 0 ? void 0 : { endTime });
         tool.endedByTurn = true;
       }
     }
-    session.span.log({ metadata: session.metadata });
-    const endTime = eventTime2(event);
-    session.span.end(endTime === void 0 ? void 0 : { endTime });
-  }
-  async ensureSession(sessionId, ctx, metadata, startTime) {
-    metadata = {
-      ...readEveTraceState(this.state).metadata,
-      ...metadata
-    };
-    const existing = this.sessionsById.get(sessionId);
-    if (existing) {
-      existing.metadata = { ...existing.metadata, ...metadata };
-      existing.span.log({ metadata: existing.metadata });
-      return existing;
-    }
-    const lineage = parentLineageFromContext(ctx);
-    const parentSubagent = lineage ? this.toolsByCallKey.get(toolKey3(lineage.sessionId, lineage.callId)) : void 0;
-    const activeParent = currentSpan();
-    const [
-      { rowId: eventId, spanId },
-      parentSubagentSpanId,
-      fallbackRootSpanId
-    ] = await Promise.all([
-      generateEveIds("session", sessionId),
-      lineage ? spanIdForSubagent(lineage.sessionId, lineage.callId) : Promise.resolve(void 0),
-      lineage ? rootSpanIdForSession(lineage.rootSessionId) : rootSpanIdForSession(sessionId)
-    ]);
-    const span = await this.startEveSpan({
-      event: {
-        id: eventId,
-        metadata
-      },
-      name: "eve.session",
-      parentSpanIds: lineage && parentSubagentSpanId ? {
-        rootSpanId: parentSubagent?.span.rootSpanId ?? fallbackRootSpanId,
-        spanId: parentSubagentSpanId
-      } : !Object.is(activeParent, NOOP_SPAN) ? {
-        rootSpanId: activeParent.rootSpanId,
-        spanId: activeParent.spanId
-      } : {
-        parentSpanIds: [],
-        rootSpanId: fallbackRootSpanId
-      },
-      spanAttributes: { type: "task" /* TASK */ },
-      spanId,
-      startTime
-    });
-    span.log({ metadata });
-    const session = { metadata, sessionId, span };
-    this.sessionsById.set(sessionId, session);
-    return session;
   }
   async ensureTurn(event, ctx, hookMetadata) {
     const sessionId = sessionIdFromContext(ctx);
     if (!sessionId) {
       return void 0;
     }
-    const session = await this.ensureSession(
-      sessionId,
-      ctx,
-      hookMetadata ?? {},
-      eventTime2(event)
-    );
     const key = turnKey2(sessionId, event.data.turnId);
     const existing = this.turnsByKey.get(key);
     if (existing) {
       return existing;
     }
-    const metadata = { ...session.metadata };
-    const span = await this.startTurnSpan(session, event, metadata);
+    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,
@@ -34020,22 +34645,35 @@ var EveBridge = class {
     this.toolsByCallKey.set(toolKey3(sessionId, result.callId), state);
     return state;
   }
-  async startTurnSpan(session, event, metadata) {
-    const { rowId: eventId, spanId } = await generateEveIds(
-      "turn",
-      session.sessionId,
-      event.data.turnId
-    );
+  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: {
-        rootSpanId: session.span.rootSpanId,
-        spanId: session.span.spanId
-      },
+      parentSpanIds: parentSpanId ? { rootSpanId, spanId: parentSpanId } : { parentSpanIds: [], rootSpanId },
       spanAttributes: { type: "task" /* TASK */ },
       spanId,
       startTime: eventTime2(event)
@@ -34096,7 +34734,6 @@ var EveBridge = class {
   }
   cleanupSession(sessionId) {
     const keyPrefix = `${sessionId}:`;
-    this.sessionsById.delete(sessionId);
     for (const key of this.turnsByKey.keys()) {
       if (key.startsWith(keyPrefix)) {
         this.turnsByKey.delete(key);
@@ -34287,7 +34924,7 @@ function modelMetadataFromRuntime(runtime) {
     return {};
   }
   const modelId = runtime["modelId"];
-  return typeof modelId === "string" ? modelMetadataFromModelId(modelId) : {};
+  return typeof modelId === "string" && !modelId.trim().startsWith("dynamic:") ? modelMetadataFromModelId(modelId) : {};
 }
 function modelMetadataFromModelId(modelId) {
   const normalized = modelId.trim();
@@ -34320,26 +34957,6 @@ function toolMetadataFromTurn(turn) {
   const { model: _model, provider: _provider, ...metadata } = turn.metadata;
   return metadata;
 }
-function parentLineageFromContext(ctx) {
-  if (!isObject(ctx)) {
-    return void 0;
-  }
-  const session = ctx.session;
-  if (!isObject(session)) {
-    return void 0;
-  }
-  const parent = session["parent"];
-  if (!isObject(parent)) {
-    return void 0;
-  }
-  const callId = parent["callId"];
-  const rootSessionId = parent["rootSessionId"];
-  const sessionId = parent["sessionId"];
-  if (typeof callId !== "string" || typeof rootSessionId !== "string" || typeof sessionId !== "string") {
-    return void 0;
-  }
-  return { callId, rootSessionId, sessionId };
-}
 function isToolCallAction(action) {
   return isObject(action) && action["kind"] === "tool-call" && typeof action["callId"] === "string" && typeof action["toolName"] === "string" && isObject(action["input"]);
 }
@@ -34395,9 +35012,6 @@ function turnKey2(sessionId, turnId) {
 function toolKey3(sessionId, callId) {
   return `${sessionId}:${callId}`;
 }
-async function rootSpanIdForSession(sessionId) {
-  return deterministicEveId("eve:root", sessionId);
-}
 async function generateEveIds(kind, ...parts) {
   const [rowId, spanId] = await Promise.all([
     deterministicEveId(`eve:row:${kind}`, ...parts),
@@ -34405,9 +35019,6 @@ async function generateEveIds(kind, ...parts) {
   ]);
   return { rowId, spanId };
 }
-async function spanIdForSubagent(sessionId, callId) {
-  return deterministicEveId("eve:subagent", sessionId, callId);
-}
 async function deterministicEveId(...parts) {
   const data = new TextEncoder().encode(
     parts.map((part) => `${part.length}:${part}`).join("\0")
@@ -34580,6 +35191,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;
@@ -34704,8 +35324,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);
@@ -35584,17 +36211,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");
@@ -35648,7 +36275,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;
@@ -35674,7 +36301,7 @@ function patchGenkitRegistryLookup(registry2) {
   }
 }
 function patchGenkitRegistryConstructor(registry2) {
-  if (!isRecord2(registry2)) {
+  if (!isRecord3(registry2)) {
     return;
   }
   const constructor = registry2.constructor;
@@ -35690,7 +36317,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);
         }
@@ -35789,7 +36416,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
@@ -36152,14 +36779,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);
@@ -36343,14 +36970,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");
@@ -36410,20 +37037,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();
@@ -36506,11 +37133,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);
@@ -36629,6 +37256,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 {
   /**
@@ -41082,6 +41974,9 @@ export {
   wrapGoogleGenAI,
   wrapGroq,
   wrapHuggingFace,
+  wrapLangSmithClient,
+  wrapLangSmithRunTrees,
+  wrapLangSmithTraceable,
   wrapMastraAgent,
   wrapMistral,
   wrapOpenAI,