@opencode/schema 2.0.2 → 2.0.4

package/dist/config/mcp.d.ts

@@ -10,6 +10,8 @@ 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]>;
+export declare const Protocol: Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>;
+export type Protocol = Mcp.Protocol;
 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>;

package/dist/config/mcp.js

@@ -7,6 +7,7 @@ export const Local = Mcp.LocalConfig;
 export const OAuth = Mcp.OAuthConfig;
 export const Remote = Mcp.RemoteConfig;
 export const Server = Mcp.ServerConfig;
+export const Protocol = Mcp.Protocol;
 export class Info extends Schema.Class("Config.MCP")({
     timeout: Timeout.pipe(optional),
     servers: Schema.Record(Schema.String, Server).pipe(optional),

package/dist/config/provider.d.ts

@@ -55,7 +55,6 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
         readonly tools: Schema.Boolean;
         readonly input: Schema.$Array<Schema.String>;
         readonly output: Schema.$Array<Schema.String>;
-        readonly responsesWebsockets: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }> & {
         default: () => {
             tools: true;
@@ -66,7 +65,6 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
         readonly tools: Schema.Boolean;
         readonly input: Schema.$Array<Schema.String>;
         readonly output: Schema.$Array<Schema.String>;
-        readonly responsesWebsockets: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }> & {
         default: () => {
             tools: true;
@@ -102,7 +100,7 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
         readonly mode: Schema.Literal<"provider">;
         readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>]>>, never, never>;
-    readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, 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>;
@@ -112,12 +110,14 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>, never, never>;
         readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>, never, never>;
     readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }>, {}>;
@@ -139,7 +139,7 @@ declare const Info_base: Schema.Class<Info, Schema.Struct<{
         readonly mode: Schema.Literal<"provider">;
         readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>]>>, never, never>;
-    readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
     readonly canonical: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Provider.ID"> & {
         opencode: string & import("effect/Brand").Brand<"Provider.ID">;
         anthropic: string & import("effect/Brand").Brand<"Provider.ID">;

package/dist/config/provider.js

@@ -38,8 +38,8 @@ class Limit extends Schema.Class("Config.Model.Limit")({
 }
 class Model extends Schema.Class("Config.Model")({
     compaction: Provider.Compaction.pipe(optional),
-    websocket: Schema.Boolean.pipe(optional).annotate({
-        description: "Use the provider's WebSocket transport for this model. Defaults to the provider policy.",
+    transport: Provider.Transport.pipe(optional).annotate({
+        description: "Session transport for this model. Defaults to the provider transport.",
     }),
     modelID: ID.pipe(optional),
     family: Family.pipe(optional),
@@ -59,8 +59,8 @@ class Model extends Schema.Class("Config.Model")({
 }
 export class Info extends Schema.Class("Config.Provider")({
     compaction: Provider.Compaction.pipe(optional),
-    websocket: Schema.Boolean.pipe(optional).annotate({
-        description: "Use the provider's WebSocket transport when the route supports it. Defaults to the built-in policy.",
+    transport: Provider.Transport.pipe(optional).annotate({
+        description: "Session transport for this provider's models. Defaults to the built-in policy; \"websocket\" on a route without a WebSocket channel warns and falls back to HTTP.",
     }),
     canonical: Provider.ID.pipe(optional),
     name: Schema.String.pipe(optional),

package/dist/config.d.ts

@@ -83,17 +83,10 @@ declare const Info_base: Schema.Class<Info, Schema.Struct<{
 }>, {}>;
 export declare class Info extends Info_base {
 }
-export declare const Preferences: Schema.Struct<{
-    readonly shell: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>, never, never>;
+export declare const Patch: Schema.Struct<{
+    readonly shell: Schema.NullOr<Schema.String>;
 }>;
-export interface Preferences extends Schema.Schema.Type<typeof Preferences> {
-}
-export declare const PreferencesPatch: Schema.Struct<{
-    readonly shell: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NullOr<Schema.String>>>, Schema.optionalKey<Schema.NullOr<Schema.String>>, never, never>;
-    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NullOr<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>>>, Schema.optionalKey<Schema.NullOr<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>>, never, never>;
-}>;
-export interface PreferencesPatch extends Schema.Schema.Type<typeof PreferencesPatch> {
+export interface Patch extends Schema.Schema.Type<typeof Patch> {
 }
 declare const Document_base: Schema.Class<Document, Schema.Struct<{
     readonly type: Schema.Literal<"document">;
@@ -108,19 +101,7 @@ declare const Directory_base: Schema.Class<Directory, Schema.Struct<{
 }>, {}>;
 export declare class Directory extends Directory_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 AgentsDirectory, typeof ClaudeDirectory]>;
+export declare const Entry: Schema.Union<readonly [typeof Document, typeof Directory]>;
 export type Entry = typeof Entry.Type;
 export declare const Event: {
     Updated: Schema.Struct<{

package/dist/config.js

@@ -107,14 +107,9 @@ export class Info extends Schema.Class("Config.Info")({
     experimental: ConfigExperimental.Info.pipe(optional),
 }) {
 }
-export const Preferences = Schema.Struct({
-    shell: Schema.String.pipe(optional),
-    websearch: ConfigWebSearch.Selection.pipe(optional),
-}).annotate({ identifier: "Config.Preferences" });
-export const PreferencesPatch = Schema.Struct({
-    shell: Schema.NullOr(Schema.String).pipe(optional),
-    websearch: Schema.NullOr(ConfigWebSearch.Selection).pipe(optional),
-}).annotate({ identifier: "Config.PreferencesPatch" });
+export const Patch = Schema.Struct({
+    shell: Schema.NullOr(Schema.String),
+}).annotate({ identifier: "Config.Patch" });
 export class Document extends Schema.Class("Config.Document")({
     type: Schema.Literal("document"),
     path: AbsolutePath.pipe(optional),
@@ -126,17 +121,7 @@ export class Directory extends Schema.Class("Config.Directory")({
     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, AgentsDirectory, ClaudeDirectory]).annotate({
+export const Entry = Schema.Union([Document, Directory]).annotate({
     identifier: "Config.Entry",
 });
 const Updated = ephemeral({

package/dist/event-manifest.d.ts

@@ -147,7 +147,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
     };
     readonly created: Schema.Finite;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly type: Schema.Literal<"catalog.updated">;
+    readonly type: Schema.Literal<"provider.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"> & {
@@ -169,7 +169,39 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
     }>>, never, never>;
     readonly data: Schema.Struct<{}>;
 }> & {
-    type: "catalog.updated";
+    type: "provider.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{}>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"model.updated">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{}>;
+}> & {
+    type: "model.updated";
     durability: "ephemeral";
     durable: undefined;
     data: Schema.Struct<{}>;
@@ -791,7 +823,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
     };
     readonly created: Schema.Finite;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly type: Schema.Literal<"session.permissions.updated">;
+    readonly type: Schema.Literal<"session.permissions">;
     readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -828,7 +860,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -4543,7 +4575,6 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
-            readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -4575,7 +4606,6 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
-            readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -6299,7 +6329,39 @@ export declare const Definitions: readonly [Schema.Struct<{
     };
     readonly created: Schema.Finite;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly type: Schema.Literal<"catalog.updated">;
+    readonly type: Schema.Literal<"provider.updated">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{}>;
+}> & {
+    type: "provider.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{}>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"model.updated">;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
@@ -6321,7 +6383,7 @@ export declare const Definitions: readonly [Schema.Struct<{
     }>>, never, never>;
     readonly data: Schema.Struct<{}>;
 }> & {
-    type: "catalog.updated";
+    type: "model.updated";
     durability: "ephemeral";
     durable: undefined;
     data: Schema.Struct<{}>;
@@ -6943,7 +7005,7 @@ export declare const Definitions: readonly [Schema.Struct<{
     };
     readonly created: Schema.Finite;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly type: Schema.Literal<"session.permissions.updated">;
+    readonly type: Schema.Literal<"session.permissions">;
     readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -6980,7 +7042,7 @@ export declare const Definitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -10767,7 +10829,6 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
-            readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -10799,7 +10860,6 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
-            readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;

package/dist/event-manifest.js

@@ -1,7 +1,6 @@
 export * as EventManifest from "./event-manifest.js";
 import { Schema } from "effect";
 import { Agent } from "./agent.js";
-import { Catalog } from "./catalog.js";
 import { Command } from "./command.js";
 import { Config } from "./config.js";
 import { Credential } from "./credential.js";
@@ -15,11 +14,13 @@ import { Integration } from "./integration.js";
 import { LegacyEventV1 } from "./legacy-event.js";
 import { LspEvent } from "./lsp-event.js";
 import { McpEvent } from "./mcp-event.js";
+import { Model } from "./model.js";
 import { ModelsDev } from "./models-dev.js";
 import { Permission } from "./permission.js";
 import { PersistentPty } from "./persistent-pty.js";
 import { Plugin } from "./plugin.js";
 import { Project } from "./project.js";
+import { Provider } from "./provider.js";
 import { Worktree } from "./worktree.js";
 import { Pty } from "./pty.js";
 import { Reference } from "./reference.js";
@@ -35,7 +36,7 @@ import { WorkspaceEvent } from "./workspace-event.js";
 import { WorktreeEvent } from "./worktree-event.js";
 import { WebSearch } from "./websearch.js";
 const coreDefinitions = Event.inventory(...SessionEvent.Definitions);
-const foundationDefinitions = Event.inventory(...ModelsDev.Event.Definitions, ...Credential.Event.Definitions, ...Integration.Event.Definitions, ...Catalog.Event.Definitions, ...Agent.Event.Definitions, ...coreDefinitions);
+const foundationDefinitions = Event.inventory(...ModelsDev.Event.Definitions, ...Credential.Event.Definitions, ...Integration.Event.Definitions, ...Provider.Event.Definitions, ...Model.Event.Definitions, ...Agent.Event.Definitions, ...coreDefinitions);
 const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...Project.Event.Definitions, ...Worktree.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...PersistentPty.Event.Definitions, ...Shell.Event.Definitions, ...Form.Event.Definitions, ...WebSearch.Event.Definitions);
 export const ServerDefinitions = Event.inventory(...foundationDefinitions, ...featureDefinitions, 
 // Current events the TUI consumes from the public stream.

package/dist/form.d.ts

@@ -518,6 +518,138 @@ export declare const State: Schema.Union<readonly [Schema.Struct<{
     readonly status: Schema.Literal<"cancelled">;
 }>]>;
 export type State = typeof State.Type;
+export declare const Detail: Schema.Struct<{
+    readonly state: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"pending">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"answered">;
+        readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"cancelled">;
+    }>]>;
+    readonly fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"string">;
+        readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+        readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>, never, never>;
+        readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly key: Schema.String;
+        readonly title: 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 required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"number">;
+        readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly key: Schema.String;
+        readonly title: 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 required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"integer">;
+        readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly key: Schema.String;
+        readonly title: 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 required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"boolean">;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly key: Schema.String;
+        readonly title: 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 required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"multiselect">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>;
+        readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly key: Schema.String;
+        readonly title: 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 required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly key: Schema.String;
+        readonly type: Schema.Literal<"external">;
+        readonly url: Schema.String;
+        readonly title: 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 id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+    readonly sessionID: Schema.String;
+    readonly title: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export interface Detail extends Schema.Schema.Type<typeof Detail> {
+}
 export declare const Reply: Schema.Struct<{
     readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
 }>;

package/dist/form.js

@@ -111,6 +111,10 @@ export const State = Schema.Union([
 ])
     .pipe(Schema.toTaggedUnion("status"))
     .annotate({ identifier: "Form.State" });
+export const Detail = Schema.Struct({
+    ...Info.fields,
+    state: State,
+}).annotate({ identifier: "Form.Detail" });
 export const Reply = Schema.Struct({
     answer: Answer,
 }).annotate({ identifier: "Form.Reply" });

package/dist/location.d.ts

@@ -12,6 +12,11 @@ export declare const Ref: Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
     }>, never, never>;
 }>;
+export declare const PublicRef: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export interface PublicRef extends Schema.Schema.Type<typeof PublicRef> {
+}
 declare const Info_base: Schema.Class<Info, Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
@@ -31,7 +36,21 @@ declare const Info_base: Schema.Class<Info, Schema.Struct<{
 }>, {}>;
 export declare class Info extends Info_base {
 }
+export declare const PublicInfo: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly project: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+}>;
+export interface PublicInfo extends Schema.Schema.Type<typeof PublicInfo> {
+}
 export declare function response<S extends Schema.Top>(data: S): Schema.Struct<{
-    readonly location: typeof Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: S;
 }>;

package/dist/location.js

@@ -1,5 +1,5 @@
 export * as Location from "./location.js";
-import { Schema } from "effect";
+import { Schema, Struct } from "effect";
 import { AbsolutePath, optional } from "./schema.js";
 import { ProjectID } from "./project-id.js";
 import { WorkspaceID } from "./workspace-id.js";
@@ -7,6 +7,9 @@ export const Ref = Schema.Struct({
     directory: AbsolutePath,
     workspaceID: optional(WorkspaceID),
 }).annotate({ identifier: "Location.Ref" });
+export const PublicRef = Schema.Struct(Struct.omit(Ref.fields, ["workspaceID"])).annotate({
+    identifier: "Location.PublicRef",
+});
 export class Info extends Schema.Class("Location.Info")({
     directory: AbsolutePath,
     workspaceID: optional(WorkspaceID),
@@ -17,6 +20,9 @@ export class Info extends Schema.Class("Location.Info")({
     }),
 }) {
 }
+export const PublicInfo = Schema.Struct(Struct.omit(Info.fields, ["workspaceID"])).annotate({
+    identifier: "Location.PublicInfo",
+});
 export function response(data) {
-    return Schema.Struct({ location: Info, data });
+    return Schema.Struct({ location: PublicRef, data });
 }