@opencode/schema 2.0.3 → 2.0.5

package/dist/mcp.d.ts

@@ -7,6 +7,8 @@ declare const TimeoutConfig_base: Schema.Class<TimeoutConfig, Schema.Struct<{
 }>, {}>;
 export declare class TimeoutConfig extends TimeoutConfig_base {
 }
+export type Protocol = typeof Protocol.Type;
+export declare const Protocol: Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>;
 declare const LocalConfig_base: Schema.Class<LocalConfig, Schema.Struct<{
     readonly type: Schema.Literal<"local">;
     readonly command: Schema.$Array<Schema.String>;
@@ -15,6 +17,7 @@ declare const LocalConfig_base: Schema.Class<LocalConfig, Schema.Struct<{
     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>;
+    readonly protocol: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>>, Schema.optionalKey<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>, never, never>;
 }>, {}>;
 export declare class LocalConfig extends LocalConfig_base {
 }
@@ -24,6 +27,7 @@ declare const OAuthConfig_base: Schema.Class<OAuthConfig, Schema.Struct<{
     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>;
+    readonly auth_server_metadata_url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }>, {}>;
 export declare class OAuthConfig extends OAuthConfig_base {
 }
@@ -35,6 +39,7 @@ declare const RemoteConfig_base: Schema.Class<RemoteConfig, Schema.Struct<{
     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>;
+    readonly protocol: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>>, Schema.optionalKey<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>, never, never>;
 }>, {}>;
 export declare class RemoteConfig extends RemoteConfig_base {
 }
@@ -52,6 +57,7 @@ export declare const Status: Schema.toTaggedUnion<"status", readonly [Schema.Str
     readonly error: Schema.String;
 }>, Schema.Struct<{
     readonly status: Schema.Literal<"needs_auth">;
+    readonly error: Schema.String;
 }>]>;
 export interface Server extends Schema.Schema.Type<typeof Server> {
 }
@@ -68,6 +74,7 @@ export declare const Server: Schema.Struct<{
         readonly error: Schema.String;
     }>, Schema.Struct<{
         readonly status: Schema.Literal<"needs_auth">;
+        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

@@ -14,6 +14,10 @@ export class TimeoutConfig extends Schema.Class("Mcp.TimeoutConfig")({
     }),
 }) {
 }
+export const Protocol = Schema.Literals(["legacy", "auto", "2026-07-28"]).annotate({
+    identifier: "Mcp.Protocol",
+    description: 'MCP protocol negotiation. "legacy" (default) opens with the initialize handshake and speaks protocol revisions up to 2025-11-25. "auto" probes for the 2026-07-28 revision and falls back to legacy when the server does not support it. "2026-07-28" requires that revision and fails otherwise.',
+});
 export class LocalConfig extends Schema.Class("Mcp.LocalConfig")({
     type: Schema.Literal("local"),
     command: Schema.String.pipe(Schema.Array),
@@ -26,6 +30,7 @@ export class LocalConfig extends Schema.Class("Mcp.LocalConfig")({
         description: "Expose this server's tools through Code Mode. Defaults to true.",
     }),
     timeout: TimeoutConfig.pipe(optional),
+    protocol: Protocol.pipe(optional),
 }) {
 }
 export class OAuthConfig extends Schema.Class("Mcp.OAuthConfig")({
@@ -34,6 +39,9 @@ export class OAuthConfig extends Schema.Class("Mcp.OAuthConfig")({
     scope: Schema.String.pipe(optional),
     callback_port: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 })).pipe(optional),
     redirect_uri: Schema.String.pipe(optional),
+    auth_server_metadata_url: Schema.String.pipe(optional).annotate({
+        description: "URL of the OAuth or OpenID Connect authorization server metadata document. Set when the MCP server does not publish protected resource metadata that names its authorization server.",
+    }),
 }) {
 }
 export class RemoteConfig extends Schema.Class("Mcp.RemoteConfig")({
@@ -46,6 +54,7 @@ export class RemoteConfig extends Schema.Class("Mcp.RemoteConfig")({
         description: "Expose this server's tools through Code Mode. Defaults to true.",
     }),
     timeout: TimeoutConfig.pipe(optional),
+    protocol: Protocol.pipe(optional),
 }) {
 }
 export const ServerConfig = Schema.Union([LocalConfig, RemoteConfig]).pipe(Schema.toTaggedUnion("type"));
