braintrust 0.2.6 → 0.3.6

package/dist/browser.js

@@ -6413,19 +6413,15 @@ function responsesCreateProxy(target) {
   return proxyCreate(target, hooks);
 }
 function parseSpanFromResponseCreateParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.create",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -6437,25 +6433,29 @@ function parseSpanFromResponseCreateParams(params) {
   };
 }
 function parseEventFromResponseCreateResult(result) {
-  return {
-    output: _optionalChain([result, 'optionalAccess', _84 => _84.output_text]) || "",
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _85 => _85.usage]))
-  };
+  const data = {};
+  if (_optionalChain([result, 'optionalAccess', _84 => _84.output]) !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _85 => _85.usage]));
+  return data;
 }
 function parseSpanFromResponseParseParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.parse",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -6467,10 +6467,18 @@ function parseSpanFromResponseParseParams(params) {
   };
 }
 function parseEventFromResponseParseResult(result) {
-  return {
-    output: _optionalChain([result, 'optionalAccess', _86 => _86.output_parsed]) || _optionalChain([result, 'optionalAccess', _87 => _87.output_text]) || "",
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _88 => _88.usage]))
-  };
+  const data = {};
+  if (_optionalChain([result, 'optionalAccess', _86 => _86.output]) !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _87 => _87.usage]));
+  return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
   const span = timedSpan.span;
@@ -6486,7 +6494,7 @@ function traceResponseCreateStream(stream, timedSpan) {
       return result;
     }
     const item = result.value;
-    if (!item || !_optionalChain([item, 'optionalAccess', _89 => _89.type]) || !_optionalChain([item, 'optionalAccess', _90 => _90.response])) {
+    if (!item || !_optionalChain([item, 'optionalAccess', _88 => _88.type]) || !_optionalChain([item, 'optionalAccess', _89 => _89.response])) {
       return result;
     }
     const event = parseLogFromItem(item);
@@ -6497,24 +6505,24 @@ function traceResponseCreateStream(stream, timedSpan) {
   };
 }
 function parseLogFromItem(item) {
-  if (!item || !_optionalChain([item, 'optionalAccess', _91 => _91.type]) || !_optionalChain([item, 'optionalAccess', _92 => _92.response])) {
+  if (!item || !_optionalChain([item, 'optionalAccess', _90 => _90.type]) || !_optionalChain([item, 'optionalAccess', _91 => _91.response])) {
     return {};
   }
   const response = item.response;
   switch (item.type) {
     case "response.completed":
-      const texts = [];
-      for (const output of _optionalChain([response, 'optionalAccess', _93 => _93.output]) || []) {
-        for (const content of _optionalChain([output, 'optionalAccess', _94 => _94.content]) || []) {
-          if (_optionalChain([content, 'optionalAccess', _95 => _95.type]) === "output_text") {
-            texts.push(content.text);
-          }
+      const data = {};
+      if (_optionalChain([response, 'optionalAccess', _92 => _92.output]) !== void 0) {
+        data.output = response.output;
+      }
+      if (response) {
+        const { usage, output, ...metadata } = response;
+        if (Object.keys(metadata).length > 0) {
+          data.metadata = metadata;
         }
       }
-      return {
-        output: texts.join(""),
-        metrics: parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _96 => _96.usage]))
-      };
+      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _93 => _93.usage]));
+      return data;
     default:
       return {};
   }
