braintrust 0.0.139 → 0.0.141-dev

package/dist/{logger.d.ts → browser.d.mts}

@@ -1,14 +1,28 @@
+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" />
-import { TRANSACTION_ID_FIELD, GitMetadataSettings, RepoInfo, TransactionId, IdField, ExperimentLogPartialArgs, ExperimentLogFullArgs, LogFeedbackFullArgs, ExperimentEvent, BackgroundLogEvent, DEFAULT_IS_LEGACY_DATASET, DatasetRecord, SpanType, SpanObjectTypeV2 } from "@braintrust/core";
-import { AnyModelParam, PromptData, Tools, Prompt as PromptRow, PromptSessionEvent, OpenAIMessage } from "@braintrust/core/typespecs";
-import { IsoAsyncLocalStorage } from "./isomorph";
-import { LazyValue } from "./util";
-import { z } from "zod";
-export type SetCurrentArg = {
+
+type SetCurrentArg = {
     setCurrent?: boolean;
 };
 type StartSpanEventArgs = ExperimentLogPartialArgs & Partial<IdField>;
-export type StartSpanArgs = {
+type StartSpanArgs = {
     name?: string;
     type?: SpanType;
     spanAttributes?: Record<any, any>;
@@ -16,9 +30,15 @@ export type StartSpanArgs = {
     parent?: string;
     event?: StartSpanEventArgs;
 };
-export type EndSpanArgs = {
+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.
  *
@@ -26,7 +46,7 @@ export type EndSpanArgs = {
  *
  * See `Span.traced` for full details.
  */
-export interface Span {
+interface Span extends Exportable {
     /**
      * Row ID of the span.
      */
@@ -78,10 +98,6 @@ export interface Span {
      * @returns The end time logged to the span metrics.
      */
     end(args?: EndSpanArgs): number;
-    /**
-     * Return a serialized representation of the span that can be used to start subspans in other places. See `Span.traced` for more details.
-     */
-    export(): Promise<string>;
     /**
      * Flush any pending rows to the server.
      */
@@ -99,7 +115,7 @@ export interface Span {
 /**
  * A fake implementation of the Span API which does nothing. This can be used as the default span.
  */
-export declare class NoopSpan implements Span {
+declare class NoopSpan implements Span {
     id: string;
     kind: "span";
     constructor();
@@ -113,7 +129,7 @@ export declare class NoopSpan implements Span {
     close(args?: EndSpanArgs): number;
     setAttributes(_args: Omit<StartSpanArgs, "event">): void;
 }
-export declare const NOOP_SPAN: NoopSpan;
+declare const NOOP_SPAN: NoopSpan;
 declare global {
     var __inherited_braintrust_state: BraintrustState;
 }
@@ -122,6 +138,7 @@ declare const loginSchema: z.ZodObject<{
     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<{
@@ -139,6 +156,7 @@ declare const loginSchema: z.ZodObject<{
     appPublicUrl: string;
     orgName: string;
     logUrl: string;
+    proxyUrl: string;
     loginToken: string;
     orgId?: string | null | undefined;
     gitMetadataSettings?: {
@@ -150,6 +168,7 @@ declare const loginSchema: z.ZodObject<{
     appPublicUrl: string;
     orgName: string;
     logUrl: string;
+    proxyUrl: string;
     loginToken: string;
     orgId?: string | null | undefined;
     gitMetadataSettings?: {
@@ -157,8 +176,8 @@ declare const loginSchema: z.ZodObject<{
         fields?: ("dirty" | "tag" | "commit" | "branch" | "author_name" | "author_email" | "commit_message" | "commit_time" | "git_diff")[] | undefined;
     } | null | undefined;
 }>;
-export type SerializedBraintrustState = z.infer<typeof loginSchema>;
-export declare class BraintrustState {
+type SerializedBraintrustState = z.infer<typeof loginSchema>;
+declare class BraintrustState {
     private loginParams;
     id: string;
     currentExperiment: Experiment | undefined;
@@ -171,11 +190,13 @@ export declare class BraintrustState {
     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;
@@ -187,11 +208,12 @@ export declare class BraintrustState {
     }): Promise<void>;
     apiConn(): HTTPConnection;
     logConn(): HTTPConnection;
+    proxyConn(): HTTPConnection;
     bgLogger(): BackgroundLogger;
     loginReplaceLogConn(logConn: HTTPConnection): void;
 }
-export declare function _internalSetInitialState(): void;
-export declare const _internalGetGlobalState: () => BraintrustState;
+declare function _internalSetInitialState(): void;
+declare const _internalGetGlobalState: () => BraintrustState;
 declare class HTTPConnection {
     base_url: string;
     token: string | null;
@@ -209,7 +231,7 @@ declare class HTTPConnection {
     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>;
 }
-export interface ObjectMetadata {
+interface ObjectMetadata {
     id: string;
     name: string;
     fullInfo: Record<string, unknown>;
@@ -226,16 +248,16 @@ interface OrgProjectMetadata {
     org_id: string;
     project: ObjectMetadata;
 }
-export interface LogOptions<IsAsyncFlush> {
+interface LogOptions<IsAsyncFlush> {
     asyncFlush?: IsAsyncFlush;
     computeMetadataArgs?: Record<string, any>;
 }
-export type PromiseUnless<B, R> = B extends true ? R : Promise<Awaited<R>>;
+type PromiseUnless<B, R> = B extends true ? R : Promise<Awaited<R>>;
 interface ParentSpanIds {
     spanId: string;
     rootSpanId: string;
 }
-export declare class Logger<IsAsyncFlush extends boolean> {
+declare class Logger<IsAsyncFlush extends boolean> implements Exportable {
     private state;
     private lazyMetadata;
     private _asyncFlush;
@@ -249,6 +271,7 @@ export declare class Logger<IsAsyncFlush extends boolean> {
     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.
      *
@@ -332,16 +355,13 @@ declare class BackgroundLogger {
 type InitOpenOption<IsOpen extends boolean> = {
     open?: IsOpen;
 };
-export type InitOptions<IsOpen extends boolean> = {
+type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
     experiment?: string;
     description?: string;
     dataset?: AnyDataset;
     update?: boolean;
     baseExperiment?: string;
     isPublic?: boolean;
-    appUrl?: string;
-    apiKey?: string;
-    orgName?: string;
     metadata?: Record<string, unknown>;
     gitMetadataSettings?: GitMetadataSettings;
     projectId?: string;
@@ -350,7 +370,7 @@ export type InitOptions<IsOpen extends boolean> = {
     setCurrent?: boolean;
     state?: BraintrustState;
 } & InitOpenOption<IsOpen>;
-export type FullInitOptions<IsOpen extends boolean> = {
+type FullInitOptions<IsOpen extends boolean> = {
     project?: string;
 } & InitOptions<IsOpen>;
 type InitializedExperiment<IsOpen extends boolean | undefined> = IsOpen extends true ? ReadonlyExperiment : Experiment;
@@ -377,38 +397,35 @@ type InitializedExperiment<IsOpen extends boolean | undefined> = IsOpen extends
  * @param options.repoInfo (Optional) Explicitly specify the git metadata for this experiment. This takes precedence over `gitMetadataSettings` if specified.
  * @returns The newly created Experiment.
  */
-export declare function init<IsOpen extends boolean = false>(options: Readonly<FullInitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+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.
  */
-export declare function init<IsOpen extends boolean = false>(project: string, options?: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+declare function init<IsOpen extends boolean = false>(project: string, options?: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
 /**
  * Alias for init(options).
  */
-export declare function initExperiment<IsOpen extends boolean = false>(options: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+declare function initExperiment<IsOpen extends boolean = false>(options: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
 /**
  * Alias for init(project, options).
  */
-export declare function initExperiment<IsOpen extends boolean = false>(project: string, options?: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
+declare function initExperiment<IsOpen extends boolean = false>(project: string, options?: Readonly<InitOptions<IsOpen>>): InitializedExperiment<IsOpen>;
 /**
  * This function is deprecated. Use `init` instead.
  */
-export declare function withExperiment<R>(project: string, callback: (experiment: Experiment) => R, options?: Readonly<InitOptions<false> & SetCurrentArg>): R;
+declare function withExperiment<R>(project: string, callback: (experiment: Experiment) => R, options?: Readonly<InitOptions<false> & SetCurrentArg>): R;
 /**
  * This function is deprecated. Use `initLogger` instead.
  */
-export declare function withLogger<IsAsyncFlush extends boolean = false, R = void>(callback: (logger: Logger<IsAsyncFlush>) => R, options?: Readonly<InitLoggerOptions<IsAsyncFlush> & SetCurrentArg>): R;
+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> = {
+type InitDatasetOptions<IsLegacyDataset extends boolean> = FullLoginOptions & {
     dataset?: string;
     description?: string;
     version?: string;
-    appUrl?: string;
-    apiKey?: string;
-    orgName?: string;
     projectId?: string;
     state?: BraintrustState;
 } & UseOutputOption<IsLegacyDataset>;
@@ -429,27 +446,23 @@ type FullInitDatasetOptions<IsLegacyDataset extends boolean> = {
  * @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.
  */
-export declare function initDataset<IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET>(options: Readonly<FullInitDatasetOptions<IsLegacyDataset>>): Dataset<IsLegacyDataset>;
+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.
  */
-export declare function initDataset<IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET>(project: string, options?: Readonly<InitDatasetOptions<IsLegacyDataset>>): Dataset<IsLegacyDataset>;
+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.
  */
-export declare function withDataset<R, IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET>(project: string, callback: (dataset: Dataset<IsLegacyDataset>) => R, options?: Readonly<InitDatasetOptions<IsLegacyDataset>>): R;
+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> = {
+type InitLoggerOptions<IsAsyncFlush> = FullLoginOptions & {
     projectName?: string;
     projectId?: string;
-    appUrl?: string;
-    apiKey?: string;
-    orgName?: string;
-    forceLogin?: boolean;
     setCurrent?: boolean;
     state?: BraintrustState;
 } & AsyncFlushArg<IsAsyncFlush>;
@@ -468,19 +481,16 @@ type InitLoggerOptions<IsAsyncFlush> = {
  * @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<IsAsyncFlush extends boolean = false>(options?: Readonly<InitLoggerOptions<IsAsyncFlush>>): Logger<IsAsyncFlush>;
-interface LoadPromptOptions {
+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;
-    appUrl?: string;
-    apiKey?: string;
-    orgName?: string;
     state?: BraintrustState;
-}
+};
 /**
  * Load a prompt from the specified project.
  *
@@ -507,11 +517,11 @@ interface LoadPromptOptions {
  * });
  * ```
  */
-export declare function loadPrompt({ projectName, projectId, slug, version, defaults, noTrace, appUrl, apiKey, orgName, state: stateArg, }: LoadPromptOptions): Promise<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.
  */
-export interface LoginOptions {
+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.
@@ -531,6 +541,9 @@ export interface LoginOptions {
      */
     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()`.
@@ -542,17 +555,17 @@ export interface LoginOptions {
  * @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)
  */
-export declare function login(options?: LoginOptions & {
+declare function login(options?: LoginOptions & {
     forceLogin?: boolean;
-}): Promise<BraintrustState | undefined>;
-export declare function loginToState(options?: LoginOptions): Promise<BraintrustState>;
+}): 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.
  */
-export declare function log(event: ExperimentLogFullArgs): string;
+declare function log(event: ExperimentLogFullArgs): string;
 /**
  * Summarize the current experiment, including the scores (compared to the closest reference experiment) and metadata.
  *
@@ -561,7 +574,7 @@ export declare function log(event: ExperimentLogFullArgs): string;
  * @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.
  */
-export declare function summarize(options?: {
+declare function summarize(options?: {
     readonly summarizeScores?: boolean;
     readonly comparisonExperimentId?: string;
 }): Promise<ExperimentSummary>;
@@ -571,21 +584,21 @@ type OptionalStateArg = {
 /**
  * Returns the currently-active experiment (set by `braintrust.init`). Returns undefined if no current experiment has been set.
  */
-export declare function currentExperiment(options?: OptionalStateArg): Experiment | undefined;
+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.
  */
-export declare function currentLogger<IsAsyncFlush extends boolean>(options?: AsyncFlushArg<IsAsyncFlush> & OptionalStateArg): Logger<IsAsyncFlush> | undefined;
+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.
  */
-export declare function currentSpan(options?: OptionalStateArg): Span;
+declare function currentSpan(options?: OptionalStateArg): 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> & OptionalStateArg): Span | Experiment | Logger<IsAsyncFlush>;
+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
@@ -596,7 +609,35 @@ export declare function getSpanParentObject<IsAsyncFlush extends boolean>(option
  *
  * See `Span.traced` for full details.
  */
-export declare function traced<IsAsyncFlush extends boolean = false, R = void>(callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg & AsyncFlushArg<IsAsyncFlush>): PromiseUnless<IsAsyncFlush, R>;
+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",
@@ -604,19 +645,19 @@ export declare function traced<IsAsyncFlush extends boolean = false, R = void>(c
  *
  * See `traced` for full details.
  */
-export declare function startSpan<IsAsyncFlush extends boolean = false>(args?: StartSpanArgs & AsyncFlushArg<IsAsyncFlush> & OptionalStateArg): Span;
+declare function startSpan<IsAsyncFlush extends boolean = false>(args?: StartSpanArgs & AsyncFlushArg<IsAsyncFlush> & OptionalStateArg): Span;
 /**
  * Flush any pending rows to the server.
  */
-export declare function flush(options?: OptionalStateArg): Promise<void>;
+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.
  */
-export declare function setFetch(fetch: typeof globalThis.fetch): void;
-export type WithTransactionId<R> = R & {
+declare function setFetch(fetch: typeof globalThis.fetch): void;
+type WithTransactionId<R> = R & {
     [TRANSACTION_ID_FIELD]: TransactionId;
 };
 declare class ObjectFetcher<RecordType> implements AsyncIterable<WithTransactionId<RecordType>> {
@@ -633,9 +674,9 @@ declare class ObjectFetcher<RecordType> implements AsyncIterable<WithTransaction
     clearCache(): void;
     version(): Promise<string | undefined>;
 }
-export type BaseMetadata = Record<string, unknown> | void;
-export type DefaultMetadataType = void;
-export type EvalCase<Input, Expected, Metadata> = {
+type BaseMetadata = Record<string, unknown> | void;
+type DefaultMetadataType = void;
+type EvalCase<Input, Expected, Metadata> = {
     input: Input;
     tags?: string[];
 } & (Expected extends void ? {} : {
@@ -655,7 +696,7 @@ export type EvalCase<Input, Expected, Metadata> = {
  *
  * You should not create `Experiment` objects directly. Instead, use the `braintrust.init()` method.
  */
-export declare class Experiment extends ObjectFetcher<ExperimentEvent> {
+declare class Experiment extends ObjectFetcher<ExperimentEvent> implements Exportable {
     private readonly lazyMetadata;
     readonly dataset?: AnyDataset;
     private lastStartTime;
@@ -748,7 +789,7 @@ export declare class Experiment extends ObjectFetcher<ExperimentEvent> {
 /**
  * A read-only view of an experiment, initialized by passing `open: true` to `init()`.
  */
-export declare class ReadonlyExperiment extends ObjectFetcher<ExperimentEvent> {
+declare class ReadonlyExperiment extends ObjectFetcher<ExperimentEvent> {
     private state;
     private readonly lazyMetadata;
     constructor(state: BraintrustState, lazyMetadata: LazyValue<ProjectExperimentMetadata>);
@@ -757,13 +798,13 @@ export declare class ReadonlyExperiment extends ObjectFetcher<ExperimentEvent> {
     protected getState(): Promise<BraintrustState>;
     asDataset<Input, Expected>(): AsyncGenerator<EvalCase<Input, Expected, void>>;
 }
-export declare function newId(): string;
+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.
  */
-export declare class SpanImpl implements Span {
+declare class SpanImpl implements Span {
     private state;
     private isMerge;
     private loggedEndTime;
@@ -802,7 +843,7 @@ export declare class SpanImpl implements Span {
  *
  * You should not create `Dataset` objects directly. Instead, use the `braintrust.initDataset()` method.
  */
-export declare class Dataset<IsLegacyDataset extends boolean = typeof DEFAULT_IS_LEGACY_DATASET> extends ObjectFetcher<DatasetRecord<IsLegacyDataset>> {
+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);
@@ -853,17 +894,17 @@ export declare class Dataset<IsLegacyDataset extends boolean = typeof DEFAULT_IS
      */
     close(): Promise<string>;
 }
-export type CompiledPromptParams = Omit<NonNullable<PromptData["options"]>["params"], "use_cache"> & {
+type CompiledPromptParams = Omit<NonNullable<PromptData["options"]>["params"], "use_cache"> & {
     model: NonNullable<NonNullable<PromptData["options"]>["model"]>;
 };
-export type ChatPrompt = {
+type ChatPrompt = {
     messages: OpenAIMessage[];
     tools?: Tools;
 };
-export type CompletionPrompt = {
+type CompletionPrompt = {
     prompt: string;
 };
-export type CompiledPrompt<Flavor extends "chat" | "completion"> = CompiledPromptParams & {
+type CompiledPrompt<Flavor extends "chat" | "completion"> = CompiledPromptParams & {
     span_info?: {
         name?: string;
         spanAttributes?: Record<any, any>;
@@ -877,12 +918,12 @@ export type CompiledPrompt<Flavor extends "chat" | "completion"> = CompiledPromp
         };
     };
 } & (Flavor extends "chat" ? ChatPrompt : Flavor extends "completion" ? CompletionPrompt : {});
-export type DefaultPromptArgs = Partial<CompiledPromptParams & AnyModelParam & ChatPrompt & CompletionPrompt>;
-export declare class Prompt {
+type DefaultPromptArgs = Partial<CompiledPromptParams & AnyModelParam & ChatPrompt & CompletionPrompt>;
+declare class Prompt {
     private metadata;
     private defaults;
     private noTrace;
-    constructor(metadata: Omit<PromptRow, "log_id"> | PromptSessionEvent, defaults: DefaultPromptArgs, noTrace: boolean);
+    constructor(metadata: Omit<Prompt$1, "log_id"> | PromptSessionEvent, defaults: DefaultPromptArgs, noTrace: boolean);
     get id(): string;
     get projectId(): string;
     get name(): string;
@@ -902,7 +943,7 @@ export declare class Prompt {
     }): CompiledPrompt<Flavor>;
     private runBuild;
 }
-export type AnyDataset = Dataset<boolean>;
+type AnyDataset = Dataset<boolean>;
 /**
  * Summary of a score's performance.
  * @property name Name of the score.
@@ -911,7 +952,7 @@ export type AnyDataset = Dataset<boolean>;
  * @property improvements Number of improvements in the score.
  * @property regressions Number of regressions in the score.
  */
-export interface ScoreSummary {
+interface ScoreSummary {
     name: string;
     score: number;
     diff?: number;
@@ -927,7 +968,7 @@ export interface ScoreSummary {
  * @property improvements Number of improvements in the metric.
  * @property regressions Number of regressions in the metric.
  */
-export interface MetricSummary {
+interface MetricSummary {
     name: string;
     metric: number;
     unit: string;
@@ -945,7 +986,7 @@ export interface MetricSummary {
  * @property comparisonExperimentName The experiment scores are baselined against.
  * @property scores Summary of the experiment's scores.
  */
-export interface ExperimentSummary {
+interface ExperimentSummary {
     projectName: string;
     experimentName: string;
     projectId?: string;
@@ -962,7 +1003,7 @@ export interface ExperimentSummary {
  * @property newRecords New or updated records added in this session.
  * @property totalRecords Total records in the dataset.
  */
-export interface DataSummary {
+interface DataSummary {
     newRecords: number;
     totalRecords: number;
 }
@@ -975,11 +1016,74 @@ export interface DataSummary {
  * @property datasetUrl URL to the experiment's page in the Braintrust app.
  * @property dataSummary Summary of the dataset's data.
  */
-export interface DatasetSummary {
+interface DatasetSummary {
     projectName: string;
     datasetName: string;
     projectUrl: string;
     datasetUrl: string;
     dataSummary: DataSummary;
 }
-export {};
+
+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 };