@opencode-ai/ai 0.0.0-bootstrap.0 → 0.0.0-dev-17472

package/dist/schema/messages.d.ts

@@ -0,0 +1,402 @@
+import { Schema } from "effect";
+import { Tool } from "@opencode-ai/schema/tool";
+import { CacheHint, GenerationOptions, HttpOptions } from "./options.js";
+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 metadata: Schema.optional<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: (value: unknown) => value is ToolResultValue;
+    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 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 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: (value: unknown) => value is ToolResultValue;
+        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>;
+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 metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-call">;
+    readonly id: Schema.String;
+    readonly name: 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 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: (value: unknown) => value is ToolResultValue;
+        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>>>;
+}>]>;
+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 metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly id: Schema.String;
+        readonly name: 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 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: (value: unknown) => value is ToolResultValue;
+            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>>>;
+    }>]>>;
+    readonly metadata: Schema.optional<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 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>>;
+}>, {}>;
+export declare class ToolDefinition extends ToolDefinition_base {
+}
+export declare namespace ToolDefinition {
+    type Input = ToolDefinition | ConstructorParameters<typeof ToolDefinition>[0];
+    /** Normalize tool definition input into the canonical `ToolDefinition` class. */
+    const make: (input: Input) => ToolDefinition;
+}
+declare const ToolChoice_base: Schema.Class<ToolChoice, Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["auto", "none", "required", "tool"]>;
+    readonly name: Schema.optional<Schema.String>;
+}>, {}>;
+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 LLMRequest_base: Schema.Class<LLMRequest, Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly model: Schema.declare<import("./options.js").LanguageModel<{
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    }>, import("./options.js").LanguageModel<{
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    }>>;
+    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<typeof ToolDefinition>;
+    readonly toolChoice: Schema.optional<typeof ToolChoice>;
+    readonly generation: Schema.optional<typeof GenerationOptions>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, 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.Number;
+        }>]>>;
+        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 extends LLMRequest_base {
+}
+export declare namespace LLMRequest {
+    type Input = ConstructorParameters<typeof LLMRequest>[0];
+    const input: (request: LLMRequest) => Input;
+    const update: (request: LLMRequest, patch: Partial<Input>) => LLMRequest;
+}
+export {};

package/dist/schema/messages.js

