braintrust 0.0.140 → 0.0.141-dev

package/dist/browser.d.ts

@@ -1,2 +1,1089 @@
-export * from "./logger";
-export * from "./wrappers/oai";
+import { GitMetadataSettings, LogFeedbackFullArgs, BackgroundLogEvent, ExperimentEvent, ExperimentLogFullArgs, ExperimentLogPartialArgs, IdField, SpanType, RepoInfo, DEFAULT_IS_LEGACY_DATASET, TRANSACTION_ID_FIELD, TransactionId, SpanObjectTypeV2, DatasetRecord } from '@braintrust/core';
+import { PromptData, OpenAIMessage, Tools, AnyModelParam, Prompt as Prompt$1, PromptSessionEvent, FunctionId } from '@braintrust/core/typespecs';
+import { z } from 'zod';
+
+interface IsoAsyncLocalStorage<T> {
+    enterWith(store: T): void;
+    run<R>(store: T | undefined, callback: () => R): R;
+    getStore(): T | undefined;
+}
+
+declare class LazyValue<T> {
+    private callable;
+    private value;
+    constructor(callable: () => Promise<T>);
+    get(): Promise<T>;
+    get hasComputed(): boolean;
+}
+
+/// <reference lib="dom" />
+
+type SetCurrentArg = {
+    setCurrent?: boolean;
+};
+type StartSpanEventArgs = ExperimentLogPartialArgs & Partial<IdField>;
+type StartSpanArgs = {
+    name?: string;
+    type?: SpanType;
+    spanAttributes?: Record<any, any>;
+    startTime?: number;
+    parent?: string;
+    event?: StartSpanEventArgs;
+};
+type EndSpanArgs = {
+    endTime?: number;
+};
+interface Exportable {
+    /**
+     * Return a serialized representation of the object that can be used to start subspans in other places. See `Span.traced` for more details.
+     */
+    export(): Promise<string>;
+}
+/**
+ * A Span encapsulates logged data and metrics for a unit of work. This interface is shared by all span implementations.
+ *
+ * We suggest using one of the various `traced` methods, instead of creating Spans directly.
+ *
+ * See `Span.traced` for full details.
+ */
+interface Span extends Exportable {
+    /**
+     * Row ID of the span.
+     */
+    id: string;
+    /**
+     * Incrementally update the current span with new data. The event will be batched and uploaded behind the scenes.
+     *
+     * @param event: Data to be logged. See `Experiment.log` for full details.
+     */
+    log(event: ExperimentLogPartialArgs): void;
+    /**
+     * Add feedback to the current span. Unlike `Experiment.logFeedback` and `Logger.logFeedback`, this method does not accept an id parameter, because it logs feedback to the current span.
+     *
+     * @param event: Data to be logged. See `Experiment.logFeedback` for full details.
+     */
+    logFeedback(event: Omit<LogFeedbackFullArgs, "id">): void;
+    /**
+     * Create a new span and run the provided callback. This is useful if you want to log more detailed trace information beyond the scope of a single log event. Data logged over several calls to `Span.log` will be merged into one logical row.
+     *
+     * Spans created within `traced` are ended automatically. By default, the span is marked as current, so they can be accessed using `braintrust.currentSpan`.
+     *
+     * @param callback The function to be run under the span context.
+     * @param args.name Optional name of the span. If not provided, a name will be inferred from the call stack.
+     * @param args.type Optional type of the span. If not provided, the type will be unset.
+     * @param args.span_attributes Optional additional attributes to attach to the span, such as a type name.
+     * @param args.start_time Optional start time of the span, as a timestamp in seconds.
+     * @param args.setCurrent If true (the default), the span will be marked as the currently-active span for the duration of the callback.
+     * @param args.parent Optional parent info string for the span. The string can be generated from `[Span,Experiment,Logger].export`. If not provided, the current span will be used (depending on context). This is useful for adding spans to an existing trace.
+     * @param args.event Data to be logged. See `Experiment.log` for full details.
+     * @Returns The result of running `callback`.
+     */
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    /**
+     * Lower-level alternative to `traced`. This allows you to start a span yourself, and can be useful in situations
+     * where you cannot use callbacks. However, spans started with `startSpan` will not be marked as the "current span",
+     * so `currentSpan()` and `traced()` will be no-ops. If you want to mark a span as current, use `traced` instead.
+     *
+     * See `traced` for full details.
+     *
+     * @returns The newly-created `Span`
+     */
+    startSpan(args?: StartSpanArgs): Span;
+    /**
+     * Log an end time to the span (defaults to the current time). Returns the logged time.
+     *
+     * Will be invoked automatically if the span is constructed with `traced`.
+     *
+     * @param args.endTime Optional end time of the span, as a timestamp in seconds.
+     * @returns The end time logged to the span metrics.
+     */
+    end(args?: EndSpanArgs): number;
+    /**
+     * Flush any pending rows to the server.
+     */
+    flush(): Promise<void>;
+    /**
+     * Alias for `end`.
+     */
+    close(args?: EndSpanArgs): number;
+    /**
+     * Set the span's name, type, or other attributes after it's created.
+     */
+    setAttributes(args: Omit<StartSpanArgs, "event">): void;
+    kind: "span";
+}
+/**
+ * A fake implementation of the Span API which does nothing. This can be used as the default span.
+ */
+declare class NoopSpan implements Span {
+    id: string;
+    kind: "span";
+    constructor();
+    log(_: ExperimentLogPartialArgs): void;
+    logFeedback(_event: Omit<LogFeedbackFullArgs, "id">): void;
+    traced<R>(callback: (span: Span) => R, _1?: StartSpanArgs & SetCurrentArg): R;
+    startSpan(_1?: StartSpanArgs): this;
+    end(args?: EndSpanArgs): number;
+    export(): Promise<string>;
+    flush(): Promise<void>;
+    close(args?: EndSpanArgs): number;
+    setAttributes(_args: Omit<StartSpanArgs, "event">): void;
+}
+declare const NOOP_SPAN: NoopSpan;
+declare global {
+    var __inherited_braintrust_state: BraintrustState;
+}
+declare const loginSchema: z.ZodObject<{
+    appUrl: z.ZodString;
+    appPublicUrl: z.ZodString;
+    orgName: z.ZodString;
+    logUrl: z.ZodString;
+    proxyUrl: z.ZodString;
+    loginToken: z.ZodString;
+    orgId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    gitMetadataSettings: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        collect: z.ZodEnum<["all", "none", "some"]>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodEnum<["dirty", "tag", "commit", "branch", "author_name", "author_email", "commit_message", "commit_time", "git_diff"]>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        collect: "some" | "none" | "all";
+        fields?: ("dirty" | "tag" | "commit" | "branch" | "author_name" | "author_email" | "commit_message" | "commit_time" | "git_diff")[] | undefined;
+    }, {
+        collect: "some" | "none" | "all";
+        fields?: ("dirty" | "tag" | "commit" | "branch" | "author_name" | "author_email" | "commit_message" | "commit_time" | "git_diff")[] | undefined;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    appUrl: string;
+    appPublicUrl: string;
+    orgName: string;
+    logUrl: string;
+    proxyUrl: string;
+    loginToken: string;
+    orgId?: string | null | undefined;
+    gitMetadataSettings?: {
+        collect: "some" | "none" | "all";
+        fields?: ("dirty" | "tag" | "commit" | "branch" | "author_name" | "author_email" | "commit_message" | "commit_time" | "git_diff")[] | undefined;
+    } | null | undefined;
+}, {
+    appUrl: string;
+    appPublicUrl: string;
+    orgName: string;
+    logUrl: string;
+    proxyUrl: string;
+    loginToken: string;
+    orgId?: string | null | undefined;
+    gitMetadataSettings?: {
+        collect: "some" | "none" | "all";
+        fields?: ("dirty" | "tag" | "commit" | "branch" | "author_name" | "author_email" | "commit_message" | "commit_time" | "git_diff")[] | undefined;
+    } | null | undefined;
+}>;
+type SerializedBraintrustState = z.infer<typeof loginSchema>;
+declare class BraintrustState {
+    private loginParams;
+    id: string;
+    currentExperiment: Experiment | undefined;
+    currentLogger: Logger<false> | undefined;
+    currentSpan: IsoAsyncLocalStorage<Span>;
+    private _bgLogger;
+    appUrl: string | null;
+    appPublicUrl: string | null;
+    loginToken: string | null;
+    orgId: string | null;
+    orgName: string | null;
+    logUrl: string | null;
+    proxyUrl: string | null;
+    loggedIn: boolean;
+    gitMetadataSettings?: GitMetadataSettings;
+    fetch: typeof globalThis.fetch;
+    private _apiConn;
+    private _logConn;
+    private _proxyConn;
+    constructor(loginParams: LoginOptions);
+    resetLoginInfo(): void;
+    copyLoginInfo(other: BraintrustState): void;
+    serialize(): SerializedBraintrustState;
+    static deserialize(serialized: unknown): BraintrustState;
+    setFetch(fetch: typeof globalThis.fetch): void;
+    login(loginParams: LoginOptions & {
+        forceLogin?: boolean;
+    }): Promise<void>;
+    apiConn(): HTTPConnection;
+    logConn(): HTTPConnection;
+    proxyConn(): HTTPConnection;
+    bgLogger(): BackgroundLogger;
+    loginReplaceLogConn(logConn: HTTPConnection): void;
+}
+declare function _internalSetInitialState(): void;
+declare const _internalGetGlobalState: () => BraintrustState;
+declare class HTTPConnection {
+    base_url: string;
+    token: string | null;
+    headers: Record<string, string>;
+    fetch: typeof globalThis.fetch;
+    constructor(base_url: string, fetch: typeof globalThis.fetch);
+    setFetch(fetch: typeof globalThis.fetch): void;
+    ping(): Promise<boolean>;
+    make_long_lived(): void;
+    static sanitize_token(token: string): string;
+    set_token(token: string): void;
+    _reset(): void;
+    get(path: string, params?: Record<string, string | undefined> | undefined, config?: RequestInit): Promise<Response>;
+    post(path: string, params?: Record<string, unknown> | string, config?: RequestInit): Promise<Response>;
+    get_json(object_type: string, args?: Record<string, string | undefined> | undefined, retries?: number): Promise<any>;
+    post_json(object_type: string, args?: Record<string, unknown> | string | undefined): Promise<any>;
+}
+interface ObjectMetadata {
+    id: string;
+    name: string;
+    fullInfo: Record<string, unknown>;
+}
+interface ProjectExperimentMetadata {
+    project: ObjectMetadata;
+    experiment: ObjectMetadata;
+}
+interface ProjectDatasetMetadata {
+    project: ObjectMetadata;
+    dataset: ObjectMetadata;
+}
+interface OrgProjectMetadata {
+    org_id: string;
+    project: ObjectMetadata;
+}
+interface LogOptions<IsAsyncFlush> {
+    asyncFlush?: IsAsyncFlush;
+    computeMetadataArgs?: Record<string, any>;
+}
+type PromiseUnless<B, R> = B extends true ? R : Promise<Awaited<R>>;
+interface ParentSpanIds {
+    spanId: string;
+    rootSpanId: string;
+}
+declare class Logger<IsAsyncFlush extends boolean> implements Exportable {
+    private state;
+    private lazyMetadata;
+    private _asyncFlush;
+    private computeMetadataArgs;
+    private lastStartTime;
+    private lazyId;
+    private calledStartSpan;
+    kind: "logger";
+    constructor(state: BraintrustState, lazyMetadata: LazyValue<OrgProjectMetadata>, logOptions?: LogOptions<IsAsyncFlush>);
+    get org_id(): Promise<string>;
+    get project(): Promise<ObjectMetadata>;
+    get id(): Promise<string>;
+    private parentObjectType;
+    private triggerWaitUntilFlush;
+    /**
+     * Log a single event. The event will be batched and uploaded behind the scenes if `logOptions.asyncFlush` is true.
+     *
+     * @param event The event to log.
+     * @param event.input: (Optional) the arguments that uniquely define a user input (an arbitrary, JSON serializable object).
+     * @param event.output: (Optional) the output of your application, including post-processing (an arbitrary, JSON serializable object), that allows you to determine whether the result is correct or not. For example, in an app that generates SQL queries, the `output` should be the _result_ of the SQL query generated by the model, not the query itself, because there may be multiple valid queries that answer a single question.
+     * @param event.expected: (Optional) the ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to determine if your `output` value is correct or not. Braintrust currently does not compare `output` to `expected` for you, since there are so many different ways to do that correctly. Instead, these values are just used to help you navigate while digging into analyses. However, we may later use these values to re-score outputs or fine-tune your models.
+     * @param event.scores: (Optional) a dictionary of numeric values (between 0 and 1) to log. The scores should give you a variety of signals that help you determine how accurate the outputs are compared to what you expect and diagnose failures. For example, a summarization app might have one score that tells you how accurate the summary is, and another that measures the word similarity between the generated and grouth truth summary. The word similarity score could help you determine whether the summarization was covering similar concepts or not. You can use these scores to help you sort, filter, and compare logs.
+     * @param event.metadata: (Optional) a dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings.
+     * @param event.metrics: (Optional) a dictionary of metrics to log. The following keys are populated automatically: "start", "end".
+     * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
+     * @param options Additional logging options
+     * @param options.allowConcurrentWithSpans in rare cases where you need to log at the top level separately from spans on the logger elsewhere, set this to true.
+     * :returns: The `id` of the logged event.
+     */
+    log(event: Readonly<StartSpanEventArgs>, options?: {
+        allowConcurrentWithSpans?: boolean;
+    }): PromiseUnless<IsAsyncFlush, string>;
+    /**
+     * Create a new toplevel span underneath the logger. The name defaults to "root".
+     *
+     * See `Span.traced` for full details.
+     */
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): PromiseUnless<IsAsyncFlush, R>;
+    /**
+     * Lower-level alternative to `traced`. This allows you to start a span yourself, and can be useful in situations
+     * where you cannot use callbacks. However, spans started with `startSpan` will not be marked as the "current span",
+     * so `currentSpan()` and `traced()` will be no-ops. If you want to mark a span as current, use `traced` instead.
+     *
+     * See `traced` for full details.
+     */
+    startSpan(args?: StartSpanArgs): Span;
+    private startSpanImpl;
+    /**
+     * Log feedback to an event. Feedback is used to save feedback scores, set an expected value, or add a comment.
+     *
+     * @param event
+     * @param event.id The id of the event to log feedback for. This is the `id` returned by `log` or accessible as the `id` field of a span.
+     * @param event.scores (Optional) a dictionary of numeric values (between 0 and 1) to log. These scores will be merged into the existing scores for the event.
+     * @param event.expected (Optional) the ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to determine if your `output` value is correct or not.
+     * @param event.comment (Optional) an optional comment string to log about the event.
+     * @param event.metadata (Optional) a dictionary with additional data about the feedback. If you have a `user_id`, you can log it here and access it in the Braintrust UI.
+     * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
+     */
+    logFeedback(event: LogFeedbackFullArgs): void;
+    /**
+     * Return a serialized representation of the logger that can be used to start subspans in other places. See `Span.start_span` for more details.
+     */
+    export(): Promise<string>;
+    flush(): Promise<void>;
+    get asyncFlush(): IsAsyncFlush | undefined;
+}
+declare class BackgroundLogger {
+    private logConn;
+    private items;
+    private activeFlush;
+    private activeFlushResolved;
+    private activeFlushError;
+    syncFlush: boolean;
+    maxRequestSize: number;
+    defaultBatchSize: number;
+    numTries: number;
+    queueDropExceedingMaxsize: number | undefined;
+    queueDropLoggingPeriod: number;
+    failedPublishPayloadsDir: string | undefined;
+    allPublishPayloadsDir: string | undefined;
+    private queueDropLoggingState;
+    constructor(logConn: LazyValue<HTTPConnection>);
+    log(items: LazyValue<BackgroundLogEvent>[]): void;
+    flush(): Promise<void>;
+    private flushOnce;
+    private unwrapLazyValues;
+    private submitLogsRequest;
+    private registerDroppedItemCount;
+    private dumpDroppedEvents;
+    private static writePayloadToDir;
+    private triggerActiveFlush;
+    private logFailedPayloadsDir;
+    internalReplaceLogConn(logConn: HTTPConnection): void;
+}
+type InitOpenOption<IsOpen extends boolean> = {
+    open?: IsOpen;
+};
+type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
+    experiment?: string;
+    description?: string;
+    dataset?: AnyDataset;
+    update?: boolean;
+    baseExperiment?: string;
+    isPublic?: boolean;
+    metadata?: Record<string, unknown>;
+    gitMetadataSettings?: GitMetadataSettings;
+    projectId?: string;
+    baseExperimentId?: string;
+    repoInfo?: RepoInfo;
+    setCurrent?: boolean;
+    state?: BraintrustState;
+} & InitOpenOption<IsOpen>;
+type FullInitOptions<IsOpen extends boolean> = {
+    project?: string;
+} & InitOptions<IsOpen>;
+type InitializedExperiment<IsOpen extends boolean | undefined> = IsOpen extends true ? ReadonlyExperiment : Experiment;
+/**
+ * Log in, and then initialize a new experiment in a specified project. If the project does not exist, it will be created.
+ *
+ * @param options Options for configuring init().
+ * @param options.project The name of the project to create the experiment in. Must specify at least one of `project` or `projectId`.
+ * @param options.experiment The name of the experiment to create. If not specified, a name will be generated automatically.
+ * @param options.description An optional description of the experiment.
+ * @param options.dataset (Optional) A dataset to associate with the experiment. You can pass in the name of the dataset (in the same project) or a dataset object (from any project).
+ * @param options.update If the experiment already exists, continue logging to it. If it does not exist, creates the experiment with the specified arguments.
+ * @param options.baseExperiment An optional experiment name to use as a base. If specified, the new experiment will be summarized and compared to this experiment. Otherwise, it will pick an experiment by finding the closest ancestor on the default (e.g. main) branch.
+ * @param options.isPublic An optional parameter to control whether the experiment is publicly visible to anybody with the link or privately visible to only members of the organization. Defaults to private.
+ * @param options.appUrl The URL of the Braintrust App. Defaults to https://www.braintrust.dev.
+ * @param options.apiKey The API key to use. If the parameter is not specified, will try to use the `BRAINTRUST_API_KEY` environment variable. If no API key is specified, will prompt the user to login.
+ * @param options.orgName (Optional) The name of a specific organization to connect to. This is useful if you belong to multiple.
+ * @param options.metadata (Optional) A dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings.
+ * @param options.gitMetadataSettings (Optional) Settings for collecting git metadata. By default, will collect all git metadata fields allowed in org-level settings.
+ * @param setCurrent If true (the default), set the global current-experiment to the newly-created one.
+ * @param options.open If the experiment already exists, open it in read-only mode. Throws an error if the experiment does not already exist.
+ * @param options.projectId The id of the project to create the experiment in. This takes precedence over `project` if specified.
+ * @param options.baseExperimentId An optional experiment id to use as a base. If specified, the new experiment will be summarized and compared to this. This takes precedence over `baseExperiment` if specified.
+ * @param options.repoInfo (Optional) Explicitly specify the git metadata for this experiment. This takes precedence over `gitMetadataSettings` if specified.
+ * @returns The newly created Experiment.
+ */
+declare function init<IsOpen extends boolean = false>(options: Readonly<FullInitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+/**
+ * Legacy form of `init` which accepts the project name as the first parameter,
+ * separately from the remaining options. See `init(options)` for full details.
+ */
+declare function init<IsOpen extends boolean = false>(project: string, options?: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+/**
+ * Alias for init(options).
+ */
+declare function initExperiment<IsOpen extends boolean = false>(options: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+/**
+ * Alias for init(project, options).
+ */
+declare function initExperiment<IsOpen extends boolean = false>(project: string, options?: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+/**
+ * This function is deprecated. Use `init` instead.
+ */
+declare function withExperiment<R>(project: string, callback: (experiment: Experiment) => R, options?: Readonly<InitOptions<false> & SetCurrentArg>): R;
+/**
+ * This function is deprecated. Use `initLogger` instead.
+ */
+declare function withLogger<IsAsyncFlush extends boolean = false, R = void>(callback: (logger: Logger<IsAsyncFlush>) => R, options?: Readonly<InitLoggerOptions<IsAsyncFlush> & SetCurrentArg>): R;
+type UseOutputOption<IsLegacyDataset extends boolean> = {
+    useOutput?: IsLegacyDataset;
+};
+type InitDatasetOptions<IsLegacyDataset extends boolean> = FullLoginOptions & {
+    dataset?: string;
+    description?: string;
+    version?: string;
+    projectId?: string;
+    state?: BraintrustState;
+} & UseOutputOption<IsLegacyDataset>;
+type FullInitDatasetOptions<IsLegacyDataset extends boolean> = {
+    project?: string;
+} & InitDatasetOptions<IsLegacyDataset>;
+/**
+ * Create a new dataset in a specified project. If the project does not exist, it will be created.
+ *
+ * @param options Options for configuring initDataset().
+ * @param options.project The name of the project to create the dataset in. Must specify at least one of `project` or `projectId`.
+ * @param options.dataset The name of the dataset to create. If not specified, a name will be generated automatically.
+ * @param options.description An optional description of the dataset.
+ * @param options.appUrl The URL of the Braintrust App. Defaults to https://www.braintrust.dev.
+ * @param options.apiKey The API key to use. If the parameter is not specified, will try to use the `BRAINTRUST_API_KEY` environment variable. If no API key is specified, will prompt the user to login.
+ * @param options.orgName (Optional) The name of a specific organization to connect to. This is useful if you belong to multiple.
+ * @param options.projectId The id of the project to create the dataset in. This takes precedence over `project` if specified.
+ * @param options.useOutput (Deprecated) If true, records will be fetched from this dataset in the legacy format, with the "expected" field renamed to "output". This option will be removed in a future version of Braintrust.
+ * @returns The newly created Dataset.
+ */
+declare function initDataset<IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET>(options: Readonly<FullInitDatasetOptions<IsLegacyDataset>>): Dataset<IsLegacyDataset>;
+/**
+ * Legacy form of `initDataset` which accepts the project name as the first
+ * parameter, separately from the remaining options. See
+ * `initDataset(options)` for full details.
+ */
+declare function initDataset<IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET>(project: string, options?: Readonly<InitDatasetOptions<IsLegacyDataset>>): Dataset<IsLegacyDataset>;
+/**
+ * This function is deprecated. Use `initDataset` instead.
+ */
+declare function withDataset<R, IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET>(project: string, callback: (dataset: Dataset<IsLegacyDataset>) => R, options?: Readonly<InitDatasetOptions<IsLegacyDataset>>): R;
+type AsyncFlushArg<IsAsyncFlush> = {
+    asyncFlush?: IsAsyncFlush;
+};
+type InitLoggerOptions<IsAsyncFlush> = FullLoginOptions & {
+    projectName?: string;
+    projectId?: string;
+    setCurrent?: boolean;
+    state?: BraintrustState;
+} & AsyncFlushArg<IsAsyncFlush>;
+/**
+ * Create a new logger in a specified project. If the project does not exist, it will be created.
+ *
+ * @param options Additional options for configuring init().
+ * @param options.projectName The name of the project to log into. If unspecified, will default to the Global project.
+ * @param options.projectId The id of the project to log into. This takes precedence over projectName if specified.
+ * @param options.asyncFlush If true, will log asynchronously in the background. Otherwise, will log synchronously. (false by default, to support serverless environments)
+ * @param options.appUrl The URL of the Braintrust App. Defaults to https://www.braintrust.dev.
+ * @param options.apiKey The API key to use. If the parameter is not specified, will try to use the `BRAINTRUST_API_KEY` environment variable. If no API
+ * key is specified, will prompt the user to login.
+ * @param options.orgName (Optional) The name of a specific organization to connect to. This is useful if you belong to multiple.
+ * @param options.forceLogin Login again, even if you have already logged in (by default, the logger will not login if you are already logged in)
+ * @param setCurrent If true (the default), set the global current-experiment to the newly-created one.
+ * @returns The newly created Logger.
+ */
+declare function initLogger<IsAsyncFlush extends boolean = false>(options?: Readonly<InitLoggerOptions<IsAsyncFlush>>): Logger<IsAsyncFlush>;
+type LoadPromptOptions = FullLoginOptions & {
+    projectName?: string;
+    projectId?: string;
+    slug?: string;
+    version?: string;
+    defaults?: DefaultPromptArgs;
+    noTrace?: boolean;
+    state?: BraintrustState;
+};
+/**
+ * Load a prompt from the specified project.
+ *
+ * @param options Options for configuring loadPrompt().
+ * @param options.projectName The name of the project to load the prompt from. Must specify at least one of `projectName` or `projectId`.
+ * @param options.projectId The id of the project to load the prompt from. This takes precedence over `projectName` if specified.
+ * @param options.slug The slug of the prompt to load.
+ * @param options.version An optional version of the prompt (to read). If not specified, the latest version will be used.
+ * @param options.defaults (Optional) A dictionary of default values to use when rendering the prompt. Prompt values will override these defaults.
+ * @param options.noTrace If true, do not include logging metadata for this prompt when build() is called.
+ * @param options.appUrl The URL of the Braintrust App. Defaults to https://www.braintrust.dev.
+ * @param options.apiKey The API key to use. If the parameter is not specified, will try to use the `BRAINTRUST_API_KEY` environment variable. If no API
+ * key is specified, will prompt the user to login.
+ * @param options.orgName (Optional) The name of a specific organization to connect to. This is useful if you belong to multiple.
+ * @returns The prompt object.
+ * @throws If the prompt is not found.
+ * @throws If multiple prompts are found with the same slug in the same project (this should never happen).
+ *
+ * @example
+ * ```javascript
+ * const prompt = await loadPrompt({
+ *  projectName: "My Project",
+ *  slug: "my-prompt",
+ * });
+ * ```
+ */
+declare function loadPrompt({ projectName, projectId, slug, version, defaults, noTrace, appUrl, apiKey, orgName, fetch, forceLogin, state: stateArg, }: LoadPromptOptions): Promise<Prompt>;
+/**
+ * Options for logging in to Braintrust.
+ */
+interface LoginOptions {
+    /**
+     * The URL of the Braintrust App. Defaults to https://www.braintrust.dev. You should not need
+     * to change this unless you are doing the "Full" deployment.
+     */
+    appUrl?: string;
+    /**
+     * The API key to use. If the parameter is not specified, will try to use the `BRAINTRUST_API_KEY` environment variable.
+     */
+    apiKey?: string;
+    /**
+     * The name of a specific organization to connect to. Since API keys are scoped to organizations, this parameter is usually
+     * unnecessary unless you are logging in with a JWT.
+     */
+    orgName?: string;
+    /**
+     * A custom fetch implementation to use.
+     */
+    fetch?: typeof globalThis.fetch;
+}
+type FullLoginOptions = LoginOptions & {
+    forceLogin?: boolean;
+};
+/**
+ * Log into Braintrust. This will prompt you for your API token, which you can find at
+ * https://www.braintrust.dev/app/token. This method is called automatically by `init()`.
+ *
+ * @param options Options for configuring login().
+ * @param options.appUrl The URL of the Braintrust App. Defaults to https://www.braintrust.dev.
+ * @param options.apiKey The API key to use. If the parameter is not specified, will try to use the `BRAINTRUST_API_KEY` environment variable. If no API
+ * key is specified, will prompt the user to login.
+ * @param options.orgName (Optional) The name of a specific organization to connect to. This is useful if you belong to multiple.
+ * @param options.forceLogin Login again, even if you have already logged in (by default, this function will exit quickly if you have already logged in)
+ */
+declare function login(options?: LoginOptions & {
+    forceLogin?: boolean;
+}): Promise<BraintrustState>;
+declare function loginToState(options?: LoginOptions): Promise<BraintrustState>;
+/**
+ * Log a single event to the current experiment. The event will be batched and uploaded behind the scenes.
+ *
+ * @param event The event to log. See `Experiment.log` for full details.
+ * @returns The `id` of the logged event.
+ */
+declare function log(event: ExperimentLogFullArgs): string;
+/**
+ * Summarize the current experiment, including the scores (compared to the closest reference experiment) and metadata.
+ *
+ * @param options Options for summarizing the experiment.
+ * @param options.summarizeScores Whether to summarize the scores. If False, only the metadata will be returned.
+ * @param options.comparisonExperimentId The experiment to compare against. If None, the most recent experiment on the origin's main branch will be used.
+ * @returns A summary of the experiment, including the scores (compared to the closest reference experiment) and metadata.
+ */
+declare function summarize(options?: {
+    readonly summarizeScores?: boolean;
+    readonly comparisonExperimentId?: string;
+}): Promise<ExperimentSummary>;
+type OptionalStateArg = {
+    state?: BraintrustState;
+};
+/**
+ * Returns the currently-active experiment (set by `braintrust.init`). Returns undefined if no current experiment has been set.
+ */
+declare function currentExperiment(options?: OptionalStateArg): Experiment | undefined;
+/**
+ * Returns the currently-active logger (set by `braintrust.initLogger`). Returns undefined if no current logger has been set.
+ */
+declare function currentLogger<IsAsyncFlush extends boolean>(options?: AsyncFlushArg<IsAsyncFlush> & OptionalStateArg): Logger<IsAsyncFlush> | undefined;
+/**
+ * Return the currently-active span for logging (set by one of the `traced` methods). If there is no active span, returns a no-op span object, which supports the same interface as spans but does no logging.
+ *
+ * See `Span` for full details.
+ */
+declare function currentSpan(options?: OptionalStateArg): Span;
+/**
+ * Mainly for internal use. Return the parent object for starting a span in a global context.
+ */
+declare function getSpanParentObject<IsAsyncFlush extends boolean>(options?: AsyncFlushArg<IsAsyncFlush> & OptionalStateArg): Span | Experiment | Logger<IsAsyncFlush>;
+/**
+ * Toplevel function for starting a span. It checks the following (in precedence order):
+ *  * Currently-active span
+ *  * Currently-active experiment
+ *  * Currently-active logger
+ *
+ * and creates a span under the first one that is active. Alternatively, if `parent` is specified, it creates a span under the specified parent row. If none of these are active, it returns a no-op span object.
+ *
+ * See `Span.traced` for full details.
+ */
+declare function traced<IsAsyncFlush extends boolean = false, R = void>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg & AsyncFlushArg<IsAsyncFlush>): PromiseUnless<IsAsyncFlush, R>;
+/**
+ * Wrap a function with `traced`, using the arguments as `input` and return value as `output`.
+ * Any functions wrapped this way will automatically be traced, similar to the `@traced` decorator
+ * in Python. If you want to correctly propagate the function's name and define it in one go, then
+ * you can do so like this:
+ *
+ * ```ts
+ * const myFunc = wrapTraced(async function myFunc(input) {
+ *  const result = await client.chat.completions.create({
+ *    model: "gpt-3.5-turbo",
+ *    messages: [{ role: "user", content: input }],
+ *  });
+ *  return result.choices[0].message.content ?? "unknown";
+ * });
+ * ```
+ * Now, any calls to `myFunc` will be traced, and the input and output will be logged automatically.
+ * If tracing is inactive, i.e. there is no active logger or experiment, it's just a no-op.
+ *
+ * @param fn The function to wrap.
+ * @param args Span-level arguments (e.g. a custom name or type) to pass to `traced`.
+ * @returns The wrapped function.
+ */
+declare function wrapTraced<F extends (...args: any[]) => any, IsAsyncFlush extends boolean = false>(fn: F, args?: StartSpanArgs & SetCurrentArg & AsyncFlushArg<IsAsyncFlush>): IsAsyncFlush extends false ? (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>> : F;
+/**
+ * A synonym for `wrapTraced`. If you're porting from systems that use `traceable`, you can use this to
+ * make your codebase more consistent.
+ */
+declare const traceable: typeof wrapTraced;
+/**
+ * Lower-level alternative to `traced`. This allows you to start a span yourself, and can be useful in situations
+ * where you cannot use callbacks. However, spans started with `startSpan` will not be marked as the "current span",
+ * so `currentSpan()` and `traced()` will be no-ops. If you want to mark a span as current, use `traced` instead.
+ *
+ * See `traced` for full details.
+ */
+declare function startSpan<IsAsyncFlush extends boolean = false>(args?: StartSpanArgs & AsyncFlushArg<IsAsyncFlush> & OptionalStateArg): Span;
+/**
+ * Flush any pending rows to the server.
+ */
+declare function flush(options?: OptionalStateArg): Promise<void>;
+/**
+ * Set the fetch implementation to use for requests. You can specify it here,
+ * or when you call `login`.
+ *
+ * @param fetch The fetch implementation to use.
+ */
+declare function setFetch(fetch: typeof globalThis.fetch): void;
+type WithTransactionId<R> = R & {
+    [TRANSACTION_ID_FIELD]: TransactionId;
+};
+declare class ObjectFetcher<RecordType> implements AsyncIterable<WithTransactionId<RecordType>> {
+    private objectType;
+    private pinnedVersion;
+    private mutateRecord?;
+    private _fetchedData;
+    constructor(objectType: "dataset" | "experiment", pinnedVersion: string | undefined, mutateRecord?: ((r: any) => RecordType) | undefined);
+    get id(): Promise<string>;
+    protected getState(): Promise<BraintrustState>;
+    fetch(): AsyncGenerator<WithTransactionId<RecordType>>;
+    [Symbol.asyncIterator](): AsyncIterator<WithTransactionId<RecordType>>;
+    fetchedData(): Promise<WithTransactionId<RecordType>[]>;
+    clearCache(): void;
+    version(): Promise<string | undefined>;
+}
+type BaseMetadata = Record<string, unknown> | void;
+type DefaultMetadataType = void;
+type EvalCase<Input, Expected, Metadata> = {
+    input: Input;
+    tags?: string[];
+} & (Expected extends void ? {} : {
+    expected: Expected;
+}) & (Metadata extends void ? {} : {
+    metadata: Metadata;
+});
+/**
+ * An experiment is a collection of logged events, such as model inputs and outputs, which represent
+ * a snapshot of your application at a particular point in time. An experiment is meant to capture more
+ * than just the model you use, and includes the data you use to test, pre- and post- processing code,
+ * comparison metrics (scores), and any other metadata you want to include.
+ *
+ * Experiments are associated with a project, and two experiments are meant to be easily comparable via
+ * their `inputs`. You can change the attributes of the experiments in a project (e.g. scoring functions)
+ * over time, simply by changing what you log.
+ *
+ * You should not create `Experiment` objects directly. Instead, use the `braintrust.init()` method.
+ */
+declare class Experiment extends ObjectFetcher<ExperimentEvent> implements Exportable {
+    private readonly lazyMetadata;
+    readonly dataset?: AnyDataset;
+    private lastStartTime;
+    private lazyId;
+    private calledStartSpan;
+    private state;
+    kind: "experiment";
+    constructor(state: BraintrustState, lazyMetadata: LazyValue<ProjectExperimentMetadata>, dataset?: AnyDataset);
+    get id(): Promise<string>;
+    get name(): Promise<string>;
+    get project(): Promise<ObjectMetadata>;
+    private parentObjectType;
+    protected getState(): Promise<BraintrustState>;
+    /**
+     * Log a single event to the experiment. The event will be batched and uploaded behind the scenes.
+     *
+     * @param event The event to log.
+     * @param event.input: The arguments that uniquely define a test case (an arbitrary, JSON serializable object). Later on, Braintrust will use the `input` to know whether two test cases are the same between experiments, so they should not contain experiment-specific state. A simple rule of thumb is that if you run the same experiment twice, the `input` should be identical.
+     * @param event.output: The output of your application, including post-processing (an arbitrary, JSON serializable object), that allows you to determine whether the result is correct or not. For example, in an app that generates SQL queries, the `output` should be the _result_ of the SQL query generated by the model, not the query itself, because there may be multiple valid queries that answer a single question.
+     * @param event.expected: (Optional) The ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to determine if your `output` value is correct or not. Braintrust currently does not compare `output` to `expected` for you, since there are so many different ways to do that correctly. Instead, these values are just used to help you navigate your experiments while digging into analyses. However, we may later use these values to re-score outputs or fine-tune your models.
+     * @param event.scores: A dictionary of numeric values (between 0 and 1) to log. The scores should give you a variety of signals that help you determine how accurate the outputs are compared to what you expect and diagnose failures. For example, a summarization app might have one score that tells you how accurate the summary is, and another that measures the word similarity between the generated and grouth truth summary. The word similarity score could help you determine whether the summarization was covering similar concepts or not. You can use these scores to help you sort, filter, and compare experiments.
+     * @param event.metadata: (Optional) a dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings.
+     * @param event.metrics: (Optional) a dictionary of metrics to log. The following keys are populated automatically: "start", "end".
+     * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
+     * @param event.dataset_record_id: (Optional) the id of the dataset record that this event is associated with. This field is required if and only if the experiment is associated with a dataset.
+     * @param event.inputs: (Deprecated) the same as `input` (will be removed in a future version).
+     * @param options Additional logging options
+     * @param options.allowConcurrentWithSpans in rare cases where you need to log at the top level separately from spans on the experiment elsewhere, set this to true.
+     * :returns: The `id` of the logged event.
+     */
+    log(event: Readonly<ExperimentLogFullArgs>, options?: {
+        allowConcurrentWithSpans?: boolean;
+    }): string;
+    /**
+     * Create a new toplevel span underneath the experiment. The name defaults to "root".
+     *
+     * See `Span.traced` for full details.
+     */
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    /**
+     * Lower-level alternative to `traced`. This allows you to start a span yourself, and can be useful in situations
+     * where you cannot use callbacks. However, spans started with `startSpan` will not be marked as the "current span",
+     * so `currentSpan()` and `traced()` will be no-ops. If you want to mark a span as current, use `traced` instead.
+     *
+     * See `traced` for full details.
+     */
+    startSpan(args?: StartSpanArgs): Span;
+    private startSpanImpl;
+    fetchBaseExperiment(): Promise<{
+        id: any;
+        name: any;
+    } | null>;
+    /**
+     * Summarize the experiment, including the scores (compared to the closest reference experiment) and metadata.
+     *
+     * @param options Options for summarizing the experiment.
+     * @param options.summarizeScores Whether to summarize the scores. If False, only the metadata will be returned.
+     * @param options.comparisonExperimentId The experiment to compare against. If None, the most recent experiment on the origin's main branch will be used.
+     * @returns A summary of the experiment, including the scores (compared to the closest reference experiment) and metadata.
+     */
+    summarize(options?: {
+        readonly summarizeScores?: boolean;
+        readonly comparisonExperimentId?: string;
+    }): Promise<ExperimentSummary>;
+    /**
+     * Log feedback to an event in the experiment. Feedback is used to save feedback scores, set an expected value, or add a comment.
+     *
+     * @param event
+     * @param event.id The id of the event to log feedback for. This is the `id` returned by `log` or accessible as the `id` field of a span.
+     * @param event.scores (Optional) a dictionary of numeric values (between 0 and 1) to log. These scores will be merged into the existing scores for the event.
+     * @param event.expected (Optional) the ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to determine if your `output` value is correct or not.
+     * @param event.comment (Optional) an optional comment string to log about the event.
+     * @param event.metadata (Optional) a dictionary with additional data about the feedback. If you have a `user_id`, you can log it here and access it in the Braintrust UI.
+     * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
+     */
+    logFeedback(event: LogFeedbackFullArgs): void;
+    /**
+     * Return a serialized representation of the experiment that can be used to start subspans in other places. See `Span.start_span` for more details.
+     */
+    export(): Promise<string>;
+    /**
+     * Flush any pending rows to the server.
+     */
+    flush(): Promise<void>;
+    /**
+     * This function is deprecated. You can simply remove it from your code.
+     */
+    close(): Promise<string>;
+}
+/**
+ * A read-only view of an experiment, initialized by passing `open: true` to `init()`.
+ */
+declare class ReadonlyExperiment extends ObjectFetcher<ExperimentEvent> {
+    private state;
+    private readonly lazyMetadata;
+    constructor(state: BraintrustState, lazyMetadata: LazyValue<ProjectExperimentMetadata>);
+    get id(): Promise<string>;
+    get name(): Promise<string>;
+    protected getState(): Promise<BraintrustState>;
+    asDataset<Input, Expected>(): AsyncGenerator<EvalCase<Input, Expected, void>>;
+}
+declare function newId(): string;
+/**
+ * Primary implementation of the `Span` interface. See the `Span` interface for full details on each method.
+ *
+ * We suggest using one of the various `traced` methods, instead of creating Spans directly. See `Span.startSpan` for full details.
+ */
+declare class SpanImpl implements Span {
+    private state;
+    private isMerge;
+    private loggedEndTime;
+    private parentObjectType;
+    private parentObjectId;
+    private parentComputeObjectMetadataArgs;
+    private _id;
+    private spanId;
+    private rootSpanId;
+    private spanParents;
+    kind: "span";
+    constructor(args: {
+        state: BraintrustState;
+        parentObjectType: SpanObjectTypeV2;
+        parentObjectId: LazyValue<string>;
+        parentComputeObjectMetadataArgs: Record<string, any> | undefined;
+        parentSpanIds: ParentSpanIds | undefined;
+        defaultRootType?: SpanType;
+    } & Omit<StartSpanArgs, "parent">);
+    get id(): string;
+    setAttributes(args: Omit<StartSpanArgs, "event">): void;
+    log(event: ExperimentLogPartialArgs): void;
+    private logInternal;
+    logFeedback(event: Omit<LogFeedbackFullArgs, "id">): void;
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    startSpan(args?: StartSpanArgs): Span;
+    end(args?: EndSpanArgs): number;
+    export(): Promise<string>;
+    flush(): Promise<void>;
+    close(args?: EndSpanArgs): number;
+}
+/**
+ * A dataset is a collection of records, such as model inputs and expected outputs, which represent
+ * data you can use to evaluate and fine-tune models. You can log production data to datasets,
+ * curate them with interesting examples, edit/delete records, and run evaluations against them.
+ *
+ * You should not create `Dataset` objects directly. Instead, use the `braintrust.initDataset()` method.
+ */
+declare class Dataset<IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET> extends ObjectFetcher<DatasetRecord<IsLegacyDataset>> {
+    private state;
+    private readonly lazyMetadata;
+    constructor(state: BraintrustState, lazyMetadata: LazyValue<ProjectDatasetMetadata>, pinnedVersion?: string, legacy?: IsLegacyDataset);
+    get id(): Promise<string>;
+    get name(): Promise<string>;
+    get project(): Promise<ObjectMetadata>;
+    protected getState(): Promise<BraintrustState>;
+    /**
+     * Insert a single record to the dataset. The record will be batched and uploaded behind the scenes. If you pass in an `id`,
+     * and a record with that `id` already exists, it will be overwritten (upsert).
+     *
+     * @param event The event to log.
+     * @param event.input The argument that uniquely define an input case (an arbitrary, JSON serializable object).
+     * @param event.expected The output of your application, including post-processing (an arbitrary, JSON serializable object).
+     * @param event.tags (Optional) a list of strings that you can use to filter and group records later.
+     * @param event.metadata (Optional) a dictionary with additional data about the test example, model outputs, or just
+     * about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the
+     * `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any
+     * JSON-serializable type, but its keys must be strings.
+     * @param event.id (Optional) a unique identifier for the event. If you don't provide one, Braintrust will generate one for you.
+     * @param event.output: (Deprecated) The output of your application. Use `expected` instead.
+     * @returns The `id` of the logged record.
+     */
+    insert({ input, expected, metadata, tags, id, output, }: {
+        readonly input?: unknown;
+        readonly expected?: unknown;
+        readonly tags?: string[];
+        readonly metadata?: Record<string, unknown>;
+        readonly id?: string;
+        readonly output?: unknown;
+    }): string;
+    delete(id: string): string;
+    /**
+     * Summarize the dataset, including high level metrics about its size and other metadata.
+     * @param summarizeData Whether to summarize the data. If false, only the metadata will be returned.
+     * @returns `DatasetSummary`
+     * @returns A summary of the dataset.
+     */
+    summarize(options?: {
+        readonly summarizeData?: boolean;
+    }): Promise<DatasetSummary>;
+    /**
+     * Flush any pending rows to the server.
+     */
+    flush(): Promise<void>;
+    /**
+     * This function is deprecated. You can simply remove it from your code.
+     */
+    close(): Promise<string>;
+}
+type CompiledPromptParams = Omit<NonNullable<PromptData["options"]>["params"], "use_cache"> & {
+    model: NonNullable<NonNullable<PromptData["options"]>["model"]>;
+};
+type ChatPrompt = {
+    messages: OpenAIMessage[];
+    tools?: Tools;
+};
+type CompletionPrompt = {
+    prompt: string;
+};
+type CompiledPrompt<Flavor extends "chat" | "completion"> = CompiledPromptParams & {
+    span_info?: {
+        name?: string;
+        spanAttributes?: Record<any, any>;
+        metadata: {
+            prompt: {
+                variables: Record<string, unknown>;
+                id: string;
+                project_id: string;
+                version: string;
+            };
+        };
+    };
+} & (Flavor extends "chat" ? ChatPrompt : Flavor extends "completion" ? CompletionPrompt : {});
+type DefaultPromptArgs = Partial<CompiledPromptParams & AnyModelParam & ChatPrompt & CompletionPrompt>;
+declare class Prompt {
+    private metadata;
+    private defaults;
+    private noTrace;
+    constructor(metadata: Omit<Prompt$1, "log_id"> | PromptSessionEvent, defaults: DefaultPromptArgs, noTrace: boolean);
+    get id(): string;
+    get projectId(): string;
+    get name(): string;
+    get slug(): string;
+    get prompt(): PromptData["prompt"];
+    get version(): TransactionId;
+    get options(): NonNullable<PromptData["options"]>;
+    /**
+     * Build the prompt with the given formatting options. The args you pass in will
+     * be forwarded to the mustache template that defines the prompt and rendered with
+     * the `mustache-js` library.
+     *
+     * @param buildArgs Args to forward along to the prompt template.
+     */
+    build<Flavor extends "chat" | "completion" = "chat">(buildArgs: unknown, options?: {
+        flavor?: Flavor;
+    }): CompiledPrompt<Flavor>;
+    private runBuild;
+}
+type AnyDataset = Dataset<boolean>;
+/**
+ * Summary of a score's performance.
+ * @property name Name of the score.
+ * @property score Average score across all examples.
+ * @property diff Difference in score between the current and reference experiment.
+ * @property improvements Number of improvements in the score.
+ * @property regressions Number of regressions in the score.
+ */
+interface ScoreSummary {
+    name: string;
+    score: number;
+    diff?: number;
+    improvements: number;
+    regressions: number;
+}
+/**
+ * Summary of a metric's performance.
+ * @property name Name of the metric.
+ * @property metric Average metric across all examples.
+ * @property unit Unit label for the metric.
+ * @property diff Difference in metric between the current and reference experiment.
+ * @property improvements Number of improvements in the metric.
+ * @property regressions Number of regressions in the metric.
+ */
+interface MetricSummary {
+    name: string;
+    metric: number;
+    unit: string;
+    diff?: number;
+    improvements: number;
+    regressions: number;
+}
+/**
+ * Summary of an experiment's scores and metadata.
+ * @property projectName Name of the project that the experiment belongs to.
+ * @property experimentName Name of the experiment.
+ * @property experimentId ID of the experiment. May be `undefined` if the eval was run locally.
+ * @property projectUrl URL to the project's page in the Braintrust app.
+ * @property experimentUrl URL to the experiment's page in the Braintrust app.
+ * @property comparisonExperimentName The experiment scores are baselined against.
+ * @property scores Summary of the experiment's scores.
+ */
+interface ExperimentSummary {
+    projectName: string;
+    experimentName: string;
+    projectId?: string;
+    experimentId?: string;
+    projectUrl?: string;
+    experimentUrl?: string;
+    comparisonExperimentName?: string;
+    scores: Record<string, ScoreSummary>;
+    metrics?: Record<string, MetricSummary>;
+}
+/**
+ * Summary of a dataset's data.
+ *
+ * @property newRecords New or updated records added in this session.
+ * @property totalRecords Total records in the dataset.
+ */
+interface DataSummary {
+    newRecords: number;
+    totalRecords: number;
+}
+/**
+ * Summary of a dataset's scores and metadata.
+ *
+ * @property projectName Name of the project that the dataset belongs to.
+ * @property datasetName Name of the dataset.
+ * @property projectUrl URL to the project's page in the Braintrust app.
+ * @property datasetUrl URL to the experiment's page in the Braintrust app.
+ * @property dataSummary Summary of the dataset's data.
+ */
+interface DatasetSummary {
+    projectName: string;
+    datasetName: string;
+    projectUrl: string;
+    datasetUrl: string;
+    dataSummary: DataSummary;
+}
+
+type BraintrustStreamChunk = {
+    type: "text_delta";
+    data: string;
+} | {
+    type: "json_delta";
+    data: string;
+};
+declare class BraintrustStream {
+    private stream;
+    constructor(baseStream: ReadableStream<Uint8Array>);
+    constructor(stream: ReadableStream<string>);
+    constructor(stream: ReadableStream<BraintrustStreamChunk>);
+    copy(): BraintrustStream;
+    toReadableStream(): ReadableStream<BraintrustStreamChunk>;
+}
+declare function createFinalValuePassThroughStream<T extends BraintrustStreamChunk | string | Uint8Array>(onFinal: (result: unknown) => void): TransformStream<T, BraintrustStreamChunk>;
+declare function devNullWritableStream(): WritableStream;
+
+type InvokeReturn<Stream extends boolean, Return> = Stream extends true ? BraintrustStream : Return;
+type InvokeFunctionArgs<Arg, Return, Stream extends boolean = false> = FunctionId & FullLoginOptions & {
+    arg: Arg;
+    parent?: Exportable | string;
+    state?: BraintrustState;
+    stream?: Stream;
+    schema?: z.ZodSchema<Return>;
+};
+declare function invoke<Arg, Return, Stream extends boolean = false>(args: InvokeFunctionArgs<Arg, Return, Stream>): Promise<InvokeReturn<Stream, Return>>;
+
+interface BetaLike {
+    chat: {
+        completions: {
+            stream: any;
+        };
+    };
+    embeddings: any;
+}
+interface ChatLike {
+    completions: any;
+}
+interface OpenAILike {
+    chat: ChatLike;
+    embeddings: any;
+    beta?: BetaLike;
+}
+declare global {
+    var __inherited_braintrust_wrap_openai: ((openai: any) => any) | undefined;
+}
+/**
+ * Wrap an `OpenAI` object (created with `new OpenAI(...)`) to add tracing. If Braintrust is
+ * not configured, this is a no-op
+ *
+ * Currently, this only supports the `v4` API.
+ *
+ * @param openai
+ * @returns The wrapped `OpenAI` object.
+ */
+declare function wrapOpenAI<T extends object>(openai: T): T;
+declare function wrapOpenAIv4<T extends OpenAILike>(openai: T): T;
+declare const LEGACY_CACHED_HEADER = "x-cached";
+declare const X_CACHED_HEADER = "x-bt-cached";
+declare function parseCachedHeader(value: string | null | undefined): number | undefined;
+
+export { type AnyDataset, type BaseMetadata, BraintrustState, BraintrustStream, type BraintrustStreamChunk, type ChatPrompt, type CompiledPrompt, type CompiledPromptParams, type CompletionPrompt, type DataSummary, Dataset, type DatasetSummary, type DefaultMetadataType, type DefaultPromptArgs, type EndSpanArgs, type EvalCase, Experiment, type ExperimentSummary, type Exportable, type FullInitOptions, type FullLoginOptions, type InitOptions, type InvokeFunctionArgs, type InvokeReturn, LEGACY_CACHED_HEADER, type LogOptions, Logger, type LoginOptions, type MetricSummary, NOOP_SPAN, NoopSpan, type ObjectMetadata, type PromiseUnless, Prompt, ReadonlyExperiment, type ScoreSummary, type SerializedBraintrustState, type SetCurrentArg, type Span, SpanImpl, type StartSpanArgs, type WithTransactionId, X_CACHED_HEADER, _internalGetGlobalState, _internalSetInitialState, createFinalValuePassThroughStream, currentExperiment, currentLogger, currentSpan, devNullWritableStream, flush, getSpanParentObject, init, initDataset, initExperiment, initLogger, invoke, loadPrompt, log, login, loginToState, newId, parseCachedHeader, setFetch, startSpan, summarize, traceable, traced, withDataset, withExperiment, withLogger, wrapOpenAI, wrapOpenAIv4, wrapTraced };