@bitfab/sdk 0.28.11 → 0.29.1

package/dist/index.d.cts

@@ -73,6 +73,76 @@ declare class BitfabError extends Error {
     constructor(message: string, url?: string | undefined);
 }
 
+/**
+ * Selective mock overrides for replay.
+ *
+ * A mock override injects a custom value into a specific span (node) during
+ * replay: the matched span short-circuits its real execution and returns the
+ * value you supply, so downstream real code runs against the substituted
+ * output. This is a third mock mode alongside "run real code" and "replay
+ * recorded output" (see {@link MockStrategy}).
+ *
+ * The matcher and value are deliberately separate so matching stays cheap
+ * (structural metadata only, no output fetch) and the recorded output is
+ * fetched lazily - and only if the value function actually asks for it via
+ * {@link MockOverrideCtx.getOriginalOutput}.
+ */
+/**
+ * Structural identity of a span during replay, passed to a {@link NodeMatcher}.
+ * Carries no output payload - matching must not depend on the recorded output,
+ * so the output fetch stays lazy and gated.
+ */
+interface SpanNodeMeta {
+    /** The `withSpan` key of the executing span (its code-side identity). */
+    traceFunctionKey: string;
+    /** Resolved span name: `options.name ?? fn.name ?? traceFunctionKey`. */
+    spanName: string;
+    /** Span type, e.g. "llm", "agent", "tool", "custom". */
+    type: string;
+    /**
+     * The id of this span in the original (replayed) trace, when it exists in
+     * that trace's tree. Undefined when the live span has no recorded
+     * counterpart (e.g. a span the changed code newly introduced).
+     */
+    originalSpanId?: string;
+}
+/** Context passed to a {@link MockValue} function for a matched span. */
+interface MockOverrideCtx {
+    /** The matched span's structural metadata. */
+    node: SpanNodeMeta;
+    /** The live replay args passed to the wrapped function this run. */
+    inputs: unknown[];
+    /**
+     * Lazily fetch this span's ORIGINAL recorded output (deserialized). The fetch
+     * happens only when called and is memoized per replay item, so a purely flat
+     * override that never calls it triggers zero output round trips. Rejects if
+     * the span has no recorded counterpart. Being async, it is only usable for
+     * spans wrapping async functions.
+     */
+    getOriginalOutput: () => Promise<unknown>;
+}
+/** Selects which spans an override applies to. Runs on structural metadata. */
+type NodeMatcher = (node: SpanNodeMeta) => boolean;
+/** The function form of {@link MockValue}, receiving the override context. */
+type MockValueFn = (ctx: MockOverrideCtx) => unknown | Promise<unknown>;
+/**
+ * The value injected for a matched span: either a flat value used as-is, or a
+ * function of the {@link MockOverrideCtx} that returns one (or a Promise of
+ * one). Full replacement - the value IS the span's output, no merge with the
+ * recorded output.
+ *
+ * The flat side is spelled out (rather than `unknown`) so an inline function
+ * still gets a typed `ctx`: `unknown | Fn` would collapse to `unknown` and drop
+ * the contextual type. To inject a value that is itself a function, wrap it:
+ * `value: () => theFunction`.
+ */
+type MockValue = MockValueFn | string | number | boolean | bigint | symbol | object | null | undefined;
+/** One (match, value) pair. */
+interface MockOverride {
+    match: NodeMatcher;
+    value: MockValue;
+}
+
 /**
  * HTTP client utilities for Bitfab API requests.
  *
@@ -654,6 +724,15 @@ interface ReplayOptions {
      * - "all": every child withSpan returns historical output
      */
     mock?: MockStrategy;
