@bitfab/sdk 0.21.1 → 0.22.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Trace, Span } from '@openai/agents';
+import { Agent, AgentInputItem, RunState, NonStreamRunOptions, RunResult, StreamRunOptions, StreamedRunResult, Trace, Span } from '@openai/agents';
 
 /**
  * BAML execution utilities for the Bitfab TypeScript SDK.
@@ -52,9 +52,14 @@ interface ActiveSpanContext$2 {
  * Captures LLM turns, tool invocations, and subagent execution as
  * Bitfab spans with proper parent-child hierarchy.
  *
+ * The TypeScript Claude Agent SDK exposes a single `query()` entry point (there
+ * is no `ClaudeSDKClient` class — that exists only in the Python SDK). Wrap the
+ * `query()` async iterator with `wrapQuery`; tool and subagent spans come from
+ * the hooks injected by `instrumentOptions`.
+ *
  * ```typescript
  * import { Bitfab } from "@bitfab/sdk";
- * import { ClaudeSDKClient } from "@anthropic-ai/claude-agent-sdk";
+ * import { query } from "@anthropic-ai/claude-agent-sdk";
  *
  * const bitfab = new Bitfab({ apiKey: "..." });
  * const handler = bitfab.getClaudeAgentHandler("my-agent");
@@ -63,11 +68,9 @@ interface ActiveSpanContext$2 {
  *   model: "claude-sonnet-4-5-...",
  * });
  *
- * const client = new ClaudeSDKClient(options);
- * await client.connect();
- * await client.query("Do something");
- *
- * for await (const message of handler.wrapResponse(client.receiveResponse())) {
+ * for await (const message of handler.wrapQuery(
+ *   query({ prompt: "Do something", options })
+ * )) {
  *   // process messages normally
  * }
  * ```
@@ -91,6 +94,9 @@ declare class BitfabClaudeAgentHandler {
     private currentLlmStartedAt;
     private currentLlmHistorySnapshot;
     private activeSubagentSpans;
+    private hasRootInput;
+    private rootInput;
+    private rootOutput;
     constructor(config: {
         apiKey?: string;
         traceFunctionKey: string;
@@ -100,6 +106,8 @@ declare class BitfabClaudeAgentHandler {
     });
     private ensureTrace;
     private getParentId;
+    private maybeStartRootSpan;
+    private completeRootSpan;
     private startSpan;
     private completeSpan;
     private sendSpan;
@@ -122,19 +130,38 @@ declare class BitfabClaudeAgentHandler {
      */
     instrumentOptions<T extends Record<string, unknown>>(options: T): T;
     /**
-     * Wrap a `ClaudeSDKClient.receiveResponse()` stream to capture LLM turns.
+     * Wrap any Claude Agent SDK message stream to capture LLM turns.
+     *
+     * Yields every message unchanged while capturing assistant message
+     * content as LLM turn spans. Kept for naming symmetry with the Python
+     * SDK's `wrapResponse` (which wraps `ClaudeSDKClient.receiveResponse()`);
+     * in TypeScript, prefer `wrapQuery` around `query()`.
      *
-     * Yields every message unchanged while capturing AssistantMessage
-     * content as LLM turn spans.
+     * Pass `{ input }` (the prompt) to record a replayable root span — see
+     * `wrapQuery`.
      */
-    wrapResponse(stream: AsyncIterable<unknown>): AsyncIterable<unknown>;
+    wrapResponse(stream: AsyncIterable<unknown>, opts?: {
+        input?: unknown;
+    }): AsyncIterable<unknown>;
     /**
      * Wrap a `query()` async iterator to capture LLM turns.
      *
-     * Same as `wrapResponse` but for the simpler `query()` API
-     * which does not support hooks (no tool/subagent spans).
+     * Tool and subagent spans are captured separately via the hooks injected
+     * by `instrumentOptions` into the `options` passed to `query()`.
+     *
+     * Pass `{ input }` — the prompt (or the serializable args that produced it)
+     * — to make a handler-only run replayable: the handler records a root `agent`
+     * span with that input, so `replay(key, fn)` can re-feed it. Omit it only
+     * when an enclosing `withSpan` already supplies the replayable root.
+     *
+     * ```typescript
+     * handler.wrapQuery(query({ prompt, options }), { input: prompt })
+     * ```
      */
-    wrapQuery(stream: AsyncIterable<unknown>): AsyncIterable<unknown>;
+    wrapQuery(stream: AsyncIterable<unknown>, opts?: {
+        input?: unknown;
+    }): AsyncIterable<unknown>;
+    private setRootInput;
     private processStream;
     private processMessage;
     private handleAssistantMessage;
@@ -286,6 +313,76 @@ declare class BitfabLangGraphCallbackHandler {
     handleRetrieverError(error: unknown, runId: string): Promise<void>;
 }
 
+/**
+ * OpenAI Agents SDK handler for Bitfab tracing.
+ *
+ * The OpenAI Agents SDK is instrumented in two layers:
+ *
+ *   1. A process-wide `TracingProcessor` (see `getOpenAiTracingProcessor` /
+ *      `BitfabOpenAITracingProcessor`) registered once with `addTraceProcessor`.
+ *      It captures everything *inside* a run — LLM calls, tool calls, handoffs —
+ *      as Bitfab spans.
+ *   2. This handler's `wrapRun`, which owns the *root*. The processor never sees
+ *      the caller's input (the SDK's trace events don't carry it), so a
+ *      processor-only run records a root span with an empty input and is not
+ *      replayable. `wrapRun` is a thin drop-in for `run()` that opens a
+ *      `withSpan` root carrying the input and final output, so the run is
+ *      replayable with no hand-written `withSpan`. The processor's spans nest
+ *      underneath it automatically (it remaps onto the active span context).
+ *
+ * Use both together: register the processor once at startup, then call
+ * `handler.wrapRun(agent, input)` instead of `run(agent, input)`.
+ */
+
+type RootSpanOptions = {
+    type: "agent";
+    finalize: (result: unknown) => unknown | Promise<unknown>;
+};
+type WithSpanFn = <TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: RootSpanOptions, fn: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+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.
+ *
+ * ```typescript
+ * import { Bitfab } from "@bitfab/sdk";
+ * import { addTraceProcessor, Agent, run } from "@openai/agents";
+ *
+ * const bitfab = new Bitfab({ apiKey: "..." });
+ * addTraceProcessor(bitfab.getOpenAiTracingProcessor()); // captures internals
+ *
+ * const agent = new Agent({ name: "Researcher", instructions: "..." });
+ * const handler = bitfab.getOpenAiAgentHandler("research-topic");
+ *
+ * // Swap run(agent, input) -> handler.wrapRun(agent, input)
+ * const result = await handler.wrapRun(agent, "Find X");
+ * return result.finalOutput;
+ * ```
+ */
+declare class BitfabOpenAIAgentHandler {
+    private readonly traceFunctionKey;
+    private readonly withSpanFn;
+    constructor(config: {
+        traceFunctionKey: string;
+        withSpan: WithSpanFn;
+    });
+    /**
+     * Drop-in replacement for the OpenAI Agents SDK's `run()` that records a
+     * replayable root `agent` span.
+     *
+     * The `input` is captured as the root span's input (as a single positional
+     * argument, so `replay(key, fn)` re-feeds it), and the run's `finalOutput`
+     * is recorded as the root output. For streaming runs (`{ stream: true }`),
+     * the result is handed back immediately and the final output is recorded
+     * once the stream completes — first-byte latency is untouched.
+     *
+     * The process-wide tracing processor (`getOpenAiTracingProcessor`) must still
+     * be registered: it captures the LLM/tool/handoff spans that nest beneath
+     * this root.
+     */
+    wrapRun<TAgent extends Agent<any, any>, TContext = undefined>(agent: TAgent, input: RunInput<TContext, TAgent>, options?: NonStreamRunOptions<TContext>): Promise<RunResult<TContext, TAgent>>;
+    wrapRun<TAgent extends Agent<any, any>, TContext = undefined>(agent: TAgent, input: RunInput<TContext, TAgent>, options: StreamRunOptions<TContext>): Promise<StreamedRunResult<TContext, TAgent>>;
+}
+
 /**
  * Per-trace environment exposed to customer code during replay.
  *
@@ -836,6 +933,29 @@ declare class Bitfab {
      * @returns A BitfabOpenAITracingProcessor instance configured for this client
      */
     getOpenAiTracingProcessor(): BitfabOpenAITracingProcessor;
+    /**
+     * Get an OpenAI Agents SDK handler that records a replayable root span.
+     *
+     * The processor from {@link getOpenAiTracingProcessor} captures everything
+     * inside a run (LLM calls, tools, handoffs) but never sees the caller's
+     * input, so a processor-only run records an empty-input root and is not
+     * replayable. This handler's `wrapRun` is a drop-in for `run()` that opens a
+     * `withSpan` root carrying the input and final output; the processor's spans
+     * nest beneath it. Register the processor once at startup, then call
+     * `handler.wrapRun(agent, input)` in place of `run(agent, input)`.
+     *
+     * ```typescript
+     * import { addTraceProcessor, Agent, run } from "@openai/agents";
+     *
+     * addTraceProcessor(client.getOpenAiTracingProcessor());
+     * const handler = client.getOpenAiAgentHandler("research-topic");
+     * const result = await handler.wrapRun(agent, "Find X");
+     * ```
+     *
+     * @param traceFunctionKey - Groups traces under this key in Bitfab
+     * @returns A BitfabOpenAIAgentHandler configured for this client
+     */
+    getOpenAiAgentHandler(traceFunctionKey: string): BitfabOpenAIAgentHandler;
     /**
      * Get a LangGraph/LangChain callback handler for tracing.
      *
@@ -877,14 +997,15 @@ declare class Bitfab {
      * execution as Bitfab spans with proper parent-child hierarchy.
      *
      * ```typescript
+     * import { query } from "@anthropic-ai/claude-agent-sdk";
+     *
      * const handler = client.getClaudeAgentHandler("my-agent");
      * const options = handler.instrumentOptions({
      *   model: "claude-sonnet-4-5-...",
      * });
-     * const sdkClient = new ClaudeSDKClient(options);
-     * await sdkClient.connect();
-     * await sdkClient.query("Do something");
-     * for await (const msg of handler.wrapResponse(sdkClient.receiveResponse())) {
+     * for await (const msg of handler.wrapQuery(
+     *   query({ prompt: "Do something", options })
+     * )) {
      *   // process messages
      * }
      * ```
@@ -1089,7 +1210,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.21.1";
+declare const __version__ = "0.22.0";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1157,4 +1278,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, 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, 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 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Trace, Span } from '@openai/agents';
+import { Agent, AgentInputItem, RunState, NonStreamRunOptions, RunResult, StreamRunOptions, StreamedRunResult, Trace, Span } from '@openai/agents';
 
 /**
  * BAML execution utilities for the Bitfab TypeScript SDK.
@@ -52,9 +52,14 @@ interface ActiveSpanContext$2 {
  * Captures LLM turns, tool invocations, and subagent execution as
  * Bitfab spans with proper parent-child hierarchy.
  *
+ * The TypeScript Claude Agent SDK exposes a single `query()` entry point (there
+ * is no `ClaudeSDKClient` class — that exists only in the Python SDK). Wrap the
+ * `query()` async iterator with `wrapQuery`; tool and subagent spans come from
+ * the hooks injected by `instrumentOptions`.
+ *
  * ```typescript
  * import { Bitfab } from "@bitfab/sdk";
- * import { ClaudeSDKClient } from "@anthropic-ai/claude-agent-sdk";
+ * import { query } from "@anthropic-ai/claude-agent-sdk";
  *
  * const bitfab = new Bitfab({ apiKey: "..." });
  * const handler = bitfab.getClaudeAgentHandler("my-agent");
@@ -63,11 +68,9 @@ interface ActiveSpanContext$2 {
  *   model: "claude-sonnet-4-5-...",
  * });
  *
- * const client = new ClaudeSDKClient(options);
- * await client.connect();
- * await client.query("Do something");
- *
- * for await (const message of handler.wrapResponse(client.receiveResponse())) {
+ * for await (const message of handler.wrapQuery(
+ *   query({ prompt: "Do something", options })
+ * )) {
  *   // process messages normally
  * }
  * ```
@@ -91,6 +94,9 @@ declare class BitfabClaudeAgentHandler {
     private currentLlmStartedAt;
     private currentLlmHistorySnapshot;
     private activeSubagentSpans;
+    private hasRootInput;
+    private rootInput;
+    private rootOutput;
     constructor(config: {
         apiKey?: string;
         traceFunctionKey: string;
@@ -100,6 +106,8 @@ declare class BitfabClaudeAgentHandler {
     });
     private ensureTrace;
     private getParentId;
+    private maybeStartRootSpan;
+    private completeRootSpan;
     private startSpan;
     private completeSpan;
     private sendSpan;
@@ -122,19 +130,38 @@ declare class BitfabClaudeAgentHandler {
      */
     instrumentOptions<T extends Record<string, unknown>>(options: T): T;
     /**
-     * Wrap a `ClaudeSDKClient.receiveResponse()` stream to capture LLM turns.
+     * Wrap any Claude Agent SDK message stream to capture LLM turns.
+     *
+     * Yields every message unchanged while capturing assistant message
+     * content as LLM turn spans. Kept for naming symmetry with the Python
+     * SDK's `wrapResponse` (which wraps `ClaudeSDKClient.receiveResponse()`);
+     * in TypeScript, prefer `wrapQuery` around `query()`.
      *
-     * Yields every message unchanged while capturing AssistantMessage
-     * content as LLM turn spans.
+     * Pass `{ input }` (the prompt) to record a replayable root span — see
+     * `wrapQuery`.
      */
