@opencode/ai 0.0.0-beta-19275

package/dist/schema/messages.d.ts

@@ -0,0 +1,646 @@
+import { Schema } from "effect";
+import { Tool } from "@opencode/schema/tool";
+import { CacheHint, GenerationOptions, HttpOptions, type LanguageModel } from "./options.js";
+export declare const MessageRole: Schema.Literals<readonly ["system", "user", "assistant", "tool"]>;
+export type MessageRole = Schema.Schema.Type<typeof MessageRole>;
+export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
+export type ProviderMetadata = Schema.Schema.Type<typeof ProviderMetadata>;
+declare const systemPartSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+export type SystemPart = Schema.Schema.Type<typeof systemPartSchema>;
+export declare const SystemPart: Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}> & {
+    make: (text: string) => SystemPart;
+    content: (input?: string | SystemPart | ReadonlyArray<SystemPart>) => any[];
+};
+export declare const TextPart: Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>;
+export type TextPart = Schema.Schema.Type<typeof TextPart>;
+export declare const MediaPart: Schema.Struct<{
+    readonly type: Schema.Literal<"media">;
+    readonly mediaType: Schema.String;
+    readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+    readonly filename: Schema.optional<Schema.String>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>;
+export type MediaPart = Schema.Schema.Type<typeof MediaPart>;
+declare const toolResultValueSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"json">;
+    readonly value: Schema.Unknown;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly value: Schema.Unknown;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly value: Schema.Unknown;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"content">;
+    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file">;
+        readonly uri: Schema.String;
+        readonly mime: Schema.String;
+        readonly name: Schema.optional<Schema.String>;
+    }>]>>;
+}>]>;
+export type ToolResultValue = Schema.Schema.Type<typeof toolResultValueSchema>;
+export declare const ToolResultValue: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"json">;
+    readonly value: Schema.Unknown;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly value: Schema.Unknown;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly value: Schema.Unknown;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"content">;
+    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file">;
+        readonly uri: Schema.String;
+        readonly mime: Schema.String;
+        readonly name: Schema.optional<Schema.String>;
+    }>]>>;
+}>]> & {
+    is: <I>(input: I) => input is I & ({
+        readonly type: "json";
+        readonly value: unknown;
+    } | {
+        readonly type: "text";
+        readonly value: unknown;
+    } | {
+        readonly type: "error";
+        readonly value: unknown;
+    } | {
+        readonly type: "content";
+        readonly value: readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "file";
+            readonly uri: string;
+            readonly mime: string;
+            readonly name?: string | undefined;
+        })[];
+    });
+    make: (value: unknown, type?: ToolResultValue["type"]) => ToolResultValue;
+};
+export interface ToolOutput {
+    readonly structured: unknown;
+    readonly content: ReadonlyArray<Tool.Content>;
+}
+export declare const ToolOutput: Schema.Struct<{
+    readonly structured: Schema.Unknown;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file">;
+        readonly uri: Schema.String;
+        readonly mime: Schema.String;
+        readonly name: Schema.optional<Schema.String>;
+    }>]>>;
+}> & {
+    make: (structured: unknown, content?: ReadonlyArray<Tool.Content>) => ToolOutput;
+    fromResultValue: (result: ToolResultValue) => ToolOutput | undefined;
+    toResultValue: (output: ToolOutput) => ToolResultValue;
+};
+export declare const ToolCallPart: Schema.Struct<{
+    readonly type: Schema.Literal<"tool-call">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly namespace: Schema.optional<Schema.String>;
+    readonly input: Schema.Unknown;
+    readonly providerExecuted: Schema.optional<Schema.Boolean>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}> & {
+    make: (input: Omit<ToolCallPart, "type">) => ToolCallPart;
+};
+export type ToolCallPart = Schema.Schema.Type<typeof ToolCallPart>;
+export declare const ToolResultPart: Schema.Struct<{
+    readonly type: Schema.Literal<"tool-result">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly namespace: Schema.optional<Schema.String>;
+    readonly result: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"json">;
+        readonly value: Schema.Unknown;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly value: Schema.Unknown;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"error">;
+        readonly value: Schema.Unknown;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"content">;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: Schema.optional<Schema.String>;
+        }>]>>;
+    }>]> & {
+        is: <I>(input: I) => input is I & ({
+            readonly type: "json";
+            readonly value: unknown;
+        } | {
+            readonly type: "text";
+            readonly value: unknown;
+        } | {
+            readonly type: "error";
+            readonly value: unknown;
+        } | {
+            readonly type: "content";
+            readonly value: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        });
+        make: (value: unknown, type?: ToolResultValue["type"]) => ToolResultValue;
+    };
+    readonly providerExecuted: Schema.optional<Schema.Boolean>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}> & {
+    make: (input: Omit<ToolResultPart, "type" | "result"> & {
+        readonly result: unknown;
+        readonly resultType?: ToolResultValue["type"];
+    }) => ToolResultPart;
+};
+export type ToolResultPart = Schema.Schema.Type<typeof ToolResultPart>;
+export declare const ReasoningPart: Schema.Struct<{
+    readonly type: Schema.Literal<"reasoning">;
+    readonly text: Schema.String;
+    readonly encrypted: Schema.optional<Schema.String>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>;
+export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>;
+/** A provider-generated context checkpoint, distinct from visible assistant text. */
+type CompactionContent = {
+    readonly encrypted: string;
+    readonly text?: never;
+} | {
+    readonly text: string | null;
+    readonly encrypted?: never;
+};
+declare const compactionPartSchema: Schema.refine<{
+    readonly type: "compaction";
+    readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    readonly id?: string | undefined;
+    readonly text?: string | null | undefined;
+    readonly encrypted?: string | undefined;
+} & CompactionContent, Schema.Struct<{
+    readonly type: Schema.Literal<"compaction">;
+    readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+    readonly id: Schema.optional<Schema.String>;
+    readonly encrypted: Schema.optional<Schema.String>;
+    /** Null means the provider failed to produce a summary; prior history must be retained. */
+    readonly text: Schema.optional<Schema.NullOr<Schema.String>>;
+}>>;
+export type CompactionPart = typeof compactionPartSchema.Type;
+export declare const CompactionPart: Schema.refine<{
+    readonly type: "compaction";
+    readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    readonly id?: string | undefined;
+    readonly text?: string | null | undefined;
+    readonly encrypted?: string | undefined;
+} & CompactionContent, Schema.Struct<{
+    readonly type: Schema.Literal<"compaction">;
+    readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+    readonly id: Schema.optional<Schema.String>;
+    readonly encrypted: Schema.optional<Schema.String>;
+    /** Null means the provider failed to produce a summary; prior history must be retained. */
+    readonly text: Schema.optional<Schema.NullOr<Schema.String>>;
+}>> & {
+    make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent) => CompactionPart;
+};
+export declare const ContentPart: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"media">;
+    readonly mediaType: Schema.String;
+    readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+    readonly filename: Schema.optional<Schema.String>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-call">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly namespace: Schema.optional<Schema.String>;
+    readonly input: Schema.Unknown;
+    readonly providerExecuted: Schema.optional<Schema.Boolean>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}> & {
+    make: (input: Omit<ToolCallPart, "type">) => ToolCallPart;
+}, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-result">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly namespace: Schema.optional<Schema.String>;
+    readonly result: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"json">;
+        readonly value: Schema.Unknown;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly value: Schema.Unknown;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"error">;
+        readonly value: Schema.Unknown;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"content">;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: Schema.optional<Schema.String>;
+        }>]>>;
+    }>]> & {
+        is: <I>(input: I) => input is I & ({
+            readonly type: "json";
+            readonly value: unknown;
+        } | {
+            readonly type: "text";
+            readonly value: unknown;
+        } | {
+            readonly type: "error";
+            readonly value: unknown;
+        } | {
+            readonly type: "content";
+            readonly value: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        });
+        make: (value: unknown, type?: ToolResultValue["type"]) => ToolResultValue;
+    };
+    readonly providerExecuted: Schema.optional<Schema.Boolean>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}> & {
+    make: (input: Omit<ToolResultPart, "type" | "result"> & {
+        readonly result: unknown;
+        readonly resultType?: ToolResultValue["type"];
+    }) => ToolResultPart;
+}, Schema.Struct<{
+    readonly type: Schema.Literal<"reasoning">;
+    readonly text: Schema.String;
+    readonly encrypted: Schema.optional<Schema.String>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, Schema.refine<{
+    readonly type: "compaction";
+    readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    readonly id?: string | undefined;
+    readonly text?: string | null | undefined;
+    readonly encrypted?: string | undefined;
+} & CompactionContent, Schema.Struct<{
+    readonly type: Schema.Literal<"compaction">;
+    readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+    readonly id: Schema.optional<Schema.String>;
+    readonly encrypted: Schema.optional<Schema.String>;
+    /** Null means the provider failed to produce a summary; prior history must be retained. */
+    readonly text: Schema.optional<Schema.NullOr<Schema.String>>;
+}>> & {
+    make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent) => CompactionPart;
+}]>;
+export type ContentPart = Schema.Schema.Type<typeof ContentPart>;
+declare const Message_base: Schema.Class<Message, Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly role: Schema.Literals<readonly ["system", "user", "assistant", "tool"]>;
+    readonly content: Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly cache: Schema.optional<typeof CacheHint>;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"media">;
+        readonly mediaType: Schema.String;
+        readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+        readonly filename: Schema.optional<Schema.String>;
+        readonly cache: Schema.optional<typeof CacheHint>;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly namespace: Schema.optional<Schema.String>;
+        readonly input: Schema.Unknown;
+        readonly providerExecuted: Schema.optional<Schema.Boolean>;
+        readonly cache: Schema.optional<typeof CacheHint>;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }> & {
+        make: (input: Omit<ToolCallPart, "type">) => ToolCallPart;
+    }, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly namespace: Schema.optional<Schema.String>;
+        readonly result: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"json">;
+            readonly value: Schema.Unknown;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly value: Schema.Unknown;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"error">;
+            readonly value: Schema.Unknown;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"content">;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"file">;
+                readonly uri: Schema.String;
+                readonly mime: Schema.String;
+                readonly name: Schema.optional<Schema.String>;
+            }>]>>;
+        }>]> & {
+            is: <I>(input: I) => input is I & ({
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            });
+            make: (value: unknown, type?: ToolResultValue["type"]) => ToolResultValue;
+        };
+        readonly providerExecuted: Schema.optional<Schema.Boolean>;
+        readonly cache: Schema.optional<typeof CacheHint>;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }> & {
+        make: (input: Omit<ToolResultPart, "type" | "result"> & {
+            readonly result: unknown;
+            readonly resultType?: ToolResultValue["type"];
+        }) => ToolResultPart;
+    }, Schema.Struct<{
+        readonly type: Schema.Literal<"reasoning">;
+        readonly text: Schema.String;
+        readonly encrypted: Schema.optional<Schema.String>;
+        readonly cache: Schema.optional<typeof CacheHint>;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, Schema.refine<{
+        readonly type: "compaction";
+        readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        readonly id?: string | undefined;
+        readonly text?: string | null | undefined;
+        readonly encrypted?: string | undefined;
+    } & CompactionContent, Schema.Struct<{
+        readonly type: Schema.Literal<"compaction">;
+        readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+        readonly id: Schema.optional<Schema.String>;
+        readonly encrypted: Schema.optional<Schema.String>;
+        /** Null means the provider failed to produce a summary; prior history must be retained. */
+        readonly text: Schema.optional<Schema.NullOr<Schema.String>>;
+    }>> & {
+        make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent) => CompactionPart;
+    }]>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly native: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, {}>;
+export declare class Message extends Message_base {
+}
+export declare namespace Message {
+    type ContentInput = string | ContentPart | ReadonlyArray<ContentPart>;
+    type SystemContentInput = string | TextPart | ReadonlyArray<TextPart>;
+    type Input = Omit<ConstructorParameters<typeof Message>[0], "content"> & {
+        readonly content: ContentInput;
+    };
+    const text: (value: string) => ContentPart;
+    const content: (input: ContentInput) => any[];
+    const make: (input: Message | Input) => Message;
+    const user: (content: ContentInput) => Message;
+    const assistant: (content: ContentInput) => Message;
+    /**
+     * Add an operator-authored instruction at this chronological point in the
+     * conversation. This is distinct from the initial `LLMRequest.system`
+     * prompt. Keep raw retrieved, tool, and web content out of privileged system
+     * updates; pass that untrusted content through ordinary user/tool channels.
+     */
+    const system: (content: SystemContentInput) => Message;
+    const tool: (result: ToolResultPart | Parameters<typeof ToolResultPart.make>[0]) => Message;
+}
+declare const toolDefinitionFields: {
+    name: Schema.String;
+    description: Schema.String;
+    inputSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+    outputSchema: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    cache: Schema.optional<typeof CacheHint>;
+    metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    native: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+};
+export type ToolDefinitionInput = Schema.Struct.Type<typeof toolDefinitionFields>;
+declare const ToolDefinition_base: Schema.Class<ToolDefinition, Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly inputSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly outputSchema: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly cache: Schema.optional<typeof CacheHint>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly native: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly type: Schema.Literal<"tool">;
+}>, {}>;
+export declare class ToolDefinition extends ToolDefinition_base {
+    constructor(input: ToolDefinitionInput);
+}
+export declare namespace ToolDefinition {
+    type Input = ToolDefinition | ToolDefinitionInput;
+    /** Normalize tool definition input into the canonical `ToolDefinition` class. */
+    const make: (input: Input) => ToolDefinition;
+}
+export type ToolNamespace = {
+    readonly type: "namespace";
+    readonly name: string;
+    readonly description?: string;
+    readonly tools: ReadonlyArray<ToolEntry>;
+};
+export type ToolNamespaceInput = Omit<ToolNamespace, "type" | "tools"> & {
+    readonly tools: ReadonlyArray<ToolEntryInput>;
+};
+export type ToolNamespaceEntryInput = ToolNamespaceInput & {
+    readonly type: "namespace";
+};
+export declare const ToolNamespace: Schema.Codec<ToolNamespace> & {
+    readonly make: (input: ToolNamespace | ToolNamespaceInput) => ToolNamespace;
+};
+export type ToolEntry = ToolDefinition | ToolNamespace;
+export type ToolEntryInput = ToolDefinition.Input | ToolNamespaceEntryInput;
+export declare const ToolEntry: Schema.Codec<ToolEntry> & {
+    readonly make: (input: ToolEntryInput) => ToolEntry;
+};
+declare const ToolChoice_base: Schema.Class<ToolChoice, Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["auto", "none", "required", "tool"]>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly disableParallelToolUse: Schema.optional<Schema.Boolean>;
+}>, {}>;
+export declare class ToolChoice extends ToolChoice_base {
+}
+export declare namespace ToolChoice {
+    type Mode = Exclude<ToolChoice["type"], "tool">;
+    type Input = ToolChoice | ConstructorParameters<typeof ToolChoice>[0] | ToolDefinition | string;
+    /** Select a specific named tool. */
+    const named: (value: string) => ToolChoice;
+    /** Normalize ergonomic tool-choice inputs into the canonical `ToolChoice` class. */
+    const make: (input: Input) => ToolChoice;
+}
+declare const requestSchema: Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly model: Schema.declare<LanguageModel<{
+        readonly [x: string]: unknown;
+    }, import("../route.js").CompactionOperations | undefined>, LanguageModel<{
+        readonly [x: string]: unknown;
+    }, import("../route.js").CompactionOperations | undefined>>;
+    readonly system: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly cache: Schema.optional<typeof CacheHint>;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }> & {
+        make: (text: string) => SystemPart;
+        content: (input?: string | SystemPart | ReadonlyArray<SystemPart>) => any[];
+    }>;
+    readonly messages: Schema.$Array<typeof Message>;
+    readonly tools: Schema.$Array<Schema.Codec<ToolEntry, ToolEntry, never, never> & {
+        readonly make: (input: ToolEntryInput) => ToolEntry;
+    }>;
+    readonly toolChoice: Schema.optional<typeof ToolChoice>;
+    readonly generation: Schema.optional<typeof GenerationOptions>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly http: Schema.optional<typeof HttpOptions>;
+    readonly cache: Schema.optional<Schema.Union<readonly [Schema.Literal<"auto">, Schema.Literal<"none">, Schema.Struct<{
+        readonly tools: Schema.optional<Schema.Boolean>;
+        readonly system: Schema.optional<Schema.Boolean>;
+        readonly messages: Schema.optional<Schema.Union<readonly [Schema.Literal<"latest-user-message">, Schema.Literal<"latest-assistant">, Schema.Struct<{
+            readonly tail: Schema.Natural;
+        }>]>>;
+        readonly ttlSeconds: Schema.optional<Schema.Number>;
+    }>]>>;
+    readonly promptCacheKey: Schema.optional<Schema.String>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+declare const LLMRequest_base: Schema.Class<LLMRequest<LanguageModel<{
+    readonly [x: string]: unknown;
+}, import("../route.js").CompactionOperations | undefined>>, Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly model: Schema.declare<LanguageModel<{
+        readonly [x: string]: unknown;
+    }, import("../route.js").CompactionOperations | undefined>, LanguageModel<{
+        readonly [x: string]: unknown;
+    }, import("../route.js").CompactionOperations | undefined>>;
+    readonly system: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly cache: Schema.optional<typeof CacheHint>;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }> & {
+        make: (text: string) => SystemPart;
+        content: (input?: string | SystemPart | ReadonlyArray<SystemPart>) => any[];
+    }>;
+    readonly messages: Schema.$Array<typeof Message>;
+    readonly tools: Schema.$Array<Schema.Codec<ToolEntry, ToolEntry, never, never> & {
+        readonly make: (input: ToolEntryInput) => ToolEntry;
+    }>;
+    readonly toolChoice: Schema.optional<typeof ToolChoice>;
+    readonly generation: Schema.optional<typeof GenerationOptions>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly http: Schema.optional<typeof HttpOptions>;
+    readonly cache: Schema.optional<Schema.Union<readonly [Schema.Literal<"auto">, Schema.Literal<"none">, Schema.Struct<{
+        readonly tools: Schema.optional<Schema.Boolean>;
+        readonly system: Schema.optional<Schema.Boolean>;
+        readonly messages: Schema.optional<Schema.Union<readonly [Schema.Literal<"latest-user-message">, Schema.Literal<"latest-assistant">, Schema.Struct<{
+            readonly tail: Schema.Natural;
+        }>]>>;
+        readonly ttlSeconds: Schema.optional<Schema.Number>;
+    }>]>>;
+    readonly promptCacheKey: Schema.optional<Schema.String>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, {}>;
+export declare class LLMRequest<Model extends LanguageModel = LanguageModel> extends LLMRequest_base {
+    readonly model: Model;
+    constructor(input: LLMRequest.Input<Model>);
+}
+export declare namespace LLMRequest {
+    type Input<Model extends LanguageModel = LanguageModel> = Omit<typeof requestSchema.Type, "model"> & {
+        readonly model: Model;
+    };
+    const input: <Model extends LanguageModel>(request: LLMRequest<Model>) => Input<Model>;
+    function update<Model extends LanguageModel>(request: LLMRequest, patch: Partial<Input<Model>> & {
+        readonly model: Model;
+    }): LLMRequest<Model>;
+    function update<Model extends LanguageModel>(request: LLMRequest<Model>, patch: Partial<Omit<Input, "model">> & {
+        readonly model?: undefined;
+    }): LLMRequest<Model>;
+    function update(request: LLMRequest, patch: Partial<Input>): LLMRequest;
+}
+export {};