braintrust 3.28.0 → 3.30.0

package/dist/instrumentation/index.d.ts

@@ -3334,6 +3334,15 @@ declare const PromptData: z.ZodObject<{
         type: "global";
         name: string;
         function_type?: "preprocessor" | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"inline">;
+        code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        type: "inline";
+    }, {
+        code: string;
+        type: "inline";
     }>, z.ZodNull]>>;
     tool_functions: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodObject<{
         type: z.ZodLiteral<"function">;
@@ -3644,6 +3653,9 @@ declare const PromptData: z.ZodObject<{
         type: "global";
         name: string;
         function_type: "preprocessor";
+    } | {
+        code: string;
+        type: "inline";
     } | null | undefined;
     origin?: {
         project_id?: string | undefined;
@@ -3918,6 +3930,9 @@ declare const PromptData: z.ZodObject<{
         type: "global";
         name: string;
         function_type?: "preprocessor" | undefined;
+    } | {
+        code: string;
+        type: "inline";
     } | null | undefined;
     origin?: {
         project_id?: string | undefined;
@@ -5361,6 +5376,15 @@ declare const Prompt$1: z.ZodObject<{
             type: "global";
             name: string;
             function_type?: "preprocessor" | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"inline">;
+            code: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            type: "inline";
+        }, {
+            code: string;
+            type: "inline";
         }>, z.ZodNull]>>;
         tool_functions: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -5671,6 +5695,9 @@ declare const Prompt$1: z.ZodObject<{
             type: "global";
             name: string;
             function_type: "preprocessor";
+        } | {
+            code: string;
+            type: "inline";
         } | null | undefined;
         origin?: {
             project_id?: string | undefined;
@@ -5945,6 +5972,9 @@ declare const Prompt$1: z.ZodObject<{
             type: "global";
             name: string;
             function_type?: "preprocessor" | undefined;
+        } | {
+            code: string;
+            type: "inline";
         } | null | undefined;
         origin?: {
             project_id?: string | undefined;
@@ -6236,6 +6266,9 @@ declare const Prompt$1: z.ZodObject<{
             type: "global";
             name: string;
             function_type: "preprocessor";
+        } | {
+            code: string;
+            type: "inline";
         } | null | undefined;
         origin?: {
             project_id?: string | undefined;
@@ -6524,6 +6557,9 @@ declare const Prompt$1: z.ZodObject<{
             type: "global";
             name: string;
             function_type?: "preprocessor" | undefined;
+        } | {
+            code: string;
+            type: "inline";
         } | null | undefined;
         origin?: {
             project_id?: string | undefined;
@@ -6608,7 +6644,6 @@ declare const PromptSessionEvent: z.ZodObject<{
 type PromptSessionEventType = z.infer<typeof PromptSessionEvent>;
 
 interface GlobalHookAsyncLocalStorage<T> {
-    enterWith(store: T): void;
     run<R>(store: T | undefined, callback: () => R): R;
     getStore(): T | undefined;
 }
@@ -7710,6 +7745,14 @@ interface PromptKey {
      */
     id?: string;
 }
+type PromptMemoryCacheEntry = {
+    value: Prompt;
+    resolvedOrgIdentity?: string;
+};
+type PromptDiskCacheEntry = {
+    value: ReturnType<Prompt["_internalSerializeForCache"]>;
+    resolvedOrgIdentity?: string;
+};
 /**
  * A configurable cache for Braintrust prompts with optional in-memory and filesystem storage.
  *
@@ -7718,10 +7761,19 @@ interface PromptKey {
 declare class PromptCache {
     private readonly memoryCache?;
     private readonly diskCache?;
+    private readonly namespace?;
+    private readonly expectedResolvedOrgIdentity?;
     constructor(options: {
-        memoryCache?: LRUCache<string, Prompt>;
-        diskCache?: DiskCache<Prompt>;
+        memoryCache?: LRUCache<string, PromptMemoryCacheEntry>;
+        diskCache?: DiskCache<PromptDiskCacheEntry>;
+        namespace?: string;
+        expectedResolvedOrgIdentity?: string;
     });
+    /**
+     * Returns a cache view that shares the same storage layers but isolates all
+     * entries under the provided namespace.
+     */
+    withNamespace(namespace: string, expectedResolvedOrgIdentity?: string): PromptCache;
     /**
      * Retrieves a prompt from the cache.
      * First checks the in-memory LRU cache, then falls back to checking the disk cache if available.
@@ -7745,13 +7797,26 @@ interface ParametersKey {
     projectName?: string;
     id?: string;
 }
+type ParametersMemoryCacheEntry = {
+    value: RemoteEvalParameters;
+    resolvedOrgIdentity?: string;
+};
+type ParametersDiskCacheEntry = {
+    value: ReturnType<RemoteEvalParameters["_internalSerializeForCache"]>;
+    resolvedOrgIdentity?: string;
+};
 declare class ParametersCache {
     private readonly memoryCache?;
     private readonly diskCache?;
+    private readonly namespace?;
+    private readonly expectedResolvedOrgIdentity?;
     constructor(options: {
-        memoryCache?: LRUCache<string, RemoteEvalParameters>;
-        diskCache?: DiskCache<RemoteEvalParameters>;
+        memoryCache?: LRUCache<string, ParametersMemoryCacheEntry>;
+        diskCache?: DiskCache<ParametersDiskCacheEntry>;
+        namespace?: string;
+        expectedResolvedOrgIdentity?: string;
     });
+    withNamespace(namespace: string, expectedResolvedOrgIdentity?: string): ParametersCache;
     get(key: ParametersKey): Promise<RemoteEvalParameters | undefined>;
     set(key: ParametersKey, value: RemoteEvalParameters): Promise<void>;
 }
@@ -8224,8 +8289,17 @@ declare const loginSchema: z.ZodObject<{
     debugLogLevelDisabled?: boolean | undefined;
 }>;
 type SerializedBraintrustState = z.infer<typeof loginSchema>;
+type ResolvedLoaderLoginOptions = Required<Pick<LoginOptions, "apiKey" | "appUrl" | "fetch">> & Pick<LoginOptions, "orgName"> & {
+    forceLogin?: boolean;
+    credentialCacheNamespace: string;
+    existingState?: BraintrustState;
+};
+type LoaderCacheViews = {
+    promptCache: PromptCache;
+    parametersCache: ParametersCache;
+};
+type LoaderRequestState = Pick<BraintrustState, "appUrl" | "orgId" | "apiConn">;
 declare class BraintrustState {
-    private loginParams;
     id: string;
     currentExperiment: Experiment | undefined;
     currentLogger: Logger<false> | undefined;
@@ -8256,12 +8330,23 @@ declare class BraintrustState {
     private _otelFlushCallback;
     spanOriginEnvironment: SpanOriginEnvironment | undefined;
     private traceContextSigningSecret;
+    private loaderLoginCache;
+    private readonly loginParams;
+    private activeLoginOrgNameSelector;
     constructor(loginParams: LoginOptions);
     /** @internal */
     _internalSetTraceContextSigningSecret(secret: string | undefined): void;
     /** @internal */
     _internalGetTraceContextSigningSecret(): string | undefined;
     resetLoginInfo(): void;
+    /** @internal */
+    _internalResolveLoaderLoginOptions({ apiKey, appUrl, orgName, fetch, forceLogin, }: Pick<LoginOptions, "apiKey" | "appUrl" | "orgName" | "fetch"> & {
+        forceLogin?: boolean;
+    }): Promise<ResolvedLoaderLoginOptions>;
+    /** @internal */
+    _internalGetLoaderCacheViews(loginOptions: ResolvedLoaderLoginOptions, requestState?: LoaderRequestState): LoaderCacheViews;
+    /** @internal */
+    _internalGetLoaderState({ apiKey, appUrl, orgName, fetch, forceLogin, existingState, }: ResolvedLoaderLoginOptions): Promise<LoaderRequestState>;
     resetIdGenState(): void;
     [RESET_CONTEXT_MANAGER_STATE](): void;
     get idGenerator(): IDGenerator;
@@ -8300,11 +8385,12 @@ declare class BraintrustState {
     toString(): string;
 }
 declare class HTTPConnection {
+    private readonly classifyTransportErrors;
     base_url: string;
     token: string | null;
     headers: Record<string, string>;
     fetch: typeof globalThis.fetch;
-    constructor(base_url: string, fetch: typeof globalThis.fetch);
+    constructor(base_url: string, fetch: typeof globalThis.fetch, classifyTransportErrors?: boolean);
     setFetch(fetch: typeof globalThis.fetch): void;
     ping(): Promise<boolean>;
     make_long_lived(): void;
@@ -8953,6 +9039,251 @@ declare class Prompt<HasId extends boolean = true, HasVersion extends boolean =
     }): PromptBlockDataType;
     private getParsedPromptData;
     static isPrompt(data: unknown): data is Prompt<boolean, boolean>;
+    /** @internal */
+    _internalSerializeForCache(): {
+        metadata: {
+            id: string;
+            created: string;
+            project_id: string;
+            _xact_id: string;
+            prompt_session_id: string;
+            function_type?: "llm" | "scorer" | "task" | "tool" | "custom_view" | "preprocessor" | "facet" | "classifier" | "tag" | "parameters" | "sandbox" | null | undefined;
+            tags?: string[] | null | undefined;
+            _pagination_key?: string | null | undefined;
+            completion?: unknown;
+            prompt_data?: unknown;
+            function_data?: unknown;
+            prompt_session_data?: unknown;
+            object_data?: unknown;
+        } | PromptRowWithId<HasId, HasVersion>;
+        defaults: Partial<Omit<z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            reasoning_enabled: z.ZodOptional<z.ZodBoolean>;
+            reasoning_budget: z.ZodOptional<z.ZodNumber>;
+            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.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.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodString]>>;
+                    strict: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodNull]>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+            }, {
+                type: "text";
+            }>, z.ZodNull]>>;
+            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<["none", "minimal", "low", "medium", "high"]>>;
+            verbosity: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            reasoning_enabled: z.ZodOptional<z.ZodBoolean>;
+            reasoning_budget: z.ZodOptional<z.ZodNumber>;
+            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>;
+            reasoning_enabled: z.ZodOptional<z.ZodBoolean>;
+            reasoning_budget: z.ZodOptional<z.ZodNumber>;
+            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>;
+            reasoning_enabled: z.ZodOptional<z.ZodBoolean>;
+            reasoning_budget: z.ZodOptional<z.ZodNumber>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+            use_cache: z.ZodOptional<z.ZodBoolean>;
+            reasoning_enabled: z.ZodOptional<z.ZodBoolean>;
+            reasoning_budget: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | undefined, "response_format" | "reasoning_effort" | "use_cache"> & Omit<{
+            max_tokens: number;
+            temperature?: number | undefined;
+            top_p?: number | undefined;
+            max_completion_tokens?: number | undefined;
+            frequency_penalty?: number | undefined;
+            presence_penalty?: number | undefined;
+            response_format?: {
+                type: "json_object";
+            } | {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            } | {
+                type: "text";
+            } | null | undefined;
+            tool_choice?: "auto" | "none" | "required" | {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            } | undefined;
+            function_call?: "auto" | "none" | {
+                name: string;
+            } | undefined;
+            n?: number | undefined;
+            stop?: string[] | undefined;
+            reasoning_effort?: "none" | "minimal" | "low" | "medium" | "high" | undefined;
+            verbosity?: "low" | "medium" | "high" | undefined;
+            top_k?: number | undefined;
+            stop_sequences?: string[] | undefined;
+            reasoning_enabled?: boolean | undefined;
+            reasoning_budget?: number | undefined;
+            max_tokens_to_sample?: number | undefined;
+            maxOutputTokens?: number | undefined;
+            topP?: number | undefined;
+            topK?: number | undefined;
+            use_cache?: boolean | undefined;
+        }, "response_format" | "reasoning_effort" | "use_cache"> & {
+            reasoning_effort?: CompiledPromptReasoningEffort;
+            response_format?: {
+                type: "json_object";
+            } | {
+                type: "text";
+            } | (Omit<{
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            }, "json_schema"> & {
+                json_schema: Omit<{
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                }, "schema"> & {
+                    schema?: Record<string, unknown> | undefined;
+                };
+            }) | undefined;
+            model: string;
+        } & {
+            max_tokens: number;
+            temperature?: number | undefined;
+            top_p?: number | undefined;
+            max_completion_tokens?: number | undefined;
+            frequency_penalty?: number | undefined;
+            presence_penalty?: number | undefined;
+            response_format?: {
+                type: "json_object";
+            } | {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    description?: string | undefined;
+                    schema?: string | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                    strict?: boolean | null | undefined;
+                };
+            } | {
+                type: "text";
+            } | null | undefined;
+            tool_choice?: "auto" | "none" | "required" | {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            } | undefined;
+            function_call?: "auto" | "none" | {
+                name: string;
+            } | undefined;
+            n?: number | undefined;
+            stop?: string[] | undefined;
+            reasoning_effort?: "none" | "minimal" | "low" | "medium" | "high" | undefined;
+            verbosity?: "low" | "medium" | "high" | undefined;
+            top_k?: number | undefined;
+            stop_sequences?: string[] | undefined;
+            reasoning_enabled?: boolean | undefined;
+            reasoning_budget?: number | undefined;
+            max_tokens_to_sample?: number | undefined;
+            maxOutputTokens?: number | undefined;
+            topP?: number | undefined;
+            topK?: number | undefined;
+            use_cache?: boolean | undefined;
+        } & ChatPrompt & CompletionPrompt>;
+        noTrace: boolean;
+    };
     static fromPromptData(name: string, promptData: PromptDataType): Prompt<false, false>;
 }
 declare class RemoteEvalParameters<HasId extends boolean = true, HasVersion extends boolean = true, T extends Record<string, unknown> = Record<string, unknown>> {
@@ -8966,6 +9297,24 @@ declare class RemoteEvalParameters<HasId extends boolean = true, HasVersion exte
     get version(): HasVersion extends true ? TransactionId : TransactionId | undefined;
     get schema(): Record<string, unknown>;
     get data(): T;
+    /** @internal */
+    _internalSerializeForCache(): {
+        metadata: {
+            id: string;
+            project_id: string;
+            name: string;
+            slug: string;
+            function_type: "parameters";
+            _xact_id: string;
+            function_data: {
+                type: "parameters";
+                __schema: Record<string, unknown>;
+                data?: Record<string, unknown> | undefined;
+            };
+            description?: string | null | undefined;
+            metadata?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        };
+    };
     validate(data: unknown): boolean;
     static isParameters(x: unknown): x is RemoteEvalParameters<boolean, boolean, Record<string, unknown>>;
 }
