braintrust 0.2.1 → 0.2.3

package/dist/browser.js

@@ -2715,6 +2715,7 @@ async function loadPrompt({
   projectId,
   slug,
   version,
+  environment,
   id,
   defaults,
   noTrace = false,
@@ -2725,6 +2726,11 @@ async function loadPrompt({
   forceLogin,
   state: stateArg
 }) {
+  if (version && environment) {
+    throw new Error(
+      "Cannot specify both 'version' and 'environment' parameters. Please use only one (remove the other)."
+    );
+  }
   if (id) {
   } else if (isEmpty(projectName) && isEmpty(projectId)) {
     throw new Error("Must specify either projectName or projectId");
@@ -2742,7 +2748,10 @@ async function loadPrompt({
       forceLogin
     });
     if (id) {
-      response = await state.apiConn().get_json(`v1/prompt/${id}`, {});
+      response = await state.apiConn().get_json(`v1/prompt/${id}`, {
+        ...version && { version },
+        ...environment && { environment }
+      });
       if (response) {
         response = { objects: [response] };
       }
@@ -2751,10 +2760,14 @@ async function loadPrompt({
         project_name: projectName,
         project_id: projectId,
         slug,
-        version
+        version,
+        ...environment && { environment }
       });
     }
   } catch (e) {
+    if (environment || version) {
+      throw new Error(`Prompt not found with specified parameters: ${e}`);
+    }
     console.warn("Failed to load prompt, attempting to fall back to cache:", e);
     let prompt2;
     if (id) {
@@ -2997,6 +3010,110 @@ function traced(callback, args) {
     })();
   }
 }
+function isGeneratorFunction(fn) {
+  return Object.prototype.toString.call(fn) === "[object GeneratorFunction]";
+}
+function isAsyncGeneratorFunction(fn) {
+  return Object.prototype.toString.call(fn) === "[object AsyncGeneratorFunction]";
+}
+function wrapTracedSyncGenerator(fn, spanArgs, noTraceIO) {
+  const wrapper = function* (...fnArgs) {
+    const span = startSpan(spanArgs);
+    try {
+      if (!noTraceIO) {
+        span.log({ input: fnArgs });
+      }
+      const envValue = isomorph_default.getEnv("BRAINTRUST_MAX_GENERATOR_ITEMS");
+      const maxItems = envValue !== void 0 ? Number(envValue) : 1e3;
+      if (!noTraceIO && maxItems !== 0) {
+        let collected = [];
+        let truncated = false;
+        const gen = generatorWithCurrent(span, fn.apply(this, fnArgs));
+        try {
+          for (const value of gen) {
+            if (maxItems === -1 || !truncated && collected.length < maxItems) {
+              collected.push(value);
+            } else {
+              truncated = true;
+              collected = [];
+              console.warn(
+                `Generator output exceeded limit of ${maxItems} items, output not logged. Increase BRAINTRUST_MAX_GENERATOR_ITEMS or set to -1 to disable limit.`
+              );
+            }
+            yield value;
+          }
+          if (!truncated) {
+            span.log({ output: collected });
+          }
+        } catch (error) {
+          logError(span, error);
+          if (!truncated && collected.length > 0) {
+            span.log({ output: collected });
+          }
+          throw error;
+        }
+      } else {
+        const gen = generatorWithCurrent(span, fn.apply(this, fnArgs));
+        for (const value of gen) {
+          yield value;
+        }
+      }
+    } finally {
+      span.end();
+    }
+  };
+  Object.defineProperty(wrapper, "name", { value: fn.name });
+  return wrapper;
+}
+function wrapTracedAsyncGenerator(fn, spanArgs, noTraceIO) {
+  const wrapper = async function* (...fnArgs) {
+    const span = startSpan(spanArgs);
+    try {
+      if (!noTraceIO) {
+        span.log({ input: fnArgs });
+      }
+      const envValue = isomorph_default.getEnv("BRAINTRUST_MAX_GENERATOR_ITEMS");
+      const maxItems = envValue !== void 0 ? Number(envValue) : 1e3;
+      if (!noTraceIO && maxItems !== 0) {
+        let collected = [];
+        let truncated = false;
+        const gen = asyncGeneratorWithCurrent(span, fn.apply(this, fnArgs));
+        try {
+          for await (const value of gen) {
+            if (maxItems === -1 || !truncated && collected.length < maxItems) {
+              collected.push(value);
+            } else {
+              truncated = true;
+              collected = [];
+              console.warn(
+                `Generator output exceeded limit of ${maxItems} items, output not logged. Increase BRAINTRUST_MAX_GENERATOR_ITEMS or set to -1 to disable limit.`
+              );
+            }
+            yield value;
+          }
+          if (!truncated) {
+            span.log({ output: collected });
+          }
+        } catch (error) {
+          logError(span, error);
+          if (!truncated && collected.length > 0) {
+            span.log({ output: collected });
+          }
+          throw error;
+        }
+      } else {
+        const gen = asyncGeneratorWithCurrent(span, fn.apply(this, fnArgs));
+        for await (const value of gen) {
+          yield value;
+        }
+      }
+    } finally {
+      span.end();
+    }
+  };
+  Object.defineProperty(wrapper, "name", { value: fn.name });
+  return wrapper;
+}
 function wrapTraced(fn, args) {
   const spanArgs = {
     name: fn.name,
@@ -3005,7 +3122,14 @@ function wrapTraced(fn, args) {
   };
   const hasExplicitInput = args && args.event && "input" in args.event && args.event.input !== void 0;
   const hasExplicitOutput = args && args.event && args.event.output !== void 0;
-  if (_optionalChain([args, 'optionalAccess', _32 => _32.asyncFlush])) {
+  const noTraceIO = _optionalChain([args, 'optionalAccess', _32 => _32.noTraceIO]) || hasExplicitInput || hasExplicitOutput;
+  if (isGeneratorFunction(fn)) {
+    return wrapTracedSyncGenerator(fn, spanArgs, !!noTraceIO);
+  }
+  if (isAsyncGeneratorFunction(fn)) {
+    return wrapTracedAsyncGenerator(fn, spanArgs, !!noTraceIO);
+  }
+  if (_optionalChain([args, 'optionalAccess', _33 => _33.asyncFlush])) {
     return (...fnArgs) => traced((span) => {
       if (!hasExplicitInput) {
         span.log({ input: fnArgs });
@@ -3043,15 +3167,15 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _34 => _34.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function setFetch(fetch2) {
   _globalState.setFetch(fetch2);
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _34 => _34.state]), () => ( _globalState));
-  const parentStr = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _35 => _35.parent]), () => ( state.currentParent.getStore()));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _35 => _35.state]), () => ( _globalState));
+  const parentStr = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _36 => _36.parent]), () => ( state.currentParent.getStore()));
   const components = parentStr ? _core.SpanComponentsV3.fromStr(parentStr) : void 0;
   if (components) {
     const parentSpanIds = components.data.row_id ? {
@@ -3067,18 +3191,18 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(components.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _36 => _36.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _37 => _37.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       (_nullishCoalesce(components.data.propagated_event, () => ( void 0)))))
     });
     return {
       span,
       isSyncFlushLogger: components.data.object_type === _core.SpanObjectTypeV3.PROJECT_LOGS && // Since there's no parent logger here, we're free to choose the async flush
       // behavior, and therefore propagate along whatever we get from the arguments
-      _optionalChain([args, 'optionalAccess', _37 => _37.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _38 => _38.asyncFlush]) === false
     };
   } else {
     const parentObject = getSpanParentObject({
-      asyncFlush: _optionalChain([args, 'optionalAccess', _38 => _38.asyncFlush])
+      asyncFlush: _optionalChain([args, 'optionalAccess', _39 => _39.asyncFlush])
     });
     const span = parentObject.startSpan(args);
     return {
@@ -3090,6 +3214,52 @@ function startSpanAndIsLogger(args) {
 function withCurrent(span, callback, state = void 0) {
   return (_nullishCoalesce(state, () => ( _globalState))).currentSpan.run(span, () => callback(span));
 }
+function* generatorWithCurrent(span, gen, state = void 0) {
+  let nextValue;
+  while (true) {
+    const result = withCurrent(
+      span,
+      () => {
+        try {
+          return gen.next(nextValue);
+        } catch (e) {
+          return { value: void 0, done: true, error: e };
+        }
+      },
+      state
+    );
+    if ("error" in result) {
+      throw result.error;
+    }
+    if (result.done) {
+      return result.value;
+    }
+    nextValue = yield result.value;
+  }
+}
+async function* asyncGeneratorWithCurrent(span, gen, state = void 0) {
+  let nextValue;
+  while (true) {
+    const result = await withCurrent(
+      span,
+      async () => {
+        try {
+          return await gen.next(nextValue);
+        } catch (e) {
+          return { value: void 0, done: true, error: e };
+        }
+      },
+      state
+    );
+    if ("error" in result) {
+      throw result.error;
+    }
+    if (result.done) {
+      return result.value;
+    }
+    nextValue = yield result.value;
+  }
+}
 function withParent(parent, callback, state = void 0) {
   return (_nullishCoalesce(state, () => ( _globalState))).currentParent.run(parent, () => callback());
 }
@@ -3220,10 +3390,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _39 => _39.type]) === _typespecs.BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _40 => _40.type]) === _typespecs.BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _40 => _40.reference, 'optionalAccess', _41 => _41.type]) === _typespecs.BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _42 => _42.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _41 => _41.reference, 'optionalAccess', _42 => _42.type]) === _typespecs.BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _43 => _43.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -3361,7 +3531,7 @@ var ObjectFetcher = (_class9 = class {
           throw new Error("Too many BTQL iterations");
         }
       }