@@ -6697,8 +6705,8 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(openai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(openai.moderations, wrapModerations);
   let betaProxy;
-  if (_optionalChain([openai, 'access', _97 => _97.beta, 'optionalAccess', _98 => _98.chat, 'optionalAccess', _99 => _99.completions, 'optionalAccess', _100 => _100.stream])) {
-    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _101 => _101.beta, 'optionalAccess', _102 => _102.chat, 'access', _103 => _103.completions]), {
+  if (_optionalChain([openai, 'access', _94 => _94.beta, 'optionalAccess', _95 => _95.chat, 'optionalAccess', _96 => _96.completions, 'optionalAccess', _97 => _97.stream])) {
+    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _98 => _98.beta, 'optionalAccess', _99 => _99.chat, 'access', _100 => _100.completions]), {
       get(target, name, receiver) {
         const baseVal = Reflect.get(target, name, receiver);
         if (name === "parse") {
@@ -6746,7 +6754,7 @@ function wrapOpenAIv4(openai) {
   });
 }
 function logCompletionResponse(startTime, response, span) {
-  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _104 => _104.usage]));
+  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _101 => _101.usage]));
   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   span.log({
     output: response.choices,
@@ -6841,55 +6849,80 @@ function logHeaders(response, span) {
   }
 }
 function wrapChatCompletion(completion) {
-  return async (allParams, options) => {
+  return (allParams, options) => {
     const { span_info: _, ...params } = allParams;
-    const span = startSpan(
-      _core.mergeDicts.call(void 0, 
-        {
-          name: "Chat Completion",
-          spanAttributes: {
-            type: _core.SpanTypeAttribute.LLM
-          }
-        },
-        parseChatCompletionParams(allParams)
-      )
-    );
-    const startTime = getCurrentUnixTimestamp();
-    if (params.stream) {
-      const { data: ret, response } = await completion(
-        // We could get rid of this type coercion if we could somehow enforce
-        // that `P extends ChatParams` BUT does not have the property
-        // `span_info`.
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        params,
-        options
-      ).withResponse();
-      logHeaders(response, span);
-      const wrapperStream = new WrapperStream(span, startTime, ret.iterator());
-      ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
-      return ret;
-    } else {
-      try {
-        const completionResponse = completion(
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          params,
-          options
-        );
-        const { data: ret, response } = await completionResponse.withResponse();
-        logHeaders(response, span);
-        const { messages, ...rest } = params;
-        span.log({
-          input: messages,
-          metadata: {
-            ...rest
+    let executionPromise = null;
+    const executeWrapped = () => {
+      if (!executionPromise) {
+        executionPromise = (async () => {
+          const span = startSpan(
+            _core.mergeDicts.call(void 0, 
+              {
+                name: "Chat Completion",
+                spanAttributes: {
+                  type: _core.SpanTypeAttribute.LLM
+                }
+              },
+              parseChatCompletionParams(allParams)
+            )
+          );
+          const startTime = getCurrentUnixTimestamp();
+          if (params.stream) {
+            const { data: ret, response } = await completion(
+              // We could get rid of this type coercion if we could somehow enforce
+              // that `P extends ChatParams` BUT does not have the property
+              // `span_info`.
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              params,
+              options
+            ).withResponse();
+            logHeaders(response, span);
+            const wrapperStream = new WrapperStream(
+              span,
+              startTime,
+              ret.iterator()
+            );
+            ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
+            return { data: ret, response };
+          } else {
+            try {
+              const completionResponse = completion(
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                params,
+                options
+              );
+              const { data: ret, response } = await completionResponse.withResponse();
+              logHeaders(response, span);
+              const { messages, ...rest } = params;
+              span.log({
+                input: messages,
+                metadata: {
+                  ...rest
+                }
+              });
+              logCompletionResponse(startTime, ret, span);
+              return { data: ret, response };
+            } finally {
+              span.end();
+            }
           }
-        });
-        logCompletionResponse(startTime, ret, span);
-        return ret;
-      } finally {
-        span.end();
+        })();
       }
-    }
+      return executionPromise;
+    };
+    const dataPromise = executeWrapped().then((result) => result.data);
+    return new Proxy(dataPromise, {
+      get(target, prop, receiver) {
+        if (prop === "withResponse") {
+          return executeWrapped;
+        }
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+    });
   };
 }
 function parseBaseParams(allParams, inputField) {
@@ -6948,7 +6981,7 @@ function parseChatCompletionParams(params) {
 function processEmbeddingResponse(result, span) {
   span.log({
     output: { embedding_length: result.data[0].embedding.length },
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _105 => _105.usage]))
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _102 => _102.usage]))
   });
 }
 function processModerationResponse(result, span) {
@@ -6978,10 +7011,10 @@ function postprocessStreamingResults(allResults) {
     if (result.usage) {
       metrics = {
         ...metrics,
-        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _106 => _106.usage]))
+        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _103 => _103.usage]))
       };
     }
-    const delta = _optionalChain([result, 'access', _107 => _107.choices, 'optionalAccess', _108 => _108[0], 'optionalAccess', _109 => _109.delta]);
+    const delta = _optionalChain([result, 'access', _104 => _104.choices, 'optionalAccess', _105 => _105[0], 'optionalAccess', _106 => _106.delta]);
     if (!delta) {
       continue;
     }

package/dist/browser.mjs