@@ -61,7 +70,7 @@ const Disabled = Schema.Struct({ status: Schema.Literal("disabled") }).annotate(
 const Failed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.String }).annotate({
     identifier: "Mcp.Status.Failed",
 });
-const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth") }).annotate({
+const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth"), error: Schema.String }).annotate({
     identifier: "Mcp.Status.NeedsAuth",
 });
 export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth]).pipe(Schema.toTaggedUnion("status"));

package/dist/model.d.ts

@@ -3,6 +3,74 @@ import { Schema } from "effect";
 import { Provider } from "./provider.js";
 export declare const ID: Schema.brand<Schema.String, "Model.ID">;
 export type ID = typeof ID.Type;
+export declare const Event: {
+    Updated: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"model.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{}>;
+    }> & {
+        type: "model.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"model.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{}>;
+    }> & {
+        type: "model.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};
 export declare const VariantID: Schema.brand<Schema.String, "Model.VariantID">;
 export type VariantID = typeof VariantID.Type;
 export declare const Ref: Schema.Struct<{
@@ -45,6 +113,7 @@ export declare const Compatibility: 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>;
 }>;
 export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {
 }
@@ -52,7 +121,6 @@ export declare const Capabilities: 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;
@@ -100,7 +168,6 @@ export declare const Info: 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;
@@ -199,6 +266,7 @@ export declare const Info: 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<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
         /** Require every assistant message to include its reasoning field, even when empty. */
@@ -206,6 +274,7 @@ export declare const Info: 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>;
     }>>, never, never>;
     readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
