braintrust 0.0.84 → 0.0.86

package/dist/logger.d.ts

@@ -7,20 +7,20 @@ export type SetCurrentArg = {
 };
 type StartSpanEventArgs = ExperimentLogPartialArgs & Partial<IdField>;
 export type StartSpanArgs = {
+    name?: string;
     spanAttributes?: Record<any, any>;
     startTime?: number;
     event?: StartSpanEventArgs;
 };
-export type StartSpanOptionalNameArgs = StartSpanArgs & {
-    name?: string;
-};
 export type EndSpanArgs = {
     endTime?: number;
 };
 /**
  * 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 `startSpan` methods, instead of creating Spans directly. See `Span.startSpan` for full details.
+ * We suggest using one of the various `traced` methods, instead of creating Spans directly.
+ *
+ * See `Span.traced` for full details.
  */
 export interface Span {
     /**
@@ -42,27 +42,31 @@ export interface Span {
      */
     log(event: ExperimentLogPartialArgs): void;
     /**
-     * Create a new span. 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.
+     * 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.
      *
-     * We recommend running spans within a callback (using `traced`) to automatically mark them as current and ensure they are terminated. If you wish to start a span outside a callback, be sure to terminate it with `span.end()`.
+     * Spans created within `traced` are ended automatically. By default, the span is marked as current, so they can be accessed using `braintrust.currentSpan`.
      *
-     * @param name The name of the span.
+     * @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.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.event Data to be logged. See `Experiment.log` for full details.
-     * @returns The newly-created `Span`
+     * @Returns The result of running `callback`.
      */
-    startSpan(name: string, args?: StartSpanArgs): Span;
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
     /**
-     * Wrapper over `Span.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.startSpan` for full details.
+     * Lower-level alternative to `traced`, which does not automatically end the span or mark it as current. Be sure to end the span with `span.end()` when it has finished.
+     *
+     * See `traced` for full details.
      *
-     * @param args.setCurrent If true (the default), the span will be marked as the currently-active span for the duration of the callback. Equivalent to calling `braintrust.withCurrent(span, callback)`.
+     * @returns The newly-created `Span`
      */
-    traced<R>(name: string, callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    startSpan(args?: StartSpanArgs): Span;
     /**
-     * Terminate the span. Returns the end time logged to the row's metrics. After calling end, you may not invoke any further methods on the span object, except for the property accessors.
+     * 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.
+     * 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.
@@ -84,19 +88,19 @@ export declare class NoopSpan implements Span {
     kind: "span";
     constructor();
     log(_: ExperimentLogPartialArgs): void;
-    startSpan(_0: string, _1?: StartSpanArgs): this;
-    traced<R>(_0: string, callback: (span: Span) => R, _1: StartSpanArgs & SetCurrentArg): R;
+    traced<R>(callback: (span: Span) => R, _1: StartSpanArgs & SetCurrentArg): R;
+    startSpan(_1?: StartSpanArgs): this;
     end(args?: EndSpanArgs): number;
     close(args?: EndSpanArgs): number;
 }
-export declare const noopSpan: NoopSpan;
+export declare const NOOP_SPAN: NoopSpan;
 declare global {
     var __inherited_braintrust_state: BraintrustState;
 }
 declare class BraintrustState {
     id: string;
-    currentExperiment: IsoAsyncLocalStorage<Experiment | undefined>;
-    currentLogger: IsoAsyncLocalStorage<Logger | undefined>;
+    currentExperiment: Experiment | undefined;
+    currentLogger: Logger<false> | undefined;
     currentSpan: IsoAsyncLocalStorage<Span>;
     apiUrl: string | null;
     loginToken: string | null;
@@ -107,6 +111,7 @@ declare class BraintrustState {
     private _apiConn;
     private _logConn;
     constructor();
+    resetLoginInfo(): void;
     apiConn(): HTTPConnection;
     logConn(): HTTPConnection;
 }
@@ -127,32 +132,37 @@ declare class HTTPConnection {
     get_json(object_type: string, args?: Record<string, string> | undefined, retries?: number): Promise<any>;
     post_json(object_type: string, args?: Record<string, unknown> | string | undefined): Promise<any>;
 }
-interface RegisteredProject {
+export interface ObjectMetadata {
     id: string;
     name: string;
+    fullInfo: Record<string, unknown>;
 }
-declare class Project {
-    name?: string;
-    id?: string;
-    constructor({ name, id }: {
-        name?: string;
-        id?: string;
-    });
-    lazyInit(): Promise<RegisteredProject>;
+interface ProjectExperimentMetadata {
+    project: ObjectMetadata;
+    experiment: ObjectMetadata;
+}
+interface ProjectDatasetMetadata {
+    project: ObjectMetadata;
+    dataset: ObjectMetadata;
+}
+interface OrgProjectMetadata {
+    org_id: string;
+    project: ObjectMetadata;
 }
-export interface LogOptions {
-    asyncFlush?: boolean;
+export interface LogOptions<IsAsyncFlush> {
+    asyncFlush?: IsAsyncFlush;
 }
-export declare class Logger {
-    private _lazyLogin;
-    private loggedIn;
-    private lazyProject;
+export type PromiseUnless<B, R> = B extends true ? R : Promise<Awaited<R>>;
+export declare class Logger<IsAsyncFlush extends boolean> {
+    private lazyMetadata;
     private logOptions;
     private bgLogger;
     private lastStartTime;
     kind: "logger";
-    constructor(lazyLogin: () => Promise<void>, lazyProject: Project, logOptions?: LogOptions);
-    private lazyLogin;
+    constructor(lazyMetadata: Promise<OrgProjectMetadata>, logOptions?: LogOptions<IsAsyncFlush>);
+    get org_id(): Promise<string>;
+    get project(): Promise<ObjectMetadata>;
+    private getState;
     /**
      * Log a single event. The event will be batched and uploaded behind the scenes if `logOptions.asyncFlush` is true.
      *
@@ -166,18 +176,21 @@ export declare class Logger {
      * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
      * :returns: The `id` of the logged event.
      */
-    log(event: Readonly<StartSpanEventArgs>): Promise<string>;
+    log(event: Readonly<StartSpanEventArgs>): PromiseUnless<IsAsyncFlush, string>;
     /**
-     * Create a new toplevel span. The name parameter is optional and defaults to "root".
+     * Create a new toplevel span underneath the logger. The name defaults to "root".
      *
-     * See `Span.startSpan` for full details.
+     * See `Span.traced` for full details.
      */
-    startSpan(args?: StartSpanOptionalNameArgs): Promise<Span>;
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): PromiseUnless<IsAsyncFlush, R>;
     /**
-     * Wrapper over `Logger.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.traced` for full details.
+     * Lower-level alternative to `traced`, which does not automatically end the span or mark it as current.
+     *
+     * See `traced` for full details.
      */
-    traced<R>(callback: (span: Span) => R, args?: StartSpanOptionalNameArgs & SetCurrentArg): Promise<R>;
+    startSpan(args?: StartSpanArgs): Span;
     flush(): Promise<void>;
+    get asyncFlush(): IsAsyncFlush | undefined;
 }
 export type IdField = {
     id: string;
@@ -231,11 +244,12 @@ export interface DatasetRecord {
     metadata: any;
 }
 declare class BackgroundLogger {
+    private logConn;
     private items;
     private active_flush;
     private active_flush_resolved;
-    constructor();
-    log(items: BackgroundLogEvent[]): void;
+    constructor(logConn: Promise<HTTPConnection>);
+    log(items: Promise<BackgroundLogEvent>[]): void;
     flush_once(batchSize?: number): Promise<string[]>;
     flush(): Promise<void>;
 }
@@ -249,14 +263,12 @@ export type InitOptions = {
     apiUrl?: string;
     apiKey?: string;
     orgName?: string;
-    disableCache?: boolean;
     metadata?: Metadata;
+    setCurrent?: boolean;
 };
 /**
  * Log in, and then initialize a new experiment in a specified project. If the project does not exist, it will be created.
  *
- * Remember to close your experiment when it is finished by calling `Experiment.close`. We recommend initializing the experiment within a callback (using `braintrust.withExperiment`) to automatically mark it as current and ensure it is terminated.
- *
  * @param project The name of the project to create the experiment in.
  * @param options Additional options for configuring init().
  * @param options.experiment The name of the experiment to create. If not specified, a name will be generated automatically.
@@ -271,26 +283,22 @@ export type InitOptions = {
  * @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.disableCache Do not use cached login information.
  * @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 setCurrent If true (the default), set the global current-experiment to the newly-created one.
  * @returns The newly created Experiment.
  */
-export declare function init(project: string, options?: Readonly<InitOptions>): Promise<Experiment>;
+export declare function init(project: string, options?: Readonly<InitOptions>): Experiment;
 /**
- * Wrapper over `braintrust.init`, which passes the initialized `Experiment` it to the given callback and closes it afterwards. See `braintrust.init` for full details.
- *
- * @param options.setCurrent If true (default), set the currently-active experiment to the newly-created one. Equivalent to calling `braintrust.withCurrent(experiment, callback)`.
+ * This function is deprecated. Use `init` instead.
  */
-export declare function withExperiment<R>(project: string, callback: (experiment: Experiment) => R, options?: Readonly<InitOptions & SetCurrentArg>): Promise<R>;
+export declare function withExperiment<R>(project: string, callback: (experiment: Experiment) => R, options?: Readonly<InitOptions & SetCurrentArg>): R;
 /**
- * Wrapper over `braintrust.initLogger`, which passes the initialized `Logger` it to the given callback and closes it afterwards. See `braintrust.initLogger` for full details.
- *
- * @param options.setCurrent If true (default), set the currently-active logger to the newly-created one. Equivalent to calling `braintrust.withCurrent(logger, callback)`.
+ * This function is deprecated. Use `initLogger` instead.
  */
-export declare function withLogger<R>(callback: (logger: Logger) => R, options?: Readonly<InitLoggerOptions & SetCurrentArg>): Promise<R>;
+export declare function withLogger<IsAsyncFlush extends boolean = false, R = void>(callback: (logger: Logger<IsAsyncFlush>) => R, options?: Readonly<InitLoggerOptions<IsAsyncFlush> & SetCurrentArg>): R;
 type InitDatasetOptions = {
     dataset?: string;
     description?: string;
@@ -298,13 +306,10 @@ type InitDatasetOptions = {
     apiUrl?: string;
     apiKey?: string;
     orgName?: string;
-    disableCache?: boolean;
 };
 /**
  * Create a new dataset in a specified project. If the project does not exist, it will be created.
  *
- * Remember to close your dataset when it is finished by calling `Dataset.close`. We recommend initializing the dataset within a callback (using `braintrust.withDataset`) to ensure it is terminated.
- *
  * @param project The name of the project to create the dataset in.
  * @param options Additional options for configuring init().
  * @param options.dataset The name of the dataset to create. If not specified, a name will be generated automatically.
@@ -313,23 +318,25 @@ type InitDatasetOptions = {
  * @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.disableCache Do not use cached login information.
  * @returns The newly created Dataset.
  */
-export declare function initDataset(project: string, options?: Readonly<InitDatasetOptions>): Promise<Dataset>;
+export declare function initDataset(project: string, options?: Readonly<InitDatasetOptions>): Dataset;
 /**
- * Wrapper over `braintrust.initDataset`, which passes the initialized `Dataset` it to the given callback and closes it afterwards. See `braintrust.initDataset` for full details.
+ * This function is deprecated. Use `initDataset` instead.
  */
-export declare function withDataset<R>(project: string, callback: (dataset: Dataset) => R, options?: Readonly<InitDatasetOptions>): Promise<R>;
-type InitLoggerOptions = {
+export declare function withDataset<R>(project: string, callback: (dataset: Dataset) => R, options?: Readonly<InitDatasetOptions>): R;
+type AsyncFlushArg<IsAsyncFlush> = {
+    asyncFlush?: IsAsyncFlush;
+};
+type InitLoggerOptions<IsAsyncFlush> = {
     projectName?: string;
     projectId?: string;
-    asyncFlush?: boolean;
     apiUrl?: string;
     apiKey?: string;
     orgName?: string;
-    disableCache?: boolean;
-};
+    forceLogin?: boolean;
+    setCurrent?: boolean;
+} & AsyncFlushArg<IsAsyncFlush>;
 /**
  * Create a new logger in a specified project. If the project does not exist, it will be created.
  *
@@ -341,10 +348,11 @@ type InitLoggerOptions = {
  * @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.disableCache Do not use cached login information.
+ * @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.
  */
-export declare function initLogger(options?: Readonly<InitLoggerOptions>): Logger;
+export declare function initLogger<IsAsyncFlush extends boolean = false>(options?: Readonly<InitLoggerOptions<IsAsyncFlush>>): Logger<IsAsyncFlush>;
 /**
  * Log into Braintrust. This will prompt you for your API token, which you can find at
  * https://www.braintrustdata.com/app/token. This method is called automatically by `init()`.
@@ -354,14 +362,12 @@ export declare function initLogger(options?: Readonly<InitLoggerOptions>): Logge
  * @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.disableCache Do not use cached login information.
  * @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)
  */
 export declare function login(options?: {
     apiUrl?: string;
     apiKey?: string;
     orgName?: string;
-    disableCache?: boolean;
     forceLogin?: boolean;
 }): Promise<void>;
 /**
@@ -384,45 +390,38 @@ export declare function summarize(options?: {
     readonly comparisonExperimentId?: string;
 }): Promise<ExperimentSummary>;
 /**
- * Returns the currently-active experiment (set by `braintrust.withExperiment` or `braintrust.withCurrent`). Returns undefined if no current experiment has been set.
+ * Returns the currently-active experiment (set by `braintrust.init`). Returns undefined if no current experiment has been set.
  */
 export declare function currentExperiment(): Experiment | undefined;
 /**
- * Returns the currently-active logger (set by `braintrust.withLogger` or `braintrust.withCurrent`). Returns undefined if no current logger has been set.
+ * Returns the currently-active logger (set by `braintrust.initLogger`). Returns undefined if no current logger has been set.
  */
-export declare function currentLogger(): Logger | undefined;
+export declare function currentLogger<IsAsyncFlush extends boolean>(options?: AsyncFlushArg<IsAsyncFlush>): Logger<IsAsyncFlush> | undefined;
 /**
- * Return the currently-active span for logging (set by `traced` or `braintrust.withCurrent`). If there is no active span, returns a no-op span object, which supports the same interface as spans but does no logging.
+ * 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.
  */
 export declare function currentSpan(): Span;
+/**
+ * Mainly for internal use. Return the parent object for starting a span in a global context.
+ */
+export declare function getSpanParentObject<IsAsyncFlush extends boolean>(options?: AsyncFlushArg<IsAsyncFlush>): 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 in the first one that is active. If none of these are active, it returns a no-op span object.
- *
- * Unless a name is explicitly provided, the name of the span will be the name of the calling function, or "root" if no meaningful name can be determined.
+ * and creates a span under the first one that is active. If none of these are active, it returns a no-op span object.
  *
- * We recommend running spans within a callback (using `traced`) to automatically mark them as current and ensure they are terminated. If you wish to start a span outside a callback, be sure to terminate it with `span.end()`.
- *
- * See `Span.startSpan` for full details.
- */
-export declare function startSpan(args?: StartSpanOptionalNameArgs): Span;
-/**
- * Wrapper over `braintrust.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.traced` for full details.
+ * See `Span.traced` for full details.
  */
-export declare function traced<R>(callback: (span: Span) => R, args?: StartSpanOptionalNameArgs & SetCurrentArg): R;
+export declare function traced<IsAsyncFlush extends boolean = false, R = void>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg & AsyncFlushArg<IsAsyncFlush>): PromiseUnless<IsAsyncFlush, R>;
 /**
- * Set the given experiment or span as current within the given callback and any asynchronous operations created within the callback. The current experiment can be accessed with `braintrust.currentExperiment`, and the current span with `braintrust.currentSpan`.
- *
- * @param object: The experiment or span to be marked as current.
- * @param callback: The callback to be run under the scope of the current object.
+ * Lower-level alternative to `traced`, which does not automatically end the span or mark it as current. See `traced` for full details.
  */
-export declare function withCurrent<R>(object: Experiment | Logger | Span, callback: () => R): R;
+export declare function startSpan<IsAsyncFlush extends boolean = false>(args?: StartSpanArgs & AsyncFlushArg<IsAsyncFlush>): Span;
 /**
  * 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
@@ -436,15 +435,16 @@ export declare function withCurrent<R>(object: Experiment | Logger | Span, callb
  * You should not create `Experiment` objects directly. Instead, use the `braintrust.init()` method.
  */
 export declare class Experiment {
-    readonly project: RegisteredProject;
-    readonly id: string;
-    readonly name: string;
+    private readonly lazyMetadata;
     readonly dataset?: Dataset;
     private bgLogger;
     private lastStartTime;
-    private finished;
     kind: "experiment";
-    constructor(project: RegisteredProject, id: string, name: string, dataset?: Dataset);
+    constructor(lazyMetadata: Promise<ProjectExperimentMetadata>, dataset?: Dataset);
+    get id(): Promise<string>;
+    get name(): Promise<string>;
+    get project(): Promise<ObjectMetadata>;
+    private getState;
     /**
      * Log a single event to the experiment. The event will be batched and uploaded behind the scenes.
      *
@@ -462,15 +462,17 @@ export declare class Experiment {
      */
     log(event: Readonly<ExperimentLogFullArgs>): string;
     /**
-     * Create a new toplevel span. The name parameter is optional and defaults to "root".
+     * Create a new toplevel span underneath the experiment. The name defaults to "root".
      *
-     * See `Span.startSpan` for full details.
+     * See `Span.traced` for full details.
      */
-    startSpan(args?: StartSpanOptionalNameArgs): Span;
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
     /**
-     * Wrapper over `Experiment.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.traced` for full details.
+     * Lower-level alternative to `traced`, which does not automatically end the span or mark it as current.
+     *
+     * See `traced` for full details.
      */
-    traced<R>(callback: (span: Span) => R, args?: StartSpanOptionalNameArgs & SetCurrentArg): R;
+    startSpan(args?: StartSpanArgs): Span;
     /**
      * Summarize the experiment, including the scores (compared to the closest reference experiment) and metadata.
      *
@@ -484,51 +486,54 @@ export declare class Experiment {
         readonly comparisonExperimentId?: string;
     }): Promise<ExperimentSummary>;
     /**
-     * Finish the experiment and return its id. After calling close, you may not invoke any further methods on the experiment object.
-     *
-     * Will be invoked automatically if the experiment is wrapped in a callback passed to `braintrust.withExperiment`.
-     *
-     * @returns The experiment id.
+     * 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>;
-    private checkNotFinished;
+}
+interface ParentExperimentIds {
+    kind: "experiment";
+    project_id: string;
+    experiment_id: string;
+}
+interface ParentProjectLogIds {
+    kind: "project_log";
+    org_id: string;
+    project_id: string;
+    log_id: "g";
 }
 /**
  * Primary implementation of the `Span` interface. See the `Span` interface for full details on each method.
  *
- * We suggest using one of the various `startSpan` methods, instead of creating Spans directly. See `Span.startSpan` for full details.
+ * We suggest using one of the various `traced` methods, instead of creating Spans directly. See `Span.startSpan` for full details.
  */
 export declare class SpanImpl implements Span {
-    private finished;
     private bgLogger;
     private internalData;
     private isMerge;
     private loggedEndTime;
-    private readonly _object_info;
+    private parentIds;
+    private readonly rowIds;
     kind: "span";
     constructor(args: {
+        parentIds: Promise<ParentExperimentIds | ParentProjectLogIds>;
         bgLogger: BackgroundLogger;
-        name: string;
-        spanAttributes?: Record<any, any>;
-        startTime?: number;
-        setCurrent?: boolean;
-        event?: ExperimentLogPartialArgs & Partial<IdField>;
-    } & ({
-        rootExperiment: Experiment;
-    } | {
-        rootProject: RegisteredProject;
-    } | {
-        parentSpan: SpanImpl;
-    }));
+        parentSpanInfo?: {
+            span_id: string;
+            root_span_id: string;
+        };
+    } & StartSpanArgs);
     get id(): string;
     get span_id(): string;
     get root_span_id(): string;
     log(event: ExperimentLogPartialArgs): void;
-    startSpan(name: string, args?: StartSpanArgs): Span;
-    traced<R>(name: string, callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    traced<R>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    startSpan(args?: StartSpanArgs): Span;
     end(args?: EndSpanArgs): number;
     close(args?: EndSpanArgs): number;
-    private checkNotFinished;
 }
 /**
  * A dataset is a collection of records, such as model inputs and outputs, which represent
@@ -538,14 +543,15 @@ export declare class SpanImpl implements Span {
  * You should not create `Dataset` objects directly. Instead, use the `braintrust.initDataset()` method.
  */
 export declare class Dataset {
-    readonly project: RegisteredProject;
-    readonly id: string;
-    readonly name: string;
+    private readonly lazyMetadata;
     private pinnedVersion?;
     private _fetchedData?;
-    private logger;
-    private finished;
-    constructor(project: RegisteredProject, id: string, name: string, pinnedVersion?: string);
+    private bgLogger;
+    constructor(lazyMetadata: Promise<ProjectDatasetMetadata>, pinnedVersion?: string);
+    get id(): Promise<string>;
+    get name(): Promise<string>;
+    get project(): Promise<ObjectMetadata>;
+    private getState;
     /**
      * 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).
@@ -611,14 +617,13 @@ export declare class Dataset {
     clearCache(): void;
     version(): Promise<any>;
     /**
-     * Terminate connection to the dataset and return its id. After calling close, you may not invoke any further methods on the dataset object.
-     *
-     * Will be invoked automatically if the dataset is bound as a context manager.
-     *
-     * @returns The dataset id.
+     * 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>;
-    private checkNotFinished;
 }
 /**
  * Summary of a score's performance.