braintrust 3.25.0 → 3.27.0

package/dist/index.mjs

@@ -63,6 +63,7 @@ import {
   braintrustFlueObserver,
   braintrustStreamChunkSchema,
   buildBedrockRuntimeSpanInfo,
+  collectAnthropicSession,
   configureInstrumentation,
   configureNode,
   constructLogs3OverflowRequest,
@@ -91,6 +92,7 @@ import {
   initExperiment,
   initLogger,
   injectTraceContext,
+  instrumentCloudflareAIChatAgent,
   isEmpty,
   isObject,
   isTemplateFormat,
@@ -139,7 +141,7 @@ import {
   wrapMastraAgent,
   wrapTraced,
   zodToJsonSchema
-} from "./chunk-2SANLSWX.mjs";
+} from "./chunk-YKD22IMR.mjs";
 import {
   INSTRUMENTATION_NAMES,
   __export,
@@ -147,6 +149,8 @@ import {
   anthropicChannels,
   bedrockRuntimeChannels,
   claudeAgentSDKChannels,
+  cloudflareAgentsChannels,
+  cloudflareThinkChannels,
   cohereChannels,
   cursorSDKChannels,
   genkitChannels,
@@ -156,9 +160,12 @@ import {
   groqChannels,
   harnessAgentChannels,
   huggingFaceChannels,
+  huggingFaceTransformersChannels,
+  isSupportedHuggingFaceTransformersTask,
   isomorph_default,
   langSmithChannels,
   mistralChannels,
+  ollamaChannels,
   openAIChannels,
   openAICodexChannels,
   openRouterAgentChannels,
@@ -166,7 +173,7 @@ import {
   piCodingAgentChannels,
   strandsAgentSDKChannels,
   withSpanInstrumentationName
-} from "./chunk-ABR2QWDP.mjs";
+} from "./chunk-CZM5JIQL.mjs";
 
 // src/exports.ts
 var exports_exports = {};
@@ -240,6 +247,7 @@ __export(exports_exports, {
   braintrustFlueObserver: () => braintrustFlueObserver,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
+  collectAnthropicSession: () => collectAnthropicSession,
   configureInstrumentation: () => configureInstrumentation,
   constructLogs3OverflowRequest: () => constructLogs3OverflowRequest,
   createFinalValuePassThroughStream: () => createFinalValuePassThroughStream,
@@ -317,6 +325,9 @@ __export(exports_exports, {
   wrapAnthropic: () => wrapAnthropic,
   wrapBedrockRuntime: () => wrapBedrockRuntime,
   wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
+  wrapCloudflareAIChat: () => wrapCloudflareAIChat,
+  wrapCloudflareAgent: () => wrapCloudflareAgent,
+  wrapCloudflareThink: () => wrapCloudflareThink,
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
@@ -325,11 +336,13 @@ __export(exports_exports, {
   wrapGoogleGenAI: () => wrapGoogleGenAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
+  wrapHuggingFaceTransformers: () => wrapHuggingFaceTransformers,
   wrapLangSmithClient: () => wrapLangSmithClient,
   wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
   wrapLangSmithTraceable: () => wrapLangSmithTraceable,
   wrapMastraAgent: () => wrapMastraAgent,
   wrapMistral: () => wrapMistral,
+  wrapOllama: () => wrapOllama,
   wrapOpenAI: () => wrapOpenAI,
   wrapOpenAICodexSDK: () => wrapOpenAICodexSDK,
   wrapOpenAIv4: () => wrapOpenAIv4,
@@ -3534,6 +3547,66 @@ function betaProxy(beta, anthropic) {
       if (prop === "messages") {
         return betaMessagesProxy(target.messages, anthropic);
       }
+      if (prop === "sessions") {
+        return target.sessions ? betaSessionsProxy(target.sessions) : target.sessions;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function betaSessionsProxy(sessions) {
+  return new Proxy(sessions, {
+    get(target, prop, receiver) {
+      if (prop === "events") {
+        return betaSessionEventsProxy(target.events);
+      }
+      if (prop === "threads") {
+        return target.threads ? betaSessionThreadsProxy(target.threads) : target.threads;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function betaSessionEventsProxy(events) {
+  return new Proxy(events, {
+    get(target, prop, receiver) {
+      if (prop === "stream") {
+        return new TypedApplyProxy(target.stream, {
+          apply(stream, thisArg, argArray) {
+            return anthropicChannels.betaSessionsEventsStream.tracePromise(
+              () => Reflect.apply(stream, thisArg, argArray),
+              { arguments: argArray }
+            );
+          }
+        });
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function betaSessionThreadsProxy(threads) {
+  return new Proxy(threads, {
+    get(target, prop, receiver) {
+      if (prop === "events") {
+        return betaSessionThreadEventsProxy(target.events);
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function betaSessionThreadEventsProxy(events) {
+  return new Proxy(events, {
+    get(target, prop, receiver) {
+      if (prop === "stream") {
+        return new TypedApplyProxy(target.stream, {
+          apply(stream, thisArg, argArray) {
+            return anthropicChannels.betaSessionsThreadsEventsStream.tracePromise(
+              () => Reflect.apply(stream, thisArg, argArray),
+              { arguments: argArray }
+            );
+          }
+        });
+      }
       return Reflect.get(target, prop, receiver);
     }
   });
@@ -3727,6 +3800,52 @@ function claudeAgentSDKProxy(sdk) {
   });
 }
 
+// src/wrappers/cloudflare-think.ts
+var WRAPPED_THINK = /* @__PURE__ */ Symbol.for("braintrust.cloudflare-think.wrapped");
+function wrapCloudflareThink(sdk) {
+  if (!sdk || typeof sdk !== "object") {
+    return sdk;
+  }
+  const thinkModule = sdk;
+  if (typeof thinkModule.Think !== "function") {
+    return sdk;
+  }
+  patchThinkClass(thinkModule.Think);
+  return sdk;
+}
+function patchThinkClass(Think) {
+  const prototype = Think.prototype;
+  if (!prototype || prototype[WRAPPED_THINK]) {
+    return;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(
+    prototype,
+    "_runInferenceLoop"
+  );
+  if (!descriptor || typeof descriptor.value !== "function") {
+    return;
+  }
+  const original = descriptor.value;
+  Object.defineProperty(prototype, "_runInferenceLoop", {
+    ...descriptor,
+    value: function wrappedCloudflareThinkRunInferenceLoop(input) {
+      const args = [input];
+      return cloudflareThinkChannels.runInferenceLoop.tracePromise(
+        () => Reflect.apply(original, this, args),
+        {
+          arguments: args,
+          self: this
+        }
+      );
+    }
+  });
+  Object.defineProperty(prototype, WRAPPED_THINK, {
+    configurable: false,
+    enumerable: false,
+    value: true
+  });
+}
+
 // src/wrappers/openai-codex.ts
 var WRAPPED_CLIENT = /* @__PURE__ */ Symbol.for("braintrust.openai-codex.wrapped-client");
 var WRAPPED_THREAD = /* @__PURE__ */ Symbol.for("braintrust.openai-codex.wrapped-thread");
@@ -4019,14 +4138,9 @@ function patchAgentSessionClass(AgentSession) {
     ...descriptor,
     value: function wrappedPiCodingAgentPrompt(text, options) {
       const args = [text, options];
-      return piCodingAgentChannels.prompt.tracePromise(
-        () => Reflect.apply(originalPrompt, this, args),
-        {
-          arguments: args,
-          self: this,
-          session: this
-        }
-      );
+      return piCodingAgentChannels.prompt.invoke(originalPrompt, this, args, {
+        session: this
+      });
     }
   });
   Object.defineProperty(prototype, WRAPPED_PROMPT, {
@@ -4036,6 +4150,67 @@ function patchAgentSessionClass(AgentSession) {
   });
 }
 
+// src/wrappers/cloudflare-agent.ts
+var WRAPPED_RUN_AGENT_TOOL = /* @__PURE__ */ Symbol.for(
+  "braintrust.cloudflare-agents.wrapped-run-agent-tool"
+);
+function wrapCloudflareAgent(Agent) {
+  if (typeof Agent !== "function") {
+    warnUnsupportedAgent();
+    return Agent;
+  }
+  const prototypeDescriptor = Object.getOwnPropertyDescriptor(
+    Agent,
+    "prototype"
+  );
+  const prototype = prototypeDescriptor && "value" in prototypeDescriptor ? prototypeDescriptor.value : void 0;
+  if (!isObjectLike(prototype)) {
+    warnUnsupportedAgent();
+    return Agent;
+  }
+  if (ownValue(prototype, WRAPPED_RUN_AGENT_TOOL) === true) {
+    return Agent;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(prototype, "runAgentTool");
+  if (!descriptor || typeof descriptor.value !== "function") {
+    warnUnsupportedAgent();
+    return Agent;
+  }
+  const originalRunAgentTool = descriptor.value;
+  Object.defineProperty(prototype, "runAgentTool", {
+    ...descriptor,
+    value: function wrappedRunAgentTool(...args) {
+      const options = args[1];
+      if (ownValue(options, "detached")) {
+        return Reflect.apply(originalRunAgentTool, this, args);
+      }
+      return cloudflareAgentsChannels.runAgentTool.tracePromise(
+        () => Reflect.apply(originalRunAgentTool, this, args),
+        { arguments: args, self: this }
+      );
+    }
+  });
+  Object.defineProperty(prototype, WRAPPED_RUN_AGENT_TOOL, {
+    configurable: false,
+    enumerable: false,
+    value: true
+  });
+  return Agent;
+}
+function ownValue(value, key) {
+  if (!isObjectLike(value)) {
+    return void 0;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function warnUnsupportedAgent() {
+  debugLogger.warn("Unsupported Cloudflare Agents Agent class. Not wrapping.");
+}
+
 // src/wrappers/strands-agent-sdk.ts
 var WRAPPED_CLASS = /* @__PURE__ */ Symbol.for("braintrust.strands-agent-sdk.wrapped-class");
 var WRAPPED_INSTANCE = /* @__PURE__ */ Symbol.for(
@@ -4204,6 +4379,81 @@ async function consumeAsyncGenerator(generator) {
   return result.value;
 }
 
+// src/wrappers/cloudflare-ai-chat.ts
+var wrappedClasses = /* @__PURE__ */ new WeakMap();
+function wrapCloudflareAIChat(module) {
+  if (!module || typeof module !== "object") {
+    return module;
+  }
+  const candidate = module;
+  let AIChatAgent;
+  try {
+    AIChatAgent = Reflect.get(candidate, "AIChatAgent");
+  } catch (error) {
+    debugLogger.debug("Failed to inspect @cloudflare/ai-chat module:", error);
+    return module;
+  }
+  if (typeof AIChatAgent !== "function") {
+    debugLogger.warn(
+      "Unsupported @cloudflare/ai-chat module. AIChatAgent was not found; not wrapping."
+    );
+    return module;
+  }
+  const target = isModuleNamespace5(module) ? Object.setPrototypeOf({}, module) : candidate;
+  return new Proxy(target, {
+    get(target2, property, receiver) {
+      const value = Reflect.get(target2, property, receiver);
+      if (property === "AIChatAgent" && typeof value === "function") {
+        return wrapAIChatAgentClass(
+          value
+        );
+      }
+      return value;
+    }
+  });
+}
+function wrapAIChatAgentClass(AgentClass) {
+  const cached = wrappedClasses.get(AgentClass);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(AgentClass, {
+    get(target, property) {
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    construct(target, args, newTarget) {
+      const instance = Reflect.construct(
+        target,
+        args,
+        newTarget
+      );
+      return instrumentCloudflareAIChatAgent(instance);
+    }
+  });
+  wrappedClasses.set(AgentClass, wrapped);
+  wrappedClasses.set(wrapped, wrapped);
+  return wrapped;
+}
+function isModuleNamespace5(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  try {
+    if (Reflect.get(value, Symbol.toStringTag) === "Module") {
+      return true;
+    }
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+      return false;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, keys[0]);
+    return descriptor ? !descriptor.configurable && !descriptor.writable : false;
+  } catch {
+    return false;
+  }
+}
+
 // src/wrappers/google-genai.ts
 function wrapGoogleGenAI(googleGenAI) {
   if (!googleGenAI || typeof googleGenAI !== "object") {
@@ -4856,6 +5106,120 @@ function wrapFeatureExtraction(original, endpointUrl) {
   };
 }
 
+// src/wrappers/huggingface-transformers.ts
+var PIPELINE_CONSTRUCTOR_KEYS = /* @__PURE__ */ new Set([
+  "TextGenerationPipeline",
+  "Text2TextGenerationPipeline",
+  "SummarizationPipeline",
+  "FeatureExtractionPipeline",
+  "QuestionAnsweringPipeline"
+]);
+var wrappedValues = /* @__PURE__ */ new WeakMap();
+function wrapHuggingFaceTransformers(transformers) {
+  const pipelineTask = transformers?.task;
+  if (typeof transformers === "function" && isSupportedHuggingFaceTransformersTask(pipelineTask)) {
+    return wrapPipeline(transformers);
+  }
+  if (!isSupportedModule(transformers)) {
+    return transformers;
+  }
+  const existing = wrappedValues.get(transformers);
+  if (existing) {
+    return existing;
+  }
+  const proxy = new Proxy(Object.create(transformers), {
+    get(_target, property, receiver) {
+      const value = Reflect.get(transformers, property, receiver);
+      if (property === "pipeline" && typeof value === "function") {
+        return wrapPipelineFactory(value);
+      }
+      if (typeof property === "string" && PIPELINE_CONSTRUCTOR_KEYS.has(property) && typeof value === "function") {
+        return wrapPipelineConstructor(
+          value
+        );
+      }
+      return value;
+    }
+  });
+  wrappedValues.set(transformers, proxy);
+  wrappedValues.set(proxy, proxy);
+  return proxy;
+}
+function isSupportedModule(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  if (typeof Reflect.get(value, "pipeline") === "function") {
+    return true;
+  }
+  for (const key of PIPELINE_CONSTRUCTOR_KEYS) {
+    if (typeof Reflect.get(value, key) === "function") {
+      return true;
+    }
+  }
+  return false;
+}
+function wrapPipelineFactory(factory) {
+  const existing = wrappedValues.get(factory);
+  if (existing) {
+    return existing;
+  }
+  const wrapped = function(...args) {
+    const [task] = args;
+    const context = {
+      arguments: args
+    };
+    return huggingFaceTransformersChannels.pipeline.tracePromise(() => Reflect.apply(factory, this, args), context).then((pipeline) => {
+      if (isSupportedHuggingFaceTransformersTask(pipeline.task ?? task)) {
+        return wrapPipeline(pipeline);
+      }
+      return pipeline;
+    });
+  };
+  wrappedValues.set(factory, wrapped);
+  wrappedValues.set(wrapped, wrapped);
+  return wrapped;
+}
+function wrapPipelineConstructor(constructor) {
+  const existing = wrappedValues.get(constructor);
+  if (existing) {
+    return existing;
+  }
+  const proxy = new Proxy(constructor, {
+    construct(target, args, newTarget) {
+      const pipeline = Reflect.construct(target, args, newTarget);
+      if (isSupportedHuggingFaceTransformersTask(pipeline.task)) {
+        return wrapPipeline(pipeline);
+      }
+      return pipeline;
+    }
+  });
+  wrappedValues.set(constructor, proxy);
+  wrappedValues.set(proxy, proxy);
+  return proxy;
+}
+function wrapPipeline(pipeline) {
+  const existing = wrappedValues.get(pipeline);
+  if (existing) {
+    return existing;
+  }
+  const proxy = new Proxy(pipeline, {
+    apply(target, thisArg, args) {
+      const context = {
+        arguments: args,
+        self: target
+      };
+      return huggingFaceTransformersChannels.pipelineCall.tracePromise(
+        () => Reflect.apply(target, thisArg, args),
+        context
+      );
+    }
+  });
+  wrappedValues.set(pipeline, proxy);
+  wrappedValues.set(proxy, proxy);
+  return proxy;
+}
+
 // src/wrappers/openrouter-agent.ts
 function wrapOpenRouterAgent(agent) {
   const candidate = agent;
@@ -5216,6 +5580,83 @@ function wrapAgentsStream(stream) {
   });
 }
 
+// src/wrappers/ollama.ts
+function wrapOllama(ollama) {
+  if (isSupportedOllamaClient(ollama)) {
+    return ollamaProxy(ollama);
+  }
+  debugLogger.warn("Unsupported Ollama library. Not wrapping.");
+  return ollama;
+}
+var ollamaProxyCache = /* @__PURE__ */ new WeakMap();
+function isSupportedOllamaClient(value) {
+  return isObject(value) && ["chat", "generate", "embed"].some(
+    (name) => typeof value[name] === "function"
+  );
+}
+function ollamaProxy(ollama) {
+  const cached = ollamaProxyCache.get(ollama);
+  if (cached) {
+    return cached;
+  }
+  let chatSource;
+  let wrappedChat;
+  let generateSource;
+  let wrappedGenerate;
+  let embedSource;
+  let wrappedEmbed;
+  const proxy = new Proxy(ollama, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "chat": {
+          const source = target.chat;
+          if (source !== chatSource) {
+            chatSource = source;
+            wrappedChat = typeof source === "function" ? wrapChat(source.bind(target)) : source;
+          }
+          return wrappedChat;
+        }
+        case "generate": {
+          const source = target.generate;
+          if (source !== generateSource) {
+            generateSource = source;
+            wrappedGenerate = typeof source === "function" ? wrapGenerate2(source.bind(target)) : source;
+          }
+          return wrappedGenerate;
+        }
+        case "embed": {
+          const source = target.embed;
+          if (source !== embedSource) {
+            embedSource = source;
+            wrappedEmbed = typeof source === "function" ? wrapEmbed3(source.bind(target)) : source;
+          }
+          return wrappedEmbed;
+        }
+        default:
+          return Reflect.get(target, prop, receiver);
+      }
+    }
+  });
+  ollamaProxyCache.set(ollama, proxy);
+  ollamaProxyCache.set(proxy, proxy);
+  return proxy;
+}
+function wrapChat(chat) {
+  return (request) => ollamaChannels.chat.tracePromise(() => chat(request), {
+    arguments: [request]
+  });
+}
+function wrapGenerate2(generate) {
+  return (request) => ollamaChannels.generate.tracePromise(() => generate(request), {
+    arguments: [request]
+  });
+}
+function wrapEmbed3(embed) {
+  return (request) => ollamaChannels.embed.tracePromise(() => embed(request), {
+    arguments: [request]
+  });
+}
+
 // src/wrappers/cohere.ts
 function wrapCohere(cohere) {
   if (isSupportedCohereClient(cohere)) {
@@ -5246,11 +5687,11 @@ function cohereProxy(cohere) {
     get(target, prop, receiver) {
       switch (prop) {
         case "chat":
-          return typeof target.chat === "function" ? wrapChat(target.chat.bind(target)) : target.chat;
+          return typeof target.chat === "function" ? wrapChat2(target.chat.bind(target)) : target.chat;
         case "chatStream":
           return typeof target.chatStream === "function" ? wrapChatStream2(target.chatStream.bind(target)) : target.chatStream;
         case "embed":
-          return typeof target.embed === "function" ? wrapEmbed3(target.embed.bind(target)) : target.embed;
+          return typeof target.embed === "function" ? wrapEmbed4(target.embed.bind(target)) : target.embed;
         case "rerank":
           return typeof target.rerank === "function" ? wrapRerank3(target.rerank.bind(target)) : target.rerank;
         default: {
@@ -5263,7 +5704,7 @@ function cohereProxy(cohere) {
   cohereProxyCache.set(cohere, proxy);
   return proxy;
 }
-function wrapChat(chat) {
+function wrapChat2(chat) {
   return (request, options) => cohereChannels.chat.tracePromise(() => chat(request, options), {
     arguments: [request]
   });
@@ -5273,7 +5714,7 @@ function wrapChatStream2(chatStream) {
     arguments: [request]
   });
 }
-function wrapEmbed3(embed) {
+function wrapEmbed4(embed) {
   return (request, options) => cohereChannels.embed.tracePromise(() => embed(request, options), {
     arguments: [request]
   });
@@ -5572,7 +6013,7 @@ function wrapNamespaceExport(namespace, exportName, marker, wrap2) {
     );
     return namespace;
   }
-  const target = isModuleNamespace5(namespace) ? Object.setPrototypeOf({}, namespace) : candidate;
+  const target = isModuleNamespace6(namespace) ? Object.setPrototypeOf({}, namespace) : candidate;
   const moduleNamespace = target !== candidate;
   let wrappedExport;
   return new Proxy(target, {
@@ -5606,7 +6047,7 @@ function wrapNamespaceExport(namespace, exportName, marker, wrap2) {
     }
   });
 }
-function isModuleNamespace5(value) {
+function isModuleNamespace6(value) {
   if (!value || typeof value !== "object") {
     return false;
   }
@@ -10125,6 +10566,7 @@ export {
   braintrustFlueObserver,
   braintrustStreamChunkSchema,
   buildLocalSummary,
+  collectAnthropicSession,
   configureInstrumentation,
   constructLogs3OverflowRequest,
   createFinalValuePassThroughStream,
@@ -10203,6 +10645,9 @@ export {
   wrapAnthropic,
   wrapBedrockRuntime,
   wrapClaudeAgentSDK,
+  wrapCloudflareAIChat,
+  wrapCloudflareAgent,
+  wrapCloudflareThink,
   wrapCohere,
   wrapCopilotClient,
   wrapCursorSDK,
@@ -10211,11 +10656,13 @@ export {
   wrapGoogleGenAI,
   wrapGroq,
   wrapHuggingFace,
+  wrapHuggingFaceTransformers,
   wrapLangSmithClient,
   wrapLangSmithRunTrees,
   wrapLangSmithTraceable,
   wrapMastraAgent,
   wrapMistral,
+  wrapOllama,
   wrapOpenAI,
   wrapOpenAICodexSDK,
   wrapOpenAIv4,