@@ -6413,19 +6413,15 @@ function responsesCreateProxy(target) {
   return proxyCreate(target, hooks);
 }
 function parseSpanFromResponseCreateParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.create",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -6437,25 +6433,29 @@ function parseSpanFromResponseCreateParams(params) {
   };
 }
 function parseEventFromResponseCreateResult(result) {
-  return {
-    output: result?.output_text || "",
-    metrics: parseMetricsFromUsage(result?.usage)
-  };
+  const data = {};
+  if (result?.output !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(result?.usage);
+  return data;
 }
 function parseSpanFromResponseParseParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.parse",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -6467,10 +6467,18 @@ function parseSpanFromResponseParseParams(params) {
   };
 }
 function parseEventFromResponseParseResult(result) {
-  return {
-    output: result?.output_parsed || result?.output_text || "",
-    metrics: parseMetricsFromUsage(result?.usage)
-  };
+  const data = {};
+  if (result?.output !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(result?.usage);
+  return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
   const span = timedSpan.span;
@@ -6503,18 +6511,18 @@ function parseLogFromItem(item) {
   const response = item.response;
   switch (item.type) {
     case "response.completed":
-      const texts = [];
-      for (const output of response?.output || []) {
-        for (const content of output?.content || []) {
-          if (content?.type === "output_text") {
-            texts.push(content.text);
-          }
+      const data = {};
+      if (response?.output !== void 0) {
+        data.output = response.output;
+      }
+      if (response) {
+        const { usage, output, ...metadata } = response;
+        if (Object.keys(metadata).length > 0) {
+          data.metadata = metadata;
         }
       }
-      return {
-        output: texts.join(""),
-        metrics: parseMetricsFromUsage(response?.usage)
-      };
+      data.metrics = parseMetricsFromUsage(response?.usage);
+      return data;
     default:
       return {};
   }
@@ -6841,55 +6849,80 @@ function logHeaders(response, span) {
   }
 }
 function wrapChatCompletion(completion) {
-  return async (allParams, options) => {
+  return (allParams, options) => {
     const { span_info: _, ...params } = allParams;
-    const span = startSpan(
-      mergeDicts2(
-        {
-          name: "Chat Completion",
-          spanAttributes: {
-            type: SpanTypeAttribute2.LLM
-          }
-        },
-        parseChatCompletionParams(allParams)
-      )
-    );
-    const startTime = getCurrentUnixTimestamp();
-    if (params.stream) {
-      const { data: ret, response } = await completion(
-        // We could get rid of this type coercion if we could somehow enforce
-        // that `P extends ChatParams` BUT does not have the property
-        // `span_info`.
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        params,
-        options
-      ).withResponse();
-      logHeaders(response, span);
-      const wrapperStream = new WrapperStream(span, startTime, ret.iterator());
-      ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
-      return ret;
-    } else {
-      try {
-        const completionResponse = completion(
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          params,
-          options
-        );
-        const { data: ret, response } = await completionResponse.withResponse();
-        logHeaders(response, span);
-        const { messages, ...rest } = params;
-        span.log({
-          input: messages,
-          metadata: {
-            ...rest
+    let executionPromise = null;
+    const executeWrapped = () => {
+      if (!executionPromise) {
+        executionPromise = (async () => {
+          const span = startSpan(
+            mergeDicts2(
+              {
+                name: "Chat Completion",
+                spanAttributes: {
+                  type: SpanTypeAttribute2.LLM
+                }
+              },
+              parseChatCompletionParams(allParams)
+            )
+          );
+          const startTime = getCurrentUnixTimestamp();
+          if (params.stream) {
+            const { data: ret, response } = await completion(
+              // We could get rid of this type coercion if we could somehow enforce
+              // that `P extends ChatParams` BUT does not have the property
+              // `span_info`.
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              params,
+              options
+            ).withResponse();
+            logHeaders(response, span);
+            const wrapperStream = new WrapperStream(
+              span,
+              startTime,
+              ret.iterator()
+            );
+            ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
+            return { data: ret, response };
+          } else {
+            try {
+              const completionResponse = completion(
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                params,
+                options
+              );
+              const { data: ret, response } = await completionResponse.withResponse();
+              logHeaders(response, span);
+              const { messages, ...rest } = params;
+              span.log({
+                input: messages,
+                metadata: {
+                  ...rest
+                }
+              });
+              logCompletionResponse(startTime, ret, span);
+              return { data: ret, response };
+            } finally {
+              span.end();
+            }
           }
-        });
-        logCompletionResponse(startTime, ret, span);
-        return ret;
-      } finally {
-        span.end();
+        })();
       }
-    }
+      return executionPromise;
+    };
+    const dataPromise = executeWrapped().then((result) => result.data);
+    return new Proxy(dataPromise, {
+      get(target, prop, receiver) {
+        if (prop === "withResponse") {
+          return executeWrapped;
+        }
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+    });
   };
 }
 function parseBaseParams(allParams, inputField) {

package/dist/cli.js

@@ -1232,7 +1232,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "0.2.6",
+      version: "0.3.6",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",

package/dist/index.js

@@ -12228,19 +12228,15 @@ function responsesCreateProxy(target) {
   return proxyCreate(target, hooks);
 }
 function parseSpanFromResponseCreateParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.create",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -12252,25 +12248,29 @@ function parseSpanFromResponseCreateParams(params) {
   };
 }
 function parseEventFromResponseCreateResult(result) {
-  return {
-    output: _optionalChain([result, 'optionalAccess', _161 => _161.output_text]) || "",
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _162 => _162.usage]))
-  };
+  const data = {};
+  if (_optionalChain([result, 'optionalAccess', _161 => _161.output]) !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _162 => _162.usage]));
+  return data;
 }
 function parseSpanFromResponseParseParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.parse",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -12282,10 +12282,18 @@ function parseSpanFromResponseParseParams(params) {
   };
 }
 function parseEventFromResponseParseResult(result) {
-  return {
-    output: _optionalChain([result, 'optionalAccess', _163 => _163.output_parsed]) || _optionalChain([result, 'optionalAccess', _164 => _164.output_text]) || "",
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _165 => _165.usage]))
-  };
+  const data = {};
+  if (_optionalChain([result, 'optionalAccess', _163 => _163.output]) !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _164 => _164.usage]));
+  return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
   const span = timedSpan.span;