-      this._fetchedData = this.mutateRecord ? _optionalChain([data, 'optionalAccess', _43 => _43.map, 'call', _44 => _44(this.mutateRecord)]) : data;
+      this._fetchedData = this.mutateRecord ? _optionalChain([data, 'optionalAccess', _44 => _44.map, 'call', _45 => _45(this.mutateRecord)]) : data;
     }
     return this._fetchedData || [];
   }
@@ -3442,7 +3612,7 @@ var Experiment = (_class10 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _45 => _45.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _46 => _46.allowConcurrentWithSpans])) {
       throw new Error(
         "Cannot run toplevel `log` method while using spans. To log to the span, call `experiment.traced` and then log with `span.log`"
       );
@@ -3495,12 +3665,12 @@ var Experiment = (_class10 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _46 => _46.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _47 => _47.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _47 => _47.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _48 => _48.propagatedEvent])
       }),
       defaultRootType: _core.SpanTypeAttribute.EVAL
     });
@@ -3792,10 +3962,10 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...serializableInternalData,
       [_core.IS_MERGE_FIELD]: this.isMerge
     });
-    if (_optionalChain([partialRecord, 'access', _48 => _48.metrics, 'optionalAccess', _49 => _49.end])) {
-      this.loggedEndTime = _optionalChain([partialRecord, 'access', _50 => _50.metrics, 'optionalAccess', _51 => _51.end]);
+    if (_optionalChain([partialRecord, 'access', _49 => _49.metrics, 'optionalAccess', _50 => _50.end])) {
+      this.loggedEndTime = _optionalChain([partialRecord, 'access', _51 => _51.metrics, 'optionalAccess', _52 => _52.end]);
     }
-    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _52 => _52._spanParents, 'optionalAccess', _53 => _53.length])) {
+    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _53 => _53._spanParents, 'optionalAccess', _54 => _54.length])) {
       throw new Error("Tags can only be logged to the root span");
     }
     const computeRecord = async () => ({
@@ -3840,18 +4010,18 @@ var SpanImpl = (_class11 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _54 => _54.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _55 => _55.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _55 => _55.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _56 => _56.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _56 => _56.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _57 => _57.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -3865,12 +4035,12 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _57 => _57.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _58 => _58.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _58 => _58.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _59 => _59.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -3879,7 +4049,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _59 => _59.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _60 => _60.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -3922,8 +4092,8 @@ var SpanImpl = (_class11 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case _core.SpanObjectTypeV3.PROJECT_LOGS: {
-        const projectID = _optionalChain([args, 'optionalAccess', _60 => _60.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _61 => _61.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _61 => _61.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _62 => _62.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -3933,7 +4103,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
         }
       }
       case _core.SpanObjectTypeV3.EXPERIMENT: {
-        const expID = _optionalChain([args, 'optionalAccess', _62 => _62.experiment_id]) || _optionalChain([this, 'access', _63 => _63.parentObjectId, 'optionalAccess', _64 => _64.getSync, 'call', _65 => _65(), 'optionalAccess', _66 => _66.value]);
+        const expID = _optionalChain([args, 'optionalAccess', _63 => _63.experiment_id]) || _optionalChain([this, 'access', _64 => _64.parentObjectId, 'optionalAccess', _65 => _65.getSync, 'call', _66 => _66(), 'optionalAccess', _67 => _67.value]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -4359,13 +4529,13 @@ var Prompt = (_class13 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _67 => _67.getParsedPromptData, 'call', _68 => _68(), 'optionalAccess', _69 => _69.prompt]);
+    return _optionalChain([this, 'access', _68 => _68.getParsedPromptData, 'call', _69 => _69(), 'optionalAccess', _70 => _70.prompt]);
   }
   get version() {
     return this.metadata[_core.TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _70 => _70.getParsedPromptData, 'call', _71 => _71(), 'optionalAccess', _72 => _72.options]) || {};
+    return _optionalChain([this, 'access', _71 => _71.getParsedPromptData, 'call', _72 => _72(), 'optionalAccess', _73 => _73.options]) || {};
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -4516,7 +4686,7 @@ var Prompt = (_class13 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _73 => _73.tools, 'optionalAccess', _74 => _74.trim, 'call', _75 => _75()]) ? {
+        ..._optionalChain([prompt, 'access', _74 => _74.tools, 'optionalAccess', _75 => _75.trim, 'call', _76 => _76()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -4586,7 +4756,9 @@ var _exportsForTestingOnly = {
   clearTestBackgroundLogger,
   simulateLoginForTests,
   simulateLogoutForTests,
-  setInitialTestState
+  setInitialTestState,
+  isGeneratorFunction,
+  isAsyncGeneratorFunction
 };
 
 // src/browser-config.ts
@@ -4799,6 +4971,8 @@ function responsesProxy(openai) {
         return responsesCreateProxy(target.create.bind(target));
       } else if (name === "stream") {
         return responsesStreamProxy(target.stream.bind(target));
+      } else if (name === "parse") {
+        return responsesParseProxy(target.parse.bind(target));
       }
       return Reflect.get(target, name, receiver);
     }
@@ -4839,8 +5013,38 @@ function parseSpanFromResponseCreateParams(params) {
 }
 function parseEventFromResponseCreateResult(result) {
   return {
-    output: _optionalChain([result, 'optionalAccess', _76 => _76.output_text]) || "",
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _77 => _77.usage]))
+    output: _optionalChain([result, 'optionalAccess', _77 => _77.output_text]) || "",
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _78 => _78.usage]))
+  };
+}
+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,
+      metadata: {
+        ...filterFrom(params, ["input", "instructions"]),
+        provider: "openai"
+      }
+    },
+    startTime: getCurrentUnixTimestamp()
+  };
+  return {
+    span: startSpan(spanArgs),
+    start: spanArgs.startTime
+  };
+}
+function parseEventFromResponseParseResult(result) {
+  return {
+    output: _optionalChain([result, 'optionalAccess', _79 => _79.output_parsed]) || _optionalChain([result, 'optionalAccess', _80 => _80.output_text]) || "",
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _81 => _81.usage]))
   };
 }
 function traceResponseCreateStream(stream, timedSpan) {
@@ -4857,7 +5061,7 @@ function traceResponseCreateStream(stream, timedSpan) {
       return result;
     }
     const item = result.value;
-    if (!item || !_optionalChain([item, 'optionalAccess', _78 => _78.type]) || !_optionalChain([item, 'optionalAccess', _79 => _79.response])) {
+    if (!item || !_optionalChain([item, 'optionalAccess', _82 => _82.type]) || !_optionalChain([item, 'optionalAccess', _83 => _83.response])) {
       return result;
     }
     const event = parseLogFromItem(item);
@@ -4868,23 +5072,23 @@ function traceResponseCreateStream(stream, timedSpan) {
   };
 }
 function parseLogFromItem(item) {
-  if (!item || !_optionalChain([item, 'optionalAccess', _80 => _80.type]) || !_optionalChain([item, 'optionalAccess', _81 => _81.response])) {
+  if (!item || !_optionalChain([item, 'optionalAccess', _84 => _84.type]) || !_optionalChain([item, 'optionalAccess', _85 => _85.response])) {
     return {};
   }
   const response = item.response;
   switch (item.type) {
     case "response.completed":
       const texts = [];
-      for (const output of _optionalChain([response, 'optionalAccess', _82 => _82.output]) || []) {
-        for (const content of _optionalChain([output, 'optionalAccess', _83 => _83.content]) || []) {
-          if (_optionalChain([content, 'optionalAccess', _84 => _84.type]) === "output_text") {
+      for (const output of _optionalChain([response, 'optionalAccess', _86 => _86.output]) || []) {
+        for (const content of _optionalChain([output, 'optionalAccess', _87 => _87.content]) || []) {
+          if (_optionalChain([content, 'optionalAccess', _88 => _88.type]) === "output_text") {
             texts.push(content.text);
           }
         }
       }
       return {
         output: texts.join(""),
-        metrics: parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _85 => _85.usage]))
+        metrics: parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _89 => _89.usage]))
       };
     default:
       return {};
@@ -4917,6 +5121,16 @@ function responsesStreamProxy(target) {
     }
   });
 }
