@bitfab/sdk 0.75.0 → 0.76.1

package/dist/{index-V6ECPulQ.d.cts → index-BYv4DSsY.d.cts}

@@ -4123,6 +4123,22 @@ interface WrapOpenAIResponsesOptions<TResponse> {
   /** Called after each call with the OpenAI response, for the caller's own usage or cost reporting. */
   onResponse?: (response: TResponse) => void;
 }
+interface WrapOpenAIChatOptions<TResponse> {
+  /** Called after each call with the chat completion, for the caller's own usage or cost reporting. */
+  onResponse?: (response: TResponse) => void;
+}
+interface WrapOpenAIEmbeddingsOptions<TResponse> {
+  /** Called after each call with the embedding list, for the caller's own usage or cost reporting. */
+  onResponse?: (response: TResponse) => void;
+}
+interface WrapOpenAITranscriptionsOptions<TResponse> {
+  /** Called after each call with the transcription, for the caller's own usage or cost reporting. */
+  onResponse?: (response: TResponse) => void;
+}
+interface WrapGeminiOptions<TResponse> {
+  /** Called after each call with the Gemini response, for the caller's own usage or cost reporting. */
+  onResponse?: (response: TResponse) => void;
+}
 interface WrapBAMLOptions {
   /** Called after each BAML invocation with the Collector instance. */
   onCollector?: (collector: unknown) => void;
@@ -4143,6 +4159,13 @@ interface CurrentSpan {
   readonly id: string;
   /** The trace ID for the current span. */
   readonly traceId: string;
+  /**
+   * The keys of every trace function running at this point, outermost first,
+   * each listed once. A trace function called inside another one comes after
+   * it, including a `withTrace` root that started its own trace, so a cost
+   * recorded here can be counted toward each of them. Empty outside a trace.
+   */
+  readonly traceFunctionKeys: readonly string[];
   /**
    * Add a context entry to this span. Each call appends to the contexts array.
    * Context entries are stored in span_data.contexts as [{key, value}, ...].
@@ -4194,6 +4217,14 @@ interface DetachedTrace {
  * A handle to the current active trace, allowing trace-level context to be set.
  */
 interface CurrentTrace {
+  /**
+   * The key of the trace function the current trace is stored under: the one
+   * that started it. A `withSpan` or `getFunction` call inside another trace
+   * function joins that trace, so it reports the outer key. A `withTrace` root
+   * inside another root starts its own trace, so it reports its own key. Empty
+   * string outside a trace.
+   */
+  readonly traceFunctionKey: string;
   /**
    * Set the session ID for this trace. Stored in the database session_id column.
    */
@@ -4221,6 +4252,14 @@ interface CurrentTrace {
    */
   drop(): void;
 }
+/**
+ * Get a handle to the current active span.
+ *
+ * Call this from inside a traced function (wrapped with `withSpan`) to get
+ * a span handle that allows adding context at runtime.
+ *
+ * Returns a no-op object if called outside of a span context (methods do nothing).
+ */
 declare function getCurrentSpan(): CurrentSpan;
 /**
  * Get the database branch the current replay item is running against.
@@ -4386,6 +4425,9 @@ interface SpanOptions {
    * For an async-generator result, `finalize` receives the array of yielded
    * values once iteration completes, and its return is recorded instead of
    * the default `{ yielded, return }`.
+   *
+   * On a node placed directly on a streamed LLM client call, `finalize` is not
+   * used: the span records the assembled stream and its usage instead.
    */
   finalize?: (result: any) => unknown | Promise<unknown>;
 }
@@ -4433,6 +4475,13 @@ interface TraceOptions {
   mockOnReplayDefault?: boolean;
   /** Maximum number of recorded descendant levels. Defaults to 30. */
   maxDepth?: number;
+  /**
+   * Maximum number of automatically captured descendant spans. Defaults to
+   * 500. Declared nodes and LLM calls (BAML, Jev, and the provider client
+   * calls the build transform records) do not count toward it and are still
+   * recorded past it, so the trace's token usage and cost stay complete;
+   * `maxDepth` still applies to them.
+   */
   maxCapturedSubtreeSpans?: number;
   /** Qualified or simple function names to leave out of the subtree. */
   exclude?: readonly string[] | ReadonlySet<string>;
@@ -4862,11 +4911,14 @@ declare class Bitfab {
    * `cachedInputTokens`, `reasoningTokens`, `costUsd` (OpenRouter's
    * `usage.cost`), and `durationMs`; fields the response omits are left out.
    *
-   * Beneath a `withTrace()` root, each `.chat.completions.create(...)` call in
-   * code compiled by the build transform, on a client whose base URL is
-   * `openrouter.ai`, is recorded without this wrapper as its own `llm` span,
-   * and a `wrapOpenRouter` around such a call records nothing more. Streaming
-   * calls (`stream: true`) are not recorded.
+   * Beneath a `withTrace()` root, each `.chat.completions.create(...)` and
+   * `.chat.completions.parse(...)` call in code compiled by the build
+   * transform, on a client whose base URL is `openrouter.ai`, is recorded
+   * without this wrapper as its own `llm` span, and a `wrapOpenRouter` around
+   * such a call records nothing more. Beneath a root, streamed calls
+   * (`stream: true` or `.chat.completions.stream(...)`) are recorded too, when
+   * the stream finishes; the wrapper itself never records a stream. For a
+   * client on any other base URL, use `wrapOpenAIChat`.
    *
    * ```typescript
    * const openai = new OpenAI({ baseURL: "https://openrouter.ai/api/v1", apiKey })
@@ -4899,11 +4951,13 @@ declare class Bitfab {
    * `outputTokens`, `cachedInputTokens` (cache reads), and `durationMs`;
    * fields the response omits are left out.
    *
-   * Beneath a `withTrace()` root, each `.messages.create(...)` call on an
-   * `@anthropic-ai/sdk` client in code compiled by the build transform is
-   * recorded without this wrapper as its own `llm` span, and a
-   * `wrapAnthropic` around such a call records nothing more. Streaming calls
-   * (`stream: true`) are not recorded.
+   * Beneath a `withTrace()` root, each `.messages.create(...)` and
+   * `.messages.parse(...)` call on an `@anthropic-ai/sdk` client in code
+   * compiled by the build transform is recorded without this wrapper as its
+   * own `llm` span, and a `wrapAnthropic` around such a call records nothing
+   * more. Beneath a root, streamed calls (`stream: true` or
+   * `.messages.stream(...)`) are recorded too, when the stream finishes; the
+   * wrapper itself never records a stream.
    *
    * ```typescript
    * const anthropic = new Anthropic()
@@ -4937,11 +4991,13 @@ declare class Bitfab {
    * when the response reports `usage.cost`), and `durationMs`; fields the
    * response omits are left out.
    *
-   * Beneath a `withTrace()` root, each `.responses.create(...)` call on an
-   * `openai` client in code compiled by the build transform is recorded
-   * without this wrapper as its own `llm` span, and a `wrapOpenAIResponses`
-   * around such a call records nothing more. Streaming calls (`stream: true`)
-   * are not recorded.
+   * Beneath a `withTrace()` root, each `.responses.create(...)` and
+   * `.responses.parse(...)` call on an `openai` client in code compiled by the
+   * build transform is recorded without this wrapper as its own `llm` span,
+   * and a `wrapOpenAIResponses` around such a call records nothing more.
+   * Beneath a root, streamed calls (`stream: true` or
+   * `.responses.stream(...)`) are recorded too, when the stream finishes; the
+   * wrapper itself never records a stream.
    *
    * ```typescript
    * const openai = new OpenAI()
@@ -4956,6 +5012,167 @@ declare class Bitfab {
    * @returns An async function with the same signature that records each call
    */
   wrapOpenAIResponses<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAIResponsesOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a chat completion to the OpenAI API, or to any
+   * OpenAI-compatible base URL other than OpenRouter, to record the call's
+   * prompt, model, token usage, and duration. Bitfab works out the cost from
+   * the model and token counts.
+   *
+   * Like `wrapOpenRouter`, it opens no span of its own. It writes into the
+   * span that is current when the call starts, so call it inside a traced
+   * function. The wrapped function must return the chat completion, as
+   * `openai.chat.completions.create` and `openai.chat.completions.parse` do.
+   * When its first argument is the request, the request's messages become the
+   * span's prompt. One context entry holds `provider` (`"openai"`), `model`,
+   * `upstreamProvider`, `inputTokens`, `outputTokens`, `cachedInputTokens`,
+   * `reasoningTokens`,
+   * `costUsd` (only when the response reports `usage.cost`), and
+   * `durationMs`; fields the response omits are left out.
+   *
+   * Beneath a `withTrace()` root, each `.chat.completions.create(...)` and
+   * `.chat.completions.parse(...)` call on an `openai` client in code
+   * compiled by the build transform is recorded without this wrapper as its
+   * own `llm` span, and a `wrapOpenAIChat` around such a call records nothing
+   * more. Beneath a root, streamed calls (`stream: true` or
+   * `.chat.completions.stream(...)`) are recorded too, when the stream
+   * finishes, and carry usage only when the request sets
+   * `stream_options: { include_usage: true }`; the wrapper itself never
+   * records a stream.
+   *
+   * ```typescript
+   * const openai = new OpenAI()
+   * const complete = client.wrapOpenAIChat(
+   *   openai.chat.completions.create.bind(openai.chat.completions),
+   * )
+   * const response = await complete({
+   *   model: "gpt-5-mini",
+   *   messages: [{ role: "user", content: text }],
+   * })
+   * ```
+   *
+   * @param method - A named function that sends the request and returns the chat completion
+   * @param options - `onResponse` is called with each chat completion after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapOpenAIChat<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAIChatOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a request to the OpenAI Embeddings API to
+   * record the call's input, model, token usage, and duration. Bitfab works
+   * out the cost from the model and token counts.
+   *
+   * Like `wrapOpenRouter`, it opens no span of its own. It writes into the
+   * span that is current when the call starts, so call it inside a traced
+   * function. The wrapped function must return the embedding list, as
+   * `openai.embeddings.create` does. When its first argument is the request,
+   * the request's `input` becomes the span's prompt. One context entry holds
+   * `provider` (`"openai"`), `model`, `upstreamProvider`, `inputTokens`,
+   * `outputTokens` (always 0), `costUsd` (only when the response reports
+   * `usage.cost`), and `durationMs`; fields the response omits are left out.
+   * The wrapper cannot see the client's base URL, so `provider` is
+   * `"openai"` even for an OpenRouter client.
+   *
+   * Beneath a `withTrace()` root, each `.embeddings.create(...)` call on an
+   * `openai` client in code compiled by the build transform is recorded
+   * without this wrapper as its own `llm` span (with `provider`
+   * `"openrouter"` when the client's base URL is `openrouter.ai`), and a
+   * `wrapOpenAIEmbeddings` around such a call records nothing more.
+   *
+   * ```typescript
+   * const openai = new OpenAI()
+   * const embed = client.wrapOpenAIEmbeddings(
+   *   openai.embeddings.create.bind(openai.embeddings),
+   * )
+   * const embeddings = await embed({
+   *   model: "text-embedding-3-small",
+   *   input: text,
+   * })
+   * ```
+   *
+   * @param method - A named function that sends the request and returns the embedding list
+   * @param options - `onResponse` is called with each embedding list after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapOpenAIEmbeddings<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAIEmbeddingsOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a request to the OpenAI audio transcription
+   * API to record the call's model, usage, and duration. Bitfab works out the
+   * cost from the model and token counts, so models billed by duration, such
+   * as `whisper-1`, record no cost.
+   *
+   * Like `wrapOpenRouter`, it opens no span of its own. It writes into the
+   * span that is current when the call starts, so call it inside a traced
+   * function. The wrapped function must return the transcription, as
+   * `openai.audio.transcriptions.create` does. When its first argument is the
+   * request, the request's `prompt` becomes the span's prompt. One context
+   * entry holds `provider` (`"openai"`), `model`, `inputTokens` and
+   * `outputTokens` (for models billed by token, such as `gpt-4o-transcribe`),
+   * `audioSeconds` (for models billed by duration, such as `whisper-1`), and
+   * `durationMs`; fields the response omits are left out.
+   *
+   * Beneath a `withTrace()` root, each `.audio.transcriptions.create(...)`
+   * call on an `openai` client in code compiled by the build transform is
+   * recorded without this wrapper as its own `llm` span, and a
+   * `wrapOpenAITranscriptions` around such a call records nothing more.
+   * Beneath a root, streamed calls (`stream: true`) are recorded too, when
+   * the stream finishes; the wrapper itself never records a stream.
+   *
+   * ```typescript
+   * const openai = new OpenAI()
+   * const transcribe = client.wrapOpenAITranscriptions(
+   *   openai.audio.transcriptions.create.bind(openai.audio.transcriptions),
+   * )
+   * const transcription = await transcribe({
+   *   model: "gpt-4o-transcribe",
+   *   file: fs.createReadStream("call.mp3"),
+   * })
+   * ```
+   *
+   * @param method - A named function that sends the request and returns the transcription
+   * @param options - `onResponse` is called with each transcription after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapOpenAITranscriptions<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAITranscriptionsOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a request to the Gemini API through
+   * `@google/genai` to record the call's prompt, model, token usage, and
+   * duration. Bitfab works out the cost from the model and token counts.
+   *
+   * Like `wrapOpenRouter`, it opens no span of its own. It writes into the
+   * span that is current when the call starts, so call it inside a traced
+   * function. The wrapped function must return the response, as
+   * `ai.models.generateContent` does. When its first argument is the request,
+   * the request's `config.systemInstruction` and `contents` become the span's
+   * prompt. One context entry holds `provider` (`"gemini"`), `model` (the
+   * response's `modelVersion`, else the requested model), `inputTokens`
+   * (prompt and tool-use prompt tokens), `outputTokens` (candidate and
+   * thinking tokens), `cachedInputTokens`, `reasoningTokens` (thinking
+   * tokens), and `durationMs`; fields the response omits are left out.
+   *
+   * Beneath a `withTrace()` root, each `.models.generateContent(...)` call on
+   * an `@google/genai` client in code compiled by the build transform is
+   * recorded without this wrapper as its own `llm` span, and a `wrapGemini`
+   * around such a call records nothing more. Beneath a root,
+   * `.models.generateContentStream(...)` calls are recorded too, when the
+   * stream finishes; the wrapper itself never records a stream.
+   *
+   * `ai.models.generateContent` has no function name of its own, so a wrapper
+   * around an unnamed function is named `generateContent`, which is the name
+   * `withNode` targets.
+   *
+   * ```typescript
+   * const ai = new GoogleGenAI({ apiKey })
+   * const generate = client.wrapGemini(ai.models.generateContent)
+   * const response = await generate({
+   *   model: "gemini-2.5-flash",
+   *   contents: text,
+   * })
+   * ```
+   *
+   * @param method - A named function that sends the request and returns the response
+   * @param options - `onResponse` is called with each response after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapGemini<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapGeminiOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
   private wrapClientCall;
   /**
    * Wrap a function to automatically create a span for its inputs and outputs.
@@ -5405,6 +5622,58 @@ declare class BitfabFunction {
    * @returns An async function with the same signature that records each call
    */
   wrapOpenAIResponses<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAIResponsesOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a chat completion to the OpenAI API to record
+   * the call's prompt, model, token usage, and duration. Delegates to the
+   * parent client's wrapOpenAIChat method.
+   *
+   * Like `wrapJev`, it does not use the bound key and opens no span of its
+   * own: it writes into the span that is current when the call starts.
+   *
+   * @param method - A named function that sends the request and returns the chat completion
+   * @param options - `onResponse` is called with each chat completion after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapOpenAIChat<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAIChatOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a request to the OpenAI Embeddings API to
+   * record the call's input, model, token usage, and duration. Delegates to
+   * the parent client's wrapOpenAIEmbeddings method.
+   *
+   * Like `wrapJev`, it does not use the bound key and opens no span of its
+   * own: it writes into the span that is current when the call starts.
+   *
+   * @param method - A named function that sends the request and returns the embedding list
+   * @param options - `onResponse` is called with each embedding list after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapOpenAIEmbeddings<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAIEmbeddingsOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a request to the OpenAI audio transcription
+   * API to record the call's model, usage, and duration. Delegates to the
+   * parent client's wrapOpenAITranscriptions method.
+   *
+   * Like `wrapJev`, it does not use the bound key and opens no span of its
+   * own: it writes into the span that is current when the call starts.
+   *
+   * @param method - A named function that sends the request and returns the transcription
+   * @param options - `onResponse` is called with each transcription after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapOpenAITranscriptions<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapOpenAITranscriptionsOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
+  /**
+   * Wrap a function that sends a request to the Gemini API to record the
+   * call's prompt, model, token usage, and duration. Delegates to the parent
+   * client's wrapGemini method.
+   *
+   * Like `wrapJev`, it does not use the bound key and opens no span of its
+   * own: it writes into the span that is current when the call starts.
+   *
+   * @param method - A named function that sends the request and returns the response
+   * @param options - `onResponse` is called with each response after it is recorded
+   * @returns An async function with the same signature that records each call
+   */
+  wrapGemini<TArgs extends unknown[], TResponse>(method: (...args: TArgs) => TResponse | Promise<TResponse>, options?: WrapGeminiOptions<TResponse>): (...args: TArgs) => Promise<TResponse>;
 }
 //#endregion
 //#region src/commitRef.d.ts
@@ -5425,7 +5694,7 @@ interface CommitRef {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.75.0";
+declare const __version__ = "0.76.1";
 //#endregion
 //#region src/constants.d.ts
 /**
@@ -5567,4 +5836,4 @@ declare function seedFromRegistry(registry: ReplayRegistry, pipeline: string, ca
   run?: boolean;
 }): Promise<SeedResult>;
 //#endregion
-export { RivetEffectType as $, ScenarioSource as $n, VercelStreamResult as $r, LabelSource as $t, SpanMethodDecoratorContext as A, DbSnapshotRef as Ai, AssertionVerdictEvidence as An, AddDatasetTracesResult as Ar, LangGraphIntegrationOptions as At, getCurrentTrace as B, ApprovalState as Bi, SavedTraceAssertion as Bn, GraderRerunTimeoutError as Br, GraderVerdictSource as Bt, NodeMethodDecorator as C, NO_MOCK_OVERRIDE as Ci, AssertionGenerationError as Cn, ExperimentSummaryFacts as Cr, PiIntegrationOptions as Ct, SeedCaseOptions as D, MixedTracingError as Di, AssertionLabelEvidence as Dn, ExperimentsClient as Dr, BitfabAgentMiddleware as Dt, ReseedResult as E, BitfabError as Ei, AssertionKind as En, ExperimentTotals as Er, BitfabOpenAIAgentHandler as Et, WrapOpenAIResponsesOptions as F, SelectiveReplayReport as Fi, SaveAssertionsParams as Fn, GraderRerun as Fr, GraderLabelOutcome as Ft, TracingProcessor as G, ScenarioData as Gn, RerunGradersResult as Gr, AssertionVerdict as Gt, ActiveSpanContext as H, Assignee as Hi, ScenarioAction as Hn, RemoveDatasetGradersResult as Hr, GradersClient as Ht, WrapOpenRouterOptions as I, AllowedEnvVars as Ii, SaveScenarioActualOutcome as In, GraderRerunError as Ir, GraderLabelSource as It, SpanListParams as J, ScenarioDataSources as Jn, UpdateDatasetParams as Jr, HumanVerdictOutcome as Jt, ListedSpan as K, ScenarioDataAppend as Kn, SaveDatasetParams as Kr, HumanLabelOutcome as Kt, WrappedBamlFn as L, BamlExecutionResult as Li, SaveScenarioData as Ln, GraderRerunProgress as Lr, GraderLabelUpdate as Lt, WrapAnthropicOptions as M, ReplayNodeIdentity as Mi, GenerateScenarioOptions as Mn, DatasetGraderRef as Mr, GetGraderLabelsParams as Mt, WrapBAMLOptions as N, SelectiveReplayDecision as Ni, SaveAssertion as Nn, DatasetTraceIds as Nr, GetGraderVerdictsParams as Nt, SeedRunOptions as O, DbSnapshotConfig as Oi, AssertionRewrite as On, ListExperimentsParams as Or, BitfabLangGraphAgent as Ot, WrapJevOptions as P, SelectiveReplayOptions as Pi, SaveAssertionsAllParams as Pn, DatasetsClient as Pr, GraderLabel as Pt, RivetContextLike as Q, ScenarioRecordInput as Qn, VercelGenerateResult as Qr, LabelOutcome as Qt, getCurrentReplayBranch as R, ProviderDefinition as Ri, SaveScenarioHistoryEntry as Rn, GraderRerunResult as Rr, GraderVerdict as Rt, DetachedTrace as S, MockValue as Si, AssertionGeneration as Sn, ExperimentSummaryExampleTrace as Sr, BitfabPiIntegration as St, ReseedOptions as T, SpanNodeMeta as Ti, AssertionGenerationTimeoutError as Tn, ExperimentTally as Tr, OrganizationMembersClient as Tt, BitfabOpenAITracingProcessor as U, Justification as Ui, ScenarioActualOutcome as Un, RemoveDatasetTracesResult as Ur, ArchiveLabelTarget as Ut, CaptureSurface as V, Approver as Vi, Scenario as Vn, ListDatasetsParams as Vr, GraderVerdictUpdate as Vt, TraceResponse as W, JustificationSpan as Wi, ScenarioCreationStatus as Wn, RerunGradersOptions as Wr, ArchiveVerdictTarget as Wt, SpansClient as X, ScenarioHistoryEntry as Xn, BitfabVercelAiHandler as Xr, LabelAction as Xt, SpanListResult as Y, ScenarioGeneration as Yn, BitfabLanguageModelMiddleware as Yr, HumanVerdictUpdate as Yt, BitfabRivetIntegration as Z, ScenarioRecord as Zn, VercelCallParams as Zr, LabelConfidence as Zt, BitfabConfig as _, DbBranchTimings as _i, VerdictsClient as _n, ExperimentRollupResult as _r, TraceIngestionType as _t, ReplayRegistryOptions as a, Category as ai, TraceLabels as an, TraceSearchFilters as ar, DbBranchOptions as at, CurrentSpan as b, MockOverrideInput as bi, AssertionCodeDraft as bn, ExperimentSummary as br, ReplayInterrupt as bt, SeedResult as c, SaveCategoryParams as ci, VerdictAction as cn, TraceTarget as cr, ReplayError as ct, seedFromRegistry as d, HttpClient as di, VerdictEvidenceItem as dn, Experiment as dr, ReplayItemFinishProgress as dt, BitfabClaudeAgentHandler as ei, LabelStatus as en, ScenarioTrigger as er, RivetIntegrationOptions as et, finalizers as f, SpanLookup as fi, VerdictOutcome as fn, ExperimentCategoryTally as fr, ReplayItemStartProgress as ft, Bitfab as g, flushTraces as gi, VerdictUpdate as gn, ExperimentRollup as gr, ReplayResult as gt, CommitRef as h, TokenUsage as hi, VerdictTarget as hn, ExperimentPage as hr, ReplayProgressItem as ht, ReplayRegistryContext as i, CategoriesClient as ii, PassFailVerdict as in, TraceAssertionsUpdate as ir, BITFAB_PROGRESS_PREFIX as it, SpanOptions as j, SUPPORTED_PROVIDERS as ji, GenerateAssertionsOptions as jn, Dataset as jr, BitfabLangGraphCallbackHandler as jt, SpanMethodDecorator as k, DbSnapshotProvider as ki, AssertionRewriteStatus as kn, AddDatasetGradersResult as kr, BitfabLangGraphIntegration as kt, defineReplayRegistry as l, CapturedSpan as li, VerdictConfidence as ln, TraceTargetOccurrence as lr, ReplayExperiment as lt, __version__ as m, SpanType as mi, VerdictStatus as mn, ExperimentJitter as mr, ReplayProgress as mt, ReplayRegistration as n, AssertionCategory as ni, LabelUpdate as nn, TraceAssertionSource as nr, AdaptContext as nt, ReseedRegistryResult as o, CategorySummary as oi, TraceVerdicts as on, TraceSearchParams as or, DbBranchReplayError as ot, DEFAULT_SERVICE_URL as p, SpanOccurrence as pi, VerdictSource as pn, ExperimentCodeChangeTotals as pr, ReplayOptions as pt, SpanListField as q, ScenarioDataOrigin as qn, SaveDatasetResult as qr, HumanLabelUpdate as qt, ReplayRegistry as r, AssertionCategorySummary as ri, LabelsClient as rn, TraceAssertionsResult as rr, AdaptInputsFn as rt, SeedCase as s, SaveAssertionCategoryParams as si, Verdict as sn, TraceSearchResult as sr, MockStrategy as st, ReplayOptionsFactory as t, AssertionCategoriesClient as ti, LabelTarget as tn, TraceAssertion as tr, ReplayBranch as tt, reseedFromRegistry as u, CodeChangeFile as ui, VerdictEvidence as un, TracesClient as ur, ReplayItem as ut, BitfabFunction as v, MockOverride as vi, ArchiveAssertionsParams as vn, ExperimentRunBy as vr, reportReplayProgress as vt, NodeOptions as w, NodeMatcher as wi, AssertionGenerationStatus as wn, ExperimentSummaryResult as wr, OrganizationMember as wt, CurrentTrace as x, MockOverrideResolver as xi, AssertionEvidenceParameter as xn, ExperimentSummaryBeforeAfter as xr, ReplayInterruptSignal as xt, CaptureWhen as y, MockOverrideCtx as yi, AssertionCode as yn, ExperimentStatus as yr, serializeReplayResult as yt, getCurrentSpan as z, ApprovalFields as zi, SaveScenarioParams as zn, GraderRerunStatus as zr, GraderVerdictOutcome as zt };
+export { SpanListResult as $, ScenarioGeneration as $n, BitfabLanguageModelMiddleware as $r, HumanVerdictUpdate as $t, SpanMethodDecoratorContext as A, BitfabError as Ai, AssertionKind as An, ExperimentTotals as Ar, BitfabOpenAIAgentHandler as At, WrapOpenRouterOptions as B, AllowedEnvVars as Bi, SaveScenarioActualOutcome as Bn, GraderRerunError as Br, GraderLabelSource as Bt, NodeMethodDecorator as C, MockOverrideCtx as Ci, AssertionCode as Cn, ExperimentStatus as Cr, serializeReplayResult as Ct, SeedCaseOptions as D, NO_MOCK_OVERRIDE as Di, AssertionGenerationError as Dn, ExperimentSummaryFacts as Dr, PiIntegrationOptions as Dt, ReseedResult as E, MockValue as Ei, AssertionGeneration as En, ExperimentSummaryExampleTrace as Er, BitfabPiIntegration as Et, WrapJevOptions as F, SUPPORTED_PROVIDERS as Fi, GenerateAssertionsOptions as Fn, Dataset as Fr, BitfabLangGraphCallbackHandler as Ft, CaptureSurface as G, Approver as Gi, Scenario as Gn, ListDatasetsParams as Gr, GraderVerdictUpdate as Gt, getCurrentReplayBranch as H, ProviderDefinition as Hi, SaveScenarioHistoryEntry as Hn, GraderRerunResult as Hr, GraderVerdict as Ht, WrapOpenAIChatOptions as I, ReplayNodeIdentity as Ii, GenerateScenarioOptions as In, DatasetGraderRef as Ir, GetGraderLabelsParams as It, TraceResponse as J, JustificationSpan as Ji, ScenarioCreationStatus as Jn, RerunGradersOptions as Jr, ArchiveVerdictTarget as Jt, ActiveSpanContext as K, Assignee as Ki, ScenarioAction as Kn, RemoveDatasetGradersResult as Kr, GradersClient as Kt, WrapOpenAIEmbeddingsOptions as L, SelectiveReplayDecision as Li, SaveAssertion as Ln, DatasetTraceIds as Lr, GetGraderVerdictsParams as Lt, WrapAnthropicOptions as M, DbSnapshotConfig as Mi, AssertionRewrite as Mn, ListExperimentsParams as Mr, BitfabLangGraphAgent as Mt, WrapBAMLOptions as N, DbSnapshotProvider as Ni, AssertionRewriteStatus as Nn, AddDatasetGradersResult as Nr, BitfabLangGraphIntegration as Nt, SeedRunOptions as O, NodeMatcher as Oi, AssertionGenerationStatus as On, ExperimentSummaryResult as Or, OrganizationMember as Ot, WrapGeminiOptions as P, DbSnapshotRef as Pi, AssertionVerdictEvidence as Pn, AddDatasetTracesResult as Pr, LangGraphIntegrationOptions as Pt, SpanListParams as Q, ScenarioDataSources as Qn, UpdateDatasetParams as Qr, HumanVerdictOutcome as Qt, WrapOpenAIResponsesOptions as R, SelectiveReplayOptions as Ri, SaveAssertionsAllParams as Rn, DatasetsClient as Rr, GraderLabel as Rt, DetachedTrace as S, MockOverride as Si, ArchiveAssertionsParams as Sn, ExperimentRunBy as Sr, reportReplayProgress as St, ReseedOptions as T, MockOverrideResolver as Ti, AssertionEvidenceParameter as Tn, ExperimentSummaryBeforeAfter as Tr, ReplayInterruptSignal as Tt, getCurrentSpan as U, ApprovalFields as Ui, SaveScenarioParams as Un, GraderRerunStatus as Ur, GraderVerdictOutcome as Ut, WrappedBamlFn as V, BamlExecutionResult as Vi, SaveScenarioData as Vn, GraderRerunProgress as Vr, GraderLabelUpdate as Vt, getCurrentTrace as W, ApprovalState as Wi, SavedTraceAssertion as Wn, GraderRerunTimeoutError as Wr, GraderVerdictSource as Wt, ListedSpan as X, ScenarioDataAppend as Xn, SaveDatasetParams as Xr, HumanLabelOutcome as Xt, TracingProcessor as Y, ScenarioData as Yn, RerunGradersResult as Yr, AssertionVerdict as Yt, SpanListField as Z, ScenarioDataOrigin as Zn, SaveDatasetResult as Zr, HumanLabelUpdate as Zt, BitfabConfig as _, SpanOccurrence as _i, VerdictSource as _n, ExperimentCodeChangeTotals as _r, ReplayOptions as _t, ReplayRegistryOptions as a, AssertionCategoriesClient as ai, LabelTarget as an, TraceAssertion as ar, ReplayBranch as at, CurrentSpan as b, flushTraces as bi, VerdictUpdate as bn, ExperimentRollup as br, ReplayResult as bt, SeedResult as c, CategoriesClient as ci, PassFailVerdict as cn, TraceAssertionsUpdate as cr, BITFAB_PROGRESS_PREFIX as ct, seedFromRegistry as d, SaveAssertionCategoryParams as di, Verdict as dn, TraceSearchResult as dr, MockStrategy as dt, BitfabVercelAiHandler as ei, LabelAction as en, ScenarioHistoryEntry as er, SpansClient as et, finalizers as f, SaveCategoryParams as fi, VerdictAction as fn, TraceTarget as fr, ReplayError as ft, Bitfab as g, SpanLookup as gi, VerdictOutcome as gn, ExperimentCategoryTally as gr, ReplayItemStartProgress as gt, CommitRef as h, HttpClient as hi, VerdictEvidenceItem as hn, Experiment as hr, ReplayItemFinishProgress as ht, ReplayRegistryContext as i, BitfabClaudeAgentHandler as ii, LabelStatus as in, ScenarioTrigger as ir, RivetIntegrationOptions as it, SpanOptions as j, MixedTracingError as ji, AssertionLabelEvidence as jn, ExperimentsClient as jr, BitfabAgentMiddleware as jt, SpanMethodDecorator as k, SpanNodeMeta as ki, AssertionGenerationTimeoutError as kn, ExperimentTally as kr, OrganizationMembersClient as kt, defineReplayRegistry as l, Category as li, TraceLabels as ln, TraceSearchFilters as lr, DbBranchOptions as lt, __version__ as m, CodeChangeFile as mi, VerdictEvidence as mn, TracesClient as mr, ReplayItem as mt, ReplayRegistration as n, VercelGenerateResult as ni, LabelOutcome as nn, ScenarioRecordInput as nr, RivetContextLike as nt, ReseedRegistryResult as o, AssertionCategory as oi, LabelUpdate as on, TraceAssertionSource as or, AdaptContext as ot, DEFAULT_SERVICE_URL as p, CapturedSpan as pi, VerdictConfidence as pn, TraceTargetOccurrence as pr, ReplayExperiment as pt, BitfabOpenAITracingProcessor as q, Justification as qi, ScenarioActualOutcome as qn, RemoveDatasetTracesResult as qr, ArchiveLabelTarget as qt, ReplayRegistry as r, VercelStreamResult as ri, LabelSource as rn, ScenarioSource as rr, RivetEffectType as rt, SeedCase as s, AssertionCategorySummary as si, LabelsClient as sn, TraceAssertionsResult as sr, AdaptInputsFn as st, ReplayOptionsFactory as t, VercelCallParams as ti, LabelConfidence as tn, ScenarioRecord as tr, BitfabRivetIntegration as tt, reseedFromRegistry as u, CategorySummary as ui, TraceVerdicts as un, TraceSearchParams as ur, DbBranchReplayError as ut, BitfabFunction as v, SpanType as vi, VerdictStatus as vn, ExperimentJitter as vr, ReplayProgress as vt, NodeOptions as w, MockOverrideInput as wi, AssertionCodeDraft as wn, ExperimentSummary as wr, ReplayInterrupt as wt, CurrentTrace as x, DbBranchTimings as xi, VerdictsClient as xn, ExperimentRollupResult as xr, TraceIngestionType as xt, CaptureWhen as y, TokenUsage as yi, VerdictTarget as yn, ExperimentPage as yr, ReplayProgressItem as yt, WrapOpenAITranscriptionsOptions as z, SelectiveReplayReport as zi, SaveAssertionsParams as zn, GraderRerun as zr, GraderLabelOutcome as zt };