@bitfab/sdk 0.23.0 → 0.23.2

package/dist/index.cjs

@@ -479,6 +479,7 @@ __export(index_exports, {
   BitfabLangGraphCallbackHandler: () => BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler: () => BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor: () => BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler: () => BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL: () => DEFAULT_SERVICE_URL,
   ReplayEnvironment: () => ReplayEnvironment,
   SUPPORTED_PROVIDERS: () => SUPPORTED_PROVIDERS,
@@ -491,7 +492,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.generated.ts
-var __version__ = "0.23.0";
+var __version__ = "0.23.2";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -2279,9 +2280,17 @@ var BitfabOpenAIAgentHandler = class {
   constructor(config) {
     this.traceFunctionKey = config.traceFunctionKey;
     this.withSpanFn = config.withSpan;
+    this.getActiveSpanContext = config.getActiveSpanContext;
   }
   async wrapRun(agent, input, options) {
     const { run } = await import("@openai/agents");
+    if (this.getActiveSpanContext?.() != null) {
+      return run(
+        agent,
+        input,
+        options
+      );
+    }
     const isStreaming = options?.stream === true;
     const finalize = async (result) => {
       const res = result;
@@ -2597,6 +2606,135 @@ var BitfabOpenAITracingProcessor = class {
   }
 };
 
+// src/vercelAiSdk.ts
+function modelLabel(model) {
+  if (!model || typeof model !== "object") {
+    return void 0;
+  }
+  const m = model;
+  const provider = typeof m.provider === "string" ? m.provider : void 0;
+  const modelId = typeof m.modelId === "string" ? m.modelId : void 0;
+  if (provider == null && modelId == null) {
+    return void 0;
+  }
+  return { provider, modelId };
+}
+function summarizeGenerate(result, model) {
+  const content = Array.isArray(result.content) ? result.content : [];
+  const text = typeof result.text === "string" ? result.text : content.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+  const toolCalls = content.filter((p) => p.type === "tool-call").map((p) => ({
+    toolCallId: p.toolCallId,
+    toolName: p.toolName,
+    input: p.input ?? p.args
+  }));
+  const summary = {
+    text,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage: result.usage,
+    finishReason: result.finishReason
+  };
+  if (model) {
+    summary.model = model;
+  }
+  return summary;
+}
+function accumulateStream(onComplete, model) {
+  let text = "";
+  const toolCalls = [];
+  let usage;
+  let finishReason;
+  let completed = false;
+  const complete = () => {
+    if (completed) {
+      return;
+    }
+    completed = true;
+    const summary = {
+      text,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage,
+      finishReason
+    };
+    if (model) {
+      summary.model = model;
+    }
+    onComplete(summary);
+  };
+  return new TransformStream({
+    transform(part, controller) {
+      try {
+        if (part?.type === "text-delta") {
+          text += part.delta ?? part.textDelta ?? "";
+        } else if (part?.type === "tool-call") {
+          toolCalls.push({
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: part.input ?? part.args
+          });
+        } else if (part?.type === "finish") {
+          usage = part.usage;
+          finishReason = part.finishReason;
+          complete();
+        }
+      } catch {
+      }
+      controller.enqueue(part);
+    },
+    flush() {
+      complete();
+    }
+  });
+}
+var BitfabVercelAiHandler = class {
+  constructor(config) {
+    this.traceFunctionKey = config.traceFunctionKey;
+    this.withSpanFn = config.withSpan;
+  }
+  /** The `wrapLanguageModel` middleware object for this trace function key. */
+  get middleware() {
+    const key = this.traceFunctionKey;
+    const withSpan = this.withSpanFn;
+    return {
+      specificationVersion: "v3",
+      wrapGenerate: async ({ doGenerate, params, model }) => {
+        const label = modelLabel(model);
+        const traced = withSpan(
+          key,
+          {
+            type: "llm",
+            finalize: (result) => summarizeGenerate(result ?? {}, label)
+          },
+          () => doGenerate()
+        );
+        return traced(params);
+      },
+      wrapStream: async ({ doStream, params, model }) => {
+        const label = modelLabel(model);
+        let resolveSummary = () => {
+        };
+        const summary = new Promise((resolve) => {
+          resolveSummary = resolve;
+        });
+        const traced = withSpan(
+          key,
+          // The wrapped fn returns immediately with the live stream, so the span
+          // output cannot be read from the return value. `finalize` instead
+          // awaits the summary the accumulator resolves once the stream drains.
+          { type: "llm", finalize: () => summary },
+          async () => {
+            const result = await doStream();
+            const stream = result.stream.pipeThrough(
+              accumulateStream(resolveSummary, label)
+            );
+            return { ...result, stream };
+          }
+        );
+        return traced(params);
+      }
+    };
+  }
+};
+
 // src/client.ts
 var activeTraceStates = /* @__PURE__ */ new Map();
 var pendingSpanPromises = /* @__PURE__ */ new Map();
@@ -3025,7 +3163,11 @@ var Bitfab = class {
   getOpenAiAgentHandler(traceFunctionKey) {
     return new BitfabOpenAIAgentHandler({
       traceFunctionKey,
-      withSpan: this.withSpan.bind(this)
+      withSpan: this.withSpan.bind(this),
+      getActiveSpanContext: () => {
+        const stack = getSpanStack();
+        return stack[stack.length - 1] ?? null;
+      }
     });
   }
   /**
@@ -3108,6 +3250,36 @@ var Bitfab = class {
       }
     });
   }
+  /**
+   * Get a Vercel AI SDK language-model middleware for tracing.
+   *
+   * Pass it to the AI SDK's `wrapLanguageModel` and use the wrapped model with
+   * `generateText` / `streamText` / `generateObject` / `streamObject`. Every
+   * call through that model is captured as a keyed `llm` span carrying the call
+   * parameters (the prompt) as input and a serializable summary
+   * (`{ text, toolCalls, usage, finishReason }`) as output. Streaming is
+   * captured without disturbing the caller's live stream.
+   *
+   * ```typescript
+   * import { wrapLanguageModel, streamText } from "ai";
+   * import { openai } from "@ai-sdk/openai";
+   *
+   * const model = wrapLanguageModel({
+   *   model: openai("gpt-4o"),
+   *   middleware: client.getVercelAiMiddleware("chat-turn"),
+   * });
+   * const result = streamText({ model, messages });
+   * ```
+   *
+   * @param traceFunctionKey - Groups traces under this key in Bitfab
+   * @returns A Vercel AI SDK middleware configured for this client
+   */
+  getVercelAiMiddleware(traceFunctionKey) {
+    return new BitfabVercelAiHandler({
+      traceFunctionKey,
+      withSpan: this.withSpan.bind(this)
+    }).middleware;
+  }
   /**
    * Wrap a BAML client method to automatically capture prompt and LLM metadata.
    *
@@ -3650,7 +3822,7 @@ var Bitfab = class {
     if (wrappedKey === void 0) {
       replayFn = this.withSpan(
         traceFunctionKey,
-        { name: fn.name || "Replay", type: "agent" },
+        { name: traceFunctionKey, type: "agent" },
         fn
       );
     } else if (wrappedKey !== traceFunctionKey) {
@@ -3780,6 +3952,7 @@ var finalizers = {
   BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
   SUPPORTED_PROVIDERS,