braintrust 0.2.3 → 0.2.5

package/dist/cli.js

@@ -164,11 +164,11 @@ var require_out = __commonJS({
       async.read(path9, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports2.stat = stat2;
-    function statSync(path9, optionsOrSettings) {
+    function statSync2(path9, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path9, settings);
     }
-    exports2.statSync = statSync;
+    exports2.statSync = statSync2;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -1232,7 +1232,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "0.2.3",
+      version: "0.2.5",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1294,6 +1294,9 @@ var require_package = __commonJS({
       author: "",
       license: "MIT",
       devDependencies: {
+        "@ai-sdk/anthropic": "^1.0.5",
+        "@anthropic-ai/sdk": "^0.35.0",
+        "@openai/agents": "^0.0.14",
         ai: "^4.3.16",
         "@jest/globals": "^29.7.0",
         "@nodelib/fs.walk": "^1.2.8",
@@ -1312,6 +1315,7 @@ var require_package = __commonJS({
         autoevals: "^0.0.69",
         "cross-env": "^7.0.3",
         "npm-run-all": "^4.1.5",
+        "openapi-zod-client": "^1.18.3",
         prettier: "^3.5.3",
         tinybench: "^4.0.1",
         "ts-jest": "^29.1.4",
@@ -1324,7 +1328,7 @@ var require_package = __commonJS({
       },
       dependencies: {
         "@ai-sdk/provider": "^1.1.3",
-        "@braintrust/core": "0.0.93",
+        "@braintrust/core": "0.0.94",
         "@next/env": "^14.2.3",
         "@vercel/functions": "^1.0.2",
         argparse: "^2.0.1",
@@ -1435,47 +1439,1262 @@ var Queue = class {
 
 // src/logger.ts
 var import_core2 = require("@braintrust/core");
-var import_typespecs2 = require("@braintrust/core/typespecs");
-var import_functions = require("@vercel/functions");
-var import_mustache2 = __toESM(require("mustache"));
-var import_zod2 = require("zod");
 
-// src/functions/stream.ts
-var import_typespecs = require("@braintrust/core/typespecs");
-var import_eventsource_parser = require("eventsource-parser");
+// src/generated_types.ts
 var import_zod = require("zod");
-var braintrustStreamChunkSchema = import_zod.z.union([
+var AclObjectType = import_zod.z.union([
+  import_zod.z.enum([
+    "organization",
+    "project",
+    "experiment",
+    "dataset",
+    "prompt",
+    "prompt_session",
+    "group",
+    "role",
+    "org_member",
+    "project_log",
+    "org_project"
+  ]),
+  import_zod.z.null()
+]);
+var Permission = import_zod.z.enum([
+  "create",
+  "read",
+  "update",
+  "delete",
+  "create_acls",
+  "read_acls",
+  "update_acls",
+  "delete_acls"
+]);
+var Acl = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  object_type: AclObjectType.and(import_zod.z.string()),
+  object_id: import_zod.z.string().uuid(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  group_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  permission: Permission.and(import_zod.z.union([import_zod.z.string(), import_zod.z.null()])).optional(),
+  restrict_object_type: AclObjectType.and(import_zod.z.unknown()).optional(),
+  role_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  _object_org_id: import_zod.z.string().uuid(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var AISecret = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  updated_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  org_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  type: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
+  preview_secret: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var ResponseFormatJsonSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  schema: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.string()]).optional(),
+  strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+});
+var ResponseFormat = import_zod.z.union([
+  import_zod.z.object({ type: import_zod.z.literal("json_object") }),
+  import_zod.z.object({
+    type: import_zod.z.literal("json_schema"),
+    json_schema: ResponseFormatJsonSchema
+  }),
+  import_zod.z.object({ type: import_zod.z.literal("text") }),
+  import_zod.z.null()
+]);
+var AnyModelParams = import_zod.z.object({
+  temperature: import_zod.z.number().optional(),
+  top_p: import_zod.z.number().optional(),
+  max_tokens: import_zod.z.number(),
+  max_completion_tokens: import_zod.z.number().optional(),
+  frequency_penalty: import_zod.z.number().optional(),
+  presence_penalty: import_zod.z.number().optional(),
+  response_format: ResponseFormat.optional(),
+  tool_choice: import_zod.z.union([
+    import_zod.z.literal("auto"),
+    import_zod.z.literal("none"),
+    import_zod.z.literal("required"),
+    import_zod.z.object({
+      type: import_zod.z.literal("function"),
+      function: import_zod.z.object({ name: import_zod.z.string() })
+    })
+  ]).optional(),
+  function_call: import_zod.z.union([
+    import_zod.z.literal("auto"),
+    import_zod.z.literal("none"),
+    import_zod.z.object({ name: import_zod.z.string() })
+  ]).optional(),
+  n: import_zod.z.number().optional(),
+  stop: import_zod.z.array(import_zod.z.string()).optional(),
+  reasoning_effort: import_zod.z.enum(["minimal", "low", "medium", "high"]).optional(),
+  verbosity: import_zod.z.enum(["low", "medium", "high"]).optional(),
+  top_k: import_zod.z.number().optional(),
+  stop_sequences: import_zod.z.array(import_zod.z.string()).optional(),
+  max_tokens_to_sample: import_zod.z.number().optional(),
+  maxOutputTokens: import_zod.z.number().optional(),
+  topP: import_zod.z.number().optional(),
+  topK: import_zod.z.number().optional(),
+  use_cache: import_zod.z.boolean().optional()
+});
+var ApiKey = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  preview_name: import_zod.z.string(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_given_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_family_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  org_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var BraintrustAttachmentReference = import_zod.z.object({
+  type: import_zod.z.literal("braintrust_attachment"),
+  filename: import_zod.z.string().min(1),
+  content_type: import_zod.z.string().min(1),
+  key: import_zod.z.string().min(1)
+});
+var ExternalAttachmentReference = import_zod.z.object({
+  type: import_zod.z.literal("external_attachment"),
+  filename: import_zod.z.string().min(1),
+  content_type: import_zod.z.string().min(1),
+  url: import_zod.z.string().min(1)
+});
+var AttachmentReference = import_zod.z.discriminatedUnion("type", [
+  BraintrustAttachmentReference,
+  ExternalAttachmentReference
+]);
+var UploadStatus = import_zod.z.enum(["uploading", "done", "error"]);
+var AttachmentStatus = import_zod.z.object({
+  upload_status: UploadStatus,
+  error_message: import_zod.z.string().optional()
+});
+var BraintrustModelParams = import_zod.z.object({ use_cache: import_zod.z.boolean() }).partial();
+var CallEvent = import_zod.z.union([
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    data: import_zod.z.string(),
+    event: import_zod.z.literal("text_delta")
+  }),
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    data: import_zod.z.string(),
+    event: import_zod.z.literal("reasoning_delta")
+  }),
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    data: import_zod.z.string(),
+    event: import_zod.z.literal("json_delta")
+  }),
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    data: import_zod.z.string(),
+    event: import_zod.z.literal("progress")
+  }),
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    data: import_zod.z.string(),
+    event: import_zod.z.literal("error")
+  }),
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    data: import_zod.z.string(),
+    event: import_zod.z.literal("console")
+  }),
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    event: import_zod.z.literal("start"),
+    data: import_zod.z.literal("")
+  }),
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    event: import_zod.z.literal("done"),
+    data: import_zod.z.literal("")
+  })
+]);
+var ChatCompletionContentPartTextWithTitle = import_zod.z.object({
+  text: import_zod.z.string().default(""),
+  type: import_zod.z.literal("text"),
+  cache_control: import_zod.z.object({ type: import_zod.z.literal("ephemeral") }).optional()
+});
+var ChatCompletionContentPartImageWithTitle = import_zod.z.object({
+  image_url: import_zod.z.object({
+    url: import_zod.z.string(),
+    detail: import_zod.z.union([import_zod.z.literal("auto"), import_zod.z.literal("low"), import_zod.z.literal("high")]).optional()
+  }),
+  type: import_zod.z.literal("image_url")
+});
+var ChatCompletionContentPart = import_zod.z.union([
+  ChatCompletionContentPartTextWithTitle,
+  ChatCompletionContentPartImageWithTitle
+]);
+var ChatCompletionContentPartText = import_zod.z.object({
+  text: import_zod.z.string().default(""),
+  type: import_zod.z.literal("text"),
+  cache_control: import_zod.z.object({ type: import_zod.z.literal("ephemeral") }).optional()
+});
+var ChatCompletionMessageToolCall = import_zod.z.object({
+  id: import_zod.z.string(),
+  function: import_zod.z.object({ arguments: import_zod.z.string(), name: import_zod.z.string() }),
+  type: import_zod.z.literal("function")
+});
+var ChatCompletionMessageReasoning = import_zod.z.object({ id: import_zod.z.string(), content: import_zod.z.string() }).partial();
+var ChatCompletionMessageParam = import_zod.z.union([
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
+    role: import_zod.z.literal("system"),
+    name: import_zod.z.string().optional()
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPart)]),
+    role: import_zod.z.literal("user"),
+    name: import_zod.z.string().optional()
+  }),
+  import_zod.z.object({
+    role: import_zod.z.literal("assistant"),
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText), import_zod.z.null()]).optional(),
+    function_call: import_zod.z.object({ arguments: import_zod.z.string(), name: import_zod.z.string() }).optional(),
+    name: import_zod.z.string().optional(),
+    tool_calls: import_zod.z.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: import_zod.z.array(ChatCompletionMessageReasoning).optional()
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
+    role: import_zod.z.literal("tool"),
+    tool_call_id: import_zod.z.string().default("")
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    name: import_zod.z.string(),
+    role: import_zod.z.literal("function")
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
+    role: import_zod.z.literal("developer"),
+    name: import_zod.z.string().optional()
+  }),
+  import_zod.z.object({
+    role: import_zod.z.literal("model"),
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  })
+]);
+var ChatCompletionOpenAIMessageParam = import_zod.z.union([
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
+    role: import_zod.z.literal("system"),
+    name: import_zod.z.string().optional()
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPart)]),
+    role: import_zod.z.literal("user"),
+    name: import_zod.z.string().optional()
+  }),
+  import_zod.z.object({
+    role: import_zod.z.literal("assistant"),
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText), import_zod.z.null()]).optional(),
+    function_call: import_zod.z.object({ arguments: import_zod.z.string(), name: import_zod.z.string() }).optional(),
+    name: import_zod.z.string().optional(),
+    tool_calls: import_zod.z.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: import_zod.z.array(ChatCompletionMessageReasoning).optional()
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
+    role: import_zod.z.literal("tool"),
+    tool_call_id: import_zod.z.string().default("")
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    name: import_zod.z.string(),
+    role: import_zod.z.literal("function")
+  }),
+  import_zod.z.object({
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
+    role: import_zod.z.literal("developer"),
+    name: import_zod.z.string().optional()
+  })
+]);
+var ChatCompletionTool = import_zod.z.object({
+  function: import_zod.z.object({
+    name: import_zod.z.string(),
+    description: import_zod.z.string().optional(),
+    parameters: import_zod.z.object({}).partial().passthrough().optional()
+  }),
+  type: import_zod.z.literal("function")
+});
+var CodeBundle = import_zod.z.object({
+  runtime_context: import_zod.z.object({
+    runtime: import_zod.z.enum(["node", "python"]),
+    version: import_zod.z.string()
+  }),
+  location: import_zod.z.union([
+    import_zod.z.object({
+      type: import_zod.z.literal("experiment"),
+      eval_name: import_zod.z.string(),
+      position: import_zod.z.union([
+        import_zod.z.object({ type: import_zod.z.literal("task") }),
+        import_zod.z.object({ type: import_zod.z.literal("scorer"), index: import_zod.z.number().int().gte(0) })
+      ])
+    }),
+    import_zod.z.object({ type: import_zod.z.literal("function"), index: import_zod.z.number().int().gte(0) })
+  ]),
+  bundle_id: import_zod.z.string(),
+  preview: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var Dataset = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  project_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
+});
+var ObjectReference = import_zod.z.union([
+  import_zod.z.object({
+    object_type: import_zod.z.enum([
+      "project_logs",
+      "experiment",
+      "dataset",
+      "prompt",
+      "function",
+      "prompt_session"
+    ]),
+    object_id: import_zod.z.string().uuid(),
+    id: import_zod.z.string(),
+    _xact_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  }),
+  import_zod.z.null()
+]);
+var DatasetEvent = import_zod.z.object({
+  id: import_zod.z.string(),
+  _xact_id: import_zod.z.string(),
+  created: import_zod.z.string().datetime({ offset: true }),
+  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  project_id: import_zod.z.string().uuid(),
+  dataset_id: import_zod.z.string().uuid(),
+  input: import_zod.z.unknown().optional(),
+  expected: import_zod.z.unknown().optional(),
+  metadata: import_zod.z.union([
+    import_zod.z.object({ model: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]) }).partial().passthrough(),
+    import_zod.z.null()
+  ]).optional(),
+  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+  span_id: import_zod.z.string(),
+  root_span_id: import_zod.z.string(),
+  is_root: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  origin: ObjectReference.optional()
+});
+var EnvVar = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  object_type: import_zod.z.enum(["organization", "project", "function"]),
+  object_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  used: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var RepoInfo = import_zod.z.union([
+  import_zod.z.object({
+    commit: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    branch: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    tag: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    dirty: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
+    author_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    author_email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    commit_message: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    commit_time: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    git_diff: import_zod.z.union([import_zod.z.string(), import_zod.z.null()])
+  }).partial(),
+  import_zod.z.null()
+]);
+var Experiment = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  project_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  repo_info: RepoInfo.optional(),
+  commit: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  base_exp_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  dataset_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  dataset_version: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  public: import_zod.z.boolean(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
+  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional()
+});
+var SpanType = import_zod.z.union([
+  import_zod.z.enum(["llm", "score", "function", "eval", "task", "tool"]),
+  import_zod.z.null()
+]);
+var SpanAttributes = import_zod.z.union([
+  import_zod.z.object({ name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]), type: SpanType }).partial().passthrough(),
+  import_zod.z.null()
+]);
+var ExperimentEvent = import_zod.z.object({
+  id: import_zod.z.string(),
+  _xact_id: import_zod.z.string(),
+  created: import_zod.z.string().datetime({ offset: true }),
+  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  project_id: import_zod.z.string().uuid(),
+  experiment_id: import_zod.z.string().uuid(),
+  input: import_zod.z.unknown().optional(),
+  output: import_zod.z.unknown().optional(),
+  expected: import_zod.z.unknown().optional(),
+  error: import_zod.z.unknown().optional(),
+  scores: import_zod.z.union([import_zod.z.record(import_zod.z.union([import_zod.z.number(), import_zod.z.null()])), import_zod.z.null()]).optional(),
+  metadata: import_zod.z.union([
+    import_zod.z.object({ model: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]) }).partial().passthrough(),
+    import_zod.z.null()
+  ]).optional(),
+  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+  metrics: import_zod.z.union([import_zod.z.record(import_zod.z.number()), import_zod.z.null()]).optional(),
+  context: import_zod.z.union([
+    import_zod.z.object({
+      caller_functionname: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      caller_filename: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      caller_lineno: import_zod.z.union([import_zod.z.number(), import_zod.z.null()])
+    }).partial().passthrough(),
+    import_zod.z.null()
+  ]).optional(),
+  span_id: import_zod.z.string(),
+  span_parents: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+  root_span_id: import_zod.z.string(),
+  span_attributes: SpanAttributes.optional(),
+  is_root: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  origin: ObjectReference.optional()
+});
+var ExtendedSavedFunctionId = import_zod.z.union([
+  import_zod.z.object({ type: import_zod.z.literal("function"), id: import_zod.z.string() }),
+  import_zod.z.object({ type: import_zod.z.literal("global"), name: import_zod.z.string() }),
+  import_zod.z.object({
+    type: import_zod.z.literal("slug"),
+    project_id: import_zod.z.string(),
+    slug: import_zod.z.string()
+  })
+]);
+var PromptBlockDataNullish = import_zod.z.union([
+  import_zod.z.object({ type: import_zod.z.literal("completion"), content: import_zod.z.string() }),
+  import_zod.z.object({
+    type: import_zod.z.literal("chat"),
+    messages: import_zod.z.array(ChatCompletionMessageParam),
+    tools: import_zod.z.string().optional()
+  }),
+  import_zod.z.null()
+]);
+var ModelParams = import_zod.z.union([
+  import_zod.z.object({
+    use_cache: import_zod.z.boolean(),
+    temperature: import_zod.z.number(),
+    top_p: import_zod.z.number(),
+    max_tokens: import_zod.z.number(),
+    max_completion_tokens: import_zod.z.number(),
+    frequency_penalty: import_zod.z.number(),
+    presence_penalty: import_zod.z.number(),
+    response_format: ResponseFormat,
+    tool_choice: import_zod.z.union([
+      import_zod.z.literal("auto"),
+      import_zod.z.literal("none"),
+      import_zod.z.literal("required"),
+      import_zod.z.object({
+        type: import_zod.z.literal("function"),
+        function: import_zod.z.object({ name: import_zod.z.string() })
+      })
+    ]),
+    function_call: import_zod.z.union([
+      import_zod.z.literal("auto"),
+      import_zod.z.literal("none"),
+      import_zod.z.object({ name: import_zod.z.string() })
+    ]),
+    n: import_zod.z.number(),
+    stop: import_zod.z.array(import_zod.z.string()),
+    reasoning_effort: import_zod.z.enum(["minimal", "low", "medium", "high"]),
+    verbosity: import_zod.z.enum(["low", "medium", "high"])
+  }).partial().passthrough(),
+  import_zod.z.object({
+    use_cache: import_zod.z.boolean().optional(),
+    max_tokens: import_zod.z.number(),
+    temperature: import_zod.z.number(),
+    top_p: import_zod.z.number().optional(),
+    top_k: import_zod.z.number().optional(),
+    stop_sequences: import_zod.z.array(import_zod.z.string()).optional(),
+    max_tokens_to_sample: import_zod.z.number().optional()
+  }).passthrough(),
+  import_zod.z.object({
+    use_cache: import_zod.z.boolean(),
+    temperature: import_zod.z.number(),
+    maxOutputTokens: import_zod.z.number(),
+    topP: import_zod.z.number(),
+    topK: import_zod.z.number()
+  }).partial().passthrough(),
+  import_zod.z.object({
+    use_cache: import_zod.z.boolean(),
+    temperature: import_zod.z.number(),
+    topK: import_zod.z.number()
+  }).partial().passthrough(),
+  import_zod.z.object({ use_cache: import_zod.z.boolean() }).partial().passthrough()
+]);
+var PromptOptionsNullish = import_zod.z.union([
+  import_zod.z.object({ model: import_zod.z.string(), params: ModelParams, position: import_zod.z.string() }).partial(),
+  import_zod.z.null()
+]);
+var PromptParserNullish = import_zod.z.union([
+  import_zod.z.object({
+    type: import_zod.z.literal("llm_classifier"),
+    use_cot: import_zod.z.boolean(),
+    choice_scores: import_zod.z.record(import_zod.z.number().gte(0).lte(1))
+  }),
+  import_zod.z.null()
+]);
+var SavedFunctionId = import_zod.z.union([
+  import_zod.z.object({ type: import_zod.z.literal("function"), id: import_zod.z.string() }),
+  import_zod.z.object({ type: import_zod.z.literal("global"), name: import_zod.z.string() })
+]);
+var PromptDataNullish = import_zod.z.union([
+  import_zod.z.object({
+    prompt: PromptBlockDataNullish,
+    options: PromptOptionsNullish,
+    parser: PromptParserNullish,
+    tool_functions: import_zod.z.union([import_zod.z.array(SavedFunctionId), import_zod.z.null()]),
+    origin: import_zod.z.union([
+      import_zod.z.object({
+        prompt_id: import_zod.z.string(),
+        project_id: import_zod.z.string(),
+        prompt_version: import_zod.z.string()
+      }).partial(),
+      import_zod.z.null()
+    ])
+  }).partial(),
+  import_zod.z.null()
+]);
+var FunctionTypeEnumNullish = import_zod.z.union([
+  import_zod.z.enum(["llm", "scorer", "task", "tool"]),
+  import_zod.z.null()
+]);
+var FunctionIdRef = import_zod.z.object({}).partial().passthrough();
+var PromptBlockData = import_zod.z.union([
+  import_zod.z.object({ type: import_zod.z.literal("completion"), content: import_zod.z.string() }),
+  import_zod.z.object({
+    type: import_zod.z.literal("chat"),
+    messages: import_zod.z.array(ChatCompletionMessageParam),
+    tools: import_zod.z.string().optional()
+  })
+]);
+var GraphNode = import_zod.z.union([
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("function"),
+    function: FunctionIdRef
+  }),
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("input")
+  }),
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("output")
+  }),
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("literal"),
+    value: import_zod.z.unknown().optional()
+  }),
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("btql"),
+    expr: import_zod.z.string()
+  }),
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("gate"),
+    condition: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  }),
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("aggregator")
+  }),
+  import_zod.z.object({
+    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
+    type: import_zod.z.literal("prompt_template"),
+    prompt: PromptBlockData
+  })
+]);
+var GraphEdge = import_zod.z.object({
+  source: import_zod.z.object({ node: import_zod.z.string().max(1024), variable: import_zod.z.string() }),
+  target: import_zod.z.object({ node: import_zod.z.string().max(1024), variable: import_zod.z.string() }),
+  purpose: import_zod.z.enum(["control", "data", "messages"])
+});
+var GraphData = import_zod.z.object({
+  type: import_zod.z.literal("graph"),
+  nodes: import_zod.z.record(GraphNode),
+  edges: import_zod.z.record(GraphEdge)
+});
+var FunctionData = import_zod.z.union([
+  import_zod.z.object({ type: import_zod.z.literal("prompt") }),
+  import_zod.z.object({
+    type: import_zod.z.literal("code"),
+    data: import_zod.z.union([
+      import_zod.z.object({ type: import_zod.z.literal("bundle") }).and(CodeBundle),
+      import_zod.z.object({
+        type: import_zod.z.literal("inline"),
+        runtime_context: import_zod.z.object({
+          runtime: import_zod.z.enum(["node", "python"]),
+          version: import_zod.z.string()
+        }),
+        code: import_zod.z.string()
+      })
+    ])
+  }),
+  GraphData,
+  import_zod.z.object({
+    type: import_zod.z.literal("remote_eval"),
+    endpoint: import_zod.z.string(),
+    eval_name: import_zod.z.string(),
+    parameters: import_zod.z.object({}).partial().passthrough()
+  }),
+  import_zod.z.object({ type: import_zod.z.literal("global"), name: import_zod.z.string() })
+]);
+var Function2 = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  _xact_id: import_zod.z.string(),
+  project_id: import_zod.z.string().uuid(),
+  log_id: import_zod.z.literal("p"),
+  org_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  slug: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  prompt_data: PromptDataNullish.optional(),
+  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
+  function_type: FunctionTypeEnumNullish.optional(),
+  function_data: FunctionData,
+  origin: import_zod.z.union([
+    import_zod.z.object({
+      object_type: AclObjectType.and(import_zod.z.string()),
+      object_id: import_zod.z.string().uuid(),
+      internal: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+    }),
+    import_zod.z.null()
+  ]).optional(),
+  function_schema: import_zod.z.union([
+    import_zod.z.object({ parameters: import_zod.z.unknown(), returns: import_zod.z.unknown() }).partial(),
+    import_zod.z.null()
+  ]).optional()
+});
+var FunctionFormat = import_zod.z.enum(["llm", "code", "global", "graph"]);
+var PromptData = import_zod.z.object({
+  prompt: PromptBlockDataNullish,
+  options: PromptOptionsNullish,
+  parser: PromptParserNullish,
+  tool_functions: import_zod.z.union([import_zod.z.array(SavedFunctionId), import_zod.z.null()]),
+  origin: import_zod.z.union([
+    import_zod.z.object({
+      prompt_id: import_zod.z.string(),
+      project_id: import_zod.z.string(),
+      prompt_version: import_zod.z.string()
+    }).partial(),
+    import_zod.z.null()
+  ])
+}).partial();
+var FunctionTypeEnum = import_zod.z.enum(["llm", "scorer", "task", "tool"]);
+var FunctionId = import_zod.z.union([
+  import_zod.z.object({ function_id: import_zod.z.string(), version: import_zod.z.string().optional() }),
   import_zod.z.object({
-    type: import_zod.z.literal("text_delta"),
-    data: import_zod.z.string()
+    project_name: import_zod.z.string(),
+    slug: import_zod.z.string(),
+    version: import_zod.z.string().optional()
   }),
+  import_zod.z.object({ global_function: import_zod.z.string() }),
   import_zod.z.object({
-    type: import_zod.z.literal("reasoning_delta"),
-    data: import_zod.z.string()
+    prompt_session_id: import_zod.z.string(),
+    prompt_session_function_id: import_zod.z.string(),
+    version: import_zod.z.string().optional()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("json_delta"),
-    data: import_zod.z.string()
+    inline_context: import_zod.z.object({
+      runtime: import_zod.z.enum(["node", "python"]),
+      version: import_zod.z.string()
+    }),
+    code: import_zod.z.string(),
+    name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("error"),
-    data: import_zod.z.string()
+    inline_prompt: PromptData.optional(),
+    inline_function: import_zod.z.object({}).partial().passthrough(),
+    function_type: FunctionTypeEnum.optional(),
+    name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("console"),
-    data: import_typespecs.sseConsoleEventDataSchema
+    inline_prompt: PromptData,
+    function_type: FunctionTypeEnum.optional(),
+    name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  })
+]);
+var FunctionObjectType = import_zod.z.enum([
+  "prompt",
+  "tool",
+  "scorer",
+  "task",
+  "agent"
+]);
+var FunctionOutputType = import_zod.z.enum(["completion", "score", "any"]);
+var GitMetadataSettings = import_zod.z.object({
+  collect: import_zod.z.enum(["all", "none", "some"]),
+  fields: import_zod.z.array(
+    import_zod.z.enum([
+      "commit",
+      "branch",
+      "tag",
+      "dirty",
+      "author_name",
+      "author_email",
+      "commit_message",
+      "commit_time",
+      "git_diff"
+    ])
+  ).optional()
+});
+var Group = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  org_id: import_zod.z.string().uuid(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  member_users: import_zod.z.union([import_zod.z.array(import_zod.z.string().uuid()), import_zod.z.null()]).optional(),
+  member_groups: import_zod.z.union([import_zod.z.array(import_zod.z.string().uuid()), import_zod.z.null()]).optional()
+});
+var IfExists = import_zod.z.enum(["error", "ignore", "replace"]);
+var InvokeParent = import_zod.z.union([
+  import_zod.z.object({
+    object_type: import_zod.z.enum(["project_logs", "experiment", "playground_logs"]),
+    object_id: import_zod.z.string(),
+    row_ids: import_zod.z.union([
+      import_zod.z.object({
+        id: import_zod.z.string(),
+        span_id: import_zod.z.string(),
+        root_span_id: import_zod.z.string()
+      }),
+      import_zod.z.null()
+    ]).optional(),
+    propagated_event: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
   }),
+  import_zod.z.string()
+]);
+var StreamingMode = import_zod.z.union([import_zod.z.enum(["auto", "parallel"]), import_zod.z.null()]);
+var InvokeFunction = FunctionId.and(
   import_zod.z.object({
-    type: import_zod.z.literal("progress"),
-    data: import_typespecs.sseProgressEventDataSchema
+    input: import_zod.z.unknown(),
+    expected: import_zod.z.unknown(),
+    metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]),
+    tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]),
+    messages: import_zod.z.array(ChatCompletionMessageParam),
+    parent: InvokeParent,
+    stream: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
+    mode: StreamingMode,
+    strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()])
+  }).partial()
+);
+var MessageRole = import_zod.z.enum([
+  "system",
+  "user",
+  "assistant",
+  "function",
+  "tool",
+  "model",
+  "developer"
+]);
+var OnlineScoreConfig = import_zod.z.union([
+  import_zod.z.object({
+    sampling_rate: import_zod.z.number().gte(0).lte(1),
+    scorers: import_zod.z.array(SavedFunctionId),
+    btql_filter: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+    apply_to_root_span: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+    apply_to_span_names: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+    skip_logging: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
   }),
+  import_zod.z.null()
+]);
+var Organization = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  api_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  is_universal_api: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  proxy_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  realtime_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var ProjectSettings = import_zod.z.union([
   import_zod.z.object({
-    type: import_zod.z.literal("start"),
-    data: import_zod.z.string()
+    comparison_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    baseline_experiment_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    spanFieldOrder: import_zod.z.union([
+      import_zod.z.array(
+        import_zod.z.object({
+          object_type: import_zod.z.string(),
+          column_id: import_zod.z.string(),
+          position: import_zod.z.string(),
+          layout: import_zod.z.union([import_zod.z.literal("full"), import_zod.z.literal("two_column"), import_zod.z.null()]).optional()
+        })
+      ),
+      import_zod.z.null()
+    ]),
+    remote_eval_sources: import_zod.z.union([
+      import_zod.z.array(
+        import_zod.z.object({
+          url: import_zod.z.string(),
+          name: import_zod.z.string(),
+          description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+        })
+      ),
+      import_zod.z.null()
+    ])
+  }).partial(),
+  import_zod.z.null()
+]);
+var Project = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  org_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  settings: ProjectSettings.optional()
+});
+var RetentionObjectType = import_zod.z.enum([
+  "project_logs",
+  "experiment",
+  "dataset"
+]);
+var ProjectAutomation = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  project_id: import_zod.z.string().uuid(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  config: import_zod.z.union([
+    import_zod.z.object({
+      event_type: import_zod.z.literal("logs"),
+      btql_filter: import_zod.z.string(),
+      interval_seconds: import_zod.z.number().gte(1).lte(2592e3),
+      action: import_zod.z.object({ type: import_zod.z.literal("webhook"), url: import_zod.z.string() })
+    }),
+    import_zod.z.object({
+      event_type: import_zod.z.literal("btql_export"),
+      export_definition: import_zod.z.union([
+        import_zod.z.object({ type: import_zod.z.literal("log_traces") }),
+        import_zod.z.object({ type: import_zod.z.literal("log_spans") }),
+        import_zod.z.object({ type: import_zod.z.literal("btql_query"), btql_query: import_zod.z.string() })
+      ]),
+      export_path: import_zod.z.string(),
+      format: import_zod.z.enum(["jsonl", "parquet"]),
+      interval_seconds: import_zod.z.number().gte(1).lte(2592e3),
+      credentials: import_zod.z.object({
+        type: import_zod.z.literal("aws_iam"),
+        role_arn: import_zod.z.string(),
+        external_id: import_zod.z.string()
+      }),
+      batch_size: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional()
+    }),
+    import_zod.z.object({
+      event_type: import_zod.z.literal("retention"),
+      object_type: RetentionObjectType,
+      retention_days: import_zod.z.number().gte(0)
+    })
+  ])
+});
+var ProjectLogsEvent = import_zod.z.object({
+  id: import_zod.z.string(),
+  _xact_id: import_zod.z.string(),
+  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.string().datetime({ offset: true }),
+  org_id: import_zod.z.string().uuid(),
+  project_id: import_zod.z.string().uuid(),
+  log_id: import_zod.z.literal("g"),
+  input: import_zod.z.unknown().optional(),
+  output: import_zod.z.unknown().optional(),
+  expected: import_zod.z.unknown().optional(),
+  error: import_zod.z.unknown().optional(),
+  scores: import_zod.z.union([import_zod.z.record(import_zod.z.union([import_zod.z.number(), import_zod.z.null()])), import_zod.z.null()]).optional(),
+  metadata: import_zod.z.union([
+    import_zod.z.object({ model: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]) }).partial().passthrough(),
+    import_zod.z.null()
+  ]).optional(),
+  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+  metrics: import_zod.z.union([import_zod.z.record(import_zod.z.number()), import_zod.z.null()]).optional(),
+  context: import_zod.z.union([
+    import_zod.z.object({
+      caller_functionname: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      caller_filename: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      caller_lineno: import_zod.z.union([import_zod.z.number(), import_zod.z.null()])
+    }).partial().passthrough(),
+    import_zod.z.null()
+  ]).optional(),
+  span_id: import_zod.z.string(),
+  span_parents: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+  root_span_id: import_zod.z.string(),
+  is_root: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  span_attributes: SpanAttributes.optional(),
+  origin: ObjectReference.optional()
+});
+var ProjectScoreType = import_zod.z.enum([
+  "slider",
+  "categorical",
+  "weighted",
+  "minimum",
+  "maximum",
+  "online",
+  "free-form"
+]);
+var ProjectScoreCategory = import_zod.z.object({
+  name: import_zod.z.string(),
+  value: import_zod.z.number()
+});
+var ProjectScoreCategories = import_zod.z.union([
+  import_zod.z.array(ProjectScoreCategory),
+  import_zod.z.record(import_zod.z.number()),
+  import_zod.z.array(import_zod.z.string()),
+  import_zod.z.null()
+]);
+var ProjectScoreConfig = import_zod.z.union([
+  import_zod.z.object({
+    multi_select: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
+    destination: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    online: OnlineScoreConfig
+  }).partial(),
+  import_zod.z.null()
+]);
+var ProjectScore = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  project_id: import_zod.z.string().uuid(),
+  user_id: import_zod.z.string().uuid(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  score_type: ProjectScoreType,
+  categories: ProjectScoreCategories.optional(),
+  config: ProjectScoreConfig.optional(),
+  position: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var ProjectTag = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  project_id: import_zod.z.string().uuid(),
+  user_id: import_zod.z.string().uuid(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  color: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  position: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var Prompt = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  _xact_id: import_zod.z.string(),
+  project_id: import_zod.z.string().uuid(),
+  log_id: import_zod.z.literal("p"),
+  org_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  slug: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  prompt_data: PromptDataNullish.optional(),
+  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
+  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
+  function_type: FunctionTypeEnumNullish.optional()
+});
+var PromptOptions = import_zod.z.object({ model: import_zod.z.string(), params: ModelParams, position: import_zod.z.string() }).partial();
+var PromptSessionEvent = import_zod.z.object({
+  id: import_zod.z.string(),
+  _xact_id: import_zod.z.string(),
+  created: import_zod.z.string().datetime({ offset: true }),
+  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  project_id: import_zod.z.string().uuid(),
+  prompt_session_id: import_zod.z.string().uuid(),
+  prompt_session_data: import_zod.z.unknown().optional(),
+  prompt_data: import_zod.z.unknown().optional(),
+  function_data: import_zod.z.unknown().optional(),
+  function_type: FunctionTypeEnumNullish.optional(),
+  object_data: import_zod.z.unknown().optional(),
+  completion: import_zod.z.unknown().optional(),
+  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional()
+});
+var Role = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  org_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  member_permissions: import_zod.z.union([
+    import_zod.z.array(
+      import_zod.z.object({
+        permission: Permission,
+        restrict_object_type: AclObjectType.optional()
+      })
+    ),
+    import_zod.z.null()
+  ]).optional(),
+  member_roles: import_zod.z.union([import_zod.z.array(import_zod.z.string().uuid()), import_zod.z.null()]).optional()
+});
+var RunEval = import_zod.z.object({
+  project_id: import_zod.z.string(),
+  data: import_zod.z.union([
+    import_zod.z.object({
+      dataset_id: import_zod.z.string(),
+      _internal_btql: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
+    }),
+    import_zod.z.object({
+      project_name: import_zod.z.string(),
+      dataset_name: import_zod.z.string(),
+      _internal_btql: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
+    }),
+    import_zod.z.object({ data: import_zod.z.array(import_zod.z.unknown()) })
+  ]),
+  task: FunctionId.and(import_zod.z.unknown()),
+  scores: import_zod.z.array(FunctionId),
+  experiment_name: import_zod.z.string().optional(),
+  metadata: import_zod.z.object({}).partial().passthrough().optional(),
+  parent: InvokeParent.and(import_zod.z.unknown()).optional(),
+  stream: import_zod.z.boolean().optional(),
+  trial_count: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional(),
+  is_public: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  timeout: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional(),
+  max_concurrency: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional().default(10),
+  base_experiment_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  base_experiment_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  git_metadata_settings: GitMetadataSettings.and(
+    import_zod.z.union([import_zod.z.object({}).partial(), import_zod.z.null()])
+  ).optional(),
+  repo_info: RepoInfo.and(import_zod.z.unknown()).optional(),
+  strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  stop_token: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  extra_messages: import_zod.z.string().optional(),
+  tags: import_zod.z.array(import_zod.z.string()).optional()
+});
+var ServiceToken = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  preview_name: import_zod.z.string(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_given_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  user_family_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  org_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var SpanIFrame = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  project_id: import_zod.z.string().uuid(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_zod.z.string(),
+  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  url: import_zod.z.string(),
+  post_message: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+});
+var SSEConsoleEventData = import_zod.z.object({
+  stream: import_zod.z.enum(["stderr", "stdout"]),
+  message: import_zod.z.string()
+});
+var SSEProgressEventData = import_zod.z.object({
+  id: import_zod.z.string(),
+  object_type: FunctionObjectType,
+  origin: ObjectReference.and(import_zod.z.unknown()).optional(),
+  format: FunctionFormat,
+  output_type: FunctionOutputType,
+  name: import_zod.z.string(),
+  event: import_zod.z.enum([
+    "reasoning_delta",
+    "text_delta",
+    "json_delta",
+    "error",
+    "console",
+    "start",
+    "done",
+    "progress"
+  ]),
+  data: import_zod.z.string()
+});
+var ToolFunctionDefinition = import_zod.z.object({
+  type: import_zod.z.literal("function"),
+  function: import_zod.z.object({
+    name: import_zod.z.string(),
+    description: import_zod.z.string().optional(),
+    parameters: import_zod.z.object({}).partial().passthrough().optional(),
+    strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+  })
+});
+var User = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  given_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  family_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  avatar_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+var ViewDataSearch = import_zod.z.union([
+  import_zod.z.object({
+    filter: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()]),
+    tag: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()]),
+    match: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()]),
+    sort: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()])
+  }).partial(),
+  import_zod.z.null()
+]);
+var ViewData = import_zod.z.union([
+  import_zod.z.object({ search: ViewDataSearch }).partial(),
+  import_zod.z.null()
+]);
+var ViewOptions = import_zod.z.union([
+  import_zod.z.object({
+    viewType: import_zod.z.literal("monitor"),
+    options: import_zod.z.object({
+      spanType: import_zod.z.union([import_zod.z.enum(["range", "frame"]), import_zod.z.null()]),
+      rangeValue: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      frameStart: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      frameEnd: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      tzUTC: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
+      chartVisibility: import_zod.z.union([import_zod.z.record(import_zod.z.boolean()), import_zod.z.null()]),
+      projectId: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+      type: import_zod.z.union([import_zod.z.enum(["project", "experiment"]), import_zod.z.null()]),
+      groupBy: import_zod.z.union([import_zod.z.string(), import_zod.z.null()])
+    }).partial()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("done"),
-    data: import_zod.z.string()
+    columnVisibility: import_zod.z.union([import_zod.z.record(import_zod.z.boolean()), import_zod.z.null()]),
+    columnOrder: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]),
+    columnSizing: import_zod.z.union([import_zod.z.record(import_zod.z.number()), import_zod.z.null()]),
+    grouping: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    rowHeight: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    tallGroupRows: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
+    layout: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    chartHeight: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]),
+    excludedMeasures: import_zod.z.union([
+      import_zod.z.array(
+        import_zod.z.object({
+          type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
+          value: import_zod.z.string()
+        })
+      ),
+      import_zod.z.null()
+    ]),
+    yMetric: import_zod.z.union([
+      import_zod.z.object({
+        type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
+        value: import_zod.z.string()
+      }),
+      import_zod.z.null()
+    ]),
+    xAxis: import_zod.z.union([
+      import_zod.z.object({
+        type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
+        value: import_zod.z.string()
+      }),
+      import_zod.z.null()
+    ]),
+    symbolGrouping: import_zod.z.union([
+      import_zod.z.object({
+        type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
+        value: import_zod.z.string()
+      }),
+      import_zod.z.null()
+    ]),
+    xAxisAggregation: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+    chartAnnotations: import_zod.z.union([
+      import_zod.z.array(import_zod.z.object({ id: import_zod.z.string(), text: import_zod.z.string() })),
+      import_zod.z.null()
+    ]),
+    timeRangeFilter: import_zod.z.union([
+      import_zod.z.string(),
+      import_zod.z.object({ from: import_zod.z.string(), to: import_zod.z.string() }),
+      import_zod.z.null()
+    ])
+  }).partial(),
+  import_zod.z.null()
+]);
+var View = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  object_type: AclObjectType.and(import_zod.z.string()),
+  object_id: import_zod.z.string().uuid(),
+  view_type: import_zod.z.enum([
+    "projects",
+    "experiments",
+    "experiment",
+    "playgrounds",
+    "playground",
+    "datasets",
+    "dataset",
+    "prompts",
+    "tools",
+    "scorers",
+    "logs",
+    "agents",
+    "monitor"
+  ]),
+  name: import_zod.z.string(),
+  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  view_data: ViewData.optional(),
+  options: ViewOptions.optional(),
+  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+});
+
+// src/logger.ts
+var import_functions = require("@vercel/functions");
+var import_mustache2 = __toESM(require("mustache"));
+var import_zod3 = require("zod");
+
+// src/functions/stream.ts
+var import_eventsource_parser = require("eventsource-parser");
+var import_zod2 = require("zod");
+var braintrustStreamChunkSchema = import_zod2.z.union([
+  import_zod2.z.object({
+    type: import_zod2.z.literal("text_delta"),
+    data: import_zod2.z.string()
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("reasoning_delta"),
+    data: import_zod2.z.string()
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("json_delta"),
+    data: import_zod2.z.string()
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("error"),
+    data: import_zod2.z.string()
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("console"),
+    data: SSEConsoleEventData
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("progress"),
+    data: SSEProgressEventData
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("start"),
+    data: import_zod2.z.string()
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("done"),
+    data: import_zod2.z.string()
   })
 ]);
 var BraintrustStream = class _BraintrustStream {
@@ -1583,12 +2802,12 @@ var BraintrustStream = class _BraintrustStream {
       case "progress":
         return {
           type: "progress",
-          data: import_typespecs.sseProgressEventDataSchema.parse(JSON.parse(event.data))
+          data: SSEProgressEventData.parse(JSON.parse(event.data))
         };
       case "console":
         return {
           type: "console",
-          data: import_typespecs.sseConsoleEventDataSchema.parse(JSON.parse(event.data))
+          data: SSEConsoleEventData.parse(JSON.parse(event.data))
         };
       case "start":
         return {
@@ -1664,7 +2883,7 @@ function btStreamParser() {
         if (event.type === "reconnect-interval") {
           return;
         }
-        const parsed = import_typespecs.callEventSchema.safeParse(event);
+        const parsed = CallEvent.safeParse(event);
         if (!parsed.success) {
           throw new Error(`Failed to parse event: ${parsed.error}`);
         }
@@ -2107,6 +3326,44 @@ function getMustacheVars(prompt) {
 }
 
 // src/logger.ts
+var import_core3 = require("@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;
@@ -2157,15 +3414,15 @@ var NoopSpan = class {
 };
 var NOOP_SPAN = new NoopSpan();
 var NOOP_SPAN_PERMALINK = "https://braintrust.dev/noop-span";
-var loginSchema = import_zod2.z.strictObject({
-  appUrl: import_zod2.z.string(),
-  appPublicUrl: import_zod2.z.string(),
-  orgName: import_zod2.z.string(),
-  apiUrl: import_zod2.z.string(),
-  proxyUrl: import_zod2.z.string(),
-  loginToken: import_zod2.z.string(),
-  orgId: import_zod2.z.string().nullish(),
-  gitMetadataSettings: import_typespecs2.gitMetadataSettingsSchema.nullish()
+var loginSchema = import_zod3.z.strictObject({
+  appUrl: import_zod3.z.string(),
+  appPublicUrl: import_zod3.z.string(),
+  orgName: import_zod3.z.string(),
+  apiUrl: import_zod3.z.string(),
+  proxyUrl: import_zod3.z.string(),
+  loginToken: import_zod3.z.string(),
+  orgId: import_zod3.z.string().nullish(),
+  gitMetadataSettings: GitMetadataSettings.nullish()
 });
 var stateNonce = 0;
 var BraintrustState = class _BraintrustState {
@@ -2307,6 +3564,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;
@@ -2548,7 +3808,7 @@ var Attachment = class extends BaseAttachment {
   constructor({ data, filename, contentType, state }) {
     super();
     this.reference = {
-      type: import_typespecs2.BRAINTRUST_ATTACHMENT,
+      type: BRAINTRUST_ATTACHMENT,
       filename,
       content_type: contentType,
       key: newId()
@@ -2614,12 +3874,12 @@ var Attachment = class extends BaseAttachment {
       let signedUrl;
       let headers;
       try {
-        ({ signedUrl, headers } = import_zod2.z.object({
-          signedUrl: import_zod2.z.string().url(),
-          headers: import_zod2.z.record(import_zod2.z.string())
+        ({ signedUrl, headers } = import_zod3.z.object({
+          signedUrl: import_zod3.z.string().url(),
+          headers: import_zod3.z.record(import_zod3.z.string())
         }).parse(await metadataResponse.json()));
       } catch (error2) {
-        if (error2 instanceof import_zod2.ZodError) {
+        if (error2 instanceof import_zod3.ZodError) {
           const errorStr = JSON.stringify(error2.flatten());
           throw new Error(`Invalid response from API server: ${errorStr}`);
         }
@@ -2676,6 +3936,7 @@ var Attachment = class extends BaseAttachment {
   }
   initData(data) {
     if (typeof data === "string") {
+      this.ensureFileReadable(data);
       const readFile3 = isomorph_default.readFile;
       if (!readFile3) {
         throw new Error(
@@ -2688,10 +3949,24 @@ 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 attachmentMetadataSchema = import_zod2.z.object({
-  downloadUrl: import_zod2.z.string(),
-  status: import_typespecs2.attachmentStatusSchema
+var attachmentMetadataSchema = import_zod3.z.object({
+  downloadUrl: import_zod3.z.string(),
+  status: AttachmentStatus
 });
 var ReadonlyAttachment = class {
   /**
@@ -3216,6 +4491,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;
@@ -3283,6 +4559,9 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
     }
     this.onFlushError = opts.onFlushError;
   }
+  setMaskingFunction(maskingFunction) {
+    this.maskingFunction = maskingFunction;
+  }
   log(items) {
     if (this._disabled) {
       return;
@@ -3379,7 +4658,36 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
         const items = await Promise.all(wrappedItems.map((x) => x.get()));
         const attachments = [];
         items.forEach((item) => extractAttachments(item, attachments));
-        return [(0, import_core2.mergeRowBatch)(items), attachments];
+        let mergedItems = (0, import_core2.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;
@@ -3727,7 +5035,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;
   }
@@ -3795,7 +5103,7 @@ function initDataset(projectOrOptions, optionalOptions) {
       };
     }
   );
-  return new Dataset(
+  return new Dataset2(
     stateArg ?? _globalState,
     lazyMetadata,
     version2,
@@ -4143,13 +5451,13 @@ function validateAndSanitizeExperimentLogPartialArgs(event) {
 function deepCopyEvent(event) {
   const attachments = [];
   const IDENTIFIER = "_bt_internal_saved_attachment";
-  const savedAttachmentSchema = import_zod2.z.strictObject({ [IDENTIFIER]: import_zod2.z.number() });
+  const savedAttachmentSchema = import_zod3.z.strictObject({ [IDENTIFIER]: import_zod3.z.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>`;
@@ -4180,10 +5488,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (value?.type === import_typespecs2.BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (value?.type === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (value?.reference?.type === import_typespecs2.BRAINTRUST_ATTACHMENT && value?.uploader) {
+    if (value?.reference?.type === BRAINTRUST_ATTACHMENT && value?.uploader) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -4201,7 +5509,7 @@ function extractAttachments(event, attachments) {
 }
 function enrichAttachments(event, state) {
   for (const [key, value] of Object.entries(event)) {
-    const parsedValue = import_typespecs2.attachmentReferenceSchema.safeParse(value);
+    const parsedValue = AttachmentReference.safeParse(value);
     if (parsedValue.success) {
       event[key] = new ReadonlyAttachment(parsedValue.data, state);
       continue;
@@ -4344,7 +5652,7 @@ var ObjectFetcher = class {
     }
   }
 };
-var Experiment = class extends ObjectFetcher {
+var Experiment2 = class extends ObjectFetcher {
   lazyMetadata;
   dataset;
   lastStartTime;
@@ -4950,7 +6258,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 ?? import_core2.DEFAULT_IS_LEGACY_DATASET;
     if (isLegacyDataset) {
@@ -5148,8 +6456,8 @@ var Dataset = class extends ObjectFetcher {
     )}`;
     let dataSummary;
     if (summarizeData) {
-      const rawDataSummary = import_zod2.z.object({
-        total_records: import_zod2.z.number()
+      const rawDataSummary = import_zod3.z.object({
+        total_records: import_zod3.z.number()
       }).parse(
         await state.apiConn().get_json(
           "dataset-summary",
@@ -5272,11 +6580,11 @@ function renderTemplatedObject(obj, args, options) {
   return obj;
 }
 function renderPromptParams(params, args, options) {
-  const schemaParsed = import_zod2.z.object({
-    response_format: import_zod2.z.object({
-      type: import_zod2.z.literal("json_schema"),
-      json_schema: import_typespecs2.responseFormatJsonSchemaSchema.omit({ schema: true }).extend({
-        schema: import_zod2.z.unknown()
+  const schemaParsed = import_zod3.z.object({
+    response_format: import_zod3.z.object({
+      type: import_zod3.z.literal("json_schema"),
+      json_schema: ResponseFormatJsonSchema.omit({ schema: true }).extend({
+        schema: import_zod3.z.unknown()
       })
     })
   }).safeParse(params);
@@ -5297,7 +6605,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;
@@ -5365,7 +6673,7 @@ var Prompt = class _Prompt {
       ...this.defaults,
       ...Object.fromEntries(
         Object.entries(this.options.params || {}).filter(
-          ([k, _v]) => !import_typespecs2.BRAINTRUST_PARAMS.includes(k)
+          ([k, _v]) => !BRAINTRUST_PARAMS.includes(k)
         )
       ),
       ...!isEmpty(this.options.model) ? {
@@ -5394,7 +6702,7 @@ var Prompt = class _Prompt {
     if (!prompt) {
       throw new Error("Empty prompt");
     }
-    const dictArgParsed = import_zod2.z.record(import_zod2.z.unknown()).safeParse(buildArgs);
+    const dictArgParsed = import_zod3.z.record(import_zod3.z.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -5415,7 +6723,7 @@ var Prompt = class _Prompt {
         ...spanInfo,
         messages: renderedPrompt.messages,
         ...renderedPrompt.tools ? {
-          tools: import_typespecs2.toolsSchema.parse(JSON.parse(renderedPrompt.tools))
+          tools: ChatCompletionTool.array().parse(JSON.parse(renderedPrompt.tools))
         } : void 0
       };
     } else if (flavor === "completion") {
@@ -5449,7 +6757,7 @@ var Prompt = class _Prompt {
         return JSON.stringify(v);
       }
     };
-    const dictArgParsed = import_zod2.z.record(import_zod2.z.unknown()).safeParse(buildArgs);
+    const dictArgParsed = import_zod3.z.record(import_zod3.z.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -5502,7 +6810,7 @@ var Prompt = class _Prompt {
   }
   getParsedPromptData() {
     if (!this.hasParsedPromptData) {
-      this.parsedPromptData = import_typespecs2.promptDataSchema.parse(this.metadata.prompt_data);
+      this.parsedPromptData = PromptData.parse(this.metadata.prompt_data);
       this.hasParsedPromptData = true;
     }
     return this.parsedPromptData;
@@ -5571,7 +6879,7 @@ var BarProgressReporter = class {
 };
 
 // src/framework.ts
-var import_core4 = require("@braintrust/core");
+var import_core5 = require("@braintrust/core");
 
 // ../../node_modules/.pnpm/async@3.2.5/node_modules/async/dist/async.mjs
 function initialParams(fn) {
@@ -6615,21 +7923,20 @@ var import_chalk = __toESM(require("chalk"));
 var import_pluralize = __toESM(require("pluralize"));
 
 // src/eval-parameters.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/framework2.ts
 var import_path = __toESM(require("path"));
 var import_slugify = __toESM(require("slugify"));
-var import_zod3 = require("zod");
-var import_typespecs3 = require("@braintrust/core/typespecs");
-var import_core3 = require("@braintrust/core");
+var import_zod4 = require("zod");
+var import_core4 = require("@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;
@@ -6856,23 +8163,23 @@ var CodePrompt = class {
     };
   }
 };
-var promptContentsSchema = import_zod3.z.union([
-  import_zod3.z.object({
-    prompt: import_zod3.z.string()
+var promptContentsSchema = import_zod4.z.union([
+  import_zod4.z.object({
+    prompt: import_zod4.z.string()
   }),
-  import_zod3.z.object({
-    messages: import_zod3.z.array(import_typespecs3.chatCompletionMessageParamSchema)
+  import_zod4.z.object({
+    messages: import_zod4.z.array(ChatCompletionMessageParam)
   })
 ]);
 var promptDefinitionSchema = promptContentsSchema.and(
-  import_zod3.z.object({
-    model: import_zod3.z.string(),
-    params: import_typespecs3.modelParamsSchema.optional()
+  import_zod4.z.object({
+    model: import_zod4.z.string(),
+    params: ModelParams.optional()
   })
 );
 var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
-  import_zod3.z.object({
-    tools: import_zod3.z.array(import_typespecs3.toolFunctionDefinitionSchema).optional()
+  import_zod4.z.object({
+    tools: import_zod4.z.array(ToolFunctionDefinition).optional()
   })
 );
 var PromptBuilder = class {
@@ -6895,13 +8202,13 @@ var PromptBuilder = class {
     const promptData = promptDefinitionToPromptData(opts, rawTools);
     const promptRow = {
       id: opts.id,
-      _xact_id: opts.version ? (0, import_core3.loadPrettyXact)(opts.version) : void 0,
+      _xact_id: opts.version ? (0, import_core4.loadPrettyXact)(opts.version) : void 0,
       name: opts.name,
       slug,
       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.
@@ -6940,8 +8247,8 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
         project_name: projectName
       });
-      const result = import_zod3.z.object({
-        project: import_typespecs3.projectSchema
+      const result = import_zod4.z.object({
+        project: Project
       }).parse(response);
       const projectId = result.project.id;
       this.nameToId[projectName] = projectId;
@@ -6954,7 +8261,7 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
         id: projectId
       });
-      const result = import_zod3.z.array(import_typespecs3.projectSchema).nonempty().parse(response);
+      const result = import_zod4.z.array(Project).nonempty().parse(response);
       const projectName = result[0].name;
       this.idToName[projectId] = projectName;
       this.nameToId[projectName] = projectId;
@@ -6970,16 +8277,15 @@ var ProjectNameIdMap = class {
 };
 
 // src/eval-parameters.ts
-var import_typespecs4 = require("@braintrust/core/typespecs");
-var evalParametersSchema = import_zod4.z.record(
-  import_zod4.z.string(),
-  import_zod4.z.union([
-    import_zod4.z.object({
-      type: import_zod4.z.literal("prompt"),
+var evalParametersSchema = import_zod5.z.record(
+  import_zod5.z.string(),
+  import_zod5.z.union([
+    import_zod5.z.object({
+      type: import_zod5.z.literal("prompt"),
       default: promptDefinitionWithToolsSchema.optional(),
-      description: import_zod4.z.string().optional()
+      description: import_zod5.z.string().optional()
     }),
-    import_zod4.z.instanceof(import_zod4.z.ZodType)
+    import_zod5.z.instanceof(import_zod5.z.ZodType)
     // For Zod schemas
   ])
 );
@@ -6989,14 +8295,14 @@ function validateParameters(parameters, parameterSchema) {
       const value = parameters[name];
       try {
         if ("type" in schema && schema.type === "prompt") {
-          const promptData = value ? import_typespecs4.promptDataSchema.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)];
@@ -7113,7 +8419,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 });
@@ -7281,11 +8587,11 @@ 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: {
-          type: import_core4.SpanTypeAttribute.EVAL
+          type: import_core5.SpanTypeAttribute.EVAL
         },
         event: {
           input: datum.input,
@@ -7308,6 +8614,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;
@@ -7315,7 +8622,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,
@@ -7330,22 +8637,29 @@ 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 });
             },
             {
               name: "task",
-              spanAttributes: { type: import_core4.SpanTypeAttribute.TASK },
+              spanAttributes: { type: import_core5.SpanTypeAttribute.TASK },
               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,
@@ -7383,17 +8697,17 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                     return rest;
                   };
                   const resultMetadata = results3.length === 1 ? results3[0].metadata : results3.reduce(
-                    (prev, s) => (0, import_core4.mergeDicts)(prev, {
+                    (prev, s) => (0, import_core5.mergeDicts)(prev, {
                       [s.name]: s.metadata
                     }),
                     {}
                   );
                   const resultOutput = results3.length === 1 ? getOtherFields(results3[0]) : results3.reduce(
-                    (prev, s) => (0, import_core4.mergeDicts)(prev, { [s.name]: getOtherFields(s) }),
+                    (prev, s) => (0, import_core5.mergeDicts)(prev, { [s.name]: getOtherFields(s) }),
                     {}
                   );
                   const scores2 = results3.reduce(
-                    (prev, s) => (0, import_core4.mergeDicts)(prev, { [s.name]: s.score }),
+                    (prev, s) => (0, import_core5.mergeDicts)(prev, { [s.name]: s.score }),
                     {}
                   );
                   span.log({
@@ -7406,7 +8720,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                 const results2 = await rootSpan.traced(runScorer, {
                   name: scorerNames[score_idx],
                   spanAttributes: {
-                    type: import_core4.SpanTypeAttribute.SCORE
+                    type: import_core5.SpanTypeAttribute.SCORE
                   },
                   event: { input: scoringArgs }
                 });
@@ -7457,7 +8771,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({
@@ -7628,6 +8942,7 @@ var import_node_async_hooks = require("async_hooks");
 var path2 = __toESM(require("path"));
 var fs = __toESM(require("fs/promises"));
 var os = __toESM(require("os"));
+var fsSync = __toESM(require("fs"));
 var crypto = __toESM(require("crypto"));
 
 // src/gitutil.ts
@@ -7863,6 +9178,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;
@@ -7879,8 +9195,8 @@ var import_env2 = require("@next/env");
 var import_fs = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
 var import_zlib = require("zlib");
-var import_zod5 = require("zod");
-var import_core5 = require("@braintrust/core");
+var import_zod6 = require("zod");
+var import_core6 = require("@braintrust/core");
 
 // src/functions/infer-source.ts
 var import_source_map = require("source-map");
@@ -8136,9 +9452,9 @@ async function getTsModule() {
 var import_slugify2 = __toESM(require("slugify"));
 var import_zod_to_json_schema = require("zod-to-json-schema");
 var import_pluralize2 = __toESM(require("pluralize"));
-var pathInfoSchema = import_zod5.z.strictObject({
-  url: import_zod5.z.string(),
-  bundleId: import_zod5.z.string()
+var pathInfoSchema = import_zod6.z.strictObject({
+  url: import_zod6.z.string(),
+  bundleId: import_zod6.z.string()
 }).strip();
 async function uploadHandleBundles({
   buildResults,
@@ -8405,7 +9721,7 @@ async function uploadBundles({
 function formatNameAndSlug(pieces) {
   const nonEmptyPieces = pieces.filter((piece) => piece.trim() !== "");
   return {
-    name: (0, import_core5.capitalize)(nonEmptyPieces.join(" ")),
+    name: (0, import_core6.capitalize)(nonEmptyPieces.join(" ")),
     slug: (0, import_slugify2.default)(nonEmptyPieces.join("-"))
   };
 }
@@ -8478,13 +9794,12 @@ async function bundleCommand(args) {
 }
 
 // src/cli-util/pull.ts
-var import_typespecs5 = require("@braintrust/core/typespecs");
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var import_promises = __toESM(require("fs/promises"));
 var import_util5 = __toESM(require("util"));
 var import_slugify3 = __toESM(require("slugify"));
 var import_path5 = __toESM(require("path"));
-var import_core6 = require("@braintrust/core");
+var import_core7 = require("@braintrust/core");
 var import_pluralize3 = __toESM(require("pluralize"));
 async function pullCommand(args) {
   await loadCLIEnv(args);
@@ -8494,13 +9809,13 @@ async function pullCommand(args) {
     ...args.project_name ? { project_name: args.project_name } : {},
     ...args.slug ? { slug: args.slug } : {},
     ...args.id ? { ids: [args.id] } : {},
-    ...args.version ? { version: (0, import_core6.loadPrettyXact)(args.version) } : {}
+    ...args.version ? { version: (0, import_core7.loadPrettyXact)(args.version) } : {}
   });
-  const functionObjects = import_zod6.z.object({ objects: import_zod6.z.array(import_zod6.z.unknown()) }).parse(functions);
+  const functionObjects = import_zod7.z.object({ objects: import_zod7.z.array(import_zod7.z.unknown()) }).parse(functions);
   const projectNameToFunctions = {};
   const projectNameIdMap = new ProjectNameIdMap();
   for (const rawFunc of functionObjects.objects) {
-    const parsedFunc = import_typespecs5.functionSchema.safeParse(rawFunc);
+    const parsedFunc = Function2.safeParse(rawFunc);
     if (!parsedFunc.success) {
       const id = typeof rawFunc === "object" && rawFunc && "id" in rawFunc ? ` ${rawFunc.id}` : "";
       console.warn(
@@ -8659,7 +9974,7 @@ function makeFunctionDefinition({
   const objectType = "prompt";
   const prompt = func.prompt_data.prompt;
   const promptContents = prompt.type === "completion" ? `prompt: ${doubleQuote(prompt.content)}` : `messages: ${safeStringify(prompt.messages).trimStart()}`;
-  const rawToolsParsed = prompt.type === "chat" && prompt.tools && prompt.tools.length > 0 ? import_zod6.z.array(import_typespecs3.toolFunctionDefinitionSchema).safeParse(JSON.parse(prompt.tools)) : void 0;
+  const rawToolsParsed = prompt.type === "chat" && prompt.tools && prompt.tools.length > 0 ? import_zod7.z.array(ToolFunctionDefinition).safeParse(JSON.parse(prompt.tools)) : void 0;
   if (rawToolsParsed && !rawToolsParsed.success) {
     console.warn(
       warning(
@@ -8680,7 +9995,7 @@ function makeFunctionDefinition({
   id: ${doubleQuote(func.id)},
   name: ${doubleQuote(func.name)},
   slug: ${doubleQuote(func.slug)},
-  version: ${doubleQuote((0, import_core6.prettifyXact)(func._xact_id))}, ${printOptionalField("description", func.description)}${printOptionalField("model", model)}
+  version: ${doubleQuote((0, import_core7.prettifyXact)(func._xact_id))}, ${printOptionalField("description", func.description)}${printOptionalField("model", model)}
 ${indent(promptContents, 2)},
 ${indent(paramsString, 2)}
 ${indent(toolsString, 2)}
@@ -8700,7 +10015,7 @@ function indent(str, numSpaces) {
   return str.replace(/^/gm, " ".repeat(numSpaces));
 }
 function printOptionalField(fieldName, fieldValue) {
-  return !(0, import_core6.isEmpty)(fieldValue) ? `
+  return !(0, import_core7.isEmpty)(fieldValue) ? `
   ${fieldName}: ${doubleQuote(fieldValue)},` : "";
 }
 var prettierImportAttempted = false;
@@ -8771,7 +10086,7 @@ var import_express = __toESM(require("express"));
 var import_cors = __toESM(require("cors"));
 
 // dev/errorHandler.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var errorHandler = (err, req, res, next) => {
   if ("status" in err) {
     res.status(err.status).json({
@@ -8782,7 +10097,7 @@ var errorHandler = (err, req, res, next) => {
     });
     return;
   }
-  if (err instanceof import_zod7.z.ZodError) {
+  if (err instanceof import_zod8.z.ZodError) {
     res.status(400).json({
       error: {
         message: "Invalid request",
@@ -8911,7 +10226,7 @@ var baseAllowedHeaders = [
 ];
 
 // dev/server.ts
-var import_core7 = require("@braintrust/core");
+var import_core8 = require("@braintrust/core");
 
 // dev/stream.ts
 function serializeSSEEvent(event) {
@@ -8919,50 +10234,49 @@ function serializeSSEEvent(event) {
 }
 
 // dev/types.ts
-var import_typespecs6 = require("@braintrust/core/typespecs");
-var import_zod8 = require("zod");
-var evalBodySchema = import_zod8.z.object({
-  name: import_zod8.z.string(),
-  parameters: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).nullish(),
-  data: import_typespecs6.runEvalSchema.shape.data,
-  scores: import_zod8.z.array(
-    import_zod8.z.object({
-      function_id: import_typespecs6.functionIdSchema,
-      name: import_zod8.z.string()
+var import_zod9 = require("zod");
+var evalBodySchema = import_zod9.z.object({
+  name: import_zod9.z.string(),
+  parameters: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).nullish(),
+  data: RunEval.shape.data,
+  scores: import_zod9.z.array(
+    import_zod9.z.object({
+      function_id: FunctionId,
+      name: import_zod9.z.string()
     })
   ).nullish(),
-  experiment_name: import_zod8.z.string().nullish(),
-  project_id: import_zod8.z.string().nullish(),
-  parent: import_typespecs6.invokeParent.optional(),
-  stream: import_zod8.z.boolean().optional()
+  experiment_name: import_zod9.z.string().nullish(),
+  project_id: import_zod9.z.string().nullish(),
+  parent: InvokeParent.optional(),
+  stream: import_zod9.z.boolean().optional()
 });
-var evalParametersSerializedSchema = import_zod8.z.record(
-  import_zod8.z.string(),
-  import_zod8.z.union([
-    import_zod8.z.object({
-      type: import_zod8.z.literal("prompt"),
-      default: import_typespecs6.promptDataSchema.optional(),
-      description: import_zod8.z.string().optional()
+var evalParametersSerializedSchema = import_zod9.z.record(
+  import_zod9.z.string(),
+  import_zod9.z.union([
+    import_zod9.z.object({
+      type: import_zod9.z.literal("prompt"),
+      default: PromptData.optional(),
+      description: import_zod9.z.string().optional()
     }),
-    import_zod8.z.object({
-      type: import_zod8.z.literal("data"),
-      schema: import_zod8.z.record(import_zod8.z.unknown()),
+    import_zod9.z.object({
+      type: import_zod9.z.literal("data"),
+      schema: import_zod9.z.record(import_zod9.z.unknown()),
       // JSON Schema
-      default: import_zod8.z.unknown().optional(),
-      description: import_zod8.z.string().optional()
+      default: import_zod9.z.unknown().optional(),
+      description: import_zod9.z.string().optional()
     })
   ])
 );
-var evaluatorDefinitionSchema = import_zod8.z.object({
+var evaluatorDefinitionSchema = import_zod9.z.object({
   parameters: evalParametersSerializedSchema.optional()
 });
-var evaluatorDefinitionsSchema = import_zod8.z.record(
-  import_zod8.z.string(),
+var evaluatorDefinitionsSchema = import_zod9.z.record(
+  import_zod9.z.string(),
   evaluatorDefinitionSchema
 );
 
 // dev/server.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var import_zod_to_json_schema2 = __toESM(require("zod-to-json-schema"));
 function runDevServer(evaluators, opts) {
   const allEvaluators = Object.fromEntries(
@@ -8985,8 +10299,8 @@ function runDevServer(evaluators, opts) {
       allowedHeaders: baseAllowedHeaders,
       credentials: true,
       exposedHeaders: [
-        import_core7.BT_CURSOR_HEADER,
-        import_core7.BT_FOUND_EXISTING_HEADER,
+        import_core8.BT_CURSOR_HEADER,
+        import_core8.BT_FOUND_EXISTING_HEADER,
         "x-bt-span-id",
         "x-bt-span-export"
       ],
@@ -9042,7 +10356,7 @@ function runDevServer(evaluators, opts) {
           validateParameters(parameters ?? {}, evaluator.parameters);
         } catch (e) {
           console.error("Error validating parameters", e);
-          if (e instanceof import_zod9.z.ZodError || e instanceof Error) {
+          if (e instanceof import_zod10.z.ZodError || e instanceof Error) {
             res.status(400).json({
               error: e.message
             });
@@ -9118,7 +10432,7 @@ function runDevServer(evaluators, opts) {
                 );
               }
             },
-            parent: (0, import_core7.parseParent)(parent),
+            parent: (0, import_core8.parseParent)(parent),
             parameters: parameters ?? {}
           }
         );
@@ -9200,9 +10514,9 @@ async function getDataset(state, data) {
     return data.data;
   }
 }
-var datasetFetchSchema = import_zod9.z.object({
-  project_id: import_zod9.z.string(),
-  name: import_zod9.z.string()
+var datasetFetchSchema = import_zod10.z.object({
+  project_id: import_zod10.z.string(),
+  name: import_zod10.z.string()
 });
 async function getDatasetById({
   state,
@@ -9211,7 +10525,7 @@ async function getDatasetById({
   const dataset = await state.appConn().post_json("api/dataset/get", {
     id: datasetId
   });
-  const parsed = import_zod9.z.array(datasetFetchSchema).parse(dataset);
+  const parsed = import_zod10.z.array(datasetFetchSchema).parse(dataset);
   if (parsed.length === 0) {
     throw new Error(`Dataset '${datasetId}' not found`);
   }
@@ -9253,13 +10567,12 @@ function makeEvalParametersSchema(parameters) {
           }
         ];
       } else {
+        const schema = (0, import_zod_to_json_schema2.default)(value);
         return [
           name,
           {
             type: "data",
-            // Since this schema is bundled, it won't pass an instanceof check.
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            schema: (0, import_zod_to_json_schema2.default)(value),
+            schema,
             default: value.default,
             description: value.description
           }
@@ -9334,7 +10647,7 @@ async function initExperiment2(evaluator, evaluatorData) {
     baseExperimentId: evaluator.baseExperimentId,
     gitMetadataSettings: evaluator.gitMetadataSettings,
     repoInfo: evaluator.repoInfo,
-    dataset: Dataset.isDataset(data) ? data : void 0,
+    dataset: Dataset2.isDataset(data) ? data : void 0,
     setCurrent: false
   });
   const info = await logger.summarize({ summarizeScores: false });