@opencode-ai/schema - npm Package Compare versions

Comparing version 0.0.0-next-16916 to 0.0.0-next-16926

dist/config/agent.d.ts

+export * as ConfigAgent from "./agent.js";
+import { Schema } from "effect";
+import { ConfigProvider } from "./provider.js";
+export declare const Color: Schema.String;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<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>>>, Schema.optionalKey<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>>, never, never>;
+    readonly request: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigProvider.Request>>, Schema.optionalKey<typeof ConfigProvider.Request>, never, never>;
+    readonly system: 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 mode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["subagent", "primary", "all"]>>>, Schema.optionalKey<Schema.Literals<readonly ["subagent", "primary", "all"]>>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly steps: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

dist/config/agent.js

+export * as ConfigAgent from "./agent.js";
+import { Schema } from "effect";
+import { Permission } from "../permission.js";
+import { optional, PositiveInt } from "../schema.js";
+import { ConfigModel } from "./model.js";
+import { ConfigProvider } from "./provider.js";
+export const Color = Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/));
+export class Info extends Schema.Class("Config.Agent")({
+    model: ConfigModel.Selection.pipe(optional),
+    request: ConfigProvider.Request.pipe(optional),
+    system: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    mode: Schema.Literals(["subagent", "primary", "all"]).pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+    color: Color.pipe(optional),
+    steps: PositiveInt.pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    permissions: Permission.Ruleset.pipe(optional),
+}) {
+}

dist/config/command.d.ts

+export * as ConfigCommand from "./command.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly template: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<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>>>, Schema.optionalKey<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>>, never, never>;
+    readonly subtask: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

dist/config/command.js

+export * as ConfigCommand from "./command.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+import { ConfigModel } from "./model.js";
+export class Info extends Schema.Class("Config.Command")({
+    template: Schema.String,
+    description: Schema.String.pipe(optional),
+    agent: Schema.String.pipe(optional),
+    model: ConfigModel.Selection.pipe(optional),
+    subtask: Schema.Boolean.pipe(optional),
+}) {
+}

dist/config/compaction.d.ts

+export * as ConfigCompaction from "./compaction.js";
+import { Schema } from "effect";
+declare const Keep_base: Schema.Class<Keep, Schema.Struct<{
+    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class Keep extends Keep_base {
+}
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly auto: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly keep: Schema.decodeTo<Schema.optional<Schema.toType<typeof Keep>>, Schema.optionalKey<typeof Keep>, never, never>;
+    readonly buffer: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

dist/config/compaction.js

+export * as ConfigCompaction from "./compaction.js";
+import { Schema } from "effect";
+import { NonNegativeInt, optional } from "../schema.js";
+export class Keep extends Schema.Class("Config.Compaction.Keep")({
+    tokens: NonNegativeInt.pipe(optional),
+}) {
+}
+export class Info extends Schema.Class("Config.Compaction")({
+    auto: Schema.Boolean.pipe(optional),
+    keep: Keep.pipe(optional),
+    buffer: NonNegativeInt.pipe(optional),
+}) {
+}

dist/config/experimental.d.ts

+export * as ConfigExperimental from "./experimental.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly subagent_depth: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly policies: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.Literal<"provider.use">;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.Literal<"provider.use">;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny"]>;
+    }>>>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

dist/config/experimental.js

+export * as ConfigExperimental from "./experimental.js";
+import { Schema } from "effect";
+import { NonNegativeInt, optional } from "../schema.js";
+import { ConfigPolicy } from "./policy.js";
+export class Info extends Schema.Class("ConfigExperimental.Info")({
+    subagent_depth: NonNegativeInt.pipe(optional).annotate({
+        description: "Maximum subagent nesting depth. Defaults to 1.",
+    }),
+    policies: ConfigPolicy.Info.pipe(Schema.Array, optional).annotate({
+        description: "Ordered policies controlling access to configured resources",
+    }),
+}) {
+}

dist/config/formatter.d.ts

+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>]>;

dist/config/formatter.js

+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)]);

dist/config/lsp.d.ts

