braintrust 3.29.0 → 3.30.0

package/dist/edge-light.mjs

@@ -5672,7 +5672,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.30.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -9919,6 +9919,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,
@@ -9932,7 +9941,7 @@ async function flush(options) {
 function setFetch(fetch2) {
   _internalGetGlobalState().setFetch(fetch2);
 }
-function startSpanAndIsLogger(args) {
+function startSpanAndIsLogger(args, internalOptions) {
   const state = args?.state ?? _globalState;
   const { parentObject, propagatedState } = getSpanParentObjectAndPropagatedState({
     asyncFlush: args?.asyncFlush,
@@ -9946,7 +9955,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,
@@ -13424,6 +13433,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 = {
@@ -13599,118 +13733,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";
@@ -13767,23 +13874,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 decoder2 = 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 += decoder2.decode();
+          break;
+        }
+        if (!(chunk.value instanceof Uint8Array)) {
+          throw new Error("Response body stream returned a non-byte chunk");
+        }
+        pending += decoder2.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;
         },
@@ -13829,13 +14486,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;
         },
@@ -13857,13 +14508,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(
@@ -13893,23 +14538,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),
@@ -13928,13 +14561,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 {};
@@ -13957,23 +14584,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),
@@ -13992,23 +14607,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),
@@ -14064,35 +14667,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;
@@ -34125,7 +34699,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();
@@ -34135,17 +34709,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)) {
@@ -34170,15 +34748,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);
@@ -34215,12 +34799,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(
@@ -37236,6 +37820,7 @@ __export(exports_exports, {
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
   collectAnthropicSession: () => collectAnthropicSession,
+  completeOpenAIBatchTrace: () => completeOpenAIBatchTrace,
   configureInstrumentation: () => configureInstrumentation,
   constructLogs3OverflowRequest: () => constructLogs3OverflowRequest,
   createFinalValuePassThroughStream: () => createFinalValuePassThroughStream,
@@ -37274,6 +37859,8 @@ __export(exports_exports, {
   loginToState: () => loginToState,
   logs3OverflowUploadSchema: () => logs3OverflowUploadSchema,
   newId: () => newId,
+  openaiBatchesRetrieveTraced: () => openaiBatchesRetrieveTraced,
+  openaiFilesCreateTraced: () => openaiFilesCreateTraced,
   parseCachedHeader: () => parseCachedHeader,
   parseTemplateFormat: () => parseTemplateFormat,
   permalink: () => permalink,
@@ -37438,6 +38025,260 @@ async function registerSandbox(options) {
   };
 }
 
+// src/wrappers/openai-promise-utils.ts
+function splitSpanInfo(allParams) {
+  const { span_info, ...params } = allParams;
+  return {
+    params,
+    span_info
+  };
+}
+function createChannelContext(_channel, params, span_info) {
+  return {
+    arguments: (
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      [params]
+    ),
+    span_info
+  };
+}
+async function tracePromiseWithResponse(channel2, traceContext, apiPromise) {
+  let enhancedResponse;
+  const tracePromise = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    channel2.tracePromise
+  );
+  const data = await tracePromise(async () => {
+    enhancedResponse = await apiPromise.withResponse();
+    traceContext.response = enhancedResponse.response;
+    return enhancedResponse.data;
+  }, traceContext);
+  if (!enhancedResponse) {
+    throw new Error("Expected withResponse() to provide response");
+  }
+  return {
+    data,
+    response: enhancedResponse.response,
+    request_id: enhancedResponse.request_id
+  };
+}
+async function tracePromiseAsResponse(channel2, traceContext, apiPromise) {
+  const tracePromise = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    channel2.tracePromise
+  );
+  let response;
+  await tracePromise(async () => {
+    response = await apiPromise.asResponse();
+    traceContext.response = response;
+    return void 0;
+  }, traceContext);
+  if (!response) {
+    throw new Error("Expected asResponse() to provide response");
+  }
+  return response;
+}
+function createLazyAPIPromise(ensureExecuted, ensureResponse, getAPIPromise) {
+  let firstConsumption;
+  let enhancedResponsePromise;
+  let dataPromise;
+  let responsePromise;
+  const withResponse = () => {
+    firstConsumption ??= "data";
+    enhancedResponsePromise ??= firstConsumption === "data" ? ensureExecuted() : getAPIPromise().withResponse();
+    return enhancedResponsePromise;
+  };
+  const asResponse = () => {
+    firstConsumption ??= "response";
+    responsePromise ??= firstConsumption === "response" ? ensureResponse() : getAPIPromise().asResponse();
+    return responsePromise;
+  };
+  return new Proxy({}, {
+    get(target, prop, receiver) {
+      if (prop === "withResponse") {
+        return withResponse;
+      }
+      if (prop === "asResponse") {
+        return asResponse;
+      }
+      if (prop === "then" || prop === "catch" || prop === "finally" || prop in Promise.prototype) {
+        dataPromise ??= withResponse().then((result) => result.data);
+        const value = Reflect.get(dataPromise, prop, receiver);
+        return typeof value === "function" ? value.bind(dataPromise) : value;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// src/openai-batch.ts
+function read2(value, key) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return void 0;
+  }
+  try {
+    return Reflect.get(value, key);
+  } catch {
+    return void 0;
+  }
+}
+function isAsyncIterable5(value) {
+  return typeof read2(value, Symbol.asyncIterator) === "function";
+}
+function teeAsyncIterable(source) {
+  const iterator = source[Symbol.asyncIterator]();
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        const result = await iterator.next();
+        if (result.done) {
+          controller.close();
+          return;
+        }
+        if (!(result.value instanceof Uint8Array)) {
+          throw new TypeError(
+            "OpenAI upload streams must yield Uint8Array chunks"
+          );
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+  const [uploadStream, trace] = stream.tee();
+  const upload = {
+    async *[Symbol.asyncIterator]() {
+      const reader = uploadStream.getReader();
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) {
+            return;
+          }
+          yield result.value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  };
+  const path = read2(source, "path");
+  if (typeof path === "string") {
+    Object.defineProperty(upload, "path", { value: path });
+  }
+  return { upload, trace: new Response(trace) };
+}
+function teeUpload(upload) {
+  if (upload instanceof Blob) {
+    return { upload, trace: new Response(upload) };
+  }
+  if (upload instanceof Response) {
+    return { upload, trace: upload.clone() };
+  }
+  if (isAsyncIterable5(upload)) {
+    return teeAsyncIterable(upload);
+  }
+  return void 0;
+}
+function openaiFilesCreateTraced(files) {
+  return (params, options) => {
+    const parent = getSpanParentObject();
+    const purpose = read2(params, "purpose");
+    const file = read2(params, "file");
+    if (purpose !== "batch") {
+      return files.create(params, options);
+    }
+    let branches;
+    try {
+      branches = teeUpload(file);
+    } catch {
+      return files.create(params, options);
+    }
+    if (!branches) {
+      return files.create(params, options);
+    }
+    const tracedParams = {
+      ...Object(params),
+      file: branches.upload
+    };
+    const apiPromise = files.create(tracedParams, options);
+    let enhancedResponse;
+    const tracedResponse = openAIChannels.filesCreateTraced.invoke(
+      async () => {
+        enhancedResponse = await apiPromise.withResponse();
+        return enhancedResponse.data;
+      },
+      files,
+      [{ params, inputFileContent: branches.trace, parent }],
+      {}
+    ).then((data) => {
+      if (!enhancedResponse) {
+        throw new Error(
+          "Expected OpenAI withResponse() to provide a response"
+        );
+      }
+      return { ...enhancedResponse, data };
+    });
+    return createLazyAPIPromise(
+      () => tracedResponse,
+      () => tracedResponse.then(({ response }) => response),
+      () => apiPromise
+    );
+  };
+}
+function openaiBatchesRetrieveTraced(batches) {
+  return (batchId, options) => {
+    const apiPromise = batches.retrieve(batchId, options);
+    let enhancedResponse;
+    const tracedResponse = openAIChannels.batchesRetrieveTraced.invoke(
+      async () => {
+        enhancedResponse = await apiPromise.withResponse();
+        return enhancedResponse.data;
+      },
+      batches,
+      [{ batchId }],
+      {}
+    ).then((data) => {
+      if (!enhancedResponse) {
+        throw new Error(
+          "Expected OpenAI withResponse() to provide a response"
+        );
+      }
+      return { ...enhancedResponse, data };
+    });
+    return createLazyAPIPromise(
+      () => tracedResponse,
+      () => tracedResponse.then(({ response }) => response),
+      () => apiPromise
+    );
+  };
+}
+async function completeOpenAIBatchTrace(args) {
+  const inputFileContent = Promise.resolve(args.inputFileContent);
+  const outputFileContent = args.outputFileContent === void 0 ? void 0 : Promise.resolve(args.outputFileContent);
+  const errorFileContent = args.errorFileContent === void 0 ? void 0 : Promise.resolve(args.errorFileContent);
+  void inputFileContent.catch(() => void 0);
+  void outputFileContent?.catch(() => void 0);
+  void errorFileContent?.catch(() => void 0);
+  await openAIChannels.batchesCompleteTrace.invoke(
+    async () => void 0,
+    void 0,
+    [
+      {
+        ...args,
+        inputFileContent,
+        outputFileContent,
+        errorFileContent
+      }
+    ],
+    {}
+  );
+}
+
 // src/functions/invoke.ts
 async function invoke(args) {
   const {
@@ -37540,58 +38381,6 @@ function initFunction({
   return f;
 }
 
-// src/wrappers/openai-promise-utils.ts
-function splitSpanInfo(allParams) {
-  const { span_info, ...params } = allParams;
-  return {
-    params,
-    span_info
-  };
-}
-function createChannelContext(_channel, params, span_info) {
-  return {
-    arguments: (
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      [params]
-    ),
-    span_info
-  };
-}
-async function tracePromiseWithResponse(channel2, traceContext, apiPromise) {
-  let enhancedResponse;
-  const tracePromise = (
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    channel2.tracePromise
-  );
-  const data = await tracePromise(async () => {
-    enhancedResponse = await apiPromise.withResponse();
-    traceContext.response = enhancedResponse.response;
-    return enhancedResponse.data;
-  }, traceContext);
-  if (!enhancedResponse) {
-    throw new Error("Expected withResponse() to provide response");
-  }
-  return { data, response: enhancedResponse.response };
-}
-function createLazyAPIPromise(ensureExecuted) {
-  let dataPromise = null;
-  return new Proxy({}, {
-    get(target, prop, receiver) {
-      if (prop === "withResponse") {
-        return () => ensureExecuted();
-      }
-      if (prop === "then" || prop === "catch" || prop === "finally" || prop in Promise.prototype) {
-        if (!dataPromise) {
-          dataPromise = ensureExecuted().then((result) => result.data);
-        }
-        const value = Reflect.get(dataPromise, prop, receiver);
-        return typeof value === "function" ? value.bind(dataPromise) : value;
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-
 // src/wrappers/oai_responses.ts
 function responsesProxy(openai) {
   if (!openai.responses) {
@@ -37628,17 +38417,33 @@ function wrapResponsesAsync(target, channel2) {
   return (allParams, options) => {
     const { span_info, params } = splitSpanInfo(allParams);
     let executionPromise = null;
+    let apiPromise = null;
+    const getAPIPromise = () => {
+      apiPromise ??= target(params, options);
+      return apiPromise;
+    };
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
           const traceContext = createChannelContext(channel2, params, span_info);
-          const apiPromise = target(params, options);
-          return tracePromiseWithResponse(channel2, traceContext, apiPromise);
+          return tracePromiseWithResponse(
+            channel2,
+            traceContext,
+            getAPIPromise()
+          );
         })();
       }
       return executionPromise;
     };
-    return createLazyAPIPromise(ensureExecuted);
+    return createLazyAPIPromise(
+      ensureExecuted,
+      () => tracePromiseAsResponse(
+        channel2,
+        createChannelContext(channel2, params, span_info),
+        getAPIPromise()
+      ),
+      getAPIPromise
+    );
   };
 }
 function wrapResponsesSyncStream(target, channel2) {
@@ -37784,6 +38589,11 @@ function wrapChatCompletion(completion) {
       allParams
     );
     let executionPromise = null;
+    let apiPromise = null;
+    const getAPIPromise = () => {
+      apiPromise ??= completion(params, options);
+      return apiPromise;
+    };
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
@@ -37793,32 +38603,44 @@ function wrapChatCompletion(completion) {
             span_info
           );
           if (params.stream) {
-            const completionPromise = completion(
-              params,
-              options
+            const completionPromise = (
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              getAPIPromise()
             );
-            const { data: data2, response: response2 } = await tracePromiseWithResponse(
+            const { data: data2, response: response2, request_id: request_id2 } = await tracePromiseWithResponse(
               openAIChannels.chatCompletionsCreate,
               traceContext,
               completionPromise
             );
-            return { data: data2, response: response2 };
+            return { data: data2, response: response2, request_id: request_id2 };
           }
-          const completionResponse = completion(
-            params,
-            options
+          const completionResponse = (
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            getAPIPromise()
           );
-          const { data, response } = await tracePromiseWithResponse(
+          const { data, response, request_id } = await tracePromiseWithResponse(
             openAIChannels.chatCompletionsCreate,
             traceContext,
             completionResponse
           );
-          return { data, response };
+          return { data, response, request_id };
         })();
       }
       return executionPromise;
     };
-    return createLazyAPIPromise(ensureExecuted);
+    return createLazyAPIPromise(
+      ensureExecuted,
+      () => tracePromiseAsResponse(
+        openAIChannels.chatCompletionsCreate,
+        createChannelContext(
+          openAIChannels.chatCompletionsCreate,
+          params,
+          span_info
+        ),
+        getAPIPromise()
+      ),
+      getAPIPromise
+    );
   };
 }
 function createEndpointProxy(target, wrapperFn) {
@@ -37836,6 +38658,11 @@ function wrapApiCreateWithChannel(create, channel2) {
   return (allParams, options) => {
     const { span_info, params } = splitSpanInfo(allParams);
     let executionPromise = null;
+    let apiPromise = null;
+    const getAPIPromise = () => {
+      apiPromise ??= create(params, options);
+      return apiPromise;
+    };
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
@@ -37843,13 +38670,21 @@ function wrapApiCreateWithChannel(create, channel2) {
           return tracePromiseWithResponse(
             channel2,
             traceContext,
-            create(params, options)
+            getAPIPromise()
           );
         })();
       }
       return executionPromise;
     };
-    return createLazyAPIPromise(ensureExecuted);
+    return createLazyAPIPromise(
+      ensureExecuted,
+      () => tracePromiseAsResponse(
+        channel2,
+        createChannelContext(channel2, params, span_info),
+        getAPIPromise()
+      ),
+      getAPIPromise
+    );
   };
 }
 var wrapEmbeddings = (create) => wrapApiCreateWithChannel(create, openAIChannels.embeddingsCreate);
@@ -40544,7 +41379,15 @@ var MAX_EVE_PROVIDER_CACHE_ENTRIES = 1e4;
 function createEveInstrumentationProvider(options = {}) {
   const bridge = new EveProviderBridge(options.metadata);
   return {
+    // Eve versions before tracePolicy use capture to decide whether provider
+    // events include content. Newer versions prefer tracePolicy when both are
+    // present, so keep the deprecated field for backwards compatibility.
     capture: "content",
+    tracePolicy: () => ({
+      emit: true,
+      recordInputs: true,
+      recordOutputs: true
+    }),
     events: {
       "action.completed": (event, context) => bridge.handleActionTerminal(event, context),
       "action.failed": (event, context) => bridge.handleActionTerminal(event, context),
@@ -44973,7 +45816,7 @@ function isAsync(fn) {
 function isAsyncGenerator2(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable5(obj) {
+function isAsyncIterable6(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -45145,7 +45988,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator2(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable5(obj)) {
+    if (isAsyncIterable6(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -46500,7 +47343,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable6(value) {
+function isAsyncIterable7(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -46535,7 +47378,7 @@ async function _internalResolveEvaluatorData(evaluator, experiment) {
     }).asDataset();
   }
   const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
-  if (isAsyncIterable6(resolvedDataResult)) {
+  if (isAsyncIterable7(resolvedDataResult)) {
     return resolvedDataResult;
   }
   if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
@@ -49583,6 +50426,7 @@ export {
   braintrustStreamChunkSchema,
   buildLocalSummary,
   collectAnthropicSession,
+  completeOpenAIBatchTrace,
   configureInstrumentation,
   constructLogs3OverflowRequest,
   createFinalValuePassThroughStream,
@@ -49622,6 +50466,8 @@ export {
   loginToState,
   logs3OverflowUploadSchema,
   newId,
+  openaiBatchesRetrieveTraced,
+  openaiFilesCreateTraced,
   parseCachedHeader,
   parseTemplateFormat,
   permalink,