@@ -9642,7 +9991,7 @@ type EveModelMessage = EveSystemModelMessage | {
     readonly role: "tool";
 };
 interface EveInstrumentationModelInput {
-    readonly instructions?: string | readonly EveSystemModelMessage[];
+    readonly instructions?: string | EveSystemModelMessage | readonly EveSystemModelMessage[];
     readonly messages: readonly EveModelMessage[];
 }
 interface EveInstrumentationStepStartedEventInput {
@@ -9671,6 +10020,198 @@ interface EveInstrumentationDefinition {
     readonly recordOutputs?: boolean;
     readonly setup?: (context: EveInstrumentationSetupContext) => void;
 }
+/**
+ * Vendored types for Eve's instrumentation-provider API, introduced in
+ * eve@0.34.0. Keep this limited to lifecycle events consumed by Braintrust.
+ */
+interface EveProviderSetupContext {
+    readonly agentName: string;
+    readonly environment?: "development" | "preview" | "production";
+    readonly evaluation?: {
+        readonly runId: string;
+    };
+    readonly frameworkVersion?: string;
+}
+interface EveProviderState {
+    get(): EveJsonValue | undefined;
+    set(value: EveJsonValue | undefined): void;
+}
+interface EveProviderContext {
+    readonly state: EveProviderState;
+}
+interface EveInstrumentationAttemptScope {
+    readonly attemptId: string;
+    readonly attemptIndex: number;
+    readonly functionId?: string;
+    readonly rootSessionId?: string;
+    readonly sessionId: string;
+    readonly stepIndex: number;
+    readonly turnId: string;
+}
+interface EveInstrumentationParentLineage {
+    readonly callId: string;
+    readonly sessionId: string;
+    readonly subagentName?: string;
+    readonly turnId: string;
+}
+interface EveInstrumentationTraceContext {
+    readonly isRemote?: boolean;
+    readonly spanId: string;
+    readonly traceFlags: number;
+    readonly traceId: string;
+}
+interface EveProviderTurnStartedEvent {
+    readonly idempotencyKey: string;
+    readonly parentLineage?: EveInstrumentationParentLineage;
+    readonly parentTraceContext?: EveInstrumentationTraceContext;
+    readonly rootSessionId: string;
+    readonly sequence: number;
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly type: "turn.started";
+}
+type EveProviderTurnTerminalEvent = {
+    readonly idempotencyKey: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly type: "turn.cancelled" | "turn.completed";
+} | {
+    readonly error?: unknown;
+    readonly idempotencyKey: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly type: "turn.failed";
+};
+interface EveProviderModelCallStartedEvent {
+    readonly idempotencyKey: string;
+    readonly input?: EveInstrumentationModelInput;
+    readonly model: {
+        readonly modelId: string;
+        readonly provider: string;
+    };
+    readonly scope: EveInstrumentationAttemptScope;
+    readonly type: "model.call.started";
+}
+type EveProviderContentPart = {
+    readonly text: string;
+    readonly type: "text";
+} | {
+    readonly text: string;
+    readonly type: "reasoning";
+} | {
+    readonly callId: string;
+    readonly input: unknown;
+    readonly toolName: string;
+    readonly type: "tool-call";
+} | {
+    readonly callId: string;
+    readonly input: unknown;
+    readonly output: unknown;
+    readonly toolName: string;
+    readonly type: "tool-result";
+} | {
+    readonly callId: string;
+    readonly error: unknown;
+    readonly input: unknown;
+    readonly toolName: string;
+    readonly type: "tool-error";
+};
+interface EveProviderUsage {
+    readonly inputTokenDetails?: {
+        readonly cacheReadTokens?: number;
+        readonly cacheWriteTokens?: number;
+    };
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+}
+type EveProviderModelCallTerminalEvent = {
+    readonly content?: readonly EveProviderContentPart[];
+    readonly finishReason: string;
+    readonly idempotencyKey: string;
+    readonly scope: EveInstrumentationAttemptScope;
+    readonly type: "model.call.completed";
+    readonly usage: EveProviderUsage;
+} | {
+    readonly error?: unknown;
+    readonly idempotencyKey: string;
+    readonly scope: EveInstrumentationAttemptScope;
+    readonly type: "model.call.failed";
+};
+type EveProviderActionKind = "load-skill" | "remote-agent-call" | "subagent-call" | "tool-call";
+interface EveProviderActionStartedEvent {
+    readonly callId: string;
+    readonly idempotencyKey: string;
+    readonly input?: unknown;
+    readonly kind: EveProviderActionKind;
+    readonly name: string;
+    readonly scope: EveInstrumentationAttemptScope;
+    readonly type: "action.started";
+}
+type EveProviderActionTerminalEvent = {
+    readonly acceptedAtMs?: number;
+    readonly idempotencyKey: string;
+    readonly outcome: "completed";
+    readonly output: {
+        readonly output?: unknown;
+        readonly type: "result";
+    } | {
+        readonly error?: unknown;
+        readonly type: "error";
+    };
+    readonly scope: EveInstrumentationAttemptScope;
+    readonly type: "action.completed";
+    readonly usage?: EveProviderUsage;
+} | {
+    readonly acceptedAtMs?: number;
+    readonly error?: unknown;
+    readonly errorCode?: string;
+    readonly idempotencyKey: string;
+    readonly outcome: "abandoned" | "cancelled" | "failed" | "rejected";
+    readonly scope: EveInstrumentationAttemptScope;
+    readonly type: "action.failed";
+};
+type EveProviderStepAttemptTerminalEvent = {
+    readonly error?: unknown;
+    readonly idempotencyKey: string;
+    readonly scope: EveInstrumentationAttemptScope;
+    readonly type: "step.attempt.completed" | "step.attempt.failed";
+};
+type EveProviderHandler<TEvent> = (event: TEvent, context: EveProviderContext) => void | PromiseLike<void>;
+type EveChannelAudience = "private" | "public" | "unknown";
+interface EveTraceCaptureContext {
+    readonly agentName?: string;
+    readonly audience: EveChannelAudience;
+    readonly channelType?: string;
+}
+type EveTracePolicyDecision = {
+    readonly emit: false;
+} | {
+    readonly emit: true;
+    readonly recordInputs: boolean;
+    readonly recordOutputs: boolean;
+};
+type EveTraceCapturePolicy = (trace: EveTraceCaptureContext) => EveTracePolicyDecision | boolean;
+interface EveProviderDefinition {
+    readonly capture?: "content" | "metadata";
+    readonly tracePolicy?: EveTraceCapturePolicy;
+    readonly events?: {
+        readonly "action.completed"?: EveProviderHandler<EveProviderActionTerminalEvent>;
+        readonly "action.failed"?: EveProviderHandler<EveProviderActionTerminalEvent>;
+        readonly "action.started"?: EveProviderHandler<EveProviderActionStartedEvent>;
+        readonly "model.call.completed"?: EveProviderHandler<EveProviderModelCallTerminalEvent>;
+        readonly "model.call.failed"?: EveProviderHandler<EveProviderModelCallTerminalEvent>;
+        readonly "model.call.started"?: EveProviderHandler<EveProviderModelCallStartedEvent>;
+        readonly "step.attempt.completed"?: EveProviderHandler<EveProviderStepAttemptTerminalEvent>;
+        readonly "step.attempt.failed"?: EveProviderHandler<EveProviderStepAttemptTerminalEvent>;
+        readonly "turn.cancelled"?: EveProviderHandler<EveProviderTurnTerminalEvent>;
+        readonly "turn.completed"?: EveProviderHandler<EveProviderTurnTerminalEvent>;
+        readonly "turn.failed"?: EveProviderHandler<EveProviderTurnTerminalEvent>;
+        readonly "turn.started"?: EveProviderHandler<EveProviderTurnStartedEvent>;
+    };
+    readonly flush?: () => void | PromiseLike<void>;
+    readonly setup?: (context: EveProviderSetupContext) => void | PromiseLike<void>;
+    readonly shutdown?: () => void | PromiseLike<void>;
+}
 
 type EveStateHandle<T> = {
     get(): T;
@@ -9682,7 +10223,20 @@ declare function braintrustEveHook(options: {
     defineState: EveDefineState;
     metadata?: Record<string, unknown>;
 }): EveHookDefinition;
-/** Eve instrumentation helper for logger setup and durable LLM input capture. */
+
+type EveProviderInstrumentationOptions = {
+    metadata?: Record<string, unknown>;
+    setup?: EveProviderDefinition["setup"];
+};
+/**
+ * Braintrust instrumentation for Eve.
+ *
+ * Pass `defineState` when using Eve's legacy authored instrumentation API.
+ * With Eve 0.34+, omit `defineState` to use the instrumentation-provider
+ * lifecycle and enable `experimental.instrumentationProviders` on the agent.
+ * The result is ready to export directly from the instrumentation module.
+ */
+declare function braintrustEveInstrumentation(options: EveProviderInstrumentationOptions): EveProviderDefinition;
 declare function braintrustEveInstrumentation(options: {
     defineState: EveDefineState;
     setup?: EveInstrumentationDefinition["setup"];