-    wrapResponse(stream: AsyncIterable<unknown>): AsyncIterable<unknown>;
+    wrapResponse(stream: AsyncIterable<unknown>, opts?: {
+        input?: unknown;
+    }): AsyncIterable<unknown>;
     /**
      * Wrap a `query()` async iterator to capture LLM turns.
      *
-     * Same as `wrapResponse` but for the simpler `query()` API
-     * which does not support hooks (no tool/subagent spans).
+     * Tool and subagent spans are captured separately via the hooks injected
+     * by `instrumentOptions` into the `options` passed to `query()`.
+     *
+     * Pass `{ input }` — the prompt (or the serializable args that produced it)
+     * — to make a handler-only run replayable: the handler records a root `agent`
+     * span with that input, so `replay(key, fn)` can re-feed it. Omit it only
+     * when an enclosing `withSpan` already supplies the replayable root.
+     *
+     * ```typescript
+     * handler.wrapQuery(query({ prompt, options }), { input: prompt })
+     * ```
      */
-    wrapQuery(stream: AsyncIterable<unknown>): AsyncIterable<unknown>;
+    wrapQuery(stream: AsyncIterable<unknown>, opts?: {
+        input?: unknown;
+    }): AsyncIterable<unknown>;
+    private setRootInput;
     private processStream;
     private processMessage;
     private handleAssistantMessage;
@@ -286,6 +313,76 @@ declare class BitfabLangGraphCallbackHandler {
     handleRetrieverError(error: unknown, runId: string): Promise<void>;
 }
 
+/**
+ * OpenAI Agents SDK handler for Bitfab tracing.
+ *
+ * The OpenAI Agents SDK is instrumented in two layers:
+ *
+ *   1. A process-wide `TracingProcessor` (see `getOpenAiTracingProcessor` /
+ *      `BitfabOpenAITracingProcessor`) registered once with `addTraceProcessor`.
+ *      It captures everything *inside* a run — LLM calls, tool calls, handoffs —
+ *      as Bitfab spans.
+ *   2. This handler's `wrapRun`, which owns the *root*. The processor never sees
+ *      the caller's input (the SDK's trace events don't carry it), so a
+ *      processor-only run records a root span with an empty input and is not
+ *      replayable. `wrapRun` is a thin drop-in for `run()` that opens a
+ *      `withSpan` root carrying the input and final output, so the run is
+ *      replayable with no hand-written `withSpan`. The processor's spans nest
+ *      underneath it automatically (it remaps onto the active span context).
+ *
+ * Use both together: register the processor once at startup, then call
+ * `handler.wrapRun(agent, input)` instead of `run(agent, input)`.
+ */
+
+type RootSpanOptions = {
+    type: "agent";
+    finalize: (result: unknown) => unknown | Promise<unknown>;
+};
+type WithSpanFn = <TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: RootSpanOptions, fn: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+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.
+ *
+ * ```typescript
+ * import { Bitfab } from "@bitfab/sdk";
+ * import { addTraceProcessor, Agent, run } from "@openai/agents";
+ *
+ * const bitfab = new Bitfab({ apiKey: "..." });
+ * addTraceProcessor(bitfab.getOpenAiTracingProcessor()); // captures internals
+ *
+ * const agent = new Agent({ name: "Researcher", instructions: "..." });
+ * const handler = bitfab.getOpenAiAgentHandler("research-topic");
+ *
+ * // Swap run(agent, input) -> handler.wrapRun(agent, input)
+ * const result = await handler.wrapRun(agent, "Find X");
+ * return result.finalOutput;
+ * ```
+ */
+declare class BitfabOpenAIAgentHandler {
+    private readonly traceFunctionKey;
+    private readonly withSpanFn;
+    constructor(config: {
+        traceFunctionKey: string;
+        withSpan: WithSpanFn;
+    });
+    /**
+     * Drop-in replacement for the OpenAI Agents SDK's `run()` that records a
+     * replayable root `agent` span.
+     *
+     * The `input` is captured as the root span's input (as a single positional
+     * argument, so `replay(key, fn)` re-feeds it), and the run's `finalOutput`
+     * is recorded as the root output. For streaming runs (`{ stream: true }`),
+     * the result is handed back immediately and the final output is recorded
+     * once the stream completes — first-byte latency is untouched.
+     *
+     * The process-wide tracing processor (`getOpenAiTracingProcessor`) must still
+     * be registered: it captures the LLM/tool/handoff spans that nest beneath
+     * this root.
+     */
+    wrapRun<TAgent extends Agent<any, any>, TContext = undefined>(agent: TAgent, input: RunInput<TContext, TAgent>, options?: NonStreamRunOptions<TContext>): Promise<RunResult<TContext, TAgent>>;
+    wrapRun<TAgent extends Agent<any, any>, TContext = undefined>(agent: TAgent, input: RunInput<TContext, TAgent>, options: StreamRunOptions<TContext>): Promise<StreamedRunResult<TContext, TAgent>>;
+}
+
 /**
  * Per-trace environment exposed to customer code during replay.
  *
@@ -836,6 +933,29 @@ declare class Bitfab {
      * @returns A BitfabOpenAITracingProcessor instance configured for this client
      */
     getOpenAiTracingProcessor(): BitfabOpenAITracingProcessor;
