braintrust 0.2.5 → 0.3.6

package/dist/browser.js

@@ -166,7 +166,7 @@ var ResponseFormatJsonSchema = _zod.z.object({
   schema: _zod.z.union([_zod.z.object({}).partial().passthrough(), _zod.z.string()]).optional(),
   strict: _zod.z.union([_zod.z.boolean(), _zod.z.null()]).optional()
 });
-var ResponseFormat = _zod.z.union([
+var ResponseFormatNullish = _zod.z.union([
   _zod.z.object({ type: _zod.z.literal("json_object") }),
   _zod.z.object({
     type: _zod.z.literal("json_schema"),
@@ -182,7 +182,7 @@ var AnyModelParams = _zod.z.object({
   max_completion_tokens: _zod.z.number().optional(),
   frequency_penalty: _zod.z.number().optional(),
   presence_penalty: _zod.z.number().optional(),
-  response_format: ResponseFormat.optional(),
+  response_format: ResponseFormatNullish.optional(),
   tool_choice: _zod.z.union([
     _zod.z.literal("auto"),
     _zod.z.literal("none"),
@@ -220,6 +220,23 @@ var ApiKey = _zod.z.object({
   user_family_name: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
   org_id: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional()
 });
+var AsyncScoringState = _zod.z.union([
+  _zod.z.object({
+    status: _zod.z.literal("enabled"),
+    token: _zod.z.string(),
+    function_ids: _zod.z.array(_zod.z.unknown()).min(1),
+    skip_logging: _zod.z.union([_zod.z.boolean(), _zod.z.null()]).optional()
+  }),
+  _zod.z.object({ status: _zod.z.literal("disabled") }),
+  _zod.z.null(),
+  _zod.z.null()
+]);
+var AsyncScoringControl = _zod.z.union([
+  _zod.z.object({ kind: _zod.z.literal("score_update"), token: _zod.z.string() }),
+  _zod.z.object({ kind: _zod.z.literal("state_override"), state: AsyncScoringState }),
+  _zod.z.object({ kind: _zod.z.literal("state_force_reselect") }),
+  _zod.z.object({ kind: _zod.z.literal("state_enabled_force_rescore") })
+]);
 var BraintrustAttachmentReference = _zod.z.object({
   type: _zod.z.literal("braintrust_attachment"),
   filename: _zod.z.string().min(1),
@@ -422,7 +439,7 @@ var Dataset = _zod.z.object({
   user_id: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
   metadata: _zod.z.union([_zod.z.object({}).partial().passthrough(), _zod.z.null()]).optional()
 });
-var ObjectReference = _zod.z.union([
+var ObjectReferenceNullish = _zod.z.union([
   _zod.z.object({
     object_type: _zod.z.enum([
       "project_logs",
@@ -456,7 +473,7 @@ var DatasetEvent = _zod.z.object({
   span_id: _zod.z.string(),
   root_span_id: _zod.z.string(),
   is_root: _zod.z.union([_zod.z.boolean(), _zod.z.null()]).optional(),
-  origin: ObjectReference.optional()
+  origin: ObjectReferenceNullish.optional()
 });
 var EnvVar = _zod.z.object({
   id: _zod.z.string().uuid(),
@@ -536,7 +553,7 @@ var ExperimentEvent = _zod.z.object({
   root_span_id: _zod.z.string(),
   span_attributes: SpanAttributes.optional(),
   is_root: _zod.z.union([_zod.z.boolean(), _zod.z.null()]).optional(),
-  origin: ObjectReference.optional()
+  origin: ObjectReferenceNullish.optional()
 });
 var ExtendedSavedFunctionId = _zod.z.union([
   _zod.z.object({ type: _zod.z.literal("function"), id: _zod.z.string() }),
@@ -565,7 +582,7 @@ var ModelParams = _zod.z.union([
     max_completion_tokens: _zod.z.number(),
     frequency_penalty: _zod.z.number(),
     presence_penalty: _zod.z.number(),
-    response_format: ResponseFormat,
+    response_format: ResponseFormatNullish,
     tool_choice: _zod.z.union([
       _zod.z.literal("auto"),
       _zod.z.literal("none"),
@@ -888,6 +905,20 @@ var MessageRole = _zod.z.enum([
   "model",
   "developer"
 ]);
+var ObjectReference = _zod.z.object({
+  object_type: _zod.z.enum([
+    "project_logs",
+    "experiment",
+    "dataset",
+    "prompt",
+    "function",
+    "prompt_session"
+  ]),
+  object_id: _zod.z.string().uuid(),
+  id: _zod.z.string(),
+  _xact_id: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
+  created: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional()
+});
 var OnlineScoreConfig = _zod.z.union([
   _zod.z.object({
     sampling_rate: _zod.z.number().gte(0).lte(1),
@@ -1020,7 +1051,7 @@ var ProjectLogsEvent = _zod.z.object({
   root_span_id: _zod.z.string(),
   is_root: _zod.z.union([_zod.z.boolean(), _zod.z.null()]).optional(),
   span_attributes: SpanAttributes.optional(),
-  origin: ObjectReference.optional()
+  origin: ObjectReferenceNullish.optional()
 });
 var ProjectScoreType = _zod.z.enum([
   "slider",
@@ -1102,6 +1133,14 @@ var PromptSessionEvent = _zod.z.object({
   completion: _zod.z.unknown().optional(),
   tags: _zod.z.union([_zod.z.array(_zod.z.string()), _zod.z.null()]).optional()
 });
+var ResponseFormat = _zod.z.union([
+  _zod.z.object({ type: _zod.z.literal("json_object") }),
+  _zod.z.object({
+    type: _zod.z.literal("json_schema"),
+    json_schema: ResponseFormatJsonSchema
+  }),
+  _zod.z.object({ type: _zod.z.literal("text") })
+]);
 var Role = _zod.z.object({
   id: _zod.z.string().uuid(),
   org_id: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
@@ -1161,10 +1200,9 @@ var ServiceToken = _zod.z.object({
   created: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
   name: _zod.z.string(),
   preview_name: _zod.z.string(),
-  user_id: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
-  user_email: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
-  user_given_name: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
-  user_family_name: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
+  service_account_id: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
+  service_account_email: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
+  service_account_name: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional(),
   org_id: _zod.z.union([_zod.z.string(), _zod.z.null()]).optional()
 });
 var SpanIFrame = _zod.z.object({
@@ -1185,7 +1223,7 @@ var SSEConsoleEventData = _zod.z.object({
 var SSEProgressEventData = _zod.z.object({
   id: _zod.z.string(),
   object_type: FunctionObjectType,
-  origin: ObjectReference.and(_zod.z.unknown()).optional(),
+  origin: ObjectReferenceNullish.and(_zod.z.unknown()).optional(),
   format: FunctionFormat,
   output_type: FunctionOutputType,
   name: _zod.z.string(),
@@ -6375,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"
       }
     },
@@ -6399,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"
       }
     },
@@ -6429,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;
@@ -6448,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);
@@ -6459,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 {};
   }
@@ -6659,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") {
@@ -6708,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,
@@ -6803,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) {
@@ -6910,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) {
@@ -6940,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;
     }