@opencode-ai/schema 0.0.0-dev-17471

package/dist/config/formatter.d.ts

@@ -0,0 +1,11 @@
+export * as ConfigFormatter from "./formatter.js";
+import { Schema } from "effect";
+declare const Entry_base: Schema.Class<Entry, Schema.Struct<{
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly command: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly environment: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly extensions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+}>, {}>;
+export declare class Entry extends Entry_base {
+}
+export declare const Info: Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof Entry>]>;

package/dist/config/formatter.js

@@ -0,0 +1,11 @@
+export * as ConfigFormatter from "./formatter.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Entry extends Schema.Class("Config.Formatter.Entry")({
+    disabled: Schema.Boolean.pipe(optional),
+    command: Schema.String.pipe(Schema.Array, optional),
+    environment: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    extensions: Schema.String.pipe(Schema.Array, optional),
+}) {
+}
+export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]);

package/dist/config/lsp.d.ts

@@ -0,0 +1,20 @@
+export * as ConfigLSP from "./lsp.js";
+import { Schema } from "effect";
+export declare const Disabled: Schema.Struct<{
+    readonly disabled: Schema.Literal<true>;
+}>;
+declare const Server_base: Schema.Class<Server, Schema.Struct<{
+    readonly command: Schema.$Array<Schema.String>;
+    readonly extensions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly env: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly initialization: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>, {}>;
+export declare class Server extends Server_base {
+}
+export declare const Entry: Schema.Union<readonly [Schema.Struct<{
+    readonly disabled: Schema.Literal<true>;
+}>, typeof Server]>;
+export declare const Info: Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly disabled: Schema.Literal<true>;
+}>, typeof Server]>>]>;

package/dist/config/lsp.js

@@ -0,0 +1,16 @@
+export * as ConfigLSP from "./lsp.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export const Disabled = Schema.Struct({
+    disabled: Schema.Literal(true),
+});
+export class Server extends Schema.Class("Config.LSP.Server")({
+    command: Schema.String.pipe(Schema.Array),
+    extensions: Schema.String.pipe(Schema.Array, optional),
+    disabled: Schema.Boolean.pipe(optional),
+    env: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    initialization: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+}) {
+}
+export const Entry = Schema.Union([Disabled, Server]);
+export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]);

package/dist/config/mcp.d.ts

@@ -0,0 +1,18 @@
+export * as ConfigMCP from "./mcp.js";
+import { Schema } from "effect";
+import { Mcp } from "../mcp.js";
+export declare const Timeout: typeof Mcp.TimeoutConfig;
+export type Timeout = Mcp.TimeoutConfig;
+export declare const Local: typeof Mcp.LocalConfig;
+export type Local = Mcp.LocalConfig;
+export declare const OAuth: typeof Mcp.OAuthConfig;
+export type OAuth = Mcp.OAuthConfig;
+export declare const Remote: typeof Mcp.RemoteConfig;
+export type Remote = Mcp.RemoteConfig;
+export declare const Server: Schema.toTaggedUnion<"type", readonly [typeof Mcp.LocalConfig, typeof Mcp.RemoteConfig]>;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<typeof Mcp.TimeoutConfig>>, Schema.optionalKey<typeof Mcp.TimeoutConfig>, never, never>;
+    readonly servers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.toTaggedUnion<"type", readonly [typeof Mcp.LocalConfig, typeof Mcp.RemoteConfig]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.toTaggedUnion<"type", readonly [typeof Mcp.LocalConfig, typeof Mcp.RemoteConfig]>>>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/mcp.js

@@ -0,0 +1,14 @@
+export * as ConfigMCP from "./mcp.js";
+import { Schema } from "effect";
+import { Mcp } from "../mcp.js";
+import { optional } from "../schema.js";
+export const Timeout = Mcp.TimeoutConfig;
+export const Local = Mcp.LocalConfig;
+export const OAuth = Mcp.OAuthConfig;
+export const Remote = Mcp.RemoteConfig;
+export const Server = Mcp.ServerConfig;
+export class Info extends Schema.Class("Config.MCP")({
+    timeout: Timeout.pipe(optional),
+    servers: Schema.Record(Schema.String, Server).pipe(optional),
+}) {
+}

package/dist/config/media.d.ts

