@opencode/ai 0.0.0-beta-19275

package/dist/schema/messages.js

@@ -0,0 +1,301 @@
+import { Schema } from "effect";
+import { Tool } from "@opencode/schema/tool";
+import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderOptions, } from "./options.js";
+import { ProviderID } from "./ids.js";
+export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"]);
+export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown)).annotate({
+    identifier: "LLM.ProviderMetadata",
+});
+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),
+    cache: Schema.optional(CacheHint),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "LLM.Content.Media" });
+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" });
+const isToolResultValue = Schema.is(toolResultValueSchema);
+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,
+    namespace: Schema.optional(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,
+    namespace: Schema.optional(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,
+        namespace: input.namespace,
+        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" });
+const compactionPartSchema = Schema.Struct({
+    type: Schema.Literal("compaction"),
+    provider: ProviderID,
+    id: Schema.optional(Schema.String),
+    encrypted: Schema.optional(Schema.String),
+    /** Null means the provider failed to produce a summary; prior history must be retained. */
+    text: Schema.optional(Schema.NullOr(Schema.String)),
+})
+    .pipe(Schema.refine((part) => (part.encrypted !== undefined) !== (part.text !== undefined), { message: "Compaction requires either encrypted content or a summary" }))
+    .annotate({ identifier: "LLM.Content.Compaction" });
+export const CompactionPart = Object.assign(compactionPartSchema, {
+    make: (input) => Schema.decodeUnknownSync(compactionPartSchema)({ type: "compaction", ...input }),
+});
+export const ContentPart = Schema.Union([
+    TextPart,
+    MediaPart,
+    ToolCallPart,
+    ToolResultPart,
+    ReasoningPart,
+    CompactionPart,
+]).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)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+    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 = {}));
+const toolDefinitionFields = {
+    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)),
+};
+export class ToolDefinition extends Schema.Class("LLM.ToolDefinition")({
+    type: Schema.Literal("tool"),
+    ...toolDefinitionFields,
+}) {
+    constructor(input) {
+        super({ ...input, type: "tool" });
+    }
+}
+(function (ToolDefinition) {
+    /** Normalize tool definition input into the canonical `ToolDefinition` class. */
+    ToolDefinition.make = (input) => (input instanceof ToolDefinition ? input : new ToolDefinition(input));
+})(ToolDefinition || (ToolDefinition = {}));
+export const ToolNamespace = Object.assign(Schema.Struct({
+    type: Schema.Literal("namespace"),
+    name: Schema.String,
+    description: Schema.optional(Schema.UndefinedOr(Schema.String)),
+    tools: Schema.Array(Schema.suspend(() => ToolEntry)),
+}).annotate({ identifier: "LLM.ToolNamespace" }), {
+    make: (input) => ({
+        ...input,
+        type: "namespace",
+        tools: input.tools.map(ToolEntry.make),
+    }),
+});
+export const ToolEntry = Object.assign(Schema.Union([ToolDefinition, ToolNamespace]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "LLM.ToolEntry" })), {
+    make: (input) => "type" in input && input.type === "namespace" ? ToolNamespace.make(input) : ToolDefinition.make(input),
+});
+export class ToolChoice extends Schema.Class("LLM.ToolChoice")({
+    type: Schema.Literals(["auto", "none", "required", "tool"]),
+    name: Schema.optional(Schema.String),
+    disableParallelToolUse: Schema.optional(Schema.Boolean),
+}) {
+}
+(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 = {}));
+const requestSchema = Schema.Struct({
+    id: Schema.optional(Schema.String),
+    model: LanguageModelSchema,
+    system: Schema.Array(SystemPart),
+    messages: Schema.Array(Message),
+    tools: Schema.Array(ToolEntry),
+    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)),
+});
+export class LLMRequest extends Schema.Class("LLM.Request")(requestSchema.fields) {
+    // Preserve model inference instead of inheriting the schema's erased constructor signature.
+    // oxlint-disable-next-line no-useless-constructor
+    constructor(input) {
+        super(input);
+    }
+}
+(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,
+    });
+    function update(request, patch) {
+        if (Object.keys(patch).length === 0)
+            return request;
+        return new LLMRequest({
+            ...LLMRequest.input(request),
+            ...patch,
+            model: patch.model ?? request.model,
+        });
+    }
+    LLMRequest.update = update;
+})(LLMRequest || (LLMRequest = {}));

