braintrust 3.22.0 → 3.23.1

package/dist/{chunk-ZG2O3XVF.mjs → chunk-RBXD2KYN.mjs}

@@ -18,6 +18,7 @@ import {
   isInstrumentationIntegrationDisabled,
   isomorph_default,
   langChainChannels,
+  langSmithChannels,
   mistralChannels,
   openAIAgentsCoreChannels,
   openAIChannels,
@@ -30,7 +31,7 @@ import {
   smithyClientChannels,
   smithyCoreChannels,
   strandsAgentSDKChannels
-} from "./chunk-KMGUTPB7.mjs";
+} from "./chunk-36IPYKMG.mjs";
 
 // src/id-gen.ts
 import { v4 as uuidv4 } from "uuid";
@@ -4194,7 +4195,7 @@ var DiskCache = class {
   }
 };
 
-// src/prompt-cache/lru-cache.ts
+// src/lru-cache.ts
 var LRUCache = class {
   cache;
   maxSize;
@@ -5436,25 +5437,46 @@ var HTTPConnection = class _HTTPConnection {
       })
     );
   }
-  async post(path2, params, config) {
+  async post(path2, 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, path2), {
-        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, path2), {
+            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 ${path2} 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;
@@ -6551,6 +6573,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, reject) => {
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", onAbort);
+      reject(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;
@@ -8289,15 +8350,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}` });
 }
@@ -8884,7 +8945,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;
@@ -10608,7 +10670,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(
@@ -19066,8 +19129,6 @@ function filterSerializableOptions(options) {
     "additionalDirectories",
     "permissionMode",
     "debug",
-    "apiKey",
-    "apiKeySource",
     "agentName",
     "instructions"
   ];
@@ -28557,6 +28618,430 @@ function isBraintrustHandler(handler) {
   return Reflect.get(handler, "name") === BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
 }
 
+// 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 eventTime2 = timestampSeconds(ownValue(event, "time"));
+      if (eventTime2 !== void 0 && eventTime2 >= startTime) {
+        metrics.time_to_first_token = eventTime2 - 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-plugin.ts
 var piStreamPatchStates = /* @__PURE__ */ new WeakMap();
 var piPromptContextStore;
@@ -28925,11 +29410,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) {
@@ -29431,6 +29916,7 @@ function logInstrumentationError4(context, error) {
 }
 
 // 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() {
@@ -29575,11 +30061,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),
@@ -29587,7 +30078,7 @@ function startAgentStream(event, activeChildParents) {
     })
   ) : startSpan({
     event: {
-      input: event.arguments[0],
+      input,
       metadata
     },
     name: formatAgentSpanName(agent),
@@ -29595,6 +30086,7 @@ function startAgentStream(event, activeChildParents) {
   });
   return {
     activeTools: /* @__PURE__ */ new Map(),
+    attachmentCache,
     finalized: false,
     metadata,
     span,
@@ -29610,11 +30102,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",
@@ -29622,7 +30115,7 @@ function startMultiAgentStream(event, operation, activeChildParents) {
     })
   ) : startSpan({
     event: {
-      input: event.arguments[0],
+      input,
       metadata
     },
     name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -29731,7 +30224,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),
@@ -29945,6 +30441,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) {
@@ -30091,6 +30588,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;
@@ -30220,6 +30877,7 @@ var BraintrustPlugin = class extends BasePlugin {
   gitHubCopilotPlugin = null;
   fluePlugin = null;
   langChainPlugin = null;
+  langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
   constructor(config = {}) {
@@ -30316,6 +30974,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) {
@@ -30406,6 +31070,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.langChainPlugin.disable();
       this.langChainPlugin = null;
     }
+    if (this.langSmithPlugin) {
+      this.langSmithPlugin.disable();
+      this.langSmithPlugin = null;
+    }
   }
 };
 
@@ -30566,6 +31234,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;
@@ -30690,8 +31367,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);