braintrust 3.29.0 → 3.31.0

package/dev/dist/index.mjs

@@ -4118,6 +4118,7 @@ var ProjectSettings = z6.union([
     ]),
     disable_realtime_queries: z6.union([z6.boolean(), z6.null()]),
     monitor_charts_use_metrics_start: z6.union([z6.boolean(), z6.null()]),
+    blind_reviews: z6.union([z6.boolean(), z6.null()]),
     default_preprocessor: NullableSavedFunctionId
   }).partial(),
   z6.null()
@@ -4179,6 +4180,7 @@ var WindowedAutomationConfig = z6.object({
     auto_approve_tools: z6.array(z6.string().min(1)).optional().default([]),
     harness: z6.enum(["native", "codex", "claude-code"]).optional(),
     model: z6.string().min(1).optional(),
+    endpoint_name: z6.string().min(1).optional(),
     reasoning_effort: z6.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional()
   }).optional(),
   actions: z6.array(
@@ -5972,7 +5974,7 @@ var INSTRUMENTATION_NAMES = {
 var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
   "braintrust.spanInstrumentationName"
 );
-var SDK_VERSION = true ? "3.29.0" : "0.0.0";
+var SDK_VERSION = true ? "3.31.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -9487,6 +9489,15 @@ function _internalStartSpanWithInitialMerge(args) {
     [INITIAL_SPAN_WRITE_AS_MERGE]: true
   }).span;
 }