@@ -12301,7 +12309,7 @@ function traceResponseCreateStream(stream, timedSpan) {
       return result;
     }
     const item = result.value;
-    if (!item || !_optionalChain([item, 'optionalAccess', _166 => _166.type]) || !_optionalChain([item, 'optionalAccess', _167 => _167.response])) {
+    if (!item || !_optionalChain([item, 'optionalAccess', _165 => _165.type]) || !_optionalChain([item, 'optionalAccess', _166 => _166.response])) {
       return result;
     }
     const event = parseLogFromItem(item);
@@ -12312,24 +12320,24 @@ function traceResponseCreateStream(stream, timedSpan) {
   };
 }
 function parseLogFromItem(item) {
-  if (!item || !_optionalChain([item, 'optionalAccess', _168 => _168.type]) || !_optionalChain([item, 'optionalAccess', _169 => _169.response])) {
+  if (!item || !_optionalChain([item, 'optionalAccess', _167 => _167.type]) || !_optionalChain([item, 'optionalAccess', _168 => _168.response])) {
     return {};
   }
   const response = item.response;
   switch (item.type) {
     case "response.completed":
-      const texts = [];
-      for (const output of _optionalChain([response, 'optionalAccess', _170 => _170.output]) || []) {
-        for (const content of _optionalChain([output, 'optionalAccess', _171 => _171.content]) || []) {
-          if (_optionalChain([content, 'optionalAccess', _172 => _172.type]) === "output_text") {
-            texts.push(content.text);
-          }
+      const data = {};
+      if (_optionalChain([response, 'optionalAccess', _169 => _169.output]) !== void 0) {
+        data.output = response.output;
+      }
+      if (response) {
+        const { usage, output, ...metadata } = response;
+        if (Object.keys(metadata).length > 0) {
+          data.metadata = metadata;
         }
       }
-      return {
-        output: texts.join(""),
-        metrics: parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _173 => _173.usage]))
-      };
+      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _170 => _170.usage]));
+      return data;
     default:
       return {};
   }
