@opencode-ai/schema 0.0.0-next-16909 → 0.0.0-next-16926

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

package/dist/config/websearch.js

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

package/dist/config.d.ts

@@ -1,69 +1,181 @@
 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">;
                 create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
             }>, never, never>;
         }>>, never, never>;
-        readonly data: import("effect/Schema").Struct<{}>;
+        readonly data: Schema.Struct<{}>;
     }> & {
         type: "config.updated";
         durability: "ephemeral";
         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">;
                 create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
             }>, never, never>;
         }>>, never, never>;
-        readonly data: import("effect/Schema").Struct<{}>;
+        readonly data: Schema.Struct<{}>;
     }> & {
         type: "config.updated";
         durability: "ephemeral";
         durable: undefined;
-        data: import("effect/Schema").Struct<{}>;
+        data: Schema.Struct<{}>;
     }];
 };

package/dist/config.js

@@ -1,5 +1,139 @@
 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({
     type: "config.updated",
     schema: {},

package/dist/mcp.d.ts

@@ -1,40 +1,40 @@
 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>;
 }>, {}>;
 export declare class TimeoutConfig extends TimeoutConfig_base {
 }
 declare const LocalConfig_base: Schema.Class<LocalConfig, Schema.Struct<{
     readonly type: Schema.Literal<"local">;
     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>;
 }>, {}>;
 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>;
 }>, {}>;
 export declare class OAuthConfig extends OAuthConfig_base {
 }
 declare const RemoteConfig_base: Schema.Class<RemoteConfig, Schema.Struct<{
     readonly type: Schema.Literal<"remote">;
     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>;
 }>, {}>;
 export declare class RemoteConfig extends RemoteConfig_base {
 }
@@ -52,9 +52,6 @@ export declare const Status: Schema.toTaggedUnion<"status", readonly [Schema.Str
     readonly error: Schema.String;
 }>, Schema.Struct<{
     readonly status: Schema.Literal<"needs_auth">;
-}>, Schema.Struct<{
-    readonly status: Schema.Literal<"needs_client_registration">;
-    readonly error: Schema.String;
 }>]>;
 export interface Server extends Schema.Schema.Type<typeof Server> {
 }
@@ -71,9 +68,6 @@ export declare const Server: Schema.Struct<{
         readonly error: Schema.String;
     }>, Schema.Struct<{
         readonly status: Schema.Literal<"needs_auth">;
-    }>, Schema.Struct<{
-        readonly status: Schema.Literal<"needs_client_registration">;
-        readonly error: Schema.String;
     }>]>;
     readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
 }>;

package/dist/mcp.js

@@ -3,13 +3,13 @@ import { Schema } from "effect";
 import { optional, PositiveInt } from "./schema.js";
 import { IntegrationID } from "./integration-id.js";
 export class TimeoutConfig extends Schema.Class("Mcp.TimeoutConfig")({
-    startup: PositiveInt.pipe(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.",
     }),
 }) {
@@ -17,35 +17,35 @@ export class TimeoutConfig extends Schema.Class("Mcp.TimeoutConfig")({
 export class LocalConfig extends Schema.Class("Mcp.LocalConfig")({
     type: Schema.Literal("local"),
     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),
 }) {
 }
 export class RemoteConfig extends Schema.Class("Mcp.RemoteConfig")({
     type: Schema.Literal("remote"),
     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),
 }) {
 }
 export const ServerConfig = Schema.Union([LocalConfig, RemoteConfig]).pipe(Schema.toTaggedUnion("type"));
@@ -64,11 +64,7 @@ const Failed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.S
 const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth") }).annotate({
     identifier: "Mcp.Status.NeedsAuth",
 });
-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({
     name: Schema.String,
     status: Status,