braintrust 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -6131,6 +6131,7 @@ async function loadPrompt({
   projectId,
   slug,
   version,
+  environment,
   id,
   defaults,
   noTrace = false,
@@ -6141,6 +6142,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");
@@ -6158,7 +6164,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] };
       }
@@ -6167,10 +6176,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) {
@@ -6413,6 +6426,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 (error2) {
+          logError(span, error2);
+          if (!truncated && collected.length > 0) {
+            span.log({ output: collected });
+          }
+          throw error2;
+        }
+      } 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 (error2) {
+          logError(span, error2);
+          if (!truncated && collected.length > 0) {
+            span.log({ output: collected });
+          }
+          throw error2;
+        }
+      } 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,
@@ -6421,6 +6538,13 @@ 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;
+  const noTraceIO = args?.noTraceIO || hasExplicitInput || hasExplicitOutput;
+  if (isGeneratorFunction(fn)) {
+    return wrapTracedSyncGenerator(fn, spanArgs, !!noTraceIO);
+  }
+  if (isAsyncGeneratorFunction(fn)) {
+    return wrapTracedAsyncGenerator(fn, spanArgs, !!noTraceIO);
+  }
   if (args?.asyncFlush) {
     return (...fnArgs) => traced((span) => {
       if (!hasExplicitInput) {
@@ -6506,6 +6630,52 @@ function startSpanAndIsLogger(args) {
 function withCurrent(span, callback, state = void 0) {
   return (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 (state ?? _globalState).currentParent.run(parent, () => callback());
 }
@@ -8002,7 +8172,9 @@ var _exportsForTestingOnly = {
   clearTestBackgroundLogger,
   simulateLoginForTests,
   simulateLogoutForTests,
-  setInitialTestState
+  setInitialTestState,
+  isGeneratorFunction,
+  isAsyncGeneratorFunction
 };
 
 // src/node.ts
@@ -9799,7 +9971,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
     const { data, baseExperiment: defaultBaseExperiment } = callEvaluatorData(
       evaluator.data
     );
-    const experiment = options.parent ? null : initExperiment2(evaluator.state, {
+    const experiment = options.parent || options.noSendLogs ? null : initExperiment2(evaluator.state, {
       ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: name },
       experiment: evaluator.experimentName,
       description: evaluator.description,
@@ -10611,6 +10783,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);
     }
@@ -10655,6 +10829,36 @@ function parseEventFromResponseCreateResult(result) {
     metrics: parseMetricsFromUsage(result?.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: result?.output_parsed || result?.output_text || "",
+    metrics: parseMetricsFromUsage(result?.usage)
+  };
+}
 function traceResponseCreateStream(stream, timedSpan) {
   const span = timedSpan.span;
   let ttft = -1;
@@ -10729,6 +10933,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",
@@ -11698,14 +11912,26 @@ function postProcessPrompt(prompt) {
   });
 }
 function postProcessOutput(text, toolCalls, finishReason) {
-  return {
-    index: 0,
-    message: {
-      role: "assistant",
-      content: text ?? (toolCalls ? toolCalls.length === 1 && toolCalls[0].toolName === "json" ? toolCalls[0].args : JSON.stringify(toolCalls) : "")
-    },
-    finish_reason: finishReason
-  };
+  return [
+    {
+      index: 0,
+      message: {
+        role: "assistant",
+        content: text ?? "",
+        ...toolCalls && toolCalls.length > 0 ? {
+          tool_calls: toolCalls.map((toolCall) => ({
+            id: toolCall.toolCallId,
+            function: {
+              name: toolCall.toolName,
+              arguments: toolCall.args
+            },
+            type: "function"
+          }))
+        } : {}
+      },
+      finish_reason: finishReason
+    }
+  ];
 }
 
 // src/wrappers/anthropic.ts
@@ -11972,7 +12198,13 @@ try {
   );
   OTEL_AVAILABLE = false;
 }
-var FILTER_PREFIXES = ["gen_ai.", "braintrust.", "llm.", "ai."];
+var FILTER_PREFIXES = [
+  "gen_ai.",
+  "braintrust.",
+  "llm.",
+  "ai.",
+  "traceloop."
+];
 var AISpanProcessor = class _AISpanProcessor {
   static checkOtelAvailable() {
     if (!OTEL_AVAILABLE) {
@@ -12029,7 +12261,7 @@ var AISpanProcessor = class _AISpanProcessor {
    * Keep spans if:
    * 1. It's a root span (no parent)
    * 2. Custom filter returns true/false (if provided)
-   * 3. Span name starts with 'gen_ai.', 'braintrust.', 'llm.', or 'ai.'
+   * 3. Span name starts with 'gen_ai.', 'braintrust.', 'llm.', 'ai.', or 'traceloop.'
    * 4. Any attribute name starts with those prefixes
    */
   shouldKeepFilteredSpan(span) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braintrust",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "SDK for integrating Braintrust",
   "repository": {
     "type": "git",
@@ -92,7 +92,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "^1.1.3",
-    "@braintrust/core": "0.0.91",
+    "@braintrust/core": "0.0.93",
     "@next/env": "^14.2.3",
     "@vercel/functions": "^1.0.2",
     "argparse": "^2.0.1",