bitfab 0.68.1 → 0.68.3

package/dist/{index-BQV7zzJx.d.cts → index-D1heoBkv.d.cts}

@@ -461,6 +461,12 @@ interface ReplayContext {
   fetchSpanOutput?: (externalSpanId: string) => Promise<unknown>;
   /** Internal framework state captured on the historical root span. */
   integrationFixtures?: Map<string, unknown>;
+  /**
+   * The final state of a streamed framework run replayed from this item's
+   * root, set by the framework integration so a drained stream replays to
+   * the same result its recording did.
+   */
+  streamResult?: unknown;
   dbBranchLease?: DbBranchLease;
   /**
    * Server-measured provisioning timings for this item's branch, echoed back
@@ -2323,6 +2329,7 @@ interface ActiveSpanContext$1 {
  */
 declare class BitfabLangGraphCallbackHandler {
   name: string;
+  awaitHandlers: boolean;
   ignoreRetry: boolean;
   ignoreRetriever: boolean;
   ignoreCustomEvent: boolean;
@@ -2334,6 +2341,9 @@ declare class BitfabLangGraphCallbackHandler {
   private readonly captureTools;
   private runToSpan;
   private invocations;
+  private claimedToolCalls;
+  private stepRunIdByNamespace;
+  private namespaceByStepRunId;
   constructor(config: {
     apiKey?: ApiKeyInput;
     traceFunctionKey: string;
@@ -2357,6 +2367,21 @@ declare class BitfabLangGraphCallbackHandler {
    * `close()` owns the worker's lifetime.
    */
   close(timeoutMs?: number): Promise<boolean>;
+  /**
+   * Mark a tool call as recorded by the LangGraph integration, so this
+   * handler does not also record it. Returns the function that releases it.
+   * @internal
+   */
+  claimToolCall(traceId: string, toolCallId: string): () => void;
+  /**
+   * The span ID of the running graph step with this checkpoint namespace,
+   * when it is a recorded span in the given trace.
+   * @internal
+   */
+  visibleStepSpanId(checkpointNamespace: string, traceId: string): string | null;
+  private isClaimedToolCall;
+  private rememberStep;
+  private forgetStep;
   private startSpan;
   private completeSpan;
   private sendSpan;
@@ -2370,7 +2395,7 @@ declare class BitfabLangGraphCallbackHandler {
   handleLLMEnd(output: Record<string, unknown>, runId: string): Promise<void>;
   handleLLMError(error: unknown, runId: string): Promise<void>;
   handleLLMNewToken(): Promise<void>;
-  handleToolStart(tool: Record<string, unknown> | null | undefined, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
+  handleToolStart(tool: Record<string, unknown> | null | undefined, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string, toolCallId?: string): Promise<void>;
   handleToolEnd(output: unknown, runId: string): Promise<void>;
   handleToolError(error: unknown, runId: string): Promise<void>;
   handleRetrieverStart(retriever: Record<string, unknown> | null | undefined, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
@@ -2378,6 +2403,13 @@ declare class BitfabLangGraphCallbackHandler {
   handleRetrieverError(error: unknown, runId: string): Promise<void>;
 }
 //#endregion
+//#region src/langgraphRuns.d.ts
+interface InstrumentableGraph {
+  invoke(input: unknown, config?: unknown): Promise<unknown>;
+  stream(input: unknown, config?: unknown): Promise<AsyncIterable<unknown>>;
+  withConfig(config: Record<string, unknown>): InstrumentableGraph;
+}
+//#endregion
 //#region src/langgraphIntegration.d.ts
 interface SpanClient {
   withSpan<TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: {
@@ -2388,6 +2420,7 @@ interface SpanClient {
     finalize?: (result: unknown) => unknown | Promise<unknown>;
     surface?: "inherit";
     instrumentation?: "langgraph";
+    frameworkParentSpanId?: string;
   }, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
 }
 interface LangGraphTool {
@@ -2402,6 +2435,56 @@ interface LangGraphRunnable<TInput, TConfig, TReturn> {
     callbacks: unknown[];
   }): ConfiguredLangGraphRunnable<TInput, TConfig, TReturn>;
 }
+/**
+ * The agent returned by the integration's `createAgent()` and
+ * `createDeepAgent()`: the framework's own agent with `invoke` and `stream`
+ * traced. Its state is typed loosely because the framework packages are
+ * optional; pass the framework's own agent type as the builder's type
+ * argument to keep its exact types.
+ *
+ * @experimental This API may change before it is stable.
+ */
+interface BitfabLangGraphAgent {
+  invoke(input: unknown, config?: Record<string, unknown>): Promise<any>;
+  stream(input: unknown, config?: Record<string, unknown>): Promise<AsyncIterable<any>>;
+  streamEvents(input: unknown, config: Record<string, unknown>, streamOptions?: Record<string, unknown>): AsyncIterable<any>;
+  batch(inputs: unknown[], config?: Record<string, unknown> | Record<string, unknown>[]): Promise<any[]>;
+  withConfig(config: Record<string, unknown>): BitfabLangGraphAgent;
+  getState(config: Record<string, unknown>): Promise<unknown>;
+}
+/** The active Bitfab span, as the integration needs it. @internal */
+interface LangGraphActiveSpan {
+  traceId: string;
+  rootTraceFunctionKey: string;
+  isRoot: boolean;
+}
+interface AgentToolCallRequest {
+  toolCall: {
+    id?: string;
+    name: string;
+    args?: unknown;
+  };
+  runtime?: {
+    configurable?: Record<string, unknown>;
+  };
+}
+type AgentToolCallHandler<TRequest extends AgentToolCallRequest> = (request: TRequest) => unknown;
+/**
+ * A LangChain agent middleware that routes each tool call through the
+ * integration. Pass it in `createAgent({ middleware: [...] })` or
+ * `createDeepAgent({ middleware: [...] })`.
+ *
+ * @experimental This API may change before it is stable.
+ */
+interface BitfabAgentMiddleware {
+  readonly name: string;
+  wrapToolCall<TRequest extends AgentToolCallRequest>(request: TRequest, handler: AgentToolCallHandler<TRequest>): Promise<any>;
+}
+interface AgentParams {
+  middleware?: readonly unknown[];
+  subagents?: readonly unknown[];
+  [key: string]: unknown;
+}
 /**
  * Options for first-class LangGraph ToolNode replay interception.
  *
@@ -2428,12 +2511,82 @@ declare class BitfabLangGraphIntegration {
   private readonly client;
   private readonly traceFunctionKey;
   private readonly mockToolsOnReplay;
+  private readonly getActiveSpan;
+  private readonly getTraceRootContexts;
+  private agentMiddleware;
+  private runHost;
   constructor(config: {
     client: SpanClient;
     traceFunctionKey: string;
     callbackHandler: BitfabLangGraphCallbackHandler;
     options?: LangGraphIntegrationOptions;
+    getActiveSpan?: () => LangGraphActiveSpan | null;
+    getTraceRootContexts?: () => Record<string, unknown>[] | null;
   });
+  /**
+   * LangChain agent middleware that makes each tool call a replayable span
+   * under the agent's `tools` step. Pass it in `createAgent({ middleware })`
+   * or `createDeepAgent({ middleware })` and run the agent through
+   * {@link instrument}. {@link createAgent} and {@link createDeepAgent} add it
+   * for you.
+   *
+   * @experimental This API may change before it is stable.
+   */
+  get middleware(): BitfabAgentMiddleware;
+  /**
+   * Trace a compiled graph or agent as this trace function. Returns the same
+   * graph, so it can be used anywhere the graph can (called directly, nested
+   * as a node, or exported to LangGraph Platform), with every way of running
+   * it traced: `invoke`, `stream`, `streamEvents`, and `batch`. Each attaches
+   * the Bitfab callback handler and records the run as a replayable root
+   * span carrying the graph input, with the final graph state as its output.
+   * `withConfig` returns a graph that stays traced, and every other property
+   * is the graph's own.
+   *
+   * When the graph has a checkpointer and the run has a `thread_id`, the
+   * thread's checkpoint at the start of the run is recorded too, and replay
+   * runs against that checkpoint in memory instead of the graph's own
+   * checkpointer. Inside a `withTrace()` root, under any trace function key,
+   * the checkpoint is recorded on that trace's root, and any run of the graph
+   * during a replay uses an in-memory checkpointer.
+   *
+   * Replay a recorded run through any run method, for example
+   * `bitfab.replay(key, (input) => agent.invoke(input))` or
+   * `bitfab.replay(key, (input) => agent.stream(input))`; a streamed replay
+   * is drained and its result is the final graph state.
+   *
+   * @experimental This API may change before it is stable.
+   */
+  instrument<TGraph extends InstrumentableGraph>(graph: TGraph): TGraph;
+  private get graphRunHost();
+  /**
+   * Build a LangChain Deep Agents agent traced as this trace function: a
+   * drop-in for `createDeepAgent` from `deepagents`. Every parameter is passed
+   * through unchanged, except that `middleware` and each declarative
+   * subagent's `middleware` gain {@link middleware}, so the tool calls of the
+   * main agent and its subagents are replayable spans. Subagents given as a
+   * compiled `runnable` or a remote `graphId` pass through as they are.
+   * Returns the agent wrapped by {@link instrument}.
+   *
+   * @experimental This API may change before it is stable.
+   */
+  createDeepAgent<TAgent = BitfabLangGraphAgent>(params?: AgentParams): Promise<TAgent>;
+  /**
+   * Build a LangChain `createAgent` agent traced as this trace function: a
+   * drop-in for `createAgent` from `langchain`. Every parameter is passed
+   * through unchanged, except that `middleware` gains {@link middleware}.
+   * Returns the agent wrapped by {@link instrument}.
+   *
+   * @experimental This API may change before it is stable.
+   */
+  createAgent<TAgent = BitfabLangGraphAgent>(params: AgentParams): Promise<TAgent>;
+  private withMiddleware;
+  private withSubagentMiddleware;
+  private interceptToolCall;
+  private stepSpanIdFor;
+  private recordingTraceId;
+  private runClaimedToolCall;
+  private shouldMock;
   /**
    * Wrap tools before passing the same returned array to both
    * `model.bindTools()` and `new ToolNode()`. Each invocation becomes an
@@ -2445,7 +2598,7 @@ declare class BitfabLangGraphIntegration {
    * callback handler, preserves invocation config, and records only the graph
    * input as the replayable root input.
    *
-   * @experimental This API may change before it is stable.
+   * @deprecated Use `instrument(graph).invoke`, which also traces `stream`.
    */
   createInvoker<TInput, TConfig, TReturn>(graph: LangGraphRunnable<TInput, TConfig, TReturn>): (input: TInput, config?: TConfig) => TReturn;
   private wrapTool;
@@ -3552,14 +3705,6 @@ 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.
@@ -3722,7 +3867,9 @@ interface SpanOptions {
    * tees internally) does not disturb the caller's own consumption. For the
    * Vercel AI SDK shape, pass the prebuilt `finalizers.aiSdk` helper.
    *
-   * Ignored for async-generator results, which are captured automatically.
+   * 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 }`.
    */
   finalize?: (result: any) => unknown | Promise<unknown>;
 }
@@ -4035,6 +4182,23 @@ declare class Bitfab {
    * @experimental This API may change before it is stable.
    */
   getLangGraphIntegration(traceFunctionKey: string, options?: LangGraphIntegrationOptions): BitfabLangGraphIntegration;
+  /**
+   * Get the LangGraph integration for a LangChain Deep Agents agent. Alias of
+   * {@link getLangGraphIntegration}, named for Deep Agents: build the agent
+   * with its `createDeepAgent()`, which takes the same parameters as
+   * `createDeepAgent` from `deepagents`.
+   *
+   * ```typescript
+   * const integration = client.getDeepAgentsIntegration("research-agent")
+   * const agent = await integration.createDeepAgent({ model, tools, subagents })
+   * await agent.invoke({ messages: [{ role: "user", content: "..." }] })
+   * ```
+   *
+   * @param traceFunctionKey - Groups traces under this key in Bitfab
+   * @param options - Controls which tools are marked for replay mocking
+   * @experimental This API may change before it is stable.
+   */
+  getDeepAgentsIntegration(traceFunctionKey: string, options?: LangGraphIntegrationOptions): BitfabLangGraphIntegration;
   /**
    * Get the first-class Rivet actor/workflow-context integration for an
    * existing trace root. The integration binds context and records effect
@@ -4541,6 +4705,15 @@ declare class BitfabFunction {
    * @experimental This API may change before it is stable.
    */
   getLangGraphIntegration(options?: LangGraphIntegrationOptions): BitfabLangGraphIntegration;
+  /**
+   * Get the LangChain Deep Agents integration bound to this key. Build the
+   * agent with its `createDeepAgent()`, which takes the same parameters as
+   * `createDeepAgent` from `deepagents`.
+   *
+   * @param options - Controls which tools are marked for replay mocking
+   * @experimental This API may change before it is stable.
+   */
+  getDeepAgentsIntegration(options?: LangGraphIntegrationOptions): BitfabLangGraphIntegration;
   /**
    * Get the first-class Rivet actor-context integration bound to this key.
    * Use its `bind()` or `withContext()` outside this handle's `withTrace()`
@@ -4611,7 +4784,7 @@ interface CommitRef {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.68.1";
+declare const __version__ = "0.68.3";
 //#endregion
 //#region src/constants.d.ts
 /**
@@ -4753,4 +4926,4 @@ declare function seedFromRegistry(registry: ReplayRegistry, pipeline: string, ca
   run?: boolean;
 }): Promise<SeedResult>;
 //#endregion
-export { ReplayBranch as $, ExperimentRollup as $n, MockOverrideResolver as $r, TraceLabels as $t, SpanMethodDecoratorContext as A, ScenarioAction as An, VercelGenerateResult as Ar, GraderLabelSource as At, ActiveSpanContext as B, TraceAssertionsResult as Bn, SaveCategoryParams as Br, HumanLabelOutcome as Bt, NodeMethodDecorator as C, SaveAssertionsParams as Cn, RerunGradersResult as Cr, BitfabLangGraphIntegration as Ct, SeedCaseOptions as D, SaveScenarioParams as Dn, BitfabLanguageModelMiddleware as Dr, GetGraderVerdictsParams as Dt, ReseedResult as E, SaveScenarioHistoryEntry as En, UpdateDatasetParams as Er, GetGraderLabelsParams as Et, WrappedBamlFn as F, ScenarioHistoryEntry as Fn, AssertionCategorySummary as Fr, GraderVerdictUpdate as Ft, SpanListField as G, TraceTarget as Gn, SpanOccurrence as Gr, LabelConfidence as Gt, TraceResponse as H, TraceSearchFilters as Hn, CodeChangeFile as Hr, HumanVerdictOutcome as Ht, getCurrentReplayBranch as I, ScenarioSource as In, CategoriesClient as Ir, GradersClient as It, SpansClient as J, Experiment as Jn, flushTraces as Jr, LabelStatus as Jt, SpanListParams as K, TraceTargetOccurrence as Kn, SpanType as Kr, LabelOutcome as Kt, getCurrentSpan as L, ScenarioTrigger as Ln, Category as Lr, ArchiveLabelTarget as Lt, WrapBAMLOptions as M, ScenarioData as Mn, BitfabClaudeAgentHandler as Mr, GraderVerdict as Mt, WrapJevOptions as N, ScenarioDataAppend as Nn, AssertionCategoriesClient as Nr, GraderVerdictOutcome as Nt, SeedRunOptions as O, SavedTraceAssertion as On, BitfabVercelAiHandler as Or, GraderLabel as Ot, WrapOpenRouterOptions as P, ScenarioDataOrigin as Pn, AssertionCategory as Pr, GraderVerdictSource as Pt, RivetIntegrationOptions as Q, ExperimentPage as Qn, MockOverrideInput as Qr, PassFailVerdict as Qt, getCurrentTrace as R, TraceAssertion as Rn, CategorySummary as Rr, ArchiveVerdictTarget as Rt, DetachedTrace as S, JustificationSpan as Si, SaveAssertionsAllParams as Sn, RerunGradersOptions as Sr, BitfabOpenAIAgentHandler as St, ReseedOptions as T, SaveScenarioData as Tn, SaveDatasetResult as Tr, BitfabLangGraphCallbackHandler as Tt, TracingProcessor as U, TraceSearchParams as Un, HttpClient as Ur, HumanVerdictUpdate as Ut, BitfabOpenAITracingProcessor as V, TraceAssertionsUpdate as Vn, CapturedSpan as Vr, HumanLabelUpdate as Vt, ListedSpan as W, TraceSearchResult as Wn, SpanLookup as Wr, LabelAction as Wt, RivetContextLike as X, ExperimentCodeChangeTotals as Xn, MockOverride as Xr, LabelUpdate as Xt, BitfabRivetIntegration as Y, ExperimentCategoryTally as Yn, DbBranchTimings as Yr, LabelTarget as Yt, RivetEffectType as Z, ExperimentJitter as Zn, MockOverrideCtx as Zr, LabelsClient as Zt, BitfabConfig as _, ApprovalFields as _i, AssertionRewrite as _n, GraderRerunStatus as _r, serializeReplayResult as _t, ReplayRegistryOptions as a, MixedTracingError as ai, VerdictSource as an, ExperimentsClient as ar, MockStrategy as at, CurrentSpan as b, Assignee as bi, GenerateAssertionsOptions as bn, RemoveDatasetGradersResult as br, OrganizationMember as bt, SeedResult as c, DbSnapshotRef as ci, VerdictUpdate as cn, AddDatasetTracesResult as cr, ReplayItem as ct, seedFromRegistry as d, SelectiveReplayDecision as di, AssertionEvidenceParameter as dn, DatasetTraceIds as dr, ReplayOptions as dt, MockValue as ei, TraceVerdicts as en, ExperimentRollupResult as er, AdaptContext as et, finalizers as f, SelectiveReplayOptions as fi, AssertionGeneration as fn, DatasetsClient as fr, ReplayProgress as ft, Bitfab as g, ProviderDefinition as gi, AssertionLabelEvidence as gn, GraderRerunResult as gr, reportReplayProgress as gt, CommitRef as h, BamlExecutionResult as hi, AssertionGenerationTimeoutError as hn, GraderRerunProgress as hr, TraceIngestionType as ht, ReplayRegistryContext as i, BitfabError as ii, VerdictOutcome as in, ExperimentTotals as ir, DbBranchReplayError as it, SpanOptions as j, ScenarioActualOutcome as jn, VercelStreamResult as jr, GraderLabelUpdate as jt, SpanMethodDecorator as k, Scenario as kn, VercelCallParams as kr, GraderLabelOutcome as kt, defineReplayRegistry as l, SUPPORTED_PROVIDERS as li, VerdictsClient as ln, Dataset as lr, ReplayItemFinishProgress as lt, __version__ as m, AllowedEnvVars as mi, AssertionGenerationStatus as mn, GraderRerunError as mr, ReplayResult as mt, ReplayRegistration as n, NodeMatcher as ni, VerdictAction as nn, ExperimentStatus as nr, BITFAB_PROGRESS_PREFIX as nt, ReseedRegistryResult as o, DbSnapshotConfig as oi, VerdictStatus as on, ListExperimentsParams as or, ReplayError as ot, DEFAULT_SERVICE_URL as p, SelectiveReplayReport as pi, AssertionGenerationError as pn, GraderRerun as pr, ReplayProgressItem as pt, SpanListResult as q, TracesClient as qn, TokenUsage as qr, LabelSource as qt, ReplayRegistry as r, SpanNodeMeta as ri, VerdictConfidence as rn, ExperimentTally as rr, DbBranchOptions as rt, SeedCase as s, DbSnapshotProvider as si, VerdictTarget as sn, AddDatasetGradersResult as sr, ReplayExperiment as st, ReplayOptionsFactory as t, NO_MOCK_OVERRIDE as ti, Verdict as tn, ExperimentRunBy as tr, AdaptInputsFn as tt, reseedFromRegistry as u, ReplayNodeIdentity as ui, ArchiveAssertionsParams as un, DatasetGraderRef as ur, ReplayItemStartProgress as ut, BitfabFunction as v, ApprovalState as vi, AssertionRewriteStatus as vn, GraderRerunTimeoutError as vr, ReplayInterrupt as vt, NodeOptions as w, SaveScenarioActualOutcome as wn, SaveDatasetParams as wr, LangGraphIntegrationOptions as wt, CurrentTrace as x, Justification as xi, SaveAssertion as xn, RemoveDatasetTracesResult as xr, OrganizationMembersClient as xt, CaptureWhen as y, Approver as yi, AssertionVerdictEvidence as yn, ListDatasetsParams as yr, ReplayInterruptSignal as yt, CaptureSurface as z, TraceAssertionSource as zn, SaveAssertionCategoryParams as zr, AssertionVerdict as zt };
+export { ReplayBranch as $, ExperimentJitter as $n, MockOverrideCtx as $r, LabelsClient as $t, SpanMethodDecoratorContext as A, SavedTraceAssertion as An, BitfabVercelAiHandler as Ar, GraderLabel as At, ActiveSpanContext as B, TraceAssertion as Bn, CategorySummary as Br, ArchiveVerdictTarget as Bt, NodeMethodDecorator as C, Justification as Ci, SaveAssertion as Cn, RemoveDatasetTracesResult as Cr, BitfabAgentMiddleware as Ct, SeedCaseOptions as D, SaveScenarioData as Dn, SaveDatasetResult as Dr, BitfabLangGraphCallbackHandler as Dt, ReseedResult as E, SaveScenarioActualOutcome as En, SaveDatasetParams as Er, LangGraphIntegrationOptions as Et, WrappedBamlFn as F, ScenarioDataAppend as Fn, AssertionCategoriesClient as Fr, GraderVerdictOutcome as Ft, SpanListField as G, TraceSearchParams as Gn, HttpClient as Gr, HumanVerdictUpdate as Gt, TraceResponse as H, TraceAssertionsResult as Hn, SaveCategoryParams as Hr, HumanLabelOutcome as Ht, getCurrentReplayBranch as I, ScenarioDataOrigin as In, AssertionCategory as Ir, GraderVerdictSource as It, SpansClient as J, TraceTargetOccurrence as Jn, SpanType as Jr, LabelOutcome as Jt, SpanListParams as K, TraceSearchResult as Kn, SpanLookup as Kr, LabelAction as Kt, getCurrentSpan as L, ScenarioHistoryEntry as Ln, AssertionCategorySummary as Lr, GraderVerdictUpdate as Lt, WrapBAMLOptions as M, ScenarioAction as Mn, VercelGenerateResult as Mr, GraderLabelSource as Mt, WrapJevOptions as N, ScenarioActualOutcome as Nn, VercelStreamResult as Nr, GraderLabelUpdate as Nt, SeedRunOptions as O, SaveScenarioHistoryEntry as On, UpdateDatasetParams as Or, GetGraderLabelsParams as Ot, WrapOpenRouterOptions as P, ScenarioData as Pn, BitfabClaudeAgentHandler as Pr, GraderVerdict as Pt, RivetIntegrationOptions as Q, ExperimentCodeChangeTotals as Qn, MockOverride as Qr, LabelUpdate as Qt, getCurrentTrace as R, ScenarioSource as Rn, CategoriesClient as Rr, GradersClient as Rt, DetachedTrace as S, Assignee as Si, GenerateAssertionsOptions as Sn, RemoveDatasetGradersResult as Sr, BitfabOpenAIAgentHandler as St, ReseedOptions as T, SaveAssertionsParams as Tn, RerunGradersResult as Tr, BitfabLangGraphIntegration as Tt, TracingProcessor as U, TraceAssertionsUpdate as Un, CapturedSpan as Ur, HumanLabelUpdate as Ut, BitfabOpenAITracingProcessor as V, TraceAssertionSource as Vn, SaveAssertionCategoryParams as Vr, AssertionVerdict as Vt, ListedSpan as W, TraceSearchFilters as Wn, CodeChangeFile as Wr, HumanVerdictOutcome as Wt, RivetContextLike as X, Experiment as Xn, flushTraces as Xr, LabelStatus as Xt, BitfabRivetIntegration as Y, TracesClient as Yn, TokenUsage as Yr, LabelSource as Yt, RivetEffectType as Z, ExperimentCategoryTally as Zn, DbBranchTimings as Zr, LabelTarget as Zt, BitfabConfig as _, BamlExecutionResult as _i, AssertionGenerationTimeoutError as _n, GraderRerunProgress as _r, serializeReplayResult as _t, ReplayRegistryOptions as a, SpanNodeMeta as ai, VerdictConfidence as an, ExperimentTally as ar, MockStrategy as at, CurrentSpan as b, ApprovalState as bi, AssertionRewriteStatus as bn, GraderRerunTimeoutError as br, OrganizationMember as bt, SeedResult as c, DbSnapshotConfig as ci, VerdictStatus as cn, ListExperimentsParams as cr, ReplayItem as ct, seedFromRegistry as d, SUPPORTED_PROVIDERS as di, VerdictsClient as dn, Dataset as dr, ReplayOptions as dt, MockOverrideInput as ei, PassFailVerdict as en, ExperimentPage as er, AdaptContext as et, finalizers as f, ReplayNodeIdentity as fi, ArchiveAssertionsParams as fn, DatasetGraderRef as fr, ReplayProgress as ft, Bitfab as g, AllowedEnvVars as gi, AssertionGenerationStatus as gn, GraderRerunError as gr, reportReplayProgress as gt, CommitRef as h, SelectiveReplayReport as hi, AssertionGenerationError as hn, GraderRerun as hr, TraceIngestionType as ht, ReplayRegistryContext as i, NodeMatcher as ii, VerdictAction as in, ExperimentStatus as ir, DbBranchReplayError as it, SpanOptions as j, Scenario as jn, VercelCallParams as jr, GraderLabelOutcome as jt, SpanMethodDecorator as k, SaveScenarioParams as kn, BitfabLanguageModelMiddleware as kr, GetGraderVerdictsParams as kt, defineReplayRegistry as l, DbSnapshotProvider as li, VerdictTarget as ln, AddDatasetGradersResult as lr, ReplayItemFinishProgress as lt, __version__ as m, SelectiveReplayOptions as mi, AssertionGeneration as mn, DatasetsClient as mr, ReplayResult as mt, ReplayRegistration as n, MockValue as ni, TraceVerdicts as nn, ExperimentRollupResult as nr, BITFAB_PROGRESS_PREFIX as nt, ReseedRegistryResult as o, BitfabError as oi, VerdictOutcome as on, ExperimentTotals as or, ReplayError as ot, DEFAULT_SERVICE_URL as p, SelectiveReplayDecision as pi, AssertionEvidenceParameter as pn, DatasetTraceIds as pr, ReplayProgressItem as pt, SpanListResult as q, TraceTarget as qn, SpanOccurrence as qr, LabelConfidence as qt, ReplayRegistry as r, NO_MOCK_OVERRIDE as ri, Verdict as rn, ExperimentRunBy as rr, DbBranchOptions as rt, SeedCase as s, MixedTracingError as si, VerdictSource as sn, ExperimentsClient as sr, ReplayExperiment as st, ReplayOptionsFactory as t, MockOverrideResolver as ti, TraceLabels as tn, ExperimentRollup as tr, AdaptInputsFn as tt, reseedFromRegistry as u, DbSnapshotRef as ui, VerdictUpdate as un, AddDatasetTracesResult as ur, ReplayItemStartProgress as ut, BitfabFunction as v, ProviderDefinition as vi, AssertionLabelEvidence as vn, GraderRerunResult as vr, ReplayInterrupt as vt, NodeOptions as w, JustificationSpan as wi, SaveAssertionsAllParams as wn, RerunGradersOptions as wr, BitfabLangGraphAgent as wt, CurrentTrace as x, Approver as xi, AssertionVerdictEvidence as xn, ListDatasetsParams as xr, OrganizationMembersClient as xt, CaptureWhen as y, ApprovalFields as yi, AssertionRewrite as yn, GraderRerunStatus as yr, ReplayInterruptSignal as yt, CaptureSurface as z, ScenarioTrigger as zn, Category as zr, ArchiveLabelTarget as zt };