@kilocode/schema 0.0.0-stage → 0.0.0-v2-9

package/dist/mcp.js

@@ -0,0 +1,120 @@
+export * as Mcp from "./mcp.js";
+import { Schema } from "effect";
+import { optional, PositiveInt } from "./schema.js";
+import { IntegrationID } from "./integration-id.js";
+export class TimeoutConfig extends Schema.Class("Mcp.TimeoutConfig")({
+    startup: PositiveInt.pipe(optional).annotate({
+        description: "Maximum time in milliseconds to establish and initialize the MCP server.",
+    }),
+    catalog: PositiveInt.pipe(optional).annotate({
+        description: "Maximum time in milliseconds to wait for MCP discovery requests such as tools/list and prompts/list.",
+    }),
+    execution: PositiveInt.pipe(optional).annotate({
+        description: "Maximum time in milliseconds to wait for MCP tool and prompt execution.",
+    }),
+}) {
+}
+export const Protocol = Schema.Literals(["legacy", "auto", "2026-07-28"]).annotate({
+    identifier: "Mcp.Protocol",
+    description: 'MCP protocol negotiation. "legacy" (default) opens with the initialize handshake and speaks protocol revisions up to 2025-11-25. "auto" probes for the 2026-07-28 revision and falls back to legacy when the server does not support it. "2026-07-28" requires that revision and fails otherwise.',
+});
+export class LocalConfig extends Schema.Class("Mcp.LocalConfig")({
+    type: Schema.Literal("local"),
+    command: Schema.String.pipe(Schema.Array),
+    cwd: Schema.String.pipe(optional).annotate({
+        description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory.",
+    }),
+    environment: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    codemode: Schema.Boolean.pipe(optional).annotate({
+        description: "Expose this server's tools through Code Mode. Defaults to true.",
+    }),
+    timeout: TimeoutConfig.pipe(optional),
+    protocol: Protocol.pipe(optional),
+}) {
+}
+export class OAuthConfig extends Schema.Class("Mcp.OAuthConfig")({
+    client_id: Schema.String.pipe(optional),
+    client_secret: Schema.String.pipe(optional),
+    scope: Schema.String.pipe(optional),
+    callback_port: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 })).pipe(optional),
+    redirect_uri: Schema.String.pipe(optional),
+    auth_server_metadata_url: Schema.String.pipe(optional).annotate({
+        description: "URL of the OAuth or OpenID Connect authorization server metadata document. Set when the MCP server does not publish protected resource metadata that names its authorization server.",
+    }),
+}) {
+}
+export class RemoteConfig extends Schema.Class("Mcp.RemoteConfig")({
+    type: Schema.Literal("remote"),
+    url: Schema.String,
+    headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    oauth: Schema.Union([OAuthConfig, Schema.Literal(false)]).pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    codemode: Schema.Boolean.pipe(optional).annotate({
+        description: "Expose this server's tools through Code Mode. Defaults to true.",
+    }),
+    timeout: TimeoutConfig.pipe(optional),
+    protocol: Protocol.pipe(optional),
+}) {
+}
+export const ServerConfig = Schema.Union([LocalConfig, RemoteConfig]).pipe(Schema.toTaggedUnion("type"));
+const Connected = Schema.Struct({ status: Schema.Literal("connected") }).annotate({
+    identifier: "Mcp.Status.Connected",
+});
+const Pending = Schema.Struct({ status: Schema.Literal("pending") }).annotate({
+    identifier: "Mcp.Status.Pending",
+});
+const Disabled = Schema.Struct({ status: Schema.Literal("disabled") }).annotate({
+    identifier: "Mcp.Status.Disabled",
+});
+const Failed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.String }).annotate({
+    identifier: "Mcp.Status.Failed",
+});
+const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth"), error: Schema.String }).annotate({
+    identifier: "Mcp.Status.NeedsAuth",
+});
+export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth]).pipe(Schema.toTaggedUnion("status"));
+export const Server = Schema.Struct({
+    name: Schema.String,
+    status: Status,
+    // Set for remote servers registered as OAuth integrations; lets clients act on the right integration
+    // without matching by name, which could collide with provider or plugin integrations.
+    integrationID: optional(IntegrationID),
+}).annotate({ identifier: "Mcp.Server" });
+export const Resource = Schema.Struct({
+    server: Schema.String,
+    name: Schema.String,
+    uri: Schema.String,
+    description: optional(Schema.String),
+    mimeType: optional(Schema.String),
+}).annotate({ identifier: "Mcp.Resource" });
+export const ResourceTemplate = Schema.Struct({
+    server: Schema.String,
+    name: Schema.String,
+    uriTemplate: Schema.String,
+    description: optional(Schema.String),
+    mimeType: optional(Schema.String),
+}).annotate({ identifier: "Mcp.ResourceTemplate" });
+export const ResourceCatalog = Schema.Struct({
+    resources: Schema.Array(Resource),
+    templates: Schema.Array(ResourceTemplate),
+}).annotate({ identifier: "Mcp.ResourceCatalog" });
+export const ResourceContentPart = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("text"),
+        uri: Schema.String,
+        text: Schema.String,
+        mimeType: optional(Schema.String),
+    }),
+    Schema.Struct({
+        type: Schema.Literal("blob"),
+        uri: Schema.String,
+        blob: Schema.String,
+        mimeType: optional(Schema.String),
+    }),
+]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Mcp.ResourceContentPart" }));
+export const ResourceContent = Schema.Struct({
+    server: Schema.String,
+    uri: Schema.String,
+    contents: Schema.Array(ResourceContentPart),
+}).annotate({ identifier: "Mcp.ResourceContent" });

