braintrust 0.0.203 → 0.0.205

package/dev/dist/index.d.mts

@@ -0,0 +1,3879 @@
+import { TRANSACTION_ID_FIELD, TransactionId, ExperimentEvent, DEFAULT_IS_LEGACY_DATASET, DatasetRecord, ExperimentLogFullArgs, ExperimentLogPartialArgs, LogFeedbackFullArgs, SpanType, IdField, BackgroundLogEvent, Score } from '@braintrust/core';
+import { GitMetadataSettings, Prompt as Prompt$1, PromptSessionEvent, PromptData, AnyModelParam, OpenAIMessage, Tools, Message, PromptBlockData, IfExists, SavedFunctionId, ToolFunctionDefinition, FunctionType, SSEProgressEventData, RepoInfo, ObjectReference } from '@braintrust/core/typespecs';
+import { z } from 'zod';
+
+type GenericFunction<Input, Output> = ((input: Input) => Output) | ((input: Input) => Promise<Output>);
+
+interface IsoAsyncLocalStorage<T> {
+    enterWith(store: T): void;
+    run<R>(store: T | undefined, callback: () => R): R;
+    getStore(): T | undefined;
+}
+
+/**
+ * Options for configuring an LRUCache instance.
+ */
+interface LRUCacheOptions {
+    /**
+     * Maximum number of items to store in the cache.
+     * If not specified, the cache will grow unbounded.
+     */
+    max?: number;
+}
+/**
+ * A Least Recently Used (LRU) cache implementation.
+ *
+ * This cache maintains items in order of use, evicting the least recently used item
+ * when the cache reaches its maximum size (if specified). Items are considered "used"
+ * when they are either added to the cache or retrieved from it.
+ *
+ * If no maximum size is specified, the cache will grow unbounded.
+ *
+ * @template K - The type of keys stored in the cache.
+ * @template V - The type of values stored in the cache.
+ */
+declare class LRUCache<K, V> {
+    private cache;
+    private readonly maxSize?;
+    constructor(options?: LRUCacheOptions);
+    /**
+     * Retrieves a value from the cache.
+     * If the key exists, the item is marked as most recently used.
+     *
+     * @param key - The key to look up.
+     * @returns The cached value if found, undefined otherwise.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Stores a value in the cache.
+     * If the key already exists, the value is updated and marked as most recently used.
+     * If the cache is at its maximum size, the least recently used item is evicted.
+     *
+     * @param key - The key to store.
+     * @param value - The value to store.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Removes all items from the cache.
+     */
+    clear(): void;
+}
+
+/**
+ * Configuration options for DiskCache.
+ */
+interface DiskCacheOptions {
+    /**
+     * Directory where cache files will be stored.
+     */
+    cacheDir: string;
+    /**
+     * Maximum number of entries to store in the cache.
+     * If not specified, the cache will grow unbounded.
+     */
+    max?: number;
+    logWarnings?: boolean;
+}
+/**
+ * A persistent filesystem-based cache implementation.
+ *
+ * This cache stores entries as compressed files on disk and implements an LRU eviction
+ * policy based on file modification times (mtime). While access times (atime) would be more
+ * semantically accurate for LRU, we use mtime because:
+ *
+ * 1. Many modern filesystems mount with noatime for performance reasons.
+ * 2. Even when atime updates are enabled, they may be subject to update delays.
+ * 3. mtime updates are more reliably supported across different filesystems.
+ *
+ * @template T - The type of values stored in the cache.
+ */
+declare class DiskCache<T> {
+    private readonly dir;
+    private readonly max?;
+    private readonly logWarnings;
+    /**
+     * Creates a new DiskCache instance.
+     * @param options - Configuration options for the cache.
+     */
+    constructor(options: DiskCacheOptions);
+    private getEntryPath;
+    /**
+     * Retrieves a value from the cache.
+     * Updates the entry's access time when read.
+     *
+     * @param key - The key to look up in the cache.
+     * @returns The cached value if found, undefined otherwise.
+     */
+    get(key: string): Promise<T | undefined>;
+    /**
+     * Stores a value in the cache.
+     * If the cache is at its maximum size, the least recently used entries will be evicted.
+     *
+     * @param key - The key to store the value under.
+     * @param value - The value to store in the cache.
+     */
+    set(key: string, value: T): Promise<void>;
+    private evictOldestIfFull;
+}
+
+/**
+ * Identifies a prompt in the cache using either project ID or project name along with the slug.
+ */
+interface PromptKey {
+    /**
+     * The slug identifier for the prompt within its project.
+     */
+    slug: string;
+    /**
+     * The version of the prompt.
+     */
+    version: string;
+    /**
+     * The ID of the project containing the prompt.
+     * Either projectId or projectName must be provided.
+     */
+    projectId?: string;
+    /**
+     * The name of the project containing the prompt.
+     * Either projectId or projectName must be provided.
+     */
+    projectName?: string;
+}
+/**
+ * A two-layer cache for Braintrust prompts with both in-memory and filesystem storage.
+ *
+ * This cache implements either a one or two-layer caching strategy:
+ * 1. A fast in-memory LRU cache for frequently accessed prompts.
+ * 2. An optional persistent filesystem-based cache that serves as a backing store.
+ */
+declare class PromptCache {
+    private readonly memoryCache;
+    private readonly diskCache?;
+    constructor(options: {
+        memoryCache: LRUCache<string, Prompt>;
+        diskCache?: DiskCache<Prompt>;
+    });
+    /**
+     * Retrieves a prompt from the cache.
+     * First checks the in-memory LRU cache, then falls back to checking the disk cache if available.
+     */
+    get(key: PromptKey): Promise<Prompt | undefined>;
+    /**
+     * Stores a prompt in the cache.
+     * Writes to the in-memory cache and the disk cache if available.
+     *
+     * @param key - The key to store the value under.
+     * @param value - The value to store in the cache.
+     * @throws If there is an error writing to the disk cache.
+     */
+    set(key: PromptKey, value: Prompt): Promise<void>;
+}
+
+declare class LazyValue<T> {
+    private callable;
+    private resolvedValue;
+    private value;
+    constructor(callable: () => Promise<T>);
+    get(): Promise<T>;
+    getSync(): {
+        resolved: boolean;
+        value: T | undefined;
+    };
+    get hasSucceeded(): boolean;
+}
+
+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;
+    propagatedEvent?: 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 {@link 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 {@link Span.traced} for full details.
+ */
+interface Span extends Exportable {
+    /**
+     * Row ID of the span.
+     */
+    id: string;
+    /**
+     * Span ID of the span.
+     */
+    spanId: string;
+    /**
+     * Root span ID of the span.
+     */
+    rootSpanId: string;
+    /**
+     * Parent span IDs of the span.
+     */
+    spanParents: 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 {@link 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 {@link 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 {@link 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 {@link Span.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;
+    /**
+     * Serialize the identifiers of this span. The return value can be used to
+     * identify this span when starting a subspan elsewhere, such as another
+     * process or service, without needing to access this `Span` object. See the
+     * parameters of {@link Span.startSpan} for usage details.
+     *
+     * Callers should treat the return value as opaque. The serialization format
+     * may change from time to time. If parsing is needed, use
+     * `SpanComponentsV3.fromStr`.
+     *
+     * @returns Serialized representation of this span's identifiers.
+     */
+    export(): Promise<string>;
+    /**
+     * Format a permalink to the Braintrust application for viewing this span.
+     *
+     * Links can be generated at any time, but they will only become viewable
+     * after the span and its root have been flushed to the server and ingested.
+     *
+     * This function can block resolving data with the server. For production
+     * applications it's preferable to call {@link Span.link} instead.
+     *
+     * @returns A promise which resolves to a permalink to the span.
+     */
+    permalink(): Promise<string>;
+    /**
+     * Format a link to the Braintrust application for viewing this span.
+     *
+     * Links can be generated at any time, but they will only become viewable
+     * after the span and its root have been flushed to the server and ingested.
+     *
+     * There are certain conditions that a Span doesn'thave enough information
+     * to return a stable link (e.g. during an unresolved experiment). In this case
+     * or if there's an error generating link, we'll return a placeholder link.
+     *
+     * @returns A link to the span.
+     */
+    link(): string;
+    /**
+     * 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;
+    /**
+     * Start a span with a specific id and parent span ids.
+     */
+    startSpanWithParents(spanId: string, spanParents: string[], args?: StartSpanArgs): Span;
+    state(): BraintrustState;
+    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;
+    spanId: string;
+    rootSpanId: string;
+    spanParents: 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>;
+    permalink(): Promise<string>;
+    link(): string;
+    flush(): Promise<void>;
+    close(args?: EndSpanArgs): number;
+    setAttributes(_args: Omit<StartSpanArgs, "event">): void;
+    startSpanWithParents(_spanId: string, _spanParents: string[], _args?: StartSpanArgs): Span;
+    state(): BraintrustState;
+}
+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;
+    apiUrl: 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;
+    apiUrl: 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;
+    apiUrl: 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;
+    currentParent: IsoAsyncLocalStorage<string>;
+    currentSpan: IsoAsyncLocalStorage<Span>;
+    private _bgLogger;
+    private _overrideBgLogger;
+    appUrl: string | null;
+    appPublicUrl: string | null;
+    loginToken: string | null;
+    orgId: string | null;
+    orgName: string | null;
+    apiUrl: string | null;
+    proxyUrl: string | null;
+    loggedIn: boolean;
+    gitMetadataSettings?: GitMetadataSettings;
+    fetch: typeof globalThis.fetch;
+    private _appConn;
+    private _apiConn;
+    private _proxyConn;
+    promptCache: PromptCache;
+    constructor(loginParams: LoginOptions);
+    resetLoginInfo(): void;
+    copyLoginInfo(other: BraintrustState): void;
+    serialize(): SerializedBraintrustState;
+    static deserialize(serialized: unknown, opts?: LoginOptions): BraintrustState;
+    setFetch(fetch: typeof globalThis.fetch): void;
+    login(loginParams: LoginOptions & {
+        forceLogin?: boolean;
+    }): Promise<void>;
+    appConn(): HTTPConnection;
+    apiConn(): HTTPConnection;
+    proxyConn(): HTTPConnection;
+    bgLogger(): BackgroundLogger;
+    httpLogger(): HTTPBackgroundLogger;
+    setOverrideBgLogger(logger: BackgroundLogger | null): void;
+    loginReplaceApiConn(apiConn: HTTPConnection): void;
+    disable(): void;
+}
+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 | 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 | 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>>;
+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;
+    /**
+     * 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.error: (Optional) The error that occurred, if any. If you use tracing to run an experiment, errors are automatically logged when your code throws an exception.
+     * @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 {@link 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 {@link 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. Note, this metadata does not correspond to the main event itself, but rather the audit log attached to the event.
+     * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
+     */
+    logFeedback(event: LogFeedbackFullArgs): void;
+    /**
+     * Update a span in the experiment using its id. It is important that you only update a span once the original span has been fully written and flushed,
+     * since otherwise updates to the span may conflict with the original span.
+     *
+     * @param event The event data to update the span with. Must include `id`. See {@link Experiment.log} for a full list of valid fields.
+     */
+    updateSpan(event: Omit<Partial<ExperimentEvent>, "id"> & Required<Pick<ExperimentEvent, "id">>): void;
+    /**
+     * Return a serialized representation of the logger that can be used to start subspans in other places.
+     *
+     * See {@link Span.startSpan} for more details.
+     */
+    export(): Promise<string>;
+    flush(): Promise<void>;
+    get asyncFlush(): IsAsyncFlush | undefined;
+}
+interface BackgroundLoggerOpts {
+    noExitFlush?: boolean;
+    onFlushError?: (error: unknown) => void;
+}
+interface BackgroundLogger {
+    log(items: LazyValue<BackgroundLogEvent>[]): void;
+    flush(): Promise<void>;
+}
+declare class HTTPBackgroundLogger implements BackgroundLogger {
+    private apiConn;
+    private items;
+    private activeFlush;
+    private activeFlushResolved;
+    private activeFlushError;
+    private onFlushError?;
+    syncFlush: boolean;
+    maxRequestSize: number;
+    defaultBatchSize: number;
+    numTries: number;
+    queueDropExceedingMaxsize: number | undefined;
+    queueDropLoggingPeriod: number;
+    failedPublishPayloadsDir: string | undefined;
+    allPublishPayloadsDir: string | undefined;
+    private _disabled;
+    private queueDropLoggingState;
+    constructor(apiConn: LazyValue<HTTPConnection>, opts?: BackgroundLoggerOpts);
+    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;
+    internalReplaceApiConn(apiConn: HTTPConnection): void;
+    disable(): void;
+}
+type AsyncFlushArg<IsAsyncFlush> = {
+    asyncFlush?: IsAsyncFlush;
+};
+/**
+ * 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;
+    /**
+     * By default, the SDK installs an event handler that flushes pending writes on the `beforeExit` event.
+     * If true, this event handler will _not_ be installed.
+     */
+    noExitFlush?: boolean;
+    /**
+     * Calls this function if there's an error in the background flusher.
+     */
+    onFlushError?: (error: unknown) => void;
+}
+type OptionalStateArg = {
+    state?: BraintrustState;
+};
+/**
+ * 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 {@link Span} for full details.
+ */
+declare function currentSpan(options?: OptionalStateArg): Span;
+/**
+ * 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 {@link traced} for full details.
+ */
+declare function startSpan<IsAsyncFlush extends boolean = true>(args?: StartSpanArgs & AsyncFlushArg<IsAsyncFlush> & OptionalStateArg): Span;
+/**
+ * Runs the provided callback with the span as the current span.
+ */
+declare function withCurrent<R>(span: Span, callback: (span: Span) => R, state?: BraintrustState | undefined): R;
+type WithTransactionId<R> = R & {
+    [TRANSACTION_ID_FIELD]: TransactionId;
+};
+declare class ObjectFetcher<RecordType> implements AsyncIterable<WithTransactionId<RecordType>> {
+    private objectType;
+    private pinnedVersion;
+    private mutateRecord?;
+    private _internal_btql?;
+    private _fetchedData;
+    constructor(objectType: "dataset" | "experiment", pinnedVersion: string | undefined, mutateRecord?: ((r: any) => WithTransactionId<RecordType>) | undefined, _internal_btql?: Record<string, unknown> | 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[];
+    id?: string;
+    _xact_id?: TransactionId;
+    created?: string | null;
+    upsert_id?: string;
+} & (Expected extends void ? object : {
+    expected: Expected;
+}) & (Metadata extends void ? object : {
+    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.error: (Optional) The error that occurred, if any. If you use tracing to run an experiment, errors are automatically logged when your code throws an exception.
+     * @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. This field is unused and 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 {@link 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 {@link 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. Note, this metadata does not correspond to the main event itself, but rather the audit log attached to the event.
+     * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
+     */
+    logFeedback(event: LogFeedbackFullArgs): void;
+    /**
+     * Update a span in the experiment using its id. It is important that you only update a span once the original span has been fully written and flushed,
+     * since otherwise updates to the span may conflict with the original span.
+     *
+     * @param event The event data to update the span with. Must include `id`. See {@link Experiment.log} for a full list of valid fields.
+     */
+    updateSpan(event: Omit<Partial<ExperimentEvent>, "id"> & Required<Pick<ExperimentEvent, "id">>): void;
+    /**
+     * Return a serialized representation of the experiment that can be used to start subspans in other places.
+     *
+     * See {@link Span.startSpan} for more details.
+     */
+    export(): Promise<string>;
+    /**
+     * Flush any pending rows to the server.
+     */
+    flush(): Promise<void>;
+    /**
+     * @deprecated This function is deprecated. You can simply remove it from your code.
+     */
+    close(): Promise<string>;
+}
+/**
+ * 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;
+    private readonly __braintrust_dataset_marker;
+    private newRecords;
+    constructor(state: BraintrustState, lazyMetadata: LazyValue<ProjectDatasetMetadata>, pinnedVersion?: string, legacy?: IsLegacyDataset, _internal_btql?: Record<string, unknown>);
+    get id(): Promise<string>;
+    get name(): Promise<string>;
+    get project(): Promise<ObjectMetadata>;
+    protected getState(): Promise<BraintrustState>;
+    private validateEvent;
+    private createArgs;
+    /**
+     * 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;
+    /**
+     * Update fields of a single record in the dataset. The updated fields will be batched and uploaded behind the scenes.
+     * You must pass in an `id` of the record to update. Only the fields provided will be updated; other fields will remain unchanged.
+     *
+     * @param event The fields to update in the record.
+     * @param event.id The unique identifier of the record to update.
+     * @param event.input (Optional) The new input value for the record (an arbitrary, JSON serializable object).
+     * @param event.expected (Optional) The new expected output value for the record (an arbitrary, JSON serializable object).
+     * @param event.tags (Optional) A list of strings to update the tags of the record.
+     * @param event.metadata (Optional) A dictionary to update the metadata of the record. The values in `metadata` can be any
+     * JSON-serializable type, but its keys must be strings.
+     * @returns The `id` of the updated record.
+     */
+    update({ input, expected, metadata, tags, id, }: {
+        readonly id: string;
+        readonly input?: unknown;
+        readonly expected?: unknown;
+        readonly tags?: string[];
+        readonly metadata?: Record<string, 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>;
+    /**
+     * @deprecated This function is deprecated. You can simply remove it from your code.
+     */
+    close(): Promise<string>;
+    static isDataset(data: unknown): data is Dataset;
+}
+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>;
+type PromptRowWithId<HasId extends boolean = true, HasVersion extends boolean = true> = Omit<Prompt$1, "log_id" | "org_id" | "project_id" | "id" | "_xact_id"> & Partial<Pick<Prompt$1, "project_id">> & (HasId extends true ? Pick<Prompt$1, "id"> : Partial<Pick<Prompt$1, "id">>) & (HasVersion extends true ? Pick<Prompt$1, "_xact_id"> : Partial<Pick<Prompt$1, "_xact_id">>);
+declare class Prompt<HasId extends boolean = true, HasVersion extends boolean = true> {
+    private metadata;
+    private defaults;
+    private noTrace;
+    private parsedPromptData;
+    private hasParsedPromptData;
+    private readonly __braintrust_prompt_marker;
+    constructor(metadata: PromptRowWithId<HasId, HasVersion> | PromptSessionEvent, defaults: DefaultPromptArgs, noTrace: boolean);
+    get id(): HasId extends true ? string : string | undefined;
+    get projectId(): string | undefined;
+    get name(): string;
+    get slug(): string;
+    get prompt(): PromptData["prompt"];
+    get version(): HasId extends true ? TransactionId : TransactionId | undefined;
+    get options(): NonNullable<PromptData["options"]>;
+    get promptData(): PromptData;
+    /**
+     * 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;
+        messages?: Message[];
+        strict?: boolean;
+    }): CompiledPrompt<Flavor>;
+    private runBuild;
+    static renderPrompt({ prompt, buildArgs, options, }: {
+        prompt: PromptBlockData;
+        buildArgs: unknown;
+        options: {
+            strict?: boolean;
+            messages?: Message[];
+        };
+    }): PromptBlockData;
+    private getParsedPromptData;
+    static isPrompt(data: unknown): data is Prompt<boolean, boolean>;
+    static fromPromptData(name: string, promptData: PromptData): Prompt<false, false>;
+}
+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 totalRecords Total records in the dataset.
+ */
+interface DataSummary {
+    /**
+     * New or updated records added in this session.
+     */
+    newRecords: number;
+    /**
+     * Total records in the dataset.
+     */
+    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 | undefined;
+}
+
+type NameOrId = {
+    name: string;
+} | {
+    id: string;
+};
+type CreateProjectOpts = NameOrId;
+declare class Project {
+    readonly name?: string;
+    readonly id?: string;
+    tools: ToolBuilder;
+    prompts: PromptBuilder;
+    scorers: ScorerBuilder;
+    constructor(args: CreateProjectOpts);
+}
+declare class ToolBuilder {
+    private readonly project;
+    private taskCounter;
+    constructor(project: Project);
+    create<Input, Output, Fn extends GenericFunction<Input, Output>>(opts: CodeOpts<Input, Output, Fn>): CodeFunction<Input, Output, Fn>;
+}
+declare class ScorerBuilder {
+    private readonly project;
+    private taskCounter;
+    constructor(project: Project);
+    create<Output, Input, Params, Returns, Fn extends GenericFunction<Exact<Params, ScorerArgs<Output, Input>>, Returns>>(opts: ScorerOpts<Output, Input, Params, Returns, Fn>): void;
+}
+type Schema<Input, Output> = Partial<{
+    parameters: z.ZodSchema<Input>;
+    returns: z.ZodSchema<Output>;
+}>;
+interface BaseFnOpts {
+    name: string;
+    slug: string;
+    description: string;
+    ifExists: IfExists;
+}
+type CodeOpts<Params, Returns, Fn extends GenericFunction<Params, Returns>> = Partial<BaseFnOpts> & {
+    handler: Fn;
+} & Schema<Params, Returns>;
+type ScorerPromptOpts = Partial<BaseFnOpts> & PromptOpts<false, false, false, false> & {
+    useCot: boolean;
+    choiceScores: Record<string, number>;
+};
+type ScorerArgs<Output, Input> = {
+    output: Output;
+    expected?: Output;
+    input?: Input;
+    metadata?: Record<string, unknown>;
+};
+type Exact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? T : never : never;
+type ScorerOpts<Output, Input, Params, Returns, Fn extends GenericFunction<Exact<Params, ScorerArgs<Output, Input>>, Returns>> = CodeOpts<Exact<Params, ScorerArgs<Output, Input>>, Returns, Fn> | ScorerPromptOpts;
+declare class CodeFunction<Input, Output, Fn extends GenericFunction<Input, Output>> {
+    readonly project: Project;
+    readonly handler: Fn;
+    readonly name: string;
+    readonly slug: string;
+    readonly type: FunctionType;
+    readonly description?: string;
+    readonly parameters?: z.ZodSchema<Input>;
+    readonly returns?: z.ZodSchema<Output>;
+    readonly ifExists?: IfExists;
+    constructor(project: Project, opts: Omit<CodeOpts<Input, Output, Fn>, "name" | "slug"> & {
+        name: string;
+        slug: string;
+        type: FunctionType;
+    });
+    key(): string;
+}
+type GenericCodeFunction = CodeFunction<any, any, GenericFunction<any, any>>;
+declare class CodePrompt {
+    readonly project: Project;
+    readonly name: string;
+    readonly slug: string;
+    readonly prompt: PromptData;
+    readonly ifExists?: IfExists;
+    readonly description?: string;
+    readonly id?: string;
+    readonly functionType?: FunctionType;
+    readonly toolFunctions: (SavedFunctionId | GenericCodeFunction)[];
+    constructor(project: Project, prompt: PromptData, toolFunctions: (SavedFunctionId | GenericCodeFunction)[], opts: Omit<PromptOpts<false, false, false, false>, "name" | "slug"> & {
+        name: string;
+        slug: string;
+    }, functionType?: FunctionType);
+}
+interface PromptId {
+    id: string;
+}
+interface PromptVersion {
+    version: TransactionId;
+}
+interface PromptTools {
+    tools: (GenericCodeFunction | SavedFunctionId | ToolFunctionDefinition)[];
+}
+interface PromptNoTrace {
+    noTrace: boolean;
+}
+declare const promptDefinitionSchema: z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
+    prompt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+}, {
+    prompt: string;
+}>, z.ZodObject<{
+    messages: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        content: z.ZodUnion<[z.ZodDefault<z.ZodString>, z.ZodArray<z.ZodObject<{
+            text: z.ZodDefault<z.ZodString>;
+            type: z.ZodLiteral<"text">;
+            cache_control: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["ephemeral"]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "ephemeral";
+            }, {
+                type: "ephemeral";
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }, {
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }>, "many">]>;
+        role: z.ZodLiteral<"system">;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: (string | {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[]) & (string | {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | undefined);
+        role: "system";
+        name?: string | undefined;
+    }, {
+        role: "system";
+        content?: string | {
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | undefined;
+        name?: string | undefined;
+    }>, z.ZodObject<{
+        content: z.ZodUnion<[z.ZodDefault<z.ZodString>, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            text: z.ZodDefault<z.ZodString>;
+            type: z.ZodLiteral<"text">;
+            cache_control: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["ephemeral"]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "ephemeral";
+            }, {
+                type: "ephemeral";
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }, {
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }>, z.ZodObject<{
+            image_url: z.ZodObject<{
+                url: z.ZodString;
+                detail: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"low">, z.ZodLiteral<"high">]>>;
+            }, "strip", z.ZodTypeAny, {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            }, {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            }>;
+            type: z.ZodLiteral<"image_url">;
+        }, "strip", z.ZodTypeAny, {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        }, {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        }>]>, "many">]>;
+        role: z.ZodLiteral<"user">;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: (string | ({
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        } | {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        })[]) & (string | ({
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        } | {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        })[] | undefined);
+        role: "user";
+        name?: string | undefined;
+    }, {
+        role: "user";
+        content?: string | ({
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        } | {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        })[] | undefined;
+        name?: string | undefined;
+    }>, z.ZodObject<{
+        role: z.ZodLiteral<"assistant">;
+        content: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodObject<{
+            text: z.ZodDefault<z.ZodString>;
+            type: z.ZodLiteral<"text">;
+            cache_control: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["ephemeral"]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "ephemeral";
+            }, {
+                type: "ephemeral";
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }, {
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }>, "many">]>>>;
+        function_call: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            arguments: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            arguments: string;
+        }, {
+            name: string;
+            arguments: string;
+        }>>>, {
+            name: string;
+            arguments: string;
+        } | undefined, {
+            name: string;
+            arguments: string;
+        } | null | undefined>;
+        name: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
+        tool_calls: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            function: z.ZodObject<{
+                arguments: z.ZodString;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string;
+            }, {
+                name: string;
+                arguments: string;
+            }>;
+            type: z.ZodLiteral<"function">;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }>, "many">>>, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | null | undefined>;
+        reasoning: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
+            content: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string | undefined;
+            content?: string | undefined;
+        }, {
+            id?: string | null | undefined;
+            content?: string | null | undefined;
+        }>, "many">>>, {
+            id?: string | undefined;
+            content?: string | undefined;
+        }[] | undefined, {
+            id?: string | null | undefined;
+            content?: string | null | undefined;
+        }[] | null | undefined>;
+    }, "strip", z.ZodTypeAny, {
+        role: "assistant";
+        content?: string | {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | null | undefined;
+        function_call?: {
+            name: string;
+            arguments: string;
+        } | undefined;
+        name?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+        reasoning?: {
+            id?: string | undefined;
+            content?: string | undefined;
+        }[] | undefined;
+    }, {
+        role: "assistant";
+        content?: string | {
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | null | undefined;
+        function_call?: {
+            name: string;
+            arguments: string;
+        } | null | undefined;
+        name?: string | null | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | null | undefined;
+        reasoning?: {
+            id?: string | null | undefined;
+            content?: string | null | undefined;
+        }[] | null | undefined;
+    }>, z.ZodObject<{
+        content: z.ZodDefault<z.ZodString>;
+        role: z.ZodLiteral<"tool">;
+        tool_call_id: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        role: "tool";
+        tool_call_id: string;
+    }, {
+        role: "tool";
+        content?: string | undefined;
+        tool_call_id?: string | undefined;
+    }>, z.ZodObject<{
+        content: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        role: z.ZodLiteral<"function">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        content: string | null;
+        role: "function";
+    }, {
+        name: string;
+        content: string | null;
+        role: "function";
+    }>]>, z.ZodObject<{
+        role: z.ZodEnum<["model"]>;
+        content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        role: "model";
+        content?: string | null | undefined;
+    }, {
+        role: "model";
+        content?: string | null | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    messages: ({
+        content: (string | {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[]) & (string | {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | undefined);
+        role: "system";
+        name?: string | undefined;
+    } | {
+        content: (string | ({
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        } | {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        })[]) & (string | ({
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        } | {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        })[] | undefined);
+        role: "user";
+        name?: string | undefined;
+    } | {
+        role: "assistant";
+        content?: string | {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | null | undefined;
+        function_call?: {
+            name: string;
+            arguments: string;
+        } | undefined;
+        name?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+        reasoning?: {
+            id?: string | undefined;
+            content?: string | undefined;
+        }[] | undefined;
+    } | {
+        content: string;
+        role: "tool";
+        tool_call_id: string;
+    } | {
+        name: string;
+        content: string | null;
+        role: "function";
+    } | {
+        role: "model";
+        content?: string | null | undefined;
+    })[];
+}, {
+    messages: ({
+        role: "system";
+        content?: string | {
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | undefined;
+        name?: string | undefined;
+    } | {
+        role: "user";
+        content?: string | ({
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        } | {
+            type: "image_url";
+            image_url: {
+                url: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            };
+        })[] | undefined;
+        name?: string | undefined;
+    } | {
+        role: "assistant";
+        content?: string | {
+            type: "text";
+            text?: string | undefined;
+            cache_control?: {
+                type: "ephemeral";
+            } | undefined;
+        }[] | null | undefined;
+        function_call?: {
+            name: string;
+            arguments: string;
+        } | null | undefined;
+        name?: string | null | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | null | undefined;
+        reasoning?: {
+            id?: string | null | undefined;
+            content?: string | null | undefined;
+        }[] | null | undefined;
+    } | {
+        role: "tool";
+        content?: string | undefined;
+        tool_call_id?: string | undefined;
+    } | {
+        name: string;
+        content: string | null;
+        role: "function";
+    } | {
+        role: "model";
+        content?: string | null | undefined;
+    })[];
+}>]>, z.ZodObject<{
+    model: z.ZodString;
+    params: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_object";
+        }, {
+            type: "json_object";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+        }, {
+            type: "text";
+        }>]>>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>]>>;
+        n: z.ZodOptional<z.ZodNumber>;
+        stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_object";
+        }, {
+            type: "json_object";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+        }, {
+            type: "text";
+        }>]>>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>]>>;
+        n: z.ZodOptional<z.ZodNumber>;
+        stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_object";
+        }, {
+            type: "json_object";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+        }, {
+            type: "text";
+        }>]>>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>]>>;
+        n: z.ZodOptional<z.ZodNumber>;
+        stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        max_tokens: z.ZodNumber;
+        temperature: z.ZodNumber;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        max_tokens: z.ZodNumber;
+        temperature: z.ZodNumber;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        max_tokens: z.ZodNumber;
+        temperature: z.ZodNumber;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>]>>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    params?: z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_object";
+        }, {
+            type: "json_object";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+        }, {
+            type: "text";
+        }>]>>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>]>>;
+        n: z.ZodOptional<z.ZodNumber>;
+        stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        max_tokens: z.ZodNumber;
+        temperature: z.ZodNumber;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    model: string;
+    params?: z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_object";
+        }, {
+            type: "json_object";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }, {
+            type: "json_schema";
+            json_schema: {
+                name: string;
+                description?: string | undefined;
+                schema?: string | Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+        }, {
+            type: "text";
+        }>]>>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>]>>;
+        n: z.ZodOptional<z.ZodNumber>;
+        stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        max_tokens: z.ZodNumber;
+        temperature: z.ZodNumber;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+        use_cache: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>>;
+type PromptDefinition = z.infer<typeof promptDefinitionSchema>;
+type PromptOpts<HasId extends boolean, HasVersion extends boolean, HasTools extends boolean = true, HasNoTrace extends boolean = true> = (Partial<Omit<BaseFnOpts, "name">> & {
+    name: string;
+}) & (HasId extends true ? PromptId : Partial<PromptId>) & (HasVersion extends true ? PromptVersion : Partial<PromptVersion>) & (HasTools extends true ? Partial<PromptTools> : {}) & (HasNoTrace extends true ? Partial<PromptNoTrace> : {}) & PromptDefinition;
+declare class PromptBuilder {
+    private readonly project;
+    constructor(project: Project);
+    create<HasId extends boolean = false, HasVersion extends boolean = false>(opts: PromptOpts<HasId, HasVersion>): Prompt<HasId, HasVersion>;
+}
+
+declare const evalParametersSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"prompt">;
+    default: z.ZodOptional<z.ZodIntersection<z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
+        prompt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        prompt: string;
+    }, {
+        prompt: string;
+    }>, z.ZodObject<{
+        messages: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+            content: z.ZodUnion<[z.ZodDefault<z.ZodString>, z.ZodArray<z.ZodObject<{
+                text: z.ZodDefault<z.ZodString>;
+                type: z.ZodLiteral<"text">;
+                cache_control: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["ephemeral"]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "ephemeral";
+                }, {
+                    type: "ephemeral";
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }, {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }>, "many">]>;
+            role: z.ZodLiteral<"system">;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            content: (string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[]) & (string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | undefined);
+            role: "system";
+            name?: string | undefined;
+        }, {
+            role: "system";
+            content?: string | {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | undefined;
+            name?: string | undefined;
+        }>, z.ZodObject<{
+            content: z.ZodUnion<[z.ZodDefault<z.ZodString>, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                text: z.ZodDefault<z.ZodString>;
+                type: z.ZodLiteral<"text">;
+                cache_control: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["ephemeral"]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "ephemeral";
+                }, {
+                    type: "ephemeral";
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }, {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }>, z.ZodObject<{
+                image_url: z.ZodObject<{
+                    url: z.ZodString;
+                    detail: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"low">, z.ZodLiteral<"high">]>>;
+                }, "strip", z.ZodTypeAny, {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                }, {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                }>;
+                type: z.ZodLiteral<"image_url">;
+            }, "strip", z.ZodTypeAny, {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            }, {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            }>]>, "many">]>;
+            role: z.ZodLiteral<"user">;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            content: (string | ({
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[]) & (string | ({
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[] | undefined);
+            role: "user";
+            name?: string | undefined;
+        }, {
+            role: "user";
+            content?: string | ({
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[] | undefined;
+            name?: string | undefined;
+        }>, z.ZodObject<{
+            role: z.ZodLiteral<"assistant">;
+            content: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodObject<{
+                text: z.ZodDefault<z.ZodString>;
+                type: z.ZodLiteral<"text">;
+                cache_control: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["ephemeral"]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "ephemeral";
+                }, {
+                    type: "ephemeral";
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }, {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }>, "many">]>>>;
+            function_call: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                arguments: z.ZodString;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string;
+            }, {
+                name: string;
+                arguments: string;
+            }>>>, {
+                name: string;
+                arguments: string;
+            } | undefined, {
+                name: string;
+                arguments: string;
+            } | null | undefined>;
+            name: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
+            tool_calls: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                function: z.ZodObject<{
+                    arguments: z.ZodString;
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    arguments: string;
+                }, {
+                    name: string;
+                    arguments: string;
+                }>;
+                type: z.ZodLiteral<"function">;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }>, "many">>>, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | null | undefined>;
+            reasoning: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                id: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
+                content: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
+            }, "strip", z.ZodTypeAny, {
+                id?: string | undefined;
+                content?: string | undefined;
+            }, {
+                id?: string | null | undefined;
+                content?: string | null | undefined;
+            }>, "many">>>, {
+                id?: string | undefined;
+                content?: string | undefined;
+            }[] | undefined, {
+                id?: string | null | undefined;
+                content?: string | null | undefined;
+            }[] | null | undefined>;
+        }, "strip", z.ZodTypeAny, {
+            role: "assistant";
+            content?: string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | null | undefined;
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+            name?: string | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+            reasoning?: {
+                id?: string | undefined;
+                content?: string | undefined;
+            }[] | undefined;
+        }, {
+            role: "assistant";
+            content?: string | {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | null | undefined;
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | null | undefined;
+            name?: string | null | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | null | undefined;
+            reasoning?: {
+                id?: string | null | undefined;
+                content?: string | null | undefined;
+            }[] | null | undefined;
+        }>, z.ZodObject<{
+            content: z.ZodDefault<z.ZodString>;
+            role: z.ZodLiteral<"tool">;
+            tool_call_id: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            role: "tool";
+            tool_call_id: string;
+        }, {
+            role: "tool";
+            content?: string | undefined;
+            tool_call_id?: string | undefined;
+        }>, z.ZodObject<{
+            content: z.ZodNullable<z.ZodString>;
+            name: z.ZodString;
+            role: z.ZodLiteral<"function">;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            content: string | null;
+            role: "function";
+        }, {
+            name: string;
+            content: string | null;
+            role: "function";
+        }>]>, z.ZodObject<{
+            role: z.ZodEnum<["model"]>;
+            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            role: "model";
+            content?: string | null | undefined;
+        }, {
+            role: "model";
+            content?: string | null | undefined;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        messages: ({
+            content: (string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[]) & (string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | undefined);
+            role: "system";
+            name?: string | undefined;
+        } | {
+            content: (string | ({
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[]) & (string | ({
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[] | undefined);
+            role: "user";
+            name?: string | undefined;
+        } | {
+            role: "assistant";
+            content?: string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | null | undefined;
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+            name?: string | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+            reasoning?: {
+                id?: string | undefined;
+                content?: string | undefined;
+            }[] | undefined;
+        } | {
+            content: string;
+            role: "tool";
+            tool_call_id: string;
+        } | {
+            name: string;
+            content: string | null;
+            role: "function";
+        } | {
+            role: "model";
+            content?: string | null | undefined;
+        })[];
+    }, {
+        messages: ({
+            role: "system";
+            content?: string | {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | undefined;
+            name?: string | undefined;
+        } | {
+            role: "user";
+            content?: string | ({
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[] | undefined;
+            name?: string | undefined;
+        } | {
+            role: "assistant";
+            content?: string | {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | null | undefined;
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | null | undefined;
+            name?: string | null | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | null | undefined;
+            reasoning?: {
+                id?: string | null | undefined;
+                content?: string | null | undefined;
+            }[] | null | undefined;
+        } | {
+            role: "tool";
+            content?: string | undefined;
+            tool_call_id?: string | undefined;
+        } | {
+            name: string;
+            content: string | null;
+            role: "function";
+        } | {
+            role: "model";
+            content?: string | null | undefined;
+        })[];
+    }>]>, z.ZodObject<{
+        model: z.ZodString;
+        params: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_object";
+            }, {
+                type: "json_object";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>]>>>;
+            tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>]>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_object";
+            }, {
+                type: "json_object";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>]>>>;
+            tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>]>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_object";
+            }, {
+                type: "json_object";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>]>>>;
+            tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>]>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            max_tokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            max_tokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            max_tokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>]>>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        params?: z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_object";
+            }, {
+                type: "json_object";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>]>>>;
+            tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>]>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            max_tokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        model: string;
+        params?: z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_object";
+            }, {
+                type: "json_object";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>]>>>;
+            tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>]>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            max_tokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>>, z.ZodObject<{
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+            type: "function";
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        tools?: {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+            type: "function";
+        }[] | undefined;
+    }, {
+        tools?: {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+            type: "function";
+        }[] | undefined;
+    }>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "prompt";
+    default?: ((({
+        prompt: string;
+    } | {
+        messages: ({
+            content: (string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[]) & (string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | undefined);
+            role: "system";
+            name?: string | undefined;
+        } | {
+            content: (string | ({
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[]) & (string | ({
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[] | undefined);
+            role: "user";
+            name?: string | undefined;
+        } | {
+            role: "assistant";
+            content?: string | {
+                type: "text";
+                text: string;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | null | undefined;
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+            name?: string | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+            reasoning?: {
+                id?: string | undefined;
+                content?: string | undefined;
+            }[] | undefined;
+        } | {
+            content: string;
+            role: "tool";
+            tool_call_id: string;
+        } | {
+            name: string;
+            content: string | null;
+            role: "function";
+        } | {
+            role: "model";
+            content?: string | null | undefined;
+        })[];
+    }) & {
+        model: string;
+        params?: z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_object";
+            }, {
+                type: "json_object";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>]>>>;
+            tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>]>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            max_tokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }) & {
+        tools?: {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+            type: "function";
+        }[] | undefined;
+    }) | undefined;
+    description?: string | undefined;
+}, {
+    type: "prompt";
+    default?: ((({
+        prompt: string;
+    } | {
+        messages: ({
+            role: "system";
+            content?: string | {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | undefined;
+            name?: string | undefined;
+        } | {
+            role: "user";
+            content?: string | ({
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            } | {
+                type: "image_url";
+                image_url: {
+                    url: string;
+                    detail?: "auto" | "low" | "high" | undefined;
+                };
+            })[] | undefined;
+            name?: string | undefined;
+        } | {
+            role: "assistant";
+            content?: string | {
+                type: "text";
+                text?: string | undefined;
+                cache_control?: {
+                    type: "ephemeral";
+                } | undefined;
+            }[] | null | undefined;
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | null | undefined;
+            name?: string | null | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | null | undefined;
+            reasoning?: {
+                id?: string | null | undefined;
+                content?: string | null | undefined;
+            }[] | null | undefined;
+        } | {
+            role: "tool";
+            content?: string | undefined;
+            tool_call_id?: string | undefined;
+        } | {
+            name: string;
+            content: string | null;
+            role: "function";
+        } | {
+            role: "model";
+            content?: string | null | undefined;
+        })[];
+    }) & {
+        model: string;
+        params?: z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_object";
+            }, {
+                type: "json_object";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | Record<string, unknown> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>]>>>;
+            tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            function_call: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>]>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            max_tokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_tokens_to_sample: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }) & {
+        tools?: {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+                strict?: boolean | null | undefined;
+            };
+            type: "function";
+        }[] | undefined;
+    }) | undefined;
+    description?: string | undefined;
+}>, z.ZodType<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodTypeDef, z.ZodType<unknown, z.ZodTypeDef, unknown>>]>>;
+type EvalParameters = z.infer<typeof evalParametersSchema>;
+type InferParameterValue<T> = T extends {
+    type: "prompt";
+} ? Prompt : T extends z.ZodType ? z.infer<T> : never;
+type InferParameters<T extends EvalParameters> = {
+    [K in keyof T]: InferParameterValue<T[K]>;
+};
+
+type BaseExperiment<Input, Expected, Metadata extends BaseMetadata = DefaultMetadataType> = {
+    _type: "BaseExperiment";
+    _phantom?: [Input, Expected, Metadata];
+    name?: string;
+};
+/**
+ * Use this to specify that the dataset should actually be the data from a previous (base) experiment.
+ * If you do not specify a name, Braintrust will automatically figure out the best base experiment to
+ * use based on your git history (or fall back to timestamps).
+ *
+ * @param options
+ * @param options.name The name of the base experiment to use. If unspecified, Braintrust will automatically figure out the best base
+ * using your git history (or fall back to timestamps).
+ * @returns
+ */
+declare function BaseExperiment<Input = unknown, Expected = unknown, Metadata extends BaseMetadata = DefaultMetadataType>(options?: {
+    name?: string;
+}): BaseExperiment<Input, Expected, Metadata>;
+type EvalData<Input, Expected, Metadata extends BaseMetadata = DefaultMetadataType> = EvalCase<Input, Expected, Metadata>[] | (() => EvalCase<Input, Expected, Metadata>[]) | Promise<EvalCase<Input, Expected, Metadata>[]> | (() => Promise<EvalCase<Input, Expected, Metadata>[]>) | AsyncGenerator<EvalCase<Input, Expected, Metadata>> | AsyncIterable<EvalCase<Input, Expected, Metadata>> | BaseExperiment<Input, Expected, Metadata> | (() => BaseExperiment<Input, Expected, Metadata>);
+type EvalTask<Input, Output, Expected, Metadata extends BaseMetadata, Parameters extends EvalParameters> = ((input: Input, hooks: EvalHooks<Expected, Metadata, Parameters>) => Promise<Output>) | ((input: Input, hooks: EvalHooks<Expected, Metadata, Parameters>) => Output);
+type TaskProgressEvent = Omit<SSEProgressEventData, "id" | "origin" | "object_type" | "name">;
+interface EvalHooks<Expected, Metadata extends BaseMetadata, Parameters extends EvalParameters> {
+    /**
+     * @deprecated Use `metadata` instead.
+     */
+    meta: (info: Metadata) => void;
+    /**
+     * The metadata object for the current evaluation. You can mutate this object to add or remove metadata.
+     */
+    metadata: Metadata extends void ? Record<string, unknown> : Metadata;
+    /**
+     * The expected output for the current evaluation.
+     */
+    expected: Expected;
+    /**
+     * The task's span.
+     */
+    span: Span;
+    /**
+     * The current parameters being used for this specific task execution.
+     * Array parameters are converted to single values.
+     */
+    parameters: InferParameters<Parameters>;
+    /**
+     * Report progress that will show up in the playground.
+     */
+    reportProgress: (progress: TaskProgressEvent) => void;
+}
+type EvalScorerArgs<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType> = EvalCase<Input, Expected, Metadata> & {
+    output: Output;
+};
+type OneOrMoreScores = Score | number | null | Array<Score>;
+type EvalScorer<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType> = (args: EvalScorerArgs<Input, Output, Expected, Metadata>) => OneOrMoreScores | Promise<OneOrMoreScores>;
+type EvalResult<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType> = EvalCase<Input, Expected, Metadata> & {
+    output: Output;
+    scores: Record<string, number | null>;
+    error: unknown;
+    origin?: ObjectReference;
+};
+type ErrorScoreHandler = (args: {
+    rootSpan: Span;
+    data: EvalCase<any, any, any>;
+    unhandledScores: string[];
+}) => Record<string, number> | undefined | void;
+interface Evaluator<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType, Parameters extends EvalParameters = EvalParameters> {
+    /**
+     * A function that returns a list of inputs, expected outputs, and metadata.
+     */
+    data: EvalData<Input, Expected, Metadata>;
+    /**
+     * A function that takes an input and returns an output.
+     */
+    task: EvalTask<Input, Output, Expected, Metadata, Parameters>;
+    /**
+     * A set of functions that take an input, output, and expected value and return a score.
+     */
+    scores: EvalScorer<Input, Output, Expected, Metadata>[];
+    /**
+     * A set of parameters that will be passed to the evaluator.
+     * Can contain array values that will be converted to single values in the task.
+     */
+    parameters?: Parameters;
+    /**
+     * An optional name for the experiment.
+     */
+    experimentName?: string;
+    /**
+     * An optional description for the experiment.
+     */
+    description?: string;
+    /**
+     * The number of times to run the evaluator per input. This is useful for evaluating applications that
+     * have non-deterministic behavior and gives you both a stronger aggregate measure and a sense of the
+     * variance in the results.
+     */
+    trialCount?: number;
+    /**
+     * Optional additional metadata for the experiment.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Whether the experiment should be public. Defaults to false.
+     */
+    isPublic?: boolean;
+    /**
+     * Whether to update an existing experiment with `experiment_name` if one exists. Defaults to false.
+     */
+    update?: boolean;
+    /**
+     * The duration, in milliseconds, after which to time out the evaluation.
+     * Defaults to undefined, in which case there is no timeout.
+     */
+    timeout?: number;
+    /**
+     * An abort signal that can be used to stop the evaluation.
+     */
+    signal?: AbortSignal;
+    /**
+     * The maximum number of tasks/scorers that will be run concurrently.
+     * Defaults to undefined, in which case there is no max concurrency.
+     */
+    maxConcurrency?: number;
+    /**
+     * If specified, uses the given project ID instead of the evaluator's name to identify the project.
+     */
+    projectId?: string;
+    /**
+     * If specified, uses the logger state to initialize Braintrust objects. If unspecified, falls back
+     * to the global state (initialized using your API key).
+     */
+    state?: BraintrustState;
+    /**
+     * An optional experiment name to use as a base. If specified, the new experiment will be summarized
+     * and compared to this experiment.
+     */
+    baseExperimentName?: string;
+    /**
+     * An optional experiment id to use as a base. If specified, the new experiment will be summarized
+     * and compared to this experiment. This takes precedence over `baseExperimentName` if specified.
+     */
+    baseExperimentId?: string;
+    /**
+     * Optional settings for collecting git metadata. By default, will collect all git metadata fields allowed in org-level settings.
+     */
+    gitMetadataSettings?: GitMetadataSettings;
+    /**
+     * Optionally explicitly specify the git metadata for this experiment. This takes precedence over `gitMetadataSettings` if specified.
+     */
+    repoInfo?: RepoInfo;
+    /**
+     * Optionally supply a custom function to specifically handle score values when tasks or scoring functions have errored.
+     * A default implementation is exported as `defaultErrorScoreHandler` which will log a 0 score to the root span for any scorer that was not run.
+     */
+    errorScoreHandler?: ErrorScoreHandler;
+    /**
+     * Whether to summarize the scores of the experiment after it has run.
+     * Defaults to true.
+     */
+    summarizeScores?: boolean;
+}
+declare class EvalResultWithSummary<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType> {
+    summary: ExperimentSummary;
+    results: EvalResult<Input, Output, Expected, Metadata>[];
+    constructor(summary: ExperimentSummary, results: EvalResult<Input, Output, Expected, Metadata>[]);
+    toString(): string;
+    toJSON(): {
+        summary: ExperimentSummary;
+        results: EvalResult<Input, Output, Expected, Metadata>[];
+    };
+}
+interface ReporterOpts {
+    verbose: boolean;
+    jsonl: boolean;
+}
+interface ReporterBody<EvalReport> {
+    /**
+     * A function that takes an evaluator and its result and returns a report.
+     *
+     * @param evaluator
+     * @param result
+     * @param opts
+     */
+    reportEval(evaluator: EvaluatorDef<any, any, any, any, any>, result: EvalResultWithSummary<any, any, any, any>, opts: ReporterOpts): Promise<EvalReport> | EvalReport;
+    /**
+     * A function that takes all evaluator results and returns a boolean indicating
+     * whether the run was successful. If you return false, the `braintrust eval`
+     * command will exit with a non-zero status code.
+     *
+     * @param reports
+     */
+    reportRun(reports: EvalReport[]): boolean | Promise<boolean>;
+}
+type ReporterDef<EvalReport> = {
+    name: string;
+} & ReporterBody<EvalReport>;
+type EvaluatorDef<Input, Output, Expected, Metadata extends BaseMetadata = DefaultMetadataType, Parameters extends EvalParameters = EvalParameters> = {
+    projectName: string;
+    evalName: string;
+} & Evaluator<Input, Output, Expected, Metadata, Parameters>;
+type EvaluatorFile = {
+    functions: CodeFunction<unknown, unknown, GenericFunction<unknown, unknown>>[];
+    prompts: CodePrompt[];
+    evaluators: {
+        [evalName: string]: {
+            evaluator: EvaluatorDef<unknown, unknown, unknown, BaseMetadata, EvalParameters>;
+            reporter?: ReporterDef<unknown> | string;
+        };
+    };
+    reporters: {
+        [reporterName: string]: ReporterDef<unknown>;
+    };
+};
+type SpanContext = {
+    currentSpan: typeof currentSpan;
+    startSpan: typeof startSpan;
+    withCurrent: typeof withCurrent;
+    NOOP_SPAN: typeof NOOP_SPAN;
+};
+declare global {
+    var _evals: EvaluatorFile;
+    var _spanContext: SpanContext | undefined;
+    var _lazy_load: boolean;
+}
+
+interface DevServerOpts {
+    host: string;
+    port: number;
+}
+declare function runDevServer(evaluators: EvaluatorDef<any, any, any, any, any>[], opts: DevServerOpts): void;
+
+export { runDevServer };