braintrust 3.5.0 → 3.6.0

package/dist/index.mjs

@@ -8,6 +8,64 @@ var __export = (target, all) => {
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as diagnostics_channel from "node:diagnostics_channel";
 import * as path from "node:path";
+
+// src/auto-instrumentations/patch-tracing-channel.ts
+function patchTracingChannel(tracingChannelFn) {
+  const dummyChannel = tracingChannelFn("__braintrust_probe__");
+  const TracingChannel = dummyChannel?.constructor;
+  if (!TracingChannel?.prototype) {
+    return;
+  }
+  if (!Object.getOwnPropertyDescriptor(TracingChannel.prototype, "hasSubscribers")) {
+    Object.defineProperty(TracingChannel.prototype, "hasSubscribers", {
+      configurable: true,
+      enumerable: false,
+      get() {
+        return Boolean(
+          this.start?.hasSubscribers || this.end?.hasSubscribers || this.asyncStart?.hasSubscribers || this.asyncEnd?.hasSubscribers || this.error?.hasSubscribers
+        );
+      }
+    });
+  }
+  if (TracingChannel.prototype.tracePromise) {
+    TracingChannel.prototype.tracePromise = function(fn, context = {}, thisArg, ...args) {
+      const { start, end, asyncStart, asyncEnd, error } = this;
+      function reject2(err) {
+        context.error = err;
+        error?.publish(context);
+        asyncStart?.publish(context);
+        asyncEnd?.publish(context);
+        return Promise.reject(err);
+      }
+      function resolve(result) {
+        context.result = result;
+        asyncStart?.publish(context);
+        asyncEnd?.publish(context);
+        return result;
+      }
+      return start.runStores(context, () => {
+        try {
+          const result = Reflect.apply(fn, thisArg, args);
+          end?.publish(context);
+          if (result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function") {
+            return result.then(resolve, reject2);
+          }
+          context.result = result;
+          asyncStart?.publish(context);
+          asyncEnd?.publish(context);
+          return result;
+        } catch (err) {
+          context.error = err;
+          error?.publish(context);
+          end?.publish(context);
+          throw err;
+        }
+      });
+    };
+  }
+}
+
+// src/node/config.ts
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as fsSync from "node:fs";
@@ -4510,6 +4568,9 @@ var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
 var LOGS3_OVERFLOW_REFERENCE_TYPE = "logs3_overflow";
 var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
+var RESET_CONTEXT_MANAGER_STATE = Symbol.for(
+  "braintrust.resetContextManagerState"
+);
 var DEFAULT_MAX_REQUEST_SIZE = 6 * 1024 * 1024;
 var parametersRowSchema = z8.object({
   id: z8.string().uuid(),
@@ -4572,13 +4633,18 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
     return `ERROR: Failed to mask field '${fieldName}' - ${errorType}`;
   }
 }
+var BRAINTRUST_CURRENT_SPAN_STORE = Symbol.for(
+  "braintrust.currentSpanStore"
+);
 var ContextManager = class {
 };
 var BraintrustContextManager = class extends ContextManager {
   _currentSpan;
+  [BRAINTRUST_CURRENT_SPAN_STORE];
   constructor() {
     super();
     this._currentSpan = isomorph_default.newAsyncLocalStorage();
+    this[BRAINTRUST_CURRENT_SPAN_STORE] = this._currentSpan;
   }
   getParentSpanIds() {
     const currentSpan2 = this._currentSpan.getStore();
@@ -4785,6 +4851,9 @@ var BraintrustState = class _BraintrustState {
   resetIdGenState() {
     this._idGenerator = null;
   }
+  [RESET_CONTEXT_MANAGER_STATE]() {
+    this._contextManager = null;
+  }
   get idGenerator() {
     if (this._idGenerator === null) {
       this._idGenerator = getIdGenerator();
@@ -7120,11 +7189,7 @@ async function loadPrompt({
   forceLogin,
   state: stateArg
 }) {
-  if (version && environment) {
-    throw new Error(
-      "Cannot specify both 'version' and 'environment' parameters. Please use only one (remove the other)."
-    );
-  }
+  const versionOrEnvironment = version ? { version } : environment ? { environment } : {};
   if (id) {
   } else if (isEmpty2(projectName) && isEmpty2(projectId)) {
     throw new Error("Must specify either projectName or projectId");
@@ -7142,10 +7207,7 @@ async function loadPrompt({
       forceLogin
     });
     if (id) {
-      response = await state.apiConn().get_json(`v1/prompt/${id}`, {
-        ...version && { version },
-        ...environment && { environment }
-      });
+      response = await state.apiConn().get_json(`v1/prompt/${id}`, versionOrEnvironment);
       if (response) {
         response = { objects: [response] };
       }
@@ -7154,12 +7216,11 @@ async function loadPrompt({
         project_name: projectName,
         project_id: projectId,
         slug,
-        version,
-        ...environment && { environment }
+        ...versionOrEnvironment
       });
     }
   } catch (e) {
-    if (environment || version) {
+    if (version || environment) {
       throw new Error(`Prompt not found with specified parameters: ${e}`);
     }
     debugLogger.forState(state).warn("Failed to load prompt, attempting to fall back to cache:", e);
@@ -7237,11 +7298,7 @@ async function loadParameters({
   forceLogin,
   state: stateArg
 }) {
-  if (version && environment) {
-    throw new Error(
-      "Cannot specify both 'version' and 'environment' parameters. Please use only one (remove the other)."
-    );
-  }
+  const versionOrEnvironment = version ? { version } : environment ? { environment } : {};
   if (id) {
   } else if (isEmpty2(projectName) && isEmpty2(projectId)) {
     throw new Error("Must specify either projectName or projectId");
@@ -7260,8 +7317,7 @@ async function loadParameters({
     });
     if (id) {
       response = await state.apiConn().get_json(`v1/function/${id}`, {
-        ...version && { version },
-        ...environment && { environment }
+        ...versionOrEnvironment
       });
       if (response) {
         response = { objects: [response] };
@@ -7271,13 +7327,12 @@ async function loadParameters({
         project_name: projectName,
         project_id: projectId,
         slug,
-        version,
         function_type: "parameters",
-        ...environment && { environment }
+        ...versionOrEnvironment
       });
     }
   } catch (e) {
-    if (environment || version) {
+    if (version || environment) {
       throw new Error(`Parameters not found with specified parameters: ${e}`);
     }
     debugLogger.forState(state).warn("Failed to load parameters, attempting to fall back to cache:", e);
@@ -9527,6 +9582,8 @@ async function simulateLoginForTests() {
 function simulateLogoutForTests() {
   const state = _internalGetGlobalState();
   state.resetLoginInfo();
+  state.resetIdGenState();
+  state[RESET_CONTEXT_MANAGER_STATE]();
   state.appUrl = "https://www.braintrust.dev";
   return state;
 }
@@ -10140,6 +10197,36 @@ function startSpanForEvent(config, event, channelName) {
   }
   return { span, startTime };
 }
+function ensureSpanStateForEvent(states, config, event, channelName) {
+  const key = event;
+  const existing = states.get(key);
+  if (existing) {
+    return existing;
+  }
+  const created = startSpanForEvent(config, event, channelName);
+  states.set(key, created);
+  return created;
+}
+function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelName) {
+  const state = _internalGetGlobalState();
+  const startChannel = tracingChannel2.start;
+  const currentSpanStore = state?.contextManager ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!currentSpanStore || !startChannel) {
+    return void 0;
+  }
+  startChannel.bindStore(
+    currentSpanStore,
+    (event) => ensureSpanStateForEvent(
+      states,
+      config,
+      event,
+      channelName
+    ).span
+  );
+  return () => {
+    startChannel.unbindStore(currentSpanStore);
+  };
+}
 function logErrorAndEnd(states, event) {
   const spanData = states.get(event);
   if (!spanData) {
@@ -10155,15 +10242,19 @@ function traceAsyncChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -10205,6 +10296,7 @@ function traceAsyncChannel(channel2, config) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -10212,15 +10304,19 @@ function traceStreamingChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -10336,6 +10432,7 @@ function traceStreamingChannel(channel2, config) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -10343,15 +10440,19 @@ function traceSyncStreamChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     end: (event) => {
@@ -10440,6 +10541,7 @@ function traceSyncStreamChannel(channel2, config) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -13001,166 +13103,1206 @@ function tryToDict(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;
+// src/instrumentation/plugins/openrouter-channels.ts
+var openRouterChannels = defineChannels("@openrouter/sdk", {
+  chatSend: channel({
+    channelName: "chat.send",
+    kind: "async"
+  }),
+  embeddingsGenerate: channel({
+    channelName: "embeddings.generate",
+    kind: "async"
+  }),
+  betaResponsesSend: channel({
+    channelName: "beta.responses.send",
+    kind: "async"
+  }),
+  callModel: channel({
+    channelName: "callModel",
+    kind: "sync-stream"
+  }),
+  toolExecute: channel({
+    channelName: "tool.execute",
+    kind: "async"
+  })
+});
+
+// src/openrouter-utils.ts
+var TOKEN_NAME_MAP2 = {
+  promptTokens: "prompt_tokens",
+  inputTokens: "prompt_tokens",
+  completionTokens: "completion_tokens",
+  outputTokens: "completion_tokens",
+  totalTokens: "tokens",
+  prompt_tokens: "prompt_tokens",
+  input_tokens: "prompt_tokens",
+  completion_tokens: "completion_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_DETAIL_PREFIX_MAP = {
+  promptTokensDetails: "prompt",
+  inputTokensDetails: "prompt",
+  completionTokensDetails: "completion",
+  outputTokensDetails: "completion",
+  costDetails: "cost",
+  prompt_tokens_details: "prompt",
+  input_tokens_details: "prompt",
+  completion_tokens_details: "completion",
+  output_tokens_details: "completion",
+  cost_details: "cost"
+};
+function camelToSnake(value) {
+  return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+}
+function parseOpenRouterMetricsFromUsage(usage) {
+  if (!isObject(usage)) {
+    return {};
   }
-  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();
+  const metrics = {};
+  for (const [name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      metrics[TOKEN_NAME_MAP2[name] || camelToSnake(name)] = value;
+      continue;
     }
-    if (integrations.aisdk !== false && integrations.vercel !== false) {
-      this.aiSDKPlugin = new AISDKPlugin();
-      this.aiSDKPlugin.enable();
+    if (!isObject(value)) {
+      continue;
     }
-    if (integrations.claudeAgentSDK !== false) {
-      this.claudeAgentSDKPlugin = new ClaudeAgentSDKPlugin();
-      this.claudeAgentSDKPlugin.enable();
+    const prefix = TOKEN_DETAIL_PREFIX_MAP[name];
+    if (!prefix) {
+      continue;
     }
-    if (integrations.googleGenAI !== false && integrations.google !== false) {
-      this.googleGenAIPlugin = new GoogleGenAIPlugin();
-      this.googleGenAIPlugin.enable();
+    for (const [nestedName, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${camelToSnake(nestedName)}`] = nestedValue;
     }
   }
-  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;
-    }
+  return metrics;
+}
+function extractOpenRouterUsageMetadata(usage) {
+  if (!isObject(usage)) {
+    return void 0;
   }
-};
+  const metadata = {};
+  if (typeof usage.isByok === "boolean") {
+    metadata.is_byok = usage.isByok;
+  } else if (typeof usage.is_byok === "boolean") {
+    metadata.is_byok = usage.is_byok;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
 
-// 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 };
+// src/openrouter-logging.ts
+var OMITTED_OPENROUTER_KEYS = /* @__PURE__ */ new Set([
+  "execute",
+  "render",
+  "nextTurnParams",
+  "requireApproval"
+]);
+function parseOpenRouterModelString(model) {
+  if (typeof model !== "string") {
+    return { model };
   }
-  /**
-   * 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
-      }
+  const slashIndex = model.indexOf("/");
+  if (slashIndex > 0 && slashIndex < model.length - 1) {
+    return {
+      provider: model.substring(0, slashIndex),
+      model: model.substring(slashIndex + 1)
     };
-    this.braintrustPlugin = new BraintrustPlugin(finalConfig);
-    this.braintrustPlugin.enable();
   }
-  /**
-   * Disable all plugins.
-   * Primarily used for testing.
-   */
-  disable() {
-    if (!this.enabled) {
-      return;
+  return { model };
+}
+function isZodSchema2(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema2(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
+  }
+}
+function serializeOpenRouterTool(tool) {
+  if (!isObject(tool)) {
+    return tool;
+  }
+  const serialized = {};
+  for (const [key, value] of Object.entries(tool)) {
+    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+      continue;
     }
-    this.enabled = false;
-    if (this.braintrustPlugin) {
-      this.braintrustPlugin.disable();
-      this.braintrustPlugin = null;
+    if (key === "function" && isObject(value)) {
+      serialized.function = sanitizeOpenRouterLoggedValue(value);
+      continue;
     }
+    serialized[key] = sanitizeOpenRouterLoggedValue(value);
   }
-  /**
-   * Check if instrumentation is enabled.
-   */
-  isEnabled() {
-    return this.enabled;
+  return serialized;
+}
+function serializeOpenRouterToolsForLogging(tools) {
+  if (!Array.isArray(tools)) {
+    return void 0;
   }
-  /**
-   * Get default configuration (all integrations enabled).
-   */
-  getDefaultConfig() {
-    return {
-      openai: true,
-      anthropic: true,
-      vercel: true,
-      aisdk: true,
-      google: true,
-      claudeAgentSDK: true
-    };
+  return tools.map((tool) => serializeOpenRouterTool(tool));
+}
+function sanitizeOpenRouterLoggedValue(value) {
+  if (isZodSchema2(value)) {
+    return serializeZodSchema2(value);
   }
-  /**
-   * 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;
-      }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeOpenRouterLoggedValue(entry));
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+      continue;
     }
-    return { integrations };
+    if (key === "tools" && Array.isArray(entry)) {
+      sanitized.tools = serializeOpenRouterToolsForLogging(entry);
+      continue;
+    }
+    sanitized[key] = sanitizeOpenRouterLoggedValue(entry);
   }
-};
-var registry = new PluginRegistry();
-function configureInstrumentation(config) {
-  registry.configure(config);
+  return sanitized;
 }
-
-// src/node/config.ts
-function configureNode() {
-  isomorph_default.buildType = "node";
-  isomorph_default.getRepoInfo = getRepoInfo;
+function buildOpenRouterMetadata(metadata, httpReferer, xTitle) {
+  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+  const metadataRecord = isObject(sanitized) ? sanitized : {};
+  const { model, provider: providerRouting, ...rest } = metadataRecord;
+  const normalizedModel = parseOpenRouterModelString(model);
+  return {
+    ...rest,
+    ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
+    ...providerRouting !== void 0 ? { providerRouting } : {},
+    ...httpReferer !== void 0 ? { httpReferer } : {},
+    ...xTitle !== void 0 ? { xTitle } : {},
+    provider: normalizedModel.provider || "openrouter"
+  };
+}
+function buildOpenRouterEmbeddingMetadata(metadata, httpReferer, xTitle) {
+  const normalized = buildOpenRouterMetadata(metadata, httpReferer, xTitle);
+  return typeof normalized.model === "string" ? {
+    ...normalized,
+    embedding_model: normalized.model
+  } : normalized;
+}
+function extractOpenRouterCallModelInput(request) {
+  return isObject(request) && "input" in request ? sanitizeOpenRouterLoggedValue(request.input) : void 0;
+}
+function extractOpenRouterCallModelMetadata(request) {
+  if (!isObject(request)) {
+    return { provider: "openrouter" };
+  }
+  const { input: _input, ...metadata } = request;
+  return buildOpenRouterMetadata(metadata, void 0, void 0);
+}
+function extractOpenRouterResponseMetadata(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const { output: _output, data: _data, usage, ...metadata } = result;
+  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+  const metadataRecord = isObject(sanitized) ? sanitized : {};
+  const { model, provider, ...rest } = metadataRecord;
+  const normalizedModel = parseOpenRouterModelString(model);
+  const normalizedProvider = (typeof provider === "string" ? provider : void 0) || normalizedModel.provider;
+  const usageMetadata = extractOpenRouterUsageMetadata(usage);
+  const combined = {
+    ...rest,
+    ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
+    ...usageMetadata || {},
+    ...normalizedProvider !== void 0 ? { provider: normalizedProvider } : {}
+  };
+  return Object.keys(combined).length > 0 ? combined : void 0;
+}
+function extractOpenRouterResponseOutput(response, fallbackOutput) {
+  if (isObject(response) && "output" in response && response.output !== void 0) {
+    return sanitizeOpenRouterLoggedValue(response.output);
+  }
+  if (fallbackOutput !== void 0) {
+    return sanitizeOpenRouterLoggedValue(fallbackOutput);
+  }
+  return void 0;
+}
+
+// src/openrouter-tool-wrapping.ts
+var OPENROUTER_WRAPPED_TOOL = Symbol("braintrust.openrouter.wrappedTool");
+var OPENROUTER_WRAPPED_CALL_MODEL_RESULT = Symbol(
+  "braintrust.openrouter.wrappedCallModelResult"
+);
+var OPENROUTER_CALL_MODEL_STREAM_METHODS = [
+  "getFullResponsesStream",
+  "getItemsStream",
+  "getNewMessagesStream",
+  "getReasoningStream",
+  "getTextStream",
+  "getToolCallsStream",
+  "getToolStream"
+];
+var OPENROUTER_CALL_MODEL_CONTEXT_METHODS = [
+  "cancel",
+  "getPendingToolCalls",
+  "getState",
+  "getToolCalls",
+  "requiresApproval"
+];
+function startOpenRouterCallModelSpan(request) {
+  return startSpan({
+    name: "openrouter.callModel",
+    spanAttributes: {
+      type: "llm" /* LLM */
+    },
+    event: {
+      input: extractOpenRouterCallModelInput(request),
+      metadata: extractOpenRouterCallModelMetadata(request)
+    }
+  });
+}
+function patchOpenRouterCallModelRequestTools(request) {
+  if (!Array.isArray(request.tools) || request.tools.length === 0) {
+    return void 0;
+  }
+  const originalTools = request.tools;
+  const wrappedTools = originalTools.map((tool) => wrapOpenRouterTool(tool));
+  const didPatch = wrappedTools.some(
+    (tool, index) => tool !== originalTools[index]
+  );
+  if (!didPatch) {
+    return void 0;
+  }
+  request.tools = wrappedTools;
+  return () => {
+    request.tools = originalTools;
+  };
+}
+function patchOpenRouterCallModelResult(span, result, request) {
+  if (!isObject(result) || isWrappedCallModelResult(result)) {
+    return false;
+  }
+  const resultLike = result;
+  const hasInstrumentableMethod = typeof resultLike.getResponse === "function" || typeof resultLike.getText === "function" || OPENROUTER_CALL_MODEL_STREAM_METHODS.some(
+    (methodName) => typeof resultLike[methodName] === "function"
+  );
+  if (!hasInstrumentableMethod) {
+    return false;
+  }
+  Object.defineProperty(resultLike, OPENROUTER_WRAPPED_CALL_MODEL_RESULT, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  const originalGetResponse = typeof resultLike.getResponse === "function" ? resultLike.getResponse.bind(resultLike) : void 0;
+  const originalGetInitialResponse = typeof resultLike.getInitialResponse === "function" ? resultLike.getInitialResponse.bind(resultLike) : void 0;
+  const originalMakeFollowupRequest = typeof resultLike.makeFollowupRequest === "function" ? resultLike.makeFollowupRequest.bind(resultLike) : void 0;
+  let ended = false;
+  let tracedTurnCount = 0;
+  const endSpanWithResult = async (response, fallbackOutput) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    const finalResponse = getFinalOpenRouterCallModelResponse(
+      resultLike,
+      response
+    );
+    if (finalResponse) {
+      const rounds = getOpenRouterCallModelRounds(resultLike);
+      const metadata = extractOpenRouterCallModelResultMetadata(
+        finalResponse,
+        rounds.length + 1
+      );
+      span.log({
+        output: extractOpenRouterResponseOutput(finalResponse, fallbackOutput),
+        ...metadata ? { metadata } : {},
+        metrics: aggregateOpenRouterCallModelMetrics(rounds, finalResponse)
+      });
+      span.end();
+      return;
+    }
+    if (fallbackOutput !== void 0) {
+      span.log({
+        output: fallbackOutput
+      });
+    }
+    span.end();
+  };
+  const endSpanWithError = (error) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    span.log({
+      error: normalizeError(error).message
+    });
+    span.end();
+  };
+  const finalizeFromResponse = async (fallbackOutput) => {
+    if (!originalGetResponse) {
+      await endSpanWithResult(void 0, fallbackOutput);
+      return;
+    }
+    try {
+      await endSpanWithResult(await originalGetResponse(), fallbackOutput);
+    } catch {
+      await endSpanWithResult(void 0, fallbackOutput);
+    }
+  };
+  if (originalGetResponse) {
+    resultLike.getResponse = async (...args) => {
+      return await withCurrent(span, async () => {
+        try {
+          const response = await originalGetResponse(...args);
+          await endSpanWithResult(response);
+          return response;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  if (typeof resultLike.getText === "function") {
+    const originalGetText = resultLike.getText.bind(resultLike);
+    resultLike.getText = async (...args) => {
+      return await withCurrent(span, async () => {
+        try {
+          const text = await originalGetText(...args);
+          await finalizeFromResponse(text);
+          return text;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_CONTEXT_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = async (...args) => {
+      return await withCurrent(span, async () => {
+        return await originalMethod.apply(resultLike, args);
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_STREAM_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = (...args) => {
+      const stream = withCurrent(
+        span,
+        () => originalMethod.apply(resultLike, args)
+      );
+      if (!isAsyncIterable2(stream)) {
+        return stream;
+      }
+      return wrapAsyncIterableWithSpan({
+        finalize: finalizeFromResponse,
+        iteratorFactory: () => stream[Symbol.asyncIterator](),
+        onError: endSpanWithError,
+        span
+      });
+    };
+  }
+  if (originalGetInitialResponse) {
+    let initialTurnTraced = false;
+    resultLike.getInitialResponse = async (...args) => {
+      if (initialTurnTraced) {
+        return await withCurrent(span, async () => {
+          return await originalGetInitialResponse(...args);
+        });
+      }
+      initialTurnTraced = true;
+      const resolvedRequest = getOpenRouterResolvedRequest(resultLike, request);
+      const childSpan = startOpenRouterCallModelTurnSpan({
+        request: resolvedRequest,
+        step: tracedTurnCount + 1,
+        stepType: tracedTurnCount === 0 ? "initial" : "continue"
+      });
+      return await withCurrent(childSpan, async () => {
+        try {
+          const response = await originalGetInitialResponse(...args);
+          tracedTurnCount++;
+          finishOpenRouterCallModelTurnSpan({
+            response,
+            step: tracedTurnCount,
+            stepType: tracedTurnCount === 1 ? "initial" : "continue",
+            span: childSpan
+          });
+          return response;
+        } catch (error) {
+          childSpan.log({
+            error: normalizeError(error).message
+          });
+          childSpan.end();
+          throw error;
+        }
+      });
+    };
+  }
+  if (originalMakeFollowupRequest) {
+    resultLike.makeFollowupRequest = async (...args) => {
+      const currentResponse = args[0];
+      const toolResults = Array.isArray(args[1]) ? args[1] : [];
+      const resolvedRequest = getOpenRouterResolvedRequest(resultLike, request);
+      const followupRequest = buildOpenRouterFollowupRequest(
+        resolvedRequest,
+        currentResponse,
+        toolResults
+      );
+      const childSpan = startOpenRouterCallModelTurnSpan({
+        request: followupRequest,
+        step: tracedTurnCount + 1,
+        stepType: "continue"
+      });
+      return await withCurrent(childSpan, async () => {
+        try {
+          const response = await originalMakeFollowupRequest(...args);
+          tracedTurnCount++;
+          finishOpenRouterCallModelTurnSpan({
+            response,
+            step: tracedTurnCount,
+            stepType: "continue",
+            span: childSpan
+          });
+          return response;
+        } catch (error) {
+          childSpan.log({
+            error: normalizeError(error).message
+          });
+          childSpan.end();
+          throw error;
+        }
+      });
+    };
+  }
+  return true;
+}
+function wrapOpenRouterTool(tool) {
+  if (isWrappedTool(tool) || !tool.function || typeof tool.function !== "object" || typeof tool.function.execute !== "function") {
+    return tool;
+  }
+  const toolName = tool.function.name || "tool";
+  const originalExecute = tool.function.execute;
+  const wrappedTool = {
+    ...tool,
+    function: {
+      ...tool.function,
+      execute(...args) {
+        return traceToolExecution({
+          args,
+          execute: () => Reflect.apply(originalExecute, this, args),
+          toolCallId: getToolCallId(args[1]),
+          toolName
+        });
+      }
+    }
+  };
+  Object.defineProperty(wrappedTool, OPENROUTER_WRAPPED_TOOL, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return wrappedTool;
+}
+function isWrappedTool(tool) {
+  return Boolean(tool[OPENROUTER_WRAPPED_TOOL]);
+}
+function isWrappedCallModelResult(value) {
+  return Boolean(
+    isObject(value) && value[OPENROUTER_WRAPPED_CALL_MODEL_RESULT]
+  );
+}
+function traceToolExecution(args) {
+  const tracingChannel2 = openRouterChannels.toolExecute.tracingChannel();
+  const input = args.args.length > 0 ? args.args[0] : void 0;
+  const event = {
+    arguments: [input],
+    span_info: {
+      name: args.toolName
+    },
+    toolCallId: args.toolCallId,
+    toolName: args.toolName
+  };
+  tracingChannel2.start.publish(event);
+  try {
+    const result = args.execute();
+    return publishToolResult(tracingChannel2, event, result);
+  } catch (error) {
+    event.error = normalizeError(error);
+    tracingChannel2.error.publish(event);
+    throw error;
+  }
+}
+function publishToolResult(tracingChannel2, event, result) {
+  if (isPromiseLike(result)) {
+    return result.then(
+      (resolved) => {
+        event.result = resolved;
+        tracingChannel2.asyncEnd.publish(event);
+        return resolved;
+      },
+      (error) => {
+        event.error = normalizeError(error);
+        tracingChannel2.error.publish(event);
+        throw error;
+      }
+    );
+  }
+  event.result = result;
+  tracingChannel2.asyncEnd.publish(event);
+  return result;
+}
+function getToolCallId(context) {
+  const toolContext = context;
+  return typeof toolContext?.toolCall?.id === "string" ? toolContext.toolCall.id : void 0;
+}
+function extractOpenRouterCallModelResultMetadata(response, turnCount) {
+  const combined = {
+    ...extractOpenRouterResponseMetadata(response) || {},
+    ...turnCount !== void 0 ? { turn_count: turnCount } : {}
+  };
+  return Object.keys(combined).length > 0 ? combined : void 0;
+}
+function getFinalOpenRouterCallModelResponse(result, response) {
+  if (isObject(response)) {
+    return response;
+  }
+  return isObject(result.finalResponse) ? result.finalResponse : void 0;
+}
+function getOpenRouterCallModelRounds(result) {
+  if (!Array.isArray(result.allToolExecutionRounds)) {
+    return [];
+  }
+  return result.allToolExecutionRounds.filter((round) => isObject(round)).map((round) => ({
+    response: isObject(round.response) ? round.response : void 0,
+    round: typeof round.round === "number" ? round.round : void 0,
+    toolResults: Array.isArray(round.toolResults) ? round.toolResults : []
+  })).filter((round) => round.response !== void 0);
+}
+function aggregateOpenRouterCallModelMetrics(rounds, finalResponse) {
+  const metrics = {};
+  const responses = [
+    ...rounds.map((round) => round.response).filter(isObject),
+    finalResponse
+  ];
+  for (const response of responses) {
+    const responseMetrics = parseOpenRouterMetricsFromUsage(response.usage);
+    for (const [name, value] of Object.entries(responseMetrics)) {
+      metrics[name] = (metrics[name] || 0) + value;
+    }
+  }
+  return metrics;
+}
+function buildNextOpenRouterCallModelInput(currentInput, response, toolResults) {
+  const normalizedInput = Array.isArray(currentInput) ? [...currentInput] : currentInput === void 0 ? [] : [currentInput];
+  const responseOutput = Array.isArray(response.output) ? response.output : response.output === void 0 ? [] : [response.output];
+  return [...normalizedInput, ...responseOutput, ...toolResults].map(
+    (entry) => sanitizeOpenRouterLoggedValue(entry)
+  );
+}
+function startOpenRouterCallModelTurnSpan(args) {
+  const requestRecord = isObject(args.request) ? args.request : void 0;
+  const metadata = requestRecord ? extractOpenRouterCallModelMetadata(requestRecord) : { provider: "openrouter" };
+  if (isObject(metadata) && "tools" in metadata) {
+    delete metadata.tools;
+  }
+  return startSpan({
+    name: "openrouter.beta.responses.send",
+    spanAttributes: {
+      type: "llm" /* LLM */
+    },
+    event: {
+      input: requestRecord ? extractOpenRouterCallModelInput(requestRecord) : void 0,
+      metadata: {
+        ...metadata,
+        step: args.step,
+        step_type: args.stepType
+      }
+    }
+  });
+}
+function finishOpenRouterCallModelTurnSpan(args) {
+  if (!isObject(args.response)) {
+    args.span.end();
+    return;
+  }
+  args.span.log({
+    output: extractOpenRouterResponseOutput(args.response),
+    ...extractOpenRouterResponseMetadata(args.response) ? {
+      metadata: {
+        ...extractOpenRouterResponseMetadata(args.response),
+        ...args.step !== void 0 ? { step: args.step } : {},
+        ...args.stepType ? { step_type: args.stepType } : {}
+      }
+    } : {},
+    metrics: parseOpenRouterMetricsFromUsage(args.response.usage)
+  });
+  args.span.end();
+}
+function getOpenRouterResolvedRequest(result, request) {
+  if (isObject(result.resolvedRequest)) {
+    return result.resolvedRequest;
+  }
+  return request;
+}
+function buildOpenRouterFollowupRequest(request, currentResponse, toolResults) {
+  if (!request) {
+    return void 0;
+  }
+  return {
+    ...request,
+    input: buildNextOpenRouterCallModelInput(
+      extractOpenRouterCallModelInput(request),
+      isObject(currentResponse) ? currentResponse : {},
+      toolResults
+    ),
+    stream: false
+  };
+}
+function wrapAsyncIterableWithSpan(args) {
+  return {
+    [Symbol.asyncIterator]() {
+      const iterator = args.iteratorFactory();
+      return {
+        next(value) {
+          return withCurrent(
+            args.span,
+            () => value === void 0 ? iterator.next() : iterator.next(value)
+          ).then(
+            async (result) => {
+              if (result.done) {
+                await args.finalize();
+              }
+              return result;
+            },
+            (error) => {
+              args.onError(error);
+              throw error;
+            }
+          );
+        },
+        return(value) {
+          if (typeof iterator.return !== "function") {
+            return args.finalize().then(() => ({
+              done: true,
+              value
+            }));
+          }
+          return withCurrent(args.span, () => iterator.return(value)).then(
+            async (result) => {
+              await args.finalize();
+              return result;
+            },
+            (error) => {
+              args.onError(error);
+              throw error;
+            }
+          );
+        },
+        throw(error) {
+          args.onError(error);
+          if (typeof iterator.throw !== "function") {
+            return Promise.reject(error);
+          }
+          return withCurrent(args.span, () => iterator.throw(error));
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  };
+}
+function isAsyncIterable2(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function isPromiseLike(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/instrumentation/plugins/openrouter-plugin.ts
+var OpenRouterPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToOpenRouterChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToOpenRouterChannels() {
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.chatSend, {
+        name: "openrouter.chat.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const chatGenerationParams = isObject(request?.chatGenerationParams) ? request.chatGenerationParams : {};
+          const httpReferer = request?.httpReferer;
+          const xTitle = request?.xTitle;
+          const { messages, ...metadata } = chatGenerationParams;
+          return {
+            input: messages,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => {
+          return isObject(result) ? result.choices : void 0;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(result?.usage);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateOpenRouterChatChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(openRouterChannels.embeddingsGenerate, {
+        name: "openrouter.embeddings.generate",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const requestBody = isObject(request?.requestBody) ? request.requestBody : {};
+          const httpReferer = request?.httpReferer;
+          const xTitle = request?.xTitle;
+          const { input, ...metadata } = requestBody;
+          return {
+            input,
+            metadata: buildOpenRouterEmbeddingMetadata(
+              metadata,
+              httpReferer,
+              xTitle
+            )
+          };
+        },
+        extractOutput: (result) => {
+          if (!isObject(result)) {
+            return void 0;
+          }
+          const embedding = result.data?.[0]?.embedding;
+          return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+        },
+        extractMetadata: (result) => {
+          if (!isObject(result)) {
+            return void 0;
+          }
+          return extractOpenRouterResponseMetadata(result);
+        },
+        extractMetrics: (result) => {
+          return isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {};
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.betaResponsesSend, {
+        name: "openrouter.beta.responses.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const openResponsesRequest = isObject(request?.openResponsesRequest) ? request.openResponsesRequest : {};
+          const httpReferer = request?.httpReferer;
+          const xTitle = request?.xTitle;
+          const { input, ...metadata } = openResponsesRequest;
+          return {
+            input,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => extractOpenRouterResponseOutput(result),
+        extractMetadata: (result) => extractOpenRouterResponseMetadata(result),
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(result?.usage);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateOpenRouterResponseStreamEvents
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openRouterChannels.callModel, {
+        name: "openrouter.callModel",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterCallModelRequestArg(args);
+          return {
+            input: request ? extractOpenRouterCallModelInput(request) : void 0,
+            metadata: request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" }
+          };
+        },
+        patchResult: ({ endEvent, result, span }) => {
+          return patchOpenRouterCallModelResult(
+            span,
+            result,
+            getOpenRouterCallModelRequestArg(endEvent.arguments)
+          );
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.toolExecute, {
+        name: "openrouter.tool",
+        type: "tool" /* TOOL */,
+        extractInput: (args, event) => ({
+          input: args[0],
+          metadata: {
+            provider: "openrouter",
+            tool_name: event.toolName,
+            ...event.toolCallId ? { tool_call_id: event.toolCallId } : {}
+          }
+        }),
+        extractOutput: (result) => result,
+        extractMetrics: () => ({}),
+        aggregateChunks: (chunks) => ({
+          output: chunks.length > 0 ? chunks[chunks.length - 1] : void 0,
+          metrics: {}
+        })
+      })
+    );
+    const callModelChannel = openRouterChannels.callModel.tracingChannel();
+    const callModelHandlers = {
+      start: (event) => {
+        const request = getOpenRouterCallModelRequestArg(event.arguments);
+        if (!request) {
+          return;
+        }
+        patchOpenRouterCallModelRequestTools(request);
+      }
+    };
+    callModelChannel.subscribe(callModelHandlers);
+    this.unsubscribers.push(() => {
+      callModelChannel.unsubscribe(callModelHandlers);
+    });
+  }
+};
+function normalizeArgs(args) {
+  if (Array.isArray(args)) {
+    return args;
+  }
+  if (isArrayLike(args)) {
+    return Array.from(args);
+  }
+  return [args];
+}
+function isArrayLike(value) {
+  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
+}
+function getOpenRouterRequestArg(args) {
+  const normalizedArgs = normalizeArgs(args);
+  const keyedCandidate = normalizedArgs.find(
+    (arg) => isObject(arg) && ("chatGenerationParams" in arg || "requestBody" in arg || "openResponsesRequest" in arg)
+  );
+  if (isObject(keyedCandidate)) {
+    return keyedCandidate;
+  }
+  const firstObjectArg = normalizedArgs.find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function getOpenRouterCallModelRequestArg(args) {
+  const firstObjectArg = normalizeArgs(args).find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function aggregateOpenRouterChatChunks(chunks) {
+  let role;
+  let content = "";
+  let toolCalls;
+  let finishReason;
+  let metrics = {};
+  for (const chunk of chunks) {
+    metrics = {
+      ...metrics,
+      ...parseOpenRouterMetricsFromUsage(chunk?.usage)
+    };
+    const choice = chunk?.choices?.[0];
+    const delta = choice?.delta;
+    if (!delta) {
+      if (choice?.finish_reason !== void 0) {
+        finishReason = choice.finish_reason;
+      }
+      continue;
+    }
+    if (!role && delta.role) {
+      role = delta.role;
+    }
+    if (typeof delta.content === "string") {
+      content += delta.content;
+    }
+    const choiceFinishReason = choice?.finishReason ?? choice?.finish_reason ?? void 0;
+    const deltaFinishReason = delta.finishReason ?? delta.finish_reason ?? void 0;
+    if (choiceFinishReason !== void 0) {
+      finishReason = choiceFinishReason;
+    } else if (deltaFinishReason !== void 0) {
+      finishReason = deltaFinishReason;
+    }
+    const toolCallDeltas = Array.isArray(delta.toolCalls) ? delta.toolCalls : Array.isArray(delta.tool_calls) ? delta.tool_calls : void 0;
+    if (!toolCallDeltas) {
+      continue;
+    }
+    for (const toolDelta of toolCallDeltas) {
+      if (!toolDelta?.function) {
+        continue;
+      }
+      const toolIndex = toolDelta.index ?? 0;
+      const existingToolCall = toolCalls?.[toolIndex];
+      if (!existingToolCall || toolDelta.id && existingToolCall.id !== void 0 && existingToolCall.id !== toolDelta.id) {
+        const nextToolCalls = [...toolCalls || []];
+        nextToolCalls[toolIndex] = {
+          index: toolIndex,
+          id: toolDelta.id,
+          type: toolDelta.type,
+          function: {
+            name: toolDelta.function.name,
+            arguments: toolDelta.function.arguments || ""
+          }
+        };
+        toolCalls = nextToolCalls;
+        continue;
+      }
+      const current = existingToolCall;
+      if (toolDelta.id && !current.id) {
+        current.id = toolDelta.id;
+      }
+      if (toolDelta.type && !current.type) {
+        current.type = toolDelta.type;
+      }
+      if (toolDelta.function.name && !current.function.name) {
+        current.function.name = toolDelta.function.name;
+      }
+      current.function.arguments += toolDelta.function.arguments || "";
+    }
+  }
+  return {
+    output: [
+      {
+        index: 0,
+        message: {
+          role,
+          content: content || void 0,
+          ...toolCalls ? { tool_calls: toolCalls } : {}
+        },
+        logprobs: null,
+        finish_reason: finishReason
+      }
+    ],
+    metrics
+  };
+}
+function aggregateOpenRouterResponseStreamEvents(chunks) {
+  let finalResponse;
+  for (const chunk of chunks) {
+    const response = chunk?.response;
+    if (!response) {
+      continue;
+    }
+    if (chunk.type === "response.completed" || chunk.type === "response.incomplete" || chunk.type === "response.failed") {
+      finalResponse = response;
+    }
+  }
+  if (!finalResponse) {
+    return {
+      output: void 0,
+      metrics: {}
+    };
+  }
+  return {
+    output: extractOpenRouterResponseOutput(finalResponse),
+    metrics: parseOpenRouterMetricsFromUsage(finalResponse.usage),
+    ...extractOpenRouterResponseMetadata(finalResponse) ? { metadata: extractOpenRouterResponseMetadata(finalResponse) } : {}
+  };
+}
+
+// src/instrumentation/braintrust-plugin.ts
+var BraintrustPlugin = class extends BasePlugin {
+  config;
+  openaiPlugin = null;
+  anthropicPlugin = null;
+  aiSDKPlugin = null;
+  claudeAgentSDKPlugin = null;
+  googleGenAIPlugin = null;
+  openRouterPlugin = 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();
+    }
+    if (integrations.openrouter !== false) {
+      this.openRouterPlugin = new OpenRouterPlugin();
+      this.openRouterPlugin.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;
+    }
+    if (this.openRouterPlugin) {
+      this.openRouterPlugin.disable();
+      this.openRouterPlugin = 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,
+      openrouter: true
+    };
+  }
+  /**
+   * Read configuration from environment variables.
+   * Supports: BRAINTRUST_DISABLE_INSTRUMENTATION=openai,anthropic,...
+   */
+  readEnvConfig() {
+    const integrations = {};
+    const disabledList = isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION");
+    if (disabledList) {
+      const disabled = disabledList.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
+      for (const sdk of disabled) {
+        integrations[sdk] = false;
+      }
+    }
+    return { integrations };
+  }
+};
+var registry = new PluginRegistry();
+function configureInstrumentation(config) {
+  registry.configure(config);
+}
+
+// src/node/config.ts
+function configureNode() {
+  isomorph_default.buildType = "node";
+  isomorph_default.getRepoInfo = getRepoInfo;
   isomorph_default.getPastNAncestors = getPastNAncestors;
   isomorph_default.getEnv = (name) => process.env[name];
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new AsyncLocalStorage();
   isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
+  patchTracingChannel(diagnostics_channel.tracingChannel);
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
@@ -13323,6 +14465,7 @@ __export(exports_exports, {
   wrapMastraAgent: () => wrapMastraAgent,
   wrapOpenAI: () => wrapOpenAI,
   wrapOpenAIv4: () => wrapOpenAIv4,
+  wrapOpenRouter: () => wrapOpenRouter,
   wrapTraced: () => wrapTraced,
   wrapVitest: () => wrapVitest
 });
@@ -13653,7 +14796,7 @@ function wrapOpenAIv4(openai) {
       return baseVal;
     }
   });
-  const chatProxy = new Proxy(typedOpenai.chat, {
+  const chatProxy2 = new Proxy(typedOpenai.chat, {
     get(target, name, receiver) {
       if (name === "completions") {
         return completionProxy;
@@ -13663,7 +14806,7 @@ function wrapOpenAIv4(openai) {
   });
   const embeddingProxy = createEndpointProxy(typedOpenai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(typedOpenai.moderations, wrapModerations);
-  let betaProxy2;
+  let betaProxy3;
   if (typedOpenai.beta?.chat?.completions?.stream) {
     const betaChatCompletionProxy = new Proxy(
       typedOpenai?.beta?.chat.completions,
@@ -13687,7 +14830,7 @@ function wrapOpenAIv4(openai) {
         return Reflect.get(target, name, receiver);
       }
     });
-    betaProxy2 = new Proxy(typedOpenai.beta, {
+    betaProxy3 = new Proxy(typedOpenai.beta, {
       get(target, name, receiver) {
         if (name === "chat") {
           return betaChatProxy;
@@ -13700,7 +14843,7 @@ function wrapOpenAIv4(openai) {
     get(target, name, receiver) {
       switch (name) {
         case "chat":
-          return chatProxy;
+          return chatProxy2;
         case "embeddings":
           return embeddingProxy;
         case "moderations":
@@ -13708,8 +14851,8 @@ function wrapOpenAIv4(openai) {
         case "responses":
           return responsesProxy(typedOpenai);
       }
-      if (name === "beta" && betaProxy2) {
-        return betaProxy2;
+      if (name === "beta" && betaProxy3) {
+        return betaProxy3;
       }
       return Reflect.get(target, name, receiver);
     }
@@ -14673,10 +15816,10 @@ function extractGatewayRoutingInfo2(result) {
   }
   return null;
 }
-var isZodSchema2 = (value) => {
+var isZodSchema3 = (value) => {
   return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
 };
-var serializeZodSchema2 = (schema) => {
+var serializeZodSchema3 = (schema) => {
   try {
     return zodToJsonSchema(schema);
   } catch {
@@ -14724,10 +15867,10 @@ var serializeOutputObject = (output, model) => {
       if (typeof responseFormat.then === "function") {
         result.response_format = Promise.resolve(responseFormat).then(
           (resolved) => {
-            if (resolved.schema && isZodSchema2(resolved.schema)) {
+            if (resolved.schema && isZodSchema3(resolved.schema)) {
               return {
                 ...resolved,
-                schema: serializeZodSchema2(resolved.schema)
+                schema: serializeZodSchema3(resolved.schema)
               };
             }
             return resolved;
@@ -14735,10 +15878,10 @@ var serializeOutputObject = (output, model) => {
         );
       } else {
         const syncResponseFormat = responseFormat;
-        if (syncResponseFormat.schema && isZodSchema2(syncResponseFormat.schema)) {
+        if (syncResponseFormat.schema && isZodSchema3(syncResponseFormat.schema)) {
           responseFormat = {
             ...syncResponseFormat,
-            schema: serializeZodSchema2(syncResponseFormat.schema)
+            schema: serializeZodSchema3(syncResponseFormat.schema)
           };
         }
         result.response_format = responseFormat;
@@ -14764,11 +15907,11 @@ var processInputAttachmentsSync = (input) => {
       processed.prompt = processPromptContent(input.prompt);
     }
   }
-  if (input.schema && isZodSchema2(input.schema)) {
-    processed.schema = serializeZodSchema2(input.schema);
+  if (input.schema && isZodSchema3(input.schema)) {
+    processed.schema = serializeZodSchema3(input.schema);
   }
-  if (input.callOptionsSchema && isZodSchema2(input.callOptionsSchema)) {
-    processed.callOptionsSchema = serializeZodSchema2(input.callOptionsSchema);
+  if (input.callOptionsSchema && isZodSchema3(input.callOptionsSchema)) {
+    processed.callOptionsSchema = serializeZodSchema3(input.callOptionsSchema);
   }
   if (input.tools) {
     processed.tools = serializeAISDKToolsForLogging(input.tools);
@@ -14805,11 +15948,11 @@ var processInputAttachments2 = async (input) => {
       processed.prompt = processPromptContent(input.prompt);
     }
   }
-  if (input.schema && isZodSchema2(input.schema)) {
-    processed.schema = serializeZodSchema2(input.schema);
+  if (input.schema && isZodSchema3(input.schema)) {
+    processed.schema = serializeZodSchema3(input.schema);
   }
-  if (input.callOptionsSchema && isZodSchema2(input.callOptionsSchema)) {
-    processed.callOptionsSchema = serializeZodSchema2(input.callOptionsSchema);
+  if (input.callOptionsSchema && isZodSchema3(input.callOptionsSchema)) {
+    processed.callOptionsSchema = serializeZodSchema3(input.callOptionsSchema);
   }
   if (input.tools) {
     processed.tools = serializeAISDKToolsForLogging(input.tools);
@@ -15578,14 +16721,14 @@ function extractModelFromResult(result) {
 function extractModelFromWrapGenerateCallback(model) {
   return model?.modelId;
 }
-function camelToSnake(str) {
+function camelToSnake2(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
 function extractModelParameters(params, excludeKeys) {
   const modelParams = {};
   for (const [key, value] of Object.entries(params)) {
     if (value !== void 0 && !excludeKeys.has(key)) {
-      const snakeKey = camelToSnake(key);
+      const snakeKey = camelToSnake2(key);
       modelParams[snakeKey] = value;
     }
   }
@@ -16445,7 +17588,7 @@ function filterSerializableOptions2(options) {
   }
   return filtered;
 }
-function isAsyncIterable2(value) {
+function isAsyncIterable3(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function wrapClaudeAgentQuery(queryFn, defaultThis) {
@@ -16453,7 +17596,7 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
     apply(target, thisArg, argArray) {
       const params = argArray[0] ?? {};
       const { prompt, options = {} } = params;
-      const promptIsAsyncIterable = isAsyncIterable2(prompt);
+      const promptIsAsyncIterable = isAsyncIterable3(prompt);
       let capturedPromptMessages;
       let promptForQuery = prompt;
       let promptStarted = false;
@@ -17302,6 +18445,111 @@ function tryToDict2(obj) {
   return null;
 }
 
+// src/wrappers/openrouter.ts
+function wrapOpenRouter(openrouter) {
+  const or = openrouter;
+  if (or && typeof or === "object" && ("chat" in or && typeof or.chat === "object" && or.chat && "send" in or.chat && "embeddings" in or && typeof or.embeddings === "object" && or.embeddings && "generate" in or.embeddings || "callModel" in or && typeof or.callModel === "function")) {
+    return openRouterProxy(or);
+  }
+  console.warn("Unsupported OpenRouter library. Not wrapping.");
+  return openrouter;
+}
+function openRouterProxy(openrouter) {
+  return new Proxy(openrouter, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "chat":
+          return target.chat ? chatProxy(target.chat) : target.chat;
+        case "embeddings":
+          return target.embeddings ? embeddingsProxy(target.embeddings) : target.embeddings;
+        case "beta":
+          return target.beta ? betaProxy2(target.beta) : target.beta;
+        case "callModel":
+          return typeof target.callModel === "function" ? wrapCallModel(target.callModel.bind(target)) : target.callModel;
+        default:
+          return Reflect.get(target, prop, receiver);
+      }
+    }
+  });
+}
+function betaProxy2(beta) {
+  return new Proxy(beta, {
+    get(target, prop, receiver) {
+      if (prop === "responses") {
+        return target.responses ? responsesProxy2(target.responses) : void 0;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function chatProxy(chat) {
+  return new Proxy(chat, {
+    get(target, prop, receiver) {
+      if (prop === "send") {
+        return wrapChatSend(target.send.bind(target));
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function embeddingsProxy(embeddings) {
+  return new Proxy(embeddings, {
+    get(target, prop, receiver) {
+      if (prop === "generate") {
+        return wrapEmbeddingsGenerate(target.generate.bind(target));
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function responsesProxy2(responses) {
+  return new Proxy(responses, {
+    get(target, prop, receiver) {
+      if (prop === "send") {
+        return wrapResponsesSend(target.send.bind(target));
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function wrapChatSend(send) {
+  return (request, options) => openRouterChannels.chatSend.tracePromise(() => send(request, options), {
+    arguments: [request]
+  });
+}
+function wrapEmbeddingsGenerate(generate) {
+  return (request, options) => openRouterChannels.embeddingsGenerate.tracePromise(
+    () => generate(request, options),
+    { arguments: [request] }
+  );
+}
+function wrapResponsesSend(send) {
+  return (request, options) => openRouterChannels.betaResponsesSend.tracePromise(
+    () => send(request, options),
+    { arguments: [request] }
+  );
+}
+function wrapCallModel(callModel) {
+  return (request, options) => {
+    const patchedRequest = { ...request };
+    patchOpenRouterCallModelRequestTools(patchedRequest);
+    const span = startOpenRouterCallModelSpan(patchedRequest);
+    try {
+      const result = callModel(patchedRequest, options);
+      if (!patchOpenRouterCallModelResult(span, result, patchedRequest)) {
+        span.end();
+      }
+      return result;
+    } catch (error) {
+      span.log({
+        error: error instanceof Error ? error.message : String(error)
+      });
+      span.end();
+      throw error;
+    }
+  };
+}
+
 // src/wrappers/vitest/context-manager.ts
 var VitestContextManager = class {
   /**
@@ -18272,7 +19520,7 @@ function isAsync(fn) {
 function isAsyncGenerator3(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable3(obj) {
+function isAsyncIterable4(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -18322,7 +19570,7 @@ function _asyncMap(eachfn, arr, iteratee, callback) {
     callback(err, results);
   });
 }
-function isArrayLike(value) {
+function isArrayLike2(value) {
   return value && typeof value.length === "number" && value.length >= 0 && value.length % 1 === 0;
 }
 var breakLoop = {};
@@ -18370,7 +19618,7 @@ function createObjectIterator(obj) {
   };
 }
 function createIterator(coll) {
-  if (isArrayLike(coll)) {
+  if (isArrayLike2(coll)) {
     return createArrayIterator(coll);
   }
   var iterator = getIterator(coll);
@@ -18444,7 +19692,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator3(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable3(obj)) {
+    if (isAsyncIterable4(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -18516,7 +19764,7 @@ function eachOfGeneric(coll, iteratee, callback) {
   return eachOfLimit$1(coll, Infinity, iteratee, callback);
 }
 function eachOf(coll, iteratee, callback) {
-  var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
+  var eachOfImplementation = isArrayLike2(coll) ? eachOfArrayLike : eachOfGeneric;
   return eachOfImplementation(coll, wrapAsync(iteratee), callback);
 }
 var eachOf$1 = awaitify(eachOf, 3);
@@ -19031,7 +20279,7 @@ function filterGeneric(eachfn, coll, iteratee, callback) {
   });
 }
 function _filter(eachfn, coll, iteratee, callback) {
-  var filter2 = isArrayLike(coll) ? filterArray : filterGeneric;
+  var filter2 = isArrayLike2(coll) ? filterArray : filterGeneric;
   return filter2(eachfn, coll, wrapAsync(iteratee), callback);
 }
 function filter(coll, iteratee, callback) {
@@ -19106,7 +20354,7 @@ if (hasNextTick) {
 }
 var nextTick = wrap(_defer);
 var _parallel = awaitify((eachfn, tasks, callback) => {
-  var results = isArrayLike(tasks) ? [] : {};
+  var results = isArrayLike2(tasks) ? [] : {};
   eachfn(tasks, (task, key, taskCb) => {
     wrapAsync(task)((err, ...result) => {
       if (result.length < 2) {
@@ -19711,7 +20959,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable4(value) {
+function isAsyncIterable5(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -19935,7 +21183,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     }
     const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
     const dataIterable = (() => {
-      if (isAsyncIterable4(resolvedDataResult)) {
+      if (isAsyncIterable5(resolvedDataResult)) {
         return resolvedDataResult;
       }
       if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
@@ -21144,6 +22392,7 @@ export {
   wrapMastraAgent,
   wrapOpenAI,
   wrapOpenAIv4,
+  wrapOpenRouter,
   wrapTraced,
   wrapVitest
 };