braintrust 3.30.0 → 3.31.0

package/dist/browser.d.mts

@@ -673,6 +673,9 @@ interface Score {
      */
     error?: unknown;
 }
+type SingleScore = Omit<Score, "name"> & {
+    name?: string;
+};
 
 declare const spanComponentsV4Schema: z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
     object_type: z.ZodNativeEnum<typeof SpanObjectTypeV3>;
@@ -25630,483 +25633,6 @@ declare function wrapLangSmithTraceable<T>(namespace: T): T;
 declare function wrapLangSmithRunTrees<T>(namespace: T): T;
 declare function wrapLangSmithClient<T>(namespace: T): T;
 
-type ScorerFunction<Output = unknown> = (args: {
-    output: Output;
-    expected?: unknown;
-    input?: unknown;
-    metadata?: Record<string, unknown>;
-}) => Score | Promise<Score> | number | null | Array<Score>;
-type ProgressEvent = {
-    type: "suite_start";
-    suiteName: string;
-} | {
-    type: "test_start";
-    testName: string;
-} | {
-    type: "test_complete";
-    testName: string;
-    passed: boolean;
-    duration: number;
-} | {
-    type: "suite_complete";
-    suiteName: string;
-    passed: number;
-    failed: number;
-};
-
-interface BraintrustTestConfig {
-    input?: unknown;
-    expected?: unknown;
-    metadata?: Record<string, unknown>;
-    tags?: string[];
-    scorers?: ScorerFunction[];
-    data?: Array<{
-        input?: unknown;
-        expected?: unknown;
-        metadata?: Record<string, unknown>;
-        tags?: string[];
-    }>;
-}
-interface TestConfig extends BraintrustTestConfig {
-    [key: string]: unknown;
-}
-type WithModifiers<T> = T & {
-    skip: T;
-    only: T;
-    concurrent: T;
-    todo: (name: string) => void;
-};
-type TestContext = Pick<BraintrustTestConfig, "input" | "expected" | "metadata">;
-type BaseTestFunction<VitestContext = unknown> = {
-    (name: string, fn: (context: VitestContext) => void | Promise<void>): void;
-    each?: <T>(cases: readonly T[]) => (name: string, fn: (context: T) => void | Promise<void>) => void;
-};
-type TestFunction<VitestContext = unknown> = WithModifiers<BaseTestFunction<VitestContext>>;
-type BaseDescribeFunction = {
-    (name: string, factory: () => void): void;
-    each?: <T>(cases: readonly T[]) => (name: string, factory: () => void) => void;
-};
-type DescribeFunction = WithModifiers<BaseDescribeFunction>;
-interface BaseWrappedTest<VitestContext = unknown> {
-    (name: string, fn: (context: VitestContext) => unknown | Promise<unknown>): void;
-    (name: string, config: TestConfig, fn: (context: TestContext & VitestContext) => unknown | Promise<unknown>): void;
-    each: <T>(cases: readonly T[]) => (name: string, fn: (context: T & TestContext & VitestContext) => unknown | Promise<unknown>) => void;
-}
-type WrappedTest<VitestContext = unknown> = WithModifiers<BaseWrappedTest<VitestContext>>;
-interface BaseWrappedDescribe {
-    (name: string, factory: () => void): void;
-    each: <T>(cases: readonly T[]) => (name: string, factory: () => void) => void;
-}
-type WrappedDescribe = WithModifiers<BaseWrappedDescribe>;
-interface VitestMethods<VitestContext = unknown, ExpectType extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> {
-    test: TestFunction<VitestContext>;
-    it?: TestFunction<VitestContext>;
-    expect: ExpectType;
-    describe: DescribeFunction;
-    beforeAll?: (fn: () => void | Promise<void>) => void;
-    afterAll?: (fn: () => void | Promise<void>) => void;
-    beforeEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
-    afterEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
-}
-interface BraintrustVitest<VitestContext = unknown, ExpectType extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> {
-    test: WrappedTest<VitestContext>;
-    it: WrappedTest<VitestContext>;
-    expect: ExpectType;
-    describe: WrappedDescribe;
-    beforeAll: (fn: () => void | Promise<void>) => void;
-    afterAll: (fn: () => void | Promise<void>) => void;
-    beforeEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
-    afterEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
-    logOutputs: (outputs: Record<string, unknown>) => void;
-    logFeedback: (feedback: {
-        name: string;
-        score: number;
-        metadata?: Record<string, unknown>;
-    }) => void;
-    getCurrentSpan: () => Span | null;
-    /**
-     * Helper function to flush the experiment and optionally display a summary.
-     * Use this in afterAll() instead of manually calling getExperimentContext().
-     *
-     * @param options - Optional configuration
-     * @param options.displaySummary - Whether to display the experiment summary (defaults to true)
-     */
-    flushExperiment: (options?: {
-        displaySummary?: boolean;
-    }) => Promise<void>;
-}
-interface WrapperConfig {
-    projectName?: string;
-    /**
-     * The id of the project to create experiments in. Takes precedence over
-     * `projectName` if both are set.
-     */
-    projectId?: string;
-    /**
-     * If true, displays a formatted experiment summary with scores and URL after the test suite completes.
-     * Defaults to true. Set to false to suppress the summary output.
-     */
-    displaySummary?: boolean;
-    /**
-     * Callback for real-time progress events.
-     * Called when tests start, complete, or progress updates occur.
-     * Progress reporting is always enabled when this callback is provided.
-     */
-    onProgress?: (event: ProgressEvent) => void;
-}
-
-/**
- * Wraps Vitest methods with Braintrust experiment tracking. This automatically creates
- * datasets and experiments from your Vitest tests, tracking pass/fail rates and evaluation metrics.
- * Experiments are automatically flushed after all tests complete.
- *
- * @param vitestMethods - Object containing Vitest methods (test, describe, expect, etc.)
- * @param config - Optional configuration object
- * @param config.projectName - Project name for the experiment (defaults to suite name)
- * @param config.displaySummary - If true, displays experiment summary after flushing (defaults to true)
- * @returns Wrapped Vitest methods with Braintrust experiment tracking
- *
- * @example Basic Usage
- * ```typescript
- * import * as vitest from "vitest";
- * import { wrapVitest } from 'braintrust';
- *
- * const {test, expect, describe } = wrapVitest(
- *   { projectName: 'my-project' }
- * );
- *
- * describe('Translation Tests', () => {
- *
- *   // Tests with input/expected are automatically added to the dataset
- *   test(
- *     'translates hello',
- *     {
- *       input: { text: 'hello' },
- *       expected: 'hola',
- *       metadata: { language: 'spanish' },
- *     },
- *     async ({ input, expected }) => {
- *       const result = await translate(input.text);
- *       bt.logOutputs({ translation: result });
- *       expect(result).toBe(expected);
- *     }
- *   );
- *
- *   // Tests without input/expected still run and track pass/fail
- *   test('basic functionality', async () => {
- *     const result = await someFunction();
- *     expect(result).toBeTruthy();
- *   });
- * });
- * ```
- *
- * @see README.md for full documentation and examples
- */
-declare function wrapVitest<VitestContext = unknown, ExpectType extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown>(vitestMethods: VitestMethods<VitestContext, ExpectType>, config?: WrapperConfig): BraintrustVitest<VitestContext, ExpectType>;
-
-/** Progress events emitted by the node-test integration. */
-type NodeTestProgressEvent = {
-    type: "test_start";
-    testName: string;
-} | {
-    type: "test_complete";
-    testName: string;
-    passed: boolean;
-    duration: number;
-};
-/**
- * Minimal test context interface compatible with node:test's TestContext.
- * We only use `name` from the context, making this compatible with any
- * test runner that provides a `{ name?: string }` context object.
- */
-interface MinimalTestContext {
-    name?: string;
-}
-/**
- * Configuration for `initNodeTestSuite()`.
- */
-interface NodeTestSuiteConfig {
-    /** Project name for the Braintrust experiment. */
-    projectName: string;
-    /** Optional experiment name. Defaults to a timestamp-based name. */
-    experimentName?: string;
-    /**
-     * If true, displays a formatted experiment summary after flushing.
-     * Defaults to true.
-     */
-    displaySummary?: boolean;
-    /**
-     * Pass `after` from `node:test` to auto-register a flush hook.
-     * When provided, `suite.flush()` is called automatically after all tests.
-     */
-    after?: (fn: () => void | Promise<void>) => void;
-    /**
-     * Callback for real-time progress events.
-     * Emits `test_start` and `test_complete` events.
-     */
-    onProgress?: (event: NodeTestProgressEvent) => void;
-}
-/**
- * Configuration for a single eval test case.
- */
-interface EvalConfig {
-    /** Test input data, logged to the span. */
-    input?: unknown;
-    /** Expected output, passed to scorers. */
-    expected?: unknown;
-    /** Custom metadata, logged to the span. */
-    metadata?: Record<string, unknown>;
-    /** Tags for organizing test cases. */
-    tags?: string[];
-    /** Scorer functions to evaluate the output. */
-    scorers?: ScorerFunction[];
-    /** Override span name (defaults to `t.name`, then `"unnamed test"`). */
-    name?: string;
-}
-/**
- * Context passed to the eval test function.
- */
-interface EvalContext {
-    input: unknown;
-    expected?: unknown;
-    metadata?: Record<string, unknown>;
-}
-/**
- * The public API surface returned by `initNodeTestSuite()`.
- */
-interface NodeTestSuite {
-    /**
-     * Creates a test function compatible with `node:test`.
-     * Pass the result to `test()` from `node:test`.
-     *
-     * @param config - Eval configuration (input, expected, scorers, etc.)
-     * @param fn - The test function. Its return value is logged as output and passed to scorers.
-     * @returns A function accepting a test context `t` from `node:test`.
-     */
-    eval(config: EvalConfig, fn: (context: EvalContext) => unknown | Promise<unknown>): (t: MinimalTestContext) => Promise<void>;
-    /**
-     * Flush the experiment: summarize results and send data to Braintrust.
-     * Called automatically if `after` was provided in the config.
-     */
-    flush(): Promise<void>;
-}
-
-/**
- * Creates a new Node.js test suite with Braintrust experiment tracking.
- *
- * @example
- * ```typescript
- * import { test, describe, after } from 'node:test';
- * import { initNodeTestSuite } from 'braintrust';
- *
- * describe('My Tests', () => {
- *   const suite = initNodeTestSuite({ projectName: 'my-project', after });
- *
- *   test('my eval', suite.eval(
- *     { input: 'hello', expected: 'world', scorers: [myScorer] },
- *     async ({ input }) => {
- *       return await myFunction(input);
- *     }
- *   ));
- * });
- * ```
- */
-declare function initNodeTestSuite(config: NodeTestSuiteConfig): NodeTestSuite;
-
-type LangChainSerialized = {
-    id?: unknown[];
-    name?: string;
-};
-type LangChainCallbackHandlerOptions<IsAsyncFlush extends boolean> = {
-    debug: boolean;
-    excludeMetadataProps: RegExp;
-    logger?: Logger<IsAsyncFlush> | Span;
-    parent?: Span | (() => Span);
-};
-type LangChainStartSpanArgs = StartSpanArgs & {
-    parentRunId?: string;
-    runId: string;
-};
-type LangChainEndSpanArgs = ExperimentLogPartialArgs & {
-    parentRunId?: string;
-    runId: string;
-    tags?: string[];
-};
-type LangChainLLMResult = {
-    generations?: unknown[];
-    llmOutput?: Record<string, unknown>;
-};
-
-declare const BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME = "BraintrustCallbackHandler";
-declare class BraintrustLangChainCallbackHandler<IsAsyncFlush extends boolean = true> {
-    name: string;
-    private spans;
-    private skippedRuns;
-    private parent?;
-    private rootRunId?;
-    private options;
-    private startTimes;
-    private firstTokenTimes;
-    private ttftMs;
-    constructor(options?: Partial<LangChainCallbackHandlerOptions<IsAsyncFlush>>);
-    protected startSpan({ runId, parentRunId, ...args }: LangChainStartSpanArgs): void;
-    protected endSpan({ runId, parentRunId, tags, metadata, ...args }: LangChainEndSpanArgs): void;
-    handleLLMStart(llm: LangChainSerialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
-    handleLLMError(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleLLMEnd(output: LangChainLLMResult, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleChatModelStart(llm: LangChainSerialized, messages: unknown[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
-    handleChainStart(chain: LangChainSerialized, inputs: unknown, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string, runName?: string): Promise<void>;
-    handleChainError(err: Error, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
-        inputs?: Record<string, unknown>;
-    }): Promise<void>;
-    handleChainEnd(outputs: unknown, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
-        inputs?: Record<string, unknown>;
-    }): Promise<void>;
-    handleToolStart(tool: LangChainSerialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
-    handleToolError(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleToolEnd(output: unknown, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleAgentAction(action: Record<string, unknown>, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleAgentEnd(action: unknown, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleRetrieverStart(retriever: LangChainSerialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, name?: string): Promise<void>;
-    handleRetrieverEnd(documents: unknown[], runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleRetrieverError(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
-    handleLLMNewToken(_token: string, _idx: {
-        prompt: number;
-        completion: number;
-    }, runId: string, _parentRunId?: string, _tags?: string[]): Promise<void>;
-}
-
-interface BuildContext {
-    getFunctionId(functionObj: unknown): Promise<FunctionIdType>;
-}
-interface Node {
-    readonly id: string;
-    __type: "node";
-    build(context: BuildContext): Promise<GraphNodeType>;
-    addDependency(dependency: Dependency): void;
-}
-type NodeLike = Node | Prompt<boolean, boolean> | ProxyVariable;
-type LazyGraphNode = {
-    type: "lazy";
-    id: string;
-};
-declare class GraphBuilder {
-    private nodes;
-    private edges;
-    private nodeLikeNodes;
-    readonly IN: InputNode;
-    readonly OUT: OutputNode;
-    constructor();
-    build(context: BuildContext): Promise<GraphDataType>;
-    addEdge({ source, sourceVar, target, targetVar, expr, purpose, }: {
-        source: NodeLike;
-        sourceVar?: string;
-        target: NodeLike;
-        targetVar?: string;
-        expr?: string;
-        purpose: GraphEdgeType["purpose"];
-    }): void;
-    resolveNode(node: NodeLike): [Node, string[]];
-    literal<T>(value: T): LiteralNode<T>;
-    gate(options: {
-        condition: string;
-    }): GateNode;
-    aggregator(): AggregatorNode;
-    promptTemplate(options: {
-        prompt: PromptBlockDataType;
-    }): PromptTemplateNode;
-    private generateId;
-    private createInputNode;
-    private createOutputNode;
-    private createPromptNode;
-}
-type ProxyVariable = {
-    [key: string]: ProxyVariable;
-};
-type TransformFn = (input: ProxyVariable) => Node;
-interface Dependency {
-    node: Node;
-    sourceVar?: string;
-    targetVar?: string;
-    expr?: string;
-}
-declare abstract class BaseNode implements Node {
-    protected graph: GraphBuilder;
-    readonly id: string;
-    readonly __type = "node";
-    dependencies: Dependency[];
-    constructor(graph: GraphBuilder, id: string);
-    addDependency(dependency: Dependency): void;
-    abstract build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare class InputNode extends BaseNode implements Node {
-    constructor(graph: GraphBuilder, id: string);
-    build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare class OutputNode extends BaseNode implements Node {
-    constructor(graph: GraphBuilder, id: string);
-    build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare class PromptNode extends BaseNode implements Node {
-    private prompt;
-    constructor(graph: GraphBuilder, id: string, prompt: Prompt);
-    build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare class GateNode extends BaseNode implements Node {
-    private condition;
-    constructor(graph: GraphBuilder, id: string, condition: string);
-    build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare class AggregatorNode extends BaseNode implements Node {
-    constructor(graph: GraphBuilder, id: string);
-    build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare class PromptTemplateNode extends BaseNode implements Node {
-    private prompt;
-    constructor(graph: GraphBuilder, id: string, prompt: PromptBlockDataType);
-    build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare class LiteralNode<T> extends BaseNode implements Node {
-    private value;
-    constructor(graph: GraphBuilder, id: string, value: T);
-    build(context: BuildContext): Promise<GraphNodeType>;
-}
-declare function createGraph(): GraphBuilder;
-declare function escapePath(parts: string[]): string | undefined;
-declare function unescapePath(path: string): string[];
-declare const _default: {
-    createGraph: typeof createGraph;
-};
-
-type graphFramework_AggregatorNode = AggregatorNode;
-declare const graphFramework_AggregatorNode: typeof AggregatorNode;
-type graphFramework_BuildContext = BuildContext;
-type graphFramework_GateNode = GateNode;
-declare const graphFramework_GateNode: typeof GateNode;
-type graphFramework_GraphBuilder = GraphBuilder;
-declare const graphFramework_GraphBuilder: typeof GraphBuilder;
-type graphFramework_InputNode = InputNode;
-declare const graphFramework_InputNode: typeof InputNode;
-type graphFramework_LazyGraphNode = LazyGraphNode;
-type graphFramework_LiteralNode<T> = LiteralNode<T>;
-declare const graphFramework_LiteralNode: typeof LiteralNode;
-type graphFramework_Node = Node;
-type graphFramework_NodeLike = NodeLike;
-type graphFramework_OutputNode = OutputNode;
-declare const graphFramework_OutputNode: typeof OutputNode;
-type graphFramework_PromptNode = PromptNode;
-declare const graphFramework_PromptNode: typeof PromptNode;
-type graphFramework_PromptTemplateNode = PromptTemplateNode;
-declare const graphFramework_PromptTemplateNode: typeof PromptTemplateNode;
-type graphFramework_ProxyVariable = ProxyVariable;
-type graphFramework_TransformFn = TransformFn;
-declare const graphFramework_createGraph: typeof createGraph;
-declare const graphFramework_escapePath: typeof escapePath;
-declare const graphFramework_unescapePath: typeof unescapePath;
-declare namespace graphFramework {
-  export { graphFramework_AggregatorNode as AggregatorNode, type graphFramework_BuildContext as BuildContext, graphFramework_GateNode as GateNode, graphFramework_GraphBuilder as GraphBuilder, graphFramework_InputNode as InputNode, type graphFramework_LazyGraphNode as LazyGraphNode, graphFramework_LiteralNode as LiteralNode, type graphFramework_Node as Node, type graphFramework_NodeLike as NodeLike, graphFramework_OutputNode as OutputNode, graphFramework_PromptNode as PromptNode, graphFramework_PromptTemplateNode as PromptTemplateNode, type graphFramework_ProxyVariable as ProxyVariable, type graphFramework_TransformFn as TransformFn, graphFramework_createGraph as createGraph, _default as default, graphFramework_escapePath as escapePath, graphFramework_unescapePath as unescapePath };
-}
-
 type GenericFunction<Input, Output> = ((input: Input) => Output) | ((input: Input) => Promise<Output>);
 interface BaseFnOpts {
     name: string;
@@ -46710,7 +46236,7 @@ type EvalScorerArgs<Input, Output, Expected, Metadata extends BaseMetadata = Def
     output: Output;
     trace?: Trace;
 };
-type OneOrMoreScores = Score | number | null | Array<Score>;
+type OneOrMoreScores = SingleScore | number | null | Array<Score>;
 type EvalScorer<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType> = (args: EvalScorerArgs<Input, Output, Expected, Metadata>) => OneOrMoreScores | Promise<OneOrMoreScores>;
 type OneOrMoreClassifications = Classification | Classification[] | null;
 type EvalClassifier<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType> = (args: EvalScorerArgs<Input, Output, Expected, Metadata>) => OneOrMoreClassifications | Promise<OneOrMoreClassifications>;
@@ -46980,6 +46506,483 @@ type ScoreAccumulator = {
 declare function buildLocalSummary(evaluator: EvaluatorDef<any, any, any, any>, results: EvalResult<any, any, any, any>[], precomputedScores?: ScoreAccumulator): ExperimentSummary;
 declare function reportFailures<Input, Output, Expected, Metadata extends BaseMetadata>(evaluator: EvaluatorDef<Input, Output, Expected, Metadata>, failingResults: EvalResult<Input, Output, Expected, Metadata>[], { verbose, jsonl }: ReporterOpts): void;
 
+type ScorerFunction<Output = unknown> = (args: {
+    output: Output;
+    expected?: unknown;
+    input?: unknown;
+    metadata?: Record<string, unknown>;
+}) => OneOrMoreScores | Promise<OneOrMoreScores>;
+type ProgressEvent = {
+    type: "suite_start";
+    suiteName: string;
+} | {
+    type: "test_start";
+    testName: string;
+} | {
+    type: "test_complete";
+    testName: string;
+    passed: boolean;
+    duration: number;
+} | {
+    type: "suite_complete";
+    suiteName: string;
+    passed: number;
+    failed: number;
+};
+
+interface BraintrustTestConfig {
+    input?: unknown;
+    expected?: unknown;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    scorers?: ScorerFunction[];
+    data?: Array<{
+        input?: unknown;
+        expected?: unknown;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+    }>;
+}
+interface TestConfig extends BraintrustTestConfig {
+    [key: string]: unknown;
+}
+type WithModifiers<T> = T & {
+    skip: T;
+    only: T;
+    concurrent: T;
+    todo: (name: string) => void;
+};
+type TestContext = Pick<BraintrustTestConfig, "input" | "expected" | "metadata">;
+type BaseTestFunction<VitestContext = unknown> = {
+    (name: string, fn: (context: VitestContext) => void | Promise<void>): void;
+    each?: <T>(cases: readonly T[]) => (name: string, fn: (context: T) => void | Promise<void>) => void;
+};
+type TestFunction<VitestContext = unknown> = WithModifiers<BaseTestFunction<VitestContext>>;
+type BaseDescribeFunction = {
+    (name: string, factory: () => void): void;
+    each?: <T>(cases: readonly T[]) => (name: string, factory: () => void) => void;
+};
+type DescribeFunction = WithModifiers<BaseDescribeFunction>;
+interface BaseWrappedTest<VitestContext = unknown> {
+    (name: string, fn: (context: VitestContext) => unknown | Promise<unknown>): void;
+    (name: string, config: TestConfig, fn: (context: TestContext & VitestContext) => unknown | Promise<unknown>): void;
+    each: <T>(cases: readonly T[]) => (name: string, fn: (context: T & TestContext & VitestContext) => unknown | Promise<unknown>) => void;
+}
+type WrappedTest<VitestContext = unknown> = WithModifiers<BaseWrappedTest<VitestContext>>;
+interface BaseWrappedDescribe {
+    (name: string, factory: () => void): void;
+    each: <T>(cases: readonly T[]) => (name: string, factory: () => void) => void;
+}
+type WrappedDescribe = WithModifiers<BaseWrappedDescribe>;
+interface VitestMethods<VitestContext = unknown, ExpectType extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> {
+    test: TestFunction<VitestContext>;
+    it?: TestFunction<VitestContext>;
+    expect: ExpectType;
+    describe: DescribeFunction;
+    beforeAll?: (fn: () => void | Promise<void>) => void;
+    afterAll?: (fn: () => void | Promise<void>) => void;
+    beforeEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
+    afterEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
+}
+interface BraintrustVitest<VitestContext = unknown, ExpectType extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> {
+    test: WrappedTest<VitestContext>;
+    it: WrappedTest<VitestContext>;
+    expect: ExpectType;
+    describe: WrappedDescribe;
+    beforeAll: (fn: () => void | Promise<void>) => void;
+    afterAll: (fn: () => void | Promise<void>) => void;
+    beforeEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
+    afterEach?: (fn: (context: VitestContext) => void | Promise<void>) => void;
+    logOutputs: (outputs: Record<string, unknown>) => void;
+    logFeedback: (feedback: {
+        name: string;
+        score: number;
+        metadata?: Record<string, unknown>;
+    }) => void;
+    getCurrentSpan: () => Span | null;
+    /**
+     * Helper function to flush the experiment and optionally display a summary.
+     * Use this in afterAll() instead of manually calling getExperimentContext().
+     *
+     * @param options - Optional configuration
+     * @param options.displaySummary - Whether to display the experiment summary (defaults to true)
+     */
+    flushExperiment: (options?: {
+        displaySummary?: boolean;
+    }) => Promise<void>;
+}
+interface WrapperConfig {
+    projectName?: string;
+    /**
+     * The id of the project to create experiments in. Takes precedence over
+     * `projectName` if both are set.
+     */
+    projectId?: string;
+    /**
+     * If true, displays a formatted experiment summary with scores and URL after the test suite completes.
+     * Defaults to true. Set to false to suppress the summary output.
+     */
+    displaySummary?: boolean;
+    /**
+     * Callback for real-time progress events.
+     * Called when tests start, complete, or progress updates occur.
+     * Progress reporting is always enabled when this callback is provided.
+     */
+    onProgress?: (event: ProgressEvent) => void;
+}
+
+/**
+ * Wraps Vitest methods with Braintrust experiment tracking. This automatically creates
+ * datasets and experiments from your Vitest tests, tracking pass/fail rates and evaluation metrics.
+ * Experiments are automatically flushed after all tests complete.
+ *
+ * @param vitestMethods - Object containing Vitest methods (test, describe, expect, etc.)
+ * @param config - Optional configuration object
+ * @param config.projectName - Project name for the experiment (defaults to suite name)
+ * @param config.displaySummary - If true, displays experiment summary after flushing (defaults to true)
+ * @returns Wrapped Vitest methods with Braintrust experiment tracking
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import * as vitest from "vitest";
+ * import { wrapVitest } from 'braintrust';
+ *
+ * const {test, expect, describe } = wrapVitest(
+ *   { projectName: 'my-project' }
+ * );
+ *
+ * describe('Translation Tests', () => {
+ *
+ *   // Tests with input/expected are automatically added to the dataset
+ *   test(
+ *     'translates hello',
+ *     {
+ *       input: { text: 'hello' },
+ *       expected: 'hola',
+ *       metadata: { language: 'spanish' },
+ *     },
+ *     async ({ input, expected }) => {
+ *       const result = await translate(input.text);
+ *       bt.logOutputs({ translation: result });
+ *       expect(result).toBe(expected);
+ *     }
+ *   );
+ *
+ *   // Tests without input/expected still run and track pass/fail
+ *   test('basic functionality', async () => {
+ *     const result = await someFunction();
+ *     expect(result).toBeTruthy();
+ *   });
+ * });
+ * ```
+ *
+ * @see README.md for full documentation and examples
+ */
+declare function wrapVitest<VitestContext = unknown, ExpectType extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown>(vitestMethods: VitestMethods<VitestContext, ExpectType>, config?: WrapperConfig): BraintrustVitest<VitestContext, ExpectType>;
+
+/** Progress events emitted by the node-test integration. */
+type NodeTestProgressEvent = {
+    type: "test_start";
+    testName: string;
+} | {
+    type: "test_complete";
+    testName: string;
+    passed: boolean;
+    duration: number;
+};
+/**
+ * Minimal test context interface compatible with node:test's TestContext.
+ * We only use `name` from the context, making this compatible with any
+ * test runner that provides a `{ name?: string }` context object.
+ */
+interface MinimalTestContext {
+    name?: string;
+}
+/**
+ * Configuration for `initNodeTestSuite()`.
+ */
+interface NodeTestSuiteConfig {
+    /** Project name for the Braintrust experiment. */
+    projectName: string;
+    /** Optional experiment name. Defaults to a timestamp-based name. */
+    experimentName?: string;
+    /**
+     * If true, displays a formatted experiment summary after flushing.
+     * Defaults to true.
+     */
+    displaySummary?: boolean;
+    /**
+     * Pass `after` from `node:test` to auto-register a flush hook.
+     * When provided, `suite.flush()` is called automatically after all tests.
+     */
+    after?: (fn: () => void | Promise<void>) => void;
+    /**
+     * Callback for real-time progress events.
+     * Emits `test_start` and `test_complete` events.
+     */
+    onProgress?: (event: NodeTestProgressEvent) => void;
+}
+/**
+ * Configuration for a single eval test case.
+ */
+interface EvalConfig {
+    /** Test input data, logged to the span. */
+    input?: unknown;
+    /** Expected output, passed to scorers. */
+    expected?: unknown;
+    /** Custom metadata, logged to the span. */
+    metadata?: Record<string, unknown>;
+    /** Tags for organizing test cases. */
+    tags?: string[];
+    /** Scorer functions to evaluate the output. */
+    scorers?: ScorerFunction[];
+    /** Override span name (defaults to `t.name`, then `"unnamed test"`). */
+    name?: string;
+}
+/**
+ * Context passed to the eval test function.
+ */
+interface EvalContext {
+    input: unknown;
+    expected?: unknown;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * The public API surface returned by `initNodeTestSuite()`.
+ */
+interface NodeTestSuite {
+    /**
+     * Creates a test function compatible with `node:test`.
+     * Pass the result to `test()` from `node:test`.
+     *
+     * @param config - Eval configuration (input, expected, scorers, etc.)
+     * @param fn - The test function. Its return value is logged as output and passed to scorers.
+     * @returns A function accepting a test context `t` from `node:test`.
+     */
+    eval(config: EvalConfig, fn: (context: EvalContext) => unknown | Promise<unknown>): (t: MinimalTestContext) => Promise<void>;
+    /**
+     * Flush the experiment: summarize results and send data to Braintrust.
+     * Called automatically if `after` was provided in the config.
+     */
+    flush(): Promise<void>;
+}
+
+/**
+ * Creates a new Node.js test suite with Braintrust experiment tracking.
+ *
+ * @example
+ * ```typescript
+ * import { test, describe, after } from 'node:test';
+ * import { initNodeTestSuite } from 'braintrust';
+ *
+ * describe('My Tests', () => {
+ *   const suite = initNodeTestSuite({ projectName: 'my-project', after });
+ *
+ *   test('my eval', suite.eval(
+ *     { input: 'hello', expected: 'world', scorers: [myScorer] },
+ *     async ({ input }) => {
+ *       return await myFunction(input);
+ *     }
+ *   ));
+ * });
+ * ```
+ */
+declare function initNodeTestSuite(config: NodeTestSuiteConfig): NodeTestSuite;
+
+type LangChainSerialized = {
+    id?: unknown[];
+    name?: string;
+};
+type LangChainCallbackHandlerOptions<IsAsyncFlush extends boolean> = {
+    debug: boolean;
+    excludeMetadataProps: RegExp;
+    logger?: Logger<IsAsyncFlush> | Span;
+    parent?: Span | (() => Span);
+};
+type LangChainStartSpanArgs = StartSpanArgs & {
+    parentRunId?: string;
+    runId: string;
+};
+type LangChainEndSpanArgs = ExperimentLogPartialArgs & {
+    parentRunId?: string;
+    runId: string;
+    tags?: string[];
+};
+type LangChainLLMResult = {
+    generations?: unknown[];
+    llmOutput?: Record<string, unknown>;
+};
+
+declare const BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME = "BraintrustCallbackHandler";
+declare class BraintrustLangChainCallbackHandler<IsAsyncFlush extends boolean = true> {
+    name: string;
+    private spans;
+    private skippedRuns;
+    private parent?;
+    private rootRunId?;
+    private options;
+    private startTimes;
+    private firstTokenTimes;
+    private ttftMs;
+    constructor(options?: Partial<LangChainCallbackHandlerOptions<IsAsyncFlush>>);
+    protected startSpan({ runId, parentRunId, ...args }: LangChainStartSpanArgs): void;
+    protected endSpan({ runId, parentRunId, tags, metadata, ...args }: LangChainEndSpanArgs): void;
+    handleLLMStart(llm: LangChainSerialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
+    handleLLMError(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleLLMEnd(output: LangChainLLMResult, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleChatModelStart(llm: LangChainSerialized, messages: unknown[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
+    handleChainStart(chain: LangChainSerialized, inputs: unknown, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string, runName?: string): Promise<void>;
+    handleChainError(err: Error, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void>;
+    handleChainEnd(outputs: unknown, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void>;
+    handleToolStart(tool: LangChainSerialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void>;
+    handleToolError(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleToolEnd(output: unknown, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleAgentAction(action: Record<string, unknown>, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleAgentEnd(action: unknown, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleRetrieverStart(retriever: LangChainSerialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, name?: string): Promise<void>;
+    handleRetrieverEnd(documents: unknown[], runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleRetrieverError(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleLLMNewToken(_token: string, _idx: {
+        prompt: number;
+        completion: number;
+    }, runId: string, _parentRunId?: string, _tags?: string[]): Promise<void>;
+}
+
+interface BuildContext {
+    getFunctionId(functionObj: unknown): Promise<FunctionIdType>;
+}
+interface Node {
+    readonly id: string;
+    __type: "node";
+    build(context: BuildContext): Promise<GraphNodeType>;
+    addDependency(dependency: Dependency): void;
+}
+type NodeLike = Node | Prompt<boolean, boolean> | ProxyVariable;
+type LazyGraphNode = {
+    type: "lazy";
+    id: string;
+};
+declare class GraphBuilder {
+    private nodes;
+    private edges;
+    private nodeLikeNodes;
+    readonly IN: InputNode;
+    readonly OUT: OutputNode;
+    constructor();
+    build(context: BuildContext): Promise<GraphDataType>;
+    addEdge({ source, sourceVar, target, targetVar, expr, purpose, }: {
+        source: NodeLike;
+        sourceVar?: string;
+        target: NodeLike;
+        targetVar?: string;
+        expr?: string;
+        purpose: GraphEdgeType["purpose"];
+    }): void;
+    resolveNode(node: NodeLike): [Node, string[]];
+    literal<T>(value: T): LiteralNode<T>;
+    gate(options: {
+        condition: string;
+    }): GateNode;
+    aggregator(): AggregatorNode;
+    promptTemplate(options: {
+        prompt: PromptBlockDataType;
+    }): PromptTemplateNode;
+    private generateId;
+    private createInputNode;
+    private createOutputNode;
+    private createPromptNode;
+}
+type ProxyVariable = {
+    [key: string]: ProxyVariable;
+};
+type TransformFn = (input: ProxyVariable) => Node;
+interface Dependency {
+    node: Node;
+    sourceVar?: string;
+    targetVar?: string;
+    expr?: string;
+}
+declare abstract class BaseNode implements Node {
+    protected graph: GraphBuilder;
+    readonly id: string;
+    readonly __type = "node";
+    dependencies: Dependency[];
+    constructor(graph: GraphBuilder, id: string);
+    addDependency(dependency: Dependency): void;
+    abstract build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare class InputNode extends BaseNode implements Node {
+    constructor(graph: GraphBuilder, id: string);
+    build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare class OutputNode extends BaseNode implements Node {
+    constructor(graph: GraphBuilder, id: string);
+    build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare class PromptNode extends BaseNode implements Node {
+    private prompt;
+    constructor(graph: GraphBuilder, id: string, prompt: Prompt);
+    build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare class GateNode extends BaseNode implements Node {
+    private condition;
+    constructor(graph: GraphBuilder, id: string, condition: string);
+    build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare class AggregatorNode extends BaseNode implements Node {
+    constructor(graph: GraphBuilder, id: string);
+    build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare class PromptTemplateNode extends BaseNode implements Node {
+    private prompt;
+    constructor(graph: GraphBuilder, id: string, prompt: PromptBlockDataType);
+    build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare class LiteralNode<T> extends BaseNode implements Node {
+    private value;
+    constructor(graph: GraphBuilder, id: string, value: T);
+    build(context: BuildContext): Promise<GraphNodeType>;
+}
+declare function createGraph(): GraphBuilder;
+declare function escapePath(parts: string[]): string | undefined;
+declare function unescapePath(path: string): string[];
+declare const _default: {
+    createGraph: typeof createGraph;
+};
+
+type graphFramework_AggregatorNode = AggregatorNode;
+declare const graphFramework_AggregatorNode: typeof AggregatorNode;
+type graphFramework_BuildContext = BuildContext;
+type graphFramework_GateNode = GateNode;
+declare const graphFramework_GateNode: typeof GateNode;
+type graphFramework_GraphBuilder = GraphBuilder;
+declare const graphFramework_GraphBuilder: typeof GraphBuilder;
+type graphFramework_InputNode = InputNode;
+declare const graphFramework_InputNode: typeof InputNode;
+type graphFramework_LazyGraphNode = LazyGraphNode;
+type graphFramework_LiteralNode<T> = LiteralNode<T>;
+declare const graphFramework_LiteralNode: typeof LiteralNode;
+type graphFramework_Node = Node;
+type graphFramework_NodeLike = NodeLike;
+type graphFramework_OutputNode = OutputNode;
+declare const graphFramework_OutputNode: typeof OutputNode;
+type graphFramework_PromptNode = PromptNode;
+declare const graphFramework_PromptNode: typeof PromptNode;
+type graphFramework_PromptTemplateNode = PromptTemplateNode;
+declare const graphFramework_PromptTemplateNode: typeof PromptTemplateNode;
+type graphFramework_ProxyVariable = ProxyVariable;
+type graphFramework_TransformFn = TransformFn;
+declare const graphFramework_createGraph: typeof createGraph;
+declare const graphFramework_escapePath: typeof escapePath;
+declare const graphFramework_unescapePath: typeof unescapePath;
+declare namespace graphFramework {
+  export { graphFramework_AggregatorNode as AggregatorNode, type graphFramework_BuildContext as BuildContext, graphFramework_GateNode as GateNode, graphFramework_GraphBuilder as GraphBuilder, graphFramework_InputNode as InputNode, type graphFramework_LazyGraphNode as LazyGraphNode, graphFramework_LiteralNode as LiteralNode, type graphFramework_Node as Node, type graphFramework_NodeLike as NodeLike, graphFramework_OutputNode as OutputNode, graphFramework_PromptNode as PromptNode, graphFramework_PromptTemplateNode as PromptTemplateNode, type graphFramework_ProxyVariable as ProxyVariable, type graphFramework_TransformFn as TransformFn, graphFramework_createGraph as createGraph, _default as default, graphFramework_escapePath as escapePath, graphFramework_unescapePath as unescapePath };
+}
+
 declare const BATCH_TASK_KIND = "braintrust.durable.batch-task";
 declare const BATCH_SCORER_KIND = "braintrust.durable.batch-scorer";
 type JsonPrimitive = string | number | boolean | null;