@@ -12512,8 +12520,8 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(openai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(openai.moderations, wrapModerations);
   let betaProxy2;
-  if (_optionalChain([openai, 'access', _174 => _174.beta, 'optionalAccess', _175 => _175.chat, 'optionalAccess', _176 => _176.completions, 'optionalAccess', _177 => _177.stream])) {
-    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _178 => _178.beta, 'optionalAccess', _179 => _179.chat, 'access', _180 => _180.completions]), {
+  if (_optionalChain([openai, 'access', _171 => _171.beta, 'optionalAccess', _172 => _172.chat, 'optionalAccess', _173 => _173.completions, 'optionalAccess', _174 => _174.stream])) {
+    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _175 => _175.beta, 'optionalAccess', _176 => _176.chat, 'access', _177 => _177.completions]), {
       get(target, name, receiver) {
         const baseVal = Reflect.get(target, name, receiver);
         if (name === "parse") {
@@ -12561,7 +12569,7 @@ function wrapOpenAIv4(openai) {
   });
 }
 function logCompletionResponse(startTime, response, span) {
-  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _181 => _181.usage]));
+  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _178 => _178.usage]));
   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   span.log({
     output: response.choices,
@@ -12656,55 +12664,80 @@ function logHeaders(response, span) {
   }
 }
 function wrapChatCompletion(completion) {
-  return async (allParams, options) => {
+  return (allParams, options) => {
     const { span_info: _, ...params } = allParams;
-    const span = startSpan(
-      _core.mergeDicts.call(void 0, 
-        {
-          name: "Chat Completion",
-          spanAttributes: {
-            type: _core.SpanTypeAttribute.LLM
-          }
-        },
-        parseChatCompletionParams(allParams)
-      )
-    );
-    const startTime = getCurrentUnixTimestamp();
-    if (params.stream) {
-      const { data: ret, response } = await completion(
-        // We could get rid of this type coercion if we could somehow enforce
-        // that `P extends ChatParams` BUT does not have the property
-        // `span_info`.
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        params,
-        options
-      ).withResponse();
-      logHeaders(response, span);
-      const wrapperStream = new WrapperStream(span, startTime, ret.iterator());
-      ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
-      return ret;
-    } else {
-      try {
-        const completionResponse = completion(
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          params,
-          options
-        );
-        const { data: ret, response } = await completionResponse.withResponse();
-        logHeaders(response, span);
-        const { messages, ...rest } = params;
-        span.log({
-          input: messages,
-          metadata: {
-            ...rest
+    let executionPromise = null;
+    const executeWrapped = () => {
+      if (!executionPromise) {
+        executionPromise = (async () => {
+          const span = startSpan(
+            _core.mergeDicts.call(void 0, 
+              {
+                name: "Chat Completion",
+                spanAttributes: {
+                  type: _core.SpanTypeAttribute.LLM
+                }
+              },
+              parseChatCompletionParams(allParams)
+            )
+          );
+          const startTime = getCurrentUnixTimestamp();
+          if (params.stream) {
+            const { data: ret, response } = await completion(
+              // We could get rid of this type coercion if we could somehow enforce
+              // that `P extends ChatParams` BUT does not have the property
+              // `span_info`.
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              params,
+              options
+            ).withResponse();
+            logHeaders(response, span);
+            const wrapperStream = new WrapperStream(
+              span,
+              startTime,
+              ret.iterator()
+            );
+            ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
+            return { data: ret, response };
+          } else {
+            try {
+              const completionResponse = completion(
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                params,
+                options
+              );
+              const { data: ret, response } = await completionResponse.withResponse();
+              logHeaders(response, span);
+              const { messages, ...rest } = params;
+              span.log({
+                input: messages,
+                metadata: {
+                  ...rest
+                }
+              });
+              logCompletionResponse(startTime, ret, span);
+              return { data: ret, response };
+            } finally {
+              span.end();
+            }
           }
-        });
-        logCompletionResponse(startTime, ret, span);
-        return ret;
-      } finally {
-        span.end();
+        })();
       }
-    }
+      return executionPromise;
+    };
+    const dataPromise = executeWrapped().then((result) => result.data);
+    return new Proxy(dataPromise, {
+      get(target, prop, receiver) {
+        if (prop === "withResponse") {
+          return executeWrapped;
+        }
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+    });
   };
 }
 function parseBaseParams(allParams, inputField) {
@@ -12763,7 +12796,7 @@ function parseChatCompletionParams(params) {
 function processEmbeddingResponse(result, span) {
   span.log({
     output: { embedding_length: result.data[0].embedding.length },
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _182 => _182.usage]))
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _179 => _179.usage]))
   });
 }
 function processModerationResponse(result, span) {
@@ -12793,10 +12826,10 @@ function postprocessStreamingResults(allResults) {
     if (result.usage) {
       metrics = {
         ...metrics,
-        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _183 => _183.usage]))
+        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _180 => _180.usage]))
       };
     }
