braintrust 3.27.0 → 3.29.0

package/dist/instrumentation/index.d.mts

@@ -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;
 }
@@ -6881,6 +6916,7 @@ interface InstrumentationIntegrationsConfig {
     langchain?: boolean;
     langgraph?: boolean;
     langsmith?: boolean;
+    voyageai?: boolean;
 }
 interface InstrumentationConfig {
     /**
@@ -6907,6 +6943,7 @@ interface BraintrustPluginConfig {
  * - Mistral SDK
  * - Ollama SDK
  * - Cohere SDK
+ * - Voyage AI SDK
  *
  * The plugin is automatically enabled when the Braintrust library is loaded.
  * Individual integrations can be disabled via configuration.
@@ -6939,6 +6976,7 @@ declare class BraintrustPlugin extends BasePlugin {
     private langSmithPlugin;
     private piCodingAgentPlugin;
     private strandsAgentSDKPlugin;
+    private voyageAIPlugin;
     private cloudflareAIChatPlugin;
     private cloudflareAgentsPlugin;
     constructor(config?: BraintrustPluginConfig);
@@ -7019,16 +7057,108 @@ declare const AsyncScoringControl: z.ZodUnion<[z.ZodObject<{
         token: z.ZodString;
         function_ids: z.ZodArray<z.ZodUnknown, "many">;
         skip_logging: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodNull]>>;
+        triggered_functions: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodObject<{
+            triggered_xact_id: z.ZodString;
+            completed_xact_id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+            idempotency_key: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+            attempts: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            scope: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"span">;
+            }, "strip", z.ZodTypeAny, {
+                type: "span";
+            }, {
+                type: "span";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"trace">;
+            }, "strip", z.ZodTypeAny, {
+                type: "trace";
+            }, {
+                type: "trace";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"group">;
+                key: z.ZodString;
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                type: "group";
+                key: string;
+            }, {
+                value: string;
+                type: "group";
+                key: string;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            triggered_xact_id: string;
+            attempts: number;
+            scope: {
+                type: "span";
+            } | {
+                type: "trace";
+            } | {
+                value: string;
+                type: "group";
+                key: string;
+            };
+            completed_xact_id?: string | null | undefined;
+            idempotency_key?: string | null | undefined;
+        }, {
+            triggered_xact_id: string;
+            scope: {
+                type: "span";
+            } | {
+                type: "trace";
+            } | {
+                value: string;
+                type: "group";
+                key: string;
+            };
+            completed_xact_id?: string | null | undefined;
+            idempotency_key?: string | null | undefined;
+            attempts?: number | undefined;
+        }>>, z.ZodNull]>>;
+        last_triggered_xact_id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
     }, "strip", z.ZodTypeAny, {
         status: "enabled";
         token: string;
         function_ids: unknown[];
         skip_logging?: boolean | null | undefined;
+        triggered_functions?: Record<string, {
+            triggered_xact_id: string;
+            attempts: number;
+            scope: {
+                type: "span";
+            } | {
+                type: "trace";
+            } | {
+                value: string;
+                type: "group";
+                key: string;
+            };
+            completed_xact_id?: string | null | undefined;
+            idempotency_key?: string | null | undefined;
+        }> | null | undefined;
+        last_triggered_xact_id?: string | number | null | undefined;
     }, {
         status: "enabled";
         token: string;
         function_ids: unknown[];
         skip_logging?: boolean | null | undefined;
+        triggered_functions?: Record<string, {
+            triggered_xact_id: string;
+            scope: {
+                type: "span";
+            } | {
+                type: "trace";
+            } | {
+                value: string;
+                type: "group";
+                key: string;
+            };
+            completed_xact_id?: string | null | undefined;
+            idempotency_key?: string | null | undefined;
+            attempts?: number | undefined;
+        }> | null | undefined;
+        last_triggered_xact_id?: string | number | null | undefined;
     }>, z.ZodObject<{
         status: z.ZodLiteral<"disabled">;
     }, "strip", z.ZodTypeAny, {
@@ -7043,6 +7173,22 @@ declare const AsyncScoringControl: z.ZodUnion<[z.ZodObject<{
         token: string;
         function_ids: unknown[];
         skip_logging?: boolean | null | undefined;
+        triggered_functions?: Record<string, {
+            triggered_xact_id: string;
+            attempts: number;
+            scope: {
+                type: "span";
+            } | {
+                type: "trace";
+            } | {
+                value: string;
+                type: "group";
+                key: string;
+            };
+            completed_xact_id?: string | null | undefined;
+            idempotency_key?: string | null | undefined;
+        }> | null | undefined;
+        last_triggered_xact_id?: string | number | null | undefined;
     } | {
         status: "disabled";
     } | null;
@@ -7053,6 +7199,22 @@ declare const AsyncScoringControl: z.ZodUnion<[z.ZodObject<{
         token: string;
         function_ids: unknown[];
         skip_logging?: boolean | null | undefined;
+        triggered_functions?: Record<string, {
+            triggered_xact_id: string;
+            scope: {
+                type: "span";
+            } | {
+                type: "trace";
+            } | {
+                value: string;
+                type: "group";
+                key: string;
+            };
+            completed_xact_id?: string | null | undefined;
+            idempotency_key?: string | null | undefined;
+            attempts?: number | undefined;
+        }> | null | undefined;
+        last_triggered_xact_id?: string | number | null | undefined;
     } | {
         status: "disabled";
     } | null;
@@ -7069,14 +7231,62 @@ declare const AsyncScoringControl: z.ZodUnion<[z.ZodObject<{
 }, {
     kind: "state_enabled_force_rescore";
 }>, z.ZodObject<{
-    kind: z.ZodLiteral<"add_triggered_functions">;
-    triggered_function_ids: z.ZodArray<z.ZodUnknown, "many">;
+    kind: z.ZodLiteral<"trigger_functions">;
+    triggered_functions: z.ZodArray<z.ZodObject<{
+        function_id: z.ZodOptional<z.ZodUnknown>;
+        scope: z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"span">;
+        }, "strip", z.ZodTypeAny, {
+            type: "span";
+        }, {
+            type: "span";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"trace">;
+        }, "strip", z.ZodTypeAny, {
+            type: "trace";
+        }, {
+            type: "trace";
+        }>]>;
+        idempotency_key: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        scope: {
+            type: "span";
+        } | {
+            type: "trace";
+        };
+        idempotency_key?: string | undefined;
+        function_id?: unknown;
+    }, {
+        scope: {
+            type: "span";
+        } | {
+            type: "trace";
+        };
+        idempotency_key?: string | undefined;
+        function_id?: unknown;
+    }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    kind: "add_triggered_functions";
-    triggered_function_ids: unknown[];
+    kind: "trigger_functions";
+    triggered_functions: {
+        scope: {
+            type: "span";
+        } | {
+            type: "trace";
+        };
+        idempotency_key?: string | undefined;
+        function_id?: unknown;
+    }[];
 }, {
-    kind: "add_triggered_functions";
-    triggered_function_ids: unknown[];
+    kind: "trigger_functions";
+    triggered_functions: {
+        scope: {
+            type: "span";
+        } | {
+            type: "trace";
+        };
+        idempotency_key?: string | undefined;
+        function_id?: unknown;
+    }[];
 }>, z.ZodObject<{
     kind: z.ZodLiteral<"complete_triggered_functions">;
     function_ids: z.ZodArray<z.ZodUnknown, "many">;
@@ -7089,6 +7299,15 @@ declare const AsyncScoringControl: z.ZodUnion<[z.ZodObject<{
     kind: "complete_triggered_functions";
     triggered_xact_id: string;
     function_ids: unknown[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"mark_attempt_failed">;
+    function_ids: z.ZodArray<z.ZodUnknown, "many">;
+}, "strip", z.ZodTypeAny, {
+    kind: "mark_attempt_failed";
+    function_ids: unknown[];
+}, {
+    kind: "mark_attempt_failed";
+    function_ids: unknown[];
 }>]>;
 type AsyncScoringControlType = z.infer<typeof AsyncScoringControl>;
 declare const ObjectReference: z.ZodObject<{
@@ -7526,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.
  *
@@ -7534,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.
@@ -7561,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>;
 }
@@ -8040,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;
@@ -8072,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;
@@ -8116,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;
@@ -8769,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>> {
@@ -8782,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>>;
 }
@@ -9458,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 {
@@ -9487,6 +10020,183 @@ 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>;
+interface EveProviderDefinition {
+    readonly capture?: "content" | "metadata";
+    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;
@@ -9498,7 +10208,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"];