braintrust 3.11.0 → 3.13.0

package/dist/chunk-75IQCUB2.mjs

@@ -0,0 +1,817 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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 = this.start;
+      const end = this.end;
+      const asyncStart = this.asyncStart;
+      const asyncEnd = this.asyncEnd;
+      const error = this.error;
+      function publishRejected(err) {
+        context.error = err;
+        error?.publish(context);
+        asyncStart?.publish(context);
+        asyncEnd?.publish(context);
+      }
+      function publishResolved(result) {
+        context.result = result;
+        asyncStart?.publish(context);
+        asyncEnd?.publish(context);
+      }
+      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") {
+            if (result.constructor === Promise) {
+              return result.then(
+                (res) => {
+                  publishResolved(res);
+                  return res;
+                },
+                (err) => {
+                  publishRejected(err);
+                  return Promise.reject(err);
+                }
+              );
+            }
+            void result.then(
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              (resolved) => {
+                try {
+                  publishResolved(resolved);
+                } catch {
+                }
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              (err) => {
+                try {
+                  publishRejected(err);
+                } catch {
+                }
+              }
+            );
+            return result;
+          }
+          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/isomorph.ts
+var DefaultAsyncLocalStorage = class {
+  constructor() {
+  }
+  enterWith(_) {
+  }
+  run(_, callback) {
+    return callback();
+  }
+  getStore() {
+    return void 0;
+  }
+};
+var DefaultChannel = class {
+  constructor(name) {
+    this.name = name;
+  }
+  hasSubscribers = false;
+  subscribe(_subscription) {
+  }
+  unsubscribe(_subscription) {
+    return false;
+  }
+  bindStore(_store, _transform) {
+  }
+  unbindStore(_store) {
+    return false;
+  }
+  publish(_message) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runStores(_message, fn, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+};
+var DefaultTracingChannel = class {
+  start;
+  end;
+  asyncStart;
+  asyncEnd;
+  error;
+  constructor(nameOrChannels) {
+    if (typeof nameOrChannels === "string") {
+      this.start = new DefaultChannel(`tracing:${nameOrChannels}:start`);
+      this.end = new DefaultChannel(`tracing:${nameOrChannels}:end`);
+      this.asyncStart = new DefaultChannel(
+        `tracing:${nameOrChannels}:asyncStart`
+      );
+      this.asyncEnd = new DefaultChannel(`tracing:${nameOrChannels}:asyncEnd`);
+      this.error = new DefaultChannel(`tracing:${nameOrChannels}:error`);
+      return;
+    }
+    this.start = nameOrChannels.start ?? new DefaultChannel("tracing:start");
+    this.end = nameOrChannels.end ?? new DefaultChannel("tracing:end");
+    this.asyncStart = nameOrChannels.asyncStart ?? new DefaultChannel("tracing:asyncStart");
+    this.asyncEnd = nameOrChannels.asyncEnd ?? new DefaultChannel("tracing:asyncEnd");
+    this.error = nameOrChannels.error ?? new DefaultChannel("tracing:error");
+  }
+  get hasSubscribers() {
+    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
+  }
+  subscribe(_handlers) {
+  }
+  unsubscribe(_handlers) {
+    return false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  traceSync(fn, _message, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tracePromise(fn, _message, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  traceCallback(fn, _position, _message, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+};
+var iso = {
+  buildType: "unknown",
+  // Will be set by configureBrowser() or configureNode()
+  getRepoInfo: async (_settings) => void 0,
+  getPastNAncestors: async () => [],
+  getEnv: (_name) => void 0,
+  getBraintrustApiKey: async () => void 0,
+  getCallerLocation: () => void 0,
+  newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  newTracingChannel: (nameOrChannels) => new DefaultTracingChannel(nameOrChannels),
+  processOn: (_0, _1) => {
+  },
+  basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
+  // eslint-disable-next-line no-restricted-properties -- preserving intentional console usage.
+  writeln: (text) => console.log(text)
+};
+var isomorph_default = iso;
+
+// src/instrumentation/core/channel-definitions.ts
+function channel(spec) {
+  return spec;
+}
+function defineChannels(pkg, channels) {
+  return Object.fromEntries(
+    Object.entries(channels).map(([key, spec]) => {
+      const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
+      if (spec.kind === "async") {
+        const asyncSpec = spec;
+        const tracingChannel2 = () => isomorph_default.newTracingChannel(
+          fullChannelName
+        );
+        return [
+          key,
+          {
+            ...asyncSpec,
+            tracingChannel: tracingChannel2,
+            tracePromise: (fn, context) => tracingChannel2().tracePromise(
+              fn,
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              context
+            )
+          }
+        ];
+      }
+      const syncSpec = spec;
+      const tracingChannel = () => isomorph_default.newTracingChannel(
+        fullChannelName
+      );
+      return [
+        key,
+        {
+          ...syncSpec,
+          tracingChannel,
+          traceSync: (fn, context) => tracingChannel().traceSync(
+            fn,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            context
+          )
+        }
+      ];
+    })
+  );
+}
+
+// src/instrumentation/plugins/openai-channels.ts
+var openAIChannels = defineChannels("openai", {
+  chatCompletionsCreate: channel({
+    channelName: "chat.completions.create",
+    kind: "async"
+  }),
+  embeddingsCreate: channel({
+    channelName: "embeddings.create",
+    kind: "async"
+  }),
+  betaChatCompletionsParse: channel({
+    channelName: "beta.chat.completions.parse",
+    kind: "async"
+  }),
+  betaChatCompletionsStream: channel({
+    channelName: "beta.chat.completions.stream",
+    kind: "sync-stream"
+  }),
+  moderationsCreate: channel({
+    channelName: "moderations.create",
+    kind: "async"
+  }),
+  responsesCreate: channel({
+    channelName: "responses.create",
+    kind: "async"
+  }),
+  responsesStream: channel({
+    channelName: "responses.stream",
+    kind: "sync-stream"
+  }),
+  responsesParse: channel({
+    channelName: "responses.parse",
+    kind: "async"
+  }),
+  responsesCompact: channel({
+    channelName: "responses.compact",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/openai-codex-channels.ts
+var openAICodexChannels = defineChannels("@openai/codex-sdk", {
+  run: channel({
+    channelName: "Thread.run",
+    kind: "async"
+  }),
+  runStreamed: channel({
+    channelName: "Thread.runStreamed",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/anthropic-channels.ts
+var anthropicChannels = defineChannels("@anthropic-ai/sdk", {
+  messagesCreate: channel({
+    channelName: "messages.create",
+    kind: "async"
+  }),
+  betaMessagesCreate: channel({
+    channelName: "beta.messages.create",
+    kind: "async"
+  }),
+  betaMessagesToolRunner: channel({
+    channelName: "beta.messages.toolRunner",
+    kind: "sync-stream"
+  })
+});
+
+// src/instrumentation/plugins/ai-sdk-channels.ts
+var aiSDKChannels = defineChannels("ai", {
+  generateText: channel({
+    channelName: "generateText",
+    kind: "async"
+  }),
+  streamText: channel({
+    channelName: "streamText",
+    kind: "async"
+  }),
+  streamTextSync: channel({
+    channelName: "streamText.sync",
+    kind: "sync-stream"
+  }),
+  generateObject: channel({
+    channelName: "generateObject",
+    kind: "async"
+  }),
+  streamObject: channel({
+    channelName: "streamObject",
+    kind: "async"
+  }),
+  streamObjectSync: channel({
+    channelName: "streamObject.sync",
+    kind: "sync-stream"
+  }),
+  embed: channel(
+    {
+      channelName: "embed",
+      kind: "async"
+    }
+  ),
+  embedMany: channel({
+    channelName: "embedMany",
+    kind: "async"
+  }),
+  rerank: channel({
+    channelName: "rerank",
+    kind: "async"
+  }),
+  agentGenerate: channel({
+    channelName: "Agent.generate",
+    kind: "async"
+  }),
+  agentStream: channel({
+    channelName: "Agent.stream",
+    kind: "async"
+  }),
+  agentStreamSync: channel({
+    channelName: "Agent.stream.sync",
+    kind: "sync-stream"
+  }),
+  toolLoopAgentGenerate: channel({
+    channelName: "ToolLoopAgent.generate",
+    kind: "async"
+  }),
+  toolLoopAgentStream: channel({
+    channelName: "ToolLoopAgent.stream",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/claude-agent-sdk-channels.ts
+var claudeAgentSDKChannels = defineChannels(
+  "@anthropic-ai/claude-agent-sdk",
+  {
+    query: channel({
+      channelName: "query",
+      kind: "sync-stream"
+    })
+  }
+);
+
+// src/instrumentation/plugins/cursor-sdk-channels.ts
+var cursorSDKChannels = defineChannels("@cursor/sdk", {
+  create: channel({
+    channelName: "Agent.create",
+    kind: "async"
+  }),
+  resume: channel({
+    channelName: "Agent.resume",
+    kind: "async"
+  }),
+  prompt: channel({
+    channelName: "Agent.prompt",
+    kind: "async"
+  }),
+  send: channel({
+    channelName: "agent.send",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/google-genai-channels.ts
+var googleGenAIChannels = defineChannels("@google/genai", {
+  generateContent: channel({
+    channelName: "models.generateContent",
+    kind: "async"
+  }),
+  generateContentStream: channel({
+    channelName: "models.generateContentStream",
+    kind: "async"
+  }),
+  embedContent: channel({
+    channelName: "models.embedContent",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/huggingface-channels.ts
+var huggingFaceChannels = defineChannels("@huggingface/inference", {
+  chatCompletion: channel({
+    channelName: "chatCompletion",
+    kind: "async"
+  }),
+  chatCompletionStream: channel({
+    channelName: "chatCompletionStream",
+    kind: "sync-stream"
+  }),
+  textGeneration: channel({
+    channelName: "textGeneration",
+    kind: "async"
+  }),
+  textGenerationStream: channel({
+    channelName: "textGenerationStream",
+    kind: "sync-stream"
+  }),
+  featureExtraction: channel({
+    channelName: "featureExtraction",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/openrouter-agent-channels.ts
+var openRouterAgentChannels = defineChannels("@openrouter/agent", {
+  callModel: channel({
+    channelName: "callModel",
+    kind: "sync-stream"
+  }),
+  callModelTurn: channel({
+    channelName: "callModel.turn",
+    kind: "async"
+  }),
+  toolExecute: channel({
+    channelName: "tool.execute",
+    kind: "async"
+  })
+});
+
+// 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"
+  }),
+  rerankRerank: channel(
+    {
+      channelName: "rerank.rerank",
+      kind: "async"
+    }
+  ),
+  betaResponsesSend: channel({
+    channelName: "beta.responses.send",
+    kind: "async"
+  }),
+  callModel: channel({
+    channelName: "callModel",
+    kind: "sync-stream"
+  }),
+  callModelTurn: channel({
+    channelName: "callModel.turn",
+    kind: "async"
+  }),
+  toolExecute: channel({
+    channelName: "tool.execute",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/mistral-channels.ts
+var mistralChannels = defineChannels("@mistralai/mistralai", {
+  chatComplete: channel({
+    channelName: "chat.complete",
+    kind: "async"
+  }),
+  chatStream: channel({
+    channelName: "chat.stream",
+    kind: "async"
+  }),
+  embeddingsCreate: channel({
+    channelName: "embeddings.create",
+    kind: "async"
+  }),
+  classifiersModerate: channel({
+    channelName: "classifiers.moderate",
+    kind: "async"
+  }),
+  classifiersModerateChat: channel({
+    channelName: "classifiers.moderateChat",
+    kind: "async"
+  }),
+  classifiersClassify: channel({
+    channelName: "classifiers.classify",
+    kind: "async"
+  }),
+  classifiersClassifyChat: channel({
+    channelName: "classifiers.classifyChat",
+    kind: "async"
+  }),
+  fimComplete: channel({
+    channelName: "fim.complete",
+    kind: "async"
+  }),
+  fimStream: channel({
+    channelName: "fim.stream",
+    kind: "async"
+  }),
+  agentsComplete: channel({
+    channelName: "agents.complete",
+    kind: "async"
+  }),
+  agentsStream: channel({
+    channelName: "agents.stream",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/google-adk-channels.ts
+var googleADKChannels = defineChannels("@google/adk", {
+  runnerRunAsync: channel({
+    channelName: "runner.runAsync",
+    kind: "sync-stream"
+  }),
+  agentRunAsync: channel({
+    channelName: "agent.runAsync",
+    kind: "sync-stream"
+  }),
+  toolRunAsync: channel({
+    channelName: "tool.runAsync",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/cohere-channels.ts
+var cohereChannels = defineChannels("cohere-ai", {
+  chat: channel({
+    channelName: "chat",
+    kind: "async"
+  }),
+  chatStream: channel({
+    channelName: "chatStream",
+    kind: "async"
+  }),
+  embed: channel({
+    channelName: "embed",
+    kind: "async"
+  }),
+  rerank: channel({
+    channelName: "rerank",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/groq-channels.ts
+var groqChannels = defineChannels("groq-sdk", {
+  chatCompletionsCreate: channel({
+    channelName: "chat.completions.create",
+    kind: "async"
+  }),
+  embeddingsCreate: channel(
+    {
+      channelName: "embeddings.create",
+      kind: "async"
+    }
+  )
+});
+
+// src/instrumentation/plugins/genkit-channels.ts
+var genkitChannels = defineChannels("@genkit-ai/ai", {
+  generate: channel({
+    channelName: "generate",
+    kind: "async"
+  }),
+  generateStream: channel({
+    channelName: "generateStream",
+    kind: "sync-stream"
+  }),
+  embed: channel({
+    channelName: "embed",
+    kind: "async"
+  }),
+  embedMany: channel({
+    channelName: "embedMany",
+    kind: "async"
+  }),
+  actionRun: channel({
+    channelName: "action.run",
+    kind: "async"
+  }),
+  actionStream: channel({
+    channelName: "action.stream",
+    kind: "sync-stream"
+  })
+});
+var genkitCoreChannels = defineChannels("@genkit-ai/core", {
+  actionSpan: channel({
+    channelName: "action.span",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/github-copilot-channels.ts
+var gitHubCopilotChannels = defineChannels("@github/copilot-sdk", {
+  createSession: channel({
+    channelName: "client.createSession",
+    kind: "async"
+  }),
+  resumeSession: channel({
+    channelName: "client.resumeSession",
+    kind: "async"
+  }),
+  sendAndWait: channel({
+    channelName: "session.sendAndWait",
+    kind: "async"
+  })
+});
+
+// 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/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 getDefaultInstrumentationIntegrations() {
+  return {
+    openai: true,
+    openaiCodexSDK: true,
+    anthropic: true,
+    vercel: true,
+    aisdk: true,
+    google: true,
+    googleGenAI: true,
+    googleADK: true,
+    huggingface: true,
+    claudeAgentSDK: true,
+    cursor: true,
+    cursorSDK: true,
+    flue: true,
+    openAIAgents: true,
+    openrouter: true,
+    openrouterAgent: true,
+    mistral: true,
+    cohere: true,
+    groq: true,
+    genkit: true,
+    gitHubCopilot: true,
+    langchain: true,
+    langgraph: true
+  };
+}
+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/openai-agents-channels.ts
+var openAIAgentsCoreChannels = defineChannels("@openai/agents-core", {
+  onTraceStart: channel({
+    channelName: "tracing.processor.onTraceStart",
+    kind: "async"
+  }),
+  onTraceEnd: channel({
+    channelName: "tracing.processor.onTraceEnd",
+    kind: "async"
+  }),
+  onSpanStart: channel({
+    channelName: "tracing.processor.onSpanStart",
+    kind: "async"
+  }),
+  onSpanEnd: channel({
+    channelName: "tracing.processor.onSpanEnd",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/langchain-channels.ts
+var langChainChannels = defineChannels("@langchain/core", {
+  configure: channel({
+    channelName: "CallbackManager.configure",
+    kind: "sync-stream"
+  }),
+  configureSync: channel({
+    channelName: "CallbackManager._configureSync",
+    kind: "sync-stream"
+  })
+});
+
+export {
+  __export,
+  patchTracingChannel,
+  isomorph_default,
+  openAIChannels,
+  openAICodexChannels,
+  anthropicChannels,
+  aiSDKChannels,
+  claudeAgentSDKChannels,
+  cursorSDKChannels,
+  openAIAgentsCoreChannels,
+  googleGenAIChannels,
+  huggingFaceChannels,
+  openRouterAgentChannels,
+  openRouterChannels,
+  mistralChannels,
+  googleADKChannels,
+  cohereChannels,
+  groqChannels,
+  genkitChannels,
+  genkitCoreChannels,
+  gitHubCopilotChannels,
+  flueChannels,
+  langChainChannels,
+  getDefaultInstrumentationIntegrations,
+  readDisabledInstrumentationEnvConfig,
+  isInstrumentationIntegrationDisabled
+};