@@ -0,0 +1,244 @@
+import { Schema } from "effect";
+import { Tool } from "@opencode-ai/schema/tool";
+import { JsonSchema, MessageRole, ProviderMetadata } from "./ids.js";
+import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, LanguageModelSchema, ProviderOptions, } from "./options.js";
+import { isRecord } from "../utils/record.js";
+const systemPartSchema = Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    cache: Schema.optional(CacheHint),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}).annotate({ identifier: "LLM.SystemPart" });
+const makeSystemPart = (text) => ({ type: "text", text });
+export const SystemPart = Object.assign(systemPartSchema, {
+    make: makeSystemPart,
+    content: (input) => {
+        if (input === undefined)
+            return [];
+        return typeof input === "string" ? [makeSystemPart(input)] : Array.isArray(input) ? [...input] : [input];
+    },
+});
+export const TextPart = Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    cache: Schema.optional(CacheHint),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "LLM.Content.Text" });
+export const MediaPart = Schema.Struct({
+    type: Schema.Literal("media"),
+    mediaType: Schema.String,
+    data: Schema.Union([Schema.String, Schema.Uint8Array]),
+    filename: Schema.optional(Schema.String),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}).annotate({ identifier: "LLM.Content.Media" });
+const isToolResultValue = (value) => isRecord(value) &&
+    (value.type === "text" || value.type === "json" || value.type === "error" || value.type === "content") &&
+    "value" in value;
+const toolResultValueSchema = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("json"),
+        value: Schema.Unknown,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("text"),
+        value: Schema.Unknown,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("error"),
+        value: Schema.Unknown,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("content"),
+        value: Schema.Array(Tool.Content),
+    }),
+]).annotate({ identifier: "LLM.ToolResult" });
+export const ToolResultValue = Object.assign(toolResultValueSchema, {
+    is: isToolResultValue,
+    make: (value, type = "json") => {
+        if (isToolResultValue(value))
+            return value;
+        if (type === "content")
+            return { type, value: Array.isArray(value) ? value : [] };
+        return { type, value };
+    },
+});
+export const ToolOutput = Object.assign(Schema.Struct({
+    structured: Schema.Unknown,
+    content: Schema.Array(Tool.Content),
+}).annotate({ identifier: "LLM.ToolOutput" }), {
+    make: (structured, content = []) => ({ structured, content }),
+    fromResultValue: (result) => {
+        switch (result.type) {
+            case "json":
+                return { structured: result.value, content: [] };
+            case "text":
+                return { structured: {}, content: [{ type: "text", text: toolResultText(result.value) }] };
+            case "content":
+                return { structured: {}, content: result.value };
+            case "error":
+                return undefined;
+        }
+    },
+    toResultValue: (output) => {
+        if (output.content.length === 0)
+            return { type: "json", value: output.structured };
+        if (output.content.length === 1 && output.content[0]?.type === "text")
+            return { type: "text", value: output.content[0].text };
+        return { type: "content", value: output.content };
+    },
+});
+const toolResultText = (value) => {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+export const ToolCallPart = Object.assign(Schema.Struct({
+    type: Schema.Literal("tool-call"),
+    id: Schema.String,
+    name: Schema.String,
+    input: Schema.Unknown,
+    providerExecuted: Schema.optional(Schema.Boolean),
+    cache: Schema.optional(CacheHint),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "LLM.Content.ToolCall" }), {
+    make: (input) => ({ type: "tool-call", ...input }),
+});
+export const ToolResultPart = Object.assign(Schema.Struct({
+    type: Schema.Literal("tool-result"),
+    id: Schema.String,
+    name: Schema.String,
+    result: ToolResultValue,
+    providerExecuted: Schema.optional(Schema.Boolean),
+    cache: Schema.optional(CacheHint),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "LLM.Content.ToolResult" }), {
+    make: (input) => ({
+        type: "tool-result",
+        id: input.id,
+        name: input.name,
+        result: ToolResultValue.make(input.result, input.resultType),
+        providerExecuted: input.providerExecuted,
+        cache: input.cache,
+        metadata: input.metadata,
+        providerMetadata: input.providerMetadata,
+    }),
+});
+export const ReasoningPart = Schema.Struct({
+    type: Schema.Literal("reasoning"),
+    text: Schema.String,
+    encrypted: Schema.optional(Schema.String),
+    cache: Schema.optional(CacheHint),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "LLM.Content.Reasoning" });
+export const ContentPart = Schema.Union([TextPart, MediaPart, ToolCallPart, ToolResultPart, ReasoningPart]).pipe(Schema.toTaggedUnion("type"));
+export class Message extends Schema.Class("LLM.Message")({
+    id: Schema.optional(Schema.String),
+    role: MessageRole,
+    content: Schema.Array(ContentPart),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {
+}
+(function (Message) {
+    Message.text = (value) => ({ type: "text", text: value });
+    Message.content = (input) => typeof input === "string" ? [Message.text(input)] : Array.isArray(input) ? [...input] : [input];
+    Message.make = (input) => {
+        if (input instanceof Message)
+            return input;
+        return new Message({ ...input, content: Message.content(input.content) });
+    };
+    Message.user = (content) => Message.make({ role: "user", content });
+    Message.assistant = (content) => Message.make({ role: "assistant", content });
+    /**
+     * 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.
+     */
+    Message.system = (content) => Message.make({ role: "system", content });
+    Message.tool = (result) => Message.make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] });
+})(Message || (Message = {}));
+export class ToolDefinition extends Schema.Class("LLM.ToolDefinition")({
+    name: Schema.String,
+    description: Schema.String,
+    inputSchema: JsonSchema,
+    outputSchema: Schema.optional(JsonSchema),
+    cache: Schema.optional(CacheHint),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {
+}
+(function (ToolDefinition) {
+    /** Normalize tool definition input into the canonical `ToolDefinition` class. */
+    ToolDefinition.make = (input) => (input instanceof ToolDefinition ? input : new ToolDefinition(input));
+})(ToolDefinition || (ToolDefinition = {}));
+export class ToolChoice extends Schema.Class("LLM.ToolChoice")({
+    type: Schema.Literals(["auto", "none", "required", "tool"]),
+    name: Schema.optional(Schema.String),
+}) {
+}
+(function (ToolChoice) {
+    const isMode = (value) => value === "auto" || value === "none" || value === "required";
+    /** Select a specific named tool. */
+    ToolChoice.named = (value) => new ToolChoice({ type: "tool", name: value });
+    /** Normalize ergonomic tool-choice inputs into the canonical `ToolChoice` class. */
+    ToolChoice.make = (input) => {
+        if (input instanceof ToolChoice)
+            return input;
+        if (input instanceof ToolDefinition)
+            return ToolChoice.named(input.name);
+        if (typeof input === "string")
+            return isMode(input) ? new ToolChoice({ type: input }) : ToolChoice.named(input);
+        return new ToolChoice(input);
+    };
+})(ToolChoice || (ToolChoice = {}));
+export class LLMRequest extends Schema.Class("LLM.Request")({
+    id: Schema.optional(Schema.String),
+    model: LanguageModelSchema,
+    system: Schema.Array(SystemPart),
+    messages: Schema.Array(Message),
+    tools: Schema.Array(ToolDefinition),
+    toolChoice: Schema.optional(ToolChoice),
+    generation: Schema.optional(GenerationOptions),
+    providerOptions: Schema.optional(ProviderOptions),
+    http: Schema.optional(HttpOptions),
+    cache: Schema.optional(CachePolicy),
+    // Stable cache affinity for protocols that support provider-managed prompt caching.
+    promptCacheKey: Schema.optional(Schema.String),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {
+}
+(function (LLMRequest) {
+    LLMRequest.input = (request) => ({
+        id: request.id,
+        model: request.model,
+        system: request.system,
+        messages: request.messages,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        generation: request.generation,
+        providerOptions: request.providerOptions,
+        http: request.http,
+        cache: request.cache,
+        promptCacheKey: request.promptCacheKey,
+        metadata: request.metadata,
+    });
+    LLMRequest.update = (request, patch) => {
+        if (Object.keys(patch).length === 0)
+            return request;
+        return new LLMRequest({
+            ...LLMRequest.input(request),
+            ...patch,
+            model: patch.model ?? request.model,
+        });
+    };
+})(LLMRequest || (LLMRequest = {}));