+function responsesParseProxy(target) {
+  const hooks = {
+    name: "openai.responses.parse",
+    toSpanFunc: parseSpanFromResponseParseParams,
+    resultToEventFunc: parseEventFromResponseParseResult,
+    traceStreamFunc: traceResponseCreateStream
+    // Reuse the same stream tracing
+  };
+  return proxyCreate(target, hooks);
+}
 var TOKEN_NAME_MAP = {
   input_tokens: "prompt_tokens",
   output_tokens: "completion_tokens",
@@ -5058,8 +5272,8 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(openai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(openai.moderations, wrapModerations);
   let betaProxy;
-  if (_optionalChain([openai, 'access', _86 => _86.beta, 'optionalAccess', _87 => _87.chat, 'optionalAccess', _88 => _88.completions, 'optionalAccess', _89 => _89.stream])) {
-    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _90 => _90.beta, 'optionalAccess', _91 => _91.chat, 'access', _92 => _92.completions]), {
+  if (_optionalChain([openai, 'access', _90 => _90.beta, 'optionalAccess', _91 => _91.chat, 'optionalAccess', _92 => _92.completions, 'optionalAccess', _93 => _93.stream])) {
+    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _94 => _94.beta, 'optionalAccess', _95 => _95.chat, 'access', _96 => _96.completions]), {
       get(target, name, receiver) {
         const baseVal = Reflect.get(target, name, receiver);
         if (name === "parse") {
@@ -5107,7 +5321,7 @@ function wrapOpenAIv4(openai) {
   });
 }
 function logCompletionResponse(startTime, response, span) {
-  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _93 => _93.usage]));
+  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _97 => _97.usage]));
   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   span.log({
     output: response.choices,
@@ -5309,7 +5523,7 @@ function parseChatCompletionParams(params) {
 function processEmbeddingResponse(result, span) {
   span.log({
     output: { embedding_length: result.data[0].embedding.length },
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _94 => _94.usage]))
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _98 => _98.usage]))
   });
 }
 function processModerationResponse(result, span) {
@@ -5339,10 +5553,10 @@ function postprocessStreamingResults(allResults) {
     if (result.usage) {
       metrics = {
         ...metrics,
-        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _95 => _95.usage]))
+        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _99 => _99.usage]))
       };
     }
-    const delta = _optionalChain([result, 'access', _96 => _96.choices, 'optionalAccess', _97 => _97[0], 'optionalAccess', _98 => _98.delta]);
+    const delta = _optionalChain([result, 'access', _100 => _100.choices, 'optionalAccess', _101 => _101[0], 'optionalAccess', _102 => _102.delta]);
     if (!delta) {
       continue;
     }