+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]>>]>;

dist/config/lsp.js

+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)]);

dist/config/mcp.d.ts

+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 {
+}

dist/config/mcp.js

+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),
+}) {
+}

dist/config/media.d.ts

+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 {
+}

dist/config/media.js

+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),
+}) {
+}

dist/config/model.d.ts

+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>;

dist/config/model.js

+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 } : {}),
+    };
+}

dist/config/plugin.d.ts

+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]>>;

dist/config/plugin.js

+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);

dist/config/policy.d.ts

+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;

dist/config/policy.js

+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,
+});

dist/config/provider.d.ts

+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>;
+    }>>>, 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>;
+    }>>, 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 {
+}

dist/config/provider.js

+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),
+}) {
+}

dist/config/reference.d.ts

+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;

dist/config/reference.js

+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);

dist/config/tool-output.d.ts

+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 {
+}

dist/config/tool-output.js

+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),
+}) {
+}

dist/config/warming.d.ts

+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]>;

dist/config/warming.js

+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]);

dist/config/watcher.d.ts

+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 {
+}

dist/config/watcher.js

+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),
+}) {
+}

dist/config/websearch.d.ts

+export * as ConfigWebSearch from "./websearch.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly provider: Schema.brand<Schema.String, "WebSearch.ID">;
+}>, {}>;
+export declare class Info extends Info_base {
+}

dist/config/websearch.js

+export * as ConfigWebSearch from "./websearch.js";
+import { Schema } from "effect";
+import { WebSearch } from "../websearch.js";
+export class Info extends Schema.Class("ConfigWebSearch.Info")({
+    provider: WebSearch.ID,
+}) {
+}

dist/config.d.ts

 export * as Config from "./config.js";
