bitfab 0.23.1 → 0.23.3

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Agent, AgentInputItem, RunState, NonStreamRunOptions, RunResult, StreamRunOptions, StreamedRunResult, Trace, Span } from '@openai/agents';
+import { Agent, AgentInputItem, RunState, NonStreamRunOptions, RunResult, StreamRunOptions, StreamedRunResult } from '@openai/agents';
 
 /**
  * BAML execution utilities for the Bitfab TypeScript SDK.
@@ -171,6 +171,122 @@ declare class BitfabClaudeAgentHandler {
     private resetState;
 }
 
+/**
+ * Vercel AI SDK integration for Bitfab tracing.
+ *
+ * The Vercel AI SDK (`ai`) routes every `generateText` / `streamText` /
+ * `generateObject` / `streamObject` call through a language model. Bitfab hooks
+ * that model with a *language-model middleware* (`wrapLanguageModel`), so each
+ * model call is captured as a keyed `llm` span with no hand-written `withSpan`:
+ *
+ * ```typescript
+ * import { Bitfab } from "@bitfab/sdk";
+ * import { wrapLanguageModel, streamText } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ *
+ * const bitfab = new Bitfab({ apiKey: "..." });
+ *
+ * const model = wrapLanguageModel({
+ *   model: openai("gpt-4o"),
+ *   middleware: bitfab.getVercelAiMiddleware("chat-turn"),
+ * });
+ *
+ * const result = streamText({ model, messages });
+ * return result.toUIMessageStreamResponse(); // live stream untouched
+ * ```
+ *
+ * The span records the call parameters (the prompt/messages) as its input and a
+ * serializable summary (`{ text, toolCalls, usage, finishReason }`) as its
+ * output. Streaming is handled by passing the model's stream through a
+ * transform that accumulates the assembled text/usage as the caller consumes
+ * it: the live stream is handed back unchanged (first-byte latency untouched)
+ * and the span is finalized once the stream completes.
+ *
+ * The middleware is fully duck-typed (no static or dynamic `ai` import), so it
+ * adds no dependency and is browser-safe. It works with `ai` v5 and v6.
+ */
+type LlmSpanOptions = {
+    type: "llm";
+    finalize: (result: unknown) => unknown | Promise<unknown>;
+};
+type WithSpanFn$1 = <TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: LlmSpanOptions, fn: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+/**
+ * Duck-typed subset of the Vercel AI SDK language-model call parameters. The
+ * only field we read for the span input is `prompt` (the messages), but the
+ * whole object is recorded so the call is reconstructable on replay.
+ */
+interface VercelCallParams {
+    prompt?: unknown;
+    [key: string]: unknown;
+}
+/** A content part of a non-streaming `doGenerate` result. */
+interface VercelContentPart {
+    type: string;
+    text?: string;
+    toolCallId?: string;
+    toolName?: string;
+    input?: unknown;
+    args?: unknown;
+}
+/** Duck-typed subset of a non-streaming `doGenerate` result. */
+interface VercelGenerateResult {
+    content?: VercelContentPart[];
+    text?: string;
+    usage?: unknown;
+    finishReason?: unknown;
+    [key: string]: unknown;
+}
+/** Duck-typed subset of a single streaming part from `doStream`. */
+interface VercelStreamPart {
+    type: string;
+    delta?: string;
+    textDelta?: string;
+    toolCallId?: string;
+    toolName?: string;
+    input?: unknown;
+    args?: unknown;
+    usage?: unknown;
+    finishReason?: unknown;
+}
+/** Duck-typed subset of a streaming `doStream` result. */
+interface VercelStreamResult {
+    stream: ReadableStream<VercelStreamPart>;
+    [key: string]: unknown;
+}
+interface MiddlewareCall<TResult> {
+    doGenerate: () => PromiseLike<VercelGenerateResult>;
+    doStream: () => PromiseLike<VercelStreamResult>;
+    params: VercelCallParams;
+    model: unknown;
+    __result?: TResult;
+}
+/**
+ * The structural shape of a Vercel AI SDK language-model middleware. Matches
+ * `LanguageModelV3Middleware` from `@ai-sdk/provider` without importing it, so
+ * the SDK stays dependency-free. `wrapLanguageModel` only reads the method
+ * fields (it ignores `specificationVersion`), so this object drops straight in.
+ */
+interface BitfabLanguageModelMiddleware {
+    specificationVersion: "v3";
+    wrapGenerate: (options: MiddlewareCall<VercelGenerateResult>) => Promise<any>;
+    wrapStream: (options: MiddlewareCall<VercelStreamResult>) => Promise<any>;
+}
+/**
+ * Vercel AI SDK middleware that records each language-model call as a keyed
+ * `llm` span. Obtain it from {@link BitfabClient.getVercelAiMiddleware} rather
+ * than constructing it directly.
+ */
+declare class BitfabVercelAiHandler {
+    private readonly traceFunctionKey;
+    private readonly withSpanFn;
+    constructor(config: {
+        traceFunctionKey: string;
+        withSpan: WithSpanFn$1;
+    });
+    /** The `wrapLanguageModel` middleware object for this trace function key. */
+    get middleware(): BitfabLanguageModelMiddleware;
+}
+
 /**
  * Per-trace database snapshot ref capture.
  *
@@ -592,7 +708,19 @@ interface ReplayResult<T> {
  * This module provides utilities for sending external traces (e.g., from OpenAI API calls)
  * to Bitfab for monitoring and analysis.
  */
