braintrust 3.1.0 → 3.2.0

package/dev/dist/index.mjs

@@ -47,7 +47,7 @@ async function currentRepo() {
     } else {
       return null;
     }
-  } catch (e) {
+  } catch {
     return null;
   }
 }
@@ -103,7 +103,7 @@ async function getBaseBranchAncestor(remote = void 0) {
       `${remoteName}/${baseBranch}`
     ]);
     return ancestor.trim();
-  } catch (e) {
+  } catch {
     return void 0;
   }
 }
@@ -130,7 +130,7 @@ async function getPastNAncestors(n = 1e3, remote = void 0) {
 async function attempt(fn) {
   try {
     return await fn();
-  } catch (e) {
+  } catch {
     return void 0;
   }
 }
@@ -1739,6 +1739,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") }),
@@ -1771,7 +1772,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)
   }),
@@ -1816,7 +1818,8 @@ var FunctionTypeEnum = z6.enum([
   "facet",
   "classifier",
   "tag",
-  "parameters"
+  "parameters",
+  "sandbox"
 ]);
 var NullableSavedFunctionId = z6.union([
   z6.object({
@@ -1831,66 +1834,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"),
@@ -1905,11 +1856,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({
@@ -2088,9 +2041,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({
@@ -2192,7 +2156,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({
@@ -2494,7 +2458,8 @@ var FunctionTypeEnumNullish = z6.union([
     "facet",
     "classifier",
     "tag",
-    "parameters"
+    "parameters",
+    "sandbox"
   ]),
   z6.null()
 ]);
@@ -2727,7 +2692,8 @@ var FunctionObjectType = z6.enum([
   "preprocessor",
   "facet",
   "classifier",
-  "parameters"
+  "parameters",
+  "sandbox"
 ]);
 var FunctionOutputType = z6.enum([
   "completion",
@@ -2863,6 +2829,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(),
@@ -2887,7 +2854,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()
         })
       ),
@@ -2913,6 +2880,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(),
@@ -2969,7 +2955,8 @@ var ProjectAutomation = z6.object({
           message_template: z6.string().optional()
         })
       ])
-    })
+    }),
+    TopicAutomationConfig
   ])
 });
 var ProjectLogsEvent = z6.object({
@@ -3159,6 +3146,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(),
@@ -4838,7 +4827,7 @@ var HTTPConnection = class _HTTPConnection {
     try {
       const resp = await this.get("ping");
       return resp.status === 200;
-    } catch (e) {
+    } catch {
       return false;
     }
   }
@@ -5242,9 +5231,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,
@@ -6811,7 +6800,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");
       }
@@ -7253,7 +7243,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
@@ -8437,12 +8431,2636 @@ 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___";
 
+// src/instrumentation/core/plugin.ts
+import { tracingChannel } from "dc-browser";
+
+// src/instrumentation/core/stream-patcher.ts
+function isAsyncIterable(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function patchStreamIfNeeded(stream, options) {
+  if (!isAsyncIterable(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 (isAsyncIterable(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/wrappers/attachment-utils.ts
+function getExtensionFromMediaType(mediaType) {
+  const extensionMap = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "application/pdf": "pdf",
+    "application/json": "json",
+    "text/plain": "txt",
+    "text/html": "html",
+    "text/csv": "csv"
+  };
+  return extensionMap[mediaType] || "bin";
+}
+function convertDataToBlob(data, mediaType) {
+  try {
+    if (typeof data === "string") {
+      if (data.startsWith("data:")) {
+        const base64Match = data.match(/^data:[^;]+;base64,(.+)$/);
+        if (base64Match) {
+          const base64 = base64Match[1];
+          const binaryString = atob(base64);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          return new Blob([bytes], { type: mediaType });
+        }
+      } else if (data.startsWith("http://") || data.startsWith("https://")) {
+        return null;
+      } else {
+        const binaryString = atob(data);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return new Blob([bytes], { type: mediaType });
+      }
+    } else if (data instanceof Uint8Array) {
+      return new Blob([data], { type: mediaType });
+    } else if (data instanceof ArrayBuffer) {
+      return new Blob([data], { type: mediaType });
+    } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
+      return new Blob([data], { type: mediaType });
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function processInputAttachments(input) {
+  if (!input) {
+    return input;
+  }
+  let attachmentIndex = 0;
+  const processContentPart = (part) => {
+    if (!part || typeof part !== "object") {
+      return part;
+    }
+    if (part.type === "image" && part.image) {
+      let mediaType = "image/png";
+      if (typeof part.image === "string" && part.image.startsWith("data:")) {
+        const mediaTypeMatch = part.image.match(/^data:([^;]+);/);
+        if (mediaTypeMatch) {
+          mediaType = mediaTypeMatch[1];
+        }
+      } else if (part.mediaType) {
+        mediaType = part.mediaType;
+      }
+      const blob = convertDataToBlob(part.image, mediaType);
+      if (blob) {
+        const filename = `input_image_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+        attachmentIndex++;
+        const attachment = new Attachment({
+          data: blob,
+          filename,
+          contentType: mediaType
+        });
+        return {
+          ...part,
+          image: attachment
+        };
+      }
+    }
+    if (part.type === "file" && part.data) {
+      const mediaType = part.mediaType || "application/octet-stream";
+      const blob = convertDataToBlob(part.data, mediaType);
+      if (blob) {
+        const filename = part.filename || `input_file_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+        attachmentIndex++;
+        const attachment = new Attachment({
+          data: blob,
+          filename,
+          contentType: mediaType
+        });
+        return {
+          ...part,
+          data: attachment
+        };
+      }
+    }
+    return part;
+  };
+  const processMessage = (message) => {
+    if (!message || typeof message !== "object") {
+      return message;
+    }
+    if (Array.isArray(message.content)) {
+      return {
+        ...message,
+        content: message.content.map(processContentPart)
+      };
+    }
+    return message;
+  };
+  if (Array.isArray(input)) {
+    return input.map(processMessage);
+  } else if (typeof input === "object" && input.content) {
+    return processMessage(input);
+  }
+  return input;
+}
+
+// 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 = parseMetricsFromUsage(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 parseMetricsFromUsage(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 = parseMetricsFromUsage(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 processImagesInOutput(result?.output);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = parseMetricsFromUsage(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 = processImagesInOutput(response.output);
+          }
+          if (response) {
+            const { usage: _usage, output: _output, ...metadata } = response;
+            if (Object.keys(metadata).length > 0) {
+              data.metadata = metadata;
+            }
+          }
+          data.metrics = parseMetricsFromUsage(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 processImagesInOutput(result?.output);
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = parseMetricsFromUsage(result?.usage);
+        if (startTime) {
+          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+        }
+        return metrics;
+      }
+    });
+  }
+  onDisable() {
+  }
+};
+var TOKEN_NAME_MAP = {
+  input_tokens: "prompt_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_PREFIX_MAP = {
+  input: "prompt",
+  output: "completion"
+};
+function parseMetricsFromUsage(usage) {
+  if (!usage) {
+    return {};
+  }
+  const metrics = {};
+  for (const [oai_name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      const metricName = TOKEN_NAME_MAP[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_MAP[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 processImagesInOutput(output) {
+  if (Array.isArray(output)) {
+    return output.map(processImagesInOutput);
+  }
+  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,
+        ...parseMetricsFromUsage(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";
+
+// src/wrappers/anthropic-tokens-util.ts
+function finalizeAnthropicTokens(metrics) {
+  const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + (metrics.prompt_cache_creation_tokens || 0);
+  return {
+    ...metrics,
+    prompt_tokens,
+    tokens: prompt_tokens + (metrics.completion_tokens || 0)
+  };
+}
+function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens = 0) {
+  const cacheTokens = {};
+  if (cacheReadTokens > 0) {
+    cacheTokens.prompt_cached_tokens = cacheReadTokens;
+  }
+  if (cacheCreationTokens > 0) {
+    cacheTokens.prompt_cache_creation_tokens = cacheCreationTokens;
+  }
+  return cacheTokens;
+}
+
+// src/instrumentation/plugins/anthropic-plugin.ts
+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 = coalesceInput(params.messages || [], params.system);
+        const metadata = filterFrom(params, ["messages", "system"]);
+        return {
+          input: processAttachmentsInInput(input),
+          metadata: { ...metadata, provider: "anthropic" }
+        };
+      },
+      extractOutput: (result) => {
+        return result ? { role: result.role, content: result.content } : null;
+      },
+      extractMetrics: (result, startTime) => {
+        const metrics = parseMetricsFromUsage2(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 = coalesceInput(params.messages || [], params.system);
+          const metadata = filterFrom(params, ["messages", "system"]);
+          return {
+            input: processAttachmentsInInput(input),
+            metadata: { ...metadata, provider: "anthropic" }
+          };
+        },
+        extractOutput: (result) => {
+          return result ? { role: result.role, content: result.content } : null;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseMetricsFromUsage2(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) : isAsyncIterable(event.result);
+        if (isStreaming && isAsyncIterable(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 parseMetricsFromUsage2(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 = parseMetricsFromUsage2(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 = parseMetricsFromUsage2(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 convertBase64ToAttachment(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 processAttachmentsInInput(input) {
+  if (Array.isArray(input)) {
+    return input.map(processAttachmentsInInput);
+  }
+  if (isObject(input)) {
+    if ((input.type === "image" || input.type === "document") && isObject(input.source) && input.source.type === "base64") {
+      return {
+        ...input,
+        source: convertBase64ToAttachment(input.source, input.type)
+      };
+    }
+    const processed = {};
+    for (const [key, value] of Object.entries(input)) {
+      processed[key] = processAttachmentsInInput(value);
+    }
+    return processed;
+  }
+  return input;
+}
+function coalesceInput(messages, system) {
+  const input = (messages || []).slice();
+  if (system) {
+    input.push({ role: "system", content: system });
+  }
+  return input;
+}
+function filterFrom(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 = extractTokenMetrics(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 = extractTokenMetrics(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 = extractTokenMetrics(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 = extractTokenMetrics(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 = extractTokenMetrics(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 = extractTokenMetrics(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 (isAsyncIterable(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 } = serializeModelWithProvider(params.model);
+  if (model) {
+    metadata.model = model;
+  }
+  if (provider) {
+    metadata.provider = provider;
+  }
+  return metadata;
+}
+function processAISDKOutput(output, denyOutputPaths) {
+  if (!output) return output;
+  const getterValues = extractGetterValues(output);
+  const merged = { ...output, ...getterValues };
+  return omit(merged, denyOutputPaths);
+}
+function extractTokenMetrics(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 = firstNumber(
+    usage.inputTokens?.total,
+    usage.inputTokens,
+    usage.promptTokens,
+    usage.prompt_tokens
+  );
+  if (promptTokens !== void 0) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  const completionTokens = firstNumber(
+    usage.outputTokens?.total,
+    usage.outputTokens,
+    usage.completionTokens,
+    usage.completion_tokens
+  );
+  if (completionTokens !== void 0) {
+    metrics.completion_tokens = completionTokens;
+  }
+  const totalTokens = firstNumber(
+    usage.totalTokens,
+    usage.tokens,
+    usage.total_tokens
+  );
+  if (totalTokens !== void 0) {
+    metrics.tokens = totalTokens;
+  }
+  const cost = extractCostFromResult(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 = extractTokenMetrics(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 extractGetterValues(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 serializeModelWithProvider(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 = parseGatewayModelString(modelId);
+  return {
+    model: parsed.model,
+    provider: explicitProvider || parsed.provider
+  };
+}
+function parseGatewayModelString(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 extractCostFromResult(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 = parseGatewayCost(gateway2?.cost) || parseGatewayCost(gateway2?.marketCost);
+      if (stepCost !== void 0 && stepCost > 0) {
+        totalCost += stepCost;
+        foundCost = true;
+      }
+    }
+    if (foundCost) {
+      return totalCost;
+    }
+  }
+  const gateway = result?.providerMetadata?.gateway;
+  const directCost = parseGatewayCost(gateway?.cost) || parseGatewayCost(gateway?.marketCost);
+  if (directCost !== void 0 && directCost > 0) {
+    return directCost;
+  }
+  return void 0;
+}
+function parseGatewayCost(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 firstNumber(...values) {
+  for (const v of values) {
+    if (typeof v === "number") {
+      return v;
+    }
+  }
+  return void 0;
+}
+function deepCopy(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function parsePath(path2) {
+  const keys = [];
+  let current = "";
+  for (let i = 0; i < path2.length; i++) {
+    const char = path2[i];
+    if (char === ".") {
+      if (current) {
+        keys.push(current);
+        current = "";
+      }
+    } else if (char === "[") {
+      if (current) {
+        keys.push(current);
+        current = "";
+      }
+      let bracketContent = "";
+      i++;
+      while (i < path2.length && path2[i] !== "]") {
+        bracketContent += path2[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 omitAtPath(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) {
+          omitAtPath(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) {
+      omitAtPath(obj[firstKey], remainingKeys);
+    }
+  }
+}
+function omit(obj, paths) {
+  const result = deepCopy(obj);
+  for (const path2 of paths) {
+    const keys = parsePath(path2);
+    omitAtPath(result, keys);
+  }
+  return result;
+}
+
+// src/instrumentation/plugins/claude-agent-sdk-plugin.ts
+import { tracingChannel as tracingChannel4 } from "dc-browser";
+function filterSerializableOptions(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 getNumberProperty(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 = getNumberProperty(usage, "input_tokens");
+  if (inputTokens !== void 0) {
+    metrics.prompt_tokens = inputTokens;
+  }
+  const outputTokens = getNumberProperty(usage, "output_tokens");
+  if (outputTokens !== void 0) {
+    metrics.completion_tokens = outputTokens;
+  }
+  const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
+  const cacheCreationTokens = getNumberProperty(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: filterSerializableOptions(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 (isAsyncIterable(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 = getNumberProperty(
+                      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 = serializeInput(params);
+        const metadata = extractMetadata(params);
+        return {
+          input,
+          metadata: { ...metadata, provider: "google-genai" }
+        };
+      },
+      extractOutput: (result) => {
+        return result;
+      },
+      extractMetrics: (result, startTime) => {
+        return extractGenerateContentMetrics(result, startTime);
+      }
+    });
+    this.subscribeToGoogleStreamingChannel(
+      "orchestrion:google-genai:models.generateContentStream",
+      {
+        name: "google-genai.generateContentStream",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const params = args[0] || {};
+          const input = serializeInput(params);
+          const metadata = extractMetadata(params);
+          return {
+            input,
+            metadata: { ...metadata, provider: "google-genai" }
+          };
+        },
+        aggregateChunks: aggregateGenerateContentChunks
+      }
+    );
+  }
+  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 (isAsyncIterable(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 serializeInput(params) {
+  const input = {
+    model: params.model,
+    contents: serializeContents(params.contents)
+  };
+  if (params.config) {
+    const config = tryToDict(params.config);
+    if (config) {
+      const tools = serializeTools(params);
+      if (tools) {
+        config.tools = tools;
+      }
+      input.config = config;
+    }
+  }
+  return input;
+}
+function serializeContents(contents) {
+  if (contents === null || contents === void 0) {
+    return null;
+  }
+  if (Array.isArray(contents)) {
+    return contents.map((item) => serializeContentItem(item));
+  }
+  return serializeContentItem(contents);
+}
+function serializeContentItem(item) {
+  if (typeof item === "object" && item !== null) {
+    if (item.parts && Array.isArray(item.parts)) {
+      return {
+        ...item,
+        parts: item.parts.map((part) => serializePart(part))
+      };
+    }
+    return item;
+  }
+  if (typeof item === "string") {
+    return { text: item };
+  }
+  return item;
+}
+function serializePart(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 serializeTools(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 extractMetadata(params) {
+  const metadata = {};
+  if (params.model) {
+    metadata.model = params.model;
+  }
+  if (params.config) {
+    const config = tryToDict(params.config);
+    if (config) {
+      Object.keys(config).forEach((key) => {
+        if (key !== "tools") {
+          metadata[key] = config[key];
+        }
+      });
+    }
+  }
+  return metadata;
+}
+function extractGenerateContentMetrics(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 aggregateGenerateContentChunks(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 tryToDict(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();
+
 // src/node/config.ts
 function configureNode() {
   isomorph_default.buildType = "node";
@@ -8477,6 +11095,7 @@ function configureNode() {
   isomorph_default.gunzip = promisify(zlib.gunzip);
   isomorph_default.hash = (data) => crypto.createHash("sha256").update(data).digest("hex");
   _internalSetInitialState();
+  registry.enable();
 }
 
 // dev/server.ts
@@ -8554,7 +11173,7 @@ function isAsync(fn) {
 function isAsyncGenerator(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable(obj) {
+function isAsyncIterable2(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -8725,7 +11344,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable(obj)) {
+    if (isAsyncIterable2(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -10035,7 +12654,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable2(value) {
+function isAsyncIterable3(value) {
   return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -10238,7 +12857,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     }
     const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
     const dataIterable = (() => {
-      if (isAsyncIterable2(resolvedDataResult)) {
+      if (isAsyncIterable3(resolvedDataResult)) {
         return resolvedDataResult;
       }
       if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {