@bitfab/sdk 0.36.4 → 0.36.6

package/dist/index.d.cts

@@ -1213,31 +1213,56 @@ interface ReplayOptions {
      * distinguish items whose function ran (`succeeded`) from items that threw
      * (`errored`).
      *
-     * Invoked synchronously right after each item settles, so keep it cheap. A
+     * Invoked synchronously right after each item finishes, so keep it cheap. A
      * throwing callback never crashes the run: the error is swallowed so progress
      * UI can't break replay.
      */
-    onProgress?: (progress: ReplayProgress) => void;
-}
-/** Running totals reported to {@link ReplayOptions.onProgress} as replay proceeds. */
-interface ReplayProgress {
+    onItemFinish?: (progress: ReplayItemFinishProgress) => void;
     /**
-     * Event kind. Omitted (or `"item"`) for the per-trace settle events streamed
-     * during the run. `"complete"` marks the single terminal event emitted once
-     * the run has settled and been enriched server-side; it carries the full
-     * {@link ReplayProgress.result} and has no `item`. The Bitfab plugin reads
-     * that terminal event to build the run's final result without parsing stdout.
+     * @deprecated Use {@link onItemFinish}. This compatibility callback receives
+     * the same per-item finish events plus the legacy whole-run `"complete"`
+     * event. It is ignored when `onItemFinish` is also provided.
      */
-    type?: "item" | "complete";
+    onProgress?: (progress: ReplayProgress) => void;
     /**
-     * The full {@link ReplayResult}, present only on the terminal `"complete"`
-     * event. Lets the plugin ingest the enriched result (server-aggregated tokens,
-     * server trace ids) over the same channel as progress, so a dependency logging
-     * to stdout can never block it.
+     * Called once when each replay item begins processing, before input loading,
+     * mock preparation, database branching, or the customer function runs. Use
+     * it with {@link onItemFinish} to distinguish queued items from items that
+     * are still in flight. A throwing callback never crashes the run.
      */
-    result?: ReplayResult<unknown>;
+    onItemStart?: (progress: ReplayItemStartProgress) => void;
+}
+/** Emitted through {@link ReplayOptions.onItemStart} when a worker starts an item. */
+interface ReplayItemStartProgress {
+    type: "started";
     /** Test run ID created for this replay. */
-    testRunId?: string;
+    testRunId: string;
+    /** Items whose processing has started so far. */
+    started: number;
+    /** Items that have finished so far, whether they succeeded or errored. */
+    completed: number;
+    /** Total number of items in this replay run. */
+    total: number;
+    /** Of the completed items, how many finished without a code or replay error. */
+    succeeded: number;
+    /** Of the completed items, how many finished with an error. */
+    errored: number;
+    /** The historical trace and span whose replay processing just started. */
+    item: {
+        originalTraceId: string;
+        originalSpanId: string;
+        /** @deprecated alias for `originalTraceId`. */
+        sourceTraceId: string;
+        /** @deprecated alias for `originalSpanId`. */
+        sourceSpanId: string;
+    };
+}
+/** Running totals reported to {@link ReplayOptions.onItemFinish} as replay proceeds. */
+interface ReplayItemFinishProgress {
+    /** Event kind, omitted for backward-compatible per-item events. */
+    type?: "item";
+    /** Test run ID created for this replay. */
+    testRunId: string;
     /** Items that have finished so far, whether they succeeded or errored. */
     completed: number;
     /** Total number of items in this replay run. */
@@ -1247,7 +1272,7 @@ interface ReplayProgress {
     /** Of the completed items, how many have `item.error` set. */
     errored: number;
     /**
-     * The single item that just settled to produce this event. `traceId` is null
+     * The single item that just finished to produce this event. `traceId` is null
      * at this stage (the server replay id isn't known until the run completes);
      * `originalTraceId` is the original (historical) trace that was replayed (so
      * a UI can identify or link it); `error` is its replay error, or null when it
@@ -1255,7 +1280,7 @@ interface ReplayProgress {
      * progress UI show per-trace pass/fail and timing as the run streams, without
      * waiting for the full {@link ReplayResult}.
      */
-    item?: {
+    item: {
         /** Trace ID of the new replay trace (null during the run; the server id arrives at completion). */
         traceId?: string | null;
         /** Bitfab trace ID of the original (historical) trace being replayed. */
@@ -1284,30 +1309,49 @@ interface ReplayProgress {
         dbSnapshotRef?: DbSnapshotRef | null;
     };
 }
+/**
+ * @deprecated Use {@link ReplayItemFinishProgress}. This legacy shape also
+ * represents the item-less terminal `"complete"` event emitted by
+ * {@link ReplayOptions.onProgress}.
+ */
+interface ReplayProgress {
+    type?: "item" | "complete";
+    result?: ReplayResult<unknown>;
+    testRunId?: string;
+    completed: number;
+    total: number;
+    succeeded: number;
+    errored: number;
+    item?: ReplayItemFinishProgress["item"];
+}
 /**
  * Wire prefix the Bitfab plugin scans for. Each line {@link reportReplayProgress}
  * writes is this prefix followed by the JSON of the running totals (plus the
- * settled `item`). The plugin polls these lines to report live progress while a
+ * finished `item`). The plugin polls these lines to report live progress while a
  * replay runs in the background; keep the SDK emitter and the plugin parser in
  * sync.
  */
 declare const BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
 /**
- * A ready-made {@link ReplayOptions.onProgress} callback for replay scripts.
+ * A ready-made replay lifecycle callback for replay scripts.
  * Pass it straight in:
  *
  * ```ts
- * await bitfab.replay("my-fn", fn, { limit, onProgress: reportReplayProgress })
+ * await bitfab.replay("my-fn", fn, {
+ *   limit,
+ *   onItemStart: reportReplayProgress,
+ *   onItemFinish: reportReplayProgress,
+ * })
  * ```
  *
- * It writes one `@@bitfab:progress` line per trace to stderr, which the Bitfab
- * plugin polls to report live progress while the replay runs in the background,
+ * It writes `@@bitfab:progress` lines to stderr, which the Bitfab plugin polls
+ * to report in-flight and finished items while replay runs in the background,
  * so scripts never hand-format the wire protocol.
  * stdout is left untouched for direct-run ReplayResult JSON. Outside Node (no
  * `process.stderr`, e.g. a browser) it is a no-op, and a write failure is
  * swallowed so progress can never crash a run.
  */
-declare function reportReplayProgress(progress: ReplayProgress): void;
+declare function reportReplayProgress(progress: ReplayItemFinishProgress | ReplayItemStartProgress | ReplayProgress): void;
 /** Per-trace context passed to {@link ReplayOptions.adaptInputs}. */
 interface AdaptContext {
     /** Bitfab trace ID of the original (historical) trace being replayed. */
@@ -1878,6 +1922,27 @@ interface SpanOptions {
      */
     finalize?: (result: any) => unknown | Promise<unknown>;
 }
+/**
+ * The standard method context passed to a decorator.
+ *
+ * Defined structurally instead of referencing TypeScript's built-in
+ * `ClassMethodDecoratorContext`, which was added in TypeScript 5.0. This keeps
+ * the SDK's non-decorator APIs consumable by projects on older compilers.
+ */
+interface SpanMethodDecoratorContext<TThis, TValue> {
+    readonly kind: "method";
+    readonly name: string | symbol;
+    readonly static: boolean;
+    readonly private: boolean;
+    readonly access: {
+        has(object: TThis): boolean;
+        get(object: TThis): TValue;
+    };
+    addInitializer(initializer: (this: TThis) => void): void;
+    readonly metadata?: Record<PropertyKey, unknown>;
+}
+/** A standard ECMAScript method decorator produced by {@link Bitfab.span}. */
+type SpanMethodDecorator = <TThis, TArgs extends unknown[], TReturn>(originalMethod: (this: TThis, ...args: TArgs) => TReturn, context: SpanMethodDecoratorContext<TThis, (this: TThis, ...args: TArgs) => TReturn>) => (this: TThis, ...args: TArgs) => TReturn;
 
 /**
  * Client for making provider-based API calls via BAML.
@@ -2148,6 +2213,31 @@ declare class Bitfab {
      * @returns A wrapped function with the same signature that creates spans for inputs and outputs
      */
     withSpan<TArgs extends unknown[], TReturn>(traceFunctionKey: string, optionsOrFn: SpanOptions | ((...args: TArgs) => TReturn), maybeFn?: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+    /**
+     * Create a standard ECMAScript method decorator that records each invocation
+     * as a span.
+     *
+     * It supports instance, static, and private methods; use
+     * {@link Bitfab.withSpan} for standalone functions, class fields, and
+     * accessors.
+     *
+     * @example
+     * ```typescript
+     * const bitfab = new Bitfab({ apiKey: process.env.BITFAB_API_KEY });
+     *
+     * class OrderService {
+     *   @bitfab.span("order-processing", { type: "agent" })
+     *   async process(orderId: string) {
+     *     return { orderId };
+     *   }
+     * }
+     * ```
+     *
+     * @param traceFunctionKey - A string identifier for grouping spans
+     * @param options - Span configuration applied to the decorated method
+     * @returns A standard ECMAScript method decorator
+     */
+    span(traceFunctionKey: string, options?: SpanOptions): SpanMethodDecorator;
     /**
      * Get a detached handle to a previously-created trace, looked up by the
      * canonical Bitfab trace ID.
@@ -2292,6 +2382,25 @@ declare class BitfabFunction {
      * @returns A wrapped function with the same signature that creates spans
      */
     withSpan<TArgs extends unknown[], TReturn>(optionsOrFn: SpanOptions | ((...args: TArgs) => TReturn), maybeFn?: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+    /**
+     * Create a standard ECMAScript method decorator bound to this function key.
+     *
+     * @example
+     * ```typescript
+     * const orders = client.getFunction("order-processing");
+     *
+     * class OrderService {
+     *   @orders.span({ type: "agent" })
+     *   async process(orderId: string) {
+     *     return { orderId };
+     *   }
+     * }
+     * ```
+     *
+     * @param options - Span configuration applied to the decorated method
+     * @returns A standard ECMAScript method decorator
+     */
+    span(options?: SpanOptions): SpanMethodDecorator;
     /**
      * Get a Vercel AI SDK language-model middleware bound to this function's key.
      *
@@ -2399,7 +2508,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.36.4";
+declare const __version__ = "0.36.6";
 
 /**
  * Constants for the Bitfab SDK.
@@ -2467,4 +2576,4 @@ declare const finalizers: {
     readableStream: typeof readableStream;
 };
 
-export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, BITFAB_PROGRESS_PREFIX, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, type BitfabLanguageModelMiddleware, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, BitfabVercelAiHandler, type CaptureWhen, type CapturedSpan, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbBranchOptions, DbBranchReplayError, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, HttpClient, type MockOverride, type MockOverrideCtx, type MockStrategy, type MockValue, type NodeMatcher, type ProviderDefinition, ReplayBranch, ReplayError, type ReplayItem, type ReplayOptions, type ReplayProgress, type ReplayResult, SUPPORTED_PROVIDERS, type SpanLookup, type SpanNodeMeta, type SpanOccurrence, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type VercelCallParams, type VercelGenerateResult, type VercelStreamResult, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentReplayBranch, getCurrentSpan, getCurrentTrace, reportReplayProgress, serializeReplayResult };
+export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, BITFAB_PROGRESS_PREFIX, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, type BitfabLanguageModelMiddleware, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, BitfabVercelAiHandler, type CaptureWhen, type CapturedSpan, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbBranchOptions, DbBranchReplayError, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, HttpClient, type MockOverride, type MockOverrideCtx, type MockStrategy, type MockValue, type NodeMatcher, type ProviderDefinition, ReplayBranch, ReplayError, type ReplayItem, type ReplayItemFinishProgress, type ReplayItemStartProgress, type ReplayOptions, type ReplayProgress, type ReplayResult, SUPPORTED_PROVIDERS, type SpanLookup, type SpanMethodDecorator, type SpanMethodDecoratorContext, type SpanNodeMeta, type SpanOccurrence, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type VercelCallParams, type VercelGenerateResult, type VercelStreamResult, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentReplayBranch, getCurrentSpan, getCurrentTrace, reportReplayProgress, serializeReplayResult };

package/dist/index.d.ts

@@ -1213,31 +1213,56 @@ interface ReplayOptions {
      * distinguish items whose function ran (`succeeded`) from items that threw
      * (`errored`).
      *
-     * Invoked synchronously right after each item settles, so keep it cheap. A
+     * Invoked synchronously right after each item finishes, so keep it cheap. A
      * throwing callback never crashes the run: the error is swallowed so progress
      * UI can't break replay.
      */
-    onProgress?: (progress: ReplayProgress) => void;
-}
-/** Running totals reported to {@link ReplayOptions.onProgress} as replay proceeds. */
-interface ReplayProgress {
+    onItemFinish?: (progress: ReplayItemFinishProgress) => void;
     /**
-     * Event kind. Omitted (or `"item"`) for the per-trace settle events streamed
-     * during the run. `"complete"` marks the single terminal event emitted once
-     * the run has settled and been enriched server-side; it carries the full
-     * {@link ReplayProgress.result} and has no `item`. The Bitfab plugin reads
-     * that terminal event to build the run's final result without parsing stdout.
+     * @deprecated Use {@link onItemFinish}. This compatibility callback receives
+     * the same per-item finish events plus the legacy whole-run `"complete"`
+     * event. It is ignored when `onItemFinish` is also provided.
      */
-    type?: "item" | "complete";
+    onProgress?: (progress: ReplayProgress) => void;
     /**
-     * The full {@link ReplayResult}, present only on the terminal `"complete"`
-     * event. Lets the plugin ingest the enriched result (server-aggregated tokens,
-     * server trace ids) over the same channel as progress, so a dependency logging
-     * to stdout can never block it.
+     * Called once when each replay item begins processing, before input loading,
+     * mock preparation, database branching, or the customer function runs. Use
+     * it with {@link onItemFinish} to distinguish queued items from items that
+     * are still in flight. A throwing callback never crashes the run.
      */
-    result?: ReplayResult<unknown>;
+    onItemStart?: (progress: ReplayItemStartProgress) => void;
+}
+/** Emitted through {@link ReplayOptions.onItemStart} when a worker starts an item. */
+interface ReplayItemStartProgress {
+    type: "started";
     /** Test run ID created for this replay. */
-    testRunId?: string;
+    testRunId: string;
+    /** Items whose processing has started so far. */
+    started: number;
+    /** Items that have finished so far, whether they succeeded or errored. */
+    completed: number;
+    /** Total number of items in this replay run. */
+    total: number;
+    /** Of the completed items, how many finished without a code or replay error. */
+    succeeded: number;
+    /** Of the completed items, how many finished with an error. */
+    errored: number;
+    /** The historical trace and span whose replay processing just started. */
+    item: {
+        originalTraceId: string;
+        originalSpanId: string;
+        /** @deprecated alias for `originalTraceId`. */
+        sourceTraceId: string;
+        /** @deprecated alias for `originalSpanId`. */
+        sourceSpanId: string;
+    };
+}
+/** Running totals reported to {@link ReplayOptions.onItemFinish} as replay proceeds. */
+interface ReplayItemFinishProgress {
+    /** Event kind, omitted for backward-compatible per-item events. */
+    type?: "item";
+    /** Test run ID created for this replay. */
+    testRunId: string;
     /** Items that have finished so far, whether they succeeded or errored. */
     completed: number;
     /** Total number of items in this replay run. */
@@ -1247,7 +1272,7 @@ interface ReplayProgress {
     /** Of the completed items, how many have `item.error` set. */
     errored: number;
     /**
-     * The single item that just settled to produce this event. `traceId` is null
+     * The single item that just finished to produce this event. `traceId` is null
      * at this stage (the server replay id isn't known until the run completes);
      * `originalTraceId` is the original (historical) trace that was replayed (so
      * a UI can identify or link it); `error` is its replay error, or null when it
@@ -1255,7 +1280,7 @@ interface ReplayProgress {
      * progress UI show per-trace pass/fail and timing as the run streams, without
      * waiting for the full {@link ReplayResult}.
      */
-    item?: {
+    item: {
         /** Trace ID of the new replay trace (null during the run; the server id arrives at completion). */
         traceId?: string | null;
         /** Bitfab trace ID of the original (historical) trace being replayed. */
@@ -1284,30 +1309,49 @@ interface ReplayProgress {
         dbSnapshotRef?: DbSnapshotRef | null;
     };
 }
+/**
+ * @deprecated Use {@link ReplayItemFinishProgress}. This legacy shape also
+ * represents the item-less terminal `"complete"` event emitted by
+ * {@link ReplayOptions.onProgress}.
+ */
+interface ReplayProgress {
+    type?: "item" | "complete";
+    result?: ReplayResult<unknown>;
+    testRunId?: string;
+    completed: number;
+    total: number;
+    succeeded: number;
+    errored: number;
+    item?: ReplayItemFinishProgress["item"];
+}
 /**
  * Wire prefix the Bitfab plugin scans for. Each line {@link reportReplayProgress}
  * writes is this prefix followed by the JSON of the running totals (plus the
- * settled `item`). The plugin polls these lines to report live progress while a
+ * finished `item`). The plugin polls these lines to report live progress while a
  * replay runs in the background; keep the SDK emitter and the plugin parser in
  * sync.
  */
 declare const BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
 /**
- * A ready-made {@link ReplayOptions.onProgress} callback for replay scripts.
+ * A ready-made replay lifecycle callback for replay scripts.
  * Pass it straight in:
  *
  * ```ts
- * await bitfab.replay("my-fn", fn, { limit, onProgress: reportReplayProgress })
+ * await bitfab.replay("my-fn", fn, {
+ *   limit,
+ *   onItemStart: reportReplayProgress,
+ *   onItemFinish: reportReplayProgress,
+ * })
  * ```
  *
- * It writes one `@@bitfab:progress` line per trace to stderr, which the Bitfab
- * plugin polls to report live progress while the replay runs in the background,
+ * It writes `@@bitfab:progress` lines to stderr, which the Bitfab plugin polls
+ * to report in-flight and finished items while replay runs in the background,
  * so scripts never hand-format the wire protocol.
  * stdout is left untouched for direct-run ReplayResult JSON. Outside Node (no
  * `process.stderr`, e.g. a browser) it is a no-op, and a write failure is
  * swallowed so progress can never crash a run.
  */
-declare function reportReplayProgress(progress: ReplayProgress): void;
+declare function reportReplayProgress(progress: ReplayItemFinishProgress | ReplayItemStartProgress | ReplayProgress): void;
 /** Per-trace context passed to {@link ReplayOptions.adaptInputs}. */
 interface AdaptContext {
     /** Bitfab trace ID of the original (historical) trace being replayed. */
@@ -1878,6 +1922,27 @@ interface SpanOptions {
      */
     finalize?: (result: any) => unknown | Promise<unknown>;
 }
+/**
+ * The standard method context passed to a decorator.
+ *
+ * Defined structurally instead of referencing TypeScript's built-in
+ * `ClassMethodDecoratorContext`, which was added in TypeScript 5.0. This keeps
+ * the SDK's non-decorator APIs consumable by projects on older compilers.
+ */
+interface SpanMethodDecoratorContext<TThis, TValue> {
+    readonly kind: "method";
+    readonly name: string | symbol;
+    readonly static: boolean;
+    readonly private: boolean;
+    readonly access: {
+        has(object: TThis): boolean;
+        get(object: TThis): TValue;
+    };
+    addInitializer(initializer: (this: TThis) => void): void;
+    readonly metadata?: Record<PropertyKey, unknown>;
+}
+/** A standard ECMAScript method decorator produced by {@link Bitfab.span}. */
+type SpanMethodDecorator = <TThis, TArgs extends unknown[], TReturn>(originalMethod: (this: TThis, ...args: TArgs) => TReturn, context: SpanMethodDecoratorContext<TThis, (this: TThis, ...args: TArgs) => TReturn>) => (this: TThis, ...args: TArgs) => TReturn;
 
 /**
  * Client for making provider-based API calls via BAML.
@@ -2148,6 +2213,31 @@ declare class Bitfab {
      * @returns A wrapped function with the same signature that creates spans for inputs and outputs
      */
     withSpan<TArgs extends unknown[], TReturn>(traceFunctionKey: string, optionsOrFn: SpanOptions | ((...args: TArgs) => TReturn), maybeFn?: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+    /**
+     * Create a standard ECMAScript method decorator that records each invocation
+     * as a span.
+     *
+     * It supports instance, static, and private methods; use
+     * {@link Bitfab.withSpan} for standalone functions, class fields, and
+     * accessors.
+     *
+     * @example
+     * ```typescript
+     * const bitfab = new Bitfab({ apiKey: process.env.BITFAB_API_KEY });
+     *
+     * class OrderService {
+     *   @bitfab.span("order-processing", { type: "agent" })
+     *   async process(orderId: string) {
+     *     return { orderId };
+     *   }
+     * }
+     * ```
+     *
+     * @param traceFunctionKey - A string identifier for grouping spans
+     * @param options - Span configuration applied to the decorated method
+     * @returns A standard ECMAScript method decorator
+     */
+    span(traceFunctionKey: string, options?: SpanOptions): SpanMethodDecorator;
     /**
      * Get a detached handle to a previously-created trace, looked up by the
      * canonical Bitfab trace ID.
@@ -2292,6 +2382,25 @@ declare class BitfabFunction {
      * @returns A wrapped function with the same signature that creates spans
      */
     withSpan<TArgs extends unknown[], TReturn>(optionsOrFn: SpanOptions | ((...args: TArgs) => TReturn), maybeFn?: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+    /**
+     * Create a standard ECMAScript method decorator bound to this function key.
+     *
+     * @example
+     * ```typescript
+     * const orders = client.getFunction("order-processing");
+     *
+     * class OrderService {
+     *   @orders.span({ type: "agent" })
+     *   async process(orderId: string) {
+     *     return { orderId };
+     *   }
+     * }
+     * ```
+     *
+     * @param options - Span configuration applied to the decorated method
+     * @returns A standard ECMAScript method decorator
+     */
+    span(options?: SpanOptions): SpanMethodDecorator;
     /**
      * Get a Vercel AI SDK language-model middleware bound to this function's key.
      *
@@ -2399,7 +2508,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.36.4";
+declare const __version__ = "0.36.6";
 
 /**
  * Constants for the Bitfab SDK.
@@ -2467,4 +2576,4 @@ declare const finalizers: {
     readableStream: typeof readableStream;
 };
 
-export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, BITFAB_PROGRESS_PREFIX, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, type BitfabLanguageModelMiddleware, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, BitfabVercelAiHandler, type CaptureWhen, type CapturedSpan, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbBranchOptions, DbBranchReplayError, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, HttpClient, type MockOverride, type MockOverrideCtx, type MockStrategy, type MockValue, type NodeMatcher, type ProviderDefinition, ReplayBranch, ReplayError, type ReplayItem, type ReplayOptions, type ReplayProgress, type ReplayResult, SUPPORTED_PROVIDERS, type SpanLookup, type SpanNodeMeta, type SpanOccurrence, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type VercelCallParams, type VercelGenerateResult, type VercelStreamResult, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentReplayBranch, getCurrentSpan, getCurrentTrace, reportReplayProgress, serializeReplayResult };
+export { type ActiveSpanContext, type AdaptContext, type AdaptInputsFn, type AllowedEnvVars, BITFAB_PROGRESS_PREFIX, type BamlExecutionResult, Bitfab, BitfabClaudeAgentHandler, type BitfabConfig, BitfabError, BitfabFunction, BitfabLangGraphCallbackHandler as BitfabLangChainCallbackHandler, BitfabLangGraphCallbackHandler, type BitfabLanguageModelMiddleware, BitfabOpenAIAgentHandler, BitfabOpenAITracingProcessor, BitfabVercelAiHandler, type CaptureWhen, type CapturedSpan, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbBranchOptions, DbBranchReplayError, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, HttpClient, type MockOverride, type MockOverrideCtx, type MockStrategy, type MockValue, type NodeMatcher, type ProviderDefinition, ReplayBranch, ReplayError, type ReplayItem, type ReplayItemFinishProgress, type ReplayItemStartProgress, type ReplayOptions, type ReplayProgress, type ReplayResult, SUPPORTED_PROVIDERS, type SpanLookup, type SpanMethodDecorator, type SpanMethodDecoratorContext, type SpanNodeMeta, type SpanOccurrence, type SpanOptions, type SpanType, type TokenUsage, type TraceResponse, type TracingProcessor, type VercelCallParams, type VercelGenerateResult, type VercelStreamResult, type WrapBAMLOptions, type WrappedBamlFn, __version__, finalizers, flushTraces, getCurrentReplayBranch, getCurrentSpan, getCurrentTrace, reportReplayProgress, serializeReplayResult };

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   getCurrentReplayBranch,
   getCurrentSpan,
   getCurrentTrace
-} from "./chunk-5NT3VGCB.js";
+} from "./chunk-BXWUPEC4.js";
 import {
   BITFAB_PROGRESS_PREFIX,
   BitfabError,
@@ -23,7 +23,7 @@ import {
   flushTraces,
   reportReplayProgress,
   serializeReplayResult
-} from "./chunk-6AXY24UL.js";
+} from "./chunk-ENOQ2K2H.js";
 export {
   BITFAB_PROGRESS_PREFIX,
   Bitfab,