braintrust 3.1.0 → 3.2.0

package/dist/workerd.mjs

@@ -1518,6 +1518,7 @@ var ApiKey = z6.object({
 var TriggeredFunctionState = z6.object({
   triggered_xact_id: z6.string(),
   completed_xact_id: z6.union([z6.string(), z6.null()]).optional(),
+  idempotency_key: z6.union([z6.string(), z6.null()]).optional(),
   attempts: z6.number().int().gte(0).optional().default(0),
   scope: z6.union([
     z6.object({ type: z6.literal("span") }),
@@ -1550,7 +1551,8 @@ var AsyncScoringControl = z6.union([
         scope: z6.union([
           z6.object({ type: z6.literal("span") }),
           z6.object({ type: z6.literal("trace") })
-        ])
+        ]),
+        idempotency_key: z6.string().optional()
       })
     ).min(1)
   }),
@@ -1595,7 +1597,8 @@ var FunctionTypeEnum = z6.enum([
   "facet",
   "classifier",
   "tag",
-  "parameters"
+  "parameters",
+  "sandbox"
 ]);
 var NullableSavedFunctionId = z6.union([
   z6.object({
@@ -1610,66 +1613,14 @@ var NullableSavedFunctionId = z6.union([
   }),
   z6.null()
 ]);
-var TopicMapReport = z6.object({
-  version: z6.literal(1),
-  created_at: z6.string().optional(),
-  settings: z6.object({
-    algorithm: z6.enum(["hdbscan", "kmeans", "hierarchical"]),
-    dimension_reduction: z6.enum(["umap", "pca", "none"]),
-    vector_field: z6.string(),
-    embedding_model: z6.string(),
-    n_clusters: z6.union([z6.number(), z6.null()]).optional(),
-    umap_dimensions: z6.union([z6.number(), z6.null()]).optional(),
-    min_cluster_size: z6.union([z6.number(), z6.null()]).optional(),
-    min_samples: z6.union([z6.number(), z6.null()]).optional()
-  }),
-  query_settings: z6.object({
-    hierarchy_threshold: z6.union([z6.number(), z6.null()]),
-    auto_naming: z6.boolean(),
-    skip_cache: z6.boolean(),
-    viz_mode: z6.enum(["bar", "scatter"]),
-    naming_model: z6.string()
-  }).partial(),
-  clusters: z6.array(
-    z6.object({
-      cluster_id: z6.number(),
-      parent_cluster_id: z6.union([z6.number(), z6.null()]).optional(),
-      topic_id: z6.string(),
-      count: z6.number(),
-      sample_texts: z6.array(z6.string()),
-      samples: z6.array(
-        z6.object({
-          id: z6.string(),
-          text: z6.string(),
-          root_span_id: z6.string(),
-          span_id: z6.string()
-        })
-      ),
-      name: z6.string().optional(),
-      description: z6.string().optional(),
-      keywords: z6.array(z6.string()).optional(),
-      centroid: z6.array(z6.number()).optional(),
-      parent_id: z6.union([z6.number(), z6.null()]).optional(),
-      is_leaf: z6.boolean().optional(),
-      depth: z6.number().optional()
-    })
-  ),
-  embedding_points: z6.array(
-    z6.object({
-      x: z6.number(),
-      y: z6.number(),
-      cluster: z6.number(),
-      text: z6.string().optional()
-    })
-  ).optional()
-});
 var TopicMapData = z6.object({
   type: z6.literal("topic_map"),
   source_facet: z6.string(),
   embedding_model: z6.string(),
-  bundle_key: z6.string(),
-  distance_threshold: z6.number().optional(),
-  report: TopicMapReport.optional()
+  bundle_key: z6.string().optional(),
+  report_key: z6.string().optional(),
+  topic_names: z6.record(z6.string()).optional(),
+  distance_threshold: z6.number().optional()
 });
 var BatchedFacetData = z6.object({
   type: z6.literal("batched_facet"),
@@ -1684,11 +1635,13 @@ var BatchedFacetData = z6.object({
     })
   ),
   topic_maps: z6.record(
-    z6.object({
-      function_name: z6.string(),
-      topic_map_id: z6.string().optional(),
-      topic_map_data: TopicMapData
-    })
+    z6.array(
+      z6.object({
+        function_name: z6.string(),
+        topic_map_id: z6.string().optional(),
+        topic_map_data: TopicMapData
+      })
+    )
   ).optional()
 });
 var BraintrustModelParams = z6.object({
@@ -1867,9 +1820,20 @@ var CodeBundle = z6.object({
         z6.object({ type: z6.literal("scorer"), index: z6.number().int().gte(0) })
       ])
     }),
-    z6.object({ type: z6.literal("function"), index: z6.number().int().gte(0) })
+    z6.object({ type: z6.literal("function"), index: z6.number().int().gte(0) }),
+    z6.object({
+      type: z6.literal("sandbox"),
+      sandbox_spec: z6.union([
+        z6.object({ provider: z6.literal("modal"), snapshot_ref: z6.string() }),
+        z6.object({ provider: z6.literal("lambda") })
+      ]),
+      entrypoints: z6.array(z6.string()).optional(),
+      eval_name: z6.string(),
+      parameters: z6.object({}).partial().passthrough().optional(),
+      evaluator_definition: z6.unknown().optional()
+    })
   ]),
-  bundle_id: z6.string(),
+  bundle_id: z6.union([z6.string(), z6.null()]).optional(),
   preview: z6.union([z6.string(), z6.null()]).optional()
 });
 var Dataset = z6.object({
@@ -1971,7 +1935,7 @@ var EnvVar = z6.object({
   used: z6.union([z6.string(), z6.null()]).optional(),
   metadata: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional(),
   secret_type: z6.union([z6.string(), z6.null()]).optional(),
-  secret_category: z6.enum(["env_var", "ai_provider"]).optional().default("env_var")
+  secret_category: z6.enum(["env_var", "ai_provider", "sandbox_provider"]).optional().default("env_var")
 });
 var EvalStatusPageTheme = z6.enum(["light", "dark"]);
 var EvalStatusPageConfig = z6.object({
@@ -2273,7 +2237,8 @@ var FunctionTypeEnumNullish = z6.union([
     "facet",
     "classifier",
     "tag",
-    "parameters"
+    "parameters",
+    "sandbox"
   ]),
   z6.null()
 ]);
@@ -2506,7 +2471,8 @@ var FunctionObjectType = z6.enum([
   "preprocessor",
   "facet",
   "classifier",
-  "parameters"
+  "parameters",
+  "sandbox"
 ]);
 var FunctionOutputType = z6.enum([
   "completion",
@@ -2642,6 +2608,7 @@ var Organization = z6.object({
   name: z6.string(),
   api_url: z6.union([z6.string(), z6.null()]).optional(),
   is_universal_api: z6.union([z6.boolean(), z6.null()]).optional(),
+  is_dataplane_private: z6.union([z6.boolean(), z6.null()]).optional(),
   proxy_url: z6.union([z6.string(), z6.null()]).optional(),
   realtime_url: z6.union([z6.string(), z6.null()]).optional(),
   created: z6.union([z6.string(), z6.null()]).optional(),
@@ -2666,7 +2633,7 @@ var ProjectSettings = z6.union([
       z6.array(
         z6.object({
           url: z6.string(),
-          name: z6.string(),
+          name: z6.union([z6.string(), z6.null()]).optional(),
           description: z6.union([z6.string(), z6.null()]).optional()
         })
       ),
@@ -2692,6 +2659,25 @@ var RetentionObjectType = z6.enum([
   "experiment",
   "dataset"
 ]);
+var TopicMapFunctionAutomation = z6.object({
+  function: SavedFunctionId.and(z6.unknown()),
+  btql_filter: z6.union([z6.string(), z6.null()]).optional()
+});
+var TopicAutomationDataScope = z6.union([
+  z6.object({ type: z6.literal("project_logs") }),
+  z6.object({ type: z6.literal("project_experiments") }),
+  z6.object({ type: z6.literal("experiment"), experiment_id: z6.string() }),
+  z6.null()
+]);
+var TopicAutomationConfig = z6.object({
+  event_type: z6.literal("topic"),
+  sampling_rate: z6.number().gte(0).lte(1),
+  facet_functions: z6.array(SavedFunctionId),
+  topic_map_functions: z6.array(TopicMapFunctionAutomation),
+  scope: z6.union([SpanScope, TraceScope, GroupScope, z6.null()]).optional(),
+  data_scope: TopicAutomationDataScope.optional(),
+  btql_filter: z6.union([z6.string(), z6.null()]).optional()
+});
 var ProjectAutomation = z6.object({
   id: z6.string().uuid(),
   project_id: z6.string().uuid(),
@@ -2748,7 +2734,8 @@ var ProjectAutomation = z6.object({
           message_template: z6.string().optional()
         })
       ])
-    })
+    }),
+    TopicAutomationConfig
   ])
 });
 var ProjectLogsEvent = z6.object({
@@ -2938,6 +2925,8 @@ var RunEval = z6.object({
     }),
     z6.object({ data: z6.array(z6.unknown()) })
   ]),
+  name: z6.string().optional(),
+  parameters: z6.object({}).partial().passthrough().optional(),
   task: FunctionId.and(z6.unknown()),
   scores: z6.array(FunctionId),
   experiment_name: z6.string().optional(),
@@ -4645,7 +4634,7 @@ var HTTPConnection = class _HTTPConnection {
     try {
       const resp = await this.get("ping");
       return resp.status === 200;
-    } catch (e) {
+    } catch {
       return false;
     }
   }
@@ -5154,9 +5143,9 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
     expected,
     tags
   });