-
+interface Trace {
+    traceId: string;
+    toJSON(): unknown;
+}
+interface Span<_T = any> {
+    traceId?: string;
+    toJSON(): unknown;
+    spanData?: {
+        type?: string;
+        _input?: unknown;
+        _response?: unknown;
+    } | null;
+}
 interface TraceResponse {
     traceId: string;
     status: "success";
@@ -705,10 +833,6 @@ declare class BitfabOpenAITracingProcessor implements TracingProcessor {
     private sendSpan;
 }
 
-/**
- * Bitfab client for provider-based API calls.
- */
-
 /**
  * Options for wrapBAML.
  */
@@ -1025,6 +1149,31 @@ declare class Bitfab {
      * @returns A BitfabClaudeAgentHandler configured for this client
      */
     getClaudeAgentHandler(traceFunctionKey: string): BitfabClaudeAgentHandler;
+    /**
+     * 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: string): BitfabLanguageModelMiddleware;
     /**
      * Wrap a BAML client method to automatically capture prompt and LLM metadata.
      *
@@ -1221,7 +1370,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.23.1";
+declare const __version__ = "0.23.3";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1289,4 +1438,4 @@ declare const finalizers: {
     readableStream: typeof readableStream;
 };
 
-export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, type MockStrategy, type ProviderDefinition, ReplayEnvironment, type ReplayEnvironmentSnapshot, type ReplayItem, type ReplayOptions, type ReplayResult, SUPPORTED_PROVIDERS, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentSpan, getCurrentTrace };
+export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, type BitfabLanguageModelMiddleware, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, BitfabVercelAiHandler, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, type MockStrategy, type ProviderDefinition, ReplayEnvironment, type ReplayEnvironmentSnapshot, type ReplayItem, type ReplayOptions, type ReplayResult, SUPPORTED_PROVIDERS, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type VercelCallParams, type VercelGenerateResult, type VercelStreamResult, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentSpan, getCurrentTrace };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Agent, AgentInputItem, RunState, NonStreamRunOptions, RunResult, StreamRunOptions, StreamedRunResult, Trace, Span } from '@openai/agents';
+import { Agent, AgentInputItem, RunState, NonStreamRunOptions, RunResult, StreamRunOptions, StreamedRunResult } from '@openai/agents';
 
 /**
  * BAML execution utilities for the Bitfab TypeScript SDK.
@@ -171,6 +171,122 @@ declare class BitfabClaudeAgentHandler {
     private resetState;
 }
 
+/**
+ * Vercel AI SDK integration for Bitfab tracing.
+ *
+ * The Vercel AI SDK (`ai`) routes every `generateText` / `streamText` /
+ * `generateObject` / `streamObject` call through a language model. Bitfab hooks
+ * that model with a *language-model middleware* (`wrapLanguageModel`), so each
+ * model call is captured as a keyed `llm` span with no hand-written `withSpan`:
+ *
+ * ```typescript
+ * import { Bitfab } from "@bitfab/sdk";
+ * import { wrapLanguageModel, streamText } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ *
+ * const bitfab = new Bitfab({ apiKey: "..." });
+ *
+ * const model = wrapLanguageModel({
+ *   model: openai("gpt-4o"),
+ *   middleware: bitfab.getVercelAiMiddleware("chat-turn"),
+ * });
+ *
+ * const result = streamText({ model, messages });
+ * return result.toUIMessageStreamResponse(); // live stream untouched
+ * ```
+ *
+ * The span records the call parameters (the prompt/messages) as its input and a
+ * serializable summary (`{ text, toolCalls, usage, finishReason }`) as its
+ * output. Streaming is handled by passing the model's stream through a
+ * transform that accumulates the assembled text/usage as the caller consumes
+ * it: the live stream is handed back unchanged (first-byte latency untouched)
+ * and the span is finalized once the stream completes.
+ *
+ * The middleware is fully duck-typed (no static or dynamic `ai` import), so it
+ * adds no dependency and is browser-safe. It works with `ai` v5 and v6.
+ */
+type LlmSpanOptions = {
+    type: "llm";
+    finalize: (result: unknown) => unknown | Promise<unknown>;
+};
+type WithSpanFn$1 = <TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: LlmSpanOptions, fn: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+/**
+ * Duck-typed subset of the Vercel AI SDK language-model call parameters. The
+ * only field we read for the span input is `prompt` (the messages), but the
+ * whole object is recorded so the call is reconstructable on replay.
+ */
+interface VercelCallParams {
+    prompt?: unknown;
+    [key: string]: unknown;
+}
+/** A content part of a non-streaming `doGenerate` result. */
+interface VercelContentPart {
+    type: string;
+    text?: string;
+    toolCallId?: string;
+    toolName?: string;
+    input?: unknown;
+    args?: unknown;
+}
+/** Duck-typed subset of a non-streaming `doGenerate` result. */
+interface VercelGenerateResult {
+    content?: VercelContentPart[];
+    text?: string;
+    usage?: unknown;
+    finishReason?: unknown;
+    [key: string]: unknown;
+}
+/** Duck-typed subset of a single streaming part from `doStream`. */
+interface VercelStreamPart {
+    type: string;
+    delta?: string;
+    textDelta?: string;
+    toolCallId?: string;
+    toolName?: string;
+    input?: unknown;
+    args?: unknown;
+    usage?: unknown;
+    finishReason?: unknown;
+}
+/** Duck-typed subset of a streaming `doStream` result. */
+interface VercelStreamResult {
+    stream: ReadableStream<VercelStreamPart>;
+    [key: string]: unknown;
+}
+interface MiddlewareCall<TResult> {
+    doGenerate: () => PromiseLike<VercelGenerateResult>;
+    doStream: () => PromiseLike<VercelStreamResult>;
+    params: VercelCallParams;
+    model: unknown;
+    __result?: TResult;
+}
+/**
+ * The structural shape of a Vercel AI SDK language-model middleware. Matches
+ * `LanguageModelV3Middleware` from `@ai-sdk/provider` without importing it, so
+ * the SDK stays dependency-free. `wrapLanguageModel` only reads the method
+ * fields (it ignores `specificationVersion`), so this object drops straight in.
+ */
+interface BitfabLanguageModelMiddleware {
+    specificationVersion: "v3";
+    wrapGenerate: (options: MiddlewareCall<VercelGenerateResult>) => Promise<any>;
+    wrapStream: (options: MiddlewareCall<VercelStreamResult>) => Promise<any>;
+}
+/**
+ * Vercel AI SDK middleware that records each language-model call as a keyed
+ * `llm` span. Obtain it from {@link BitfabClient.getVercelAiMiddleware} rather
+ * than constructing it directly.
+ */
+declare class BitfabVercelAiHandler {
+    private readonly traceFunctionKey;
+    private readonly withSpanFn;
+    constructor(config: {
+        traceFunctionKey: string;
+        withSpan: WithSpanFn$1;
+    });
+    /** The `wrapLanguageModel` middleware object for this trace function key. */
+    get middleware(): BitfabLanguageModelMiddleware;
+}
+
 /**
  * Per-trace database snapshot ref capture.
  *
@@ -592,7 +708,19 @@ interface ReplayResult<T> {
  * This module provides utilities for sending external traces (e.g., from OpenAI API calls)
  * to Bitfab for monitoring and analysis.
  */
-
+interface Trace {
+    traceId: string;
+    toJSON(): unknown;
+}
+interface Span<_T = any> {
+    traceId?: string;
+    toJSON(): unknown;
+    spanData?: {
+        type?: string;
+        _input?: unknown;
+        _response?: unknown;
+    } | null;
+}
 interface TraceResponse {
     traceId: string;
     status: "success";
@@ -705,10 +833,6 @@ declare class BitfabOpenAITracingProcessor implements TracingProcessor {
     private sendSpan;
 }
 
-/**
- * Bitfab client for provider-based API calls.
- */
-
 /**
  * Options for wrapBAML.
  */
@@ -1025,6 +1149,31 @@ declare class Bitfab {
      * @returns A BitfabClaudeAgentHandler configured for this client
      */
     getClaudeAgentHandler(traceFunctionKey: string): BitfabClaudeAgentHandler;
+    /**
+     * 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: string): BitfabLanguageModelMiddleware;
     /**
      * Wrap a BAML client method to automatically capture prompt and LLM metadata.
      *
@@ -1221,7 +1370,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.23.1";
+declare const __version__ = "0.23.3";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1289,4 +1438,4 @@ declare const finalizers: {
     readableStream: typeof readableStream;
 };
 
-export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, type MockStrategy, type ProviderDefinition, ReplayEnvironment, type ReplayEnvironmentSnapshot, type ReplayItem, type ReplayOptions, type ReplayResult, SUPPORTED_PROVIDERS, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentSpan, getCurrentTrace };
+export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, type BitfabLanguageModelMiddleware, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, BitfabVercelAiHandler, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, type MockStrategy, type ProviderDefinition, ReplayEnvironment, type ReplayEnvironmentSnapshot, type ReplayItem, type ReplayOptions, type ReplayResult, SUPPORTED_PROVIDERS, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type VercelCallParams, type VercelGenerateResult, type VercelStreamResult, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentSpan, getCurrentTrace };

package/dist/index.js

@@ -14,6 +14,7 @@ import {
   BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
   SUPPORTED_PROVIDERS,
@@ -22,7 +23,7 @@ import {
   flushTraces,
   getCurrentSpan,
   getCurrentTrace
-} from "./chunk-2EDITKO2.js";
+} from "./chunk-CG6LVLBK.js";
 import {
   BitfabError
 } from "./chunk-EQI6ZJC3.js";
@@ -35,6 +36,7 @@ export {
   BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
   SUPPORTED_PROVIDERS,

package/dist/node.cjs

@@ -495,6 +495,7 @@ __export(node_exports, {
   BitfabLangGraphCallbackHandler: () => BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler: () => BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor: () => BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler: () => BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL: () => DEFAULT_SERVICE_URL,
   ReplayEnvironment: () => ReplayEnvironment,
   SUPPORTED_PROVIDERS: () => SUPPORTED_PROVIDERS,
@@ -514,7 +515,7 @@ registerAsyncLocalStorageClass(
 );
 
 // src/version.generated.ts
-var __version__ = "0.23.1";
+var __version__ = "0.23.3";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -1455,6 +1456,16 @@ var BitfabClaudeAgentHandler = class {
 // src/client.ts
 init_asyncStorage();
 
+// 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() {
@@ -1462,7 +1473,7 @@ async function loadBaml() {
     return cachedBaml;
   }
   try {
-    cachedBaml = await import("@boundaryml/baml");
+    cachedBaml = await importOptionalPeer(["@boundaryml", "baml"]);
     return cachedBaml;
   } catch {
     throw new Error(
@@ -2305,7 +2316,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,
@@ -2628,6 +2642,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();
@@ -2727,7 +2870,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 {
@@ -3143,6 +3289,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.
    *
@@ -3819,6 +3995,7 @@ assertAsyncStorageRegistered();
   BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
   SUPPORTED_PROVIDERS,