braintrust 0.0.183 → 0.0.185

package/dist/index.js

@@ -65,6 +65,8 @@ __export(src_exports, {
   currentLogger: () => currentLogger,
   currentSpan: () => currentSpan,
   default: () => src_default,
+  defaultErrorScoreHandler: () => defaultErrorScoreHandler,
+  deserializePlainStringAsJSON: () => deserializePlainStringAsJSON,
   devNullWritableStream: () => devNullWritableStream,
   flush: () => flush,
   getSpanParentObject: () => getSpanParentObject,
@@ -84,6 +86,7 @@ __export(src_exports, {
   permalink: () => permalink,
   projects: () => projects,
   renderMessage: () => renderMessage,
+  renderPromptParams: () => renderPromptParams,
   reportFailures: () => reportFailures,
   runEvaluator: () => runEvaluator,
   setFetch: () => setFetch,
@@ -310,7 +313,7 @@ async function repoInfo() {
 // src/stackutil.ts
 function getStackTrace() {
   const trace = new Error().stack;
-  if (trace === void 0) {
+  if (typeof trace !== "string") {
     return [];
   }
   const traceLines = trace.split("\n");
@@ -354,54 +357,7 @@ function getCallerLocation() {
 var import_uuid = require("uuid");
 var import_core = require("@braintrust/core");
 var import_typespecs2 = require("@braintrust/core/typespecs");
-
-// src/util.ts
-var GLOBAL_PROJECT = "Global";
-function runCatchFinally(f, catchF, finallyF) {
-  let runSyncCleanup = true;
-  try {
-    const ret = f();
-    if (ret instanceof Promise) {
-      runSyncCleanup = false;
-      return ret.catch(catchF).finally(finallyF);
-    } else {
-      return ret;
-    }
-  } catch (e) {
-    return catchF(e);
-  } finally {
-    if (runSyncCleanup) {
-      finallyF();
-    }
-  }
-}
-function getCurrentUnixTimestamp() {
-  return (/* @__PURE__ */ new Date()).getTime() / 1e3;
-}
-function isEmpty(a) {
-  return a === void 0 || a === null;
-}
-var LazyValue = class {
-  callable;
-  value = {
-    hasComputed: false
-  };
-  constructor(callable) {
-    this.callable = callable;
-  }
-  get() {
-    if (this.value.hasComputed) {
-      return this.value.val;
-    }
-    this.value = { hasComputed: true, val: this.callable() };
-    return this.value.val;
-  }
-  get hasComputed() {
-    return this.value.hasComputed;
-  }
-};
-
-// src/logger.ts
+var import_functions = require("@vercel/functions");
 var import_mustache = __toESM(require("mustache"));
 var import_zod2 = require("zod");
 
@@ -659,61 +615,6 @@ function devNullWritableStream() {
   });
 }
 
-// src/logger.ts
-var import_functions = require("@vercel/functions");
-
-// src/prompt-cache/prompt-cache.ts
-function createCacheKey(key) {
-  const prefix = key.projectId ?? key.projectName;
-  if (!prefix) {
-    throw new Error("Either projectId or projectName must be provided");
-  }
-  return `${prefix}:${key.slug}:${key.version}`;
-}
-var PromptCache = class {
-  memoryCache;
-  diskCache;
-  constructor(options) {
-    this.memoryCache = options.memoryCache;
-    this.diskCache = options.diskCache;
-  }
-  /**
-   * Retrieves a prompt from the cache.
-   * First checks the in-memory LRU cache, then falls back to checking the disk cache if available.
-   */
-  async get(key) {
-    const cacheKey = createCacheKey(key);
-    const memoryPrompt = this.memoryCache.get(cacheKey);
-    if (memoryPrompt !== void 0) {
-      return memoryPrompt;
-    }
-    if (this.diskCache) {
-      const diskPrompt = await this.diskCache.get(cacheKey);
-      if (!diskPrompt) {
-        return void 0;
-      }
-      this.memoryCache.set(cacheKey, diskPrompt);
-      return diskPrompt;
-    }
-    return void 0;
-  }
-  /**
-   * Stores a prompt in the cache.
-   * Writes to the in-memory cache and the disk cache if available.
-   *
-   * @param key - The key to store the value under.
-   * @param value - The value to store in the cache.
-   * @throws If there is an error writing to the disk cache.
-   */
-  async set(key, value) {
-    const cacheKey = createCacheKey(key);
-    this.memoryCache.set(cacheKey, value);
-    if (this.diskCache) {
-      await this.diskCache.set(cacheKey, value);
-    }
-  }
-};
-
 // src/prompt-cache/disk-cache.ts
 function canUseDiskCache() {
   return !!(isomorph_default.gunzip && isomorph_default.gzip && isomorph_default.stat && isomorph_default.readFile && isomorph_default.writeFile && isomorph_default.utimes && isomorph_default.readdir && isomorph_default.mkdir && isomorph_default.unlink && isomorph_default.homedir);
@@ -851,12 +752,129 @@ var LRUCache = class {
   }
 };
 
+// src/prompt-cache/prompt-cache.ts
+function createCacheKey(key) {
+  const prefix = key.projectId ?? key.projectName;
+  if (!prefix) {
+    throw new Error("Either projectId or projectName must be provided");
+  }
+  return `${prefix}:${key.slug}:${key.version}`;
+}
+var PromptCache = class {
+  memoryCache;
+  diskCache;
+  constructor(options) {
+    this.memoryCache = options.memoryCache;
+    this.diskCache = options.diskCache;
+  }
+  /**
+   * Retrieves a prompt from the cache.
+   * First checks the in-memory LRU cache, then falls back to checking the disk cache if available.
+   */
+  async get(key) {
+    const cacheKey = createCacheKey(key);
+    const memoryPrompt = this.memoryCache.get(cacheKey);
+    if (memoryPrompt !== void 0) {
+      return memoryPrompt;
+    }
+    if (this.diskCache) {
+      const diskPrompt = await this.diskCache.get(cacheKey);
+      if (!diskPrompt) {
+        return void 0;
+      }
+      this.memoryCache.set(cacheKey, diskPrompt);
+      return diskPrompt;
+    }
+    return void 0;
+  }
+  /**
+   * Stores a prompt in the cache.
+   * Writes to the in-memory cache and the disk cache if available.
+   *
+   * @param key - The key to store the value under.
+   * @param value - The value to store in the cache.
+   * @throws If there is an error writing to the disk cache.
+   */
+  async set(key, value) {
+    const cacheKey = createCacheKey(key);
+    this.memoryCache.set(cacheKey, value);
+    if (this.diskCache) {
+      await this.diskCache.set(cacheKey, value);
+    }
+  }
+};
+
+// src/util.ts
+var GLOBAL_PROJECT = "Global";
+function runCatchFinally(f, catchF, finallyF) {
+  let runSyncCleanup = true;
+  try {
+    const ret = f();
+    if (ret instanceof Promise) {
+      runSyncCleanup = false;
+      return ret.catch(catchF).finally(finallyF);
+    } else {
+      return ret;
+    }
+  } catch (e) {
+    return catchF(e);
+  } finally {
+    if (runSyncCleanup) {
+      finallyF();
+    }
+  }
+}
+function getCurrentUnixTimestamp() {
+  return (/* @__PURE__ */ new Date()).getTime() / 1e3;
+}
+function isEmpty(a) {
+  return a === void 0 || a === null;
+}
+var LazyValue = class {
+  callable;
+  value = {
+    computedState: "uninitialized"
+  };
+  constructor(callable) {
+    this.callable = callable;
+  }
+  get() {
+    if (this.value.computedState !== "uninitialized") {
+      return this.value.val;
+    }
+    this.value = {
+      computedState: "in_progress",
+      val: this.callable().then((x) => {
+        this.value.computedState = "succeeded";
+        return x;
+      })
+    };
+    return this.value.val;
+  }
+  // If this is true, the caller should be able to obtain the LazyValue without
+  // it throwing.
+  get hasSucceeded() {
+    return this.value.computedState === "succeeded";
+  }
+};
+function addAzureBlobHeaders(headers, url) {
+  if (url.includes("blob.core.windows.net")) {
+    headers["x-ms-blob-type"] = "BlockBlob";
+  }
+}
+
 // src/logger.ts
 var NoopSpan = class {
   id;
+  spanId;
+  rootSpanId;
+  spanParents;
   kind = "span";
   constructor() {
     this.id = "";
+    this.spanId = "";
+    this.rootSpanId = "";
+    this.spanParents = [];
   }
   log(_) {
   }
@@ -1331,6 +1349,7 @@ var Attachment = class {
         }
         throw error2;
       }
+      addAzureBlobHeaders(headers, signedUrl);
       let objectStoreResponse;
       try {
         objectStoreResponse = await checkResponse(
@@ -1872,7 +1891,7 @@ var Logger = class {
   async export() {
     return new import_core.SpanComponentsV3({
       object_type: this.parentObjectType(),
-      ...this.computeMetadataArgs && !this.lazyId.hasComputed ? { compute_object_metadata_args: this.computeMetadataArgs } : { object_id: await this.lazyId.get() }
+      ...this.computeMetadataArgs && !this.lazyId.hasSucceeded ? { compute_object_metadata_args: this.computeMetadataArgs } : { object_id: await this.lazyId.get() }
     }).toStr();
   }
   /*
@@ -2404,6 +2423,7 @@ function init(projectOrOptions, optionalOptions) {
         experiment: {
           id: response.experiment.id,
           name: response.experiment.name,
+          created: response.experiment.created,
           fullInfo: response.experiment
         }
       };
@@ -2470,7 +2490,8 @@ function initDataset(projectOrOptions, optionalOptions) {
     projectId,
     metadata,
     useOutput: legacy,
-    state: stateArg
+    state: stateArg,
+    _internal_btql
   } = options;
   const state = stateArg ?? _globalState;
   const lazyMetadata = new LazyValue(
@@ -2505,7 +2526,13 @@ function initDataset(projectOrOptions, optionalOptions) {
       };
     }
   );
-  return new Dataset(stateArg ?? _globalState, lazyMetadata, version, legacy);
+  return new Dataset(
+    stateArg ?? _globalState,
+    lazyMetadata,
+    version,
+    legacy,
+    _internal_btql
+  );
 }
 function withDataset(project, callback, options = {}) {
   console.warn(
@@ -3082,10 +3109,11 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
   return event;
 }
 var ObjectFetcher = class {
-  constructor(objectType, pinnedVersion, mutateRecord) {
+  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
+    this._internal_btql = _internal_btql;
   }
   _fetchedData = void 0;
   get id() {
@@ -3106,14 +3134,46 @@ var ObjectFetcher = class {
   async fetchedData() {
     if (this._fetchedData === void 0) {
       const state = await this.getState();
-      const resp = await state.apiConn().get(
-        `v1/${this.objectType}/${await this.id}/fetch`,
-        {
-          version: this.pinnedVersion
-        },
-        { headers: { "Accept-Encoding": "gzip" } }
-      );
-      const data = (await resp.json()).events;
+      let data = null;
+      if (this._internal_btql) {
+        const resp = await state.apiConn().post(
+          `btql`,
+          {
+            query: {
+              ...this._internal_btql,
+              select: [
+                {
+                  op: "star"
+                }
+              ],
+              from: {
+                op: "function",
+                name: {
+                  op: "ident",
+                  name: [this.objectType]
+                },
+                args: [
+                  {
+                    op: "literal",
+                    value: await this.id
+                  }
+                ]
+              }
+            }
+          },
+          { headers: { "Accept-Encoding": "gzip" } }
+        );
+        data = (await resp.json()).data;
+      } else {
+        const resp = await state.apiConn().get(
+          `v1/${this.objectType}/${await this.id}/fetch`,
+          {
+            version: this.pinnedVersion
+          },
+          { headers: { "Accept-Encoding": "gzip" } }
+        );
+        data = (await resp.json()).events;
+      }
       this._fetchedData = this.mutateRecord ? data?.map(this.mutateRecord) : data;
     }
     return this._fetchedData || [];
@@ -3445,9 +3505,9 @@ var SpanImpl = class _SpanImpl {
   parentObjectId;
   parentComputeObjectMetadataArgs;
   _id;
-  spanId;
-  rootSpanId;
-  spanParents;
+  _spanId;
+  _rootSpanId;
+  _spanParents;
   kind = "span";
   constructor(args) {
     this.state = args.state;
@@ -3492,13 +3552,13 @@ var SpanImpl = class _SpanImpl {
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
     this._id = eventId ?? (0, import_uuid.v4)();
-    this.spanId = (0, import_uuid.v4)();
+    this._spanId = (0, import_uuid.v4)();
     if (args.parentSpanIds) {
-      this.rootSpanId = args.parentSpanIds.rootSpanId;
-      this.spanParents = [args.parentSpanIds.spanId];
+      this._rootSpanId = args.parentSpanIds.rootSpanId;
+      this._spanParents = [args.parentSpanIds.spanId];
     } else {
-      this.rootSpanId = this.spanId;
-      this.spanParents = void 0;
+      this._rootSpanId = this._spanId;
+      this._spanParents = void 0;
     }
     this.isMerge = false;
     this.logInternal({ event, internalData });
@@ -3507,6 +3567,15 @@ var SpanImpl = class _SpanImpl {
   get id() {
     return this._id;
   }
+  get spanId() {
+    return this._spanId;
+  }
+  get rootSpanId() {
+    return this._rootSpanId;
+  }
+  get spanParents() {
+    return this._spanParents ?? [];
+  }
   setAttributes(args) {
     this.logInternal({ internalData: { span_attributes: args } });
   }
@@ -3523,16 +3592,16 @@ var SpanImpl = class _SpanImpl {
     });
     const partialRecord = deepCopyEvent({
       id: this.id,
-      span_id: this.spanId,
-      root_span_id: this.rootSpanId,
-      span_parents: this.spanParents,
+      span_id: this._spanId,
+      root_span_id: this._rootSpanId,
+      span_parents: this._spanParents,
       ...serializableInternalData,
       [import_core.IS_MERGE_FIELD]: this.isMerge
     });
     if (partialRecord.metrics?.end) {
       this.loggedEndTime = partialRecord.metrics?.end;
     }
-    if ((partialRecord.tags ?? []).length > 0 && this.spanParents?.length) {
+    if ((partialRecord.tags ?? []).length > 0 && this._spanParents?.length) {
       throw new Error("Tags can only be logged to the root span");
     }
     const computeRecord = async () => ({
@@ -3577,7 +3646,7 @@ var SpanImpl = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = args?.parent ? void 0 : { spanId: this.spanId, rootSpanId: this.rootSpanId };
+    const parentSpanIds = args?.parent ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this.state,
       ...args,
@@ -3607,10 +3676,10 @@ var SpanImpl = class _SpanImpl {
   async export() {
     return new import_core.SpanComponentsV3({
       object_type: this.parentObjectType,
-      ...this.parentComputeObjectMetadataArgs && !this.parentObjectId.hasComputed ? { compute_object_metadata_args: this.parentComputeObjectMetadataArgs } : { object_id: await this.parentObjectId.get() },
+      ...this.parentComputeObjectMetadataArgs && !this.parentObjectId.hasSucceeded ? { compute_object_metadata_args: this.parentComputeObjectMetadataArgs } : { object_id: await this.parentObjectId.get() },
       row_id: this.id,
-      span_id: this.spanId,
-      root_span_id: this.rootSpanId,
+      span_id: this._spanId,
+      root_span_id: this._rootSpanId,
       propagated_event: this.propagatedEvent
     }).toStr();
   }
@@ -3657,7 +3726,7 @@ function splitLoggingData({
   return [serializableInternalData, lazyInternalData];
 }
 var Dataset = class extends ObjectFetcher {
-  constructor(state, lazyMetadata, pinnedVersion, legacy) {
+  constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql) {
     const isLegacyDataset = legacy ?? import_core.DEFAULT_IS_LEGACY_DATASET;
     if (isLegacyDataset) {
       console.warn(
@@ -3667,13 +3736,15 @@ var Dataset = class extends ObjectFetcher {
     super(
       "dataset",
       pinnedVersion,
-      (r) => (0, import_core.ensureDatasetRecord)(enrichAttachments(r), isLegacyDataset)
+      (r) => (0, import_core.ensureDatasetRecord)(enrichAttachments(r), isLegacyDataset),
+      _internal_btql
     );
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
   lazyMetadata;
   __braintrust_dataset_marker = true;
+  newRecords = 0;
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).dataset.id;
@@ -3781,6 +3852,7 @@ var Dataset = class extends ObjectFetcher {
       })
     );
     this.state.bgLogger().log([args]);
+    this.newRecords++;
     return rowId;
   }
   /**
@@ -3843,15 +3915,23 @@ var Dataset = class extends ObjectFetcher {
     const datasetUrl = `${projectUrl}/datasets/${encodeURIComponent(
       await this.name
     )}`;
-    let dataSummary = void 0;
+    let dataSummary;
     if (summarizeData) {
-      dataSummary = await state.apiConn().get_json(
-        "dataset-summary",
-        {
-          dataset_id: await this.id
-        },
-        3
+      const rawDataSummary = import_zod2.z.object({
+        total_records: import_zod2.z.number()
+      }).parse(
+        await state.apiConn().get_json(
+          "dataset-summary",
+          {
+            dataset_id: await this.id
+          },
+          3
+        )
       );
+      dataSummary = {
+        newRecords: this.newRecords,
+        totalRecords: rawDataSummary.total_records
+      };
     }
     return {
       projectName: (await this.project).name,
@@ -3919,6 +3999,65 @@ function renderMessage(render, message) {
     } : {}
   };
 }
+function deserializePlainStringAsJSON(s) {
+  if (s.trim() === "") {
+    return { value: null, error: void 0 };
+  }
+  try {
+    return { value: JSON.parse(s), error: void 0 };
+  } catch (e) {
+    return { value: s, error: e };
+  }
+}
+function renderTemplatedObject(obj, args) {
+  if (typeof obj === "string") {
+    return import_mustache.default.render(obj, args, void 0, {
+      escape: (value) => {
+        if (typeof value === "string") {
+          return value;
+        } else {
+          return JSON.stringify(value);
+        }
+      }
+    });
+  } else if ((0, import_core.isArray)(obj)) {
+    return obj.map((item) => renderTemplatedObject(item, args));
+  } else if ((0, import_core.isObject)(obj)) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        renderTemplatedObject(value, args)
+      ])
+    );
+  }
+  return obj;
+}
+function renderPromptParams(params, args) {
+  const schemaParsed = import_zod2.z.object({
+    response_format: import_zod2.z.object({
+      type: import_zod2.z.literal("json_schema"),
+      json_schema: import_typespecs2.responseFormatJsonSchemaSchema.omit({ schema: true }).extend({
+        schema: import_zod2.z.unknown()
+      })
+    })
+  }).safeParse(params);
+  if (schemaParsed.success) {
+    const rawSchema = schemaParsed.data.response_format.json_schema.schema;
+    const templatedSchema = renderTemplatedObject(rawSchema, args);
+    const parsedSchema = typeof templatedSchema === "string" ? deserializePlainStringAsJSON(templatedSchema).value : templatedSchema;
+    return {
+      ...params,
+      response_format: {
+        ...schemaParsed.data.response_format,
+        json_schema: {
+          ...schemaParsed.data.response_format.json_schema,
+          schema: parsedSchema
+        }
+      }
+    };
+  }
+  return params;
+}
 var Prompt = class {
   constructor(metadata, defaults, noTrace) {
     this.metadata = metadata;
@@ -4015,7 +4154,7 @@ var Prompt = class {
         ...options.messages ?? []
       ];
       return {
-        ...params,
+        ...renderPromptParams(params, variables),
         ...spanInfo,
         messages,
         ...prompt.tools?.trim() ? {
@@ -4034,7 +4173,7 @@ var Prompt = class {
         );
       }
       return {
-        ...params,
+        ...renderPromptParams(params, variables),
         ...spanInfo,
         prompt: import_mustache.default.render(prompt.content, variables)
       };
@@ -4116,6 +4255,8 @@ __export(exports_node_exports, {
   currentExperiment: () => currentExperiment,
   currentLogger: () => currentLogger,
   currentSpan: () => currentSpan,
+  defaultErrorScoreHandler: () => defaultErrorScoreHandler,
+  deserializePlainStringAsJSON: () => deserializePlainStringAsJSON,
   devNullWritableStream: () => devNullWritableStream,
   flush: () => flush,
   getSpanParentObject: () => getSpanParentObject,
@@ -4135,6 +4276,7 @@ __export(exports_node_exports, {
   permalink: () => permalink,
   projects: () => projects,
   renderMessage: () => renderMessage,
+  renderPromptParams: () => renderPromptParams,
   reportFailures: () => reportFailures,
   runEvaluator: () => runEvaluator,
   setFetch: () => setFetch,
@@ -5593,6 +5735,15 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters, st
   }
   return winner;
 }
+var defaultErrorScoreHandler = ({
+  rootSpan,
+  data,
+  unhandledScores
+}) => {
+  const scores = Object.fromEntries(unhandledScores.map((s) => [s, 0]));
+  rootSpan.log({ scores });
+  return scores;
+};
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream) {
   if (typeof evaluator.data === "string") {
     throw new Error("Unimplemented: string data paths");
@@ -5654,6 +5805,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             object_type: "dataset",
             object_id: await eventDataset.id,
             id: datum.id,
+            created: datum.created,
             _xact_id: datum._xact_id
           } : void 0,
           ...datum.upsert_id ? { id: datum.upsert_id } : {}
@@ -5667,6 +5819,8 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         let output = void 0;
         let error2 = void 0;
         const scores = {};
+        const scorerNames = evaluator.scores.map(scorerName);
+        let unhandledScores = scorerNames;
         try {
           const meta = (o) => metadata = { ...metadata, ...o };
           await rootSpan.traced(
@@ -5706,7 +5860,6 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             metadata,
             output
           };
-          const scorerNames = evaluator.scores.map(scorerName);
           const scoreResults = await Promise.all(
             evaluator.scores.map(async (score, score_idx) => {
               try {
@@ -5773,22 +5926,18 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               }
             })
           );
-          const passingScorersAndResults = [];
           const failingScorersAndResults = [];
           scoreResults.forEach((results2, i) => {
             const name = scorerNames[i];
             if (results2.kind === "score") {
               (results2.value || []).forEach((result) => {
-                passingScorersAndResults.push({
-                  name: result.name,
-                  score: result
-                });
                 scores[result.name] = result.score;
               });
             } else {
               failingScorersAndResults.push({ name, error: results2.value });
             }
           });
+          unhandledScores = null;
           if (failingScorersAndResults.length) {
             const scorerErrors = Object.fromEntries(
               failingScorersAndResults.map(({ name, error: error3 }) => [
@@ -5797,9 +5946,12 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               ])
             );
             metadata["scorer_errors"] = scorerErrors;
-            rootSpan.log({ metadata: { scorer_errors: scorerErrors } });
+            rootSpan.log({
+              metadata: { scorer_errors: scorerErrors }
+            });
             const names = Object.keys(scorerErrors).join(", ");
             const errors = failingScorersAndResults.map((item) => item.error);
+            unhandledScores = Object.keys(scorerErrors);
             throw new AggregateError(
               errors,
               `Found exceptions for the following scorers: ${names}`
@@ -5817,7 +5969,14 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           output,
           tags: datum.tags,
           metadata,
-          scores,
+          scores: {
+            ...evaluator.errorScoreHandler && unhandledScores ? evaluator.errorScoreHandler({
+              rootSpan,
+              data: datum,
+              unhandledScores
+            }) : void 0,
+            ...scores
+          },
           error: error2
         });
       };
@@ -6780,14 +6939,16 @@ function postProcessPrompt(prompt) {
           {
             role: "assistant",
             content: textPart?.text,
-            tool_calls: toolCallParts.map((part) => ({
-              id: part.toolCallId,
-              function: {
-                name: part.toolName,
-                arguments: JSON.stringify(part.args)
-              },
-              type: "function"
-            }))
+            ...toolCallParts.length > 0 ? {
+              tool_calls: toolCallParts.map((part) => ({
+                id: part.toolCallId,
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.args)
+                },
+                type: "function"
+              }))
+            } : {}
           }
         ];
       case "user":
@@ -6875,6 +7036,8 @@ var src_default = exports_node_exports;
   currentExperiment,
   currentLogger,
   currentSpan,
+  defaultErrorScoreHandler,
+  deserializePlainStringAsJSON,
   devNullWritableStream,
   flush,
   getSpanParentObject,
@@ -6894,6 +7057,7 @@ var src_default = exports_node_exports;
   permalink,
   projects,
   renderMessage,
+  renderPromptParams,
   reportFailures,
   runEvaluator,
   setFetch,