@@ -0,0 +1,15 @@
+export * as ConfigMedia from "./media.js";
+import { Schema } from "effect";
+declare const Image_base: Schema.Class<Image, Schema.Struct<{
+    readonly auto_resize: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly max_width: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly max_height: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly max_base64_bytes: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class Image extends Image_base {
+}
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly image: Schema.decodeTo<Schema.optional<Schema.toType<typeof Image>>, Schema.optionalKey<typeof Image>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/media.js

@@ -0,0 +1,14 @@
+export * as ConfigMedia from "./media.js";
+import { Schema } from "effect";
+import { optional, PositiveInt } from "../schema.js";
+export class Image extends Schema.Class("Config.Media.Image")({
+    auto_resize: Schema.Boolean.pipe(optional),
+    max_width: PositiveInt.pipe(optional),
+    max_height: PositiveInt.pipe(optional),
+    max_base64_bytes: PositiveInt.pipe(optional),
+}) {
+}
+export class Info extends Schema.Class("Config.Media")({
+    image: Image.pipe(optional),
+}) {
+}

package/dist/config/model.d.ts

@@ -0,0 +1,18 @@
+export * as ConfigModel from "./model.js";
+import { Schema } from "effect";
+declare const Explicit: Schema.Struct<{
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+    readonly model: Schema.brand<Schema.String, "Model.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>;
+}>;
+export interface Selection extends Schema.Schema.Type<typeof Explicit> {
+}
+export declare const Selection: Schema.decodeTo<Schema.Struct<{
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+    readonly model: Schema.brand<Schema.String, "Model.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>;
+}>, Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+    readonly model: Schema.brand<Schema.String, "Model.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>;
+}>]>, never, never>;

package/dist/config/model.js

