braintrust 3.10.0 → 3.12.0

package/dist/auto-instrumentations/chunk-73BZUKVI.mjs

@@ -0,0 +1,300 @@
+import {
+  aiSDKConfigs,
+  anthropicConfigs,
+  channel,
+  claudeAgentSDKConfigs,
+  cohereConfigs,
+  cursorSDKConfigs,
+  defineChannels,
+  genkitConfigs,
+  gitHubCopilotConfigs,
+  googleADKConfigs,
+  googleGenAIConfigs,
+  groqConfigs,
+  huggingFaceConfigs,
+  langchainConfigs,
+  mistralConfigs,
+  openAIAgentsCoreConfigs,
+  openAICodexConfigs,
+  openRouterAgentConfigs,
+  openRouterConfigs,
+  openaiConfigs
+} from "./chunk-2DPA74KK.mjs";
+
+// src/auto-instrumentations/bundler/plugin.ts
+import { createUnplugin } from "unplugin";
+import {
+  create
+} from "@apm-js-collab/code-transformer";
+import { extname, join, sep } from "path";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import moduleDetailsFromPath from "module-details-from-path";
+
+// src/instrumentation/config.ts
+var envIntegrationAliases = {
+  openai: "openai",
+  "openai-codex": "openaiCodexSDK",
+  "openai-codex-sdk": "openaiCodexSDK",
+  openaicodexsdk: "openaiCodexSDK",
+  codex: "openaiCodexSDK",
+  "codex-sdk": "openaiCodexSDK",
+  anthropic: "anthropic",
+  aisdk: "aisdk",
+  "ai-sdk": "aisdk",
+  "vercel-ai": "aisdk",
+  vercel: "vercel",
+  claudeagentsdk: "claudeAgentSDK",
+  "claude-agent-sdk": "claudeAgentSDK",
+  cursor: "cursor",
+  "cursor-sdk": "cursorSDK",
+  cursorsdk: "cursorSDK",
+  flue: "flue",
+  "flue-runtime": "flue",
+  "openai-agents": "openAIAgents",
+  openaiagents: "openAIAgents",
+  "openai-agents-core": "openAIAgents",
+  openaiagentscore: "openAIAgents",
+  google: "google",
+  "google-genai": "googleGenAI",
+  googlegenai: "googleGenAI",
+  huggingface: "huggingface",
+  openrouter: "openrouter",
+  openrouteragent: "openrouterAgent",
+  "openrouter-agent": "openrouterAgent",
+  mistral: "mistral",
+  googleadk: "googleADK",
+  "google-adk": "googleADK",
+  cohere: "cohere",
+  groq: "groq",
+  "groq-sdk": "groq",
+  genkit: "genkit",
+  "firebase-genkit": "genkit",
+  githubcopilot: "gitHubCopilot",
+  "github-copilot": "gitHubCopilot",
+  "copilot-sdk": "gitHubCopilot",
+  langchain: "langchain",
+  "langchain-js": "langchain",
+  "@langchain": "langchain",
+  langgraph: "langgraph"
+};
+function readDisabledInstrumentationEnvConfig(disabledList) {
+  const integrations = {};
+  if (disabledList) {
+    for (const value of disabledList.split(",")) {
+      const sdk = value.trim().toLowerCase();
+      if (sdk.length > 0) {
+        integrations[envIntegrationAliases[sdk] ?? sdk] = false;
+      }
+    }
+  }
+  return { integrations };
+}
+function isInstrumentationIntegrationDisabled(integrations, ...names) {
+  return names.some((name) => integrations?.[name] === false);
+}
+
+// src/instrumentation/plugins/flue-channels.ts
+var flueChannels = defineChannels("@flue/runtime", {
+  createContext: channel({
+    channelName: "createFlueContext",
+    kind: "sync-stream"
+  }),
+  openSession: channel({
+    channelName: "Harness.openSession",
+    kind: "async"
+  }),
+  contextEvent: channel({
+    channelName: "context.event",
+    kind: "sync-stream"
+  }),
+  prompt: channel({
+    channelName: "session.prompt",
+    kind: "async"
+  }),
+  skill: channel({
+    channelName: "session.skill",
+    kind: "async"
+  }),
+  task: channel({
+    channelName: "session.task",
+    kind: "async"
+  }),
+  compact: channel({
+    channelName: "session.compact",
+    kind: "async"
+  })
+});
+
+// src/auto-instrumentations/configs/flue.ts
+var flueVersionRange = ">=0.7.0 <0.8.0";
+var flueConfigs = [
+  {
+    channelName: flueChannels.createContext.channelName,
+    module: {
+      name: "@flue/runtime",
+      versionRange: flueVersionRange,
+      filePath: "dist/internal.mjs"
+    },
+    functionQuery: {
+      functionName: "createFlueContext",
+      kind: "Sync"
+    }
+  },
+  {
+    channelName: flueChannels.openSession.channelName,
+    module: {
+      name: "@flue/runtime",
+      versionRange: flueVersionRange,
+      filePath: "dist/internal.mjs"
+    },
+    functionQuery: {
+      className: "Harness",
+      methodName: "openSession",
+      kind: "Async"
+    }
+  }
+];
+
+// src/auto-instrumentations/configs/all.ts
+var defaultInstrumentationConfigGroups = [
+  { integrations: ["openai"], configs: openaiConfigs },
+  {
+    integrations: ["openaiCodexSDK"],
+    configs: openAICodexConfigs
+  },
+  { integrations: ["anthropic"], configs: anthropicConfigs },
+  {
+    integrations: ["aisdk", "vercel"],
+    configs: aiSDKConfigs
+  },
+  {
+    integrations: ["claudeAgentSDK"],
+    configs: claudeAgentSDKConfigs
+  },
+  { integrations: ["cursor", "cursorSDK"], configs: cursorSDKConfigs },
+  { integrations: ["flue"], configs: flueConfigs },
+  {
+    integrations: ["openAIAgents"],
+    configs: openAIAgentsCoreConfigs
+  },
+  {
+    integrations: ["google", "googleGenAI"],
+    configs: googleGenAIConfigs
+  },
+  { integrations: ["huggingface"], configs: huggingFaceConfigs },
+  {
+    integrations: ["langchain", "langgraph"],
+    configs: langchainConfigs
+  },
+  { integrations: ["openrouter"], configs: openRouterConfigs },
+  {
+    integrations: ["openrouterAgent"],
+    configs: openRouterAgentConfigs
+  },
+  { integrations: ["mistral"], configs: mistralConfigs },
+  { integrations: ["googleADK"], configs: googleADKConfigs },
+  { integrations: ["cohere"], configs: cohereConfigs },
+  { integrations: ["groq"], configs: groqConfigs },
+  {
+    integrations: ["genkit"],
+    configs: genkitConfigs
+  },
+  {
+    integrations: ["gitHubCopilot"],
+    configs: gitHubCopilotConfigs
+  }
+];
+function getDefaultInstrumentationConfigs({
+  additionalInstrumentations,
+  disabledIntegrationConfig,
+  disabledIntegrations
+} = {}) {
+  const disabledConfig = disabledIntegrationConfig ?? (disabledIntegrations ? readDisabledInstrumentationEnvConfig(
+    [...disabledIntegrations].join(",")
+  ).integrations : void 0);
+  return [
+    ...defaultInstrumentationConfigGroups.flatMap(
+      ({ configs, integrations }) => isInstrumentationIntegrationDisabled(disabledConfig, ...integrations) ? [] : configs
+    ),
+    ...additionalInstrumentations ?? []
+  ];
+}
+
+// src/auto-instrumentations/bundler/plugin.ts
+function getModuleVersion(basedir) {
+  try {
+    const packageJsonPath = join(basedir, "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (packageJson.version) {
+      return packageJson.version;
+    }
+  } catch (error) {
+  }
+  return void 0;
+}
+var unplugin = createUnplugin(
+  (options = {}) => {
+    const allInstrumentations = getDefaultInstrumentationConfigs({
+      additionalInstrumentations: options.instrumentations
+    });
+    const dcModule = options.browser === false ? void 0 : "dc-browser";
+    const instrumentationMatcher = create(allInstrumentations, dcModule);
+    return {
+      name: "code-transformer",
+      enforce: "pre",
+      transform(code, id) {
+        if (!id) {
+          return null;
+        }
+        const filePath = id.startsWith("file:") ? fileURLToPath(id) : id;
+        const ext = extname(filePath);
+        let isModule = ext === ".mjs" || ext === ".ts" || ext === ".tsx";
+        if (ext === ".js") {
+          isModule = code.includes("export ") || code.includes("import ");
+        }
+        const normalizedForPlatform = filePath.split("/").join(sep);
+        const moduleDetails = moduleDetailsFromPath(normalizedForPlatform);
+        if (!moduleDetails) {
+          return null;
+        }
+        const moduleName = moduleDetails.name;
+        const moduleVersion = getModuleVersion(moduleDetails.basedir);
+        if (!moduleVersion) {
+          console.warn(
+            `No 'package.json' version found for module ${moduleName} at ${moduleDetails.basedir}. Skipping transformation.`
+          );
+          return null;
+        }
+        const normalizedModulePath = moduleDetails.path.replace(/\\/g, "/");
+        const transformer = instrumentationMatcher.getTransformer(
+          moduleName,
+          moduleVersion,
+          normalizedModulePath
+        );
+        if (!transformer) {
+          return null;
+        }
+        try {
+          const moduleType = isModule ? "esm" : "cjs";
+          const result = transformer.transform(code, moduleType);
+          const transformedCode = result.code.replace(
+            /const \{tracingChannel: ([A-Za-z_$][\w$]*)\} = ([A-Za-z_$][\w$]*);/g,
+            "const $1 = $2.tracingChannel;"
+          );
+          return {
+            code: transformedCode,
+            map: result.map
+          };
+        } catch (error) {
+          console.warn(`Code transformation failed for ${id}: ${error}`);
+          return null;
+        }
+      }
+    };
+  }
+);
+
+export {
+  unplugin
+};