+function _internalStartSpanWithInitialMergeAndParentSpanIds(args) {
+  return startSpanAndIsLogger(
+    {
+      ...args,
+      [INITIAL_SPAN_WRITE_AS_MERGE]: true
+    },
+    { useParentSpanIdsForObjectParent: true }
+  ).span;
+}
 function _internalStartSpanWithContext(args, context) {
   return startSpanAndIsLogger({
     ...args,
@@ -9497,7 +9508,7 @@ async function flush(options) {
   const state = options?.state ?? _globalState;
   return await state.bgLogger().flush();
 }
-function startSpanAndIsLogger(args) {
+function startSpanAndIsLogger(args, internalOptions) {
   const state = args?.state ?? _globalState;
   const { parentObject, propagatedState } = getSpanParentObjectAndPropagatedState({
     asyncFlush: args?.asyncFlush,
@@ -9511,7 +9522,7 @@ function startSpanAndIsLogger(args) {
     ) ? {
       spanId: parentObject.data.span_id,
       rootSpanId: parentObject.data.root_span_id
-    } : void 0;
+    } : internalOptions?.useParentSpanIdsForObjectParent ? args?.parentSpanIds : void 0;
     const { parent: _ignoredParent, ...spanArgs } = args ?? {};
     const span = new SpanImpl({
       state,
@@ -12811,6 +12822,131 @@ function unsubscribeAll(unsubscribers) {
   return [];
 }
 
+// src/instrumentation/core/channel-definitions.ts
+function channel(spec) {
+  return spec;
+}
+function defineChannels(pkg, channels, options) {
+  const { instrumentationName } = options;
+  return Object.fromEntries(
+    Object.entries(channels).map(([key, spec]) => {
+      const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
+      if (spec.kind === "async") {
+        const asyncSpec = spec;
+        const tracingChannel2 = () => isomorph_default.newTracingChannel(
+          fullChannelName
+        );
+        const intercept2 = (interceptor) => {
+          const hook = tracingChannel2();
+          return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+          };
+        };
+        return [
+          key,
+          {
+            ...asyncSpec,
+            instrumentationName,
+            intercept: intercept2,
+            invoke: (target, thisArg, args, additional) => {
+              const hook = tracingChannel2();
+              return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+            },
+            tracingChannel: tracingChannel2,
+            tracePromise: (fn, context) => tracingChannel2().tracePromise(
+              fn,
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              context
+            )
+          }
+        ];
+      }
+      const syncSpec = spec;
+      const tracingChannel = () => isomorph_default.newTracingChannel(
+        fullChannelName
+      );
+      const intercept = (interceptor) => {
+        const hook = tracingChannel();
+        return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+        };
+      };
+      return [
+        key,
+        {
+          ...syncSpec,
+          instrumentationName,
+          intercept,
+          invoke: (target, thisArg, args, additional) => {
+            const hook = tracingChannel();
+            return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+          },
+          tracingChannel,
+          traceSync: (fn, context) => tracingChannel().traceSync(
+            fn,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            context
+          )
+        }
+      ];
+    })
+  );
+}
+
+// src/instrumentation/plugins/openai-channels.ts
+var openAIChannels = defineChannels(
+  "openai",
+  {
+    filesCreateTraced: channel({
+      channelName: "files.create-traced",
+      kind: "async"
+    }),
+    batchesRetrieveTraced: channel({
+      channelName: "batches.retrieve-traced",
+      kind: "async"
+    }),
+    batchesCompleteTrace: channel({
+      channelName: "batches.complete-trace",
+      kind: "async"
+    }),
+    chatCompletionsCreate: channel({
+      channelName: "chat.completions.create",
+      kind: "async"
+    }),
+    embeddingsCreate: channel({
+      channelName: "embeddings.create",
+      kind: "async"
+    }),
+    betaChatCompletionsParse: channel({
+      channelName: "beta.chat.completions.parse",
+      kind: "async"
+    }),
+    betaChatCompletionsStream: channel({
+      channelName: "beta.chat.completions.stream",
+      kind: "sync-stream"
+    }),
+    moderationsCreate: channel({
+      channelName: "moderations.create",
+      kind: "async"
+    }),
+    responsesCreate: channel({
+      channelName: "responses.create",
+      kind: "async"
+    }),
+    responsesStream: channel({
+      channelName: "responses.stream",
+      kind: "sync-stream"
+    }),
+    responsesParse: channel({
+      channelName: "responses.parse",
+      kind: "async"
+    }),
+    responsesCompact: channel({
+      channelName: "responses.compact",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OPENAI }
+);
+
 // src/wrappers/attachment-utils.ts
 function getExtensionFromMediaType(mediaType) {
   const extensionMap = {
@@ -12986,118 +13122,91 @@ function processInputAttachments(input) {
   return processNode(input);
 }
 
-// src/instrumentation/core/channel-definitions.ts
-function channel(spec) {
-  return spec;
-}
-function defineChannels(pkg, channels, options) {
-  const { instrumentationName } = options;
-  return Object.fromEntries(
-    Object.entries(channels).map(([key, spec]) => {
-      const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
-      if (spec.kind === "async") {
-        const asyncSpec = spec;
-        const tracingChannel2 = () => isomorph_default.newTracingChannel(
-          fullChannelName
-        );
-        const intercept2 = (interceptor) => {
-          const hook = tracingChannel2();
-          return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
-          };
-        };
-        return [
-          key,
-          {
-            ...asyncSpec,
-            instrumentationName,
-            intercept: intercept2,
-            invoke: (target, thisArg, args, additional) => {
-              const hook = tracingChannel2();
-              return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
-            },
-            tracingChannel: tracingChannel2,
-            tracePromise: (fn, context) => tracingChannel2().tracePromise(
-              fn,
-              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-              context
-            )
-          }
-        ];
+// src/instrumentation/plugins/openai-span-data.ts
+var OPENAI_METADATA_KEYS = [
+  "model",
+  "temperature",
+  "top_p",
+  "max_tokens",
+  "frequency_penalty",
+  "presence_penalty",
+  "stop",
+  "response_format",
+  "tools",
+  "tool_choice",
+  "parallel_tool_calls",
+  "max_tool_calls"
+];
+function batchMetadata(params) {
+  const metadata = { provider: "openai" };
+  for (const key of OPENAI_METADATA_KEYS) {
+    try {
+      const value = Reflect.get(params, key);
+      if (value !== void 0) {
+        metadata[key] = value;
       }
-      const syncSpec = spec;
-      const tracingChannel = () => isomorph_default.newTracingChannel(
-        fullChannelName
-      );
-      const intercept = (interceptor) => {
-        const hook = tracingChannel();
-        return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
-        };
-      };
-      return [
-        key,
-        {
-          ...syncSpec,
-          instrumentationName,
-          intercept,
-          invoke: (target, thisArg, args, additional) => {
-            const hook = tracingChannel();
-            return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
-          },
-          tracingChannel,
-          traceSync: (fn, context) => tracingChannel().traceSync(
-            fn,
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            context
-          )
-        }
-      ];
-    })
-  );
+    } catch {
+    }
+  }
+  return metadata;
+}
+function extractOpenAIBatchInput(endpoint, params) {
+  const input = endpoint === "/v1/chat/completions" ? params.messages : params.input;
+  return {
+    input: processInputAttachments(input),
+    metadata: batchMetadata(params)
+  };
+}
+function extractOpenAIChatInput(params) {
+  const { messages, ...metadata } = params;
+  return {
+    input: processInputAttachments(messages),
+    metadata: { ...metadata, provider: "openai" }
+  };
+}
+function extractOpenAIResponsesInput(params) {
+  const { input, ...metadata } = params;
+  return {
+    input: processInputAttachments(input),
+    metadata: { ...metadata, provider: "openai" }
+  };
+}
+function extractOpenAIResponsesMetadata(result) {
+  if (!result) {
+    return void 0;
+  }
+  const { output: _output, usage: _usage, ...metadata } = result;
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function processImagesInOutput(output) {
+  if (Array.isArray(output)) {
+    return output.map(processImagesInOutput);
+  }
+  if (isObject(output) && output.type === "image_generation_call" && typeof output.result === "string" && output.result) {
+    const fileExtension = output.output_format || "png";
+    const contentType = `image/${fileExtension}`;
+    const baseFilename = typeof output.revised_prompt === "string" ? output.revised_prompt.slice(0, 50).replace(/[^a-zA-Z0-9]/g, "_") : "generated_image";
+    let binaryString;
+    try {
+      binaryString = atob(output.result);
+    } catch {
+      return output;
+    }
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return {
+      ...output,
+      result: new Attachment({
+        data: new Blob([bytes], { type: contentType }),
+        filename: `${baseFilename}.${fileExtension}`,
+        contentType
+      })
+    };
+  }
+  return output;
 }
-
-// src/instrumentation/plugins/openai-channels.ts
-var openAIChannels = defineChannels(
-  "openai",
-  {
-    chatCompletionsCreate: channel({
-      channelName: "chat.completions.create",
-      kind: "async"
-    }),
-    embeddingsCreate: channel({
-      channelName: "embeddings.create",
-      kind: "async"
-    }),
-    betaChatCompletionsParse: channel({
-      channelName: "beta.chat.completions.parse",
-      kind: "async"
-    }),
-    betaChatCompletionsStream: channel({
-      channelName: "beta.chat.completions.stream",
-      kind: "sync-stream"
-    }),
-    moderationsCreate: channel({
-      channelName: "moderations.create",
-      kind: "async"
-    }),
-    responsesCreate: channel({
-      channelName: "responses.create",
-      kind: "async"
-    }),
-    responsesStream: channel({
-      channelName: "responses.stream",
-      kind: "sync-stream"
-    }),
-    responsesParse: channel({
-      channelName: "responses.parse",
-      kind: "async"
-    }),
-    responsesCompact: channel({
-      channelName: "responses.compact",
-      kind: "async"
-    })
-  },
-  { instrumentationName: INSTRUMENTATION_NAMES.OPENAI }
-);
 
 // src/openai-utils.ts
 var BRAINTRUST_CACHED_STREAM_METRIC = "__braintrust_cached_metric";
@@ -13154,23 +13263,573 @@ function getCachedMetricFromHeaders(headers) {
   return parseCachedHeader(headers.get(LEGACY_CACHED_HEADER));
 }
 
+// src/instrumentation/plugins/openai-batch-instrumentation.ts
+var SUPPORTED_ENDPOINTS = /* @__PURE__ */ new Set(["/v1/chat/completions", "/v1/responses"]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "expired",
+  "cancelled"
+]);
+var pendingBatchTraces = /* @__PURE__ */ new Map();
+function read(value, key) {
+  if (!isObject(value)) {
+    return void 0;
+  }
+  try {
+    return Reflect.get(value, key);
+  } catch {
+    return void 0;
+  }
+}
+function isBatchRecordIterable(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  return typeof read(value, Symbol.iterator) === "function" || typeof read(value, Symbol.asyncIterator) === "function";
+}
+function validCustomId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 64;
+}
+function logBatchInstrumentationError(context, error) {
+  debugLogger.debug(`OpenAI Batch instrumentation ${context}:`, error);
+}
+async function exportParent(parent) {
+  if ("toStr" in parent && typeof parent.toStr === "function") {
+    return parent.toStr();
+  }
+  if ("export" in parent && typeof parent.export === "function") {
+    return await parent.export();
+  }
+  return void 0;
+}
+async function deterministicDigest(namespace, ...parts) {
+  const encoded = new TextEncoder().encode(
+    [namespace, ...parts].map((part) => `${part.length}:${part}`).join("\0")
+  );
+  return new Uint8Array(
+    await globalThis.crypto.subtle.digest("SHA-256", encoded)
+  );
+}
+function digestHex(bytes, length) {
+  return Array.from(bytes.slice(0, length)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function digestUuid(bytes) {
+  const hex = digestHex(bytes, 16);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+async function batchSpanIds(inputFileId) {
+  const [row, span, root] = await Promise.all([
+    deterministicDigest("openai:batch:row", inputFileId),
+    deterministicDigest("openai:batch:span", inputFileId),
+    deterministicDigest("openai:batch:root", inputFileId)
+  ]);
+  return {
+    rowId: digestUuid(row),
+    spanId: digestHex(span, 8),
+    rootSpanId: digestHex(root, 16)
+  };
+}
+async function childSpanIds(inputFileId, customId) {
+  const [row, span] = await Promise.all([
+    deterministicDigest("openai:batch:child:row", inputFileId, customId),
+    deterministicDigest("openai:batch:child:span", inputFileId, customId)
+  ]);
+  return { rowId: digestUuid(row), spanId: digestHex(span, 8) };
+}
+async function startBatchSpan(context) {
+  const ids = await batchSpanIds(context.inputFileId);
+  const parent = SpanComponentsV4.fromStr(context.parent);
+  const hasParentSpan = Boolean(
+    parent.data.row_id && parent.data.span_id && parent.data.root_span_id
+  );
+  return withCurrent(
+    NOOP_SPAN,
+    () => _internalStartSpanWithInitialMergeAndParentSpanIds(
+      withSpanInstrumentationName(
+        {
+          name: "openai.batch",
+          type: "task" /* TASK */,
+          parent: context.parent,
+          ...!hasParentSpan ? {
+            parentSpanIds: {
+              parentSpanIds: [],
+              rootSpanId: ids.rootSpanId
+            }
+          } : {},
+          spanId: ids.spanId,
+          startTime: context.taskStartTime,
+          event: {
+            id: ids.rowId,
+            metadata: {
+              endpoint: context.endpoint,
+              input_file_id: context.inputFileId,
+              provider: "openai"
+            }
+          }
+        },
+        INSTRUMENTATION_NAMES.OPENAI
+      )
+    )
+  );
+}
+async function startBatchChild(context, taskParent, input) {
+  const ids = await childSpanIds(context.inputFileId, input.customId);
+  return withCurrent(
+    NOOP_SPAN,
+    () => _internalStartSpanWithInitialMerge(
+      withSpanInstrumentationName(
+        {
+          name: context.endpoint === "/v1/chat/completions" ? "Chat Completion" : "openai.responses.create",
+          type: "llm" /* LLM */,
+          parent: taskParent,
+          spanId: ids.spanId,
+          startTime: context.childStartTime,
+          event: {
+            id: ids.rowId,
+            ...input.spanData?.input !== void 0 ? { input: input.spanData.input } : {},
+            metadata: {
+              ...input.spanData?.metadata,
+              custom_id: input.customId,
+              provider: "openai"
+            }
+          }
+        },
+        INSTRUMENTATION_NAMES.OPENAI
+      )
+    )
+  );
+}
+async function* jsonlRecords(file, onIssue = () => {
+}) {
+  const resolvedFile = await file;
+  if (typeof resolvedFile === "string") {
+    for (const line of resolvedFile.split("\n")) {
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        yield JSON.parse(line.replace(/\r$/, ""));
+      } catch (error) {
+        logBatchInstrumentationError("skipped malformed JSONL", error);
+        onIssue(new Error("OpenAI Batch file contains malformed JSONL"));
+      }
+    }
+    return;
+  }
+  const body = read(resolvedFile, "body");
+  const getReader = read(body, "getReader");
+  if (isObject(body) && typeof getReader === "function") {
+    let reader;
+    try {
+      reader = Reflect.apply(getReader, body, []);
+      const decoder = new TextDecoder();
+      let pending = "";
+      while (true) {
+        const readChunk = read(reader, "read");
+        if (typeof readChunk !== "function") {
+          throw new Error("Response body stream has no read method");
+        }
+        const chunk = await Reflect.apply(readChunk, reader, []);
+        if (!isObject(chunk)) {
+          throw new Error("Response body stream returned an invalid chunk");
+        }
+        if (chunk.done === true) {
+          pending += decoder.decode();
+          break;
+        }
+        if (!(chunk.value instanceof Uint8Array)) {
+          throw new Error("Response body stream returned a non-byte chunk");
+        }
+        pending += decoder.decode(chunk.value, { stream: true });
+        let newline = pending.indexOf("\n");
+        while (newline !== -1) {
+          const line = pending.slice(0, newline).replace(/\r$/, "");
+          pending = pending.slice(newline + 1);
+          if (line.trim()) {
+            try {
+              yield JSON.parse(line);
+            } catch (error) {
+              logBatchInstrumentationError("skipped malformed JSONL", error);
+              onIssue(new Error("OpenAI Batch file contains malformed JSONL"));
+            }
+          }
+          newline = pending.indexOf("\n");
+        }
+      }
+      if (pending.trim()) {
+        try {
+          yield JSON.parse(pending.replace(/\r$/, ""));
+        } catch (error) {
+          logBatchInstrumentationError("skipped malformed JSONL", error);
+          onIssue(new Error("OpenAI Batch file contains malformed JSONL"));
+        }
+      }
+    } catch (error) {
+      logBatchInstrumentationError("could not read JSONL response body", error);
+      onIssue(new Error("OpenAI Batch response body could not be read"));
+    } finally {
+      const releaseLock = read(reader, "releaseLock");
+      if (typeof releaseLock === "function") {
+        try {
+          Reflect.apply(releaseLock, reader, []);
+        } catch (error) {
+          logBatchInstrumentationError(
+            "could not release stream reader",
+            error
+          );
+        }
+      }
+    }
+    return;
+  }
+  if (isBatchRecordIterable(resolvedFile)) {
+    for await (const record of resolvedFile) {
+      yield record;
+    }
+    return;
+  }
+  logBatchInstrumentationError("skipped invalid JSONL source", resolvedFile);
+  onIssue(new Error("OpenAI Batch file source is invalid"));
+}
+async function readBatchInputs(file) {
+  const inputs = /* @__PURE__ */ new Map();
+  const issues = [];
+  let endpoint;
+  try {
+    for await (const value of jsonlRecords(
+      file,
+      (issue) => issues.push(issue)
+    )) {
+      const customId = read(value, "custom_id");
+      const url = read(value, "url");
+      const body = read(value, "body");
+      if (!validCustomId(customId) || inputs.has(customId) || read(value, "method") !== "POST" || typeof url !== "string" || !SUPPORTED_ENDPOINTS.has(url) || endpoint !== void 0 && endpoint !== url || !isObject(body)) {
+        issues.push(new Error("OpenAI Batch input contains an invalid record"));
+        continue;
+      }
+      endpoint = url;
+      let spanData;
+      try {
+        spanData = extractOpenAIBatchInput(url, body);
+      } catch (error) {
+        logBatchInstrumentationError("could not extract batch input", error);
+      }
+      inputs.set(customId, { customId, spanData });
+    }
+  } catch (error) {
+    logBatchInstrumentationError("could not process input file", error);
+    issues.push(new Error("OpenAI Batch input file could not be processed"));
+  }
+  if (!endpoint || inputs.size === 0) {
+    issues.push(new Error("OpenAI Batch input contains no supported records"));
+  }
+  return { endpoint, inputs, issues };
+}
+async function writePendingSpans(trace, endTime) {
+  const task = await startBatchSpan(trace.context);
+  const taskParent = await task.export();
+  for (const input of trace.inputs.values()) {
+    try {
+      const child = await startBatchChild(trace.context, taskParent, input);
+      if (endTime !== void 0) {
+        child.end({ endTime });
+      }
+    } catch (error) {
+      logBatchInstrumentationError("could not write batch request span", error);
+    }
+  }
+  if (endTime !== void 0) {
+    if (trace.status && trace.status !== "completed") {
+      task.log({ error: new Error(`OpenAI Batch ${trace.status}`) });
+    }
+    task.end({ endTime });
+  }
+}
+var interceptOpenAIFilesCreateTraced = async (target, thisArg, args) => {
+  const startTime = getCurrentUnixTimestamp();
+  const inputPromise = readBatchInputs(args[0].inputFileContent);
+  const parentPromise = exportParent(args[0].parent);
+  const file = await Reflect.apply(target, thisArg, args);
+  try {
+    const inputFileId = read(file, "id");
+    const [inputData, exportedParent2] = await Promise.all([
+      inputPromise,
+      parentPromise
+    ]);
+    if (typeof inputFileId !== "string" || !exportedParent2 || !inputData.endpoint || inputData.issues.length > 0) {
+      if (inputData.issues[0]) {
+        logBatchInstrumentationError(
+          "skipped invalid input file",
+          inputData.issues[0]
+        );
+      }
+      return file;
+    }
+    const trace = {
+      context: {
+        inputFileId,
+        endpoint: inputData.endpoint,
+        parent: exportedParent2,
+        taskStartTime: startTime,
+        childStartTime: startTime
+      },
+      inputs: inputData.inputs
+    };
+    pendingBatchTraces.set(inputFileId, trace);
+    await writePendingSpans(trace);
+  } catch (error) {
+    logBatchInstrumentationError("could not start batch spans", error);
+  }
+  return file;
+};
+function validTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function terminalEndTime(batch, startTime) {
+  let timestamp;
+  switch (batch.status) {
+    case "completed":
+      timestamp = batch.completed_at;
+      break;
+    case "failed":
+      timestamp = batch.failed_at;
+      break;
+    case "expired":
+      timestamp = batch.expired_at;
+      break;
+    default:
+      timestamp = batch.cancelled_at;
+  }
+  return validTimestamp(timestamp) ? Math.max(timestamp, startTime) : Math.max(getCurrentUnixTimestamp(), startTime);
+}
+async function updateBatchTimestamps(batch) {
+  const trace = pendingBatchTraces.get(batch.input_file_id);
+  if (!trace || trace.context.endpoint !== batch.endpoint) {
+    return;
+  }
+  if (validTimestamp(batch.created_at)) {
+    trace.context.taskStartTime = batch.created_at;
+  }
+  trace.context.childStartTime = validTimestamp(batch.in_progress_at) ? Math.max(batch.in_progress_at, trace.context.taskStartTime) : trace.context.taskStartTime;
+  trace.status = batch.status;
+  if (TERMINAL_STATUSES.has(batch.status)) {
+    trace.endTime = terminalEndTime(batch, trace.context.childStartTime);
+  }
+  await writePendingSpans(trace, trace.endTime);
+}
+var interceptOpenAIBatchesRetrieveTraced = (target, thisArg, args) => Promise.resolve(Reflect.apply(target, thisArg, args)).then(async (batch) => {
+  try {
+    await updateBatchTimestamps(batch);
+  } catch (error) {
+    logBatchInstrumentationError("could not update batch timestamps", error);
+  }
+  return batch;
+});
+function errorFromResult(result) {
+  const error = read(result.value, "error");
+  if (isObject(error)) {
+    const message = read(error, "message");
+    return new Error(
+      typeof message === "string" ? message : "OpenAI Batch request failed"
+    );
+  }
+  const response = read(result.value, "response");
+  const statusCode = read(response, "status_code");
+  if (result.source === "error" || typeof statusCode === "number" && (statusCode < 200 || statusCode >= 300)) {
+    const message = read(read(read(response, "body"), "error"), "message");
+    return new Error(
+      typeof message === "string" ? message : "OpenAI Batch request failed"
+    );
+  }
+  return void 0;
+}
+async function completeBatchResult(context, taskParent, endTime, input, result) {
+  const child = await startBatchChild(context, taskParent, input);
+  try {
+    const resultError = errorFromResult(result);
+    const responseBody = read(read(result.value, "response"), "body");
+    if (resultError) {
+      child.log({ error: resultError });
+    } else if (isObject(responseBody)) {
+      const model = read(responseBody, "model");
+      child.log({
+        output: context.endpoint === "/v1/chat/completions" ? read(responseBody, "choices") : processImagesInOutput(read(responseBody, "output")),
+        ...typeof model === "string" ? { metadata: { model } } : {},
+        metrics: parseMetricsFromUsage(read(responseBody, "usage"))
+      });
+    } else {
+      child.log({ error: new Error("OpenAI Batch response body is missing") });
+    }
+  } catch (error) {
+    child.log({ error });
+  } finally {
+    child.end({ endTime });
+  }
+}
+async function completeResultFile({
+  context,
+  endTime,
+  file,
+  inputs,
+  issues,
+  seen,
+  source,
+  taskParent
+}) {
+  if (file === void 0) {
+    return;
+  }
+  for await (const value of jsonlRecords(file, (issue) => issues.push(issue))) {
+    const customId = read(value, "custom_id");
+    if (!validCustomId(customId) || !isObject(value)) {
+      issues.push(
+        new Error("OpenAI Batch result is missing a valid custom_id")
+      );
+      continue;
+    }
+    if (seen.has(customId)) {
+      issues.push(new Error("OpenAI Batch result contains a duplicate"));
+      continue;
+    }
+    const input = inputs.get(customId);
+    if (!input) {
+      issues.push(
+        new Error("OpenAI Batch result does not match an input record")
+      );
+      continue;
+    }
+    seen.add(customId);
+    await completeBatchResult(context, taskParent, endTime, input, {
+      value,
+      source
+    });
+  }
+}
+function sameInputs(first, second) {
+  return first.size === second.size && [...first.keys()].every((customId) => second.has(customId));
+}
+async function contextForCompletion(inputFileId, inputData) {
+  if (!inputData.endpoint || inputData.issues.length > 0) {
+    return void 0;
+  }
+  const existing = pendingBatchTraces.get(inputFileId);
+  if (existing) {
+    if (existing.context.endpoint !== inputData.endpoint || !sameInputs(existing.inputs, inputData.inputs)) {
+      return void 0;
+    }
+    return { ...existing, inputs: inputData.inputs };
+  }
+  const parent = await exportParent(getSpanParentObject());
+  if (!parent) {
+    return void 0;
+  }
+  const startTime = getCurrentUnixTimestamp();
+  return {
+    context: {
+      inputFileId,
+      endpoint: inputData.endpoint,
+      parent,
+      taskStartTime: startTime,
+      childStartTime: startTime
+    },
+    inputs: inputData.inputs
+  };
+}
+async function completeBatch(args) {
+  const inputData = await readBatchInputs(args.inputFileContent);
+  const trace = await contextForCompletion(args.inputFileId, inputData);
+  if (!trace) {
+    logBatchInstrumentationError(
+      "left batch spans pending",
+      inputData.issues[0] ?? new Error("OpenAI Batch input does not match")
+    );
+    return;
+  }
+  const endTime = trace.endTime ?? getCurrentUnixTimestamp();
+  const task = await startBatchSpan(trace.context);
+  const taskParent = await task.export();
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  await Promise.all([
+    completeResultFile({
+      context: trace.context,
+      endTime,
+      file: args.outputFileContent,
+      inputs: trace.inputs,
+      issues,
+      seen,
+      source: "output",
+      taskParent
+    }),
+    completeResultFile({
+      context: trace.context,
+      endTime,
+      file: args.errorFileContent,
+      inputs: trace.inputs,
+      issues,
+      seen,
+      source: "error",
+      taskParent
+    })
+  ]);
+  if (issues.length > 0) {
+    logBatchInstrumentationError("left batch spans pending", issues[0]);
+    return;
+  }
+  const missing = [...trace.inputs.values()].filter(
+    ({ customId }) => !seen.has(customId)
+  );
+  if (!trace.status || trace.status === "completed") {
+    if (missing.length > 0) {
+      logBatchInstrumentationError(
+        "left batch spans pending",
+        new Error("OpenAI Batch result files are incomplete")
+      );
+      return;
+    }
+  } else {
+    for (const input of missing) {
+      const child = await startBatchChild(trace.context, taskParent, input);
+      child.log({ error: new Error(`OpenAI Batch ${trace.status}`) });
+      child.end({ endTime });
+    }
+    task.log({ error: new Error(`OpenAI Batch ${trace.status}`) });
+  }
+  task.end({ endTime });
+  pendingBatchTraces.delete(args.inputFileId);
+}
+var interceptOpenAIBatchTraceComplete = (target, thisArg, args) => Promise.resolve(Reflect.apply(target, thisArg, args)).then(async (result) => {
+  try {
+    await completeBatch(args[0]);
+  } catch (error) {
+    logBatchInstrumentationError("could not complete batch", error);
+  }
+  return result;
+});
+
 // src/instrumentation/plugins/openai-plugin.ts
 var OpenAIPlugin = class extends BasePlugin {
   constructor() {
     super();
   }
   onEnable() {
+    this.unsubscribers.push(
+      openAIChannels.filesCreateTraced.intercept(
+        interceptOpenAIFilesCreateTraced
+      ),
+      openAIChannels.batchesRetrieveTraced.intercept(
+        interceptOpenAIBatchesRetrieveTraced
+      ),
+      openAIChannels.batchesCompleteTrace.intercept(
+        interceptOpenAIBatchTraceComplete
+      )
+    );
     this.unsubscribers.push(
       traceStreamingChannel(openAIChannels.chatCompletionsCreate, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const { messages, ...metadata } = params;
-          return {
-            input: processInputAttachments(messages),
-            metadata: { ...metadata, provider: "openai" }
-          };
-        },
+        extractInput: ([params]) => extractOpenAIChatInput(params),
         extractOutput: (result) => {
           return result?.choices;
         },
@@ -13216,13 +13875,7 @@ var OpenAIPlugin = class extends BasePlugin {
       traceStreamingChannel(openAIChannels.betaChatCompletionsParse, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const { messages, ...metadata } = params;
-          return {
-            input: processInputAttachments(messages),
-            metadata: { ...metadata, provider: "openai" }
-          };
-        },
+        extractInput: ([params]) => extractOpenAIChatInput(params),
         extractOutput: (result) => {
           return result?.choices;
         },
@@ -13244,13 +13897,7 @@ var OpenAIPlugin = class extends BasePlugin {
       traceSyncStreamChannel(openAIChannels.betaChatCompletionsStream, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const { messages, ...metadata } = params;
-          return {
-            input: processInputAttachments(messages),
-            metadata: { ...metadata, provider: "openai" }
-          };
-        }
+        extractInput: ([params]) => extractOpenAIChatInput(params)
       })
     );
     this.unsubscribers.push(
@@ -13280,23 +13927,11 @@ var OpenAIPlugin = class extends BasePlugin {
       traceStreamingChannel(openAIChannels.responsesCreate, {
         name: "openai.responses.create",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const { input, ...metadata } = params;
-          return {
-            input: processInputAttachments(input),
-            metadata: { ...metadata, provider: "openai" }
-          };
-        },
+        extractInput: ([params]) => extractOpenAIResponsesInput(params),
         extractOutput: (result) => {
           return processImagesInOutput(result?.output);
         },
-        extractMetadata: (result) => {
-          if (!result) {
-            return void 0;
-          }
-          const { output: _output, usage: _usage, ...metadata } = result;
-          return Object.keys(metadata).length > 0 ? metadata : void 0;
-        },
+        extractMetadata: (result) => extractOpenAIResponsesMetadata(result),
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
             parseMetricsFromUsage(result?.usage),
@@ -13315,13 +13950,7 @@ var OpenAIPlugin = class extends BasePlugin {
       traceSyncStreamChannel(openAIChannels.responsesStream, {
         name: "openai.responses.create",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const { input, ...metadata } = params;
-          return {
-            input: processInputAttachments(input),
-            metadata: { ...metadata, provider: "openai" }
-          };
-        },
+        extractInput: ([params]) => extractOpenAIResponsesInput(params),
         extractFromEvent: (event) => {
           if (event.type !== "response.completed" || !event.response) {
             return {};
@@ -13344,23 +13973,11 @@ var OpenAIPlugin = class extends BasePlugin {
       traceStreamingChannel(openAIChannels.responsesParse, {
         name: "openai.responses.parse",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const { input, ...metadata } = params;
-          return {
-            input: processInputAttachments(input),
-            metadata: { ...metadata, provider: "openai" }
-          };
-        },
+        extractInput: ([params]) => extractOpenAIResponsesInput(params),
         extractOutput: (result) => {
           return processImagesInOutput(result?.output);
         },
-        extractMetadata: (result) => {
-          if (!result) {
-            return void 0;
-          }
-          const { output: _output, usage: _usage, ...metadata } = result;
-          return Object.keys(metadata).length > 0 ? metadata : void 0;
-        },
+        extractMetadata: (result) => extractOpenAIResponsesMetadata(result),
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
             parseMetricsFromUsage(result?.usage),
@@ -13379,23 +13996,11 @@ var OpenAIPlugin = class extends BasePlugin {
       traceAsyncChannel(openAIChannels.responsesCompact, {
         name: "openai.responses.compact",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const { input, ...metadata } = params;
-          return {
-            input: processInputAttachments(input),
-            metadata: { ...metadata, provider: "openai" }
-          };
-        },
+        extractInput: ([params]) => extractOpenAIResponsesInput(params),
         extractOutput: (result) => {
           return processImagesInOutput(result?.output);
         },
-        extractMetadata: (result) => {
-          if (!result) {
-            return void 0;
-          }
-          const { output: _output, usage: _usage, ...metadata } = result;
-          return Object.keys(metadata).length > 0 ? metadata : void 0;
-        },
+        extractMetadata: (result) => extractOpenAIResponsesMetadata(result),
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
             parseMetricsFromUsage(result?.usage),
@@ -13451,35 +14056,6 @@ function withCachedMetric(metrics, result, endEvent) {
     cached
   };
 }
-function processImagesInOutput(output) {
-  if (Array.isArray(output)) {
-    return output.map(processImagesInOutput);
-  }
-  if (isObject(output)) {
-    if (output.type === "image_generation_call" && output.result && typeof output.result === "string") {
-      const fileExtension = output.output_format || "png";
-      const contentType = `image/${fileExtension}`;
-      const baseFilename = output.revised_prompt && typeof output.revised_prompt === "string" ? output.revised_prompt.slice(0, 50).replace(/[^a-zA-Z0-9]/g, "_") : "generated_image";
-      const filename = `${baseFilename}.${fileExtension}`;
-      const binaryString = atob(output.result);
-      const bytes = new Uint8Array(binaryString.length);
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      const blob = new Blob([bytes], { type: contentType });
-      const attachment = new Attachment({
-        data: blob,
-        filename,
-        contentType
-      });
-      return {
-        ...output,
-        result: attachment
-      };
-    }
-  }
-  return output;
-}
 function mergeLogprobTokens(existing, incoming) {
   if (incoming === void 0) {
     return existing;
@@ -18623,6 +19199,12 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       if (!activeEntry) {
         return result;
       }
+      const executionOptions = args[1];
+      const toolCallId = isObject(executionOptions) ? executionOptions.toolCallId : void 0;
+      const toolInput = {
+        input: serializeToolExecutionInput(args),
+        ...typeof toolCallId === "string" ? { metadata: { toolCallId } } : {}
+      };
       if (isAsyncGenerator(result)) {
         return (async function* () {
           const span = activeEntry.parentSpan.startSpan(
@@ -18636,7 +19218,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
               INSTRUMENTATION_NAMES.AI_SDK
             )
           );
-          span.log({ input: serializeToolExecutionInput(args) });
+          span.log(toolInput);
           try {
             let lastValue;
             for await (const value of result) {
@@ -18654,7 +19236,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       }
       return activeEntry.parentSpan.traced(
         async (span) => {
-          span.log({ input: serializeToolExecutionInput(args) });
+          span.log(toolInput);
           const awaitedResult = await result;
           span.log({ output: awaitedResult });
           return awaitedResult;
@@ -32776,14 +33358,17 @@ function getMetricsFromResponse(response) {
     if (!isRecord(usageMetadata)) {
       continue;
     }
-    const inputTokenDetails = usageMetadata.input_token_details;
+    const inputTokenDetails = isRecord(usageMetadata.input_token_details) ? usageMetadata.input_token_details : {};
     const outputTokenDetails = usageMetadata.output_token_details;
     return normalizeTokenMetrics({
       total_tokens: usageMetadata.total_tokens,
       prompt_tokens: usageMetadata.input_tokens,
       completion_tokens: usageMetadata.output_tokens,
-      prompt_cache_creation_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_creation : void 0,
-      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0,
+      // Prefer TTL-specific cache writes over the aggregate when available.
+      prompt_cache_creation_tokens: inputTokenDetails.ephemeral_5m_input_tokens == null && inputTokenDetails.ephemeral_1h_input_tokens == null ? inputTokenDetails.cache_creation : void 0,
+      prompt_cache_creation_5m_tokens: inputTokenDetails.ephemeral_5m_input_tokens,
+      prompt_cache_creation_1h_tokens: inputTokenDetails.ephemeral_1h_input_tokens,
+      prompt_cached_tokens: inputTokenDetails.cache_read,
       completion_reasoning_tokens: isRecord(outputTokenDetails) ? outputTokenDetails.reasoning : void 0
     });
   }
@@ -33499,7 +34084,7 @@ function extractSession(event) {
   return isObject(candidate) && typeof candidate.prompt === "function" ? candidate : void 0;
 }
 function isPiAgent(value) {
-  return isObject(value) && typeof value.streamFn === "function" && typeof value.subscribe === "function";
+  return isObject(value) && (typeof value.streamFunction === "function" || typeof value.streamFn === "function") && typeof value.subscribe === "function";
 }
 function promptContextStore() {
   piPromptContextStore ??= isomorph_default.newAsyncLocalStorage();
@@ -33509,17 +34094,21 @@ function currentPiPromptState() {
   return promptContextStore().getStore();
 }
 function installPiAgentInstrumentation(agent) {
+  const property = typeof agent.streamFunction === "function" ? "streamFunction" : "streamFn";
+  const streamFunction = agent[property];
   const existing = piAgentPatchStates.get(agent);
-  if (!existing || agent.streamFn !== existing.wrappedStreamFn) {
+  if (streamFunction && (!existing || existing.property !== property || streamFunction !== existing.wrappedStreamFunction)) {
     const patchState = {
-      originalStreamFn: agent.streamFn,
-      wrappedStreamFn: agent.streamFn
+      originalStreamFunction: streamFunction,
+      property,
+      wrappedStreamFunction: streamFunction
     };
-    patchState.wrappedStreamFn = makeInstrumentedStreamFn(
+    patchState.wrappedStreamFunction = makeInstrumentedStreamFunction(
       agent,
-      patchState.originalStreamFn
+      patchState.originalStreamFunction,
+      property
     );
-    agent.streamFn = patchState.wrappedStreamFn;
+    agent[property] = patchState.wrappedStreamFunction;
     piAgentPatchStates.set(agent, patchState);
   }
   if (piAgentEventSubscriptions.has(agent)) {
@@ -33544,15 +34133,21 @@ function installPiAgentInstrumentation(agent) {
     logInstrumentationError4("Pi Coding Agent event subscription", error);
   }
 }
-function makeInstrumentedStreamFn(agent, originalStreamFn) {
-  return async function instrumentedPiStreamFn(model, context, options) {
-    const invokeOriginal = () => Reflect.apply(originalStreamFn, this, [model, context, options]);
+function makeInstrumentedStreamFunction(agent, originalStreamFunction, property) {
+  return async function instrumentedPiStreamFunction(model, context, options) {
+    const invokeOriginal = () => Reflect.apply(originalStreamFunction, this, [model, context, options]);
     const state = currentPiPromptState();
     if (!state || state.agent !== agent || state.finalized) {
       return invokeOriginal();
     }
     wrapPiToolExecutors(context.tools);
-    const llmState = await startPiLlmSpan(state, model, context, options);
+    const llmState = await startPiLlmSpan(
+      state,
+      model,
+      context,
+      property,
+      options
+    );
     try {
       const stream = await runWithAutoInstrumentationSuppressed(invokeOriginal);
       return patchAssistantMessageStream(stream, state, llmState);
@@ -33589,12 +34184,12 @@ function wrapPiToolExecutors(tools) {
     }
   }
 }
-async function startPiLlmSpan(state, model, context, options) {
+async function startPiLlmSpan(state, model, context, property, options) {
   const metadata = {
     ...extractModelMetadata2(model),
     ...extractStreamOptionsMetadata(options),
     ...extractToolMetadata(context.tools),
-    "pi_coding_agent.operation": "agent.streamFn"
+    "pi_coding_agent.operation": `agent.${property}`
   };
   const span = startSpan(
     withSpanInstrumentationName(
@@ -38787,19 +39382,29 @@ function buildSpanScores(results) {
 function _internalPrepareEvaluatorScore(scoreValue, name) {
   if (scoreValue === null) return { results: null };
   if (Array.isArray(scoreValue)) {
+    const names = /* @__PURE__ */ new Set();
     for (const score of scoreValue) {
       if (!(typeof score === "object" && !isEmpty2(score))) {
         throw new Error(
           `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(score)}`
         );
       }
+      if (typeof score.name !== "string") {
+        throw new Error(
+          `When returning an array of scores, each score must have a name. Got: ${JSON.stringify(score)}`
+        );
+      }
+      if (names.has(score.name)) {
+        throw new Error(`Duplicate score name '${score.name}' in score array`);
+      }
+      names.add(score.name);
     }
   }
   let results;
   if (Array.isArray(scoreValue)) {
     results = scoreValue;
   } else if (typeof scoreValue === "object" && !isEmpty2(scoreValue)) {
-    results = [scoreValue];
+    results = [{ ...scoreValue, name: scoreValue.name ?? name }];
   } else {
     results = [{ name, score: scoreValue }];
   }