package/dist/model-compatibility.d.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+export type ReasoningField = "reasoning" | "reasoning_content" | "reasoning_text" | (string & {});
+export declare const ReasoningField: Schema.Codec<ReasoningField>;
+export declare const MaxTokensField: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
+export type MaxTokensField = typeof MaxTokensField.Type;
+export declare const CacheFormat: Schema.Literals<readonly ["anthropic", "alibaba"]>;
+export type CacheFormat = typeof CacheFormat.Type;
+export interface Compatibility extends Schema.Schema.Type<typeof Compatibility> {
+}
+export declare const Compatibility: Schema.Struct<{
+    readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+    /** Require every assistant message to include its reasoning field, even when empty. */
+    readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+    readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    /** Request usage in the stream with `stream_options.include_usage`. Defaults to true. */
+    readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+    readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    /** Supports per-message effort updates. Overrides model-ID detection. */
+    readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export interface ProviderCompatibility extends Schema.Schema.Type<typeof ProviderCompatibility> {
+}
+export declare const ProviderCompatibility: Schema.Struct<{
+    readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+    readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+    readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+}>;

package/dist/model-compatibility.js

@@ -0,0 +1,28 @@
+import { Schema, Struct } from "effect";
+import { optional } from "./schema.js";
+export const ReasoningField = Schema.Union([
+    Schema.Literals(["reasoning", "reasoning_content", "reasoning_text"]),
+    Schema.String,
+]).annotate({ identifier: "Model.ReasoningField" });
+export const MaxTokensField = Schema.Literals(["max_completion_tokens", "max_tokens"]).annotate({
+    identifier: "Model.MaxTokensField",
+});
+export const CacheFormat = Schema.Literals(["anthropic", "alibaba"]).annotate({ identifier: "Model.CacheFormat" });
+export const Compatibility = Schema.Struct({
+    reasoningField: ReasoningField.pipe(optional),
+    /** Require every assistant message to include its reasoning field, even when empty. */
+    requireReasoning: Schema.Boolean.pipe(optional),
+    maxTokensField: MaxTokensField.pipe(optional),
+    requireFinishReason: Schema.Boolean.pipe(optional),
+    requireAssistantAfterTool: Schema.Boolean.pipe(optional),
+    supportsPromptCacheKey: Schema.Boolean.pipe(optional),
+    /** Request usage in the stream with `stream_options.include_usage`. Defaults to true. */
+    streamUsage: Schema.Boolean.pipe(optional),
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    cacheFormat: CacheFormat.pipe(optional),
+    /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+    supportsThinkingBlockBinding: Schema.Boolean.pipe(optional),
+    /** Supports per-message effort updates. Overrides model-ID detection. */
+    supportsEffortUpdates: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Model.Compatibility" });
+export const ProviderCompatibility = Schema.Struct(Struct.omit(Compatibility.fields, ["supportsThinkingBlockBinding", "supportsEffortUpdates"])).annotate({ identifier: "Provider.Compatibility" });

package/dist/model.d.ts

@@ -0,0 +1,406 @@
+export * as Model from "./model.js";
+import { Schema } from "effect";
+import { Provider } from "./provider.js";
+import { Compatibility, MaxTokensField, ReasoningField } from "./model-compatibility.js";
+export declare const ID: Schema.brand<Schema.String, "Model.ID">;
+export type ID = typeof ID.Type;
+export declare const Event: {
+    Updated: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"model.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{}>;
+    }> & {
+        type: "model.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"model.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{}>;
+    }> & {
+        type: "model.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};
+export declare const VariantID: Schema.brand<Schema.String, "Model.VariantID">;
+export type VariantID = typeof VariantID.Type;
+export declare const Ref: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Model.ID">;
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+}> & {
+    parse: (input: string) => {
+        readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+        readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+        readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+    };
+};
+export interface Ref extends Schema.Schema.Type<typeof Ref> {
+}
+export { Compatibility, MaxTokensField, ReasoningField };
+export declare const Family: Schema.brand<Schema.String, "Model.Family">;
+export type Family = typeof Family.Type;
+export declare const Settings: Schema.StructWithRest<Schema.Struct<{
+    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"summary">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"native">;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"summary">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"native">;
+    }>]>>, never, never>;
+    readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Any>]>;
+export type Settings = typeof Settings.Type;
+export declare const Overlays: {
+    settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
+    headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+};
+export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {
+}
+export declare const Capabilities: Schema.Struct<{
+    readonly tools: Schema.Boolean;
+    readonly input: Schema.$Array<Schema.String>;
+    readonly output: Schema.$Array<Schema.String>;
+    /** Whether the model accepts a sampling temperature. Unknown when unset. */
+    readonly temperature: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}> & {
+    default: () => {
+        tools: true;
+        input: string[];
+        output: string[];
+    };
+};
+export interface Cost extends Schema.Schema.Type<typeof Cost> {
+}
+export declare const Cost: Schema.Struct<{
+    readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly type: Schema.tag<"context">;
+        readonly size: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly type: Schema.tag<"context">;
+        readonly size: Schema.Int;
+    }>>, never, never>;
+    readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
+    readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
+    readonly cache: Schema.Struct<{
+        readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+    }>;
+}>;
+export interface Variant extends Schema.Schema.Type<typeof Variant> {
+}
+export declare const Variant: Schema.Struct<{
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
+    readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
+    readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Model.ID">;
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly canonical: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    }>, never, never>;
+    readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.Family">>, never, never>;
+    readonly name: Schema.String;
+    readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+        readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+        readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>, never, never>;
+    readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly capabilities: Schema.Struct<{
+        readonly tools: Schema.Boolean;
+        readonly input: Schema.$Array<Schema.String>;
+        readonly output: Schema.$Array<Schema.String>;
+        /** Whether the model accepts a sampling temperature. Unknown when unset. */
+        readonly temperature: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }> & {
+        default: () => {
+            tools: true;
+            input: string[];
+            output: string[];
+        };
+    };
+    readonly variants: Schema.$Array<Schema.Struct<{
+        readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+            readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"summary">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"native">;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"summary">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"native">;
+            }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+            readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"summary">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"native">;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"summary">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"native">;
+            }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
+        readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+        readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+    }>>;
+    readonly time: Schema.Struct<{
+        readonly released: Schema.Finite;
+    }>;
+    readonly cost: Schema.$Array<Schema.Struct<{
+        readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.tag<"context">;
+            readonly size: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.tag<"context">;
+            readonly size: Schema.Int;
+        }>>, never, never>;
+        readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly cache: Schema.Struct<{
+            readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+        }>;
+    }>>;
+    readonly status: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
+    readonly enabled: Schema.Boolean;
+    readonly limit: Schema.Struct<{
+        readonly context: Schema.Int;
+        readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly output: Schema.Int;
+    }>;
+}> & {
+    default: (providerID: Provider.ID, id: ID) => {
+        id: string & import("effect/Brand").Brand<"Model.ID">;
+        modelID: string & import("effect/Brand").Brand<"Model.ID">;
+        providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+        name: string & import("effect/Brand").Brand<"Model.ID">;
+        capabilities: {
+            tools: true;
+            input: string[];
+            output: string[];
+        };
+        variants: never[];
+        time: {
+            released: number;
+        };
+        cost: never[];
+        status: "active";
+        enabled: true;
+        limit: {
+            context: number;
+            output: number;
+        };
+    };
+};