braintrust 0.0.113 → 0.0.115

package/dist/index.js

@@ -4949,6 +4949,7 @@ var require_pluralize = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   BaseExperiment: () => BaseExperiment,
+  Dataset: () => Dataset,
   Eval: () => Eval,
   Experiment: () => Experiment,
   Logger: () => Logger,
@@ -4956,9 +4957,11 @@ __export(src_exports, {
   NoopSpan: () => NoopSpan,
   Prompt: () => Prompt,
   ReadonlyExperiment: () => ReadonlyExperiment,
+  Reporter: () => Reporter,
   SpanImpl: () => SpanImpl,
   _internalGetGlobalState: () => _internalGetGlobalState,
   _internalSetInitialState: () => _internalSetInitialState,
+  buildLocalSummary: () => buildLocalSummary,
   currentExperiment: () => currentExperiment,
   currentLogger: () => currentLogger,
   currentSpan: () => currentSpan,
@@ -4970,6 +4973,7 @@ __export(src_exports, {
   loadPrompt: () => loadPrompt,
   log: () => log,
   login: () => login,
+  reportFailures: () => reportFailures,
   startSpan: () => startSpan,
   summarize: () => summarize,
   traced: () => traced,
@@ -9466,6 +9470,88 @@ function makeLegacyEvent(e) {
   }
   return event;
 }
+var SpanParentObjectType = /* @__PURE__ */ ((SpanParentObjectType2) => {
+  SpanParentObjectType2["EXPERIMENT"] = "experiment";
+  SpanParentObjectType2["PROJECT_LOGS"] = "project_logs";
+  return SpanParentObjectType2;
+})(SpanParentObjectType || {});
+var _OBJECT_TYPE_TO_PREFIX = {
+  [
+    "experiment"
+    /* EXPERIMENT */
+  ]: "ex",
+  [
+    "project_logs"
+    /* PROJECT_LOGS */
+  ]: "pl"
+};
+var _PREFIX_TO_OBJECT_TYPE = Object.fromEntries(
+  Object.entries(_OBJECT_TYPE_TO_PREFIX).map(([k, v]) => [v, k])
+);
+var _SEP = ":";
+var SpanParentComponents = class _SpanParentComponents {
+  constructor(args) {
+    this.objectType = args.objectType;
+    this.objectId = args.objectId;
+    this.rowId = args.rowId;
+    if (!(typeof this.objectType === "string")) {
+      throw new Error("objectType must be a string");
+    }
+    if (!(typeof this.objectId === "string")) {
+      throw new Error("objectId must be a string");
+    }
+    if (!(typeof this.rowId === "string")) {
+      throw new Error("rowId must be a string");
+    }
+    const objectTypePrefix = _OBJECT_TYPE_TO_PREFIX[this.objectType];
+    if (objectTypePrefix.includes(_SEP)) {
+      throw new Error(
+        `objectType prefix ${objectTypePrefix} may not contain separator character ${_SEP}`
+      );
+    }
+    if (this.objectId.includes(_SEP)) {
+      throw new Error(
+        `objectId ${this.objectId} may not contain separator character ${_SEP}`
+      );
+    }
+  }
+  toStr() {
+    return [
+      _OBJECT_TYPE_TO_PREFIX[this.objectType],
+      this.objectId,
+      this.rowId
+    ].join(_SEP);
+  }
+  static fromStr(s) {
+    const items = s.split(_SEP);
+    if (items.length < 3) {
+      throw new Error(
+        `Serialized parent components string must have at least three components. Provided string ${s} has only ${items.length}`
+      );
+    }
+    return new _SpanParentComponents({
+      objectType: _PREFIX_TO_OBJECT_TYPE[items[0]],
+      objectId: items[1],
+      rowId: items.slice(2).join(_SEP)
+    });
+  }
+  asDict() {
+    const out = (() => {
+      switch (this.objectType) {
+        case "experiment":
+          return { experiment_id: this.objectId };
+        case "project_logs":
+          return { project_id: this.objectId, log_id: "g" };
+        default:
+          throw new Error("Impossible");
+      }
+    })();
+    if (this.rowId) {
+      out[PARENT_ID_FIELD] = this.rowId;
+    }
+    return out;
+  }
+};
 var SpanTypeAttribute = /* @__PURE__ */ ((SpanTypeAttribute22) => {
   SpanTypeAttribute22["LLM"] = "llm";
   SpanTypeAttribute22["SCORE"] = "score";
@@ -13278,62 +13364,66 @@ var modeToTypes = {
   }
 };
 var customTypes = modeToTypes[mode];
-var chatCompletionSystemMessageParamSchema = z.object({
-  content: z.string(),
+var chatCompletionSystemMessageParamSchema = z.strictObject({
+  content: z.string().default(""),
   role: z.literal("system"),
   name: z.string().optional()
 });
-var chatCompletionContentPartTextSchema = z.object({
-  text: z.string(),
+var chatCompletionContentPartTextSchema = z.strictObject({
+  text: z.string().default(""),
   type: z.literal("text")
 });
-var functionCallSchema = z.object({
+var imageURLSchema = z.strictObject({
+  url: z.string(),
+  detail: z.union([z.literal("auto"), z.literal("low"), z.literal("high")]).optional()
+});
+var chatCompletionContentPartImageSchema = z.strictObject({
+  image_url: imageURLSchema,
+  type: z.literal("image_url")
+});
+var chatCompletionContentPartSchema = z.union([
+  chatCompletionContentPartTextSchema,
+  chatCompletionContentPartImageSchema
+]);
+var chatCompletionContentSchema = z.union([
+  z.string().default(""),
+  z.array(chatCompletionContentPartSchema)
+]);
+var chatCompletionUserMessageParamSchema = z.strictObject({
+  content: chatCompletionContentSchema,
+  role: z.literal("user"),
+  name: z.string().optional()
+});
+var functionCallSchema = z.strictObject({
   arguments: z.string(),
   name: z.string()
 });
-var functionSchema = z.object({
+var functionSchema = z.strictObject({
   arguments: z.string(),
   name: z.string()
 });
-var imageURLSchema = z.object({
-  url: z.string(),
-  detail: z.union([z.literal("auto"), z.literal("low"), z.literal("high")]).optional()
-});
-var chatCompletionToolMessageParamSchema = z.object({
-  content: z.string(),
+var chatCompletionToolMessageParamSchema = z.strictObject({
+  content: z.string().default(""),
   role: z.literal("tool"),
   tool_call_id: z.string()
 });
-var chatCompletionFunctionMessageParamSchema = z.object({
-  content: z.string().nullable(),
+var chatCompletionFunctionMessageParamSchema = z.strictObject({
+  content: z.string().default(""),
   name: z.string(),
   role: z.literal("function")
 });
-var chatCompletionContentPartImageSchema = z.object({
-  image_url: imageURLSchema,
-  type: z.literal("image_url")
-});
-var chatCompletionMessageToolCallSchema = z.object({
+var chatCompletionMessageToolCallSchema = z.strictObject({
   id: z.string(),
   function: functionSchema,
   type: z.literal("function")
 });
-var chatCompletionContentPartSchema = z.union([
-  chatCompletionContentPartTextSchema,
-  chatCompletionContentPartImageSchema
-]);
-var chatCompletionAssistantMessageParamSchema = z.object({
+var chatCompletionAssistantMessageParamSchema = z.strictObject({
   role: z.literal("assistant"),
-  content: z.string().optional().nullable(),
+  content: z.string().nullish(),
   function_call: functionCallSchema.optional(),
   name: z.string().optional(),
   tool_calls: z.array(chatCompletionMessageToolCallSchema).optional()
 });
-var chatCompletionUserMessageParamSchema = z.object({
-  content: z.union([z.string(), z.array(chatCompletionContentPartSchema)]),
-  role: z.literal("user"),
-  name: z.string().optional()
-});
 var chatCompletionMessageParamSchema = z.union([
   chatCompletionSystemMessageParamSchema,
   chatCompletionUserMessageParamSchema,
@@ -13342,12 +13432,12 @@ var chatCompletionMessageParamSchema = z.union([
   chatCompletionFunctionMessageParamSchema
 ]);
 var functionParametersSchema = z.record(z.unknown());
-var functionDefinitionSchema = z.object({
+var functionDefinitionSchema = z.strictObject({
   name: z.string(),
   description: z.string().optional(),
   parameters: functionParametersSchema.optional()
 });
-var chatCompletionToolSchema = z.object({
+var chatCompletionToolSchema = z.strictObject({
   function: functionDefinitionSchema,
   type: z.literal("function")
 });
@@ -13361,69 +13451,71 @@ var messageRoleSchema = z.enum([
   "model"
 ]);
 var promptBlockDataSchema = z.union([
-  z.object({
+  z.strictObject({
     type: z.literal("completion"),
     content: z.string()
   }),
-  z.object({
+  z.strictObject({
     type: z.literal("chat"),
     messages: z.array(chatCompletionMessageParamSchema),
     tools: z.string().optional()
   })
 ]);
-var braintrustModelParamsSchema = z.object({
+var braintrustModelParamsSchema = z.strictObject({
   use_cache: z.boolean().optional()
 });
 var BRAINTRUST_PARAMS = Object.keys(braintrustModelParamsSchema.shape);
-var openAIModelParamsSchema = z.object({
-  temperature: z.number(),
+var openAIModelParamsSchema = z.strictObject({
+  temperature: z.number().optional(),
   top_p: z.number().optional(),
   max_tokens: z.number().optional(),
   frequency_penalty: z.number().optional(),
   presence_penalty: z.number().optional(),
-  response_format: z.union([z.literal(null), z.object({ type: z.literal("json_object") })]).optional(),
+  response_format: z.union([
+    z.literal(null),
+    z.strictObject({ type: z.literal("json_object") })
+  ]).optional(),
   tool_choice: z.union([
     z.literal("auto"),
     z.literal("none"),
-    z.object({
+    z.strictObject({
       type: z.literal("function"),
-      function: z.object({ name: z.string() })
+      function: z.strictObject({ name: z.string() })
     })
   ]).optional()
 });
-var anthropicModelParamsSchema = z.object({
+var anthropicModelParamsSchema = z.strictObject({
   max_tokens: z.number(),
   temperature: z.number(),
   top_p: z.number().optional(),
   top_k: z.number().optional(),
   max_tokens_to_sample: z.number().optional().describe("This is a legacy parameter that should not be used.")
 });
-var googleModelParamsSchema = z.object({
+var googleModelParamsSchema = z.strictObject({
   temperature: z.number(),
   maxOutputTokens: z.number().optional(),
   topP: z.number().optional(),
   topK: z.number().optional()
 });
-var jsCompletionParamsSchema = z.object({});
-var modelParamsSchema = braintrustModelParamsSchema.and(
-  z.union([
-    openAIModelParamsSchema,
-    anthropicModelParamsSchema,
-    googleModelParamsSchema,
-    jsCompletionParamsSchema
-  ])
-);
-var anyModelParamsSchema = openAIModelParamsSchema.and(anthropicModelParamsSchema).and(googleModelParamsSchema).and(braintrustModelParamsSchema);
-var promptOptionsSchema = z.object({
+var jsCompletionParamsSchema = z.strictObject({});
+var modelParamsSchema = z.union([
+  braintrustModelParamsSchema.merge(openAIModelParamsSchema),
+  braintrustModelParamsSchema.merge(anthropicModelParamsSchema),
+  braintrustModelParamsSchema.merge(googleModelParamsSchema),
+  braintrustModelParamsSchema.merge(jsCompletionParamsSchema)
+]);
+var anyModelParamsSchema = openAIModelParamsSchema.merge(anthropicModelParamsSchema).merge(googleModelParamsSchema).merge(braintrustModelParamsSchema);
+var promptOptionsSchema = z.strictObject({
   model: z.string().optional(),
   params: modelParamsSchema.optional(),
   position: z.string().optional()
 });
-var promptDataSchema = z.object({
+var promptDataSchema = z.strictObject({
   prompt: promptBlockDataSchema.nullish(),
   options: promptOptionsSchema.nullish(),
-  origin: z.object({
+  origin: z.strictObject({
     prompt_id: z.string().optional(),
+    project_id: z.string().optional(),
     prompt_version: z.string().optional()
   }).nullish()
 }).openapi("PromptData");
@@ -13433,7 +13525,7 @@ function generateBaseTableSchema(objectName, opts) {
   if (opts == null ? void 0 : opts.uniqueName) {
     nameDescription += `. Within a project, ${objectName} names are unique`;
   }
-  return z.object({
+  return z.strictObject({
     id: z.string().uuid().describe(`Unique identifier for the ${objectName}`),
     project_id: z.string().uuid().describe(
       `Unique identifier for the project that the ${objectName} belongs under`
@@ -13449,7 +13541,7 @@ function generateBaseTableSchema(objectName, opts) {
   });
 }
 var userBaseSchema = generateBaseTableSchema("user");
-var userSchema = z.object({
+var userSchema = z.strictObject({
   id: userBaseSchema.shape.id,
   auth_id: z.string().uuid().nullish().describe("Internal authentication token used to identify the user"),
   given_name: z.string().nullish().describe("Given name of the user"),
@@ -13457,29 +13549,29 @@ var userSchema = z.object({
   email: z.string().nullish().describe("The user's email"),
   avatar_url: z.string().nullish().describe("URL of the user's Avatar image"),
   created: userBaseSchema.shape.created
-}).strict().openapi("User");
+}).openapi("User");
 var organizationBaseSchema = generateBaseTableSchema("organization");
-var organizationSchema = z.object({
+var organizationSchema = z.strictObject({
   id: organizationBaseSchema.shape.id,
   name: organizationBaseSchema.shape.name.nullish(),
   api_url: z.string().nullish(),
   created: organizationBaseSchema.shape.created
-}).strict().openapi("Organization");
-var memberSchema = z.object({
+}).openapi("Organization");
+var memberSchema = z.strictObject({
   org_id: organizationSchema.shape.id,
   user_id: userSchema.shape.id
-}).strict().openapi("Member");
-var meSchema = z.object({
+}).openapi("Member");
+var meSchema = z.strictObject({
   id: userSchema.shape.id,
   // By filtering by auth_id equality, we will ensure this is not-null.
   auth_id: userSchema.shape.auth_id.unwrap().unwrap(),
-  organizations: z.object({
+  organizations: z.strictObject({
     id: memberSchema.shape.org_id,
     name: organizationSchema.shape.name
   }).array()
-}).strict().openapi("Me");
+}).openapi("Me");
 var apiKeyBaseSchema = generateBaseTableSchema("api key");
-var apiKeySchema = z.object({
+var apiKeySchema = z.strictObject({
   id: apiKeyBaseSchema.shape.id,
   created: apiKeyBaseSchema.shape.created,
   key_hash: z.string(),
@@ -13487,9 +13579,9 @@ var apiKeySchema = z.object({
   preview_name: z.string(),
   user_id: userSchema.shape.id.nullish(),
   org_id: organizationSchema.shape.id.nullish()
-}).strict().openapi("ApiKey");
+}).openapi("ApiKey");
 var projectBaseSchema = generateBaseTableSchema("project");
-var projectSchema = z.object({
+var projectSchema = z.strictObject({
   id: projectBaseSchema.shape.id,
   org_id: z.string().uuid().describe(
     "Unique id for the organization that the project belongs under"
@@ -13498,11 +13590,11 @@ var projectSchema = z.object({
   created: projectBaseSchema.shape.created,
   deleted_at: projectBaseSchema.shape.deleted_at,
   user_id: projectBaseSchema.shape.user_id
-}).strict().openapi("Project");
+}).openapi("Project");
 var datasetBaseSchema = generateBaseTableSchema("dataset", {
   uniqueName: true
 });
-var datasetSchema = z.object({
+var datasetSchema = z.strictObject({
   id: datasetBaseSchema.shape.id,
   project_id: datasetBaseSchema.shape.project_id.nullish(),
   name: datasetBaseSchema.shape.name,
@@ -13510,22 +13602,26 @@ var datasetSchema = z.object({
   created: datasetBaseSchema.shape.created,
   deleted_at: datasetBaseSchema.shape.deleted_at,
   user_id: datasetBaseSchema.shape.user_id
-}).strict().openapi("Dataset");
+}).openapi("Dataset");
 var promptBaseSchema = generateBaseTableSchema("prompt");
-var promptSchema = z.object({
+var promptSchema = z.strictObject({
   id: promptBaseSchema.shape.id,
   // This has to be copy/pasted because zod blows up when there are circular dependencies
   _xact_id: z.string().describe(
     `The transaction id of an event is unique to the network operation that processed the event insertion. Transaction ids are monotonically increasing over time and can be used to retrieve a versioned snapshot of the prompt (see the \`version\` parameter)`
   ),
   project_id: promptBaseSchema.shape.project_id,
+  log_id: z.literal("p").describe("A literal 'p' which identifies the object as a project prompt"),
+  org_id: organizationSchema.shape.id,
   name: promptBaseSchema.shape.name,
   slug: z.string().describe("Unique identifier for the prompt"),
   description: promptBaseSchema.shape.description,
+  created: promptBaseSchema.shape.created,
   prompt_data: promptDataSchema.nullish().describe("The prompt, model, and its parameters"),
-  tags: z.array(z.string()).nullish().describe("A list of tags for the prompt")
+  tags: z.array(z.string()).nullish().describe("A list of tags for the prompt"),
+  metadata: promptBaseSchema.shape.metadata
 });
-var repoInfoSchema = z.object({
+var repoInfoSchema = z.strictObject({
   commit: z.string().nullish().describe("SHA of most recent commit"),
   branch: z.string().nullish().describe("Name of the branch the most recent commit belongs to"),
   tag: z.string().nullish().describe("Name of the tag on the most recent commit"),
@@ -13545,7 +13641,7 @@ var repoInfoSchema = z.object({
 var experimentBaseSchema = generateBaseTableSchema("experiment", {
   uniqueName: true
 });
-var experimentSchema = z.object({
+var experimentSchema = z.strictObject({
   id: experimentBaseSchema.shape.id,
   project_id: experimentBaseSchema.shape.project_id,
   name: experimentBaseSchema.shape.name,
@@ -13568,10 +13664,10 @@ var experimentSchema = z.object({
   ),
   user_id: experimentBaseSchema.shape.user_id,
   metadata: experimentBaseSchema.shape.metadata
-}).strict().openapi("Experiment");
+}).openapi("Experiment");
 var appLimitSchema = z.number().int().nonnegative().describe("Limit the number of objects to return");
 function generateBaseTableOpSchema(objectName) {
-  return z.object({
+  return z.strictObject({
     org_name: z.string().nullish().describe(
       `For nearly all users, this parameter should be unnecessary. But in the rare case that your API key belongs to multiple organizations, you may specify the name of the organization the ${objectName} belongs in.`
     )
@@ -13590,14 +13686,14 @@ var endingBeforeSchema = z.string().uuid().describe(
   ].join("\n\n")
 ).openapi("EndingBefore");
 var createProjectBaseSchema = generateBaseTableOpSchema("project");
-var createProjectSchema = z.object({
+var createProjectSchema = z.strictObject({
   name: projectSchema.shape.name,
   org_name: createProjectBaseSchema.shape.org_name
-}).strict().openapi("CreateProject");
-var patchProjectSchema = z.object({
+}).openapi("CreateProject");
+var patchProjectSchema = z.strictObject({
   name: projectSchema.shape.name.nullish()
-}).strict().openapi("PatchProject");
-var createExperimentSchema = z.object({
+}).openapi("PatchProject");
+var createExperimentSchema = z.strictObject({
   project_id: experimentSchema.shape.project_id,
   name: experimentSchema.shape.name.nullish(),
   description: experimentSchema.shape.description,
@@ -13607,21 +13703,28 @@ var createExperimentSchema = z.object({
   dataset_version: experimentSchema.shape.dataset_version,
   public: experimentSchema.shape.public.nullish(),
   metadata: experimentSchema.shape.metadata
-}).strict().openapi("CreateExperiment");
-var patchExperimentSchema = createExperimentSchema.omit({ project_id: true }).strict().openapi("PatchExperiment");
-var createDatasetSchema = z.object({
+}).openapi("CreateExperiment");
+var patchExperimentSchema = createExperimentSchema.omit({ project_id: true }).openapi("PatchExperiment");
+var createDatasetSchema = z.strictObject({
   project_id: datasetSchema.shape.project_id,
   name: datasetSchema.shape.name,
   description: datasetSchema.shape.description
-}).strict().openapi("CreateDataset");
-var patchDatasetSchema = createDatasetSchema.omit({ project_id: true }).strict().openapi("PatchDataset");
-var createPromptSchema = promptSchema.omit({ id: true, _xact_id: true }).strict().openapi("CreatePrompt");
-var patchPromptSchema = z.object({
+}).openapi("CreateDataset");
+var patchDatasetSchema = createDatasetSchema.omit({ project_id: true }).openapi("PatchDataset");
+var createPromptSchema = promptSchema.omit({
+  id: true,
+  _xact_id: true,
+  org_id: true,
+  log_id: true,
+  created: true,
+  metadata: true
+}).openapi("CreatePrompt");
+var patchPromptSchema = z.strictObject({
   name: promptSchema.shape.name.nullish(),
   description: promptSchema.shape.description.nullish(),
   prompt_data: promptSchema.shape.prompt_data.nullish(),
   tags: promptSchema.shape.tags.nullish()
-}).strict().openapi("PatchPrompt");
+}).openapi("PatchPrompt");
 function capitalize(s, sep) {
   const items = sep ? s.split(sep) : [s];
   return items.map((s2) => s2 ? s2.charAt(0).toUpperCase() + s2.slice(1) : s2).join(sep || "");
@@ -13645,7 +13748,7 @@ var SpanTypeAttribute2 = /* @__PURE__ */ ((SpanTypeAttribute22) => {
 var auditSourcesSchema = z.enum(VALID_SOURCES2);
 function generateBaseEventOpSchema(objectType2) {
   const eventDescription = getEventObjectDescription(objectType2);
-  return z.object({
+  return z.strictObject({
     id: z.string().describe(
       `A unique identifier for the ${eventDescription} event. If you don't provide one, BrainTrust will generate one for you`
     ),
@@ -13661,7 +13764,7 @@ function generateBaseEventOpSchema(objectType2) {
     metadata: z.record(customTypes.any).nullish().describe(
       "A dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings"
     ),
-    metrics: z.object({
+    metrics: z.strictObject({
       start: z.number().nullish().describe(
         `A unix timestamp recording when the section of code which produced the ${eventDescription} event started`
       ),
@@ -13671,7 +13774,7 @@ function generateBaseEventOpSchema(objectType2) {
     }).catchall(customTypes.any).nullish().describe(
       `Metrics are numerical measurements tracking the execution of the code that produced the ${eventDescription} event. Use "start" and "end" to track the time span over which the ${eventDescription} event was produced`
     ),
-    context: z.object({
+    context: z.strictObject({
       caller_functionname: z.string().nullish().describe(
         `The function in code which created the ${eventDescription} event`
       ),
@@ -13693,7 +13796,7 @@ function generateBaseEventOpSchema(objectType2) {
     root_span_id: z.string().describe(
       `The \`span_id\` of the root of the trace this ${eventDescription} event belongs to`
     ),
-    span_attributes: z.object({
+    span_attributes: z.strictObject({
       name: z.string().nullish().describe("Name of the span, for display purposes only"),
       type: z.nativeEnum(SpanTypeAttribute2).nullish().describe("Type of the span, for display purposes only")
     }).catchall(customTypes.any).nullish().describe(
@@ -13707,7 +13810,7 @@ function generateBaseEventOpSchema(objectType2) {
 function generateBaseEventFeedbackSchema(objectType2) {
   const eventObjectType = getEventObjectType(objectType2);
   const eventDescription = getEventObjectDescription(objectType2);
-  return z.object({
+  return z.strictObject({
     id: z.string().describe(
       `The id of the ${eventDescription} event to log feedback for. This is the row \`id\` returned by \`POST /v1/${eventObjectType}/{${objectType2}_id}/insert\``
     ),
@@ -13748,7 +13851,7 @@ var versionSchema = z.string().describe(
     "The version id is essentially a filter on the latest event transaction id. You can use the `max_xact_id` returned by a past fetch as the version to reproduce that exact fetch."
   ].join("\n\n")
 );
-var pathTypeFilterSchema = z.object({
+var pathTypeFilterSchema = z.strictObject({
   type: z.literal("path_lookup").describe("Denotes the type of filter as a path-lookup filter"),
   path: z.string().array().describe(
     'List of fields describing the path to the value to be checked against. For instance, if you wish to filter on the value of `c` in `{"input": {"a": {"b": {"c": "hello"}}}}`, pass `path=["input", "a", "b", "c"]`'
@@ -13759,7 +13862,7 @@ var pathTypeFilterSchema = z.object({
 }).describe(
   'A path-lookup filter describes an equality comparison against a specific sub-field in the event row. For instance, if you wish to filter on the value of `c` in `{"input": {"a": {"b": {"c": "hello"}}}}`, pass `path=["input", "a", "b", "c"]` and `value="hello"`'
 ).openapi("PathLookupFilter");
-var sqlTypeFilterSchema = z.object({
+var sqlTypeFilterSchema = z.strictObject({
   type: z.literal("sql_filter").describe("Denotes the type of filter as a sql-type filter"),
   expr: z.string().describe(
     `A SQL expression in [duckDB syntax](https://duckdb.org/docs/sql/expressions/overview). For instance, if you wish to fuzzy-match the value of \`c\` in \`{"input": {"a": {"b": {"c": "hello"}}}}\`, pass \`expr="input->'a'->'b'->>'c' LIKE '%el%'"\`.`
@@ -13773,24 +13876,24 @@ var allFetchFiltersSchema = z.union([pathTypeFilterSchema, sqlTypeFilterSchema])
 var fetchFiltersSchema = pathTypeFilterSchema.array().describe(
   "A list of filters on the events to fetch. Currently, only path-lookup type filters are supported, but we may add more in the future"
 ).openapi("FetchEventsFilters");
-var fetchEventsRequestSchema = z.object({
+var fetchEventsRequestSchema = z.strictObject({
   limit: fetchLimitSchema.nullish(),
   max_xact_id: maxXactIdSchema.nullish(),
   max_root_span_id: maxRootSpanIdSchema.nullish(),
   filters: fetchFiltersSchema.nullish(),
   version: versionSchema.nullish()
-}).strict().openapi("FetchEventsRequest");
+}).openapi("FetchEventsRequest");
 function makeFetchEventsResponseSchema(objectType2, eventSchema) {
   const eventName = capitalize(getEventObjectType(objectType2), "_").replace(
     "_",
     ""
   );
-  return z.object({
+  return z.strictObject({
     events: eventSchema.array().describe("A list of fetched events")
-  }).strict().openapi(`Fetch${eventName}EventsResponse`);
+  }).openapi(`Fetch${eventName}EventsResponse`);
 }
 var experimentEventBaseSchema = generateBaseEventOpSchema("experiment");
-var experimentEventSchema = z.object({
+var experimentEventSchema = z.strictObject({
   id: experimentEventBaseSchema.shape.id,
   dataset_record_id: z.string().nullish().describe(
     "If the experiment is associated to a dataset, this is the event-level dataset id this experiment event is tied to"
@@ -13819,9 +13922,9 @@ var experimentEventSchema = z.object({
   span_parents: experimentEventBaseSchema.shape.span_parents,
   root_span_id: experimentEventBaseSchema.shape.root_span_id,
   span_attributes: experimentEventBaseSchema.shape.span_attributes
-}).strict().openapi("ExperimentEvent");
+}).openapi("ExperimentEvent");
 var datasetEventBaseSchema = generateBaseEventOpSchema("dataset");
-var datasetEventSchema = z.object({
+var datasetEventSchema = z.strictObject({
   id: datasetEventBaseSchema.shape.id,
   [TRANSACTION_ID_FIELD2]: datasetEventBaseSchema.shape[TRANSACTION_ID_FIELD2],
   created: datasetEventBaseSchema.shape.created,
@@ -13837,9 +13940,9 @@ var datasetEventSchema = z.object({
   tags: datasetEventBaseSchema.shape.tags,
   span_id: datasetEventBaseSchema.shape.span_id,
   root_span_id: datasetEventBaseSchema.shape.root_span_id
-}).strict().openapi("DatasetEvent");
+}).openapi("DatasetEvent");
 var projectLogsEventBaseSchema = generateBaseEventOpSchema("project");
-var projectLogsEventSchema = z.object({
+var projectLogsEventSchema = z.strictObject({
   id: projectLogsEventBaseSchema.shape.id,
   [TRANSACTION_ID_FIELD2]: projectLogsEventBaseSchema.shape[TRANSACTION_ID_FIELD2],
   created: projectLogsEventBaseSchema.shape.created,
@@ -13866,12 +13969,12 @@ var projectLogsEventSchema = z.object({
   span_parents: projectLogsEventBaseSchema.shape.span_parents,
   root_span_id: projectLogsEventBaseSchema.shape.root_span_id,
   span_attributes: projectLogsEventBaseSchema.shape.span_attributes
-}).strict().openapi("ProjectLogsEvent");
+}).openapi("ProjectLogsEvent");
 var isMergeDescription = [
   "The `_is_merge` field controls how the row is merged with any existing row with the same id in the DB. By default (or when set to `false`), the existing row is completely replaced by the new row. When set to `true`, the new row is deep-merged into the existing row",
   'For example, say there is an existing row in the DB `{"id": "foo", "input": {"a": 5, "b": 10}}`. If we merge a new row as `{"_is_merge": true, "id": "foo", "input": {"b": 11, "c": 20}}`, the new row will be `{"id": "foo", "input": {"a": 5, "b": 11, "c": 20}}`. If we replace the new row as `{"id": "foo", "input": {"b": 11, "c": 20}}`, the new row will be `{"id": "foo", "input": {"b": 11, "c": 20}}`'
 ].join("\n\n");
-var mergeEventSchema = z.object({
+var mergeEventSchema = z.strictObject({
   [IS_MERGE_FIELD2]: customTypes.literalTrue.describe(isMergeDescription),
   [MERGE_PATHS_FIELD2]: z.string().array().array().nullish().describe(
     [
@@ -13880,7 +13983,7 @@ var mergeEventSchema = z.object({
     ].join("\n\n")
   )
 });
-var replacementEventSchema = z.object({
+var replacementEventSchema = z.strictObject({
   [IS_MERGE_FIELD2]: customTypes.literalFalse.nullish().describe(isMergeDescription),
   [PARENT_ID_FIELD2]: z.string().nullish().describe(
     [
@@ -13896,25 +13999,25 @@ function makeInsertEventSchemas(objectType2, insertSchema) {
     getEventObjectType(objectType2),
     "_"
   ).replace("_", "");
-  const replaceVariantSchema = insertSchema.merge(replacementEventSchema).strict().openapi(`Insert${eventSchemaName}EventReplace`);
-  const mergeVariantSchema = insertSchema.merge(mergeEventSchema).strict().openapi(`Insert${eventSchemaName}EventMerge`);
+  const replaceVariantSchema = insertSchema.merge(replacementEventSchema).openapi(`Insert${eventSchemaName}EventReplace`);
+  const mergeVariantSchema = insertSchema.merge(mergeEventSchema).openapi(`Insert${eventSchemaName}EventMerge`);
   const eventSchema = z.union([replaceVariantSchema, mergeVariantSchema]).describe(`${capitalize(article)} ${eventDescription} event`).openapi(`Insert${eventSchemaName}Event`);
-  const requestSchema = z.object({
+  const requestSchema = z.strictObject({
     events: eventSchema.array().describe(`A list of ${eventDescription} events to insert`)
-  }).strict().openapi(`Insert${eventSchemaName}EventRequest`);
+  }).openapi(`Insert${eventSchemaName}EventRequest`);
   return { eventSchema, requestSchema };
 }
-var insertEventsResponseSchema = z.object({
+var insertEventsResponseSchema = z.strictObject({
   row_ids: z.string().array().describe(
     "The ids of all rows that were inserted, aligning one-to-one with the rows provided as input"
   )
-}).strict().openapi("InsertEventsResponse");
+}).openapi("InsertEventsResponse");
 var {
   eventSchema: insertExperimentEventSchema,
   requestSchema: insertExperimentEventsRequestSchema
 } = makeInsertEventSchemas(
   "experiment",
-  z.object({
+  z.strictObject({
     input: experimentEventSchema.shape.input,
     output: experimentEventSchema.shape.output,
     expected: experimentEventSchema.shape.expected,
@@ -13927,28 +14030,28 @@ var {
     id: experimentEventSchema.shape.id.nullish(),
     dataset_record_id: experimentEventSchema.shape.dataset_record_id,
     [OBJECT_DELETE_FIELD]: experimentEventBaseSchema.shape[OBJECT_DELETE_FIELD]
-  }).strict()
+  })
 );
 var {
   eventSchema: insertDatasetEventSchema,
   requestSchema: insertDatasetEventsRequestSchema
 } = makeInsertEventSchemas(
   "dataset",
-  z.object({
+  z.strictObject({
     input: datasetEventSchema.shape.input,
     expected: datasetEventSchema.shape.expected,
     metadata: datasetEventSchema.shape.metadata,
     tags: datasetEventSchema.shape.tags,
     id: datasetEventSchema.shape.id.nullish(),
     [OBJECT_DELETE_FIELD]: datasetEventBaseSchema.shape[OBJECT_DELETE_FIELD]
-  }).strict()
+  })
 );
 var {
   eventSchema: insertProjectLogsEventSchema,
   requestSchema: insertProjectLogsEventsRequestSchema
 } = makeInsertEventSchemas(
   "project",
-  z.object({
+  z.strictObject({
     input: projectLogsEventSchema.shape.input,
     output: projectLogsEventSchema.shape.output,
     expected: projectLogsEventSchema.shape.expected,
@@ -13960,7 +14063,7 @@ var {
     span_attributes: projectLogsEventSchema.shape.span_attributes,
     id: projectLogsEventSchema.shape.id.nullish(),
     [OBJECT_DELETE_FIELD]: projectLogsEventBaseSchema.shape[OBJECT_DELETE_FIELD]
-  }).strict()
+  })
 );
 function makeFeedbackRequestSchema(objectType2, feedbackSchema) {
   const eventDescription = getEventObjectDescription(objectType2);
@@ -13968,54 +14071,54 @@ function makeFeedbackRequestSchema(objectType2, feedbackSchema) {
     getEventObjectType(objectType2),
     "_"
   ).replace("_", "");
-  return z.object({
+  return z.strictObject({
     feedback: feedbackSchema.array().describe(`A list of ${eventDescription} feedback items`)
-  }).strict().openapi(`Feedback${eventSchemaName}EventRequest`);
+  }).openapi(`Feedback${eventSchemaName}EventRequest`);
 }
 var feedbackExperimentRequestBaseSchema = generateBaseEventFeedbackSchema("experiment");
-var feedbackExperimentItemSchema = z.object({
+var feedbackExperimentItemSchema = z.strictObject({
   id: feedbackExperimentRequestBaseSchema.shape.id,
   scores: feedbackExperimentRequestBaseSchema.shape.scores,
   expected: feedbackExperimentRequestBaseSchema.shape.expected,
   comment: feedbackExperimentRequestBaseSchema.shape.comment,
   metadata: feedbackExperimentRequestBaseSchema.shape.metadata,
   source: feedbackExperimentRequestBaseSchema.shape.source
-}).strict().openapi("FeedbackExperimentItem");
+}).openapi("FeedbackExperimentItem");
 var feedbackExperimentRequestSchema = makeFeedbackRequestSchema(
   "experiment",
   feedbackExperimentItemSchema
 );
 var feedbackDatasetRequestBaseSchema = generateBaseEventFeedbackSchema("dataset");
-var feedbackDatasetItemSchema = z.object({
+var feedbackDatasetItemSchema = z.strictObject({
   id: feedbackDatasetRequestBaseSchema.shape.id,
   comment: feedbackDatasetRequestBaseSchema.shape.comment,
   metadata: feedbackDatasetRequestBaseSchema.shape.metadata,
   source: feedbackDatasetRequestBaseSchema.shape.source
-}).strict().openapi("FeedbackDatasetItem");
+}).openapi("FeedbackDatasetItem");
 var feedbackDatasetRequestSchema = makeFeedbackRequestSchema(
   "dataset",
   feedbackDatasetItemSchema
 );
 var feedbackProjectLogsRequestBaseSchema = generateBaseEventFeedbackSchema("project");
-var feedbackProjectLogsItemSchema = z.object({
+var feedbackProjectLogsItemSchema = z.strictObject({
   id: feedbackProjectLogsRequestBaseSchema.shape.id,
   scores: feedbackProjectLogsRequestBaseSchema.shape.scores,
   expected: feedbackProjectLogsRequestBaseSchema.shape.expected,
   comment: feedbackProjectLogsRequestBaseSchema.shape.comment,
   metadata: feedbackProjectLogsRequestBaseSchema.shape.metadata,
   source: feedbackProjectLogsRequestBaseSchema.shape.source
-}).strict().openapi("FeedbackProjectLogsItem");
+}).openapi("FeedbackProjectLogsItem");
 var feedbackProjectLogsRequestSchema = makeFeedbackRequestSchema(
   "project",
   feedbackProjectLogsItemSchema
 );
 var feedbackPromptRequestBaseSchema = generateBaseEventFeedbackSchema("prompt");
-var feedbackPromptItemSchema = z.object({
+var feedbackPromptItemSchema = z.strictObject({
   id: feedbackPromptRequestBaseSchema.shape.id,
   comment: feedbackPromptRequestBaseSchema.shape.comment,
   metadata: feedbackPromptRequestBaseSchema.shape.metadata,
   source: feedbackPromptRequestBaseSchema.shape.source
-}).strict().openapi("FeedbackPromptItem");
+}).openapi("FeedbackPromptItem");
 var feedbackPromptRequestSchema = makeFeedbackRequestSchema(
   "prompt",
   feedbackPromptItemSchema
@@ -14060,12 +14163,12 @@ function makeCrossObjectIndividualRequestSchema(objectType2) {
   const eventObjectType = getEventObjectType(objectType2);
   const eventDescription = getEventObjectDescription(objectType2);
   const eventObjectSchema = eventObjectSchemas[eventObjectType];
-  const insertObject = z.object({
+  const insertObject = z.strictObject({
     ...eventObjectSchema.insertEvent ? {
       events: eventObjectSchema.insertEvent.array().nullish().describe(`A list of ${eventDescription} events to insert`)
     } : {},
     feedback: eventObjectSchema.feedbackItem.array().nullish().describe(`A list of ${eventDescription} feedback items`)
-  }).strict();
+  });
   return z.record(z.string().uuid(), insertObject).nullish().describe(
     `A mapping from ${objectType2} id to a set of log events and feedback items to insert`
   );
@@ -14075,18 +14178,16 @@ function makeCrossObjectIndividualResponseSchema(objectType2) {
     `A mapping from ${objectType2} id to row ids for inserted \`events\``
   );
 }
-var crossObjectInsertRequestSchema = z.object({
+var crossObjectInsertRequestSchema = z.strictObject({
   experiment: makeCrossObjectIndividualRequestSchema("experiment"),
   dataset: makeCrossObjectIndividualRequestSchema("dataset"),
-  project_logs: makeCrossObjectIndividualRequestSchema("project"),
-  prompt: makeCrossObjectIndividualRequestSchema("prompt")
-}).strict().openapi("CrossObjectInsertRequest");
-var crossObjectInsertResponseSchema = z.object({
+  project_logs: makeCrossObjectIndividualRequestSchema("project")
+}).openapi("CrossObjectInsertRequest");
+var crossObjectInsertResponseSchema = z.strictObject({
   experiment: makeCrossObjectIndividualResponseSchema("experiment"),
   dataset: makeCrossObjectIndividualResponseSchema("dataset"),
-  project_logs: makeCrossObjectIndividualResponseSchema("project"),
-  prompt: makeCrossObjectIndividualResponseSchema("prompt")
-}).strict().openapi("CrossObjectInsertResponse");
+  project_logs: makeCrossObjectIndividualResponseSchema("project")
+}).openapi("CrossObjectInsertResponse");
 var summarizeScoresParamSchema = z.boolean().describe(
   "Whether to summarize the scores and metrics. If false (or omitted), only the metadata will be returned."
 );
@@ -14096,14 +14197,14 @@ var comparisonExperimentIdParamSchema = z.string().uuid().describe(
 var summarizeDataParamSchema = z.boolean().describe(
   "Whether to summarize the data. If false (or omitted), only the metadata will be returned."
 );
-var summarizeExperimentResponseSchema = z.object({
+var summarizeExperimentResponseSchema = z.strictObject({
   project_name: z.string().describe("Name of the project that the experiment belongs to"),
   experiment_name: z.string().describe("Name of the experiment"),
   project_url: z.string().url().describe("URL to the project's page in the Braintrust app"),
   experiment_url: z.string().url().describe("URL to the experiment's page in the Braintrust app"),
   comparison_experiment_name: z.string().nullish().describe("The experiment which scores are baselined against"),
   scores: z.record(
-    z.object({
+    z.strictObject({
       name: z.string().describe("Name of the score"),
       score: z.number().min(0).max(1).describe("Average score across all examples"),
       diff: z.number().min(-1).max(1).describe(
@@ -14114,7 +14215,7 @@ var summarizeExperimentResponseSchema = z.object({
     }).describe("Summary of a score's performance").openapi("ScoreSummary")
   ).nullish().describe("Summary of the experiment's scores"),
   metrics: z.record(
-    z.object({
+    z.strictObject({
       name: z.string().describe("Name of the metric"),
       metric: z.number().describe("Average metric across all examples"),
       unit: z.string().describe("Unit label for the metric"),
@@ -14125,16 +14226,16 @@ var summarizeExperimentResponseSchema = z.object({
       regressions: z.number().int().min(0).describe("Number of regressions in the metric")
     }).describe("Summary of a metric's performance").openapi("MetricSummary")
   ).nullish().describe("Summary of the experiment's metrics")
-}).strict().describe("Summary of an experiment").openapi("SummarizeExperimentResponse");
-var summarizeDatasetResponseSchema = z.object({
+}).describe("Summary of an experiment").openapi("SummarizeExperimentResponse");
+var summarizeDatasetResponseSchema = z.strictObject({
   project_name: z.string().describe("Name of the project that the dataset belongs to"),
   dataset_name: z.string().describe("Name of the dataset"),
   project_url: z.string().url().describe("URL to the project's page in the Braintrust app"),
   dataset_url: z.string().url().describe("URL to the dataset's page in the Braintrust app"),
-  data_summary: z.object({
+  data_summary: z.strictObject({
     total_records: z.number().int().min(0).describe("Total number of records in the dataset")
   }).nullish().describe("Summary of a dataset's data").openapi("DataSummary")
-}).strict().describe("Summary of a dataset").openapi("SummarizeDatasetResponse");
+}).describe("Summary of a dataset").openapi("SummarizeDatasetResponse");
 
 // src/util.ts
 var GLOBAL_PROJECT = "Global";
@@ -14648,7 +14749,7 @@ var NoopSpan = class {
   }
   log(_) {
   }
-  logFeedback(event) {
+  logFeedback(_event) {
   }
   traced(callback, _1) {
     return callback(this);
@@ -14662,6 +14763,8 @@ var NoopSpan = class {
   close(args) {
     return this.end(args);
   }
+  async flush() {
+  }
 };
 var NOOP_SPAN = new NoopSpan();
 var BraintrustState = class {
@@ -14671,7 +14774,12 @@ var BraintrustState = class {
   // (safely) dynamically cast it whenever retrieving the logger.
   currentLogger;
   currentSpan;
+  // For operations not tied to a particular data object instance, we maintain a
+  // global BackgroundLogger which is refreshed anytime we log in with different
+  // credentials.
+  _globalBgLogger = void 0;
   appUrl = null;
+  appPublicUrl = null;
   loginToken = null;
   orgId = null;
   orgName = null;
@@ -14680,6 +14788,7 @@ var BraintrustState = class {
   gitMetadataSettings;
   _apiConn = null;
   _logConn = null;
+  _globalBgLoggerDirty = true;
   constructor() {
     this.id = v4_default();
     this.currentExperiment = void 0;
@@ -14698,6 +14807,7 @@ var BraintrustState = class {
     this.gitMetadataSettings = void 0;
     this._apiConn = null;
     this._logConn = null;
+    this._globalBgLoggerDirty = true;
   }
   apiConn() {
     if (!this._apiConn) {
@@ -14717,6 +14827,18 @@ var BraintrustState = class {
     }
     return this._logConn;
   }
+  globalBgLogger() {
+    if (this._globalBgLogger === void 0 || this._globalBgLoggerDirty) {
+      const getLogConn = async () => {
+        await login();
+        this._globalBgLoggerDirty = false;
+        return this.logConn();
+      };
+      this._globalBgLogger = new BackgroundLogger(new LazyValue(getLogConn));
+      this._globalBgLoggerDirty = false;
+    }
+    return this._globalBgLogger;
+  }
 };
 var _state;
 function _internalSetInitialState() {
@@ -14839,7 +14961,7 @@ var HTTPConnection = class _HTTPConnection {
     return await resp.json();
   }
 };
-function logFeedbackImpl(bgLogger, parentIds, {
+function logFeedbackImpl(bgLogger, parentObjectType, parentObjectId, {
   id,
   expected,
   scores,
@@ -14867,16 +14989,17 @@ function logFeedbackImpl(bgLogger, parentIds, {
   updateEvent = Object.fromEntries(
     Object.entries(updateEvent).filter(([_, v]) => !isEmpty(v))
   );
-  const trueParentIds = new LazyValue(async () => {
-    const { kind, ...ids } = await parentIds.get();
-    return ids;
-  });
+  const parentIds = async () => new SpanParentComponents({
+    objectType: parentObjectType,
+    objectId: await parentObjectId.get(),
+    rowId: ""
+  }).asDict();
   if (Object.keys(updateEvent).length > 0) {
     const record = new LazyValue(async () => {
       return {
         id,
         ...updateEvent,
-        ...await trueParentIds.get(),
+        ...await parentIds(),
         [AUDIT_SOURCE_FIELD]: source,
         [AUDIT_METADATA_FIELD]: metadata,
         [IS_MERGE_FIELD]: true
@@ -14897,7 +15020,7 @@ function logFeedbackImpl(bgLogger, parentIds, {
         comment: {
           text: comment
         },
-        ...await trueParentIds.get(),
+        ...await parentIds(),
         [AUDIT_SOURCE_FIELD]: source,
         [AUDIT_METADATA_FIELD]: metadata
       };
@@ -14905,11 +15028,48 @@ function logFeedbackImpl(bgLogger, parentIds, {
     bgLogger.log([record]);
   }
 }
+function startSpanParentArgs(args) {
+  if (args.parent && args.parentId) {
+    throw new Error(
+      "Cannot specify both `parent` and `parentId`. Prefer `parent"
+    );
+  }
+  let parentObjectId = void 0;
+  let parentRowId = void 0;
+  if (args.parent) {
+    const parentComponents = SpanParentComponents.fromStr(args.parent);
+    if (args.spanParentObjectType !== parentComponents.objectType) {
+      throw new Error(
+        `Mismatch between expected span parent object type ${args.spanParentObjectType} and provided type ${parentComponents.objectType}`
+      );
+    }
+    const computeParentObjectId = async () => {
+      if (await args.spanParentObjectId.get() !== parentComponents.objectId) {
+        throw new Error(
+          `Mismatch between expected span parent object id ${await args.spanParentObjectId.get()} and provided id ${parentComponents.objectId}`
+        );
+      }
+      return await args.spanParentObjectId.get();
+    };
+    parentObjectId = new LazyValue(computeParentObjectId);
+    parentRowId = parentComponents.rowId;
+  } else {
+    parentObjectId = args.spanParentObjectId;
+    parentRowId = args.parentId ?? "";
+  }
+  return {
+    parentObjectType: args.spanParentObjectType,
+    parentObjectId,
+    parentRowId
+  };
+}
 var Logger = class {
   lazyMetadata;
   logOptions;
   bgLogger;
   lastStartTime;
+  lazyId;
+  calledStartSpan;
   // For type identification.
   kind = "logger";
   constructor(lazyMetadata, logOptions = {}) {
@@ -14920,6 +15080,8 @@ var Logger = class {
     );
     this.bgLogger = new BackgroundLogger(logConn);
     this.lastStartTime = getCurrentUnixTimestamp();
+    this.lazyId = new LazyValue(async () => await this.id);
+    this.calledStartSpan = false;
   }
   get org_id() {
     return (async () => {
@@ -14931,6 +15093,12 @@ var Logger = class {
       return (await this.lazyMetadata.get()).project;
     })();
   }
+  get id() {
+    return (async () => (await this.project).id)();
+  }
+  spanParentObjectType() {
+    return SpanParentObjectType.PROJECT_LOGS;
+  }
   async getState() {
     await this.lazyMetadata.get();
     return _state;
@@ -14947,19 +15115,16 @@ var Logger = class {
    * @param event.metrics: (Optional) a dictionary of metrics to log. The following keys are populated automatically: "start", "end".
    * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
    * @param options Additional logging options
-   * @param options.allowLogConcurrentWithActiveSpan in rare cases where you need to log at the top level separately from an active span on the logger, set this to true.
+   * @param options.allowConcurrentWithSpans in rare cases where you need to log at the top level separately from spans on the logger elsewhere, set this to true.
    * :returns: The `id` of the logged event.
    */
   log(event, options) {
-    if (!options?.allowLogConcurrentWithActiveSpan) {
-      const checkCurrentSpan = currentSpan();
-      if (checkCurrentSpan instanceof SpanImpl && checkCurrentSpan.parentObject === this) {
-        throw new Error(
-          "Cannot run toplevel Logger.log method while there is an active span. To log to the span, use Span.log"
-        );
-      }
+    if (this.calledStartSpan && !options?.allowConcurrentWithSpans) {
+      throw new Error(
+        "Cannot run toplevel `log` method while using spans. To log to the span, call `logger.traced` and then log with `span.log`"
+      );
     }
-    const span = this.startSpan({ startTime: this.lastStartTime, event });
+    const span = this.startSpanImpl({ startTime: this.lastStartTime, event });
     this.lastStartTime = span.end();
     const ret = span.id;
     if (this.logOptions.asyncFlush === true) {
@@ -14999,14 +15164,6 @@ var Logger = class {
       })();
     }
   }
-  async lazyParentIds() {
-    return {
-      kind: "project_log",
-      org_id: await this.org_id,
-      project_id: (await this.project).id,
-      log_id: "g"
-    };
-  }
   /**
    * Lower-level alternative to `traced`. This allows you to start a span yourself, and can be useful in situations
    * where you cannot use callbacks. However, spans started with `startSpan` will not be marked as the "current span",
@@ -15015,13 +15172,20 @@ var Logger = class {
    * See `traced` for full details.
    */
   startSpan(args) {
-    const { name, ...argsRest } = args ?? {};
+    this.calledStartSpan = true;
+    return this.startSpanImpl(args);
+  }
+  startSpanImpl(args) {
     return new SpanImpl({
-      parentObject: this,
-      parentIds: new LazyValue(() => this.lazyParentIds()),
+      ...startSpanParentArgs({
+        parent: args?.parent,
+        parentId: args?.parentId,
+        spanParentObjectType: this.spanParentObjectType(),
+        spanParentObjectId: this.lazyId
+      }),
+      ...args,
       bgLogger: this.bgLogger,
-      name: name ?? "root",
-      ...argsRest
+      defaultRootType: SpanTypeAttribute.TASK
     });
   }
   /**
@@ -15038,10 +15202,21 @@ var Logger = class {
   logFeedback(event) {
     logFeedbackImpl(
       this.bgLogger,
-      new LazyValue(() => this.lazyParentIds()),
+      this.spanParentObjectType(),
+      this.lazyId,
       event
     );
   }
+  /**
+   * Return a serialized representation of the logger that can be used to start subspans in other places. See `Span.start_span` for more details.
+   */
+  async export() {
+    return new SpanParentComponents({
+      objectType: this.spanParentObjectType(),
+      objectId: await this.id,
+      rowId: ""
+    }).toStr();
+  }
   /*
    * Flush any pending logs to the server.
    */
@@ -15631,8 +15806,10 @@ async function login(options = {}) {
     apiKey = isomorph_default.getEnv("BRAINTRUST_API_KEY"),
     orgName = isomorph_default.getEnv("BRAINTRUST_ORG_NAME")
   } = options || {};
+  const appPublicUrl = isomorph_default.getEnv("BRAINTRUST_APP_PUBLIC_URL") || appUrl;
   _state.resetLoginInfo();
   _state.appUrl = appUrl;
+  _state.appPublicUrl = appPublicUrl;
   let conn = null;
   if (apiKey !== void 0) {
     const resp = await checkResponse(
@@ -15708,7 +15885,33 @@ function getSpanParentObject(options) {
   return NOOP_SPAN;
 }
 function traced(callback, args) {
-  const { span, parentObject } = startSpanReturnParent(args);
+  const { span, isLogger } = (() => {
+    if (args?.parent) {
+      if (args?.parentId) {
+        throw new Error(
+          "Cannot specify both `parent` and `parent_id`. Prefer `parent`"
+        );
+      }
+      const components = SpanParentComponents.fromStr(args?.parent);
+      const span2 = new SpanImpl({
+        ...args,
+        parentObjectType: components.objectType,
+        parentObjectId: new LazyValue(async () => components.objectId),
+        parentRowId: components.rowId,
+        bgLogger: _state.globalBgLogger()
+      });
+      return {
+        span: span2,
+        isLogger: components.objectType === SpanParentObjectType.PROJECT_LOGS
+      };
+    } else {
+      const parentObject = getSpanParentObject({
+        asyncFlush: args?.asyncFlush
+      });
+      const span2 = parentObject.startSpan(args);
+      return { span: span2, isLogger: parentObject.kind === "logger" };
+    }
+  })();
   const ret = runFinally(
     () => {
       if (args?.setCurrent ?? true) {
@@ -15724,23 +15927,17 @@ function traced(callback, args) {
   } else {
     return (async () => {
       const awaitedRet = await ret;
-      if (parentObject.kind === "logger") {
-        await parentObject.flush();
+      if (isLogger) {
+        await span.flush();
       }
       return awaitedRet;
     })();
   }
 }
 function startSpan(args) {
-  return startSpanReturnParent(args).span;
-}
-function startSpanReturnParent(args) {
-  const parentObject = getSpanParentObject({
+  return getSpanParentObject({
     asyncFlush: args?.asyncFlush
-  });
-  const { name: nameOpt, ...argsRest } = args ?? {};
-  const name = parentObject.kind === "span" ? nameOpt : nameOpt ?? "root";
-  return { span: parentObject.startSpan({ name, ...argsRest }), parentObject };
+  }).startSpan(args);
 }
 function withCurrent(span, callback) {
   return _state.currentSpan.run(span, () => callback(span));
@@ -15922,6 +16119,8 @@ var Experiment = class extends ObjectFetcher {
   dataset;
   bgLogger;
   lastStartTime;
+  lazyId;
+  calledStartSpan;
   // For type identification.
   kind = "experiment";
   constructor(lazyMetadata, dataset) {
@@ -15933,6 +16132,8 @@ var Experiment = class extends ObjectFetcher {
     );
     this.bgLogger = new BackgroundLogger(logConn);
     this.lastStartTime = getCurrentUnixTimestamp();
+    this.lazyId = new LazyValue(async () => await this.id);
+    this.calledStartSpan = false;
   }
   get id() {
     return (async () => {
@@ -15949,6 +16150,9 @@ var Experiment = class extends ObjectFetcher {
       return (await this.lazyMetadata.get()).project;
     })();
   }
+  spanParentObjectType() {
+    return SpanParentObjectType.EXPERIMENT;
+  }
   async getState() {
     await this.lazyMetadata.get();
     return _state;
@@ -15967,20 +16171,17 @@ var Experiment = class extends ObjectFetcher {
    * @param event.dataset_record_id: (Optional) the id of the dataset record that this event is associated with. This field is required if and only if the experiment is associated with a dataset.
    * @param event.inputs: (Deprecated) the same as `input` (will be removed in a future version).
    * @param options Additional logging options
-   * @param options.allowLogConcurrentWithActiveSpan in rare cases where you need to log at the top level separately from an active span on the experiment, set this to true.
+   * @param options.allowConcurrentWithSpans in rare cases where you need to log at the top level separately from spans on the experiment elsewhere, set this to true.
    * :returns: The `id` of the logged event.
    */
   log(event, options) {
-    if (!options?.allowLogConcurrentWithActiveSpan) {
-      const checkCurrentSpan = currentSpan();
-      if (checkCurrentSpan instanceof SpanImpl && checkCurrentSpan.parentObject === this) {
-        throw new Error(
-          "Cannot run toplevel Experiment.log method while there is an active span. To log to the span, use Span.log"
-        );
-      }
+    if (this.calledStartSpan && !options?.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`"
+      );
     }
     event = validateAndSanitizeExperimentLogFullArgs(event, !!this.dataset);
-    const span = this.startSpan({ startTime: this.lastStartTime, event });
+    const span = this.startSpanImpl({ startTime: this.lastStartTime, event });
     this.lastStartTime = span.end();
     return span.id;
   }
@@ -16003,13 +16204,6 @@ var Experiment = class extends ObjectFetcher {
       () => span.end()
     );
   }
-  async lazyParentIds() {
-    return {
-      kind: "experiment",
-      project_id: (await this.project).id,
-      experiment_id: await this.id
-    };
-  }
   /**
    * Lower-level alternative to `traced`. This allows you to start a span yourself, and can be useful in situations
    * where you cannot use callbacks. However, spans started with `startSpan` will not be marked as the "current span",
@@ -16018,13 +16212,20 @@ var Experiment = class extends ObjectFetcher {
    * See `traced` for full details.
    */
   startSpan(args) {
-    const { name, ...argsRest } = args ?? {};
+    this.calledStartSpan = true;
+    return this.startSpanImpl(args);
+  }
+  startSpanImpl(args) {
     return new SpanImpl({
-      parentObject: this,
-      parentIds: new LazyValue(() => this.lazyParentIds()),
+      ...startSpanParentArgs({
+        parent: args?.parent,
+        parentId: args?.parentId,
+        spanParentObjectType: this.spanParentObjectType(),
+        spanParentObjectId: this.lazyId
+      }),
+      ...args,
       bgLogger: this.bgLogger,
-      name: name ?? "root",
-      ...argsRest
+      defaultRootType: SpanTypeAttribute.EVAL
     });
   }
   async fetchBaseExperiment() {
@@ -16059,10 +16260,10 @@ var Experiment = class extends ObjectFetcher {
     let { summarizeScores = true, comparisonExperimentId = void 0 } = options || {};
     await this.bgLogger.flush();
     const state = await this.getState();
-    const projectUrl = `${state.appUrl}/app/${encodeURIComponent(
+    const projectUrl = `${state.appPublicUrl}/app/${encodeURIComponent(
       state.orgName
     )}/p/${encodeURIComponent((await this.project).name)}`;
-    const experimentUrl = `${projectUrl}/${encodeURIComponent(
+    const experimentUrl = `${projectUrl}/experiments/${encodeURIComponent(
       await this.name
     )}`;
     let scores = void 0;
@@ -16095,7 +16296,7 @@ var Experiment = class extends ObjectFetcher {
       projectUrl,
       experimentUrl,
       comparisonExperimentName,
-      scores,
+      scores: scores ?? {},
       metrics
     };
   }
@@ -16113,10 +16314,21 @@ var Experiment = class extends ObjectFetcher {
   logFeedback(event) {
     logFeedbackImpl(
       this.bgLogger,
-      new LazyValue(() => this.lazyParentIds()),
+      this.spanParentObjectType(),
+      this.lazyId,
       event
     );
   }
+  /**
+   * Return a serialized representation of the experiment that can be used to start subspans in other places. See `Span.start_span` for more details.
+   */
+  async export() {
+    return new SpanParentComponents({
+      objectType: this.spanParentObjectType(),
+      objectId: await this.id,
+      rowId: ""
+    }).toStr();
+  }
   /**
    * Flush any pending rows to the server.
    */
@@ -16184,20 +16396,26 @@ var SpanImpl = class _SpanImpl {
   isMerge;
   loggedEndTime;
   // For internal use only.
-  parentObject;
-  // These fields are logged to every span row.
-  parentIds;
-  rowIds;
+  parentObjectType;
+  parentObjectId;
+  parentRowId;
+  _id;
   kind = "span";
-  // root_experiment should only be specified for a root span. parent_span
-  // should only be specified for non-root spans.
   constructor(args) {
+    const spanAttributes = args.spanAttributes ?? {};
+    const event = args.event ?? {};
+    const type = args.type ?? (args.parentRowId ? void 0 : args.defaultRootType);
     this.loggedEndTime = void 0;
+    this.parentObjectType = args.parentObjectType;
+    this.parentObjectId = args.parentObjectId;
+    this.parentRowId = args.parentRowId;
     this.bgLogger = args.bgLogger;
     const callerLocation = isomorph_default.getCallerLocation();
     const name = (() => {
       if (args.name)
         return args.name;
+      if (!args.parentRowId)
+        return "root";
       if (callerLocation) {
         const pathComponents = callerLocation.caller_filename.split("/");
         const filename = pathComponents[pathComponents.length - 1];
@@ -16213,71 +16431,52 @@ var SpanImpl = class _SpanImpl {
       },
       context: { ...callerLocation },
       span_attributes: {
-        ...args.spanAttributes,
         name,
+        type,
+        ...spanAttributes,
         exec_counter: executionCounter++
       },
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this.parentObject = args.parentObject;
-    this.parentIds = args.parentIds;
-    const id = args.event?.id ?? v4_default();
-    this.rowIds = { id };
-    const parentSpanInfo = "parentSpanInfo" in args ? args.parentSpanInfo : void 0;
-    const parentId = "parentId" in args ? args.parentId : void 0;
-    if (parentSpanInfo && parentId) {
-      throw new Error(
-        "Only one of parentSpanInfo and parentId may be specified"
-      );
-    }
-    if (parentId) {
-      this.rowIds[PARENT_ID_FIELD] = parentId;
-    } else {
-      this.rowIds.span_id = v4_default();
-      if (parentSpanInfo) {
-        this.rowIds.root_span_id = parentSpanInfo.root_span_id;
-        this.internalData.span_parents = [parentSpanInfo.span_id];
-      } else {
-        this.rowIds.root_span_id = this.rowIds.span_id;
-      }
-    }
+    this._id = event.id ?? v4_default();
     this.isMerge = false;
-    const { id: _id, ...eventRest } = args.event ?? {};
+    const { id: _id, ...eventRest } = event;
     this.log(eventRest);
     this.isMerge = true;
   }
   get id() {
-    return this.rowIds.id;
+    return this._id;
   }
   log(event) {
     const sanitized = validateAndSanitizeExperimentLogPartialArgs(event);
     let sanitizedAndInternalData = { ...this.internalData };
     mergeDicts(sanitizedAndInternalData, sanitized);
     this.internalData = {};
-    if (sanitizedAndInternalData.tags && sanitizedAndInternalData.tags.length > 0 && this.rowIds.span_id !== this.rowIds.root_span_id) {
-      throw new Error("Tags can only be logged to the root span");
-    }
     let partialRecord = {
       ...sanitizedAndInternalData,
-      ...this.rowIds,
       [IS_MERGE_FIELD]: this.isMerge
     };
+    const serializedPartialRecord = JSON.stringify(partialRecord);
+    partialRecord = JSON.parse(serializedPartialRecord);
     if (partialRecord.metrics?.end) {
       this.loggedEndTime = partialRecord.metrics?.end;
     }
-    const serializedPartialRecord = JSON.stringify(partialRecord);
-    partialRecord = JSON.parse(serializedPartialRecord);
-    const record = new LazyValue(async () => {
-      const { kind, ...parentIds } = await this.parentIds.get();
-      return {
-        ...partialRecord,
-        ...parentIds
-      };
+    if ((partialRecord.tags ?? []).length > 0 && this.parentRowId) {
+      throw new Error("Tags can only be logged to the root span");
+    }
+    const computeRecord = async () => ({
+      ...partialRecord,
+      ...new SpanParentComponents({
+        objectType: this.parentObjectType,
+        objectId: await this.parentObjectId.get(),
+        rowId: this.parentRowId
+      }).asDict(),
+      id: this.id
     });
-    this.bgLogger.log([record]);
+    this.bgLogger.log([new LazyValue(computeRecord)]);
   }
   logFeedback(event) {
-    logFeedbackImpl(this.bgLogger, this.parentIds, {
+    logFeedbackImpl(this.bgLogger, this.parentObjectType, this.parentObjectId, {
       ...event,
       id: this.id
     });
@@ -16297,25 +16496,15 @@ var SpanImpl = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentId = args?.parentId ?? (this.rowIds[PARENT_ID_FIELD] ? this.id : void 0);
-    const parentSpanInfo = (() => {
-      if (parentId)
-        return void 0;
-      if (!(this.rowIds.span_id && this.rowIds.root_span_id)) {
-        throw new Error("Impossible");
-      }
-      return {
-        span_id: this.rowIds.span_id,
-        root_span_id: this.rowIds.root_span_id
-      };
-    })();
     return new _SpanImpl({
-      parentObject: this.parentObject,
-      parentIds: this.parentIds,
-      bgLogger: this.bgLogger,
-      parentSpanInfo,
-      parentId,
-      ...args
+      ...args,
+      ...startSpanParentArgs({
+        parent: args?.parent,
+        parentId: args?.parentId ?? (args?.parent ? void 0 : this.id),
+        spanParentObjectType: this.parentObjectType,
+        spanParentObjectId: this.parentObjectId
+      }),
+      bgLogger: this.bgLogger
     });
   }
   end(args) {
@@ -16329,9 +16518,22 @@ var SpanImpl = class _SpanImpl {
     this.log({});
     return endTime;
   }
+  /**
+   * Return a serialized representation of the span that can be used to start subspans in other places. See `Span.start_span` for more details.
+   */
+  async export() {
+    return new SpanParentComponents({
+      objectType: this.parentObjectType,
+      objectId: await this.parentObjectId.get(),
+      rowId: this.id
+    }).toStr();
+  }
   close(args) {
     return this.end(args);
   }
+  async flush() {
+    return await this.bgLogger.flush();
+  }
 };
 var Dataset = class extends ObjectFetcher {
   lazyMetadata;
@@ -16418,7 +16620,6 @@ var Dataset = class extends ObjectFetcher {
       input,
       expected: expected === void 0 ? output : expected,
       tags,
-      project_id: (await this.project).id,
       dataset_id: await this.id,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       metadata
@@ -16429,7 +16630,6 @@ var Dataset = class extends ObjectFetcher {
   delete(id) {
     const args = new LazyValue(async () => ({
       id,
-      project_id: (await this.project).id,
       dataset_id: await this.id,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       _object_delete: true
@@ -16447,10 +16647,12 @@ var Dataset = class extends ObjectFetcher {
     let { summarizeData = true } = options || {};
     await this.bgLogger.flush();
     const state = await this.getState();
-    const projectUrl = `${state.appUrl}/app/${encodeURIComponent(
+    const projectUrl = `${state.appPublicUrl}/app/${encodeURIComponent(
       state.orgName
     )}/p/${encodeURIComponent((await this.project).name)}`;
-    const datasetUrl = `${projectUrl}/d/${encodeURIComponent(await this.name)}`;
+    const datasetUrl = `${projectUrl}/datasets/${encodeURIComponent(
+      await this.name
+    )}`;
     let dataSummary = void 0;
     if (summarizeData) {
       dataSummary = await state.logConn().get_json(
@@ -16530,7 +16732,7 @@ var Prompt = class {
       ...this.defaults,
       ...Object.fromEntries(
         Object.entries(this.options.params || {}).filter(
-          ([k, v]) => !BRAINTRUST_PARAMS.includes(k)
+          ([k, _v]) => !BRAINTRUST_PARAMS.includes(k)
         )
       ),
       ...!isEmpty(this.options.model) ? {
@@ -16564,9 +16766,14 @@ var Prompt = class {
           "Prompt is a completion prompt. Use buildCompletion() instead"
         );
       }
+      const render3 = (template) => mustache_default.render(template, buildArgs, void 0, {
+        escape: (v) => typeof v === "string" ? v : JSON.stringify(v)
+      });
       const messages = (prompt.messages || []).map((m) => ({
         ...m,
-        ..."content" in m && typeof m.content === "string" ? { content: mustache_default.render(m.content, buildArgs) } : {}
+        ..."content" in m ? {
+          content: typeof m.content === "string" ? render3(m.content) : JSON.parse(render3(JSON.stringify(m.content)))
+        } : {}
       }));
       return {
         ...params,
@@ -16662,25 +16869,37 @@ function initExperiment2(projectName, options = {}) {
     setCurrent: false
   });
 }
-globalThis._evals = {};
-async function Eval(name, evaluator) {
+globalThis._evals = {
+  evaluators: {},
+  reporters: {}
+};
+async function Eval(name, evaluator, reporter) {
   let evalName = makeEvalName(name, evaluator.experimentName);
-  if (_evals[evalName]) {
+  if (_evals.evaluators[evalName]) {
     evalName = `${evalName}_${Object.keys(_evals).length}`;
   }
   if (globalThis._lazy_load) {
-    _evals[evalName] = { evalName, projectName: name, ...evaluator };
+    _evals.evaluators[evalName] = {
+      evaluator: { evalName, projectName: name, ...evaluator },
+      reporter
+    };
     return {
-      projectName: "_lazy_load",
-      experimentName: "_lazy_load",
-      projectUrl: "",
-      experimentUrl: "",
-      comparisonExperimentName: "",
-      scores: {},
-      metrics: {}
+      summary: {
+        scores: {},
+        metrics: {},
+        projectName: "",
+        experimentName: ""
+      },
+      results: []
     };
   }
   const progressReporter = new BarProgressReporter();
+  if (typeof reporter === "string") {
+    throw new Error(
+      "Must specify a reporter object, not a name. Can only specify reporter names when running 'braintrust eval'"
+    );
+  }
+  const resolvedReporter = reporter || defaultReporter;
   try {
     const experiment = initExperiment2(name, {
       experiment: evaluator.experimentName,
@@ -16688,18 +16907,17 @@ async function Eval(name, evaluator) {
       isPublic: evaluator.isPublic
     });
     try {
-      const ret = await runEvaluator(
-        experiment,
-        {
-          evalName,
-          projectName: name,
-          ...evaluator
-        },
-        progressReporter,
-        []
-      );
-      reportEvaluatorResult(name, ret, { verbose: true, jsonl: false });
-      return ret.summary;
+      const evalDef = {
+        evalName,
+        projectName: name,
+        ...evaluator
+      };
+      const ret = await runEvaluator(experiment, evalDef, progressReporter, []);
+      resolvedReporter.reportEval(evalDef, ret, {
+        verbose: true,
+        jsonl: false
+      });
+      return ret;
     } finally {
       experiment.flush();
     }
@@ -16707,6 +16925,16 @@ async function Eval(name, evaluator) {
     progressReporter.stop();
   }
 }
+function Reporter(name, reporter) {
+  const ret = { name, ...reporter };
+  if (_evals.reporters[name]) {
+    throw new Error(`Reporter ${name} already exists`);
+  }
+  if (globalThis._lazy_load) {
+    _evals.reporters[name] = ret;
+  }
+  return ret;
+}
 function serializeJSONWithPlainString(v) {
   if (typeof v === "string") {
     return v;
@@ -16799,27 +17027,54 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
         const scoreResults = await Promise.all(
           evaluator.scores.map(async (score, score_idx) => {
             try {
-              const result = await rootSpan.traced(
+              const results2 = await rootSpan.traced(
                 async (span) => {
                   const scoreResult = score(scoringArgs);
                   const scoreValue = scoreResult instanceof Promise ? await scoreResult : scoreResult;
                   if (scoreValue === null) {
                     return null;
                   }
-                  const result2 = typeof scoreValue === "object" ? scoreValue : { name: scorerNames[score_idx], score: scoreValue };
-                  const {
-                    metadata: resultMetadata,
-                    name,
-                    ...resultRest
-                  } = result2;
+                  if (Array.isArray(scoreValue)) {
+                    for (const s of scoreValue) {
+                      if (!(typeof s === "object" && !isEmpty(s))) {
+                        throw new Error(
+                          `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(
+                            s
+                          )}`
+                        );
+                      }
+                    }
+                  }
+                  const results3 = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty(scoreValue) ? [scoreValue] : [
+                    {
+                      name: scorerNames[score_idx],
+                      score: scoreValue
+                    }
+                  ];
+                  const getOtherFields = (s) => {
+                    const { metadata: metadata2, name, ...rest } = s;
+                    return rest;
+                  };
+                  const resultMetadata = results3.length === 1 ? results3[0].metadata : results3.reduce(
+                    (prev, s) => mergeDicts(prev, {
+                      [s.name]: s.metadata
+                    }),
+                    {}
+                  );
+                  const resultOutput = results3.length === 1 ? getOtherFields(results3[0]) : results3.reduce(
+                    (prev, s) => mergeDicts(prev, { [s.name]: getOtherFields(s) }),
+                    {}
+                  );
+                  const scores2 = results3.reduce(
+                    (prev, s) => mergeDicts(prev, { [s.name]: s.score }),
+                    {}
+                  );
                   span.log({
-                    output: resultRest,
+                    output: resultOutput,
                     metadata: resultMetadata,
-                    scores: {
-                      [name]: resultRest.score
-                    }
+                    scores: scores2
                   });
-                  return result2;
+                  return results3;
                 },
                 {
                   name: scorerNames[score_idx],
@@ -16829,7 +17084,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
                   event: { input: scoringArgs }
                 }
               );
-              return { kind: "score", value: result };
+              return { kind: "score", value: results2 };
             } catch (e) {
               return { kind: "error", value: e };
             }
@@ -16837,12 +17092,18 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
         );
         const passingScorersAndResults = [];
         const failingScorersAndResults = [];
-        scoreResults.forEach((result, i) => {
+        scoreResults.forEach((results2, i) => {
           const name = scorerNames[i];
-          if (result.kind === "score") {
-            passingScorersAndResults.push({ name, score: result.value });
+          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: result.value });
+            failingScorersAndResults.push({ name, error: results2.value });
           }
         });
         if (failingScorersAndResults.length) {
@@ -16867,7 +17128,10 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
         progressReporter.increment(evaluator.evalName);
       }
       return {
+        input: datum.input,
+        ..."expected" in datum ? { expected: datum.expected } : {},
         output,
+        tags: datum.tags,
         metadata,
         scores,
         error: error2
@@ -16890,10 +17154,10 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
     }
   });
   const results = await Promise.all(evals);
-  const summary = experiment ? await experiment.summarize() : null;
+  const summary = experiment ? await experiment.summarize() : buildLocalSummary(evaluator, results);
   return {
-    results,
-    summary
+    summary,
+    results
   };
 }
 var error = import_chalk.default.bold.red;
@@ -16905,28 +17169,46 @@ function logError(e, verbose) {
     console.error(e);
   }
 }
-function reportEvaluatorResult(evaluatorName, evaluatorResult, {
-  verbose,
-  jsonl
-}) {
-  const { results, summary } = evaluatorResult;
-  const failingResults = results.filter(
-    (r) => r.error !== void 0
-  );
+function buildLocalSummary(evaluator, results) {
+  const scoresByName = {};
+  for (const result of results) {
+    for (const [name, score] of Object.entries(result.scores)) {
+      const { total, count } = scoresByName[name] || { total: 0, count: 0 };
+      if (score === null) {
+        continue;
+      }
+      scoresByName[name] = { total: total + score, count: count + 1 };
+    }
+  }
+  return {
+    projectName: evaluator.projectName,
+    experimentName: evaluator.evalName,
+    scores: Object.fromEntries(
+      Object.entries(scoresByName).map(([name, { total, count }]) => [
+        name,
+        {
+          name,
+          score: total / count
+        }
+      ])
+    )
+  };
+}
+function reportFailures(evaluator, failingResults, { verbose, jsonl }) {
   if (failingResults.length > 0) {
     console.error(
       warning(
-        `Evaluator ${evaluatorName} failed with ${(0, import_pluralize.default)(
+        `Evaluator ${evaluator.evalName} failed with ${(0, import_pluralize.default)(
           "error",
           failingResults.length,
           true
-        )}. This evaluation ("${evaluatorName}") will not be fully logged.`
+        )}. This evaluation ("${evaluator.evalName}") will not be fully logged.`
       )
     );
     if (jsonl) {
       console.log(
         JSON.stringify({
-          evaluatorName,
+          evaluatorName: evaluator.evalName,
           errors: failingResults.map(
             (r) => `${r.error instanceof Error ? r.error.stack : r.error}`
           )
@@ -16941,33 +17223,24 @@ function reportEvaluatorResult(evaluatorName, evaluatorResult, {
       console.error(warning("Add --verbose to see full stack traces."));
     }
   }
-  if (summary) {
-    console.log(jsonl ? JSON.stringify(summary) : summary);
-  } else {
-    const scoresByName = {};
-    for (const result of results) {
-      for (const [name, score] of Object.entries(result.scores)) {
-        const { total, count } = scoresByName[name] || { total: 0, count: 0 };
-        if (score === null) {
-          continue;
-        }
-        scoresByName[name] = { total: total + score, count: count + 1 };
-      }
+}
+var defaultReporter = {
+  name: "Braintrust default reporter",
+  async reportEval(evaluator, result, { verbose, jsonl }) {
+    const { results, summary } = result;
+    const failingResults = results.filter(
+      (r) => r.error !== void 0
+    );
+    if (failingResults.length > 0) {
+      reportFailures(evaluator, failingResults, { verbose, jsonl });
     }
-    const summary2 = {
-      scores: Object.fromEntries(
-        Object.entries(scoresByName).map(([name, { total, count }]) => [
-          name,
-          {
-            name,
-            score: total / count
-          }
-        ])
-      )
-    };
-    console.log(jsonl ? JSON.stringify(summary2) : summary2);
+    console.log(jsonl ? JSON.stringify(summary) : summary);
+    return failingResults.length === 0;
+  },
+  async reportRun(evalReports) {
+    return evalReports.every((r) => r);
   }
-}
+};
 
 // src/oai.ts
 function wrapOpenAI(openai) {
@@ -17085,7 +17358,7 @@ function wrapBetaChatCompletion(completion) {
     });
     ret.on("chatCompletion", (completion2) => {
       span.log({
-        output: completion2.choices[0]
+        output: completion2.choices
       });
     });
     ret.on("end", () => {
@@ -17113,8 +17386,8 @@ function wrapChatCompletion(completion) {
         span_info || {}
       )
     });
+    const startTime = getCurrentUnixTimestamp();
     if (params.stream) {
-      const startTime = getCurrentUnixTimestamp();
       const ret = await completion(
         params,
         options
@@ -17134,8 +17407,9 @@ function wrapChatCompletion(completion) {
           metadata: {
             ...rest2
           },
-          output: ret.choices[0],
+          output: ret.choices,
           metrics: {
+            time_to_first_token: getCurrentUnixTimestamp() - startTime,
             tokens: ret.usage?.total_tokens,
             prompt_tokens: ret.usage?.prompt_tokens,
             completion_tokens: ret.usage?.completion_tokens
@@ -17185,6 +17459,52 @@ function wrapEmbeddings(create) {
     );
   };
 }
+function postprocessStreamingResults(allResults) {
+  let role = void 0;
+  let content = void 0;
+  let tool_calls = void 0;
+  let finish_reason = void 0;
+  for (const result of allResults) {
+    const delta = result.choices?.[0]?.delta;
+    if (!delta) {
+      continue;
+    }
+    if (!role && delta.role) {
+      role = delta.role;
+    }
+    if (delta.finish_reason) {
+      finish_reason = delta.finish_reason;
+    }
+    if (delta.content) {
+      content = (content || "") + delta.content;
+    }
+    if (delta.tool_calls) {
+      if (!tool_calls) {
+        tool_calls = [
+          {
+            id: delta.tool_calls[0].id,
+            type: delta.tool_calls[0].type,
+            function: delta.tool_calls[0].function
+          }
+        ];
+      } else {
+        tool_calls[0].function.arguments += delta.tool_calls[0].function.arguments;
+      }
+    }
+  }
+  return [
+    {
+      index: 0,
+      message: {
+        role,
+        content,
+        tool_calls
+      },
+      logprobs: null,
+      finish_reason
+    }
+  ];
+}
 var WrapperStream = class {
   span;
   iter;
@@ -17212,7 +17532,7 @@ var WrapperStream = class {
         yield item;
       }
       this.span.log({
-        output: allResults
+        output: postprocessStreamingResults(allResults)
       });
     } finally {
       this.span.end();
@@ -17225,6 +17545,7 @@ configureNode();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseExperiment,
+  Dataset,
   Eval,
   Experiment,
   Logger,
@@ -17232,9 +17553,11 @@ configureNode();
   NoopSpan,
   Prompt,
   ReadonlyExperiment,
+  Reporter,
   SpanImpl,
   _internalGetGlobalState,
   _internalSetInitialState,
+  buildLocalSummary,
   currentExperiment,
   currentLogger,
   currentSpan,
@@ -17246,6 +17569,7 @@ configureNode();
   loadPrompt,
   log,
   login,
+  reportFailures,
   startSpan,
   summarize,
   traced,