@@ -0,0 +1,28 @@
+export * as ConfigModel from "./model.js";
+import { Schema, SchemaGetter } from "effect";
+import { Model } from "../model.js";
+import { Provider } from "../provider.js";
+import { optional } from "../schema.js";
+const ProviderID = Provider.ID.check(Schema.isPattern(/^[^/#]+$/));
+const ModelID = Model.ID.check(Schema.isPattern(/^[^#]+$/));
+const VariantID = Model.VariantID.check(Schema.isPattern(/^[^#]+$/));
+const Explicit = Schema.Struct({
+    providerID: ProviderID,
+    model: ModelID,
+    variant: VariantID.pipe(optional),
+});
+const Short = Schema.String.check(Schema.isPattern(/^[^/#]+\/[^#]+(?:#[^#]+)?$/));
+export const Selection = Schema.Union([Short, Explicit])
+    .pipe(Schema.decodeTo(Explicit, {
+    decode: SchemaGetter.transform((input) => (typeof input === "string" ? parse(input) : input)),
+    encode: SchemaGetter.passthrough({ strict: false }),
+}))
+    .annotate({ identifier: "Config.ModelSelection" });
+function parse(input) {
+    const ref = Model.Ref.parse(input);
+    return {
+        providerID: ref.providerID,
+        model: ref.id,
+        ...(ref.variant ? { variant: ref.variant } : {}),
+    };
+}

package/dist/config/plugin.d.ts

@@ -0,0 +1,11 @@
+export * as ConfigPlugin from "./plugin.js";
+import { Schema } from "effect";
+declare const Entry_base: Schema.Class<Entry, Schema.Struct<{
+    readonly package: Schema.String;
+    readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>, {}>;
+export declare class Entry extends Entry_base {
+}
+export declare const Plugin: Schema.Union<readonly [Schema.String, typeof Entry]>;
+export type Plugin = typeof Plugin.Type;
+export declare const Plugins: Schema.$Array<Schema.Union<readonly [Schema.String, typeof Entry]>>;

package/dist/config/plugin.js

@@ -0,0 +1,10 @@
+export * as ConfigPlugin from "./plugin.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Entry extends Schema.Class("Config.Plugin.Entry")({
+    package: Schema.String,
+    options: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+}) {
+}
+export const Plugin = Schema.Union([Schema.String, Entry]);
+export const Plugins = Plugin.pipe(Schema.Array);

package/dist/config/policy.d.ts

@@ -0,0 +1,10 @@
+export * as ConfigPolicy from "./policy.js";
+import { Schema } from "effect";
+export declare const Effect: Schema.Literals<readonly ["allow", "deny"]>;
+export type Effect = typeof Effect.Type;
+export declare const Info: Schema.Struct<{
+    readonly action: Schema.Literal<"provider.use">;
+    readonly resource: Schema.String;
+    readonly effect: Schema.Literals<readonly ["allow", "deny"]>;
+}>;
+export type Info = typeof Info.Type;

package/dist/config/policy.js

@@ -0,0 +1,8 @@
+export * as ConfigPolicy from "./policy.js";
+import { Schema } from "effect";
+export const Effect = Schema.Literals(["allow", "deny"]);
+export const Info = Schema.Struct({
+    action: Schema.Literal("provider.use"),
+    resource: Schema.String,
+    effect: Effect,
+});

package/dist/config/provider.d.ts

@@ -0,0 +1,106 @@
+export * as ConfigProvider from "./provider.js";
+import { Schema } from "effect";
+export declare const Overlays: {
+    settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+};
+declare const Request_base: Schema.Class<Request, Schema.Struct<{
+    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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+}>, {}>;
+export declare class Request extends Request_base {
+}
+declare const Cache_base: Schema.Class<Cache, Schema.Struct<{
+    readonly read: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    }>, never, never>;
+    readonly write: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    }>, never, never>;
+}>, {}>;
+declare class Cache extends Cache_base {
+}
+declare const Cost_base: Schema.Class<Cost, Schema.Struct<{
+    readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly type: Schema.Literal<"context">;
+        readonly size: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly type: Schema.Literal<"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.decodeTo<Schema.optional<Schema.toType<typeof Cache>>, Schema.optionalKey<typeof Cache>, never, never>;
+}>, {}>;
+declare class Cost extends Cost_base {
+}
+declare const Limit_base: Schema.Class<Limit, Schema.Struct<{
+    readonly context: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly output: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+declare class Limit extends Limit_base {
+}
+declare const Model_base: Schema.Class<Model, Schema.Struct<{
+    readonly capabilities: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly tools: Schema.Boolean;
+        readonly input: Schema.$Array<Schema.String>;
+        readonly output: Schema.$Array<Schema.String>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly tools: Schema.Boolean;
+        readonly input: Schema.$Array<Schema.String>;
+        readonly output: Schema.$Array<Schema.String>;
+    }>>, never, never>;
+    readonly variants: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+    }>>>, never, never>;
+    readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [typeof Cost, Schema.$Array<typeof Cost>]>>>, Schema.optionalKey<Schema.Union<readonly [typeof Cost, Schema.$Array<typeof Cost>]>>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<typeof Limit>>, Schema.optionalKey<typeof Limit>, never, never>;
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+    readonly modelID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>, 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>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>, 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>;
+    }>>, never, never>;
+    readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>, {}>;
+declare class Model extends Model_base {
+}
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly models: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof Model>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof Model>>, never, never>;
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly env: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/provider.js

@@ -0,0 +1,62 @@
+export * as ConfigProvider from "./provider.js";
+import { Schema } from "effect";
+import { Money } from "../money.js";
+import { Capabilities, Compatibility, Family, ID, VariantID } from "../model.js";
+import { optional } from "../schema.js";
+const JsonRecord = Schema.Record(Schema.String, Schema.Json);
+export const Overlays = {
+    settings: JsonRecord.pipe(optional),
+    headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    body: JsonRecord.pipe(optional),
+};
+export class Request extends Schema.Class("Config.Provider.Request")({
+    headers: Overlays.headers,
+    body: Overlays.body,
+}) {
+}
+class Cache extends Schema.Class("Config.Model.Cost.Cache")({
+    read: Money.USDPerMillionTokens.pipe(optional),
+    write: Money.USDPerMillionTokens.pipe(optional),
+}) {
+}
+class Cost extends Schema.Class("Config.Model.Cost")({
+    tier: Schema.Struct({
+        type: Schema.Literal("context"),
+        size: Schema.Int,
+    }).pipe(optional),
+    input: Money.USDPerMillionTokens,
+    output: Money.USDPerMillionTokens,
+    cache: Cache.pipe(optional),
+}) {
+}
+class Limit extends Schema.Class("Config.Model.Limit")({
+    context: Schema.Int.pipe(optional),
+    input: Schema.Int.pipe(optional),
+    output: Schema.Int.pipe(optional),
+}) {
+}
+class Model extends Schema.Class("Config.Model")({
+    modelID: ID.pipe(optional),
+    family: Family.pipe(optional),
+    name: Schema.String.pipe(optional),
+    compatibility: Compatibility.pipe(optional),
+    package: Schema.String.pipe(optional),
+    ...Overlays,
+    capabilities: Capabilities.pipe(optional),
+    variants: Schema.Struct({
+        id: VariantID,
+        ...Overlays,
+    }).pipe(Schema.Array, optional),
+    cost: Schema.Union([Cost, Cost.pipe(Schema.Array)]).pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    limit: Limit.pipe(optional),
+}) {
+}
+export class Info extends Schema.Class("Config.Provider")({
+    name: Schema.String.pipe(optional),
+    env: Schema.String.pipe(Schema.Array, optional),
+    package: Schema.String.pipe(optional),
+    ...Overlays,
+    models: Schema.Record(Schema.String, Model).pipe(optional),
+}) {
+}

package/dist/config/reference.d.ts

@@ -0,0 +1,21 @@
+export * as ConfigReference from "./reference.js";
+import { Schema } from "effect";
+declare const Git_base: Schema.Class<Git, Schema.Struct<{
+    readonly repository: Schema.String;
+    readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, {}>;
+export declare class Git extends Git_base {
+}
+declare const Local_base: Schema.Class<Local, Schema.Struct<{
+    readonly path: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, {}>;
+export declare class Local extends Local_base {
+}
+export declare const Entry: Schema.Union<readonly [Schema.String, typeof Git, typeof Local]>;
+export type Entry = typeof Entry.Type;
+export declare const Info: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof Git, typeof Local]>>;
+export type Info = typeof Info.Type;

package/dist/config/reference.js

@@ -0,0 +1,18 @@
+export * as ConfigReference from "./reference.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Git extends Schema.Class("Config.Reference.Git")({
+    repository: Schema.String,
+    branch: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+}) {
+}
+export class Local extends Schema.Class("Config.Reference.Local")({
+    path: Schema.String,
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+}) {
+}
+export const Entry = Schema.Union([Schema.String, Git, Local]);
+export const Info = Schema.Record(Schema.String, Entry);

package/dist/config/tool-output.d.ts

@@ -0,0 +1,8 @@
+export * as ConfigToolOutput from "./tool-output.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly max_lines: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly max_bytes: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/tool-output.js

@@ -0,0 +1,8 @@
+export * as ConfigToolOutput from "./tool-output.js";
+import { Schema } from "effect";
+import { optional, PositiveInt } from "../schema.js";
+export class Info extends Schema.Class("Config.ToolOutput")({
+    max_lines: PositiveInt.pipe(optional),
+    max_bytes: PositiveInt.pipe(optional),
+}) {
+}

package/dist/config/warming.d.ts

@@ -0,0 +1,10 @@
+export * as ConfigWarming from "./warming.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly interval: Schema.decodeTo<Schema.optional<Schema.toType<Schema.DurationFromString>>, Schema.optionalKey<Schema.DurationFromString>, never, never>;
+    readonly duration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.DurationFromString>>, Schema.optionalKey<Schema.DurationFromString>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export declare const Warming: Schema.Union<readonly [Schema.Boolean, typeof Info]>;

package/dist/config/warming.js

@@ -0,0 +1,16 @@
+export * as ConfigWarming from "./warming.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Info extends Schema.Class("Config.Warming")({
+    prompt: Schema.String.pipe(optional).annotate({
+        description: "Prompt sent for keep-alive requests",
+    }),
+    interval: Schema.DurationFromString.pipe(optional).annotate({
+        description: 'Idle time between keep-alive requests (default: "4 minutes")',
+    }),
+    duration: Schema.DurationFromString.pipe(optional).annotate({
+        description: 'Time after the last active request to keep a session warm (default: "30 minutes")',
+    }),
+}) {
+}
+export const Warming = Schema.Union([Schema.Boolean, Info]);

package/dist/config/watcher.d.ts

@@ -0,0 +1,7 @@
+export * as ConfigWatcher from "./watcher.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly ignore: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/watcher.js

@@ -0,0 +1,7 @@
+export * as ConfigWatcher from "./watcher.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Info extends Schema.Class("Config.Watcher")({
+    ignore: Schema.String.pipe(Schema.Array, optional),
+}) {
+}

package/dist/config/websearch.d.ts

@@ -0,0 +1,9 @@
+export * as ConfigWebSearch from "./websearch.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly provider: Schema.Union<readonly [Schema.Literal<"random">, Schema.brand<Schema.String, "WebSearch.ID">]>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export declare const Selection: Schema.Union<readonly [Schema.Literal<false>, typeof Info]>;
+export type Selection = typeof Selection.Type;

package/dist/config/websearch.js

@@ -0,0 +1,8 @@
+export * as ConfigWebSearch from "./websearch.js";
+import { Schema } from "effect";
+import { WebSearch } from "../websearch.js";
+export class Info extends Schema.Class("ConfigWebSearch.Info")({
+    provider: Schema.Union([Schema.Literal("random"), WebSearch.ID]),
+}) {
+}
+export const Selection = Schema.Union([Schema.Literal(false), Info]);