package/dist/auto-instrumentations/chunk-AFXRW7I7.mjs

@@ -0,0 +1,18 @@
+import {
+  unplugin
+} from "./chunk-73BZUKVI.mjs";
+
+// src/auto-instrumentations/bundler/webpack.ts
+function braintrustWebpackPlugin(options = {}) {
+  const { useDiagnosticChannelCompatShim = false, ...pluginOptions } = options;
+  return unplugin.webpack({
+    ...pluginOptions,
+    browser: useDiagnosticChannelCompatShim
+  });
+}
+var webpackPlugin = unplugin.webpack;
+
+export {
+  braintrustWebpackPlugin,
+  webpackPlugin
+};

package/dist/auto-instrumentations/{chunk-ITP7RAUY.mjs → chunk-MWZXZQUO.mjs}

@@ -53,7 +53,29 @@ function getPackageName(baseDir) {
   return void 0;
 }
 
+// src/auto-instrumentations/loader/openai-api-promise-patch.ts
+var OPENAI_API_PROMISE_PATCH = `
+;(function __btPatchAPIPromise() {
+  if (typeof APIPromise === "undefined" || APIPromise.prototype.__btParsePatched) return;
+  APIPromise.prototype.__btParsePatched = true;
+  var _origThen = APIPromise.prototype.then;
+  APIPromise.prototype.then = function __btThen(onfulfilled, onrejected) {
+    if (!this.__btParseWrapped && Object.prototype.hasOwnProperty.call(this, "parseResponse")) {
+      this.__btParseWrapped = true;
+      var _origParse = this.parseResponse;
+      var _cached;
+      this.parseResponse = function() {
+        if (!_cached) _cached = _origParse.apply(this, arguments);
+        return _cached;
+      };
+    }
+    return _origThen.call(this, onfulfilled, onrejected);
+  };
+})();
+`;
+
 export {
   getPackageVersion,
-  getPackageName
+  getPackageName,
+  OPENAI_API_PROMISE_PATCH
 };