braintrust 0.2.4 → 0.2.6

package/dist/browser.mjs

@@ -109,64 +109,1302 @@ 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 ResponseFormatNullish = 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: ResponseFormatNullish.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 AsyncScoringState = z.union([
+  z.object({
+    status: z.literal("enabled"),
+    token: z.string(),
+    function_ids: z.array(z.unknown()).min(1),
+    skip_logging: z.union([z.boolean(), z.null()]).optional()
+  }),
+  z.object({ status: z.literal("disabled") }),
+  z.null(),
+  z.null()
+]);
+var AsyncScoringControl = z.union([
+  z.object({ kind: z.literal("score_update"), token: z.string() }),
+  z.object({ kind: z.literal("state_override"), state: AsyncScoringState }),
+  z.object({ kind: z.literal("state_force_reselect") }),
+  z.object({ kind: z.literal("state_enabled_force_rescore") })
+]);
+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 ObjectReferenceNullish = 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: ObjectReferenceNullish.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: ObjectReferenceNullish.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: ResponseFormatNullish,
+    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("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({
+    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({
+    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({
+    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({
+    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({
+    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({
+    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({
+    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 Function = 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({
-    type: z.literal("text_delta"),
-    data: z.string()
+    project_name: z.string(),
+    slug: z.string(),
+    version: z.string().optional()
   }),
+  z.object({ global_function: z.string() }),
   z.object({
-    type: z.literal("reasoning_delta"),
-    data: z.string()
+    prompt_session_id: z.string(),
+    prompt_session_function_id: z.string(),
+    version: z.string().optional()
   }),
   z.object({
-    type: z.literal("json_delta"),
-    data: z.string()
+    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({
-    type: z.literal("error"),
-    data: z.string()
+    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 ObjectReference = 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()
+});
+var OnlineScoreConfig = z.union([
   z.object({
-    type: z.literal("console"),
-    data: sseConsoleEventDataSchema
+    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: ObjectReferenceNullish.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 ResponseFormat = z.union([
+  z.object({ type: z.literal("json_object") }),
   z.object({
-    type: z.literal("progress"),
-    data: sseProgressEventDataSchema
+    type: z.literal("json_schema"),
+    json_schema: ResponseFormatJsonSchema
   }),
+  z.object({ type: z.literal("text") })
+]);
+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(),
+  service_account_id: z.union([z.string(), z.null()]).optional(),
+  service_account_email: z.union([z.string(), z.null()]).optional(),
+  service_account_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: ObjectReferenceNullish.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({
-    type: z.literal("start"),
-    data: z.string()
+    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({
-    type: z.literal("done"),
-    data: z.string()
+    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 {
@@ -274,12 +1512,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 {
@@ -355,7 +1593,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}`);
         }
@@ -780,6 +2018,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 (error) {
+    const errorType = error instanceof Error ? error.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;
@@ -830,15 +2106,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 {
@@ -980,6 +2256,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;
@@ -1058,6 +2337,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(
@@ -1299,9 +2590,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 (error) {
         if (error instanceof ZodError) {
@@ -1361,6 +2652,7 @@ var Attachment = class extends BaseAttachment {
   }
   initData(data) {
     if (typeof data === "string") {
+      this.ensureFileReadable(data);
       const readFile = isomorph_default.readFile;
       if (!readFile) {
         throw new Error(
@@ -1373,6 +2665,20 @@ with a Blob/ArrayBuffer, or run the program on Node.js.`
       return new LazyValue(async () => new Blob([data]));
     }
   }
+  ensureFileReadable(data) {
+    const statSync = isomorph_default.statSync;
+    if (!statSync) {
+      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 {
+      statSync(data);
+    } catch (e) {
+      console.warn(`Failed to read file: ${e}`);
+    }
+  }
 };
 var ExternalAttachment = class extends BaseAttachment {
   /**
@@ -1441,9 +2747,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 {
   /**
@@ -1982,9 +3288,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();
   }
@@ -1998,7 +3308,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;
@@ -2009,6 +3346,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;
@@ -2076,6 +3414,9 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
     }
     this.onFlushError = opts.onFlushError;
   }
+  setMaskingFunction(maskingFunction) {
+    this.maskingFunction = maskingFunction;
+  }
   log(items) {
     if (this._disabled) {
       return;
@@ -2172,7 +3513,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;
@@ -2520,7 +3890,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;
   }
@@ -2617,7 +3987,7 @@ function initDataset(projectOrOptions, optionalOptions) {
       };
     }
   );
-  return new Dataset(
+  return new Dataset2(
     stateArg ?? _globalState,
     lazyMetadata,
     version,
@@ -2813,8 +4183,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);
@@ -2829,6 +4199,9 @@ async function loadPrompt({
   }
   return prompt;
 }
+function setMaskingFunction(maskingFunction) {
+  _globalState.setMaskingFunction(maskingFunction);
+}
 async function login(options = {}) {
   const { forceLogin = false } = options || {};
   if (_globalState.loggedIn && !forceLogin) {
@@ -3353,13 +4726,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>`;
@@ -3411,7 +4784,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;
@@ -3554,7 +4927,7 @@ var ObjectFetcher = class {
     }
   }
 };
-var Experiment = class extends ObjectFetcher {
+var Experiment2 = class extends ObjectFetcher {
   lazyMetadata;
   dataset;
   lastStartTime;
@@ -4160,7 +5533,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) {
@@ -4358,8 +5731,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",
@@ -4482,11 +5855,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);
@@ -4507,7 +5880,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;
@@ -4604,7 +5977,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 : {}
@@ -4625,7 +5998,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") {
@@ -4659,7 +6032,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 : {}
@@ -4712,7 +6085,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;
@@ -4749,6 +6122,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,
@@ -4757,6 +6181,7 @@ var _exportsForTestingOnly = {
   simulateLoginForTests,
   simulateLogoutForTests,
   setInitialTestState,
+  initTestExperiment,
   isGeneratorFunction,
   isAsyncGeneratorFunction
 };
@@ -4800,9 +6225,9 @@ __export(exports_browser_exports, {
   BaseAttachment: () => BaseAttachment,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
-  Dataset: () => Dataset,
+  Dataset: () => Dataset2,
   ERR_PERMALINK: () => ERR_PERMALINK,
-  Experiment: () => Experiment,
+  Experiment: () => Experiment2,
   ExternalAttachment: () => ExternalAttachment,
   FailedHTTPResponse: () => FailedHTTPResponse,
   INTERNAL_BTQL_LIMIT: () => INTERNAL_BTQL_LIMIT,
@@ -4812,7 +6237,7 @@ __export(exports_browser_exports, {
   NOOP_SPAN: () => NOOP_SPAN,
   NOOP_SPAN_PERMALINK: () => NOOP_SPAN_PERMALINK,
   NoopSpan: () => NoopSpan,
-  Prompt: () => Prompt,
+  Prompt: () => Prompt2,
   ReadonlyAttachment: () => ReadonlyAttachment,
   ReadonlyExperiment: () => ReadonlyExperiment,
   SpanImpl: () => SpanImpl,
@@ -4831,6 +6256,7 @@ __export(exports_browser_exports, {
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema: () => evaluatorDefinitionsSchema,
   flush: () => flush,
+  getPromptVersions: () => getPromptVersions,
   getSpanParentObject: () => getSpanParentObject,
   init: () => init,
   initDataset: () => initDataset,
@@ -4849,6 +6275,7 @@ __export(exports_browser_exports, {
   renderMessage: () => renderMessage,
   renderPromptParams: () => renderPromptParams,
   setFetch: () => setFetch,
+  setMaskingFunction: () => setMaskingFunction,
   spanComponentsToObjectId: () => spanComponentsToObjectId,
   startSpan: () => startSpan,
   summarize: () => summarize,
@@ -4866,9 +6293,6 @@ __export(exports_browser_exports, {
 });
 
 // src/functions/invoke.ts
-import {
-  functionIdSchema
-} from "@braintrust/core/typespecs";
 async function invoke(args) {
   const {
     orgName,
@@ -4897,7 +6321,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,
@@ -5638,50 +7062,44 @@ var WrapperStream = class {
 };
 
 // dev/types.ts
-import {
-  functionIdSchema as functionIdSchema2,
-  invokeParent,
-  runEvalSchema,
-  promptDataSchema as promptDataSchema2
-} from "@braintrust/core/typespecs";
-import { z as z3 } from "zod";
-var evalBodySchema = z3.object({
-  name: z3.string(),
-  parameters: z3.record(z3.string(), z3.unknown()).nullish(),
-  data: runEvalSchema.shape.data,
-  scores: z3.array(
-    z3.object({
-      function_id: functionIdSchema2,
-      name: z3.string()
+import { z as z4 } from "zod";
+var evalBodySchema = z4.object({
+  name: z4.string(),
+  parameters: z4.record(z4.string(), z4.unknown()).nullish(),
+  data: RunEval.shape.data,
+  scores: z4.array(
+    z4.object({
+      function_id: FunctionId,
+      name: z4.string()
     })
   ).nullish(),
-  experiment_name: z3.string().nullish(),
-  project_id: z3.string().nullish(),
-  parent: invokeParent.optional(),
-  stream: z3.boolean().optional()
+  experiment_name: z4.string().nullish(),
+  project_id: z4.string().nullish(),
+  parent: InvokeParent.optional(),
+  stream: z4.boolean().optional()
 });
-var evalParametersSerializedSchema = z3.record(
-  z3.string(),
-  z3.union([
-    z3.object({
-      type: z3.literal("prompt"),
-      default: promptDataSchema2.optional(),
-      description: z3.string().optional()
+var evalParametersSerializedSchema = z4.record(
+  z4.string(),
+  z4.union([
+    z4.object({
+      type: z4.literal("prompt"),
+      default: PromptData.optional(),
+      description: z4.string().optional()
     }),
-    z3.object({
-      type: z3.literal("data"),
-      schema: z3.record(z3.unknown()),
+    z4.object({
+      type: z4.literal("data"),
+      schema: z4.record(z4.unknown()),
       // JSON Schema
-      default: z3.unknown().optional(),
-      description: z3.string().optional()
+      default: z4.unknown().optional(),
+      description: z4.string().optional()
     })
   ])
 );
-var evaluatorDefinitionSchema = z3.object({
+var evaluatorDefinitionSchema = z4.object({
   parameters: evalParametersSerializedSchema.optional()
 });
-var evaluatorDefinitionsSchema = z3.record(
-  z3.string(),
+var evaluatorDefinitionsSchema = z4.record(
+  z4.string(),
   evaluatorDefinitionSchema
 );
 
@@ -5693,9 +7111,9 @@ export {
   BaseAttachment,
   BraintrustState,
   BraintrustStream,
-  Dataset,
+  Dataset2 as Dataset,
   ERR_PERMALINK,
-  Experiment,
+  Experiment2 as Experiment,
   ExternalAttachment,
   FailedHTTPResponse,
   INTERNAL_BTQL_LIMIT,
@@ -5705,7 +7123,7 @@ export {
   NOOP_SPAN,
   NOOP_SPAN_PERMALINK,
   NoopSpan,
-  Prompt,
+  Prompt2 as Prompt,
   ReadonlyAttachment,
   ReadonlyExperiment,
   SpanImpl,
@@ -5725,6 +7143,7 @@ export {
   evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema,
   flush,
+  getPromptVersions,
   getSpanParentObject,
   init,
   initDataset,
@@ -5743,6 +7162,7 @@ export {
   renderMessage,
   renderPromptParams,
   setFetch,
+  setMaskingFunction,
   spanComponentsToObjectId,
   startSpan,
   summarize,