-    const delta = _optionalChain([result, 'access', _184 => _184.choices, 'optionalAccess', _185 => _185[0], 'optionalAccess', _186 => _186.delta]);
+    const delta = _optionalChain([result, 'access', _181 => _181.choices, 'optionalAccess', _182 => _182[0], 'optionalAccess', _183 => _183.delta]);
     if (!delta) {
       continue;
     }
@@ -12901,17 +12934,17 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
 
 // src/wrappers/ai-sdk-v2.ts
 function detectProviderFromResult(result) {
-  if (!_optionalChain([result, 'optionalAccess', _187 => _187.providerMetadata])) {
+  if (!_optionalChain([result, 'optionalAccess', _184 => _184.providerMetadata])) {
     return void 0;
   }
   const keys = Object.keys(result.providerMetadata);
-  return _optionalChain([keys, 'optionalAccess', _188 => _188.at, 'call', _189 => _189(0)]);
+  return _optionalChain([keys, 'optionalAccess', _185 => _185.at, 'call', _186 => _186(0)]);
 }
 function extractModelFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _190 => _190.response, 'optionalAccess', _191 => _191.modelId])) {
+  if (_optionalChain([result, 'optionalAccess', _187 => _187.response, 'optionalAccess', _188 => _188.modelId])) {
     return result.response.modelId;
   }
-  if (_optionalChain([result, 'optionalAccess', _192 => _192.request, 'optionalAccess', _193 => _193.body, 'optionalAccess', _194 => _194.model])) {
+  if (_optionalChain([result, 'optionalAccess', _189 => _189.request, 'optionalAccess', _190 => _190.body, 'optionalAccess', _191 => _191.model])) {
     return result.request.body.model;
   }
   return void 0;
@@ -12971,7 +13004,7 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
-    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _195 => _195.anthropic]);
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _192 => _192.anthropic]);
     if (anthropicMetadata) {
       const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
       const cacheCreationTokens = getNumberProperty(
@@ -13136,7 +13169,7 @@ function BraintrustMiddleware(config = {}) {
 // src/wrappers/ai-sdk-v1.ts
 function wrapAISDKModel(model) {
   const m = model;
-  if (_optionalChain([m, 'optionalAccess', _196 => _196.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _197 => _197.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _198 => _198.modelId]) === "string") {
+  if (_optionalChain([m, 'optionalAccess', _193 => _193.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _194 => _194.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _195 => _195.modelId]) === "string") {
     return new BraintrustLanguageModelWrapper(m);
   } else {
     console.warn("Unsupported AI SDK model. Not wrapping.");
@@ -13192,10 +13225,10 @@ var BraintrustLanguageModelWrapper = class {
         metrics: {
           time_to_first_token: getCurrentUnixTimestamp() - startTime,
           tokens: !isEmpty(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: _optionalChain([ret, 'access', _199 => _199.usage, 'optionalAccess', _200 => _200.promptTokens]),
-          completion_tokens: _optionalChain([ret, 'access', _201 => _201.usage, 'optionalAccess', _202 => _202.completionTokens]),
+          prompt_tokens: _optionalChain([ret, 'access', _196 => _196.usage, 'optionalAccess', _197 => _197.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _198 => _198.usage, 'optionalAccess', _199 => _199.completionTokens]),
           cached: parseCachedHeader(
-            _nullishCoalesce(_optionalChain([ret, 'access', _203 => _203.rawResponse, 'optionalAccess', _204 => _204.headers, 'optionalAccess', _205 => _205[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _206 => _206.rawResponse, 'optionalAccess', _207 => _207.headers, 'optionalAccess', _208 => _208[LEGACY_CACHED_HEADER]])))
+            _nullishCoalesce(_optionalChain([ret, 'access', _200 => _200.rawResponse, 'optionalAccess', _201 => _201.headers, 'optionalAccess', _202 => _202[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _203 => _203.rawResponse, 'optionalAccess', _204 => _204.headers, 'optionalAccess', _205 => _205[LEGACY_CACHED_HEADER]])))
           )
         }
       });
@@ -13287,10 +13320,10 @@ var BraintrustLanguageModelWrapper = class {
                 metrics: {
                   time_to_first_token,
                   tokens: !isEmpty(usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _209 => _209.promptTokens]),
-                  completion_tokens: _optionalChain([usage, 'optionalAccess', _210 => _210.completionTokens]),
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _206 => _206.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _207 => _207.completionTokens]),
                   cached: parseCachedHeader(
-                    _nullishCoalesce(_optionalChain([ret, 'access', _211 => _211.rawResponse, 'optionalAccess', _212 => _212.headers, 'optionalAccess', _213 => _213[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _214 => _214.rawResponse, 'optionalAccess', _215 => _215.headers, 'optionalAccess', _216 => _216[LEGACY_CACHED_HEADER]])))
+                    _nullishCoalesce(_optionalChain([ret, 'access', _208 => _208.rawResponse, 'optionalAccess', _209 => _209.headers, 'optionalAccess', _210 => _210[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _211 => _211.rawResponse, 'optionalAccess', _212 => _212.headers, 'optionalAccess', _213 => _213[LEGACY_CACHED_HEADER]])))
                   )
                 }
               });
@@ -13337,7 +13370,7 @@ function postProcessPrompt(prompt) {
         return [
           {
             role: "assistant",
-            content: _optionalChain([textPart, 'optionalAccess', _217 => _217.text]),
+            content: _optionalChain([textPart, 'optionalAccess', _214 => _214.text]),
             ...toolCallParts.length > 0 ? {
               tool_calls: toolCallParts.map((part) => ({
                 id: part.toolCallId,
@@ -13574,9 +13607,9 @@ function streamNextProxy(stream, sspan) {
       return result;
     }
     const item = result.value;
-    switch (_optionalChain([item, 'optionalAccess', _218 => _218.type])) {
+    switch (_optionalChain([item, 'optionalAccess', _215 => _215.type])) {
       case "message_start":
-        const msg = _optionalChain([item, 'optionalAccess', _219 => _219.message]);
+        const msg = _optionalChain([item, 'optionalAccess', _216 => _216.message]);
         if (msg) {
           const event = parseEventFromMessage(msg);
           totals = { ...totals, ...event.metrics };
@@ -13584,20 +13617,20 @@ function streamNextProxy(stream, sspan) {
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([item, 'access', _220 => _220.delta, 'optionalAccess', _221 => _221.type]) === "text_delta") {
-          const text = _optionalChain([item, 'optionalAccess', _222 => _222.delta, 'optionalAccess', _223 => _223.text]);
+        if (_optionalChain([item, 'access', _217 => _217.delta, 'optionalAccess', _218 => _218.type]) === "text_delta") {
+          const text = _optionalChain([item, 'optionalAccess', _219 => _219.delta, 'optionalAccess', _220 => _220.text]);
           if (text) {
             deltas.push(text);
           }
         }
         break;
       case "message_delta":
-        const usage = _optionalChain([item, 'optionalAccess', _224 => _224.usage]);
+        const usage = _optionalChain([item, 'optionalAccess', _221 => _221.usage]);
         if (usage) {
           const metrics = parseMetricsFromUsage2(usage);
           totals = { ...totals, ...metrics };
         }
-        const delta = _optionalChain([item, 'optionalAccess', _225 => _225.delta]);
+        const delta = _optionalChain([item, 'optionalAccess', _222 => _222.delta]);
         if (delta) {
           metadata = { ...metadata, ...delta };
         }
@@ -13609,8 +13642,8 @@ function streamNextProxy(stream, sspan) {
   };
 }
 function parseEventFromMessage(message) {
-  const output = _optionalChain([message, 'optionalAccess', _226 => _226.content]) || null;
-  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _227 => _227.usage]));
+  const output = _optionalChain([message, 'optionalAccess', _223 => _223.content]) || null;
+  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _224 => _224.usage]));
   const metas = ["stop_reason", "stop_sequence"];
   const metadata = {};
   for (const m of metas) {

package/dist/index.mjs

@@ -12228,19 +12228,15 @@ function responsesCreateProxy(target) {
   return proxyCreate(target, hooks);
 }
 function parseSpanFromResponseCreateParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.create",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -12252,25 +12248,29 @@ function parseSpanFromResponseCreateParams(params) {
   };
 }
 function parseEventFromResponseCreateResult(result) {
-  return {
-    output: result?.output_text || "",
-    metrics: parseMetricsFromUsage(result?.usage)
-  };
+  const data = {};
+  if (result?.output !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(result?.usage);
+  return data;
 }
 function parseSpanFromResponseParseParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.parse",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -12282,10 +12282,18 @@ function parseSpanFromResponseParseParams(params) {
   };
 }
 function parseEventFromResponseParseResult(result) {
-  return {
-    output: result?.output_parsed || result?.output_text || "",
-    metrics: parseMetricsFromUsage(result?.usage)
-  };
+  const data = {};
+  if (result?.output !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(result?.usage);
+  return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
   const span = timedSpan.span;
@@ -12318,18 +12326,18 @@ function parseLogFromItem(item) {
   const response = item.response;
   switch (item.type) {
     case "response.completed":
-      const texts = [];
-      for (const output of response?.output || []) {
-        for (const content of output?.content || []) {
-          if (content?.type === "output_text") {
-            texts.push(content.text);
-          }
+      const data = {};
+      if (response?.output !== void 0) {
+        data.output = response.output;
+      }
+      if (response) {
+        const { usage, output, ...metadata } = response;
+        if (Object.keys(metadata).length > 0) {
+          data.metadata = metadata;
         }
       }
-      return {
-        output: texts.join(""),
-        metrics: parseMetricsFromUsage(response?.usage)
-      };
+      data.metrics = parseMetricsFromUsage(response?.usage);
+      return data;
     default:
       return {};
   }
@@ -12656,55 +12664,80 @@ function logHeaders(response, span) {
   }
 }
 function wrapChatCompletion(completion) {
-  return async (allParams, options) => {
+  return (allParams, options) => {
     const { span_info: _, ...params } = allParams;
-    const span = startSpan(
-      mergeDicts3(
-        {
-          name: "Chat Completion",
-          spanAttributes: {
-            type: SpanTypeAttribute3.LLM
-          }
-        },
-        parseChatCompletionParams(allParams)
-      )
-    );
-    const startTime = getCurrentUnixTimestamp();
-    if (params.stream) {
-      const { data: ret, response } = await completion(
-        // We could get rid of this type coercion if we could somehow enforce
-        // that `P extends ChatParams` BUT does not have the property
-        // `span_info`.
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        params,
-        options
-      ).withResponse();
-      logHeaders(response, span);
-      const wrapperStream = new WrapperStream(span, startTime, ret.iterator());
-      ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
-      return ret;
-    } else {
-      try {
-        const completionResponse = completion(
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          params,
-          options
-        );
-        const { data: ret, response } = await completionResponse.withResponse();
-        logHeaders(response, span);
-        const { messages, ...rest } = params;
-        span.log({
-          input: messages,
-          metadata: {
-            ...rest
+    let executionPromise = null;
+    const executeWrapped = () => {
+      if (!executionPromise) {
+        executionPromise = (async () => {
+          const span = startSpan(
+            mergeDicts3(
+              {
+                name: "Chat Completion",
+                spanAttributes: {
+                  type: SpanTypeAttribute3.LLM
+                }
+              },
+              parseChatCompletionParams(allParams)
+            )
+          );
+          const startTime = getCurrentUnixTimestamp();
+          if (params.stream) {
+            const { data: ret, response } = await completion(
+              // We could get rid of this type coercion if we could somehow enforce
+              // that `P extends ChatParams` BUT does not have the property
+              // `span_info`.
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              params,
+              options
+            ).withResponse();
+            logHeaders(response, span);
+            const wrapperStream = new WrapperStream(
+              span,
+              startTime,
+              ret.iterator()
+            );
+            ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
+            return { data: ret, response };
+          } else {
+            try {
+              const completionResponse = completion(
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                params,
+                options
+              );
+              const { data: ret, response } = await completionResponse.withResponse();
+              logHeaders(response, span);
+              const { messages, ...rest } = params;
+              span.log({
+                input: messages,
+                metadata: {
+                  ...rest
+                }
+              });
+              logCompletionResponse(startTime, ret, span);
+              return { data: ret, response };
+            } finally {
+              span.end();
+            }
           }
-        });
-        logCompletionResponse(startTime, ret, span);
-        return ret;
-      } finally {
-        span.end();
+        })();
       }
-    }
+      return executionPromise;
+    };
+    const dataPromise = executeWrapped().then((result) => result.data);
+    return new Proxy(dataPromise, {
+      get(target, prop, receiver) {
+        if (prop === "withResponse") {
+          return executeWrapped;
+        }
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+    });
   };
 }
 function parseBaseParams(allParams, inputField) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braintrust",
-  "version": "0.2.6",
+  "version": "0.3.6",
   "description": "SDK for integrating Braintrust",
   "repository": {
     "type": "git",