-  let { metadata, ...updateEvent } = deepCopyEvent(validatedEvent);
-  updateEvent = Object.fromEntries(
-    Object.entries(updateEvent).filter(([_, v]) => !isEmpty2(v))
+  const { metadata, ...rawUpdateEvent } = deepCopyEvent(validatedEvent);
+  const updateEvent = Object.fromEntries(
+    Object.entries(rawUpdateEvent).filter(([_, v]) => !isEmpty2(v))
   );
   const parentIds = async () => new SpanComponentsV3({
     object_type: parentObjectType,
@@ -7344,7 +7333,8 @@ function validateAndSanitizeExperimentLogPartialArgs(event) {
     if (Array.isArray(event.scores)) {
       throw new Error("scores must be an object, not an array");
     }
-    for (let [name, score] of Object.entries(event.scores)) {
+    for (const [name, rawScore] of Object.entries(event.scores)) {
+      let score = rawScore;
       if (typeof name !== "string") {
         throw new Error("score names must be strings");
       }
@@ -7786,7 +7776,11 @@ var Experiment2 = class extends ObjectFetcher {
    * @returns A summary of the experiment, including the scores (compared to the closest reference experiment) and metadata.
    */
   async summarize(options = {}) {
-    let { summarizeScores = true, comparisonExperimentId = void 0 } = options || {};
+    const {
+      summarizeScores = true,
+      comparisonExperimentId: comparisonExperimentIdOpt
+    } = options || {};
+    let comparisonExperimentId = comparisonExperimentIdOpt;
     const state = await this.getState();
     const projectUrl = `${state.appPublicUrl}/app/${encodeURIComponent(
       state.orgName
@@ -8970,8 +8964,7 @@ var RemoteEvalParameters = class {
     return true;
   }
   static isParameters(x) {
-    return typeof x === "object" && x !== null && "__braintrust_parameters_marker" in x && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    x.__braintrust_parameters_marker === true;
+    return typeof x === "object" && x !== null && "__braintrust_parameters_marker" in x && x.__braintrust_parameters_marker === true;
   }
 };
 var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
@@ -9154,6 +9147,7 @@ __export(exports_exports, {
   addAzureBlobHeaders: () => addAzureBlobHeaders,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
+  configureInstrumentation: () => configureInstrumentation,
   constructLogs3OverflowRequest: () => constructLogs3OverflowRequest,
   createFinalValuePassThroughStream: () => createFinalValuePassThroughStream,
   currentExperiment: () => currentExperiment,
@@ -9229,7 +9223,8 @@ __export(exports_exports, {
   wrapMastraAgent: () => wrapMastraAgent,
   wrapOpenAI: () => wrapOpenAI,
   wrapOpenAIv4: () => wrapOpenAIv4,
-  wrapTraced: () => wrapTraced
+  wrapTraced: () => wrapTraced,
+  wrapVitest: () => wrapVitest
 });
 
 // src/functions/invoke.ts
@@ -9385,7 +9380,7 @@ function parseEventFromResponseCreateResult(result) {
     data.output = processImagesInOutput(result.output);
   }
   if (result) {
-    const { output, usage, ...metadata } = result;
+    const { output: _output, usage: _usage, ...metadata } = result;
     if (Object.keys(metadata).length > 0) {
       data.metadata = metadata;
     }
@@ -9448,7 +9443,7 @@ function parseEventFromResponseParseResult(result) {
     data.output = processImagesInOutput(result.output);
   }
   if (result) {
-    const { output, usage, ...metadata } = result;
+    const { output: _output, usage: _usage, ...metadata } = result;
     if (Object.keys(metadata).length > 0) {
       data.metadata = metadata;
     }
@@ -9492,7 +9487,7 @@ function parseLogFromItem(item) {
         data.output = processImagesInOutput(response.output);
       }
       if (response) {
-        const { usage, output, ...metadata } = response;
+        const { usage: _usage, output: _output, ...metadata } = response;
         if (Object.keys(metadata).length > 0) {
           data.metadata = metadata;
         }
@@ -9883,7 +9878,7 @@ function wrapChatCompletion(completion) {
               );
               const { data: ret, response } = await completionResponse.withResponse();
               logHeaders(response, span);
-              const { messages, ...rest } = params;
+              const { messages: _messages, ...rest } = params;
               span.log({
                 metadata: {
                   ...rest
@@ -10206,7 +10201,7 @@ function convertDataToBlob(data, mediaType) {
     } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
       return new Blob([data], { type: mediaType });
     }
-  } catch (error) {
+  } catch {
     return null;
   }
   return null;
@@ -12479,7 +12474,6 @@ function apiPromiseProxy2(apiPromise, span, onThen) {
         return function(onFulfilled, onRejected) {
           return thenFunc.call(
             target,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             async (result) => {
               try {
                 const processed = onThen(result);
@@ -13691,6 +13685,582 @@ function tryToDict(obj) {
   return null;
 }
 
+// src/wrappers/vitest/context-manager.ts
+var VitestContextManager = class {
+  /**
+   * AsyncLocalStorage for experiment context isolation.
+   * Each async execution flow (test, concurrent test, worker thread) gets its own context.
+   */
+  contextStorage;
+  constructor() {
+    this.contextStorage = isomorph_default.newAsyncLocalStorage();
+  }
+  getCurrentContext() {
+    return this.contextStorage.getStore();
+  }
+  setContext(context) {
+    this.contextStorage.enterWith(context);
+  }
+  runInContext(context, callback) {
+    return this.contextStorage.run(context, callback);
+  }
+  createChildContext(dataset, experiment) {
+    const parent = this.getCurrentContext();
+    return {
+      dataset,
+      experiment,
+      datasetExamples: /* @__PURE__ */ new Map(),
+      parent,
+      flushResolved: true,
+      passed: 0,
+      failed: 0
+    };
+  }
+};
+var _contextManager;
+function getVitestContextManager() {
+  if (!_contextManager) {
+    _contextManager = new VitestContextManager();
+  }
+  return _contextManager;
+}
+
+// src/wrappers/vitest/flush-manager.ts
+var FlushCoordinator = class {
+  activeFlushes = /* @__PURE__ */ new Map();
+  async coordinateFlush(context, config) {
+    if (!context) return;
+    const experimentId = await context.experiment.id;
+    if (this.activeFlushes.has(experimentId)) {
+      return this.activeFlushes.get(experimentId);
+    }
+    const flushPromise = this.doFlush(context, config);
+    this.activeFlushes.set(experimentId, flushPromise);
+    try {
+      await flushPromise;
+    } finally {
+      this.activeFlushes.delete(experimentId);
+    }
+  }
+  async doFlush(context, config) {
+    let summary;
+    try {
+      summary = await context.experiment.summarize();
+    } catch (error) {
+      console.warn("Failed to generate experiment summary:", error);
+    }
+    try {
+      await context.experiment.flush();
+    } catch (error) {
+      console.warn("Failed to flush experiment:", error);
+      throw error;
+    }
+    if (summary && (config.displaySummary ?? true)) {
+      console.log(formatExperimentSummary(summary));
+    }
+  }
+};
+var flushCoordinator = new FlushCoordinator();
+async function flushExperimentWithSync(context, config) {
+  return flushCoordinator.coordinateFlush(context, config);
+}
+
+// src/wrappers/vitest/scorers.ts
+async function runScorers(args) {
+  const { scorers, output, expected, input, metadata, span } = args;
+  const scorerArgs = {
+    output,
+    expected,
+    input,
+    metadata: metadata || {}
+  };
+  for (const scorer of scorers) {
+    try {
+      const result = await scorer(scorerArgs);
+      const scores = normalizeScores(result);
+      for (const score of scores) {
+        if (score.metadata && Object.keys(score.metadata).length > 0) {
+          span.log({
+            scores: { [score.name]: score.score },
+            metadata: score.metadata
+          });
+        } else {
+          span.log({
+            scores: { [score.name]: score.score }
+          });
+        }
+      }
+    } catch (scorerError) {
+      console.warn("Braintrust: Scorer failed:", scorerError);
+      span.log({
+        metadata: {
+          scorer_error: scorerError instanceof Error ? { message: scorerError.message, name: scorerError.name } : String(scorerError)
+        }
+      });
+    }
+  }
+}
+function isScore(val) {
+  return "name" in val && "score" in val;
+}
+function normalizeScores(result) {
+  if (result === null || result === void 0) {
+    return [];
+  }
+  if (typeof result === "number") {
+    return [{ name: "score", score: result }];
+  }
+  if (Array.isArray(result)) {
+    return result.filter((s) => s !== null && s !== void 0);
+  }
+  if (typeof result === "object" && result !== null && isScore(result)) {
+    return [result];
+  }
+  return [];
+}
+
+// src/wrappers/vitest/wrapper.ts
+function formatExperimentSummary(summary) {
+  const lines = [];
+  lines.push("\n\u250C\u2500 Braintrust Experiment Summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  lines.push(`\u2502 Experiment: ${summary.experimentName}`);
+  if (Object.keys(summary.scores).length > 0) {
+    lines.push("\u2502");
+    lines.push("\u2502 Scores:");
+    for (const [name, score] of Object.entries(summary.scores)) {
+      const percent = (score.score * 100).toFixed(2);
+      lines.push(`\u2502   ${name}: ${percent}%`);
+    }
+  }
+  if (summary.metrics && Object.keys(summary.metrics).length > 0) {
+    lines.push("\u2502");
+    lines.push("\u2502 Metrics:");
+    for (const [name, metric] of Object.entries(summary.metrics)) {
+      const value = Number.isInteger(metric.metric) ? metric.metric.toFixed(0) : metric.metric.toFixed(2);
+      const formatted = metric.unit === "$" ? `${metric.unit}${value}` : `${value}${metric.unit}`;
+      lines.push(`\u2502   ${name}: ${formatted}`);
+    }
+  }
+  if (summary.experimentUrl) {
+    lines.push("\u2502");
+    lines.push(`\u2502 View results: ${summary.experimentUrl}`);
+  }
+  lines.push("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n");
+  return lines.join("\n");
+}
+function getExperimentContext() {
+  return getVitestContextManager().getCurrentContext() ?? null;
+}
+function wrapTest(originalTest, config) {
+  const wrapBare = (testFn) => {
+    const wrapped = function(name, configOrFn, maybeFn) {
+      const isEnhanced = typeof configOrFn !== "function";
+      const testConfig = isEnhanced ? configOrFn : void 0;
+      if (isEnhanced && testConfig?.data && Array.isArray(testConfig.data)) {
+        const dataRecords = testConfig.data;
+        const testFn2 = maybeFn;
+        if (!testFn2) {
+          throw new Error(
+            "Braintrust: test function required when using data array"
+          );
+        }
+        dataRecords.forEach((record, index) => {
+          const mergedConfig = {
+            ...testConfig,
+            input: record.input,
+            expected: record.expected,
+            metadata: { ...testConfig.metadata, ...record.metadata },
+            tags: [
+              ...testConfig.tags || [],
+              ...record.tags || []
+            ],
+            data: void 0
+          };
+          wrappedTest(`${name} [${index}]`, mergedConfig, testFn2);
+        });
+        return;
+      }
+      let vitestOptions;
+      if (testConfig) {
+        const {
+          input: _input,
+          expected: _expected,
+          metadata: _metadata,
+          tags: _tags,
+          scorers: _scorers,
+          data: _data,
+          ...rest
+        } = testConfig;
+        vitestOptions = rest;
+      }
+      const hasVitestOptions = vitestOptions && Object.keys(vitestOptions).length > 0;
+      const registrationContext = getExperimentContext();
+      const testImplementation = async (vitestContext) => {
+        const experimentContext = getExperimentContext() ?? registrationContext;
+        const experiment = experimentContext?.experiment;
+        if (config.onProgress) {
+          config.onProgress({ type: "test_start", testName: name });
+        }
+        const startTime = performance.now();
+        let passed = false;
+        try {
+          if (!experiment) {
+            if (testConfig && maybeFn) {
+              const params = {
+                input: testConfig.input,
+                expected: testConfig.expected,
+                metadata: testConfig.metadata
+              };
+              const context = {
+                ...vitestContext,
+                ...params
+              };
+              const result2 = await maybeFn(context);
+              passed = true;
+              return result2;
+            } else if (typeof configOrFn === "function") {
+              const result2 = await configOrFn(vitestContext);
+              passed = true;
+              return result2;
+            }
+            passed = true;
+            return;
+          }
+          const result = await experiment.traced(
+            async (span) => {
+              let testResult;
+              try {
+                if (testConfig && maybeFn) {
+                  const params = {
+                    input: testConfig.input,
+                    expected: testConfig.expected,
+                    metadata: testConfig.metadata
+                  };
+                  const context = {
+                    ...vitestContext,
+                    ...params
+                  };
+                  testResult = await maybeFn(context);
+                } else if (typeof configOrFn === "function") {
+                  testResult = await configOrFn(vitestContext);
+                }
+                if (testConfig?.scorers && testConfig.scorers.length > 0) {
+                  await runScorers({
+                    scorers: testConfig.scorers,
+                    output: testResult,
+                    expected: testConfig.expected,
+                    input: testConfig.input,
+                    metadata: testConfig.metadata,
+                    span
+                  });
+                }
+                span.log({
+                  scores: {
+                    pass: 1
+                  }
+                });
+                if (testResult !== void 0) {
+                  span.log({
+                    output: testResult
+                  });
+                }
+              } catch (error) {
+                if (testConfig?.scorers && testConfig.scorers.length > 0) {
+                  await runScorers({
+                    scorers: testConfig.scorers,
+                    output: testResult,
+                    expected: testConfig.expected,
+                    input: testConfig.input,
+                    metadata: testConfig.metadata,
+                    span
+                  });
+                }
+                span.log({
+                  scores: {
+                    pass: 0
+                  },
+                  metadata: {
+                    error: error instanceof Error ? {
+                      message: error.message,
+                      name: error.name,
+                      stack: error.stack
+                    } : String(error)
+                  }
+                });
+                throw error;
+              }
+              return testResult;
+            },
+            {
+              name,
+              spanAttributes: {
+                type: "task" /* TASK */
+              },
+              event: testConfig ? {
+                input: testConfig.input,
+                expected: testConfig.expected,
+                metadata: testConfig.metadata,
+                tags: testConfig.tags
+              } : void 0
+            }
+          );
+          passed = true;
+          return result;
+        } catch (error) {
+          passed = false;
+          throw error;
+        } finally {
+          const duration = performance.now() - startTime;
+          if (experimentContext) {
+            if (passed) {
+              experimentContext.passed = (experimentContext.passed ?? 0) + 1;
+            } else {
+              experimentContext.failed = (experimentContext.failed ?? 0) + 1;
+            }
+          }
+          if (config.onProgress) {
+            config.onProgress({
+              type: "test_complete",
+              testName: name,
+              passed,
+              duration
+            });
+          }
+        }
+      };
+      return testFn(
+        name,
+        hasVitestOptions ? vitestOptions : void 0,
+        testImplementation
+      );
+    };
+    return wrapped;
+  };
+  const wrappedTest = wrapBare(originalTest);
+  wrappedTest.skip = wrapBare(originalTest.skip);
+  wrappedTest.only = wrapBare(originalTest.only);
+  wrappedTest.concurrent = wrapBare(originalTest.concurrent);
+  if (originalTest.todo) wrappedTest.todo = originalTest.todo;
+  if (originalTest.each) wrappedTest.each = originalTest.each;
+  return wrappedTest;
+}
+function wrapDescribe(originalDescribe, config, afterAll) {
+  const wrapBare = (describeFn) => {
+    const wrapped = function(suiteName, factory) {
+      return describeFn(suiteName, () => {
+        const contextManager = getVitestContextManager();
+        let context = null;
+        const getOrCreateContext = () => {
+          if (!context) {
+            const projectName = config.projectName || suiteName;
+            const experiment = initExperiment(projectName, {
+              experiment: `${suiteName}-${(/* @__PURE__ */ new Date()).toISOString()}`
+            });
+            context = contextManager.createChildContext(void 0, experiment);
+          }
+          return context;
+        };
+        const lazyContext = {
+          get dataset() {
+            return getOrCreateContext().dataset;
+          },
+          get experiment() {
+            return getOrCreateContext().experiment;
+          },
+          get datasetExamples() {
+            return getOrCreateContext().datasetExamples;
+          },
+          get parent() {
+            return getOrCreateContext().parent;
+          },
+          get flushPromise() {
+            return getOrCreateContext().flushPromise;
+          },
+          set flushPromise(value) {
+            if (context) context.flushPromise = value;
+          },
+          get flushResolved() {
+            return getOrCreateContext().flushResolved;
+          },
+          set flushResolved(value) {
+            if (context) context.flushResolved = value;
+          }
+        };
+        if (config.onProgress) {
+          config.onProgress({ type: "suite_start", suiteName });
+        }
+        contextManager.setContext(lazyContext);
+        factory();
+        if (afterAll && (config.displaySummary ?? true)) {
+          afterAll(async () => {
+            await flushExperimentWithSync(context, config);
+            if (config.onProgress) {
+              config.onProgress({
+                type: "suite_complete",
+                suiteName,
+                passed: context?.passed ?? 0,
+                failed: context?.failed ?? 0
+              });
+            }
+          });
+        }
+      });
+    };
+    return wrapped;
+  };
+  const wrappedDescribe = wrapBare(originalDescribe);
+  wrappedDescribe.skip = wrapBare(originalDescribe.skip);
+  wrappedDescribe.only = wrapBare(originalDescribe.only);
+  wrappedDescribe.concurrent = wrapBare(originalDescribe.concurrent);
+  if (originalDescribe.todo) wrappedDescribe.todo = originalDescribe.todo;
+  if (originalDescribe.each)
+    wrappedDescribe.each = originalDescribe.each;
+  return wrappedDescribe;
+}
+
+// src/wrappers/vitest/expect-wrapper.ts
+function proxyAssertion(assertion, value, key, span) {
+  return new Proxy(assertion, {
+    get(target, prop, receiver) {
+      const original = Reflect.get(target, prop, receiver);
+      if (typeof original === "function") {
+        return function(...args) {
+          let result;
+          try {
+            result = original.apply(target, args);
+          } catch (err) {
+            span.log({ output: { [key]: value }, scores: { [key]: 0 } });
+            throw err;
+          }
+          if (result !== null && typeof result === "object" && "then" in result && typeof Reflect.get(result, "then") === "function") {
+            return Promise.resolve(result).then(
+              (v) => {
+                span.log({ output: { [key]: value }, scores: { [key]: 1 } });
+                return v;
+              },
+              (err) => {
+                span.log({ output: { [key]: value }, scores: { [key]: 0 } });
+                throw err;
+              }
+            );
+          }
+          span.log({ output: { [key]: value }, scores: { [key]: 1 } });
+          return result;
+        };
+      }
+      if (original !== null && typeof original === "object") {
+        return proxyAssertion(original, value, key, span);
+      }
+      return original;
+    }
+  });
+}
+function wrapExpect(originalExpect) {
+  const wrapped = function(value, message) {
+    if (message === void 0) {
+      return originalExpect(value);
+    }
+    const assertion = originalExpect(value, message);
+    const span = currentSpan();
+    if (!span) {
+      return assertion;
+    }
+    if (assertion === null || typeof assertion !== "object") return assertion;
+    return proxyAssertion(assertion, value, message, span);
+  };
+  return Object.assign(wrapped, originalExpect);
+}
+
+// src/wrappers/vitest/index.ts
+function wrapVitest(vitestMethods, config = {}) {
+  if (!vitestMethods.test) {
+    throw new Error(
+      "Braintrust: vitestMethods.test is required. Please pass in the test function from vitest."
+    );
+  }
+  if (!vitestMethods.describe) {
+    throw new Error(
+      "Braintrust: vitestMethods.describe is required. Please pass in the describe function from vitest."
+    );
+  }
+  if (!vitestMethods.expect) {
+    throw new Error(
+      "Braintrust: vitestMethods.expect is required. Please pass in the expect function from vitest."
+    );
+  }
+  const wrappedTest = wrapTest(vitestMethods.test, config);
+  const wrappedDescribe = wrapDescribe(
+    vitestMethods.describe,
+    config,
+    vitestMethods.afterAll
+  );
+  return {
+    test: wrappedTest,
+    it: wrappedTest,
+    expect: wrapExpect(vitestMethods.expect),
+    describe: wrappedDescribe,
+    beforeAll: vitestMethods.beforeAll || (() => {
+    }),
+    afterAll: vitestMethods.afterAll || (() => {
+    }),
+    beforeEach: vitestMethods.beforeEach,
+    afterEach: vitestMethods.afterEach,
+    logOutputs: (outputs) => {
+      const span = currentSpan();
+      if (!span) {
+        console.warn(
+          "Braintrust: No active span. logOutputs() must be called within a wrapped test."
+        );
+        return;
+      }
+      span.log({ output: outputs });
+    },
+    logFeedback: (feedback) => {
+      const span = currentSpan();
+      if (!span) {
+        console.warn(
+          "Braintrust: No active span. logFeedback() must be called within a wrapped test."
+        );
+        return;
+      }
+      span.log({
+        scores: {
+          [feedback.name]: feedback.score
+        },
+        metadata: feedback.metadata
+      });
+    },
+    getCurrentSpan: () => {
+      return currentSpan();
+    },
+    flushExperiment: async (options) => {
+      const ctx = getExperimentContext();
+      if (!ctx) {
+        console.warn(
+          "Braintrust: No experiment context found. Make sure you're using bt.describe() and calling flushExperiment() within an afterAll() hook."
+        );
+        return;
+      }
+      const shouldDisplaySummary = options?.displaySummary ?? config.displaySummary ?? true;
+      let summary;
+      if (shouldDisplaySummary) {
+        try {
+          summary = await ctx.experiment.summarize();
+        } catch (error) {
+          console.warn(
+            "Braintrust: Failed to generate experiment summary:",
+            error
+          );
+        }
+      }
+      await ctx.experiment.flush();
+      if (summary && shouldDisplaySummary) {
+        console.log(formatExperimentSummary(summary));
+      }
+    }
+  };
+}
+
 // src/graph-framework.ts
 var graph_framework_exports = {};
 __export(graph_framework_exports, {
@@ -16707,6 +17277,2482 @@ var evaluatorDefinitionsSchema = z12.record(
   evaluatorDefinitionSchema
 );
 
+// src/instrumentation/core/plugin.ts
+import { tracingChannel } from "dc-browser";
+
+// src/instrumentation/core/stream-patcher.ts
+function isAsyncIterable4(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function patchStreamIfNeeded(stream, options) {
+  if (!isAsyncIterable4(stream)) {
+    return stream;
+  }
+  if (Object.isFrozen(stream) || Object.isSealed(stream)) {
+    console.warn(
+      "Cannot patch frozen/sealed stream. Stream output will not be collected."
+    );
+    return stream;
+  }
+  const originalIteratorFn = stream[Symbol.asyncIterator];
+  if (originalIteratorFn.__braintrust_patched) {
+    return stream;
+  }
+  try {
+    const patchedIteratorFn = function() {
+      const iterator = originalIteratorFn.call(this);
+      const originalNext = iterator.next.bind(iterator);
+      const chunks = [];
+      let completed = false;
+      iterator.next = async function(...args) {
+        try {
+          const result = await originalNext(...args);
+          if (result.done) {
+            if (!completed) {
+              completed = true;
+              try {
+                options.onComplete(chunks);
+              } catch (error) {
+                console.error("Error in stream onComplete handler:", error);
+              }
+            }
+          } else {
+            const chunk = result.value;
+            const shouldCollect = options.shouldCollect ? options.shouldCollect(chunk) : true;
+            if (shouldCollect) {
+              chunks.push(chunk);
+              if (options.onChunk) {
+                try {
+                  options.onChunk(chunk);
+                } catch (error) {
+                  console.error("Error in stream onChunk handler:", error);
+                }
+              }
+            }
+          }
+          return result;
+        } catch (error) {
+          if (!completed) {
+            completed = true;
+            if (options.onError) {
+              try {
+                options.onError(error, chunks);
+              } catch (handlerError) {
+                console.error("Error in stream onError handler:", handlerError);
+              }
+            }
+          }
+          throw error;
+        }
+      };
+      if (iterator.return) {
+        const originalReturn = iterator.return.bind(iterator);
+        iterator.return = async function(...args) {
+          if (!completed) {
+            completed = true;
+            try {
+              options.onComplete(chunks);
+            } catch (error) {
+              console.error("Error in stream onComplete handler:", error);
+            }
+          }
+          return originalReturn(...args);
+        };
+      }
+      if (iterator.throw) {
+        const originalThrow = iterator.throw.bind(iterator);
+        iterator.throw = async function(...args) {
+          if (!completed) {
+            completed = true;
+            const error = args[0];
+            if (options.onError) {
+              try {
+                options.onError(error, chunks);
+              } catch (handlerError) {
+                console.error("Error in stream onError handler:", handlerError);
+              }
+            }
+          }
+          return originalThrow(...args);
+        };
+      }
+      return iterator;
+    };
+    patchedIteratorFn.__braintrust_patched = true;
+    stream[Symbol.asyncIterator] = patchedIteratorFn;
+    return stream;
+  } catch (error) {
+    console.warn("Failed to patch stream:", error);
+    return stream;
+  }
+}
+
+// src/instrumentation/core/plugin.ts
+var BasePlugin = class {
+  enabled = false;
+  unsubscribers = [];
+  /**
+   * Enables the plugin. Must be called before the plugin will receive events.
+   */
+  enable() {
+    if (this.enabled) {
+      return;
+    }
+    this.enabled = true;
+    this.onEnable();
+  }
+  /**
+   * Disables the plugin. After this, the plugin will no longer receive events.
+   */
+  disable() {
+    if (!this.enabled) {
+      return;
+    }
+    this.enabled = false;
+    this.onDisable();
+  }
+  /**
+   * Helper to subscribe to a channel with raw handlers.
+   *
+   * @param channelName - The channel name to subscribe to
+   * @param handlers - Event handlers
+   */
+  subscribe(channelName, handlers) {
+    const channel = tracingChannel(channelName);
+    channel.subscribe(handlers);
+  }
+  /**
+   * Subscribe to a channel for async methods (non-streaming).
+   * Creates a span and logs input/output/metrics.
+   */
+  subscribeToChannel(channelName, config) {
+    const channel = tracingChannel(channelName);
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const span = startSpan({
+          name: config.name,
+          spanAttributes: {
+            type: config.type
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        spans.set(event, { span, startTime });
+        try {
+          const { input, metadata } = config.extractInput(event.arguments);
+          span.log({
+            input,
+            metadata
+          });
+        } catch (error) {
+          console.error(`Error extracting input for ${channelName}:`, error);
+        }
+      },
+      asyncEnd: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span, startTime } = spanData;
+        try {
+          const output = config.extractOutput(event.result);
+          const metrics = config.extractMetrics(event.result, startTime);
+          span.log({
+            output,
+            metrics
+          });
+        } catch (error) {
+          console.error(`Error extracting output for ${channelName}:`, error);
+        } finally {
+          span.end();
+          spans.delete(event);
+        }
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+  /**
+   * Subscribe to a channel for async methods that may return streams.
+   * Handles both streaming and non-streaming responses.
+   */
+  subscribeToStreamingChannel(channelName, config) {
+    const channel = tracingChannel(channelName);
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const span = startSpan({
+          name: config.name,
+          spanAttributes: {
+            type: config.type
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        spans.set(event, { span, startTime });
+        try {
+          const { input, metadata } = config.extractInput(event.arguments);
+          span.log({
+            input,
+            metadata
+          });
+        } catch (error) {
+          console.error(`Error extracting input for ${channelName}:`, error);
+        }
+      },
+      asyncEnd: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span, startTime } = spanData;
+        if (isAsyncIterable4(event.result)) {
+          patchStreamIfNeeded(event.result, {
+            onComplete: (chunks) => {
+              try {
+                let output;
+                let metrics;
+                if (config.aggregateChunks) {
+                  const aggregated = config.aggregateChunks(chunks);
+                  output = aggregated.output;
+                  metrics = aggregated.metrics;
+                } else {
+                  output = config.extractOutput(chunks);
+                  metrics = config.extractMetrics(chunks, startTime);
+                }
+                if (!metrics.time_to_first_token && chunks.length > 0) {
+                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+                }
+                span.log({
+                  output,
+                  metrics
+                });
+              } catch (error) {
+                console.error(
+                  `Error extracting output for ${channelName}:`,
+                  error
+                );
+              } finally {
+                span.end();
+              }
+            },
+            onError: (error) => {
+              span.log({
+                error: error.message
+              });
+              span.end();
+            }
+          });
+        } else {
+          try {
+            const output = config.extractOutput(event.result);
+            const metrics = config.extractMetrics(event.result, startTime);
+            span.log({
+              output,
+              metrics
+            });
+          } catch (error) {
+            console.error(`Error extracting output for ${channelName}:`, error);
+          } finally {
+            span.end();
+            spans.delete(event);
+          }
+        }
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+  /**
+   * Subscribe to a channel for sync methods that return event-based streams.
+   * Used for methods like beta.chat.completions.stream() and responses.stream().
+   */
+  subscribeToSyncStreamChannel(channelName, config) {
+    const channel = tracingChannel(channelName);
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const span = startSpan({
+          name: config.name,
+          spanAttributes: {
+            type: config.type
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        spans.set(event, { span, startTime });
+        try {
+          const { input, metadata } = config.extractInput(event.arguments);
+          span.log({
+            input,
+            metadata
+          });
+        } catch (error) {
+          console.error(`Error extracting input for ${channelName}:`, error);
+        }
+      },
+      end: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span, startTime } = spanData;
+        const stream = event.result;
+        if (!stream || typeof stream.on !== "function") {
+          span.end();
+          spans.delete(event);
+          return;
+        }
+        let first = true;
+        stream.on("chunk", (chunk) => {
+          if (first) {
+            const now2 = getCurrentUnixTimestamp();
+            span.log({
+              metrics: {
+                time_to_first_token: now2 - startTime
+              }
+            });
+            first = false;
+          }
+        });
+        stream.on("chatCompletion", (completion) => {
+          try {
+            span.log({
+              output: completion.choices
+            });
+          } catch (error) {
+            console.error(
+              `Error extracting chatCompletion for ${channelName}:`,
+              error
+            );
+          }
+        });
+        stream.on("event", (streamEvent) => {
+          if (config.extractFromEvent) {
+            try {
+              if (first) {
+                const now2 = getCurrentUnixTimestamp();
+                span.log({
+                  metrics: {
+                    time_to_first_token: now2 - startTime
+                  }
+                });
+                first = false;
+              }
+              const extracted = config.extractFromEvent(streamEvent);
+              if (extracted && Object.keys(extracted).length > 0) {
+                span.log(extracted);
+              }
+            } catch (error) {
+              console.error(
+                `Error extracting event for ${channelName}:`,
+                error
+              );
+            }
+          }
+        });
+        stream.on("end", () => {
+          span.end();
+          spans.delete(event);
+        });
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+};
+
+// src/instrumentation/plugins/openai-plugin.ts
+var OpenAIPlugin = class extends BasePlugin {
+  constructor() {
+    super();
+  }
+  onEnable() {
+    this.subscribeToStreamingChannel(
+      "orchestrion:openai:chat.completions.create",
+      {
+        name: "Chat Completion",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const params = args[0] || {};
+          const { messages, ...metadata } = params;
+          return {
+            input: processInputAttachments(messages),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return result?.choices;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseMetricsFromUsage3(result?.usage);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateChatCompletionChunks
+      }
+    );
+    this.subscribeToChannel("orchestrion:openai:embeddings.create", {
+      name: "Embedding",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        const { input, ...metadata } = params;
+        return {
+          input,
+          metadata: { ...metadata, provider: "openai" }
+        };
+      },
+      extractOutput: (result) => {
+        return result?.data?.map((d) => d.embedding);
+      },
+      extractMetrics: (result) => {
+        return parseMetricsFromUsage3(result?.usage);
+      }
+    });
+    this.subscribeToStreamingChannel(
+      "orchestrion:openai:beta.chat.completions.parse",
+      {
+        name: "Chat Completion",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const params = args[0] || {};
+          const { messages, ...metadata } = params;
+          return {
+            input: processInputAttachments(messages),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return result?.choices;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseMetricsFromUsage3(result?.usage);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateChatCompletionChunks
+      }
+    );
+    this.subscribeToSyncStreamChannel(
+      "orchestrion:openai:beta.chat.completions.stream",
+      {
+        name: "Chat Completion",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const params = args[0] || {};
+          const { messages, ...metadata } = params;
+          return {
+            input: processInputAttachments(messages),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        }
+      }
+    );
+    this.subscribeToChannel("orchestrion:openai:moderations.create", {
+      name: "Moderation",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        const { input, ...metadata } = params;
+        return {
+          input,
+          metadata: { ...metadata, provider: "openai" }
+        };
+      },
+      extractOutput: (result) => {
+        return result?.results;
+      },
+      extractMetrics: () => {
+        return {};
+      }
+    });
+    this.subscribeToStreamingChannel("orchestrion:openai:responses.create", {
+      name: "openai.responses.create",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        const { input, ...metadata } = params;
+        return {
+          input: processInputAttachments(input),
+          metadata: { ...metadata, provider: "openai" }
+        };
+      },
+      extractOutput: (result) => {
+        return processImagesInOutput2(result?.output);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = parseMetricsFromUsage3(result?.usage);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      }
+    });
+    this.subscribeToSyncStreamChannel("orchestrion:openai:responses.stream", {
+      name: "openai.responses.stream",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        const { input, ...metadata } = params;
+        return {
+          input: processInputAttachments(input),
+          metadata: { ...metadata, provider: "openai" }
+        };
+      },
+      extractFromEvent: (event) => {
+        if (!event || !event.type || !event.response) {
+          return {};
+        }
+        const response = event.response;
+        if (event.type === "response.completed") {
+          const data = {};
+          if (response?.output !== void 0) {
+            data.output = processImagesInOutput2(response.output);
+          }
+          if (response) {
+            const { usage: _usage, output: _output, ...metadata } = response;
+            if (Object.keys(metadata).length > 0) {
+              data.metadata = metadata;
+            }
+          }
+          data.metrics = parseMetricsFromUsage3(response?.usage);
+          return data;
+        }
+        return {};
+      }
+    });
+    this.subscribeToStreamingChannel("orchestrion:openai:responses.parse", {
+      name: "openai.responses.parse",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        const { input, ...metadata } = params;
+        return {
+          input: processInputAttachments(input),
+          metadata: { ...metadata, provider: "openai" }
+        };
+      },
+      extractOutput: (result) => {
+        return processImagesInOutput2(result?.output);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = parseMetricsFromUsage3(result?.usage);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      }
+    });
+  }
+  onDisable() {
+  }
+};
+var TOKEN_NAME_MAP2 = {
+  input_tokens: "prompt_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_PREFIX_MAP2 = {
+  input: "prompt",
+  output: "completion"
+};
+function parseMetricsFromUsage3(usage) {
+  if (!usage) {
+    return {};
+  }
+  const metrics = {};
+  for (const [oai_name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      const metricName = TOKEN_NAME_MAP2[oai_name] || oai_name;
+      metrics[metricName] = value;
+    } else if (oai_name.endsWith("_tokens_details")) {
+      if (!isObject(value)) {
+        continue;
+      }
+      const rawPrefix = oai_name.slice(0, -"_tokens_details".length);
+      const prefix = TOKEN_PREFIX_MAP2[rawPrefix] || rawPrefix;
+      for (const [key, n] of Object.entries(value)) {
+        if (typeof n !== "number") {
+          continue;
+        }
+        const metricName = `${prefix}_${key}`;
+        metrics[metricName] = n;
+      }
+    }
+  }
+  return metrics;
+}
+function processImagesInOutput2(output) {
+  if (Array.isArray(output)) {
+    return output.map(processImagesInOutput2);
+  }
+  if (isObject(output)) {
+    if (output.type === "image_generation_call" && output.result && typeof output.result === "string") {
+      const fileExtension = output.output_format || "png";
+      const contentType = `image/${fileExtension}`;
+      const baseFilename = output.revised_prompt && typeof output.revised_prompt === "string" ? output.revised_prompt.slice(0, 50).replace(/[^a-zA-Z0-9]/g, "_") : "generated_image";
+      const filename = `${baseFilename}.${fileExtension}`;
+      const binaryString = atob(output.result);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      const blob = new Blob([bytes], { type: contentType });
+      const attachment = new Attachment({
+        data: blob,
+        filename,
+        contentType
+      });
+      return {
+        ...output,
+        result: attachment
+      };
+    }
+  }
+  return output;
+}
+function aggregateChatCompletionChunks(chunks) {
+  let role = void 0;
+  let content = void 0;
+  let tool_calls = void 0;
+  let finish_reason = void 0;
+  let metrics = {};
+  for (const chunk of chunks) {
+    if (chunk.usage) {
+      metrics = {
+        ...metrics,
+        ...parseMetricsFromUsage3(chunk.usage)
+      };
+    }
+    const delta = chunk.choices?.[0]?.delta;
+    if (!delta) {
+      continue;
+    }
+    if (!role && delta.role) {
+      role = delta.role;
+    }
+    if (delta.finish_reason) {
+      finish_reason = delta.finish_reason;
+    }
+    if (delta.content) {
+      content = (content || "") + delta.content;
+    }
+    if (delta.tool_calls) {
+      const toolDelta = delta.tool_calls[0];
+      if (!tool_calls || toolDelta.id && tool_calls[tool_calls.length - 1].id !== toolDelta.id) {
+        tool_calls = [
+          ...tool_calls || [],
+          {
+            id: toolDelta.id,
+            type: toolDelta.type,
+            function: toolDelta.function
+          }
+        ];
+      } else {
+        tool_calls[tool_calls.length - 1].function.arguments += toolDelta.function.arguments;
+      }
+    }
+  }
+  return {
+    metrics,
+    output: [
+      {
+        index: 0,
+        message: {
+          role,
+          content,
+          tool_calls
+        },
+        logprobs: null,
+        finish_reason
+      }
+    ]
+  };
+}
+
+// src/instrumentation/plugins/anthropic-plugin.ts
+import { tracingChannel as tracingChannel2 } from "dc-browser";
+var AnthropicPlugin = class extends BasePlugin {
+  unsubscribers = [];
+  onEnable() {
+    this.subscribeToAnthropicChannels();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+  subscribeToAnthropicChannels() {
+    this.subscribeToStreamingChannel("orchestrion:anthropic:messages.create", {
+      name: "anthropic.messages.create",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        const input = coalesceInput2(params.messages || [], params.system);
+        const metadata = filterFrom2(params, ["messages", "system"]);
+        return {
+          input: processAttachmentsInInput3(input),
+          metadata: { ...metadata, provider: "anthropic" }
+        };
+      },
+      extractOutput: (result) => {
+        return result ? { role: result.role, content: result.content } : null;
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = parseMetricsFromUsage4(result?.usage);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        const finalized = finalizeAnthropicTokens(metrics);
+        return Object.fromEntries(
+          Object.entries(finalized).filter(([, v]) => v !== void 0)
+        );
+      },
+      extractMetadata: (result) => {
+        const metadata = {};
+        const metas = ["stop_reason", "stop_sequence"];
+        for (const m of metas) {
+          if (result?.[m] !== void 0) {
+            metadata[m] = result[m];
+          }
+        }
+        return metadata;
+      },
+      aggregateChunks: aggregateAnthropicStreamChunks,
+      isStreaming: (args) => {
+        return args[0]?.stream === true;
+      }
+    });
+    this.subscribeToStreamingChannel(
+      "orchestrion:anthropic:beta.messages.create",
+      {
+        name: "anthropic.beta.messages.create",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const params = args[0] || {};
+          const input = coalesceInput2(params.messages || [], params.system);
+          const metadata = filterFrom2(params, ["messages", "system"]);
+          return {
+            input: processAttachmentsInInput3(input),
+            metadata: { ...metadata, provider: "anthropic" }
+          };
+        },
+        extractOutput: (result) => {
+          return result ? { role: result.role, content: result.content } : null;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseMetricsFromUsage4(result?.usage);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          const finalized = finalizeAnthropicTokens(metrics);
+          return Object.fromEntries(
+            Object.entries(finalized).filter(([, v]) => v !== void 0)
+          );
+        },
+        extractMetadata: (result) => {
+          const metadata = {};
+          const metas = ["stop_reason", "stop_sequence"];
+          for (const m of metas) {
+            if (result?.[m] !== void 0) {
+              metadata[m] = result[m];
+            }
+          }
+          return metadata;
+        },
+        aggregateChunks: aggregateAnthropicStreamChunks,
+        isStreaming: (args) => {
+          return args[0]?.stream === true;
+        }
+      }
+    );
+  }
+  /**
+   * Subscribe to a channel for async methods that may return streams.
+   * Handles both streaming and non-streaming responses based on the stream parameter.
+   */
+  subscribeToStreamingChannel(channelName, config) {
+    const channel = tracingChannel2(channelName);
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const span = startSpan({
+          name: config.name,
+          spanAttributes: {
+            type: config.type
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        spans.set(event, { span, startTime });
+        try {
+          const { input, metadata } = config.extractInput(event.arguments);
+          span.log({
+            input,
+            metadata
+          });
+        } catch (error) {
+          console.error(`Error extracting input for ${channelName}:`, error);
+        }
+      },
+      asyncEnd: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span, startTime } = spanData;
+        const isStreaming = config.isStreaming ? config.isStreaming(event.arguments) : isAsyncIterable4(event.result);
+        if (isStreaming && isAsyncIterable4(event.result)) {
+          patchStreamIfNeeded(event.result, {
+            onComplete: (chunks) => {
+              try {
+                let output;
+                let metrics;
+                let metadata = {};
+                if (config.aggregateChunks) {
+                  const aggregated = config.aggregateChunks(chunks);
+                  output = aggregated.output;
+                  metrics = aggregated.metrics;
+                  metadata = aggregated.metadata || {};
+                } else {
+                  output = config.extractOutput(chunks);
+                  metrics = config.extractMetrics(chunks, startTime);
+                  if (config.extractMetadata) {
+                    metadata = config.extractMetadata(chunks);
+                  }
+                }
+                if (!metrics.time_to_first_token && chunks.length > 0) {
+                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+                }
+                span.log({
+                  output,
+                  metrics,
+                  metadata
+                });
+              } catch (error) {
+                console.error(
+                  `Error extracting output for ${channelName}:`,
+                  error
+                );
+              } finally {
+                span.end();
+              }
+            },
+            onError: (error) => {
+              span.log({
+                error: error.message
+              });
+              span.end();
+            }
+          });
+        } else {
+          try {
+            const output = config.extractOutput(event.result);
+            const metrics = config.extractMetrics(event.result, startTime);
+            const metadata = config.extractMetadata ? config.extractMetadata(event.result) : {};
+            span.log({
+              output,
+              metrics,
+              metadata
+            });
+          } catch (error) {
+            console.error(`Error extracting output for ${channelName}:`, error);
+          } finally {
+            span.end();
+            spans.delete(event);
+          }
+        }
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+};
+function parseMetricsFromUsage4(usage) {
+  if (!usage) {
+    return {};
+  }
+  const metrics = {};
+  function saveIfExistsTo(source, target) {
+    const value = usage[source];
+    if (value !== void 0 && value !== null && typeof value === "number") {
+      metrics[target] = value;
+    }
+  }
+  saveIfExistsTo("input_tokens", "prompt_tokens");
+  saveIfExistsTo("output_tokens", "completion_tokens");
+  saveIfExistsTo("cache_read_input_tokens", "prompt_cached_tokens");
+  saveIfExistsTo("cache_creation_input_tokens", "prompt_cache_creation_tokens");
+  return metrics;
+}
+function aggregateAnthropicStreamChunks(chunks) {
+  const deltas = [];
+  let metrics = {};
+  let metadata = {};
+  for (const chunk of chunks) {
+    switch (chunk?.type) {
+      case "message_start":
+        if (chunk.message?.usage) {
+          const initialMetrics = parseMetricsFromUsage4(chunk.message.usage);
+          metrics = { ...metrics, ...initialMetrics };
+        }
+        break;
+      case "content_block_delta":
+        if (chunk.delta?.type === "text_delta") {
+          const text = chunk.delta?.text;
+          if (text) {
+            deltas.push(text);
+          }
+        }
+        break;
+      case "message_delta":
+        if (chunk.usage) {
+          const finalMetrics = parseMetricsFromUsage4(chunk.usage);
+          metrics = { ...metrics, ...finalMetrics };
+        }
+        if (chunk.delta) {
+          metadata = { ...metadata, ...chunk.delta };
+        }
+        break;
+    }
+  }
+  const output = deltas.join("");
+  const finalized = finalizeAnthropicTokens(metrics);
+  const filteredMetrics = Object.fromEntries(
+    Object.entries(finalized).filter(([, v]) => v !== void 0)
+  );
+  return {
+    output,
+    metrics: filteredMetrics,
+    metadata
+  };
+}
+function convertBase64ToAttachment2(source, contentType) {
+  const mediaType = typeof source.media_type === "string" ? source.media_type : "image/png";
+  const base64Data = source.data;
+  if (base64Data && typeof base64Data === "string") {
+    const binaryString = atob(base64Data);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    const blob = new Blob([bytes], { type: mediaType });
+    const extension = mediaType.split("/")[1] || "bin";
+    const prefix = contentType === "document" ? "document" : "image";
+    const filename = `${prefix}.${extension}`;
+    const attachment = new Attachment({
+      data: blob,
+      filename,
+      contentType: mediaType
+    });
+    return {
+      ...source,
+      data: attachment
+    };
+  }
+  return source;
+}
+function processAttachmentsInInput3(input) {
+  if (Array.isArray(input)) {
+    return input.map(processAttachmentsInInput3);
+  }
+  if (isObject(input)) {
+    if ((input.type === "image" || input.type === "document") && isObject(input.source) && input.source.type === "base64") {
+      return {
+        ...input,
+        source: convertBase64ToAttachment2(input.source, input.type)
+      };
+    }
+    const processed = {};
+    for (const [key, value] of Object.entries(input)) {
+      processed[key] = processAttachmentsInInput3(value);
+    }
+    return processed;
+  }
+  return input;
+}
+function coalesceInput2(messages, system) {
+  const input = (messages || []).slice();
+  if (system) {
+    input.push({ role: "system", content: system });
+  }
+  return input;
+}
+function filterFrom2(obj, fieldsToRemove) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!fieldsToRemove.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/instrumentation/plugins/ai-sdk-plugin.ts
+import { tracingChannel as tracingChannel3 } from "dc-browser";
+var DEFAULT_DENY_OUTPUT_PATHS = [
+  // v3
+  "roundtrips[].request.body",
+  "roundtrips[].response.headers",
+  "rawResponse.headers",
+  "responseMessages",
+  // v5
+  "request.body",
+  "response.body",
+  "response.headers",
+  "steps[].request.body",
+  "steps[].response.body",
+  "steps[].response.headers"
+];
+var AISDKPlugin = class extends BasePlugin {
+  unsubscribers = [];
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  onEnable() {
+    this.subscribeToAISDK();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+  subscribeToAISDK() {
+    const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
+    this.subscribeToStreamingChannel("orchestrion:ai-sdk:generateText", {
+      name: "generateText",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        return {
+          input: processAISDKInput(params),
+          metadata: extractMetadataFromParams(params)
+        };
+      },
+      extractOutput: (result) => {
+        return processAISDKOutput(result, denyOutputPaths);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = extractTokenMetrics2(result);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      },
+      aggregateChunks: aggregateAISDKChunks
+    });
+    this.subscribeToStreamingChannel("orchestrion:ai-sdk:streamText", {
+      name: "streamText",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        return {
+          input: processAISDKInput(params),
+          metadata: extractMetadataFromParams(params)
+        };
+      },
+      extractOutput: (result) => {
+        return processAISDKOutput(result, denyOutputPaths);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = extractTokenMetrics2(result);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      },
+      aggregateChunks: aggregateAISDKChunks
+    });
+    this.subscribeToStreamingChannel("orchestrion:ai-sdk:generateObject", {
+      name: "generateObject",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        return {
+          input: processAISDKInput(params),
+          metadata: extractMetadataFromParams(params)
+        };
+      },
+      extractOutput: (result) => {
+        return processAISDKOutput(result, denyOutputPaths);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = extractTokenMetrics2(result);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      },
+      aggregateChunks: aggregateAISDKChunks
+    });
+    this.subscribeToStreamingChannel("orchestrion:ai-sdk:streamObject", {
+      name: "streamObject",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        return {
+          input: processAISDKInput(params),
+          metadata: extractMetadataFromParams(params)
+        };
+      },
+      extractOutput: (result) => {
+        return processAISDKOutput(result, denyOutputPaths);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = extractTokenMetrics2(result);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      },
+      aggregateChunks: aggregateAISDKChunks
+    });
+    this.subscribeToStreamingChannel("orchestrion:ai-sdk:Agent.generate", {
+      name: "Agent.generate",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        return {
+          input: processAISDKInput(params),
+          metadata: extractMetadataFromParams(params)
+        };
+      },
+      extractOutput: (result) => {
+        return processAISDKOutput(result, denyOutputPaths);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = extractTokenMetrics2(result);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      },
+      aggregateChunks: aggregateAISDKChunks
+    });
+    this.subscribeToStreamingChannel("orchestrion:ai-sdk:Agent.stream", {
+      name: "Agent.stream",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        return {
+          input: processAISDKInput(params),
+          metadata: extractMetadataFromParams(params)
+        };
+      },
+      extractOutput: (result) => {
+        return processAISDKOutput(result, denyOutputPaths);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = extractTokenMetrics2(result);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      },
+      aggregateChunks: aggregateAISDKChunks
+    });
+  }
+  /**
+   * Subscribe to a channel for async methods that may return streams.
+   * Handles both streaming and non-streaming responses.
+   */
+  subscribeToStreamingChannel(channelName, config) {
+    const channel = tracingChannel3(channelName);
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const span = startSpan({
+          name: config.name,
+          spanAttributes: {
+            type: config.type
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        spans.set(event, { span, startTime });
+        try {
+          const { input, metadata } = config.extractInput(event.arguments);
+          span.log({
+            input,
+            metadata
+          });
+        } catch (error) {
+          console.error(`Error extracting input for ${channelName}:`, error);
+        }
+      },
+      asyncEnd: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span, startTime } = spanData;
+        if (isAsyncIterable4(event.result)) {
+          patchStreamIfNeeded(event.result, {
+            onComplete: (chunks) => {
+              try {
+                let output;
+                let metrics;
+                if (config.aggregateChunks) {
+                  const aggregated = config.aggregateChunks(chunks);
+                  output = aggregated.output;
+                  metrics = aggregated.metrics;
+                } else {
+                  output = config.extractOutput(chunks);
+                  metrics = config.extractMetrics(chunks, startTime);
+                }
+                if (!metrics.time_to_first_token && chunks.length > 0) {
+                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+                }
+                span.log({
+                  output,
+                  metrics
+                });
+              } catch (error) {
+                console.error(
+                  `Error extracting output for ${channelName}:`,
+                  error
+                );
+              } finally {
+                span.end();
+              }
+            },
+            onError: (error) => {
+              span.log({
+                error: error.message
+              });
+              span.end();
+            }
+          });
+        } else {
+          try {
+            const output = config.extractOutput(event.result);
+            const metrics = config.extractMetrics(event.result, startTime);
+            span.log({
+              output,
+              metrics
+            });
+          } catch (error) {
+            console.error(`Error extracting output for ${channelName}:`, error);
+          } finally {
+            span.end();
+            spans.delete(event);
+          }
+        }
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+};
+function processAISDKInput(params) {
+  if (!params) return params;
+  return processInputAttachments(params);
+}
+function extractMetadataFromParams(params) {
+  const metadata = {
+    braintrust: {
+      integration_name: "ai-sdk",
+      sdk_language: "typescript"
+    }
+  };
+  const { model, provider } = serializeModelWithProvider2(params.model);
+  if (model) {
+    metadata.model = model;
+  }
+  if (provider) {
+    metadata.provider = provider;
+  }
+  return metadata;
+}
+function processAISDKOutput(output, denyOutputPaths) {
+  if (!output) return output;
+  const getterValues = extractGetterValues2(output);
+  const merged = { ...output, ...getterValues };
+  return omit2(merged, denyOutputPaths);
+}
+function extractTokenMetrics2(result) {
+  const metrics = {};
+  let usage = result?.totalUsage || result?.usage;
+  if (!usage && result) {
+    try {
+      if ("totalUsage" in result && typeof result.totalUsage !== "function") {
+        usage = result.totalUsage;
+      } else if ("usage" in result && typeof result.usage !== "function") {
+        usage = result.usage;
+      }
+    } catch {
+    }
+  }
+  if (!usage) {
+    return metrics;
+  }
+  const promptTokens = firstNumber2(
+    usage.inputTokens?.total,
+    usage.inputTokens,
+    usage.promptTokens,
+    usage.prompt_tokens
+  );
+  if (promptTokens !== void 0) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  const completionTokens = firstNumber2(
+    usage.outputTokens?.total,
+    usage.outputTokens,
+    usage.completionTokens,
+    usage.completion_tokens
+  );
+  if (completionTokens !== void 0) {
+    metrics.completion_tokens = completionTokens;
+  }
+  const totalTokens = firstNumber2(
+    usage.totalTokens,
+    usage.tokens,
+    usage.total_tokens
+  );
+  if (totalTokens !== void 0) {
+    metrics.tokens = totalTokens;
+  }
+  const cost = extractCostFromResult2(result);
+  if (cost !== void 0) {
+    metrics.estimated_cost = cost;
+  }
+  return metrics;
+}
+function aggregateAISDKChunks(chunks) {
+  const lastChunk = chunks[chunks.length - 1];
+  const output = {};
+  let metrics = {};
+  if (lastChunk) {
+    metrics = extractTokenMetrics2(lastChunk);
+    if (lastChunk.text !== void 0) {
+      output.text = lastChunk.text;
+    }
+    if (lastChunk.object !== void 0) {
+      output.object = lastChunk.object;
+    }
+    if (lastChunk.finishReason !== void 0) {
+      output.finishReason = lastChunk.finishReason;
+    }
+    if (lastChunk.toolCalls !== void 0) {
+      output.toolCalls = lastChunk.toolCalls;
+    }
+  }
+  return { output, metrics };
+}
+function extractGetterValues2(obj) {
+  const getterValues = {};
+  const getterNames = [
+    "text",
+    "object",
+    "finishReason",
+    "usage",
+    "totalUsage",
+    "toolCalls",
+    "toolResults",
+    "warnings",
+    "experimental_providerMetadata",
+    "providerMetadata",
+    "rawResponse",
+    "response"
+  ];
+  for (const name of getterNames) {
+    try {
+      if (obj && name in obj && typeof obj[name] !== "function") {
+        getterValues[name] = obj[name];
+      }
+    } catch {
+    }
+  }
+  return getterValues;
+}
+function serializeModelWithProvider2(model) {
+  const modelId = typeof model === "string" ? model : model?.modelId;
+  const explicitProvider = typeof model === "object" ? model?.provider : void 0;
+  if (!modelId) {
+    return { model: modelId, provider: explicitProvider };
+  }
+  const parsed = parseGatewayModelString2(modelId);
+  return {
+    model: parsed.model,
+    provider: explicitProvider || parsed.provider
+  };
+}
+function parseGatewayModelString2(modelString) {
+  if (!modelString || typeof modelString !== "string") {
+    return { model: modelString };
+  }
+  const slashIndex = modelString.indexOf("/");
+  if (slashIndex > 0 && slashIndex < modelString.length - 1) {
+    return {
+      provider: modelString.substring(0, slashIndex),
+      model: modelString.substring(slashIndex + 1)
+    };
+  }
+  return { model: modelString };
+}
+function extractCostFromResult2(result) {
+  if (result?.steps && Array.isArray(result.steps) && result.steps.length > 0) {
+    let totalCost = 0;
+    let foundCost = false;
+    for (const step of result.steps) {
+      const gateway2 = step?.providerMetadata?.gateway;
+      const stepCost = parseGatewayCost2(gateway2?.cost) || parseGatewayCost2(gateway2?.marketCost);
+      if (stepCost !== void 0 && stepCost > 0) {
+        totalCost += stepCost;
+        foundCost = true;
+      }
+    }
+    if (foundCost) {
+      return totalCost;
+    }
+  }
+  const gateway = result?.providerMetadata?.gateway;
+  const directCost = parseGatewayCost2(gateway?.cost) || parseGatewayCost2(gateway?.marketCost);
+  if (directCost !== void 0 && directCost > 0) {
+    return directCost;
+  }
+  return void 0;
+}
+function parseGatewayCost2(cost) {
+  if (cost === void 0 || cost === null) {
+    return void 0;
+  }
+  if (typeof cost === "number") {
+    return cost;
+  }
+  if (typeof cost === "string") {
+    const parsed = parseFloat(cost);
+    if (!isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function firstNumber2(...values) {
+  for (const v of values) {
+    if (typeof v === "number") {
+      return v;
+    }
+  }
+  return void 0;
+}
+function deepCopy2(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function parsePath2(path) {
+  const keys = [];
+  let current = "";
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === ".") {
+      if (current) {
+        keys.push(current);
+        current = "";
+      }
+    } else if (char === "[") {
+      if (current) {
+        keys.push(current);
+        current = "";
+      }
+      let bracketContent = "";
+      i++;
+      while (i < path.length && path[i] !== "]") {
+        bracketContent += path[i];
+        i++;
+      }
+      if (bracketContent === "") {
+        keys.push("[]");
+      } else {
+        const index = parseInt(bracketContent, 10);
+        keys.push(isNaN(index) ? bracketContent : index);
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    keys.push(current);
+  }
+  return keys;
+}
+function omitAtPath2(obj, keys) {
+  if (keys.length === 0) return;
+  const firstKey = keys[0];
+  const remainingKeys = keys.slice(1);
+  if (firstKey === "[]") {
+    if (Array.isArray(obj)) {
+      obj.forEach((item) => {
+        if (remainingKeys.length > 0) {
+          omitAtPath2(item, remainingKeys);
+        }
+      });
+    }
+  } else if (remainingKeys.length === 0) {
+    if (obj && typeof obj === "object" && firstKey in obj) {
+      obj[firstKey] = "<omitted>";
+    }
+  } else {
+    if (obj && typeof obj === "object" && firstKey in obj) {
+      omitAtPath2(obj[firstKey], remainingKeys);
+    }
+  }
+}
+function omit2(obj, paths) {
+  const result = deepCopy2(obj);
+  for (const path of paths) {
+    const keys = parsePath2(path);
+    omitAtPath2(result, keys);
+  }
+  return result;
+}
+
+// src/instrumentation/plugins/claude-agent-sdk-plugin.ts
+import { tracingChannel as tracingChannel4 } from "dc-browser";
+function filterSerializableOptions2(options) {
+  const allowedKeys = [
+    "model",
+    "maxTurns",
+    "cwd",
+    "continue",
+    "allowedTools",
+    "disallowedTools",
+    "additionalDirectories",
+    "permissionMode",
+    "debug",
+    "apiKey",
+    "apiKeySource",
+    "agentName",
+    "instructions"
+  ];
+  const filtered = {};
+  for (const key of allowedKeys) {
+    if (options[key] !== void 0) {
+      filtered[key] = options[key];
+    }
+  }
+  return filtered;
+}
+function getNumberProperty3(obj, key) {
+  if (!obj || typeof obj !== "object" || !(key in obj)) {
+    return void 0;
+  }
+  const value = Reflect.get(obj, key);
+  return typeof value === "number" ? value : void 0;
+}
+function extractUsageFromMessage(message) {
+  const metrics = {};
+  let usage;
+  if (message.type === "assistant") {
+    usage = message.message?.usage;
+  } else if (message.type === "result") {
+    usage = message.usage;
+  }
+  if (!usage || typeof usage !== "object") {
+    return metrics;
+  }
+  const inputTokens = getNumberProperty3(usage, "input_tokens");
+  if (inputTokens !== void 0) {
+    metrics.prompt_tokens = inputTokens;
+  }
+  const outputTokens = getNumberProperty3(usage, "output_tokens");
+  if (outputTokens !== void 0) {
+    metrics.completion_tokens = outputTokens;
+  }
+  const cacheReadTokens = getNumberProperty3(usage, "cache_read_input_tokens") || 0;
+  const cacheCreationTokens = getNumberProperty3(usage, "cache_creation_input_tokens") || 0;
+  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
+    const cacheTokens = extractAnthropicCacheTokens(
+      cacheReadTokens,
+      cacheCreationTokens
+    );
+    Object.assign(metrics, cacheTokens);
+  }
+  if (Object.keys(metrics).length > 0) {
+    Object.assign(metrics, finalizeAnthropicTokens(metrics));
+  }
+  return metrics;
+}
+function buildLLMInput(prompt, conversationHistory) {
+  const promptMessage = typeof prompt === "string" ? { content: prompt, role: "user" } : void 0;
+  const inputParts = [
+    ...promptMessage ? [promptMessage] : [],
+    ...conversationHistory
+  ];
+  return inputParts.length > 0 ? inputParts : void 0;
+}
+async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
+  if (messages.length === 0) return void 0;
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage.type !== "assistant" || !lastMessage.message?.usage) {
+    return void 0;
+  }
+  const model = lastMessage.message.model || options.model;
+  const usage = extractUsageFromMessage(lastMessage);
+  const input = buildLLMInput(prompt, conversationHistory);
+  const outputs = messages.map(
+    (m) => m.message?.content && m.message?.role ? { content: m.message.content, role: m.message.role } : void 0
+  ).filter((c) => c !== void 0);
+  const span = startSpan({
+    name: "anthropic.messages.create",
+    spanAttributes: {
+      type: "llm" /* LLM */
+    },
+    startTime,
+    parent: parentSpan
+  });
+  span.log({
+    input,
+    output: outputs,
+    metadata: model ? { model } : void 0,
+    metrics: usage
+  });
+  await span.end();
+  return lastMessage.message?.content && lastMessage.message?.role ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+}
+var ClaudeAgentSDKPlugin = class extends BasePlugin {
+  unsubscribers = [];
+  onEnable() {
+    this.subscribeToQuery();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+  /**
+   * Subscribe to the query channel for agent interactions.
+   * Handles streaming responses and traces both the top-level agent task
+   * and individual LLM calls.
+   */
+  subscribeToQuery() {
+    const channel = tracingChannel4("orchestrion:claude-agent-sdk:query");
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const params = event.arguments[0] ?? {};
+        const { prompt, options = {} } = params;
+        const span = startSpan({
+          name: "Claude Agent",
+          spanAttributes: {
+            type: "task" /* TASK */
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        try {
+          span.log({
+            input: typeof prompt === "string" ? prompt : {
+              type: "streaming",
+              description: "AsyncIterable<SDKMessage>"
+            },
+            metadata: filterSerializableOptions2(options)
+          });
+        } catch (error) {
+          console.error("Error extracting input for Claude Agent SDK:", error);
+        }
+        spans.set(event, {
+          span,
+          startTime,
+          conversationHistory: [],
+          currentMessages: [],
+          currentMessageId: void 0,
+          currentMessageStartTime: startTime,
+          accumulatedOutputTokens: 0
+        });
+      },
+      asyncEnd: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        if (isAsyncIterable4(event.result)) {
+          patchStreamIfNeeded(event.result, {
+            onChunk: async (message) => {
+              const currentTime = getCurrentUnixTimestamp();
+              const params = event.arguments[0];
+              const { prompt, options = {} } = params;
+              const messageId = message.message?.id;
+              if (messageId && messageId !== spanData.currentMessageId) {
+                if (spanData.currentMessages.length > 0) {
+                  const finalMessage = await createLLMSpanForMessages(
+                    spanData.currentMessages,
+                    prompt,
+                    spanData.conversationHistory,
+                    options,
+                    spanData.currentMessageStartTime,
+                    await spanData.span.export()
+                  );
+                  if (finalMessage) {
+                    spanData.conversationHistory.push(finalMessage);
+                  }
+                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
+                  if (lastMessage?.message?.usage) {
+                    const outputTokens = getNumberProperty3(
+                      lastMessage.message.usage,
+                      "output_tokens"
+                    ) || 0;
+                    spanData.accumulatedOutputTokens += outputTokens;
+                  }
+                  spanData.currentMessages = [];
+                }
+                spanData.currentMessageId = messageId;
+                spanData.currentMessageStartTime = currentTime;
+              }
+              if (message.type === "assistant" && message.message?.usage) {
+                spanData.currentMessages.push(message);
+              }
+              if (message.type === "result" && message.usage) {
+                const finalUsageMetrics = extractUsageFromMessage(message);
+                if (spanData.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
+                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
+                  if (lastMessage?.message?.usage) {
+                    const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
+                    if (adjustedTokens >= 0) {
+                      lastMessage.message.usage.output_tokens = adjustedTokens;
+                    }
+                  }
+                }
+                const result_metadata = {};
+                if (message.num_turns !== void 0) {
+                  result_metadata.num_turns = message.num_turns;
+                }
+                if (message.session_id !== void 0) {
+                  result_metadata.session_id = message.session_id;
+                }
+                if (Object.keys(result_metadata).length > 0) {
+                  spanData.span.log({
+                    metadata: result_metadata
+                  });
+                }
+              }
+            },
+            onComplete: async () => {
+              try {
+                const params = event.arguments[0];
+                const { prompt, options = {} } = params;
+                if (spanData.currentMessages.length > 0) {
+                  const finalMessage = await createLLMSpanForMessages(
+                    spanData.currentMessages,
+                    prompt,
+                    spanData.conversationHistory,
+                    options,
+                    spanData.currentMessageStartTime,
+                    await spanData.span.export()
+                  );
+                  if (finalMessage) {
+                    spanData.conversationHistory.push(finalMessage);
+                  }
+                }
+                spanData.span.log({
+                  output: spanData.conversationHistory.length > 0 ? spanData.conversationHistory[spanData.conversationHistory.length - 1] : void 0
+                });
+              } catch (error) {
+                console.error(
+                  "Error extracting output for Claude Agent SDK:",
+                  error
+                );
+              } finally {
+                spanData.span.end();
+                spans.delete(event);
+              }
+            },
+            onError: (error) => {
+              spanData.span.log({
+                error: error.message
+              });
+              spanData.span.end();
+              spans.delete(event);
+            }
+          });
+        } else {
+          try {
+            spanData.span.log({
+              output: event.result
+            });
+          } catch (error) {
+            console.error(
+              "Error extracting output for Claude Agent SDK:",
+              error
+            );
+          } finally {
+            spanData.span.end();
+            spans.delete(event);
+          }
+        }
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+};
+
+// src/instrumentation/plugins/google-genai-plugin.ts
+import { tracingChannel as tracingChannel5 } from "dc-browser";
+var GoogleGenAIPlugin = class extends BasePlugin {
+  unsubscribers = [];
+  onEnable() {
+    this.subscribeToGoogleGenAIChannels();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+  subscribeToGoogleGenAIChannels() {
+    this.subscribeToChannel("orchestrion:google-genai:models.generateContent", {
+      name: "google-genai.generateContent",
+      type: "llm" /* LLM */,
+      extractInput: (args) => {
+        const params = args[0] || {};
+        const input = serializeInput2(params);
+        const metadata = extractMetadata2(params);
+        return {
+          input,
+          metadata: { ...metadata, provider: "google-genai" }
+        };
+      },
+      extractOutput: (result) => {
+        return result;
+      },
+      extractMetrics: (result, startTime) => {
+        return extractGenerateContentMetrics2(result, startTime);
+      }
+    });
+    this.subscribeToGoogleStreamingChannel(
+      "orchestrion:google-genai:models.generateContentStream",
+      {
+        name: "google-genai.generateContentStream",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const params = args[0] || {};
+          const input = serializeInput2(params);
+          const metadata = extractMetadata2(params);
+          return {
+            input,
+            metadata: { ...metadata, provider: "google-genai" }
+          };
+        },
+        aggregateChunks: aggregateGenerateContentChunks2
+      }
+    );
+  }
+  subscribeToChannel(channelName, config) {
+    const channel = tracingChannel5(channelName);
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const span = startSpan({
+          name: config.name,
+          spanAttributes: {
+            type: config.type
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        spans.set(event, { span, startTime });
+        try {
+          const { input, metadata } = config.extractInput(event.arguments);
+          span.log({
+            input,
+            metadata
+          });
+        } catch (error) {
+          console.error(`Error extracting input for ${channelName}:`, error);
+        }
+      },
+      asyncEnd: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span, startTime } = spanData;
+        try {
+          const output = config.extractOutput(event.result);
+          const metrics = config.extractMetrics(event.result, startTime);
+          span.log({
+            output,
+            metrics
+          });
+        } catch (error) {
+          console.error(`Error extracting output for ${channelName}:`, error);
+        } finally {
+          span.end();
+          spans.delete(event);
+        }
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+  subscribeToGoogleStreamingChannel(channelName, config) {
+    const channel = tracingChannel5(channelName);
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const span = startSpan({
+          name: config.name,
+          spanAttributes: {
+            type: config.type
+          }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        spans.set(event, { span, startTime });
+        try {
+          const { input, metadata } = config.extractInput(event.arguments);
+          span.log({
+            input,
+            metadata
+          });
+        } catch (error) {
+          console.error(`Error extracting input for ${channelName}:`, error);
+        }
+      },
+      asyncEnd: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span, startTime } = spanData;
+        if (isAsyncIterable4(event.result)) {
+          patchStreamIfNeeded(event.result, {
+            onComplete: (chunks) => {
+              try {
+                const { output, metrics } = config.aggregateChunks(
+                  chunks,
+                  startTime
+                );
+                span.log({
+                  output,
+                  metrics
+                });
+              } catch (error) {
+                console.error(
+                  `Error extracting output for ${channelName}:`,
+                  error
+                );
+              } finally {
+                span.end();
+              }
+            },
+            onError: (error) => {
+              span.log({
+                error: error.message
+              });
+              span.end();
+            }
+          });
+        } else {
+          span.end();
+          spans.delete(event);
+        }
+      },
+      error: (event) => {
+        const spanData = spans.get(event);
+        if (!spanData) {
+          return;
+        }
+        const { span } = spanData;
+        span.log({
+          error: event.error.message
+        });
+        span.end();
+        spans.delete(event);
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+};
+function serializeInput2(params) {
+  const input = {
+    model: params.model,
+    contents: serializeContents2(params.contents)
+  };
+  if (params.config) {
+    const config = tryToDict2(params.config);
+    if (config) {
+      const tools = serializeTools2(params);
+      if (tools) {
+        config.tools = tools;
+      }
+      input.config = config;
+    }
+  }
+  return input;
+}
+function serializeContents2(contents) {
+  if (contents === null || contents === void 0) {
+    return null;
+  }
+  if (Array.isArray(contents)) {
+    return contents.map((item) => serializeContentItem2(item));
+  }
+  return serializeContentItem2(contents);
+}
+function serializeContentItem2(item) {
+  if (typeof item === "object" && item !== null) {
+    if (item.parts && Array.isArray(item.parts)) {
+      return {
+        ...item,
+        parts: item.parts.map((part) => serializePart2(part))
+      };
+    }
+    return item;
+  }
+  if (typeof item === "string") {
+    return { text: item };
+  }
+  return item;
+}
+function serializePart2(part) {
+  if (!part || typeof part !== "object") {
+    return part;
+  }
+  if (part.inlineData && part.inlineData.data) {
+    const { data, mimeType } = part.inlineData;
+    if (data instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(data) || typeof data === "string") {
+      const extension = mimeType ? mimeType.split("/")[1] : "bin";
+      const filename = `file.${extension}`;
+      const buffer = typeof data === "string" ? typeof Buffer !== "undefined" ? Buffer.from(data, "base64") : new Uint8Array(
+        atob(data).split("").map((c) => c.charCodeAt(0))
+      ) : typeof Buffer !== "undefined" ? Buffer.from(data) : new Uint8Array(data);
+      const attachment = new Attachment({
+        data: buffer,
+        filename,
+        contentType: mimeType || "application/octet-stream"
+      });
+      return {
+        image_url: { url: attachment }
+      };
+    }
+  }
+  return part;
+}
+function serializeTools2(params) {
+  if (!params.config?.tools) {
+    return null;
+  }
+  try {
+    return params.config.tools.map((tool) => {
+      if (typeof tool === "object" && tool.functionDeclarations) {
+        return tool;
+      }
+      return tool;
+    });
+  } catch {
+    return null;
+  }
+}
+function extractMetadata2(params) {
+  const metadata = {};
+  if (params.model) {
+    metadata.model = params.model;
+  }
+  if (params.config) {
+    const config = tryToDict2(params.config);
+    if (config) {
+      Object.keys(config).forEach((key) => {
+        if (key !== "tools") {
+          metadata[key] = config[key];
+        }
+      });
+    }
+  }
+  return metadata;
+}
+function extractGenerateContentMetrics2(response, startTime) {
+  const metrics = {};
+  if (startTime) {
+    const end = getCurrentUnixTimestamp();
+    metrics.duration = end - startTime;
+  }
+  if (response.usageMetadata) {
+    const usage = response.usageMetadata;
+    if (usage.promptTokenCount !== void 0) {
+      metrics.prompt_tokens = usage.promptTokenCount;
+    }
+    if (usage.candidatesTokenCount !== void 0) {
+      metrics.completion_tokens = usage.candidatesTokenCount;
+    }
+    if (usage.totalTokenCount !== void 0) {
+      metrics.tokens = usage.totalTokenCount;
+    }
+    if (usage.cachedContentTokenCount !== void 0) {
+      metrics.prompt_cached_tokens = usage.cachedContentTokenCount;
+    }
+    if (usage.thoughtsTokenCount !== void 0) {
+      metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
+    }
+  }
+  return metrics;
+}
+function aggregateGenerateContentChunks2(chunks, startTime) {
+  const end = getCurrentUnixTimestamp();
+  const metrics = {
+    duration: end - startTime
+  };
+  let firstTokenTime = null;
+  if (chunks.length > 0 && firstTokenTime === null) {
+    firstTokenTime = getCurrentUnixTimestamp();
+    metrics.time_to_first_token = firstTokenTime - startTime;
+  }
+  if (chunks.length === 0) {
+    return { output: {}, metrics };
+  }
+  let text = "";
+  let thoughtText = "";
+  const otherParts = [];
+  let usageMetadata = null;
+  let lastResponse = null;
+  for (const chunk of chunks) {
+    lastResponse = chunk;
+    if (chunk.usageMetadata) {
+      usageMetadata = chunk.usageMetadata;
+    }
+    if (chunk.candidates && Array.isArray(chunk.candidates)) {
+      for (const candidate of chunk.candidates) {
+        if (candidate.content?.parts) {
+          for (const part of candidate.content.parts) {
+            if (part.text !== void 0) {
+              if (part.thought) {
+                thoughtText += part.text;
+              } else {
+                text += part.text;
+              }
+            } else if (part.functionCall) {
+              otherParts.push({ functionCall: part.functionCall });
+            } else if (part.codeExecutionResult) {
+              otherParts.push({
+                codeExecutionResult: part.codeExecutionResult
+              });
+            } else if (part.executableCode) {
+              otherParts.push({ executableCode: part.executableCode });
+            }
+          }
+        }
+      }
+    }
+  }
+  const output = {};
+  const parts = [];
+  if (thoughtText) {
+    parts.push({ text: thoughtText, thought: true });
+  }
+  if (text) {
+    parts.push({ text });
+  }
+  parts.push(...otherParts);
+  if (parts.length > 0 && lastResponse?.candidates) {
+    const candidates = [];
+    for (const candidate of lastResponse.candidates) {
+      const candidateDict = {
+        content: {
+          parts,
+          role: "model"
+        }
+      };
+      if (candidate.finishReason !== void 0) {
+        candidateDict.finishReason = candidate.finishReason;
+      }
+      if (candidate.safetyRatings) {
+        candidateDict.safetyRatings = candidate.safetyRatings;
+      }
+      candidates.push(candidateDict);
+    }
+    output.candidates = candidates;
+  }
+  if (usageMetadata) {
+    output.usageMetadata = usageMetadata;
+    if (usageMetadata.promptTokenCount !== void 0) {
+      metrics.prompt_tokens = usageMetadata.promptTokenCount;
+    }
+    if (usageMetadata.candidatesTokenCount !== void 0) {
+      metrics.completion_tokens = usageMetadata.candidatesTokenCount;
+    }
+    if (usageMetadata.totalTokenCount !== void 0) {
+      metrics.tokens = usageMetadata.totalTokenCount;
+    }
+    if (usageMetadata.cachedContentTokenCount !== void 0) {
+      metrics.prompt_cached_tokens = usageMetadata.cachedContentTokenCount;
+    }
+    if (usageMetadata.thoughtsTokenCount !== void 0) {
+      metrics.completion_reasoning_tokens = usageMetadata.thoughtsTokenCount;
+    }
+  }
+  if (text) {
+    output.text = text;
+  }
+  return { output, metrics };
+}
+function tryToDict2(obj) {
+  if (obj === null || obj === void 0) {
+    return null;
+  }
+  if (typeof obj === "object") {
+    if (typeof obj.toJSON === "function") {
+      return obj.toJSON();
+    }
+    return obj;
+  }
+  return null;
+}
+
+// src/instrumentation/braintrust-plugin.ts
+var BraintrustPlugin = class extends BasePlugin {
+  config;
+  openaiPlugin = null;
+  anthropicPlugin = null;
+  aiSDKPlugin = null;
+  claudeAgentSDKPlugin = null;
+  googleGenAIPlugin = null;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  onEnable() {
+    const integrations = this.config.integrations || {};
+    if (integrations.openai !== false) {
+      this.openaiPlugin = new OpenAIPlugin();
+      this.openaiPlugin.enable();
+    }
+    if (integrations.anthropic !== false) {
+      this.anthropicPlugin = new AnthropicPlugin();
+      this.anthropicPlugin.enable();
+    }
+    if (integrations.aisdk !== false && integrations.vercel !== false) {
+      this.aiSDKPlugin = new AISDKPlugin();
+      this.aiSDKPlugin.enable();
+    }
+    if (integrations.claudeAgentSDK !== false) {
+      this.claudeAgentSDKPlugin = new ClaudeAgentSDKPlugin();
+      this.claudeAgentSDKPlugin.enable();
+    }
+    if (integrations.googleGenAI !== false && integrations.google !== false) {
+      this.googleGenAIPlugin = new GoogleGenAIPlugin();
+      this.googleGenAIPlugin.enable();
+    }
+  }
+  onDisable() {
+    if (this.openaiPlugin) {
+      this.openaiPlugin.disable();
+      this.openaiPlugin = null;
+    }
+    if (this.anthropicPlugin) {
+      this.anthropicPlugin.disable();
+      this.anthropicPlugin = null;
+    }
+    if (this.aiSDKPlugin) {
+      this.aiSDKPlugin.disable();
+      this.aiSDKPlugin = null;
+    }
+    if (this.claudeAgentSDKPlugin) {
+      this.claudeAgentSDKPlugin.disable();
+      this.claudeAgentSDKPlugin = null;
+    }
+    if (this.googleGenAIPlugin) {
+      this.googleGenAIPlugin.disable();
+      this.googleGenAIPlugin = null;
+    }
+  }
+};
+
+// src/instrumentation/registry.ts
+var PluginRegistry = class {
+  braintrustPlugin = null;
+  config = {};
+  enabled = false;
+  /**
+   * Configure which integrations should be enabled.
+   * This must be called before any SDK imports to take effect.
+   */
+  configure(config) {
+    if (this.enabled) {
+      console.warn(
+        "Braintrust: Cannot configure instrumentation after it has been enabled. Call configureInstrumentation() before importing any AI SDKs."
+      );
+      return;
+    }
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Enable all configured plugins.
+   * Called automatically when the library is loaded.
+   */
+  enable() {
+    if (this.enabled) {
+      return;
+    }
+    this.enabled = true;
+    const envConfig = this.readEnvConfig();
+    const finalConfig = {
+      integrations: {
+        ...this.getDefaultConfig(),
+        ...this.config.integrations,
+        ...envConfig.integrations
+      }
+    };
+    this.braintrustPlugin = new BraintrustPlugin(finalConfig);
+    this.braintrustPlugin.enable();
+  }
+  /**
+   * Disable all plugins.
+   * Primarily used for testing.
+   */
+  disable() {
+    if (!this.enabled) {
+      return;
+    }
+    this.enabled = false;
+    if (this.braintrustPlugin) {
+      this.braintrustPlugin.disable();
+      this.braintrustPlugin = null;
+    }
+  }
+  /**
+   * Check if instrumentation is enabled.
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Get default configuration (all integrations enabled).
+   */
+  getDefaultConfig() {
+    return {
+      openai: true,
+      anthropic: true,
+      vercel: true,
+      aisdk: true,
+      google: true,
+      claudeAgentSDK: true
+    };
+  }
+  /**
+   * Read configuration from environment variables.
+   * Supports: BRAINTRUST_DISABLE_INSTRUMENTATION=openai,anthropic,...
+   */
+  readEnvConfig() {
+    const integrations = {};
+    const disabledList = isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION");
+    if (disabledList) {
+      const disabled = disabledList.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
+      for (const sdk of disabled) {
+        integrations[sdk] = false;
+      }
+    }
+    return { integrations };
+  }
+};
+var registry = new PluginRegistry();
+function configureInstrumentation(config) {
+  registry.configure(config);
+}
+
 // src/workerd/index.ts
 configureWorkerd();
 export {
@@ -16762,6 +19808,7 @@ export {
   addAzureBlobHeaders,
   braintrustStreamChunkSchema,
   buildLocalSummary,
+  configureInstrumentation,
   constructLogs3OverflowRequest,
   createFinalValuePassThroughStream,
   currentExperiment,
@@ -16838,5 +19885,6 @@ export {
   wrapMastraAgent,
   wrapOpenAI,
   wrapOpenAIv4,
-  wrapTraced
+  wrapTraced,
+  wrapVitest
 };