package/dist/schema/options.d.ts

@@ -0,0 +1,157 @@
+import { Schema } from "effect";
+import { ModelID, ProviderID } from "./ids.js";
+import type { AnyRoute, CompactionOperations } from "../route/client.js";
+export declare const JsonSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+export type JsonSchema = Schema.Schema.Type<typeof JsonSchema>;
+export declare const mergeJsonRecords: (...items: ReadonlyArray<Record<string, unknown> | undefined>) => Record<string, unknown> | undefined;
+export declare const ProviderOptions: Schema.$Record<Schema.String, Schema.Unknown>;
+export type ProviderOptions = Schema.Schema.Type<typeof ProviderOptions>;
+export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOptions | undefined>) => ProviderOptions | undefined;
+declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
+    readonly body: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly query: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+}>, {}>;
+export declare class HttpOptions extends HttpOptions_base {
+}
+export declare namespace HttpOptions {
+    type Input = HttpOptions | ConstructorParameters<typeof HttpOptions>[0];
+    /** Normalize HTTP option input into the canonical `HttpOptions` class. */
+    const make: (input: Input) => HttpOptions;
+}
+export declare const mergeHttpOptions: (...items: ReadonlyArray<HttpOptions | undefined>) => HttpOptions | undefined;
+declare const GenerationOptions_base: Schema.Class<GenerationOptions, Schema.Struct<{
+    readonly maxTokens: Schema.optional<Schema.Number>;
+    readonly temperature: Schema.optional<Schema.Number>;
+    readonly topP: Schema.optional<Schema.Number>;
+    readonly topK: Schema.optional<Schema.Number>;
+    readonly frequencyPenalty: Schema.optional<Schema.Number>;
+    readonly presencePenalty: Schema.optional<Schema.Number>;
+    readonly seed: Schema.optional<Schema.Number>;
+    readonly stop: Schema.optional<Schema.$Array<Schema.String>>;
+}>, {}>;
+export declare class GenerationOptions extends GenerationOptions_base {
+}
+export declare namespace GenerationOptions {
+    type Input = GenerationOptions | ConstructorParameters<typeof GenerationOptions>[0];
+    /** Normalize generation option input into the canonical `GenerationOptions` class. */
+    const make: (input?: Input) => GenerationOptions;
+}
+export type GenerationOptionsFields = {
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    readonly topP?: number;
+    readonly topK?: number;
+    readonly frequencyPenalty?: number;
+    readonly presencePenalty?: number;
+    readonly seed?: number;
+    readonly stop?: ReadonlyArray<string>;
+};
+export type GenerationOptionsInput = GenerationOptions | GenerationOptionsFields;
+export declare const mergeGenerationOptions: (...items: ReadonlyArray<GenerationOptionsInput | undefined>) => GenerationOptions | undefined;
+declare const LanguageModelDefaults_base: Schema.Class<LanguageModelDefaults, Schema.Struct<{
+    readonly generation: Schema.optional<typeof GenerationOptions>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly http: Schema.optional<typeof HttpOptions>;
+}>, {}>;
+export declare class LanguageModelDefaults extends LanguageModelDefaults_base {
+}
+export declare namespace LanguageModelDefaults {
+    type Input = LanguageModelDefaults | {
+        readonly generation?: GenerationOptions.Input;
+        readonly providerOptions?: ProviderOptions;
+        readonly http?: HttpOptions.Input;
+    };
+    /** Normalize selected-model request defaults without applying precedence. */
+    const make: (input: Input) => LanguageModelDefaults;
+}
+export declare const LanguageModelToolSchemaCompatibility: Schema.Literals<readonly ["gemini", "moonshot"]>;
+export type LanguageModelToolSchemaCompatibility = Schema.Schema.Type<typeof LanguageModelToolSchemaCompatibility>;
+export declare const LanguageModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
+export type LanguageModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof LanguageModelMaxTokensFieldCompatibility>;
+declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompatibility, Schema.Struct<{
+    readonly toolSchema: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot"]>>;
+    readonly reasoningField: Schema.optional<Schema.String>;
+    /** Require every assistant message to include its reasoning field, even when empty. */
+    readonly requireReasoning: Schema.optional<Schema.Boolean>;
+    readonly maxTokensField: Schema.optional<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>;
+    readonly requireFinishReason: Schema.optional<Schema.Boolean>;
+    readonly requireAssistantAfterTool: Schema.optional<Schema.Boolean>;
+    readonly supportsStore: Schema.optional<Schema.Boolean>;
+    readonly supportsUsageInStreaming: Schema.optional<Schema.Boolean>;
+    readonly supportsStrictMode: Schema.optional<Schema.Boolean>;
+    readonly zaiToolStream: Schema.optional<Schema.Boolean>;
+    readonly requireSignature: Schema.optional<Schema.Boolean>;
+}>, {}>;
+export declare class LanguageModelCompatibility extends LanguageModelCompatibility_base {
+}
+export declare namespace LanguageModelCompatibility {
+    type Input = LanguageModelCompatibility | ConstructorParameters<typeof LanguageModelCompatibility>[0];
+    /** Normalize model/upstream compatibility metadata without projecting requests. */
+    const make: (input: Input) => LanguageModelCompatibility;
+}
+export declare class LanguageModel<Options extends ProviderOptions = ProviderOptions, Compact extends CompactionOperations | undefined = CompactionOperations | undefined> {
+    protected readonly _ProviderOptions: Options;
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: AnyRoute<Compact>;
+    readonly defaults?: LanguageModelDefaults;
+    readonly compatibility?: LanguageModelCompatibility;
+    constructor(input: LanguageModel.ConstructorInput<Compact>);
+    static make<Options extends ProviderOptions = ProviderOptions, Compact extends CompactionOperations | undefined = CompactionOperations | undefined>(input: LanguageModel.Input<Compact>): LanguageModel<Options, Compact>;
+    static input<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(model: LanguageModel<Options, Compact>): LanguageModel.ConstructorInput<Compact>;
+    static update<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input<Compact>> & {
+        readonly route: AnyRoute<Compact>;
+    }): LanguageModel<Options, Compact>;
+    static update<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(model: LanguageModel<Options, Compact>, patch: Partial<Omit<LanguageModel.Input, "route">> & {
+        readonly route?: undefined;
+    }): LanguageModel<Options, Compact>;
+    static update<Options extends ProviderOptions>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input>): LanguageModel<Options>;
+}
+export declare namespace LanguageModel {
+    type ConstructorInput<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = {
+        readonly id: ModelID;
+        readonly provider: ProviderID;
+        readonly route: AnyRoute<Compact>;
+        readonly defaults?: LanguageModelDefaults;
+        readonly compatibility?: LanguageModelCompatibility;
+    };
+    type Input<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = Omit<ConstructorInput<Compact>, "id" | "provider" | "defaults" | "compatibility"> & {
+        readonly id: string | ModelID;
+        readonly provider: string | ProviderID;
+        readonly defaults?: LanguageModelDefaults.Input;
+        readonly compatibility?: LanguageModelCompatibility.Input;
+    };
+}
+export type LanguageModelInput = LanguageModel.Input;
+export type LanguageModelProviderOptions<SelectedModel> = SelectedModel extends LanguageModel<infer Options> ? Options : never;
+export declare const LanguageModelSchema: Schema.declare<LanguageModel<{
+    readonly [x: string]: unknown;
+}, CompactionOperations | undefined>, LanguageModel<{
+    readonly [x: string]: unknown;
+}, CompactionOperations | undefined>>;
+declare const CacheHint_base: Schema.Class<CacheHint, Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["ephemeral", "persistent"]>;
+    readonly ttlSeconds: Schema.optional<Schema.Number>;
+}>, {}>;
+export declare class CacheHint extends CacheHint_base {
+}
+export declare const CachePolicyObject: 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>;
+}>;
+export type CachePolicyObject = Schema.Schema.Type<typeof CachePolicyObject>;
+export declare const CachePolicy: 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>;
+}>]>;
+export type CachePolicy = Schema.Schema.Type<typeof CachePolicy>;
+export {};