@@ -219,8 +288,8 @@ export declare const 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>;
-    /** Session WebSocket policy; omitted inherits the provider policy, then defaults to disabled. */
-    readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    /** Session transport; omitted inherits the provider transport, then defaults to HTTP. */
+    readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
 }> & {
     default: (providerID: Provider.ID, id: ID) => {
         id: string & import("effect/Brand").Brand<"Model.ID">;

package/dist/model.js

@@ -3,7 +3,10 @@ import { Schema } from "effect";
 import { optional, statics } from "./schema.js";
 import { Provider } from "./provider.js";
 import { Money } from "./money.js";
+import { ephemeral, inventory } from "./event.js";
 export const ID = Schema.String.pipe(Schema.brand("Model.ID"));
+const Updated = ephemeral({ type: "model.updated", schema: {} });
+export const Event = { Updated, Definitions: inventory(Updated) };
 export const VariantID = Schema.String.pipe(Schema.brand("Model.VariantID"));
 export const Ref = Schema.Struct({
     id: ID,
@@ -44,12 +47,12 @@ export const Compatibility = Schema.Struct({
     maxTokensField: MaxTokensField.pipe(optional),
     requireFinishReason: Schema.Boolean.pipe(optional),
     requireAssistantAfterTool: Schema.Boolean.pipe(optional),
+    supportsPromptCacheKey: Schema.Boolean.pipe(optional),
 }).annotate({ identifier: "Model.Compatibility" });
 export const Capabilities = Schema.Struct({
     tools: Schema.Boolean,
     input: Schema.Array(Schema.String),
     output: Schema.Array(Schema.String),
-    responsesWebsockets: Schema.Boolean.pipe(optional),
 })
     .annotate({ identifier: "Model.Capabilities" })
     .pipe(statics(() => ({
@@ -81,8 +84,8 @@ export const Info = Schema.Struct({
     compatibility: Compatibility.pipe(optional),
     package: Provider.Package.pipe(optional),
     compaction: Provider.Compaction.pipe(optional),
-    /** Session WebSocket policy; omitted inherits the provider policy, then defaults to disabled. */
-    websocket: Schema.Boolean.pipe(optional),
+    /** Session transport; omitted inherits the provider transport, then defaults to HTTP. */
+    transport: Provider.Transport.pipe(optional),
     ...Provider.Overlays,
     capabilities: Capabilities,
     variants: Schema.Array(Variant),

package/dist/permission-saved.d.ts

@@ -13,6 +13,10 @@ export declare const Info: Schema.Struct<{
     };
     readonly action: Schema.String;
     readonly resource: Schema.String;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly updated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>;
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }

package/dist/permission-saved.js

@@ -2,11 +2,15 @@ export * as PermissionSaved from "./permission-saved.js";
 import { Schema } from "effect";
 import { ascending } from "./identifier.js";
 import { ProjectID } from "./project-id.js";
-import { statics } from "./schema.js";
+import { DateTimeUtcFromMillis, statics } from "./schema.js";
 export const ID = Schema.String.pipe(Schema.brand("PermissionSaved.ID"), statics((schema) => ({ create: () => schema.make("psv_" + ascending()) })));
 export const Info = Schema.Struct({
     id: ID,
     projectID: ProjectID,
     action: Schema.String,
     resource: Schema.String,
+    time: Schema.Struct({
+        created: DateTimeUtcFromMillis,
+        updated: DateTimeUtcFromMillis,
+    }),
 }).annotate({ identifier: "PermissionSaved.Info" });

package/dist/project.d.ts

@@ -29,7 +29,6 @@ export interface Commands extends Schema.Schema.Type<typeof Commands> {
 export declare const 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>;
 }>;
 export interface Time extends Schema.Schema.Type<typeof Time> {
 }
@@ -57,7 +56,6 @@ export declare const Info: 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>;
 }>;
@@ -137,7 +135,6 @@ export declare const Event: {
             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>;
         }>;
@@ -169,7 +166,6 @@ export declare const Event: {
             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>;
         }>;
@@ -224,7 +220,6 @@ export declare const Event: {
             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>;
         }>;
@@ -256,7 +251,6 @@ export declare const Event: {
             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/project.js

@@ -23,7 +23,6 @@ export const Commands = Schema.Struct({
 export const Time = Schema.Struct({
     created: NonNegativeInt,
     updated: NonNegativeInt,
-    initialized: optional(NonNegativeInt),
 }).annotate({ identifier: "Project.Time" });
 export const Info = Schema.Struct({
     id: ID,

package/dist/provider.d.ts

@@ -14,6 +14,74 @@ export declare const ID: Schema.brand<Schema.String, "Provider.ID"> & {
     gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
 };
 export type ID = typeof ID.Type;
+export declare const Event: {
+    Updated: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"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<{}>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"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<{}>;
+    }];
+};
 export declare const Package: Schema.String;
 export type Package = typeof Package.Type;
 export declare const Activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
@@ -25,6 +93,9 @@ export declare const Compaction: Schema.Union<readonly [Schema.Struct<{
     readonly mode: Schema.Literal<"provider">;
     readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
 }>]>;
+/** "websocket" on a route without a WebSocket channel warns and falls back to HTTP. */
+export declare const Transport: Schema.Literals<readonly ["http", "websocket"]>;
+export type Transport = typeof Transport.Type;
 export declare const Overlays: {
     settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
     headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
@@ -98,8 +169,8 @@ export declare const 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>;
-    /** Session WebSocket policy for routes that support it; omitted means disabled. */
-    readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    /** Session transport for this provider's models; omitted means HTTP. */
+    readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
 }> & {
     empty: (id: ID) => Info;
 };

package/dist/provider.js

@@ -2,6 +2,7 @@ export * as Provider from "./provider.js";
 import { Effect, Schema } from "effect";
 import { Integration } from "./integration.js";
 import { optional, PositiveInt, statics } from "./schema.js";
+import { ephemeral, inventory } from "./event.js";
 export const ID = Schema.String.pipe(Schema.brand("Provider.ID"), statics((schema) => ({
     opencode: schema.make("opencode"),
     anthropic: schema.make("anthropic"),
@@ -15,12 +16,16 @@ export const ID = Schema.String.pipe(Schema.brand("Provider.ID"), statics((schem
     mistral: schema.make("mistral"),
     gitlab: schema.make("gitlab"),
 })));
+const Updated = ephemeral({ type: "provider.updated", schema: {} });
+export const Event = { Updated, Definitions: inventory(Updated) };
 export const Package = Schema.String;
 export const Activation = Schema.Literals(["auto", "enabled", "disabled"]);
 export const Compaction = Schema.Union([
     Schema.Struct({ mode: Schema.Literal("local") }),
     Schema.Struct({ mode: Schema.Literal("provider"), threshold: PositiveInt.pipe(optional) }),
 ]).annotate({ identifier: "Provider.Compaction" });
+/** "websocket" on a route without a WebSocket channel warns and falls back to HTTP. */
+export const Transport = Schema.Literals(["http", "websocket"]).annotate({ identifier: "Provider.Transport" });
 export const Overlays = {
     settings: Schema.Record(Schema.String, Schema.Any).pipe(optional),
     headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
@@ -40,8 +45,8 @@ export const Info = Schema.Struct({
     activation: Activation,
     package: Package,
     compaction: Compaction.pipe(optional),
-    /** Session WebSocket policy for routes that support it; omitted means disabled. */
-    websocket: Schema.Boolean.pipe(optional),
+    /** Session transport for this provider's models; omitted means HTTP. */
+    transport: Transport.pipe(optional),
     ...Overlays,
 })
     .annotate({ identifier: "Provider.Info" })

package/dist/session-event.d.ts

@@ -602,13 +602,13 @@ export declare const Renamed: Schema.Struct<{
     }>;
 };
 export type Renamed = typeof Renamed.Type;
-export declare const PermissionsUpdated: Schema.Struct<{
+export declare const Permissions: 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<"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">;
@@ -645,7 +645,7 @@ export declare const PermissionsUpdated: Schema.Struct<{
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -663,7 +663,7 @@ export declare const PermissionsUpdated: Schema.Struct<{
         };
     }>;
 };
-export type PermissionsUpdated = typeof PermissionsUpdated.Type;
+export type Permissions = typeof Permissions.Type;
 export declare const Viewed: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -5079,7 +5079,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">;
@@ -5116,7 +5116,7 @@ export declare const Definitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -9152,7 +9152,7 @@ export declare const DurableDefinitions: 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">;
@@ -9189,7 +9189,7 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -13510,7 +13510,7 @@ export declare const Durable: Schema.Union<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">;
@@ -13547,7 +13547,7 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -17542,7 +17542,7 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
     };
     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">;
@@ -17579,7 +17579,7 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;

package/dist/session-event.js

@@ -95,8 +95,8 @@ export const Renamed = Event.durable({
         title: Schema.String,
     },
 });
-export const PermissionsUpdated = Event.durable({
-    type: "session.permissions.updated",
+export const Permissions = Event.durable({
+    type: "session.permissions",
     ...options,
     schema: {
         ...Base,
@@ -547,7 +547,7 @@ export var RevertEvent;
         schema: { ...Base, to: SessionMessage.ID },
     });
 })(RevertEvent || (RevertEvent = {}));
-export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, PermissionsUpdated, Viewed, UsageUpdated, Deleted, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Streamed, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, RetryScheduled, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
+export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, Permissions, Viewed, UsageUpdated, Deleted, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Streamed, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, RetryScheduled, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
 // Internal and replay-only events are excluded from the public manifest.
 export const DurableDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded, MessageContentUpdated);
 export const EphemeralDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "ephemeral"));

package/dist/session-fork.d.ts

@@ -14,13 +14,3 @@ export declare const Boundary: Schema.Union<readonly [Schema.Struct<{
     };
 }>]>;
 export type Boundary = typeof Boundary.Type;
-export declare const RequestBoundary: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"before">;
-    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-        fromEvent: (eventID: import("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
-    };
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"through">;
-}>]>;
-export type RequestBoundary = typeof RequestBoundary.Type;

package/dist/session-fork.js

@@ -5,7 +5,3 @@ export const Boundary = Schema.Union([
     Schema.Struct({ type: Schema.Literal("before"), messageID: SessionMessage.ID }),
     Schema.Struct({ type: Schema.Literal("through"), messageID: SessionMessage.ID }),
 ]).annotate({ identifier: "Session.ForkBoundary" });
-export const RequestBoundary = Schema.Union([
-    Schema.Struct({ type: Schema.Literal("before"), messageID: SessionMessage.ID }),
-    Schema.Struct({ type: Schema.Literal("through") }),
-]).annotate({ identifier: "Session.ForkRequestBoundary" });