+import { Schema } from "effect";
+import { ConfigAgent } from "./config/agent.js";
+import { ConfigMedia } from "./config/media.js";
+import { ConfigCompaction } from "./config/compaction.js";
+import { ConfigCommand } from "./config/command.js";
+import { ConfigExperimental } from "./config/experimental.js";
+import { ConfigFormatter } from "./config/formatter.js";
+import { ConfigLSP } from "./config/lsp.js";
+import { ConfigMCP } from "./config/mcp.js";
+import { ConfigPlugin } from "./config/plugin.js";
+import { ConfigProvider } from "./config/provider.js";
+import { ConfigReference } from "./config/reference.js";
+import { ConfigWebSearch } from "./config/websearch.js";
+import { ConfigToolOutput } from "./config/tool-output.js";
+import { ConfigWatcher } from "./config/watcher.js";
+import { ConfigWarming } from "./config/warming.js";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly $schema: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly shell: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<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>>>, Schema.optionalKey<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>>, never, never>;
+    readonly default_agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly autoupdate: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.Literal<"notify">]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Literal<"notify">]>>, never, never>;
+    readonly share: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["manual", "auto", "disabled"]>>>, Schema.optionalKey<Schema.Literals<readonly ["manual", "auto", "disabled"]>>, never, never>;
+    readonly enterprise: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly username: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>, never, never>;
+    readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigAgent.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigAgent.Info>>, never, never>;
+    readonly snapshots: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly watcher: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigWatcher.Info>>, Schema.optionalKey<typeof ConfigWatcher.Info>, never, never>;
+    readonly formatter: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof ConfigFormatter.Entry>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof ConfigFormatter.Entry>]>>, never, never>;
+    readonly lsp: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly disabled: Schema.Literal<true>;
+    }>, typeof ConfigLSP.Server]>>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly disabled: Schema.Literal<true>;
+    }>, typeof ConfigLSP.Server]>>]>>, never, never>;
+    readonly media: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigMedia.Info>>, Schema.optionalKey<typeof ConfigMedia.Info>, never, never>;
+    readonly tool_output: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigToolOutput.Info>>, Schema.optionalKey<typeof ConfigToolOutput.Info>, never, never>;
+    readonly mcp: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigMCP.Info>>, Schema.optionalKey<typeof ConfigMCP.Info>, never, never>;
+    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigCompaction.Info>>, Schema.optionalKey<typeof ConfigCompaction.Info>, never, never>;
+    readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigCommand.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigCommand.Info>>, never, never>;
+    readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly references: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof ConfigReference.Git, typeof ConfigReference.Local]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof ConfigReference.Git, typeof ConfigReference.Local]>>>, never, never>;
+    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigWebSearch.Info>>, Schema.optionalKey<typeof ConfigWebSearch.Info>, never, never>;
+    readonly plugins: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.String, typeof ConfigPlugin.Entry]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.String, typeof ConfigPlugin.Entry]>>>, never, never>;
+    readonly warming: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, typeof ConfigWarming.Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, typeof ConfigWarming.Info]>>, never, never>;
+    readonly providers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigProvider.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigProvider.Info>>, never, never>;
+    readonly experimental: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigExperimental.Info>>, Schema.optionalKey<typeof ConfigExperimental.Info>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+declare const Document_base: Schema.Class<Document, Schema.Struct<{
+    readonly type: Schema.Literal<"document">;
+    readonly path: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly info: typeof Info;
+}>, {}>;
+export declare class Document extends Document_base {
+}
+declare const Directory_base: Schema.Class<Directory, Schema.Struct<{
+    readonly type: Schema.Literal<"directory">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class Directory extends Directory_base {
+}
+declare const File_base: Schema.Class<File, Schema.Struct<{
+    readonly type: Schema.Literal<"file">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class File extends File_base {
+}
+declare const AgentsDirectory_base: Schema.Class<AgentsDirectory, Schema.Struct<{
+    readonly type: Schema.Literal<"agents">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class AgentsDirectory extends AgentsDirectory_base {
+}
+declare const ClaudeDirectory_base: Schema.Class<ClaudeDirectory, Schema.Struct<{
+    readonly type: Schema.Literal<"claude">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class ClaudeDirectory extends ClaudeDirectory_base {
+}
+export declare const Entry: Schema.Union<readonly [typeof Document, typeof Directory, typeof File, typeof AgentsDirectory, typeof ClaudeDirectory]>;
+export type Entry = typeof Entry.Type;
 export declare const Event: {
-    Updated: import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+    Updated: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Event.ID">;
         };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"config.updated">;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        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<"config.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">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "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>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+        }>>>, 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">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
@@ -29,3 +141,3 @@ create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
         }>>, never, never>;
-        readonly data: import("effect/Schema").Struct<{}>;
+        readonly data: Schema.Struct<{}>;
     }> & {
@@ -35,26 +147,26 @@ type: "config.updated";
         durable: undefined;
-        data: import("effect/Schema").Struct<{}>;
+        data: Schema.Struct<{}>;
     };
-    Definitions: readonly [import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Event.ID">;
         };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"config.updated">;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        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<"config.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">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "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>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+        }>>>, 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">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
@@ -64,3 +176,3 @@ create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
         }>>, never, never>;
-        readonly data: import("effect/Schema").Struct<{}>;
+        readonly data: Schema.Struct<{}>;
     }> & {
@@ -70,4 +182,4 @@ type: "config.updated";
         durable: undefined;
-        data: import("effect/Schema").Struct<{}>;
+        data: Schema.Struct<{}>;
     }];
 };

dist/config.js

 export * as Config from "./config.js";
+import { Schema } from "effect";
 import { ephemeral, inventory } from "./event.js";
