braintrust 0.2.3 → 0.2.5

package/dist/index.mjs

@@ -481,15 +481,15 @@ function mergeTwoObjects(one, two, level = 0, objects) {
       for (let i = 0, j = two.length; i < j; i++) {
         result.push(takeValue(two[i]));
       }
-    } else if (isObject2(two)) {
+    } else if (isObject3(two)) {
       const keys = Object.keys(two);
       for (let i = 0, j = keys.length; i < j; i++) {
         const key = keys[i];
         result[key] = takeValue(two[key]);
       }
     }
-  } else if (isObject2(one)) {
-    if (isObject2(two)) {
+  } else if (isObject3(one)) {
+    if (isObject3(two)) {
       if (!shouldMerge(one, two)) {
         return two;
       }
@@ -510,7 +510,7 @@ function mergeTwoObjects(one, two, level = 0, objects) {
           if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
             delete result[key];
           } else {
-            if (isObject2(obj1) && isObject2(obj2)) {
+            if (isObject3(obj1) && isObject3(obj2)) {
               const arr1 = objects.get(obj1) || [];
               const arr2 = objects.get(obj2) || [];
               arr1.push({ obj: one, key });
@@ -544,7 +544,7 @@ function isArray2(value) {
 function isFunction(value) {
   return typeof value === "function";
 }
-function isObject2(value) {
+function isObject3(value) {
   return !isPrimitive(value) && !isArray2(value) && !isFunction(value) && typeof value === "object";
 }
 function isPrimitive(value) {
@@ -3198,6 +3198,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
+import * as fsSync from "node:fs";
 import * as crypto from "node:crypto";
 
 // src/isomorph.ts
@@ -3519,64 +3520,1264 @@ import {
   isArray,
   isObject
 } from "@braintrust/core";
-import {
-  attachmentReferenceSchema,
-  responseFormatJsonSchemaSchema,
-  attachmentStatusSchema,
-  BRAINTRUST_ATTACHMENT,
-  BRAINTRUST_PARAMS,
-  gitMetadataSettingsSchema,
-  promptDataSchema,
-  promptSchema,
-  toolsSchema,
-  EXTERNAL_ATTACHMENT
-} from "@braintrust/core/typespecs";
-import { waitUntil } from "@vercel/functions";
-import Mustache2 from "mustache";
-import { z as z2, ZodError } from "zod";
 
-// src/functions/stream.ts
-import {
-  callEventSchema,
-  sseConsoleEventDataSchema,
-  sseProgressEventDataSchema
-} from "@braintrust/core/typespecs";
-import {
-  createParser
-} from "eventsource-parser";
+// src/generated_types.ts
 import { z } from "zod";
-var braintrustStreamChunkSchema = z.union([
+var AclObjectType = z.union([
+  z.enum([
+    "organization",
+    "project",
+    "experiment",
+    "dataset",
+    "prompt",
+    "prompt_session",
+    "group",
+    "role",
+    "org_member",
+    "project_log",
+    "org_project"
+  ]),
+  z.null()
+]);
+var Permission = z.enum([
+  "create",
+  "read",
+  "update",
+  "delete",
+  "create_acls",
+  "read_acls",
+  "update_acls",
+  "delete_acls"
+]);
+var Acl = z.object({
+  id: z.string().uuid(),
+  object_type: AclObjectType.and(z.string()),
+  object_id: z.string().uuid(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  group_id: z.union([z.string(), z.null()]).optional(),
+  permission: Permission.and(z.union([z.string(), z.null()])).optional(),
+  restrict_object_type: AclObjectType.and(z.unknown()).optional(),
+  role_id: z.union([z.string(), z.null()]).optional(),
+  _object_org_id: z.string().uuid(),
+  created: z.union([z.string(), z.null()]).optional()
+});
+var AISecret = z.object({
+  id: z.string().uuid(),
+  created: z.union([z.string(), z.null()]).optional(),
+  updated_at: z.union([z.string(), z.null()]).optional(),
+  org_id: z.string().uuid(),
+  name: z.string(),
+  type: z.union([z.string(), z.null()]).optional(),
+  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
+  preview_secret: z.union([z.string(), z.null()]).optional()
+});
+var ResponseFormatJsonSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  schema: z.union([z.object({}).partial().passthrough(), z.string()]).optional(),
+  strict: z.union([z.boolean(), z.null()]).optional()
+});
+var ResponseFormat = z.union([
+  z.object({ type: z.literal("json_object") }),
+  z.object({
+    type: z.literal("json_schema"),
+    json_schema: ResponseFormatJsonSchema
+  }),
+  z.object({ type: z.literal("text") }),
+  z.null()
+]);
+var AnyModelParams = z.object({
+  temperature: z.number().optional(),
+  top_p: z.number().optional(),
+  max_tokens: z.number(),
+  max_completion_tokens: z.number().optional(),
+  frequency_penalty: z.number().optional(),
+  presence_penalty: z.number().optional(),
+  response_format: ResponseFormat.optional(),
+  tool_choice: z.union([
+    z.literal("auto"),
+    z.literal("none"),
+    z.literal("required"),
+    z.object({
+      type: z.literal("function"),
+      function: z.object({ name: z.string() })
+    })
+  ]).optional(),
+  function_call: z.union([
+    z.literal("auto"),
+    z.literal("none"),
+    z.object({ name: z.string() })
+  ]).optional(),
+  n: z.number().optional(),
+  stop: z.array(z.string()).optional(),
+  reasoning_effort: z.enum(["minimal", "low", "medium", "high"]).optional(),
+  verbosity: z.enum(["low", "medium", "high"]).optional(),
+  top_k: z.number().optional(),
+  stop_sequences: z.array(z.string()).optional(),
+  max_tokens_to_sample: z.number().optional(),
+  maxOutputTokens: z.number().optional(),
+  topP: z.number().optional(),
+  topK: z.number().optional(),
+  use_cache: z.boolean().optional()
+});
+var ApiKey = z.object({
+  id: z.string().uuid(),
+  created: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  preview_name: z.string(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  user_email: z.union([z.string(), z.null()]).optional(),
+  user_given_name: z.union([z.string(), z.null()]).optional(),
+  user_family_name: z.union([z.string(), z.null()]).optional(),
+  org_id: z.union([z.string(), z.null()]).optional()
+});
+var BraintrustAttachmentReference = z.object({
+  type: z.literal("braintrust_attachment"),
+  filename: z.string().min(1),
+  content_type: z.string().min(1),
+  key: z.string().min(1)
+});
+var ExternalAttachmentReference = z.object({
+  type: z.literal("external_attachment"),
+  filename: z.string().min(1),
+  content_type: z.string().min(1),
+  url: z.string().min(1)
+});
+var AttachmentReference = z.discriminatedUnion("type", [
+  BraintrustAttachmentReference,
+  ExternalAttachmentReference
+]);
+var UploadStatus = z.enum(["uploading", "done", "error"]);
+var AttachmentStatus = z.object({
+  upload_status: UploadStatus,
+  error_message: z.string().optional()
+});
+var BraintrustModelParams = z.object({ use_cache: z.boolean() }).partial();
+var CallEvent = z.union([
+  z.object({
+    id: z.string().optional(),
+    data: z.string(),
+    event: z.literal("text_delta")
+  }),
+  z.object({
+    id: z.string().optional(),
+    data: z.string(),
+    event: z.literal("reasoning_delta")
+  }),
+  z.object({
+    id: z.string().optional(),
+    data: z.string(),
+    event: z.literal("json_delta")
+  }),
+  z.object({
+    id: z.string().optional(),
+    data: z.string(),
+    event: z.literal("progress")
+  }),
+  z.object({
+    id: z.string().optional(),
+    data: z.string(),
+    event: z.literal("error")
+  }),
+  z.object({
+    id: z.string().optional(),
+    data: z.string(),
+    event: z.literal("console")
+  }),
+  z.object({
+    id: z.string().optional(),
+    event: z.literal("start"),
+    data: z.literal("")
+  }),
+  z.object({
+    id: z.string().optional(),
+    event: z.literal("done"),
+    data: z.literal("")
+  })
+]);
+var ChatCompletionContentPartTextWithTitle = z.object({
+  text: z.string().default(""),
+  type: z.literal("text"),
+  cache_control: z.object({ type: z.literal("ephemeral") }).optional()
+});
+var ChatCompletionContentPartImageWithTitle = z.object({
+  image_url: z.object({
+    url: z.string(),
+    detail: z.union([z.literal("auto"), z.literal("low"), z.literal("high")]).optional()
+  }),
+  type: z.literal("image_url")
+});
+var ChatCompletionContentPart = z.union([
+  ChatCompletionContentPartTextWithTitle,
+  ChatCompletionContentPartImageWithTitle
+]);
+var ChatCompletionContentPartText = z.object({
+  text: z.string().default(""),
+  type: z.literal("text"),
+  cache_control: z.object({ type: z.literal("ephemeral") }).optional()
+});
+var ChatCompletionMessageToolCall = z.object({
+  id: z.string(),
+  function: z.object({ arguments: z.string(), name: z.string() }),
+  type: z.literal("function")
+});
+var ChatCompletionMessageReasoning = z.object({ id: z.string(), content: z.string() }).partial();
+var ChatCompletionMessageParam = z.union([
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
+    role: z.literal("system"),
+    name: z.string().optional()
+  }),
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPart)]),
+    role: z.literal("user"),
+    name: z.string().optional()
+  }),
+  z.object({
+    role: z.literal("assistant"),
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText), z.null()]).optional(),
+    function_call: z.object({ arguments: z.string(), name: z.string() }).optional(),
+    name: z.string().optional(),
+    tool_calls: z.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: z.array(ChatCompletionMessageReasoning).optional()
+  }),
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
+    role: z.literal("tool"),
+    tool_call_id: z.string().default("")
+  }),
+  z.object({
+    content: z.union([z.string(), z.null()]),
+    name: z.string(),
+    role: z.literal("function")
+  }),
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
+    role: z.literal("developer"),
+    name: z.string().optional()
+  }),
+  z.object({
+    role: z.literal("model"),
+    content: z.union([z.string(), z.null()]).optional()
+  })
+]);
+var ChatCompletionOpenAIMessageParam = z.union([
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
+    role: z.literal("system"),
+    name: z.string().optional()
+  }),
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPart)]),
+    role: z.literal("user"),
+    name: z.string().optional()
+  }),
+  z.object({
+    role: z.literal("assistant"),
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText), z.null()]).optional(),
+    function_call: z.object({ arguments: z.string(), name: z.string() }).optional(),
+    name: z.string().optional(),
+    tool_calls: z.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: z.array(ChatCompletionMessageReasoning).optional()
+  }),
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
+    role: z.literal("tool"),
+    tool_call_id: z.string().default("")
+  }),
+  z.object({
+    content: z.union([z.string(), z.null()]),
+    name: z.string(),
+    role: z.literal("function")
+  }),
+  z.object({
+    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
+    role: z.literal("developer"),
+    name: z.string().optional()
+  })
+]);
+var ChatCompletionTool = z.object({
+  function: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    parameters: z.object({}).partial().passthrough().optional()
+  }),
+  type: z.literal("function")
+});
+var CodeBundle = z.object({
+  runtime_context: z.object({
+    runtime: z.enum(["node", "python"]),
+    version: z.string()
+  }),
+  location: z.union([
+    z.object({
+      type: z.literal("experiment"),
+      eval_name: z.string(),
+      position: z.union([
+        z.object({ type: z.literal("task") }),
+        z.object({ type: z.literal("scorer"), index: z.number().int().gte(0) })
+      ])
+    }),
+    z.object({ type: z.literal("function"), index: z.number().int().gte(0) })
+  ]),
+  bundle_id: z.string(),
+  preview: z.union([z.string(), z.null()]).optional()
+});
+var Dataset = z.object({
+  id: z.string().uuid(),
+  project_id: z.string().uuid(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  deleted_at: z.union([z.string(), z.null()]).optional(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
+});
+var ObjectReference = z.union([
+  z.object({
+    object_type: z.enum([
+      "project_logs",
+      "experiment",
+      "dataset",
+      "prompt",
+      "function",
+      "prompt_session"
+    ]),
+    object_id: z.string().uuid(),
+    id: z.string(),
+    _xact_id: z.union([z.string(), z.null()]).optional(),
+    created: z.union([z.string(), z.null()]).optional()
+  }),
+  z.null()
+]);
+var DatasetEvent = z.object({
+  id: z.string(),
+  _xact_id: z.string(),
+  created: z.string().datetime({ offset: true }),
+  _pagination_key: z.union([z.string(), z.null()]).optional(),
+  project_id: z.string().uuid(),
+  dataset_id: z.string().uuid(),
+  input: z.unknown().optional(),
+  expected: z.unknown().optional(),
+  metadata: z.union([
+    z.object({ model: z.union([z.string(), z.null()]) }).partial().passthrough(),
+    z.null()
+  ]).optional(),
+  tags: z.union([z.array(z.string()), z.null()]).optional(),
+  span_id: z.string(),
+  root_span_id: z.string(),
+  is_root: z.union([z.boolean(), z.null()]).optional(),
+  origin: ObjectReference.optional()
+});
+var EnvVar = z.object({
+  id: z.string().uuid(),
+  object_type: z.enum(["organization", "project", "function"]),
+  object_id: z.string().uuid(),
+  name: z.string(),
+  created: z.union([z.string(), z.null()]).optional(),
+  used: z.union([z.string(), z.null()]).optional()
+});
+var RepoInfo = z.union([
+  z.object({
+    commit: z.union([z.string(), z.null()]),
+    branch: z.union([z.string(), z.null()]),
+    tag: z.union([z.string(), z.null()]),
+    dirty: z.union([z.boolean(), z.null()]),
+    author_name: z.union([z.string(), z.null()]),
+    author_email: z.union([z.string(), z.null()]),
+    commit_message: z.union([z.string(), z.null()]),
+    commit_time: z.union([z.string(), z.null()]),
+    git_diff: z.union([z.string(), z.null()])
+  }).partial(),
+  z.null()
+]);
+var Experiment = z.object({
+  id: z.string().uuid(),
+  project_id: z.string().uuid(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  repo_info: RepoInfo.optional(),
+  commit: z.union([z.string(), z.null()]).optional(),
+  base_exp_id: z.union([z.string(), z.null()]).optional(),
+  deleted_at: z.union([z.string(), z.null()]).optional(),
+  dataset_id: z.union([z.string(), z.null()]).optional(),
+  dataset_version: z.union([z.string(), z.null()]).optional(),
+  public: z.boolean(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
+  tags: z.union([z.array(z.string()), z.null()]).optional()
+});
+var SpanType = z.union([
+  z.enum(["llm", "score", "function", "eval", "task", "tool"]),
+  z.null()
+]);
+var SpanAttributes = z.union([
+  z.object({ name: z.union([z.string(), z.null()]), type: SpanType }).partial().passthrough(),
+  z.null()
+]);
+var ExperimentEvent = z.object({
+  id: z.string(),
+  _xact_id: z.string(),
+  created: z.string().datetime({ offset: true }),
+  _pagination_key: z.union([z.string(), z.null()]).optional(),
+  project_id: z.string().uuid(),
+  experiment_id: z.string().uuid(),
+  input: z.unknown().optional(),
+  output: z.unknown().optional(),
+  expected: z.unknown().optional(),
+  error: z.unknown().optional(),
+  scores: z.union([z.record(z.union([z.number(), z.null()])), z.null()]).optional(),
+  metadata: z.union([
+    z.object({ model: z.union([z.string(), z.null()]) }).partial().passthrough(),
+    z.null()
+  ]).optional(),
+  tags: z.union([z.array(z.string()), z.null()]).optional(),
+  metrics: z.union([z.record(z.number()), z.null()]).optional(),
+  context: z.union([
+    z.object({
+      caller_functionname: z.union([z.string(), z.null()]),
+      caller_filename: z.union([z.string(), z.null()]),
+      caller_lineno: z.union([z.number(), z.null()])
+    }).partial().passthrough(),
+    z.null()
+  ]).optional(),
+  span_id: z.string(),
+  span_parents: z.union([z.array(z.string()), z.null()]).optional(),
+  root_span_id: z.string(),
+  span_attributes: SpanAttributes.optional(),
+  is_root: z.union([z.boolean(), z.null()]).optional(),
+  origin: ObjectReference.optional()
+});
+var ExtendedSavedFunctionId = z.union([
+  z.object({ type: z.literal("function"), id: z.string() }),
+  z.object({ type: z.literal("global"), name: z.string() }),
+  z.object({
+    type: z.literal("slug"),
+    project_id: z.string(),
+    slug: z.string()
+  })
+]);
+var PromptBlockDataNullish = z.union([
+  z.object({ type: z.literal("completion"), content: z.string() }),
+  z.object({
+    type: z.literal("chat"),
+    messages: z.array(ChatCompletionMessageParam),
+    tools: z.string().optional()
+  }),
+  z.null()
+]);
+var ModelParams = z.union([
+  z.object({
+    use_cache: z.boolean(),
+    temperature: z.number(),
+    top_p: z.number(),
+    max_tokens: z.number(),
+    max_completion_tokens: z.number(),
+    frequency_penalty: z.number(),
+    presence_penalty: z.number(),
+    response_format: ResponseFormat,
+    tool_choice: z.union([
+      z.literal("auto"),
+      z.literal("none"),
+      z.literal("required"),
+      z.object({
+        type: z.literal("function"),
+        function: z.object({ name: z.string() })
+      })
+    ]),
+    function_call: z.union([
+      z.literal("auto"),
+      z.literal("none"),
+      z.object({ name: z.string() })
+    ]),
+    n: z.number(),
+    stop: z.array(z.string()),
+    reasoning_effort: z.enum(["minimal", "low", "medium", "high"]),
+    verbosity: z.enum(["low", "medium", "high"])
+  }).partial().passthrough(),
+  z.object({
+    use_cache: z.boolean().optional(),
+    max_tokens: z.number(),
+    temperature: z.number(),
+    top_p: z.number().optional(),
+    top_k: z.number().optional(),
+    stop_sequences: z.array(z.string()).optional(),
+    max_tokens_to_sample: z.number().optional()
+  }).passthrough(),
+  z.object({
+    use_cache: z.boolean(),
+    temperature: z.number(),
+    maxOutputTokens: z.number(),
+    topP: z.number(),
+    topK: z.number()
+  }).partial().passthrough(),
+  z.object({
+    use_cache: z.boolean(),
+    temperature: z.number(),
+    topK: z.number()
+  }).partial().passthrough(),
+  z.object({ use_cache: z.boolean() }).partial().passthrough()
+]);
+var PromptOptionsNullish = z.union([
+  z.object({ model: z.string(), params: ModelParams, position: z.string() }).partial(),
+  z.null()
+]);
+var PromptParserNullish = z.union([
+  z.object({
+    type: z.literal("llm_classifier"),
+    use_cot: z.boolean(),
+    choice_scores: z.record(z.number().gte(0).lte(1))
+  }),
+  z.null()
+]);
+var SavedFunctionId = z.union([
+  z.object({ type: z.literal("function"), id: z.string() }),
+  z.object({ type: z.literal("global"), name: z.string() })
+]);
+var PromptDataNullish = z.union([
+  z.object({
+    prompt: PromptBlockDataNullish,
+    options: PromptOptionsNullish,
+    parser: PromptParserNullish,
+    tool_functions: z.union([z.array(SavedFunctionId), z.null()]),
+    origin: z.union([
+      z.object({
+        prompt_id: z.string(),
+        project_id: z.string(),
+        prompt_version: z.string()
+      }).partial(),
+      z.null()
+    ])
+  }).partial(),
+  z.null()
+]);
+var FunctionTypeEnumNullish = z.union([
+  z.enum(["llm", "scorer", "task", "tool"]),
+  z.null()
+]);
+var FunctionIdRef = z.object({}).partial().passthrough();
+var PromptBlockData = z.union([
+  z.object({ type: z.literal("completion"), content: z.string() }),
   z.object({
-    type: z.literal("text_delta"),
-    data: z.string()
+    type: z.literal("chat"),
+    messages: z.array(ChatCompletionMessageParam),
+    tools: z.string().optional()
+  })
+]);
+var GraphNode = z.union([
+  z.object({
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("function"),
+    function: FunctionIdRef
   }),
   z.object({
-    type: z.literal("reasoning_delta"),
-    data: z.string()
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("input")
   }),
   z.object({
-    type: z.literal("json_delta"),
-    data: z.string()
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("output")
   }),
   z.object({
-    type: z.literal("error"),
-    data: z.string()
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("literal"),
+    value: z.unknown().optional()
   }),
   z.object({
-    type: z.literal("console"),
-    data: sseConsoleEventDataSchema
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("btql"),
+    expr: z.string()
   }),
   z.object({
-    type: z.literal("progress"),
-    data: sseProgressEventDataSchema
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("gate"),
+    condition: z.union([z.string(), z.null()]).optional()
   }),
   z.object({
-    type: z.literal("start"),
-    data: z.string()
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("aggregator")
   }),
   z.object({
-    type: z.literal("done"),
-    data: z.string()
+    description: z.union([z.string(), z.null()]).optional(),
+    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
+    type: z.literal("prompt_template"),
+    prompt: PromptBlockData
+  })
+]);
+var GraphEdge = z.object({
+  source: z.object({ node: z.string().max(1024), variable: z.string() }),
+  target: z.object({ node: z.string().max(1024), variable: z.string() }),
+  purpose: z.enum(["control", "data", "messages"])
+});
+var GraphData = z.object({
+  type: z.literal("graph"),
+  nodes: z.record(GraphNode),
+  edges: z.record(GraphEdge)
+});
+var FunctionData = z.union([
+  z.object({ type: z.literal("prompt") }),
+  z.object({
+    type: z.literal("code"),
+    data: z.union([
+      z.object({ type: z.literal("bundle") }).and(CodeBundle),
+      z.object({
+        type: z.literal("inline"),
+        runtime_context: z.object({
+          runtime: z.enum(["node", "python"]),
+          version: z.string()
+        }),
+        code: z.string()
+      })
+    ])
+  }),
+  GraphData,
+  z.object({
+    type: z.literal("remote_eval"),
+    endpoint: z.string(),
+    eval_name: z.string(),
+    parameters: z.object({}).partial().passthrough()
+  }),
+  z.object({ type: z.literal("global"), name: z.string() })
+]);
+var Function2 = z.object({
+  id: z.string().uuid(),
+  _xact_id: z.string(),
+  project_id: z.string().uuid(),
+  log_id: z.literal("p"),
+  org_id: z.string().uuid(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  prompt_data: PromptDataNullish.optional(),
+  tags: z.union([z.array(z.string()), z.null()]).optional(),
+  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
+  function_type: FunctionTypeEnumNullish.optional(),
+  function_data: FunctionData,
+  origin: z.union([
+    z.object({
+      object_type: AclObjectType.and(z.string()),
+      object_id: z.string().uuid(),
+      internal: z.union([z.boolean(), z.null()]).optional()
+    }),
+    z.null()
+  ]).optional(),
+  function_schema: z.union([
+    z.object({ parameters: z.unknown(), returns: z.unknown() }).partial(),
+    z.null()
+  ]).optional()
+});
+var FunctionFormat = z.enum(["llm", "code", "global", "graph"]);
+var PromptData = z.object({
+  prompt: PromptBlockDataNullish,
+  options: PromptOptionsNullish,
+  parser: PromptParserNullish,
+  tool_functions: z.union([z.array(SavedFunctionId), z.null()]),
+  origin: z.union([
+    z.object({
+      prompt_id: z.string(),
+      project_id: z.string(),
+      prompt_version: z.string()
+    }).partial(),
+    z.null()
+  ])
+}).partial();
+var FunctionTypeEnum = z.enum(["llm", "scorer", "task", "tool"]);
+var FunctionId = z.union([
+  z.object({ function_id: z.string(), version: z.string().optional() }),
+  z.object({
+    project_name: z.string(),
+    slug: z.string(),
+    version: z.string().optional()
+  }),
+  z.object({ global_function: z.string() }),
+  z.object({
+    prompt_session_id: z.string(),
+    prompt_session_function_id: z.string(),
+    version: z.string().optional()
+  }),
+  z.object({
+    inline_context: z.object({
+      runtime: z.enum(["node", "python"]),
+      version: z.string()
+    }),
+    code: z.string(),
+    name: z.union([z.string(), z.null()]).optional()
+  }),
+  z.object({
+    inline_prompt: PromptData.optional(),
+    inline_function: z.object({}).partial().passthrough(),
+    function_type: FunctionTypeEnum.optional(),
+    name: z.union([z.string(), z.null()]).optional()
+  }),
+  z.object({
+    inline_prompt: PromptData,
+    function_type: FunctionTypeEnum.optional(),
+    name: z.union([z.string(), z.null()]).optional()
+  })
+]);
+var FunctionObjectType = z.enum([
+  "prompt",
+  "tool",
+  "scorer",
+  "task",
+  "agent"
+]);
+var FunctionOutputType = z.enum(["completion", "score", "any"]);
+var GitMetadataSettings = z.object({
+  collect: z.enum(["all", "none", "some"]),
+  fields: z.array(
+    z.enum([
+      "commit",
+      "branch",
+      "tag",
+      "dirty",
+      "author_name",
+      "author_email",
+      "commit_message",
+      "commit_time",
+      "git_diff"
+    ])
+  ).optional()
+});
+var Group = z.object({
+  id: z.string().uuid(),
+  org_id: z.string().uuid(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  deleted_at: z.union([z.string(), z.null()]).optional(),
+  member_users: z.union([z.array(z.string().uuid()), z.null()]).optional(),
+  member_groups: z.union([z.array(z.string().uuid()), z.null()]).optional()
+});
+var IfExists = z.enum(["error", "ignore", "replace"]);
+var InvokeParent = z.union([
+  z.object({
+    object_type: z.enum(["project_logs", "experiment", "playground_logs"]),
+    object_id: z.string(),
+    row_ids: z.union([
+      z.object({
+        id: z.string(),
+        span_id: z.string(),
+        root_span_id: z.string()
+      }),
+      z.null()
+    ]).optional(),
+    propagated_event: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
+  }),
+  z.string()
+]);
+var StreamingMode = z.union([z.enum(["auto", "parallel"]), z.null()]);
+var InvokeFunction = FunctionId.and(
+  z.object({
+    input: z.unknown(),
+    expected: z.unknown(),
+    metadata: z.union([z.object({}).partial().passthrough(), z.null()]),
+    tags: z.union([z.array(z.string()), z.null()]),
+    messages: z.array(ChatCompletionMessageParam),
+    parent: InvokeParent,
+    stream: z.union([z.boolean(), z.null()]),
+    mode: StreamingMode,
+    strict: z.union([z.boolean(), z.null()])
+  }).partial()
+);
+var MessageRole = z.enum([
+  "system",
+  "user",
+  "assistant",
+  "function",
+  "tool",
+  "model",
+  "developer"
+]);
+var OnlineScoreConfig = z.union([
+  z.object({
+    sampling_rate: z.number().gte(0).lte(1),
+    scorers: z.array(SavedFunctionId),
+    btql_filter: z.union([z.string(), z.null()]).optional(),
+    apply_to_root_span: z.union([z.boolean(), z.null()]).optional(),
+    apply_to_span_names: z.union([z.array(z.string()), z.null()]).optional(),
+    skip_logging: z.union([z.boolean(), z.null()]).optional()
+  }),
+  z.null()
+]);
+var Organization = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  api_url: z.union([z.string(), z.null()]).optional(),
+  is_universal_api: z.union([z.boolean(), z.null()]).optional(),
+  proxy_url: z.union([z.string(), z.null()]).optional(),
+  realtime_url: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional()
+});
+var ProjectSettings = z.union([
+  z.object({
+    comparison_key: z.union([z.string(), z.null()]),
+    baseline_experiment_id: z.union([z.string(), z.null()]),
+    spanFieldOrder: z.union([
+      z.array(
+        z.object({
+          object_type: z.string(),
+          column_id: z.string(),
+          position: z.string(),
+          layout: z.union([z.literal("full"), z.literal("two_column"), z.null()]).optional()
+        })
+      ),
+      z.null()
+    ]),
+    remote_eval_sources: z.union([
+      z.array(
+        z.object({
+          url: z.string(),
+          name: z.string(),
+          description: z.union([z.string(), z.null()]).optional()
+        })
+      ),
+      z.null()
+    ])
+  }).partial(),
+  z.null()
+]);
+var Project = z.object({
+  id: z.string().uuid(),
+  org_id: z.string().uuid(),
+  name: z.string(),
+  created: z.union([z.string(), z.null()]).optional(),
+  deleted_at: z.union([z.string(), z.null()]).optional(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  settings: ProjectSettings.optional()
+});
+var RetentionObjectType = z.enum([
+  "project_logs",
+  "experiment",
+  "dataset"
+]);
+var ProjectAutomation = z.object({
+  id: z.string().uuid(),
+  project_id: z.string().uuid(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  config: z.union([
+    z.object({
+      event_type: z.literal("logs"),
+      btql_filter: z.string(),
+      interval_seconds: z.number().gte(1).lte(2592e3),
+      action: z.object({ type: z.literal("webhook"), url: z.string() })
+    }),
+    z.object({
+      event_type: z.literal("btql_export"),
+      export_definition: z.union([
+        z.object({ type: z.literal("log_traces") }),
+        z.object({ type: z.literal("log_spans") }),
+        z.object({ type: z.literal("btql_query"), btql_query: z.string() })
+      ]),
+      export_path: z.string(),
+      format: z.enum(["jsonl", "parquet"]),
+      interval_seconds: z.number().gte(1).lte(2592e3),
+      credentials: z.object({
+        type: z.literal("aws_iam"),
+        role_arn: z.string(),
+        external_id: z.string()
+      }),
+      batch_size: z.union([z.number(), z.null()]).optional()
+    }),
+    z.object({
+      event_type: z.literal("retention"),
+      object_type: RetentionObjectType,
+      retention_days: z.number().gte(0)
+    })
+  ])
+});
+var ProjectLogsEvent = z.object({
+  id: z.string(),
+  _xact_id: z.string(),
+  _pagination_key: z.union([z.string(), z.null()]).optional(),
+  created: z.string().datetime({ offset: true }),
+  org_id: z.string().uuid(),
+  project_id: z.string().uuid(),
+  log_id: z.literal("g"),
+  input: z.unknown().optional(),
+  output: z.unknown().optional(),
+  expected: z.unknown().optional(),
+  error: z.unknown().optional(),
+  scores: z.union([z.record(z.union([z.number(), z.null()])), z.null()]).optional(),
+  metadata: z.union([
+    z.object({ model: z.union([z.string(), z.null()]) }).partial().passthrough(),
+    z.null()
+  ]).optional(),
+  tags: z.union([z.array(z.string()), z.null()]).optional(),
+  metrics: z.union([z.record(z.number()), z.null()]).optional(),
+  context: z.union([
+    z.object({
+      caller_functionname: z.union([z.string(), z.null()]),
+      caller_filename: z.union([z.string(), z.null()]),
+      caller_lineno: z.union([z.number(), z.null()])
+    }).partial().passthrough(),
+    z.null()
+  ]).optional(),
+  span_id: z.string(),
+  span_parents: z.union([z.array(z.string()), z.null()]).optional(),
+  root_span_id: z.string(),
+  is_root: z.union([z.boolean(), z.null()]).optional(),
+  span_attributes: SpanAttributes.optional(),
+  origin: ObjectReference.optional()
+});
+var ProjectScoreType = z.enum([
+  "slider",
+  "categorical",
+  "weighted",
+  "minimum",
+  "maximum",
+  "online",
+  "free-form"
+]);
+var ProjectScoreCategory = z.object({
+  name: z.string(),
+  value: z.number()
+});
+var ProjectScoreCategories = z.union([
+  z.array(ProjectScoreCategory),
+  z.record(z.number()),
+  z.array(z.string()),
+  z.null()
+]);
+var ProjectScoreConfig = z.union([
+  z.object({
+    multi_select: z.union([z.boolean(), z.null()]),
+    destination: z.union([z.string(), z.null()]),
+    online: OnlineScoreConfig
+  }).partial(),
+  z.null()
+]);
+var ProjectScore = z.object({
+  id: z.string().uuid(),
+  project_id: z.string().uuid(),
+  user_id: z.string().uuid(),
+  created: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  score_type: ProjectScoreType,
+  categories: ProjectScoreCategories.optional(),
+  config: ProjectScoreConfig.optional(),
+  position: z.union([z.string(), z.null()]).optional()
+});
+var ProjectTag = z.object({
+  id: z.string().uuid(),
+  project_id: z.string().uuid(),
+  user_id: z.string().uuid(),
+  created: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  color: z.union([z.string(), z.null()]).optional(),
+  position: z.union([z.string(), z.null()]).optional()
+});
+var Prompt = z.object({
+  id: z.string().uuid(),
+  _xact_id: z.string(),
+  project_id: z.string().uuid(),
+  log_id: z.literal("p"),
+  org_id: z.string().uuid(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  prompt_data: PromptDataNullish.optional(),
+  tags: z.union([z.array(z.string()), z.null()]).optional(),
+  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
+  function_type: FunctionTypeEnumNullish.optional()
+});
+var PromptOptions = z.object({ model: z.string(), params: ModelParams, position: z.string() }).partial();
+var PromptSessionEvent = z.object({
+  id: z.string(),
+  _xact_id: z.string(),
+  created: z.string().datetime({ offset: true }),
+  _pagination_key: z.union([z.string(), z.null()]).optional(),
+  project_id: z.string().uuid(),
+  prompt_session_id: z.string().uuid(),
+  prompt_session_data: z.unknown().optional(),
+  prompt_data: z.unknown().optional(),
+  function_data: z.unknown().optional(),
+  function_type: FunctionTypeEnumNullish.optional(),
+  object_data: z.unknown().optional(),
+  completion: z.unknown().optional(),
+  tags: z.union([z.array(z.string()), z.null()]).optional()
+});
+var Role = z.object({
+  id: z.string().uuid(),
+  org_id: z.union([z.string(), z.null()]).optional(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  deleted_at: z.union([z.string(), z.null()]).optional(),
+  member_permissions: z.union([
+    z.array(
+      z.object({
+        permission: Permission,
+        restrict_object_type: AclObjectType.optional()
+      })
+    ),
+    z.null()
+  ]).optional(),
+  member_roles: z.union([z.array(z.string().uuid()), z.null()]).optional()
+});
+var RunEval = z.object({
+  project_id: z.string(),
+  data: z.union([
+    z.object({
+      dataset_id: z.string(),
+      _internal_btql: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
+    }),
+    z.object({
+      project_name: z.string(),
+      dataset_name: z.string(),
+      _internal_btql: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
+    }),
+    z.object({ data: z.array(z.unknown()) })
+  ]),
+  task: FunctionId.and(z.unknown()),
+  scores: z.array(FunctionId),
+  experiment_name: z.string().optional(),
+  metadata: z.object({}).partial().passthrough().optional(),
+  parent: InvokeParent.and(z.unknown()).optional(),
+  stream: z.boolean().optional(),
+  trial_count: z.union([z.number(), z.null()]).optional(),
+  is_public: z.union([z.boolean(), z.null()]).optional(),
+  timeout: z.union([z.number(), z.null()]).optional(),
+  max_concurrency: z.union([z.number(), z.null()]).optional().default(10),
+  base_experiment_name: z.union([z.string(), z.null()]).optional(),
+  base_experiment_id: z.union([z.string(), z.null()]).optional(),
+  git_metadata_settings: GitMetadataSettings.and(
+    z.union([z.object({}).partial(), z.null()])
+  ).optional(),
+  repo_info: RepoInfo.and(z.unknown()).optional(),
+  strict: z.union([z.boolean(), z.null()]).optional(),
+  stop_token: z.union([z.string(), z.null()]).optional(),
+  extra_messages: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var ServiceToken = z.object({
+  id: z.string().uuid(),
+  created: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  preview_name: z.string(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  user_email: z.union([z.string(), z.null()]).optional(),
+  user_given_name: z.union([z.string(), z.null()]).optional(),
+  user_family_name: z.union([z.string(), z.null()]).optional(),
+  org_id: z.union([z.string(), z.null()]).optional()
+});
+var SpanIFrame = z.object({
+  id: z.string().uuid(),
+  project_id: z.string().uuid(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional(),
+  deleted_at: z.union([z.string(), z.null()]).optional(),
+  name: z.string(),
+  description: z.union([z.string(), z.null()]).optional(),
+  url: z.string(),
+  post_message: z.union([z.boolean(), z.null()]).optional()
+});
+var SSEConsoleEventData = z.object({
+  stream: z.enum(["stderr", "stdout"]),
+  message: z.string()
+});
+var SSEProgressEventData = z.object({
+  id: z.string(),
+  object_type: FunctionObjectType,
+  origin: ObjectReference.and(z.unknown()).optional(),
+  format: FunctionFormat,
+  output_type: FunctionOutputType,
+  name: z.string(),
+  event: z.enum([
+    "reasoning_delta",
+    "text_delta",
+    "json_delta",
+    "error",
+    "console",
+    "start",
+    "done",
+    "progress"
+  ]),
+  data: z.string()
+});
+var ToolFunctionDefinition = z.object({
+  type: z.literal("function"),
+  function: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    parameters: z.object({}).partial().passthrough().optional(),
+    strict: z.union([z.boolean(), z.null()]).optional()
+  })
+});
+var User = z.object({
+  id: z.string().uuid(),
+  given_name: z.union([z.string(), z.null()]).optional(),
+  family_name: z.union([z.string(), z.null()]).optional(),
+  email: z.union([z.string(), z.null()]).optional(),
+  avatar_url: z.union([z.string(), z.null()]).optional(),
+  created: z.union([z.string(), z.null()]).optional()
+});
+var ViewDataSearch = z.union([
+  z.object({
+    filter: z.union([z.array(z.unknown()), z.null()]),
+    tag: z.union([z.array(z.unknown()), z.null()]),
+    match: z.union([z.array(z.unknown()), z.null()]),
+    sort: z.union([z.array(z.unknown()), z.null()])
+  }).partial(),
+  z.null()
+]);
+var ViewData = z.union([
+  z.object({ search: ViewDataSearch }).partial(),
+  z.null()
+]);
+var ViewOptions = z.union([
+  z.object({
+    viewType: z.literal("monitor"),
+    options: z.object({
+      spanType: z.union([z.enum(["range", "frame"]), z.null()]),
+      rangeValue: z.union([z.string(), z.null()]),
+      frameStart: z.union([z.string(), z.null()]),
+      frameEnd: z.union([z.string(), z.null()]),
+      tzUTC: z.union([z.boolean(), z.null()]),
+      chartVisibility: z.union([z.record(z.boolean()), z.null()]),
+      projectId: z.union([z.string(), z.null()]),
+      type: z.union([z.enum(["project", "experiment"]), z.null()]),
+      groupBy: z.union([z.string(), z.null()])
+    }).partial()
+  }),
+  z.object({
+    columnVisibility: z.union([z.record(z.boolean()), z.null()]),
+    columnOrder: z.union([z.array(z.string()), z.null()]),
+    columnSizing: z.union([z.record(z.number()), z.null()]),
+    grouping: z.union([z.string(), z.null()]),
+    rowHeight: z.union([z.string(), z.null()]),
+    tallGroupRows: z.union([z.boolean(), z.null()]),
+    layout: z.union([z.string(), z.null()]),
+    chartHeight: z.union([z.number(), z.null()]),
+    excludedMeasures: z.union([
+      z.array(
+        z.object({
+          type: z.enum(["none", "score", "metric", "metadata"]),
+          value: z.string()
+        })
+      ),
+      z.null()
+    ]),
+    yMetric: z.union([
+      z.object({
+        type: z.enum(["none", "score", "metric", "metadata"]),
+        value: z.string()
+      }),
+      z.null()
+    ]),
+    xAxis: z.union([
+      z.object({
+        type: z.enum(["none", "score", "metric", "metadata"]),
+        value: z.string()
+      }),
+      z.null()
+    ]),
+    symbolGrouping: z.union([
+      z.object({
+        type: z.enum(["none", "score", "metric", "metadata"]),
+        value: z.string()
+      }),
+      z.null()
+    ]),
+    xAxisAggregation: z.union([z.string(), z.null()]),
+    chartAnnotations: z.union([
+      z.array(z.object({ id: z.string(), text: z.string() })),
+      z.null()
+    ]),
+    timeRangeFilter: z.union([
+      z.string(),
+      z.object({ from: z.string(), to: z.string() }),
+      z.null()
+    ])
+  }).partial(),
+  z.null()
+]);
+var View = z.object({
+  id: z.string().uuid(),
+  object_type: AclObjectType.and(z.string()),
+  object_id: z.string().uuid(),
+  view_type: z.enum([
+    "projects",
+    "experiments",
+    "experiment",
+    "playgrounds",
+    "playground",
+    "datasets",
+    "dataset",
+    "prompts",
+    "tools",
+    "scorers",
+    "logs",
+    "agents",
+    "monitor"
+  ]),
+  name: z.string(),
+  created: z.union([z.string(), z.null()]).optional(),
+  view_data: ViewData.optional(),
+  options: ViewOptions.optional(),
+  user_id: z.union([z.string(), z.null()]).optional(),
+  deleted_at: z.union([z.string(), z.null()]).optional()
+});
+
+// src/logger.ts
+import { waitUntil } from "@vercel/functions";
+import Mustache2 from "mustache";
+import { z as z3, ZodError } from "zod";
+
+// src/functions/stream.ts
+import {
+  createParser
+} from "eventsource-parser";
+import { z as z2 } from "zod";
+var braintrustStreamChunkSchema = z2.union([
+  z2.object({
+    type: z2.literal("text_delta"),
+    data: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("reasoning_delta"),
+    data: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("json_delta"),
+    data: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("error"),
+    data: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("console"),
+    data: SSEConsoleEventData
+  }),
+  z2.object({
+    type: z2.literal("progress"),
+    data: SSEProgressEventData
+  }),
+  z2.object({
+    type: z2.literal("start"),
+    data: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("done"),
+    data: z2.string()
   })
 ]);
 var BraintrustStream = class _BraintrustStream {
@@ -3684,12 +4885,12 @@ var BraintrustStream = class _BraintrustStream {
       case "progress":
         return {
           type: "progress",
-          data: sseProgressEventDataSchema.parse(JSON.parse(event.data))
+          data: SSEProgressEventData.parse(JSON.parse(event.data))
         };
       case "console":
         return {
           type: "console",
-          data: sseConsoleEventDataSchema.parse(JSON.parse(event.data))
+          data: SSEConsoleEventData.parse(JSON.parse(event.data))
         };
       case "start":
         return {
@@ -3765,7 +4966,7 @@ function btStreamParser() {
         if (event.type === "reconnect-interval") {
           return;
         }
-        const parsed = callEventSchema.safeParse(event);
+        const parsed = CallEvent.safeParse(event);
         if (!parsed.success) {
           throw new Error(`Failed to parse event: ${parsed.error}`);
         }
@@ -4196,6 +5397,44 @@ function getMustacheVars(prompt) {
 }
 
 // src/logger.ts
+import { prettifyXact } from "@braintrust/core";
+var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
+var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
+var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
+var REDACTION_FIELDS = [
+  "input",
+  "output",
+  "expected",
+  "metadata",
+  "context",
+  "scores",
+  "metrics"
+];
+var MaskingError = class {
+  constructor(fieldName, errorType) {
+    this.fieldName = fieldName;
+    this.errorType = errorType;
+  }
+  get errorMsg() {
+    return `ERROR: Failed to mask field '${this.fieldName}' - ${this.errorType}`;
+  }
+};
+function applyMaskingToField(maskingFunction, data, fieldName) {
+  try {
+    return maskingFunction(data);
+  } catch (error2) {
+    const errorType = error2 instanceof Error ? error2.constructor.name : "Error";
+    if (fieldName === "scores" || fieldName === "metrics") {
+      return new MaskingError(fieldName, errorType);
+    }
+    if (fieldName === "metadata") {
+      return {
+        error: `ERROR: Failed to mask field '${fieldName}' - ${errorType}`
+      };
+    }
+    return `ERROR: Failed to mask field '${fieldName}' - ${errorType}`;
+  }
+}
 var NoopSpan = class {
   id;
   spanId;
@@ -4246,15 +5485,15 @@ var NoopSpan = class {
 };
 var NOOP_SPAN = new NoopSpan();
 var NOOP_SPAN_PERMALINK = "https://braintrust.dev/noop-span";
-var loginSchema = z2.strictObject({
-  appUrl: z2.string(),
-  appPublicUrl: z2.string(),
-  orgName: z2.string(),
-  apiUrl: z2.string(),
-  proxyUrl: z2.string(),
-  loginToken: z2.string(),
-  orgId: z2.string().nullish(),
-  gitMetadataSettings: gitMetadataSettingsSchema.nullish()
+var loginSchema = z3.strictObject({
+  appUrl: z3.string(),
+  appPublicUrl: z3.string(),
+  orgName: z3.string(),
+  apiUrl: z3.string(),
+  proxyUrl: z3.string(),
+  loginToken: z3.string(),
+  orgId: z3.string().nullish(),
+  gitMetadataSettings: GitMetadataSettings.nullish()
 });
 var stateNonce = 0;
 var BraintrustState = class _BraintrustState {
@@ -4396,6 +5635,9 @@ var BraintrustState = class _BraintrustState {
     this._apiConn?.setFetch(fetch2);
     this._appConn?.setFetch(fetch2);
   }
+  setMaskingFunction(maskingFunction) {
+    this.bgLogger().setMaskingFunction(maskingFunction);
+  }
   async login(loginParams) {
     if (this.apiUrl && !loginParams.forceLogin) {
       return;
@@ -4474,6 +5716,18 @@ function useTestBackgroundLogger() {
 function clearTestBackgroundLogger() {
   _internalGetGlobalState()?.setOverrideBgLogger(null);
 }
+function initTestExperiment(experimentName, projectName) {
+  setInitialTestState();
+  const state = _internalGetGlobalState();
+  const project = projectName ?? experimentName;
+  const lazyMetadata = new LazyValue(
+    async () => ({
+      project: { id: project, name: project, fullInfo: {} },
+      experiment: { id: experimentName, name: experimentName, fullInfo: {} }
+    })
+  );
+  return new Experiment2(state, lazyMetadata);
+}
 function _internalSetInitialState() {
   if (_globalState) {
     console.warn(
@@ -4715,9 +5969,9 @@ var Attachment = class extends BaseAttachment {
       let signedUrl;
       let headers;
       try {
-        ({ signedUrl, headers } = z2.object({
-          signedUrl: z2.string().url(),
-          headers: z2.record(z2.string())
+        ({ signedUrl, headers } = z3.object({
+          signedUrl: z3.string().url(),
+          headers: z3.record(z3.string())
         }).parse(await metadataResponse.json()));
       } catch (error2) {
         if (error2 instanceof ZodError) {
@@ -4777,6 +6031,7 @@ var Attachment = class extends BaseAttachment {
   }
   initData(data) {
     if (typeof data === "string") {
+      this.ensureFileReadable(data);
       const readFile2 = isomorph_default.readFile;
       if (!readFile2) {
         throw new Error(
@@ -4789,6 +6044,20 @@ with a Blob/ArrayBuffer, or run the program on Node.js.`
       return new LazyValue(async () => new Blob([data]));
     }
   }
+  ensureFileReadable(data) {
+    const statSync2 = isomorph_default.statSync;
+    if (!statSync2) {
+      throw new Error(
+        `This platform does not support reading the filesystem. Construct the Attachment
+with a Blob/ArrayBuffer, or run the program on Node.js.`
+      );
+    }
+    try {
+      statSync2(data);
+    } catch (e) {
+      console.warn(`Failed to read file: ${e}`);
+    }
+  }
 };
 var ExternalAttachment = class extends BaseAttachment {
   /**
@@ -4857,9 +6126,9 @@ var ExternalAttachment = class extends BaseAttachment {
     });
   }
 };
-var attachmentMetadataSchema = z2.object({
-  downloadUrl: z2.string(),
-  status: attachmentStatusSchema
+var attachmentMetadataSchema = z3.object({
+  downloadUrl: z3.string(),
+  status: AttachmentStatus
 });
 var ReadonlyAttachment = class {
   /**
@@ -5398,9 +6667,13 @@ function now() {
 }
 var TestBackgroundLogger = class {
   items = [];
+  maskingFunction = null;
   log(items) {
     this.items.push(items);
   }
+  setMaskingFunction(maskingFunction) {
+    this.maskingFunction = maskingFunction;
+  }
   async flush() {
     return Promise.resolve();
   }
@@ -5414,7 +6687,34 @@ var TestBackgroundLogger = class {
       }
     }
     const batch = mergeRowBatch(events);
-    return batch.flat();
+    let flatBatch = batch.flat();
+    if (this.maskingFunction) {
+      flatBatch = flatBatch.map((item) => {
+        const maskedItem = { ...item };
+        for (const field of REDACTION_FIELDS) {
+          if (item[field] !== void 0) {
+            const maskedValue = applyMaskingToField(
+              this.maskingFunction,
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              item[field],
+              field
+            );
+            if (maskedValue instanceof MaskingError) {
+              delete maskedItem[field];
+              if (maskedItem.error) {
+                maskedItem.error = `${maskedItem.error}; ${maskedValue.errorMsg}`;
+              } else {
+                maskedItem.error = maskedValue.errorMsg;
+              }
+            } else {
+              maskedItem[field] = maskedValue;
+            }
+          }
+        }
+        return maskedItem;
+      });
+    }
+    return flatBatch;
   }
 };
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
@@ -5425,6 +6725,7 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
   activeFlushResolved = true;
   activeFlushError = void 0;
   onFlushError;
+  maskingFunction = null;
   syncFlush = false;
   // 6 MB for the AWS lambda gateway (from our own testing).
   maxRequestSize = 6 * 1024 * 1024;
@@ -5492,6 +6793,9 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
     }
     this.onFlushError = opts.onFlushError;
   }
+  setMaskingFunction(maskingFunction) {
+    this.maskingFunction = maskingFunction;
+  }
   log(items) {
     if (this._disabled) {
       return;
@@ -5588,7 +6892,36 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
         const items = await Promise.all(wrappedItems.map((x) => x.get()));
         const attachments = [];
         items.forEach((item) => extractAttachments(item, attachments));
-        return [mergeRowBatch(items), attachments];
+        let mergedItems = mergeRowBatch(items);
+        if (this.maskingFunction) {
+          mergedItems = mergedItems.map(
+            (batch) => batch.map((item) => {
+              const maskedItem = { ...item };
+              for (const field of REDACTION_FIELDS) {
+                if (item[field] !== void 0) {
+                  const maskedValue = applyMaskingToField(
+                    this.maskingFunction,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    item[field],
+                    field
+                  );
+                  if (maskedValue instanceof MaskingError) {
+                    delete maskedItem[field];
+                    if (maskedItem.error) {
+                      maskedItem.error = `${maskedItem.error}; ${maskedValue.errorMsg}`;
+                    } else {
+                      maskedItem.error = maskedValue.errorMsg;
+                    }
+                  } else {
+                    maskedItem[field] = maskedValue;
+                  }
+                }
+              }
+              return maskedItem;
+            })
+          );
+        }
+        return [mergedItems, attachments];
       } catch (e) {
         let errmsg = "Encountered error when constructing records to flush";
         const isRetrying = i + 1 < this.numTries;
@@ -5936,7 +7269,7 @@ function init(projectOrOptions, optionalOptions) {
       };
     }
   );
-  const ret = new Experiment(state, lazyMetadata, dataset);
+  const ret = new Experiment2(state, lazyMetadata, dataset);
   if (options.setCurrent ?? true) {
     state.currentExperiment = ret;
   }
@@ -6033,7 +7366,7 @@ function initDataset(projectOrOptions, optionalOptions) {
       };
     }
   );
-  return new Dataset(
+  return new Dataset2(
     stateArg ?? _globalState,
     lazyMetadata,
     version,
@@ -6229,8 +7562,8 @@ async function loadPrompt({
       );
     }
   }
-  const metadata = promptSchema.parse(response["objects"][0]);
-  const prompt = new Prompt(metadata, defaults || {}, noTrace);
+  const metadata = Prompt.parse(response["objects"][0]);
+  const prompt = new Prompt2(metadata, defaults || {}, noTrace);
   try {
     if (id) {
       await state.promptCache.set({ id }, prompt);
@@ -6245,6 +7578,9 @@ async function loadPrompt({
   }
   return prompt;
 }
+function setMaskingFunction(maskingFunction) {
+  _globalState.setMaskingFunction(maskingFunction);
+}
 async function login(options = {}) {
   const { forceLogin = false } = options || {};
   if (_globalState.loggedIn && !forceLogin) {
@@ -6769,13 +8105,13 @@ function validateAndSanitizeExperimentLogPartialArgs(event) {
 function deepCopyEvent(event) {
   const attachments = [];
   const IDENTIFIER = "_bt_internal_saved_attachment";
-  const savedAttachmentSchema = z2.strictObject({ [IDENTIFIER]: z2.number() });
+  const savedAttachmentSchema = z3.strictObject({ [IDENTIFIER]: z3.number() });
   const serialized = JSON.stringify(event, (_k, v) => {
     if (v instanceof SpanImpl || v instanceof NoopSpan) {
       return `<span>`;
-    } else if (v instanceof Experiment) {
+    } else if (v instanceof Experiment2) {
       return `<experiment>`;
-    } else if (v instanceof Dataset) {
+    } else if (v instanceof Dataset2) {
       return `<dataset>`;
     } else if (v instanceof Logger) {
       return `<logger>`;
@@ -6827,7 +8163,7 @@ function extractAttachments(event, attachments) {
 }
 function enrichAttachments(event, state) {
   for (const [key, value] of Object.entries(event)) {
-    const parsedValue = attachmentReferenceSchema.safeParse(value);
+    const parsedValue = AttachmentReference.safeParse(value);
     if (parsedValue.success) {
       event[key] = new ReadonlyAttachment(parsedValue.data, state);
       continue;
@@ -6970,7 +8306,7 @@ var ObjectFetcher = class {
     }
   }
 };
-var Experiment = class extends ObjectFetcher {
+var Experiment2 = class extends ObjectFetcher {
   lazyMetadata;
   dataset;
   lastStartTime;
@@ -7576,7 +8912,7 @@ function splitLoggingData({
   }
   return [serializableInternalData, lazyInternalData];
 }
-var Dataset = class extends ObjectFetcher {
+var Dataset2 = class extends ObjectFetcher {
   constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql) {
     const isLegacyDataset = legacy ?? DEFAULT_IS_LEGACY_DATASET;
     if (isLegacyDataset) {
@@ -7774,8 +9110,8 @@ var Dataset = class extends ObjectFetcher {
     )}`;
     let dataSummary;
     if (summarizeData) {
-      const rawDataSummary = z2.object({
-        total_records: z2.number()
+      const rawDataSummary = z3.object({
+        total_records: z3.number()
       }).parse(
         await state.apiConn().get_json(
           "dataset-summary",
@@ -7898,11 +9234,11 @@ function renderTemplatedObject(obj, args, options) {
   return obj;
 }
 function renderPromptParams(params, args, options) {
-  const schemaParsed = z2.object({
-    response_format: z2.object({
-      type: z2.literal("json_schema"),
-      json_schema: responseFormatJsonSchemaSchema.omit({ schema: true }).extend({
-        schema: z2.unknown()
+  const schemaParsed = z3.object({
+    response_format: z3.object({
+      type: z3.literal("json_schema"),
+      json_schema: ResponseFormatJsonSchema.omit({ schema: true }).extend({
+        schema: z3.unknown()
       })
     })
   }).safeParse(params);
@@ -7923,7 +9259,7 @@ function renderPromptParams(params, args, options) {
   }
   return params;
 }
-var Prompt = class _Prompt {
+var Prompt2 = class _Prompt {
   constructor(metadata, defaults, noTrace) {
     this.metadata = metadata;
     this.defaults = defaults;
@@ -8020,7 +9356,7 @@ var Prompt = class _Prompt {
     if (!prompt) {
       throw new Error("Empty prompt");
     }
-    const dictArgParsed = z2.record(z2.unknown()).safeParse(buildArgs);
+    const dictArgParsed = z3.record(z3.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -8041,7 +9377,7 @@ var Prompt = class _Prompt {
         ...spanInfo,
         messages: renderedPrompt.messages,
         ...renderedPrompt.tools ? {
-          tools: toolsSchema.parse(JSON.parse(renderedPrompt.tools))
+          tools: ChatCompletionTool.array().parse(JSON.parse(renderedPrompt.tools))
         } : void 0
       };
     } else if (flavor === "completion") {
@@ -8075,7 +9411,7 @@ var Prompt = class _Prompt {
         return JSON.stringify(v);
       }
     };
-    const dictArgParsed = z2.record(z2.unknown()).safeParse(buildArgs);
+    const dictArgParsed = z3.record(z3.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -8128,7 +9464,7 @@ var Prompt = class _Prompt {
   }
   getParsedPromptData() {
     if (!this.hasParsedPromptData) {
-      this.parsedPromptData = promptDataSchema.parse(this.metadata.prompt_data);
+      this.parsedPromptData = PromptData.parse(this.metadata.prompt_data);
       this.hasParsedPromptData = true;
     }
     return this.parsedPromptData;
@@ -8165,6 +9501,57 @@ function simulateLogoutForTests() {
   _globalState.appUrl = "https://www.braintrust.dev";
   return _globalState;
 }
+async function getPromptVersions(projectId, promptId) {
+  const state = _internalGetGlobalState();
+  if (!state) {
+    throw new Error("Must log in first");
+  }
+  await state.login({});
+  const query = {
+    from: {
+      op: "function",
+      name: {
+        op: "ident",
+        name: ["project_prompts"]
+      },
+      args: [
+        {
+          op: "literal",
+          value: projectId
+        }
+      ]
+    },
+    select: [
+      {
+        op: "star"
+      }
+    ],
+    filter: {
+      op: "eq",
+      left: { op: "ident", name: ["id"] },
+      right: { op: "literal", value: promptId }
+    }
+  };
+  const response = await state.apiConn().post(
+    "btql",
+    {
+      query,
+      audit_log: true,
+      use_columnstore: false,
+      brainstore_realtime: true
+    },
+    { headers: { "Accept-Encoding": "gzip" } }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `API request failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const result = await response.json();
+  return result.data?.filter(
+    (entry) => ["upsert", "merge"].includes(entry.audit_data?.action)
+  ).map((entry) => prettifyXact(entry._xact_id)) || [];
+}
 var _exportsForTestingOnly = {
   extractAttachments,
   deepCopyEvent,
@@ -8173,6 +9560,7 @@ var _exportsForTestingOnly = {
   simulateLoginForTests,
   simulateLogoutForTests,
   setInitialTestState,
+  initTestExperiment,
   isGeneratorFunction,
   isAsyncGeneratorFunction
 };
@@ -8196,6 +9584,7 @@ function configureNode() {
   isomorph_default.readFile = fs.readFile;
   isomorph_default.readdir = fs.readdir;
   isomorph_default.stat = fs.stat;
+  isomorph_default.statSync = fsSync.statSync;
   isomorph_default.utimes = fs.utimes;
   isomorph_default.unlink = fs.unlink;
   isomorph_default.homedir = os.homedir;
@@ -8219,11 +9608,11 @@ __export(exports_node_exports, {
   BraintrustStream: () => BraintrustStream,
   CodeFunction: () => CodeFunction,
   CodePrompt: () => CodePrompt,
-  Dataset: () => Dataset,
+  Dataset: () => Dataset2,
   ERR_PERMALINK: () => ERR_PERMALINK,
   Eval: () => Eval,
   EvalResultWithSummary: () => EvalResultWithSummary,
-  Experiment: () => Experiment,
+  Experiment: () => Experiment2,
   ExternalAttachment: () => ExternalAttachment,
   FailedHTTPResponse: () => FailedHTTPResponse,
   INTERNAL_BTQL_LIMIT: () => INTERNAL_BTQL_LIMIT,
@@ -8233,9 +9622,9 @@ __export(exports_node_exports, {
   NOOP_SPAN: () => NOOP_SPAN,
   NOOP_SPAN_PERMALINK: () => NOOP_SPAN_PERMALINK,
   NoopSpan: () => NoopSpan,
-  Project: () => Project,
+  Project: () => Project2,
   ProjectNameIdMap: () => ProjectNameIdMap,
-  Prompt: () => Prompt,
+  Prompt: () => Prompt2,
   PromptBuilder: () => PromptBuilder,
   ReadonlyAttachment: () => ReadonlyAttachment,
   ReadonlyExperiment: () => ReadonlyExperiment,
@@ -8258,6 +9647,7 @@ __export(exports_node_exports, {
   deserializePlainStringAsJSON: () => deserializePlainStringAsJSON,
   devNullWritableStream: () => devNullWritableStream,
   flush: () => flush,
+  getPromptVersions: () => getPromptVersions,
   getSpanParentObject: () => getSpanParentObject,
   graph: () => graph_framework_exports,
   init: () => init,
@@ -8284,10 +9674,11 @@ __export(exports_node_exports, {
   reportFailures: () => reportFailures,
   runEvaluator: () => runEvaluator,
   setFetch: () => setFetch,
+  setMaskingFunction: () => setMaskingFunction,
   spanComponentsToObjectId: () => spanComponentsToObjectId,
   startSpan: () => startSpan,
   summarize: () => summarize,
-  toolFunctionDefinitionSchema: () => toolFunctionDefinitionSchema,
+  toolFunctionDefinitionSchema: () => ToolFunctionDefinition,
   traceable: () => traceable,
   traced: () => traced,
   updateSpan: () => updateSpan,
@@ -8304,9 +9695,6 @@ __export(exports_node_exports, {
 });
 
 // src/functions/invoke.ts
-import {
-  functionIdSchema
-} from "@braintrust/core/typespecs";
 async function invoke(args) {
   const {
     orgName,
@@ -8335,7 +9723,7 @@ async function invoke(args) {
     fetch: fetch2
   });
   const parent = parentArg ? typeof parentArg === "string" ? parentArg : await parentArg.export() : await getSpanParentObject().export();
-  const functionId = functionIdSchema.safeParse({
+  const functionId = FunctionId.safeParse({
     function_id: functionIdArgs.function_id,
     project_name: functionIdArgs.projectName,
     slug: functionIdArgs.slug,
@@ -9476,26 +10864,20 @@ var BarProgressReporter = class {
 };
 
 // src/eval-parameters.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/framework2.ts
 import path2 from "path";
 import slugifyLib from "slugify";
-import { z as z3 } from "zod";
-import {
-  toolFunctionDefinitionSchema,
-  chatCompletionMessageParamSchema,
-  modelParamsSchema,
-  projectSchema
-} from "@braintrust/core/typespecs";
+import { z as z4 } from "zod";
 import { loadPrettyXact } from "@braintrust/core";
 var ProjectBuilder = class {
   create(opts) {
-    return new Project(opts);
+    return new Project2(opts);
   }
 };
 var projects = new ProjectBuilder();
-var Project = class {
+var Project2 = class {
   name;
   id;
   tools;
@@ -9722,23 +11104,23 @@ var CodePrompt = class {
     };
   }
 };
-var promptContentsSchema = z3.union([
-  z3.object({
-    prompt: z3.string()
+var promptContentsSchema = z4.union([
+  z4.object({
+    prompt: z4.string()
   }),
-  z3.object({
-    messages: z3.array(chatCompletionMessageParamSchema)
+  z4.object({
+    messages: z4.array(ChatCompletionMessageParam)
   })
 ]);
 var promptDefinitionSchema = promptContentsSchema.and(
-  z3.object({
-    model: z3.string(),
-    params: modelParamsSchema.optional()
+  z4.object({
+    model: z4.string(),
+    params: ModelParams.optional()
   })
 );
 var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
-  z3.object({
-    tools: z3.array(toolFunctionDefinitionSchema).optional()
+  z4.object({
+    tools: z4.array(ToolFunctionDefinition).optional()
   })
 );
 var PromptBuilder = class {
@@ -9767,7 +11149,7 @@ var PromptBuilder = class {
       prompt_data: promptData,
       ...this.project.id !== void 0 ? { project_id: this.project.id } : {}
     };
-    const prompt = new Prompt(
+    const prompt = new Prompt2(
       promptRow,
       {},
       // It doesn't make sense to specify defaults here.
@@ -9806,8 +11188,8 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
         project_name: projectName
       });
-      const result = z3.object({
-        project: projectSchema
+      const result = z4.object({
+        project: Project
       }).parse(response);
       const projectId = result.project.id;
       this.nameToId[projectName] = projectId;
@@ -9820,7 +11202,7 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
         id: projectId
       });
-      const result = z3.array(projectSchema).nonempty().parse(response);
+      const result = z4.array(Project).nonempty().parse(response);
       const projectName = result[0].name;
       this.idToName[projectId] = projectName;
       this.nameToId[projectName] = projectId;
@@ -9836,16 +11218,15 @@ var ProjectNameIdMap = class {
 };
 
 // src/eval-parameters.ts
-import { promptDataSchema as promptDataSchema2 } from "@braintrust/core/typespecs";
-var evalParametersSchema = z4.record(
-  z4.string(),
-  z4.union([
-    z4.object({
-      type: z4.literal("prompt"),
+var evalParametersSchema = z5.record(
+  z5.string(),
+  z5.union([
+    z5.object({
+      type: z5.literal("prompt"),
       default: promptDefinitionWithToolsSchema.optional(),
-      description: z4.string().optional()
+      description: z5.string().optional()
     }),
-    z4.instanceof(z4.ZodType)
+    z5.instanceof(z5.ZodType)
     // For Zod schemas
   ])
 );
@@ -9855,14 +11236,14 @@ function validateParameters(parameters, parameterSchema) {
       const value = parameters[name];
       try {
         if ("type" in schema && schema.type === "prompt") {
-          const promptData = value ? promptDataSchema2.parse(value) : schema.default ? promptDefinitionToPromptData(
+          const promptData = value ? PromptData.parse(value) : schema.default ? promptDefinitionToPromptData(
             schema.default,
             schema.default.tools
           ) : void 0;
           if (!promptData) {
             throw new Error(`Parameter '${name}' is required`);
           }
-          return [name, Prompt.fromPromptData(name, promptData)];
+          return [name, Prompt2.fromPromptData(name, promptData)];
         } else {
           const schemaCasted = schema;
           return [name, schemaCasted.parse(value)];
@@ -9982,7 +11363,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
       baseExperimentId: evaluator.baseExperimentId,
       gitMetadataSettings: evaluator.gitMetadataSettings,
       repoInfo: evaluator.repoInfo,
-      dataset: Dataset.isDataset(data) ? data : void 0
+      dataset: Dataset2.isDataset(data) ? data : void 0
     });
     if (experiment && options.onStart) {
       const summary = await experiment.summarize({ summarizeScores: false });
@@ -10143,7 +11524,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       datum,
       trialIndex
     }) => {
-      const eventDataset = experiment ? experiment.dataset : Dataset.isDataset(evaluator.data) ? evaluator.data : void 0;
+      const eventDataset = experiment ? experiment.dataset : Dataset2.isDataset(evaluator.data) ? evaluator.data : void 0;
       const baseEvent = {
         name: "eval",
         spanAttributes: {
@@ -10170,6 +11551,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         const expected = "expected" in datum ? datum.expected : void 0;
         let output = void 0;
         let error2 = void 0;
+        let tags = [...datum.tags ?? []];
         const scores = {};
         const scorerNames = evaluator.scores.map(scorerName);
         let unhandledScores = scorerNames;
@@ -10177,7 +11559,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           const meta = (o) => metadata = { ...metadata, ...o };
           await rootSpan.traced(
             async (span) => {
-              const outputResult = evaluator.task(datum.input, {
+              const hooksForTask = {
                 meta,
                 metadata,
                 expected,
@@ -10192,13 +11574,16 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                     object_type: "task"
                   });
                 },
-                trialIndex
-              });
+                trialIndex,
+                tags
+              };
+              const outputResult = evaluator.task(datum.input, hooksForTask);
               if (outputResult instanceof Promise) {
                 output = await outputResult;
               } else {
                 output = outputResult;
               }
+              tags = hooksForTask.tags ?? [];
               span.log({ output });
             },
             {
@@ -10207,7 +11592,11 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               event: { input: datum.input }
             }
           );
-          rootSpan.log({ output, metadata, expected });
+          if (tags.length) {
+            rootSpan.log({ output, metadata, expected, tags });
+          } else {
+            rootSpan.log({ output, metadata, expected });
+          }
           const scoringArgs = {
             input: datum.input,
             expected: "expected" in datum ? datum.expected : void 0,
@@ -10319,7 +11708,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           input: datum.input,
           ..."expected" in datum ? { expected: datum.expected } : {},
           output,
-          tags: datum.tags,
+          tags: tags.length ? tags : void 0,
           metadata,
           scores: {
             ...evaluator.errorScoreHandler && unhandledScores ? evaluator.errorScoreHandler({
@@ -10561,7 +11950,7 @@ var GraphBuilder = class {
     };
   }
   resolveNode(node) {
-    if (node instanceof Prompt) {
+    if (node instanceof Prompt2) {
       const cached = this.nodeLikeNodes.get(node);
       if (cached) {
         return [cached, []];
@@ -10773,6 +12162,7 @@ import { SpanTypeAttribute as SpanTypeAttribute3 } from "@braintrust/core";
 import { mergeDicts as mergeDicts3 } from "@braintrust/core";
 
 // src/wrappers/oai_responses.ts
+import { isObject as isObject2 } from "@braintrust/core";
 function responsesProxy(openai) {
   if (!openai.responses) {
     return openai;
@@ -10962,11 +12352,11 @@ function parseMetricsFromUsage(usage) {
       const metricName = TOKEN_NAME_MAP[oai_name] || oai_name;
       metrics[metricName] = value;
     } else if (oai_name.endsWith("_tokens_details")) {
-      const rawPrefix = oai_name.slice(0, -"_tokens_details".length);
-      const prefix = TOKEN_PREFIX_MAP[rawPrefix] || rawPrefix;
-      if (typeof value !== "object") {
+      if (!isObject2(value)) {
         continue;
       }
+      const rawPrefix = oai_name.slice(0, -"_tokens_details".length);
+      const prefix = TOKEN_PREFIX_MAP[rawPrefix] || rawPrefix;
       for (const [key, n] of Object.entries(value)) {
         if (typeof n !== "number") {
           continue;
@@ -11450,6 +12840,28 @@ var WrapperStream = class {
 
 // src/wrappers/ai-sdk-v2.ts
 import { SpanTypeAttribute as SpanTypeAttribute4 } from "@braintrust/core";
+
+// src/wrappers/anthropic-tokens-util.ts
+function finalizeAnthropicTokens(metrics) {
+  const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + (metrics.prompt_cache_creation_tokens || 0);
+  return {
+    ...metrics,
+    prompt_tokens,
+    tokens: prompt_tokens + (metrics.completion_tokens || 0)
+  };
+}
+function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens = 0) {
+  const cacheTokens = {};
+  if (cacheReadTokens > 0) {
+    cacheTokens.prompt_cached_tokens = cacheReadTokens;
+  }
+  if (cacheCreationTokens > 0) {
+    cacheTokens.prompt_cache_creation_tokens = cacheCreationTokens;
+  }
+  return cacheTokens;
+}
+
+// src/wrappers/ai-sdk-v2.ts
 function detectProviderFromResult(result) {
   if (!result?.providerMetadata) {
     return void 0;
@@ -11498,7 +12910,7 @@ function getNumberProperty(obj, key) {
   const value = Reflect.get(obj, key);
   return typeof value === "number" ? value : void 0;
 }
-function normalizeUsageMetrics(usage) {
+function normalizeUsageMetrics(usage, provider, providerMetadata) {
   const metrics = {};
   const inputTokens = getNumberProperty(usage, "inputTokens");
   if (inputTokens !== void 0) {
@@ -11520,6 +12932,22 @@ function normalizeUsageMetrics(usage) {
   if (cachedInputTokens !== void 0) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
+  if (provider === "anthropic") {
+    const anthropicMetadata = providerMetadata?.anthropic;
+    if (anthropicMetadata) {
+      const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
+      const cacheCreationTokens = getNumberProperty(
+        anthropicMetadata.usage,
+        "cache_creation_input_tokens"
+      ) || 0;
+      const cacheTokens = extractAnthropicCacheTokens(
+        cacheReadTokens,
+        cacheCreationTokens
+      );
+      Object.assign(metrics, cacheTokens);
+      Object.assign(metrics, finalizeAnthropicTokens(metrics));
+    }
+  }
   return metrics;
 }
 function BraintrustMiddleware(config = {}) {
@@ -11555,7 +12983,11 @@ function BraintrustMiddleware(config = {}) {
         span.log({
           output: result.content,
           metadata,
-          metrics: normalizeUsageMetrics(result.usage)
+          metrics: normalizeUsageMetrics(
+            result.usage,
+            provider,
+            result.providerMetadata
+          )
         });
         return result;
       } catch (error2) {
@@ -11632,7 +13064,11 @@ function BraintrustMiddleware(config = {}) {
               span.log({
                 output,
                 metadata,
-                metrics: normalizeUsageMetrics(finalUsage)
+                metrics: normalizeUsageMetrics(
+                  finalUsage,
+                  provider,
+                  providerMetadata
+                )
               });
               span.end();
             } catch (error2) {
@@ -12009,7 +13445,7 @@ function createProxy(create) {
           const event = parseEventFromMessage(msgOrStream);
           span.log({
             ...event,
-            metrics: event.metrics ? finalizeMetrics(event.metrics) : void 0
+            metrics: event.metrics ? finalizeAnthropicTokens(event.metrics) : void 0
           });
           span.end();
           return msgOrStream;
@@ -12093,7 +13529,7 @@ function streamNextProxy(stream, sspan) {
       const output = deltas.join("");
       span.log({
         output,
-        metrics: finalizeMetrics(totals),
+        metrics: finalizeAnthropicTokens(totals),
         metadata
       });
       span.end();
@@ -12167,15 +13603,6 @@ function parseMetricsFromUsage2(usage) {
   saveIfExistsTo("cache_creation_input_tokens", "prompt_cache_creation_tokens");
   return metrics;
 }
-function finalizeMetrics(metrics) {
-  const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + (metrics.prompt_cache_creation_tokens || 0);
-  return {
-    ...metrics,
-    // Anthropic's `input_tokens` does not include cache creation or cached read tokens.
-    prompt_tokens,
-    tokens: prompt_tokens + (metrics.completion_tokens || 0)
-  };
-}
 function coalesceInput(messages, system) {
   const input = (messages || []).slice();
   if (system) {
@@ -12334,11 +13761,31 @@ var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
         "x-bt-parent": parent,
         ...options.headers
       };
-      exporter = new OTLPTraceExporter2({
+      const baseExporter = new OTLPTraceExporter2({
         url: new URL("otel/v1/traces", apiUrl).href,
         headers
       });
+      exporter = new Proxy(baseExporter, {
+        get(target, prop, receiver) {
+          if (prop === "export") {
+            return function(spans, resultCallback) {
+              const fixedSpans = spans.map((span) => {
+                if (!span.instrumentationScope && span.instrumentationLibrary) {
+                  span.instrumentationScope = span.instrumentationLibrary;
+                }
+                return span;
+              });
+              return Reflect.apply(target.export, target, [
+                fixedSpans,
+                resultCallback
+              ]);
+            };
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
     } catch (error2) {
+      console.error(error2);
       throw new Error(
         "Failed to create OTLP exporter. Make sure @opentelemetry/exporter-trace-otlp-http is installed."
       );
@@ -12416,50 +13863,44 @@ var BraintrustExporter = class _BraintrustExporter {
 };
 
 // dev/types.ts
-import {
-  functionIdSchema as functionIdSchema2,
-  invokeParent,
-  runEvalSchema,
-  promptDataSchema as promptDataSchema3
-} from "@braintrust/core/typespecs";
-import { z as z5 } from "zod";
-var evalBodySchema = z5.object({
-  name: z5.string(),
-  parameters: z5.record(z5.string(), z5.unknown()).nullish(),
-  data: runEvalSchema.shape.data,
-  scores: z5.array(
-    z5.object({
-      function_id: functionIdSchema2,
-      name: z5.string()
+import { z as z6 } from "zod";
+var evalBodySchema = z6.object({
+  name: z6.string(),
+  parameters: z6.record(z6.string(), z6.unknown()).nullish(),
+  data: RunEval.shape.data,
+  scores: z6.array(
+    z6.object({
+      function_id: FunctionId,
+      name: z6.string()
     })
   ).nullish(),
-  experiment_name: z5.string().nullish(),
-  project_id: z5.string().nullish(),
-  parent: invokeParent.optional(),
-  stream: z5.boolean().optional()
+  experiment_name: z6.string().nullish(),
+  project_id: z6.string().nullish(),
+  parent: InvokeParent.optional(),
+  stream: z6.boolean().optional()
 });
-var evalParametersSerializedSchema = z5.record(
-  z5.string(),
-  z5.union([
-    z5.object({
-      type: z5.literal("prompt"),
-      default: promptDataSchema3.optional(),
-      description: z5.string().optional()
+var evalParametersSerializedSchema = z6.record(
+  z6.string(),
+  z6.union([
+    z6.object({
+      type: z6.literal("prompt"),
+      default: PromptData.optional(),
+      description: z6.string().optional()
     }),
-    z5.object({
-      type: z5.literal("data"),
-      schema: z5.record(z5.unknown()),
+    z6.object({
+      type: z6.literal("data"),
+      schema: z6.record(z6.unknown()),
       // JSON Schema
-      default: z5.unknown().optional(),
-      description: z5.string().optional()
+      default: z6.unknown().optional(),
+      description: z6.string().optional()
     })
   ])
 );
-var evaluatorDefinitionSchema = z5.object({
+var evaluatorDefinitionSchema = z6.object({
   parameters: evalParametersSerializedSchema.optional()
 });
-var evaluatorDefinitionsSchema = z5.record(
-  z5.string(),
+var evaluatorDefinitionsSchema = z6.record(
+  z6.string(),
   evaluatorDefinitionSchema
 );
 
@@ -12478,11 +13919,11 @@ export {
   BraintrustStream,
   CodeFunction,
   CodePrompt,
-  Dataset,
+  Dataset2 as Dataset,
   ERR_PERMALINK,
   Eval,
   EvalResultWithSummary,
-  Experiment,
+  Experiment2 as Experiment,
   ExternalAttachment,
   FailedHTTPResponse,
   INTERNAL_BTQL_LIMIT,
@@ -12492,9 +13933,9 @@ export {
   NOOP_SPAN,
   NOOP_SPAN_PERMALINK,
   NoopSpan,
-  Project,
+  Project2 as Project,
   ProjectNameIdMap,
-  Prompt,
+  Prompt2 as Prompt,
   PromptBuilder,
   ReadonlyAttachment,
   ReadonlyExperiment,
@@ -12520,6 +13961,7 @@ export {
   evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema,
   flush,
+  getPromptVersions,
   getSpanParentObject,
   graph_framework_exports as graph,
   init,
@@ -12546,10 +13988,11 @@ export {
   reportFailures,
   runEvaluator,
   setFetch,
+  setMaskingFunction,
   spanComponentsToObjectId,
   startSpan,
   summarize,
-  toolFunctionDefinitionSchema,
+  ToolFunctionDefinition as toolFunctionDefinitionSchema,
   traceable,
   traced,
   updateSpan,