@bitfab/sdk 0.23.1 → 0.23.3

package/dist/{chunk-2EDITKO2.js → chunk-CG6LVLBK.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-EQI6ZJC3.js";
 
 // src/version.generated.ts
-var __version__ = "0.23.1";
+var __version__ = "0.23.3";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -946,6 +946,16 @@ var BitfabClaudeAgentHandler = class {
   }
 };
 
+// src/optionalPeer.ts
+function importOptionalPeer(specifierParts) {
+  const specifier = specifierParts.join("/");
+  return import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    specifier
+  );
+}
+
 // src/baml.ts
 var cachedBaml = null;
 async function loadBaml() {
@@ -953,7 +963,7 @@ async function loadBaml() {
     return cachedBaml;
   }
   try {
-    cachedBaml = await import("@boundaryml/baml");
+    cachedBaml = await importOptionalPeer(["@boundaryml", "baml"]);
     return cachedBaml;
   } catch {
     throw new Error(
@@ -1794,7 +1804,10 @@ var BitfabOpenAIAgentHandler = class {
     this.getActiveSpanContext = config.getActiveSpanContext;
   }
   async wrapRun(agent, input, options) {
-    const { run } = await import("@openai/agents");
+    const { run } = await importOptionalPeer([
+      "@openai",
+      "agents"
+    ]);
     if (this.getActiveSpanContext?.() != null) {
       return run(
         agent,
@@ -2110,6 +2123,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();
@@ -2209,7 +2351,10 @@ async function loadCollectorClass() {
     return cachedCollectorClass;
   }
   try {
-    const baml = await import("@boundaryml/baml");
+    const baml = await importOptionalPeer([
+      "@boundaryml",
+      "baml"
+    ]);
     cachedCollectorClass = baml.Collector;
     return cachedCollectorClass;
   } catch {
@@ -2625,6 +2770,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.
    *
@@ -3298,10 +3473,11 @@ export {
   BitfabOpenAIAgentHandler,
   ReplayEnvironment,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   getCurrentSpan,
   getCurrentTrace,
   Bitfab,
   BitfabFunction,
   finalizers
 };
-//# sourceMappingURL=chunk-2EDITKO2.js.map
+//# sourceMappingURL=chunk-CG6LVLBK.js.map