+import { Permission } from "./permission.js";
+import { AbsolutePath, optional } from "./schema.js";
+import { ConfigAgent } from "./config/agent.js";
+import { ConfigMedia } from "./config/media.js";
+import { ConfigCompaction } from "./config/compaction.js";
+import { ConfigCommand } from "./config/command.js";
+import { ConfigExperimental } from "./config/experimental.js";
+import { ConfigFormatter } from "./config/formatter.js";
+import { ConfigLSP } from "./config/lsp.js";
+import { ConfigMCP } from "./config/mcp.js";
+import { ConfigModel } from "./config/model.js";
+import { ConfigPlugin } from "./config/plugin.js";
+import { ConfigProvider } from "./config/provider.js";
+import { ConfigReference } from "./config/reference.js";
+import { ConfigWebSearch } from "./config/websearch.js";
+import { ConfigToolOutput } from "./config/tool-output.js";
+import { ConfigWatcher } from "./config/watcher.js";
+import { ConfigWarming } from "./config/warming.js";
+export class Info extends Schema.Class("Config.Info")({
+    $schema: optional(Schema.String).annotate({
+        description: "JSON schema reference for configuration validation",
+    }),
+    shell: Schema.String.pipe(optional).annotate({
+        description: "Default shell to use for terminal and shell tool execution",
+    }),
+    model: ConfigModel.Selection.pipe(optional).annotate({
+        description: "Default model to use when no session or agent model is selected",
+    }),
+    default_agent: Schema.String.pipe(optional).annotate({
+        description: "Default primary agent to use when no session agent is selected",
+    }),
+    autoupdate: Schema.Union([Schema.Boolean, Schema.Literal("notify")])
+        .pipe(optional)
+        .annotate({
+        description: "Automatically update or notify when a new version is available",
+    }),
+    share: Schema.Literals(["manual", "auto", "disabled"]).pipe(optional).annotate({
+        description: "Control whether sessions may be shared manually, automatically, or not at all",
+    }),
+    enterprise: Schema.Struct({
+        url: Schema.String.pipe(optional),
+    })
+        .pipe(optional)
+        .annotate({
+        description: "Enterprise sharing service configuration",
+    }),
+    username: Schema.String.pipe(optional).annotate({
+        description: "Username displayed in conversations and used for telemetry identity",
+    }),
+    permissions: Permission.Ruleset.pipe(optional).annotate({
+        description: "Ordered tool permission rules applied to agent tool use",
+    }),
+    agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(optional).annotate({
+        description: "Named built-in agent overrides and custom agent definitions",
+    }),
+    snapshots: Schema.Boolean.pipe(optional).annotate({
+        description: "Enable snapshots used for undo and revert behavior",
+    }),
+    watcher: ConfigWatcher.Info.pipe(optional).annotate({
+        description: "Filesystem watcher configuration",
+    }),
+    formatter: ConfigFormatter.Info.pipe(optional).annotate({
+        description: "Enable built-in formatters or configure formatter overrides",
+    }),
+    lsp: ConfigLSP.Info.pipe(optional).annotate({
+        description: "Enable built-in language servers or configure server overrides",
+    }),
+    media: ConfigMedia.Info.pipe(optional).annotate({
+        description: "Media processing configuration",
+    }),
+    tool_output: ConfigToolOutput.Info.pipe(optional).annotate({
+        description: "Tool output truncation thresholds",
+    }),
+    mcp: ConfigMCP.Info.pipe(optional).annotate({
+        description: "MCP server configuration",
+    }),
+    compaction: ConfigCompaction.Info.pipe(optional).annotate({
+        description: "Conversation compaction behavior",
+    }),
+    skills: Schema.String.pipe(Schema.Array, optional).annotate({
+        description: "Additional paths or URLs to discover skills from",
+    }),
+    commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(optional).annotate({
+        description: "Named slash command definitions",
+    }),
+    instructions: Schema.String.pipe(Schema.Array, optional).annotate({
+        description: "Additional paths or URLs supplying ambient instructions",
+    }),
+    references: ConfigReference.Info.pipe(optional).annotate({
+        description: "Named local directories or Git repositories available as external context",
+    }),
+    websearch: ConfigWebSearch.Info.pipe(optional).annotate({
+        description: "Web search provider selection",
+    }),
+    plugins: ConfigPlugin.Plugins.pipe(optional).annotate({
+        description: "Ordered plugin enablement directives and external package declarations",
+    }),
+    warming: ConfigWarming.Warming.pipe(optional).annotate({
+        description: "Keep recently active sessions warm with transient model requests (default: false)",
+    }),
+    providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(optional),
+    experimental: ConfigExperimental.Info.pipe(optional),
+}) {
+}
+export class Document extends Schema.Class("Config.Document")({
+    type: Schema.Literal("document"),
+    path: Schema.String.pipe(optional),
+    info: Info,
+}) {
+}
+export class Directory extends Schema.Class("Config.Directory")({
+    type: Schema.Literal("directory"),
+    path: AbsolutePath,
+}) {
+}
+export class File extends Schema.Class("Config.File")({
+    type: Schema.Literal("file"),
+    path: AbsolutePath,
+}) {
+}
+export class AgentsDirectory extends Schema.Class("Config.AgentsDirectory")({
+    type: Schema.Literal("agents"),
+    path: AbsolutePath,
+}) {
+}
+export class ClaudeDirectory extends Schema.Class("Config.ClaudeDirectory")({
+    type: Schema.Literal("claude"),
+    path: AbsolutePath,
+}) {
+}
+export const Entry = Schema.Union([Document, Directory, File, AgentsDirectory, ClaudeDirectory]).annotate({
+    identifier: "Config.Entry",
+});
 const Updated = ephemeral({
@@ -4,0 +138,0 @@ type: "config.updated",

dist/mcp.d.ts

 export * as Mcp from "./mcp.js";
 import { Schema } from "effect";
 declare const TimeoutConfig_base: Schema.Class<TimeoutConfig, Schema.Struct<{
-    readonly startup: Schema.optional<Schema.Int>;
-    readonly catalog: Schema.optional<Schema.Int>;
-    readonly execution: Schema.optional<Schema.Int>;
+    readonly startup: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly catalog: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly execution: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
 }>, {}>;
@@ -13,7 +13,7 @@ export declare class TimeoutConfig extends TimeoutConfig_base {
     readonly command: Schema.$Array<Schema.String>;
-    readonly cwd: Schema.optional<Schema.String>;
-    readonly environment: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
-    readonly disabled: Schema.optional<Schema.Boolean>;
-    readonly codemode: Schema.optional<Schema.Boolean>;
-    readonly timeout: Schema.optional<typeof TimeoutConfig>;
+    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<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 disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly codemode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<typeof TimeoutConfig>>, Schema.optionalKey<typeof TimeoutConfig>, never, never>;
 }>, {}>;
@@ -23,7 +23,7 @@ export declare class LocalConfig extends LocalConfig_base {
 declare const OAuthConfig_base: Schema.Class<OAuthConfig, Schema.Struct<{
-    readonly client_id: Schema.optional<Schema.String>;
-    readonly client_secret: Schema.optional<Schema.String>;
-    readonly scope: Schema.optional<Schema.String>;
-    readonly callback_port: Schema.optional<Schema.Int>;
-    readonly redirect_uri: Schema.optional<Schema.String>;
+    readonly client_id: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly client_secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly scope: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly callback_port: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly redirect_uri: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }>, {}>;
@@ -35,7 +35,7 @@ export declare class OAuthConfig extends OAuthConfig_base {
     readonly url: Schema.String;
-    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
-    readonly oauth: Schema.optional<Schema.Union<readonly [typeof OAuthConfig, Schema.Literal<false>]>>;
-    readonly disabled: Schema.optional<Schema.Boolean>;
-    readonly codemode: Schema.optional<Schema.Boolean>;
-    readonly timeout: Schema.optional<typeof TimeoutConfig>;
+    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 oauth: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [typeof OAuthConfig, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [typeof OAuthConfig, Schema.Literal<false>]>>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly codemode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<typeof TimeoutConfig>>, Schema.optionalKey<typeof TimeoutConfig>, never, never>;
 }>, {}>;
@@ -58,5 +58,2 @@ export declare class RemoteConfig extends RemoteConfig_base {
     readonly status: Schema.Literal<"needs_auth">;
-}>, Schema.Struct<{
-    readonly status: Schema.Literal<"needs_client_registration">;
-    readonly error: Schema.String;
 }>]>;
@@ -78,5 +75,2 @@ export interface Server extends Schema.Schema.Type<typeof Server> {
         readonly status: Schema.Literal<"needs_auth">;
-    }>, Schema.Struct<{
-        readonly status: Schema.Literal<"needs_client_registration">;
-        readonly error: Schema.String;
     }>]>;
@@ -83,0 +77,0 @@ readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;

dist/mcp.js

@@ -6,9 +6,9 @@ export * as Mcp from "./mcp.js";
 export class TimeoutConfig extends Schema.Class("Mcp.TimeoutConfig")({
-    startup: PositiveInt.pipe(Schema.optional).annotate({
+    startup: PositiveInt.pipe(optional).annotate({
         description: "Maximum time in milliseconds to establish and initialize the MCP server.",
     }),
-    catalog: PositiveInt.pipe(Schema.optional).annotate({
+    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(Schema.optional).annotate({
+    execution: PositiveInt.pipe(optional).annotate({
         description: "Maximum time in milliseconds to wait for MCP tool and prompt execution.",
@@ -21,19 +21,19 @@ }),
     command: Schema.String.pipe(Schema.Array),
-    cwd: Schema.String.pipe(Schema.optional).annotate({
+    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(Schema.optional),
-    disabled: Schema.Boolean.pipe(Schema.optional),
-    codemode: Schema.Boolean.pipe(Schema.optional).annotate({
+    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(Schema.optional),
+    timeout: TimeoutConfig.pipe(optional),
 }) {
 }
 export class OAuthConfig extends Schema.Class("Mcp.OAuthConfig")({
-    client_id: Schema.String.pipe(Schema.optional),
-    client_secret: Schema.String.pipe(Schema.optional),
-    scope: Schema.String.pipe(Schema.optional),
-    callback_port: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 })).pipe(Schema.optional),
-    redirect_uri: Schema.String.pipe(Schema.optional),
+    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),
 }) {
@@ -44,9 +44,9 @@ }
     url: Schema.String,
-    headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
-    oauth: Schema.Union([OAuthConfig, Schema.Literal(false)]).pipe(Schema.optional),
-    disabled: Schema.Boolean.pipe(Schema.optional),
-    codemode: Schema.Boolean.pipe(Schema.optional).annotate({
+    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(Schema.optional),
+    timeout: TimeoutConfig.pipe(optional),
 }) {
@@ -70,7 +70,3 @@ }
 });
-const NeedsClientRegistration = Schema.Struct({
-    status: Schema.Literal("needs_client_registration"),
-    error: Schema.String,
-}).annotate({ identifier: "Mcp.Status.NeedsClientRegistration" });
-export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth, NeedsClientRegistration]).pipe(Schema.toTaggedUnion("status"));
+export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth]).pipe(Schema.toTaggedUnion("status"));
 export const Server = Schema.Struct({
@@ -77,0 +73,0 @@ name: Schema.String,

dist/prompt.d.ts

@@ -180,2 +180,10 @@ import { Schema } from "effect";
         readonly text: string;
+        readonly agents?: readonly {
+            readonly name: string;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
         readonly files?: readonly {
@@ -198,2 +206,5 @@ readonly data: string;
         }[] | undefined;
+    }>;
+    fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
+        readonly text: string;
         readonly agents?: readonly {
@@ -207,5 +218,2 @@ readonly name: string;
         }[] | undefined;
-    }>;
-    fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
-        readonly text: string;
         readonly files?: readonly {
@@ -228,11 +236,3 @@ readonly data: string;
         }[] | undefined;
-        readonly agents?: readonly {
-            readonly name: string;
-            readonly mention?: {
-                readonly start: number;
-                readonly end: number;
-                readonly text: string;
-            } | undefined;
-        }[] | undefined;
     };
 };

package.json

 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/schema",
-  "version": "0.0.0-next-16916",
+  "version": "0.0.0-next-16926",
   "type": "module",
@@ -6,0 +6,0 @@ "license": "MIT",

New alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Fixed alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Improved metrics

Total package byte prevSize

3468190

1.59%

Number of package files

195

21.12%

Lines of code

54417

1.64%

No dependency changes