+    /**
+     * Selective mock overrides: inject custom values into specific spans during
+     * replay, so downstream real code runs against the substituted output. Each
+     * override is a `{ match, value }` pair; the first matcher that
+     * matches a span wins. These take precedence over any overrides registered on
+     * the client via `registerMockOverride`, and over the base `mock` strategy - a
+     * span no override matches falls back to that strategy. See {@link MockOverride}.
+     */
+    mockOverride?: MockOverride | MockOverride[];
     /**
      * Per-trace environment. When the source trace carries a DB branching
      * snapshot, the SDK populates `environment.databaseUrl` before invoking
@@ -706,6 +785,21 @@ interface ReplayOptions {
 }
 /** Running totals reported to {@link ReplayOptions.onProgress} as replay proceeds. */
 interface ReplayProgress {
+    /**
+     * 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.
+     */
+    type?: "item" | "complete";
+    /**
+     * 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.
+     */
+    result?: ReplayResult<unknown>;
     /** Test run ID created for this replay. */
     testRunId?: string;
     /** Items that have finished so far, whether they succeeded or errored. */
@@ -717,18 +811,25 @@ interface ReplayProgress {
     /** Of the completed items, how many threw (their `item.error` is set). */
     errored: number;
     /**
-     * The single item that just settled to produce this event. `traceId` is the
-     * source (historical) trace that was replayed (so a UI can identify or link
-     * it); `error` is its replay error, or null when it ran ok; `durationMs` is how
-     * long this one trace took to replay. Lets a progress UI show per-trace
-     * pass/fail and timing as the run streams, without waiting for the full
-     * {@link ReplayResult}.
+     * The single item that just settled 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
+     * ran ok; `durationMs` is how long this one trace took to replay. Lets a
+     * progress UI show per-trace pass/fail and timing as the run streams, without
+     * waiting for the full {@link ReplayResult}.
      */
     item?: {
-        /** Source (historical) trace ID being replayed. */
-        traceId: string | null;
-        /** Local SDK replay trace ID, before the server maps it to a row ID. */
-        replayTraceId?: string | null;
+        /** 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. */
+        originalTraceId: string | null;
+        /** External span ID the recorded inputs were read from (the original root span). */
+        originalSpanId?: string | null;
+        /** @deprecated alias for `originalTraceId`. */
+        sourceTraceId: string | null;
+        /** @deprecated alias for `originalSpanId`. */
+        sourceSpanId?: string | null;
         /** Deserialized inputs from the original trace. */
         input?: unknown[];
         /** The result returned by the replayed function, or undefined on error. */
@@ -768,9 +869,13 @@ declare const BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
 declare function reportReplayProgress(progress: ReplayProgress): void;
 /** Per-trace context passed to {@link ReplayOptions.adaptInputs}. */
 interface AdaptContext {
-    /** Bitfab trace ID of the historical trace being replayed. */
-    traceId: string;
+    /** Bitfab trace ID of the original (historical) trace being replayed. */
+    originalTraceId: string;
     /** External span ID the recorded inputs were read from. */
+    originalSpanId: string;
+    /** @deprecated alias for {@link AdaptContext.originalTraceId}. */
+    sourceTraceId: string;
+    /** @deprecated alias for {@link AdaptContext.originalSpanId}. */
     sourceSpanId: string;
 }
 /**
@@ -786,8 +891,23 @@ interface AdaptContext {
  */
 type AdaptInputsFn = (inputs: unknown[], ctx: AdaptContext) => unknown[];
 interface ReplayItem<T> {
-    /** Trace ID of the new trace created during replay. */
+    /**
+     * Server trace ID of the new replay trace this item produced. Written in by
+     * `replay()` from the complete-replay response once the server has minted the
+     * trace row; the client-side id used to correlate spans during the run is
+     * never surfaced here. Null until completion, on older servers that omit the
+     * mapping, or if the item produced no trace. Not the verdict-persistence key:
+     * that is the original-trace lineage (`originalTraceId` + `testRunId`).
+     */
     traceId: string | null;
+    /** Bitfab trace ID of the original (historical) trace being replayed. */
+    originalTraceId: string;
+    /** External span ID the recorded inputs were read from (the original root span). */
+    originalSpanId: string;
+    /** @deprecated alias for {@link ReplayItem.originalTraceId}. */
+    sourceTraceId: string;
+    /** @deprecated alias for {@link ReplayItem.originalSpanId}. */
+    sourceSpanId: string;
     /** Deserialized inputs from the original trace. */
     input: unknown[];
     /** The result returned by the function during replay, or undefined on error. */
@@ -1192,6 +1312,12 @@ declare class Bitfab {
     private readonly httpClient;
     private readonly bamlClient;
     private readonly dbSnapshot;
+    /**
+     * Mock overrides registered via {@link Bitfab.registerMockOverride}, applied
+     * to every `replay` on this client (after any per-call `mockOverride`). In
+     * registration order; first matcher wins within this list.
+     */
+    private readonly mockOverrides;
     /**
      * Initialize the Bitfab client.
      *
@@ -1499,6 +1625,30 @@ declare class Bitfab {
      *   determines how many traces replay.
      * @returns ReplayResult with items, testRunId, and testRunUrl
      */
+    /**
+     * Register a mock override applied to every subsequent `replay` on this
+     * client, so downstream real code runs against a value you supply for the
+     * matched span. Instance-scoped (no global state); call {@link clearMockOverrides}
+     * to reset. Per-call `replay({ mockOverride })` overrides take precedence, and
+     * both take precedence over the base `mock` strategy.
+     *
+     * ```ts
+     * // Object form (value is a flat value here)
+     * bitfab.registerMockOverride({
+     *   match: (node) => node.traceFunctionKey === "classify-intent",
+     *   value: { label: "refund" },
+     * })
+     * // Ordered form (equivalent); value may also be a function of the context
+     * bitfab.registerMockOverride(
+     *   (node) => node.traceFunctionKey === "classify-intent",
+     *   ({ inputs }) => ({ label: "refund" }),
+     * )
+     * ```
+     */
+    registerMockOverride(override: MockOverride): void;
+    registerMockOverride(match: NodeMatcher, value: MockValue): void;
+    /** Remove all overrides registered via {@link registerMockOverride}. */
+    clearMockOverrides(): void;
     replay<TReturn>(traceFunctionKey: string, fn: (...args: any[]) => TReturn | Promise<TReturn>, options?: ReplayOptions): Promise<ReplayResult<TReturn>>;
 }
 /**
@@ -1649,7 +1799,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.28.11";
+declare const __version__ = "0.29.1";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1717,4 +1867,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 CapturedSpan, 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 ReplayProgress, type ReplayResult, SUPPORTED_PROVIDERS, type SpanLookup, 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, getCurrentSpan, getCurrentTrace, reportReplayProgress };
+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 CapturedSpan, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, type MockOverride, type MockOverrideCtx, type MockStrategy, type MockValue, type NodeMatcher, type ProviderDefinition, ReplayEnvironment, type ReplayEnvironmentSnapshot, 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, getCurrentSpan, getCurrentTrace, reportReplayProgress };

package/dist/index.d.ts

@@ -73,6 +73,76 @@ declare class BitfabError extends Error {
     constructor(message: string, url?: string | undefined);
 }
 
+/**
+ * Selective mock overrides for replay.
+ *
+ * A mock override injects a custom value into a specific span (node) during
+ * replay: the matched span short-circuits its real execution and returns the
+ * value you supply, so downstream real code runs against the substituted
+ * output. This is a third mock mode alongside "run real code" and "replay
+ * recorded output" (see {@link MockStrategy}).
+ *
+ * The matcher and value are deliberately separate so matching stays cheap
+ * (structural metadata only, no output fetch) and the recorded output is
+ * fetched lazily - and only if the value function actually asks for it via
+ * {@link MockOverrideCtx.getOriginalOutput}.
+ */
+/**
+ * Structural identity of a span during replay, passed to a {@link NodeMatcher}.
+ * Carries no output payload - matching must not depend on the recorded output,
+ * so the output fetch stays lazy and gated.
+ */
+interface SpanNodeMeta {
+    /** The `withSpan` key of the executing span (its code-side identity). */
+    traceFunctionKey: string;
+    /** Resolved span name: `options.name ?? fn.name ?? traceFunctionKey`. */
+    spanName: string;
+    /** Span type, e.g. "llm", "agent", "tool", "custom". */
+    type: string;
+    /**
+     * The id of this span in the original (replayed) trace, when it exists in
+     * that trace's tree. Undefined when the live span has no recorded
+     * counterpart (e.g. a span the changed code newly introduced).
+     */
+    originalSpanId?: string;
+}
+/** Context passed to a {@link MockValue} function for a matched span. */
+interface MockOverrideCtx {
+    /** The matched span's structural metadata. */
+    node: SpanNodeMeta;
+    /** The live replay args passed to the wrapped function this run. */
+    inputs: unknown[];
+    /**
+     * Lazily fetch this span's ORIGINAL recorded output (deserialized). The fetch
+     * happens only when called and is memoized per replay item, so a purely flat
+     * override that never calls it triggers zero output round trips. Rejects if
+     * the span has no recorded counterpart. Being async, it is only usable for
+     * spans wrapping async functions.
+     */
+    getOriginalOutput: () => Promise<unknown>;
+}
+/** Selects which spans an override applies to. Runs on structural metadata. */
+type NodeMatcher = (node: SpanNodeMeta) => boolean;
+/** The function form of {@link MockValue}, receiving the override context. */
+type MockValueFn = (ctx: MockOverrideCtx) => unknown | Promise<unknown>;
+/**
+ * The value injected for a matched span: either a flat value used as-is, or a
+ * function of the {@link MockOverrideCtx} that returns one (or a Promise of
+ * one). Full replacement - the value IS the span's output, no merge with the
+ * recorded output.
+ *
+ * The flat side is spelled out (rather than `unknown`) so an inline function
+ * still gets a typed `ctx`: `unknown | Fn` would collapse to `unknown` and drop
+ * the contextual type. To inject a value that is itself a function, wrap it:
+ * `value: () => theFunction`.
+ */
+type MockValue = MockValueFn | string | number | boolean | bigint | symbol | object | null | undefined;
+/** One (match, value) pair. */
+interface MockOverride {
+    match: NodeMatcher;
+    value: MockValue;
+}
+
 /**
  * HTTP client utilities for Bitfab API requests.
  *
@@ -654,6 +724,15 @@ interface ReplayOptions {
      * - "all": every child withSpan returns historical output
      */
     mock?: MockStrategy;
+    /**
+     * Selective mock overrides: inject custom values into specific spans during
+     * replay, so downstream real code runs against the substituted output. Each
+     * override is a `{ match, value }` pair; the first matcher that
+     * matches a span wins. These take precedence over any overrides registered on
+     * the client via `registerMockOverride`, and over the base `mock` strategy - a
+     * span no override matches falls back to that strategy. See {@link MockOverride}.
+     */
+    mockOverride?: MockOverride | MockOverride[];
     /**
      * Per-trace environment. When the source trace carries a DB branching
      * snapshot, the SDK populates `environment.databaseUrl` before invoking
@@ -706,6 +785,21 @@ interface ReplayOptions {
 }
 /** Running totals reported to {@link ReplayOptions.onProgress} as replay proceeds. */
 interface ReplayProgress {
+    /**
+     * 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.
+     */
+    type?: "item" | "complete";
+    /**
+     * 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.
+     */
+    result?: ReplayResult<unknown>;
     /** Test run ID created for this replay. */
     testRunId?: string;
     /** Items that have finished so far, whether they succeeded or errored. */
@@ -717,18 +811,25 @@ interface ReplayProgress {
     /** Of the completed items, how many threw (their `item.error` is set). */
     errored: number;
     /**
-     * The single item that just settled to produce this event. `traceId` is the
-     * source (historical) trace that was replayed (so a UI can identify or link
-     * it); `error` is its replay error, or null when it ran ok; `durationMs` is how
-     * long this one trace took to replay. Lets a progress UI show per-trace
-     * pass/fail and timing as the run streams, without waiting for the full
-     * {@link ReplayResult}.
+     * The single item that just settled 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
+     * ran ok; `durationMs` is how long this one trace took to replay. Lets a
+     * progress UI show per-trace pass/fail and timing as the run streams, without
+     * waiting for the full {@link ReplayResult}.
      */
     item?: {
-        /** Source (historical) trace ID being replayed. */
-        traceId: string | null;
-        /** Local SDK replay trace ID, before the server maps it to a row ID. */
-        replayTraceId?: string | null;
+        /** 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. */
+        originalTraceId: string | null;
+        /** External span ID the recorded inputs were read from (the original root span). */
+        originalSpanId?: string | null;
+        /** @deprecated alias for `originalTraceId`. */
+        sourceTraceId: string | null;
+        /** @deprecated alias for `originalSpanId`. */
+        sourceSpanId?: string | null;
         /** Deserialized inputs from the original trace. */
         input?: unknown[];
         /** The result returned by the replayed function, or undefined on error. */
@@ -768,9 +869,13 @@ declare const BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
 declare function reportReplayProgress(progress: ReplayProgress): void;
 /** Per-trace context passed to {@link ReplayOptions.adaptInputs}. */
 interface AdaptContext {
-    /** Bitfab trace ID of the historical trace being replayed. */
-    traceId: string;
+    /** Bitfab trace ID of the original (historical) trace being replayed. */
+    originalTraceId: string;
     /** External span ID the recorded inputs were read from. */
+    originalSpanId: string;
+    /** @deprecated alias for {@link AdaptContext.originalTraceId}. */
+    sourceTraceId: string;
+    /** @deprecated alias for {@link AdaptContext.originalSpanId}. */
     sourceSpanId: string;
 }
 /**
@@ -786,8 +891,23 @@ interface AdaptContext {
  */
 type AdaptInputsFn = (inputs: unknown[], ctx: AdaptContext) => unknown[];
 interface ReplayItem<T> {
-    /** Trace ID of the new trace created during replay. */
+    /**
+     * Server trace ID of the new replay trace this item produced. Written in by
+     * `replay()` from the complete-replay response once the server has minted the
+     * trace row; the client-side id used to correlate spans during the run is
+     * never surfaced here. Null until completion, on older servers that omit the
+     * mapping, or if the item produced no trace. Not the verdict-persistence key:
+     * that is the original-trace lineage (`originalTraceId` + `testRunId`).
+     */
     traceId: string | null;
+    /** Bitfab trace ID of the original (historical) trace being replayed. */
+    originalTraceId: string;
+    /** External span ID the recorded inputs were read from (the original root span). */
+    originalSpanId: string;
+    /** @deprecated alias for {@link ReplayItem.originalTraceId}. */
+    sourceTraceId: string;
+    /** @deprecated alias for {@link ReplayItem.originalSpanId}. */
+    sourceSpanId: string;
     /** Deserialized inputs from the original trace. */
     input: unknown[];
     /** The result returned by the function during replay, or undefined on error. */
@@ -1192,6 +1312,12 @@ declare class Bitfab {
     private readonly httpClient;
     private readonly bamlClient;
     private readonly dbSnapshot;
+    /**
+     * Mock overrides registered via {@link Bitfab.registerMockOverride}, applied
+     * to every `replay` on this client (after any per-call `mockOverride`). In
+     * registration order; first matcher wins within this list.
+     */
+    private readonly mockOverrides;
     /**
      * Initialize the Bitfab client.
      *
@@ -1499,6 +1625,30 @@ declare class Bitfab {
      *   determines how many traces replay.
      * @returns ReplayResult with items, testRunId, and testRunUrl
      */
+    /**
+     * Register a mock override applied to every subsequent `replay` on this
+     * client, so downstream real code runs against a value you supply for the
+     * matched span. Instance-scoped (no global state); call {@link clearMockOverrides}
+     * to reset. Per-call `replay({ mockOverride })` overrides take precedence, and
+     * both take precedence over the base `mock` strategy.
+     *
+     * ```ts
+     * // Object form (value is a flat value here)
+     * bitfab.registerMockOverride({
+     *   match: (node) => node.traceFunctionKey === "classify-intent",
+     *   value: { label: "refund" },
+     * })
+     * // Ordered form (equivalent); value may also be a function of the context
+     * bitfab.registerMockOverride(
+     *   (node) => node.traceFunctionKey === "classify-intent",
+     *   ({ inputs }) => ({ label: "refund" }),
+     * )
+     * ```
+     */
+    registerMockOverride(override: MockOverride): void;
+    registerMockOverride(match: NodeMatcher, value: MockValue): void;
+    /** Remove all overrides registered via {@link registerMockOverride}. */
+    clearMockOverrides(): void;
     replay<TReturn>(traceFunctionKey: string, fn: (...args: any[]) => TReturn | Promise<TReturn>, options?: ReplayOptions): Promise<ReplayResult<TReturn>>;
 }
 /**
@@ -1649,7 +1799,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.28.11";
+declare const __version__ = "0.29.1";
 
 /**
  * Constants for the Bitfab SDK.
@@ -1717,4 +1867,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 CapturedSpan, 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 ReplayProgress, type ReplayResult, SUPPORTED_PROVIDERS, type SpanLookup, 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, getCurrentSpan, getCurrentTrace, reportReplayProgress };
+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 CapturedSpan, type CodeChangeFile, type CurrentSpan, type CurrentTrace, DEFAULT_SERVICE_URL, type DbSnapshotConfig, type DbSnapshotProvider, type DbSnapshotRef, type DetachedTrace, type MockOverride, type MockOverrideCtx, type MockStrategy, type MockValue, type NodeMatcher, type ProviderDefinition, ReplayEnvironment, type ReplayEnvironmentSnapshot, 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, getCurrentSpan, getCurrentTrace, reportReplayProgress };

package/dist/index.js

@@ -14,12 +14,12 @@ import {
   flushTraces,
   getCurrentSpan,
   getCurrentTrace
-} from "./chunk-ZBWTCBVQ.js";
+} from "./chunk-RTPEBWVO.js";
 import {
   BITFAB_PROGRESS_PREFIX,
   BitfabError,
   reportReplayProgress
-} from "./chunk-5E4BUIYA.js";
+} from "./chunk-YZU6WFG2.js";
 export {
   BITFAB_PROGRESS_PREFIX,
   Bitfab,