package/dist/schema/options.js

@@ -0,0 +1,187 @@
+import { Schema } from "effect";
+import { ModelID, ProviderID } from "./ids.js";
+import { isRecord } from "../utils/record.js";
+export const JsonSchema = Schema.Record(Schema.String, Schema.Unknown);
+export const mergeJsonRecords = (...items) => {
+    const defined = items.filter((item) => item !== undefined);
+    if (defined.length === 0)
+        return undefined;
+    if (defined.length === 1 && Object.values(defined[0]).every((value) => value !== undefined))
+        return defined[0];
+    const result = {};
+    for (const item of defined) {
+        for (const [key, value] of Object.entries(item)) {
+            if (value === undefined)
+                continue;
+            result[key] = isRecord(result[key]) && isRecord(value) ? mergeJsonRecords(result[key], value) : value;
+        }
+    }
+    return Object.keys(result).length === 0 ? undefined : result;
+};
+const mergeStringRecords = (...items) => {
+    const defined = items.filter((item) => item !== undefined);
+    if (defined.length === 0)
+        return undefined;
+    if (defined.length === 1)
+        return defined[0];
+    const result = Object.fromEntries(defined.flatMap((item) => Object.entries(item).filter((entry) => entry[1] !== undefined)));
+    return Object.keys(result).length === 0 ? undefined : result;
+};
+export const ProviderOptions = Schema.Record(Schema.String, Schema.Unknown);
+export const mergeProviderOptions = (...items) => mergeJsonRecords(...items);
+export class HttpOptions extends Schema.Class("AI.HttpOptions")({
+    body: Schema.optional(JsonSchema),
+    headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    query: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+}) {
+}
+(function (HttpOptions) {
+    /** Normalize HTTP option input into the canonical `HttpOptions` class. */
+    HttpOptions.make = (input) => (input instanceof HttpOptions ? input : new HttpOptions(input));
+})(HttpOptions || (HttpOptions = {}));
+export const mergeHttpOptions = (...items) => {
+    const body = mergeJsonRecords(...items.map((item) => item?.body));
+    const headers = mergeStringRecords(...items.map((item) => item?.headers));
+    const query = mergeStringRecords(...items.map((item) => item?.query));
+    if (!body && !headers && !query)
+        return undefined;
+    return new HttpOptions({ body, headers, query });
+};
+export class GenerationOptions extends Schema.Class("LLM.GenerationOptions")({
+    maxTokens: Schema.optional(Schema.Number),
+    temperature: Schema.optional(Schema.Number),
+    topP: Schema.optional(Schema.Number),
+    topK: Schema.optional(Schema.Number),
+    frequencyPenalty: Schema.optional(Schema.Number),
+    presencePenalty: Schema.optional(Schema.Number),
+    seed: Schema.optional(Schema.Number),
+    stop: Schema.optional(Schema.Array(Schema.String)),
+}) {
+}
+(function (GenerationOptions) {
+    /** Normalize generation option input into the canonical `GenerationOptions` class. */
+    GenerationOptions.make = (input = {}) => (input instanceof GenerationOptions ? input : new GenerationOptions(input));
+})(GenerationOptions || (GenerationOptions = {}));
+const latestGeneration = (items, key) => items.findLast((item) => item?.[key] !== undefined)?.[key];
+export const mergeGenerationOptions = (...items) => {
+    const result = new GenerationOptions({
+        maxTokens: latestGeneration(items, "maxTokens"),
+        temperature: latestGeneration(items, "temperature"),
+        topP: latestGeneration(items, "topP"),
+        topK: latestGeneration(items, "topK"),
+        frequencyPenalty: latestGeneration(items, "frequencyPenalty"),
+        presencePenalty: latestGeneration(items, "presencePenalty"),
+        seed: latestGeneration(items, "seed"),
+        stop: latestGeneration(items, "stop"),
+    });
+    return Object.values(result).some((value) => value !== undefined) ? result : undefined;
+};
+export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaults")({
+    generation: Schema.optional(GenerationOptions),
+    providerOptions: Schema.optional(ProviderOptions),
+    http: Schema.optional(HttpOptions),
+}) {
+}
+(function (LanguageModelDefaults) {
+    /** Normalize selected-model request defaults without applying precedence. */
+    LanguageModelDefaults.make = (input) => {
+        if (input instanceof LanguageModelDefaults)
+            return input;
+        return new LanguageModelDefaults({
+            generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
+            providerOptions: input.providerOptions,
+            http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        });
+    };
+})(LanguageModelDefaults || (LanguageModelDefaults = {}));
+export const LanguageModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"]);
+export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"]);
+export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelCompatibility")({
+    toolSchema: Schema.optional(LanguageModelToolSchemaCompatibility),
+    reasoningField: Schema.optional(Schema.String),
+    /** Require every assistant message to include its reasoning field, even when empty. */
+    requireReasoning: Schema.optional(Schema.Boolean),
+    maxTokensField: Schema.optional(LanguageModelMaxTokensFieldCompatibility),
+    requireFinishReason: Schema.optional(Schema.Boolean),
+    requireAssistantAfterTool: Schema.optional(Schema.Boolean),
+    supportsStore: Schema.optional(Schema.Boolean),
+    supportsUsageInStreaming: Schema.optional(Schema.Boolean),
+    supportsStrictMode: Schema.optional(Schema.Boolean),
+    zaiToolStream: Schema.optional(Schema.Boolean),
+    requireSignature: Schema.optional(Schema.Boolean),
+}) {
+}
+(function (LanguageModelCompatibility) {
+    /** Normalize model/upstream compatibility metadata without projecting requests. */
+    LanguageModelCompatibility.make = (input) => input instanceof LanguageModelCompatibility ? input : new LanguageModelCompatibility(input);
+})(LanguageModelCompatibility || (LanguageModelCompatibility = {}));
+export class LanguageModel {
+    id;
+    provider;
+    route;
+    defaults;
+    compatibility;
+    constructor(input) {
+        this.id = input.id;
+        this.provider = input.provider;
+        this.route = input.route;
+        this.defaults = input.defaults;
+        this.compatibility = input.compatibility;
+    }
+    static make(input) {
+        return new LanguageModel({
+            id: ModelID.make(input.id),
+            provider: ProviderID.make(input.provider),
+            route: input.route,
+            defaults: input.defaults === undefined ? undefined : LanguageModelDefaults.make(input.defaults),
+            compatibility: input.compatibility === undefined ? undefined : LanguageModelCompatibility.make(input.compatibility),
+        });
+    }
+    static input(model) {
+        return {
+            id: model.id,
+            provider: model.provider,
+            route: model.route,
+            defaults: model.defaults,
+            compatibility: model.compatibility,
+        };
+    }
+    static update(model, patch) {
+        if (Object.keys(patch).length === 0)
+            return model;
+        return LanguageModel.make({
+            ...LanguageModel.input(model),
+            ...patch,
+            route: patch.route ?? model.route,
+        });
+    }
+}
+export const LanguageModelSchema = Schema.declare((value) => value instanceof LanguageModel, {
+    expected: "LLM.LanguageModel",
+});
+export class CacheHint extends Schema.Class("LLM.CacheHint")({
+    type: Schema.Literals(["ephemeral", "persistent"]),
+    ttlSeconds: Schema.optional(Schema.Number),
+}) {
+}
+// Auto-placement policy for prompt caching. The protocol-neutral lowering step
+// reads this and injects `CacheHint`s at the configured boundaries; the
+// per-protocol body builders then translate those hints into wire markers as
+// usual. `"auto"` is the default for agent loops — it places
+// breakpoints at the last tool definition, the first and last distinct system
+// parts, and the conversation tail so recent prefixes remain reusable during
+// tool loops.
+//
+// Pass `"none"` to opt out entirely (the legacy behavior). Pass the granular
+// object form to override individual choices.
+export const CachePolicyObject = Schema.Struct({
+    tools: Schema.optional(Schema.Boolean),
+    system: Schema.optional(Schema.Boolean),
+    messages: Schema.optional(Schema.Union([
+        Schema.Literal("latest-user-message"),
+        Schema.Literal("latest-assistant"),
+        Schema.Struct({ tail: Schema.Natural }),
+    ])),
+    ttlSeconds: Schema.optional(Schema.Number),
+});
+export const CachePolicy = Schema.Union([Schema.Literal("auto"), Schema.Literal("none"), CachePolicyObject]);