+    /**
+     * Get an OpenAI Agents SDK handler that records a replayable root span.
+     *
+     * The processor from {@link getOpenAiTracingProcessor} captures everything
+     * inside a run (LLM calls, tools, handoffs) but never sees the caller's
+     * input, so a processor-only run records an empty-input root and is not
+     * replayable. This handler's `wrapRun` is a drop-in for `run()` that opens a
+     * `withSpan` root carrying the input and final output; the processor's spans
+     * nest beneath it. Register the processor once at startup, then call
+     * `handler.wrapRun(agent, input)` in place of `run(agent, input)`.
+     *
+     * ```typescript
+     * import { addTraceProcessor, Agent, run } from "@openai/agents";
+     *
+     * addTraceProcessor(client.getOpenAiTracingProcessor());
+     * const handler = client.getOpenAiAgentHandler("research-topic");
+     * const result = await handler.wrapRun(agent, "Find X");
+     * ```
+     *
+     * @param traceFunctionKey - Groups traces under this key in Bitfab
+     * @returns A BitfabOpenAIAgentHandler configured for this client
+     */
+    getOpenAiAgentHandler(traceFunctionKey: string): BitfabOpenAIAgentHandler;
     /**
      * Get a LangGraph/LangChain callback handler for tracing.
      *
@@ -877,14 +997,15 @@ declare class Bitfab {
      * execution as Bitfab spans with proper parent-child hierarchy.
      *
      * ```typescript
+     * import { query } from "@anthropic-ai/claude-agent-sdk";
+     *
      * const handler = client.getClaudeAgentHandler("my-agent");
      * const options = handler.instrumentOptions({
      *   model: "claude-sonnet-4-5-...",
      * });
-     * const sdkClient = new ClaudeSDKClient(options);
-     * await sdkClient.connect();
-     * await sdkClient.query("Do something");
-     * for await (const msg of handler.wrapResponse(sdkClient.receiveResponse())) {
+     * for await (const msg of handler.wrapQuery(
+     *   query({ prompt: "Do something", options })
+     * )) {
      *   // process messages
      * }
      * ```
@@ -1089,7 +1210,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.21.1";
+declare const __version__ = "0.22.0";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1157,4 +1278,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, 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, 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 };

package/dist/index.js

@@ -3,6 +3,7 @@ import {
   BitfabClaudeAgentHandler,
   BitfabFunction,
   BitfabLangGraphCallbackHandler,
+  BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,
@@ -12,7 +13,7 @@ import {
   flushTraces,
   getCurrentSpan,
   getCurrentTrace
-} from "./chunk-75LZO6JS.js";
+} from "./chunk-4SLFC266.js";
 import {
   BitfabError
 } from "./chunk-EQI6ZJC3.js";
@@ -23,6 +24,7 @@ export {
   BitfabFunction,
   BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler,
   BitfabLangGraphCallbackHandler,
+  BitfabOpenAIAgentHandler,
   BitfabOpenAITracingProcessor,
   DEFAULT_SERVICE_URL,
   ReplayEnvironment,