@opencode-ai/ai 0.0.0-beta-17492

package/dist/schema/options.d.ts

@@ -0,0 +1,159 @@
+import { Schema } from "effect";
+import { ModelID, ProviderID } from "./ids.js";
+import type { AnyRoute } from "../route/client.js";
+export declare const mergeJsonRecords: (...items: ReadonlyArray<Record<string, unknown> | undefined>) => Record<string, unknown> | undefined;
+export declare const ProviderOptions: Schema.$Record<Schema.String, 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 LanguageModelLimits_base: Schema.Class<LanguageModelLimits, Schema.Struct<{
+    readonly context: Schema.optional<Schema.Number>;
+    readonly input: Schema.optional<Schema.Number>;
+    readonly output: Schema.optional<Schema.Number>;
+}>, {}>;
+export declare class LanguageModelLimits extends LanguageModelLimits_base {
+}
+export declare namespace LanguageModelLimits {
+    type Input = LanguageModelLimits | ConstructorParameters<typeof LanguageModelLimits>[0];
+    /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
+    const make: (input: Input | undefined) => LanguageModelLimits;
+}
+declare const LanguageModelDefaults_base: Schema.Class<LanguageModelDefaults, Schema.Struct<{
+    readonly limits: Schema.optional<typeof LanguageModelLimits>;
+    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>;
+}>, {}>;
+export declare class LanguageModelDefaults extends LanguageModelDefaults_base {
+}
+export declare namespace LanguageModelDefaults {
+    type Input = LanguageModelDefaults | {
+        readonly limits?: LanguageModelLimits.Input;
+        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>;
+    readonly maxTokensField: Schema.optional<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>;
+    readonly requireFinishReason: 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> {
+    protected readonly _ProviderOptions: Options;
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: AnyRoute;
+    readonly defaults?: LanguageModelDefaults;
+    readonly compatibility?: LanguageModelCompatibility;
+    constructor(input: LanguageModel.ConstructorInput);
+    static make<Options extends ProviderOptions = ProviderOptions>(input: LanguageModel.Input): LanguageModel<Options>;
+    static input<Options extends ProviderOptions>(model: LanguageModel<Options>): LanguageModel.ConstructorInput;
+    static update<Options extends ProviderOptions>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input>): LanguageModel<Options>;
+}
+export declare namespace LanguageModel {
+    type ConstructorInput = {
+        readonly id: ModelID;
+        readonly provider: ProviderID;
+        readonly route: AnyRoute;
+        readonly defaults?: LanguageModelDefaults;
+        readonly compatibility?: LanguageModelCompatibility;
+    };
+    type Input = Omit<ConstructorInput, "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]: {
+        readonly [x: string]: unknown;
+    };
+}>, LanguageModel<{
+    readonly [x: string]: {
+        readonly [x: string]: unknown;
+    };
+}>>;
+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.Number;
+    }>]>>;
+    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.Number;
+    }>]>>;
+    readonly ttlSeconds: Schema.optional<Schema.Number>;
+}>]>;
+export type CachePolicy = Schema.Schema.Type<typeof CachePolicy>;
+export {};

package/dist/schema/options.js

@@ -0,0 +1,202 @@
+import { Schema } from "effect";
+import { JsonSchema, ModelID, ProviderID } from "./ids.js";
+import { isRecord } from "../utils/record.js";
+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.Record(Schema.String, Schema.Unknown));
+export const mergeProviderOptions = (...items) => {
+    const result = {};
+    for (const item of items) {
+        if (!item)
+            continue;
+        for (const [provider, options] of Object.entries(item)) {
+            const merged = mergeJsonRecords(result[provider], options);
+            if (merged)
+                result[provider] = merged;
+        }
+    }
+    return Object.keys(result).length === 0 ? undefined : result;
+};
+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 LanguageModelLimits extends Schema.Class("LLM.LanguageModelLimits")({
+    context: Schema.optional(Schema.Number),
+    input: Schema.optional(Schema.Number),
+    output: Schema.optional(Schema.Number),
+}) {
+}
+(function (LanguageModelLimits) {
+    /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
+    LanguageModelLimits.make = (input) => input instanceof LanguageModelLimits ? input : new LanguageModelLimits(input ?? {});
+})(LanguageModelLimits || (LanguageModelLimits = {}));
+export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaults")({
+    limits: Schema.optional(LanguageModelLimits),
+    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({
+            limits: input.limits === undefined ? undefined : LanguageModelLimits.make(input.limits),
+            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),
+    maxTokensField: Schema.optional(LanguageModelMaxTokensFieldCompatibility),
+    requireFinishReason: 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,
+        });
+    }
+}
+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 recommended default for agent loops — it places
+// breakpoints at the last tool definition, the first and last distinct system
+// parts, and the conversation tail. The rolling message breakpoint keeps a
+// prior cache entry within Anthropic/Bedrock's 20-block lookback during long
+// 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.Number }),
+    ])),
+    ttlSeconds: Schema.optional(Schema.Number),
+});
+export const CachePolicy = Schema.Union([Schema.Literal("auto"), Schema.Literal("none"), CachePolicyObject]);