@bitfab/sdk 0.23.0 → 0.23.2

package/dist/index.d.cts

@@ -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.
  *
@@ -330,6 +446,14 @@ declare class BitfabLangGraphCallbackHandler {
  *      replayable with no hand-written `withSpan`. The processor's spans nest
  *      underneath it automatically (it remaps onto the active span context).
  *
+ * When `wrapRun` runs inside an enclosing Bitfab span (the replay auto-wrap, or
+ * a caller's own `withSpan`), that span is already the replayable root: the
+ * handler skips opening a second one and lets the processor nest the run's spans
+ * under the existing root. This mirrors the Claude Agent SDK and LangGraph
+ * handlers, which no-op their root span under an enclosing span, and keeps a
+ * replayed run's span tree identical to the original (no doubled root agent
+ * span).
+ *
  * Use both together: register the processor once at startup, then call
  * `handler.wrapRun(agent, input)` instead of `run(agent, input)`.
  */
@@ -339,6 +463,7 @@ type RootSpanOptions = {
     finalize: (result: unknown) => unknown | Promise<unknown>;
 };
 type WithSpanFn = <TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: RootSpanOptions, fn: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+type GetActiveSpanContextFn = () => unknown | null;
 type RunInput<TContext, TAgent extends Agent<any, any>> = string | AgentInputItem[] | RunState<TContext, TAgent>;
 /**
  * OpenAI Agents SDK handler that records a replayable root span around a run.
@@ -361,9 +486,11 @@ type RunInput<TContext, TAgent extends Agent<any, any>> = string | AgentInputIte
 declare class BitfabOpenAIAgentHandler {
     private readonly traceFunctionKey;
     private readonly withSpanFn;
+    private readonly getActiveSpanContext?;
     constructor(config: {
         traceFunctionKey: string;
         withSpan: WithSpanFn;
+        getActiveSpanContext?: GetActiveSpanContextFn;
     });
     /**
      * Drop-in replacement for the OpenAI Agents SDK's `run()` that records a
@@ -694,10 +821,6 @@ declare class BitfabOpenAITracingProcessor implements TracingProcessor {
     private sendSpan;
 }
 
-/**
- * Bitfab client for provider-based API calls.
- */
-
 /**
  * Options for wrapBAML.
  */
@@ -1014,6 +1137,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.
      *
@@ -1210,7 +1358,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.23.0";
+declare const __version__ = "0.23.2";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1278,4 +1426,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

@@ -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.
  *
@@ -330,6 +446,14 @@ declare class BitfabLangGraphCallbackHandler {
  *      replayable with no hand-written `withSpan`. The processor's spans nest
  *      underneath it automatically (it remaps onto the active span context).
  *
+ * When `wrapRun` runs inside an enclosing Bitfab span (the replay auto-wrap, or
+ * a caller's own `withSpan`), that span is already the replayable root: the
+ * handler skips opening a second one and lets the processor nest the run's spans
+ * under the existing root. This mirrors the Claude Agent SDK and LangGraph
+ * handlers, which no-op their root span under an enclosing span, and keeps a
+ * replayed run's span tree identical to the original (no doubled root agent
+ * span).
+ *
  * Use both together: register the processor once at startup, then call
  * `handler.wrapRun(agent, input)` instead of `run(agent, input)`.
  */
@@ -339,6 +463,7 @@ type RootSpanOptions = {
     finalize: (result: unknown) => unknown | Promise<unknown>;
 };
 type WithSpanFn = <TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: RootSpanOptions, fn: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+type GetActiveSpanContextFn = () => unknown | null;
 type RunInput<TContext, TAgent extends Agent<any, any>> = string | AgentInputItem[] | RunState<TContext, TAgent>;
 /**
  * OpenAI Agents SDK handler that records a replayable root span around a run.
@@ -361,9 +486,11 @@ type RunInput<TContext, TAgent extends Agent<any, any>> = string | AgentInputIte
 declare class BitfabOpenAIAgentHandler {
     private readonly traceFunctionKey;
     private readonly withSpanFn;
+    private readonly getActiveSpanContext?;
     constructor(config: {
         traceFunctionKey: string;
         withSpan: WithSpanFn;
+        getActiveSpanContext?: GetActiveSpanContextFn;
     });
     /**
      * Drop-in replacement for the OpenAI Agents SDK's `run()` that records a
@@ -694,10 +821,6 @@ declare class BitfabOpenAITracingProcessor implements TracingProcessor {
     private sendSpan;
 }
 
-/**
- * Bitfab client for provider-based API calls.
- */
-
 /**
  * Options for wrapBAML.
  */
@@ -1014,6 +1137,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.
      *
@@ -1210,7 +1358,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.23.0";
+declare const __version__ = "0.23.2";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1278,4 +1426,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

@@ -5,6 +5,7 @@ import {
   BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
   SUPPORTED_PROVIDERS,
@@ -13,7 +14,7 @@ import {
   flushTraces,
   getCurrentSpan,
   getCurrentTrace
-} from "./chunk-QOPP5TSO.js";
+} from "./chunk-PP5K6RIU.js";
 import {
   BitfabError
 } from "./chunk-EQI6ZJC3.js";
@@ -26,6 +27,7 @@ export {
   BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
   SUPPORTED_PROVIDERS,

package/dist/node.cjs

@@ -486,6 +486,7 @@ __export(node_exports, {
   BitfabLangGraphCallbackHandler: () => BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler: () => BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor: () => BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler: () => BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL: () => DEFAULT_SERVICE_URL,
   ReplayEnvironment: () => ReplayEnvironment,
   SUPPORTED_PROVIDERS: () => SUPPORTED_PROVIDERS,
@@ -505,7 +506,7 @@ registerAsyncLocalStorageClass(
 );
 
 // src/version.generated.ts
-var __version__ = "0.23.0";
+var __version__ = "0.23.2";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -2293,9 +2294,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;
@@ -2611,6 +2620,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();
@@ -3039,7 +3177,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;
+      }
     });
   }
   /**
@@ -3122,6 +3264,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.
    *
@@ -3664,7 +3836,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) {
@@ -3798,6 +3970,7 @@ assertAsyncStorageRegistered();
   BitfabLangGraphCallbackHandler,
   BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
+  BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
   SUPPORTED_PROVIDERS,