@opencode/client 2.0.32 → 2.1.1

package/dist/effect/client.d.ts

@@ -7,539 +7,361 @@ import type { RpcCallOptions } from "../promise/rpc.js";
 export declare const make: (options?: {
     readonly baseUrl?: URL | string;
 } | undefined) => Effect.Effect<{
-    event: {
-        subscribe: () => Stream.Stream<{
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "skill.updated";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly form: {
-                    readonly id: string & import("effect/Brand").Brand<"Form.ID">;
-                    readonly fields: readonly [{
-                        readonly type: "string";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly options?: readonly {
-                            readonly value: string;
-                            readonly label: string;
-                            readonly description?: string | undefined;
-                        }[] | undefined;
-                        readonly description?: string | undefined;
-                        readonly format?: "email" | "uri" | "date" | "date-time" | undefined;
-                        readonly minLength?: number | undefined;
-                        readonly maxLength?: number | undefined;
-                        readonly pattern?: string | undefined;
-                        readonly placeholder?: string | undefined;
-                        readonly default?: string | undefined;
-                        readonly custom?: boolean | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                    } | {
-                        readonly type: "number";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: number | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                        readonly minimum?: number | undefined;
-                        readonly maximum?: number | undefined;
-                    } | {
-                        readonly type: "integer";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: number | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                        readonly minimum?: number | undefined;
-                        readonly maximum?: number | undefined;
-                    } | {
-                        readonly type: "boolean";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: boolean | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                    } | {
-                        readonly type: "multiselect";
-                        readonly options: readonly {
-                            readonly value: string;
-                            readonly label: string;
-                            readonly description?: string | undefined;
-                        }[];
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: readonly string[] | undefined;
-                        readonly custom?: boolean | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                        readonly minItems?: number | undefined;
-                        readonly maxItems?: number | undefined;
-                    } | {
-                        readonly type: "external";
-                        readonly url: string;
-                        readonly key: string;
-                        readonly description?: string | undefined;
-                        readonly title?: string | undefined;
-                    }, ...({
-                        readonly type: "string";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly options?: readonly {
-                            readonly value: string;
-                            readonly label: string;
-                            readonly description?: string | undefined;
-                        }[] | undefined;
-                        readonly description?: string | undefined;
-                        readonly format?: "email" | "uri" | "date" | "date-time" | undefined;
-                        readonly minLength?: number | undefined;
-                        readonly maxLength?: number | undefined;
-                        readonly pattern?: string | undefined;
-                        readonly placeholder?: string | undefined;
-                        readonly default?: string | undefined;
-                        readonly custom?: boolean | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                    } | {
-                        readonly type: "number";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: number | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                        readonly minimum?: number | undefined;
-                        readonly maximum?: number | undefined;
-                    } | {
-                        readonly type: "integer";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: number | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                        readonly minimum?: number | undefined;
-                        readonly maximum?: number | undefined;
-                    } | {
-                        readonly type: "boolean";
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: boolean | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                    } | {
-                        readonly type: "multiselect";
-                        readonly options: readonly {
-                            readonly value: string;
-                            readonly label: string;
-                            readonly description?: string | undefined;
-                        }[];
-                        readonly key: string;
-                        readonly required?: boolean | undefined;
-                        readonly description?: string | undefined;
-                        readonly default?: readonly string[] | undefined;
-                        readonly custom?: boolean | undefined;
-                        readonly title?: string | undefined;
-                        readonly hidden?: boolean | undefined;
-                        readonly when?: readonly {
-                            readonly key: string;
-                            readonly op: "eq" | "neq";
-                            readonly value: string | number | boolean;
-                        }[] | undefined;
-                        readonly minItems?: number | undefined;
-                        readonly maxItems?: number | undefined;
-                    } | {
-                        readonly type: "external";
-                        readonly url: string;
-                        readonly key: string;
-                        readonly description?: string | undefined;
-                        readonly title?: string | undefined;
-                    })[]];
-                    readonly sessionID: string;
-                    readonly title: string;
-                    readonly metadata?: {
-                        readonly [x: string]: unknown;
-                    } | undefined;
-                };
-            };
-            readonly type: "form.created";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"Form.ID">;
-                readonly sessionID: string;
-                readonly answer: {
-                    readonly [x: string]: string | number | boolean | readonly string[];
-                };
-            };
-            readonly type: "form.replied";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"Form.ID">;
-                readonly sessionID: string;
+    server: {
+        info: () => Effect.Effect<import("./api.js").ServerInfoOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        pair: () => Effect.Effect<import("./api.js").ServerPairOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        connect: (input: import("./api.js").ServerConnectInput) => Effect.Effect<import("./api.js").ServerConnectOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    location: {
+        get: (input?: import("./api.js").LocationGetInput) => Effect.Effect<import("@opencode/schema/location").PublicInfo, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        reload: () => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    agent: {
+        list: (input?: import("./api.js").AgentListInput) => Effect.Effect<import("./api.js").AgentListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        get: (input: import("./api.js").AgentGetInput) => Effect.Effect<import("./api.js").AgentGetOutput, import("@opencode/protocol/errors").AgentNotFoundError | ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    plugin: {
+        list: (input?: import("./api.js").PluginListInput) => Effect.Effect<import("./api.js").PluginListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        check: (input?: import("./api.js").PluginCheckInput) => Effect.Effect<import("./api.js").PluginCheckOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        update: (input: import("./api.js").PluginUpdateInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    session: {
+        list: (input?: import("./api.js").SessionListInput) => Effect.Effect<import("./api.js").SessionListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidCursorError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        stats: (input?: import("./api.js").SessionStatsInput) => Effect.Effect<import("./api.js").SessionStatsOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        create: (input?: import("./api.js").SessionCreateInput) => Effect.Effect<import("@opencode/schema/session").Info, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        import: (input: import("./api.js").SessionImportInput) => Effect.Effect<import("@opencode/schema/session").Info, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        export: (input: import("./api.js").SessionExportInput) => Effect.Effect<import("./api.js").SessionExportOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError, never>;
+        active: () => Effect.Effect<import("./api.js").SessionActiveOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        get: (input: import("./api.js").SessionGetInput) => Effect.Effect<import("@opencode/schema/session").Info, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        remove: (input: import("./api.js").SessionRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        fork: (input: import("./api.js").SessionForkInput) => Effect.Effect<import("@opencode/schema/session").Info, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        switchAgent: (input: import("./api.js").SessionSwitchAgentInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        switchModel: (input: import("./api.js").SessionSwitchModelInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        update: (input: import("./api.js").SessionUpdateInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        move: (input: import("./api.js").SessionMoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        prompt: (input: import("./api.js").SessionPromptInput) => Effect.Effect<import("@opencode/schema/session-inbox").User, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        command: (input: import("./api.js").SessionCommandInput) => Effect.Effect<void, ClientError | import("@opencode/protocol/errors").CommandExecutionError | import("@opencode/protocol/errors").CommandNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        skill: (input: import("./api.js").SessionSkillInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").SkillNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        synthetic: (input: import("./api.js").SessionSyntheticInput) => Effect.Effect<import("@opencode/schema/session-inbox").Synthetic, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        shell: (input: import("./api.js").SessionShellInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        compact: (input: import("./api.js").SessionCompactInput) => Effect.Effect<import("@opencode/schema/session-inbox").Compaction, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        wait: (input: import("./api.js").SessionWaitInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        revert: {
+            stage: (input: import("./api.js").SessionRevertStageInput) => Effect.Effect<import("@opencode/schema/session-revert").Revert, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionBusyError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError, never>;
+            clear: (input: import("./api.js").SessionRevertClearInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionBusyError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError, never>;
+            commit: (input: import("./api.js").SessionRevertCommitInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionBusyError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        context: (input: import("./api.js").SessionContextInput) => Effect.Effect<import("./api.js").SessionContextOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError, never>;
+        diff: (input: import("./api.js").SessionDiffInput) => Effect.Effect<import("./api.js").SessionDiffOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError, never>;
+        inbox: {
+            list: (input: import("./api.js").SessionInboxListInput) => Effect.Effect<import("./api.js").SessionInboxListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            cancel: (input: import("./api.js").SessionInboxCancelInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            update: (input: import("./api.js").SessionInboxUpdateInput) => Effect.Effect<void, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        instructions: {
+            entry: {
+                list: (input: import("./api.js").SessionInstructionsEntryListInput) => Effect.Effect<import("./api.js").SessionInstructionsEntryListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+                put: (input: import("./api.js").SessionInstructionsEntryPutInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/schema/instruction-entry").ValueTooLargeError, never>;
+                remove: (input: import("./api.js").SessionInstructionsEntryRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
             };
-            readonly type: "form.cancelled";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "credential.updated";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
+        };
+        generate: (input: import("./api.js").SessionGenerateInput) => Effect.Effect<import("./api.js").SessionGenerateOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        log: (input: import("./api.js").SessionLogInput) => Stream.Stream<import("./api.js").SessionLogOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/encoding/Sse").Retry | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/encoding/Sse").SseError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        interrupt: (input: import("./api.js").SessionInterruptInput) => Effect.Effect<import("./api.js").SessionInterruptOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        background: (input: import("./api.js").SessionBackgroundInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        message: {
+            get: (input: import("./api.js").SessionMessageGetInput) => Effect.Effect<import("@opencode/schema/session-message").Info, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        form: {
+            list: (input: import("./api.js").SessionFormListInput) => Effect.Effect<import("./api.js").SessionFormListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            create: (input: import("./api.js").SessionFormCreateInput) => Effect.Effect<import("@opencode/schema/form").Info, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            get: (input: import("./api.js").SessionFormGetInput) => Effect.Effect<import("@opencode/schema/form").Detail, ClientError | import("@opencode/protocol/errors").FormNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            reply: (input: import("./api.js").SessionFormReplyInput) => Effect.Effect<void, ClientError | import("@opencode/protocol/errors").FormAlreadySettledError | import("@opencode/protocol/errors").FormInvalidAnswerError | import("@opencode/protocol/errors").FormNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            cancel: (input: import("./api.js").SessionFormCancelInput) => Effect.Effect<void, ClientError | import("@opencode/protocol/errors").FormAlreadySettledError | import("@opencode/protocol/errors").FormNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        environment: (input: import("./api.js").SessionEnvironmentInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        view: (input: import("./api.js").SessionViewInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    message: {
+        list: (input: import("./api.js").MessageListInput) => Effect.Effect<import("./api.js").MessageListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidCursorError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError, never>;
+    };
+    model: {
+        list: (input?: import("./api.js").ModelListInput) => Effect.Effect<import("./api.js").ModelListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        default: (input?: import("./api.js").ModelDefaultInput) => Effect.Effect<import("./api.js").ModelDefaultOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    generate: {
+        text: (input: import("./api.js").GenerateTextInput) => Effect.Effect<import("./api.js").GenerateTextOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    voice: {
+        session: (input: import("./api.js").VoiceSessionInput) => Effect.Effect<import("./api.js").VoiceSessionOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    provider: {
+        list: (input?: import("./api.js").ProviderListInput) => Effect.Effect<import("./api.js").ProviderListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        get: (input: import("./api.js").ProviderGetInput) => Effect.Effect<import("./api.js").ProviderGetOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").ProviderNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    integration: {
+        list: (input?: import("./api.js").IntegrationListInput) => Effect.Effect<import("./api.js").IntegrationListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        get: (input: import("./api.js").IntegrationGetInput) => Effect.Effect<import("./api.js").IntegrationGetOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        wellknown: {
+            add: (input: import("./api.js").IntegrationWellknownAddInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        connect: {
+            key: (input: import("./api.js").IntegrationConnectKeyInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            external: (input: import("./api.js").IntegrationConnectExternalInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        oauth: {
+            connect: (input: import("./api.js").IntegrationOauthConnectInput) => Effect.Effect<import("./api.js").IntegrationOauthConnectOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            status: (input: import("./api.js").IntegrationOauthStatusInput) => Effect.Effect<import("./api.js").IntegrationOauthStatusOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            complete: (input: import("./api.js").IntegrationOauthCompleteInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            cancel: (input: import("./api.js").IntegrationOauthCancelInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        command: {
+            connect: (input: import("./api.js").IntegrationCommandConnectInput) => Effect.Effect<import("./api.js").IntegrationCommandConnectOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").IntegrationMethodNotFoundError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            status: (input: import("./api.js").IntegrationCommandStatusInput) => Effect.Effect<import("./api.js").IntegrationCommandStatusOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            cancel: (input: import("./api.js").IntegrationCommandCancelInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+    };
+    mcp: {
+        list: (input?: import("./api.js").McpListInput) => Effect.Effect<import("./api.js").McpListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        add: (input: import("./api.js").McpAddInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        remove: (input: import("./api.js").McpRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").McpServerNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        connect: (input: import("./api.js").McpConnectInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").McpServerNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        disconnect: (input: import("./api.js").McpDisconnectInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").McpServerNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        resource: {
+            catalog: (input?: import("./api.js").McpResourceCatalogInput) => Effect.Effect<import("./api.js").McpResourceCatalogOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+    };
+    credential: {
+        list: () => Effect.Effect<import("./api.js").CredentialListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        create: (input: import("./api.js").CredentialCreateInput) => Effect.Effect<import("@opencode/schema/credential").Entry, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        update: (input: import("./api.js").CredentialUpdateInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        activate: (input: import("./api.js").CredentialActivateInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        remove: (input: import("./api.js").CredentialRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    project: {
+        list: (input?: import("./api.js").ProjectListInput) => Effect.Effect<import("./api.js").ProjectListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        update: (input: import("./api.js").ProjectUpdateInput) => Effect.Effect<import("@opencode/schema/project").Info, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    form: {
+        list: (input?: import("./api.js").FormListInput) => Effect.Effect<import("./api.js").FormListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    permission: {
+        request: {
+            list: (input?: import("./api.js").PermissionRequestListInput) => Effect.Effect<import("./api.js").PermissionRequestListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        saved: {
+            list: (input?: import("./api.js").PermissionSavedListInput) => Effect.Effect<import("./api.js").PermissionSavedListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            update: (input: import("./api.js").PermissionSavedUpdateInput) => Effect.Effect<import("@opencode/schema/permission-saved").Info, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").PermissionSavedNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            remove: (input: import("./api.js").PermissionSavedRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        create: (input: import("./api.js").PermissionCreateInput) => Effect.Effect<import("./api.js").PermissionCreateOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        list: (input: import("./api.js").PermissionListInput) => Effect.Effect<import("./api.js").PermissionListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        get: (input: import("./api.js").PermissionGetInput) => Effect.Effect<import("@opencode/schema/permission").Request, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").PermissionNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        reply: (input: import("./api.js").PermissionReplyInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").PermissionNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    file: {
+        list: (input?: import("./api.js").FileListInput) => Effect.Effect<import("./api.js").FileListOutput, ClientError | import("@opencode/protocol/errors").FileNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        find: (input: import("./api.js").FileFindInput) => Effect.Effect<import("./api.js").FileFindOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    command: {
+        list: (input?: import("./api.js").CommandListInput) => Effect.Effect<import("./api.js").CommandListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    skill: {
+        list: (input?: import("./api.js").SkillListInput) => Effect.Effect<import("./api.js").SkillListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    pty: {
+        list: (input?: import("./api.js").PtyListInput) => Effect.Effect<import("./api.js").PtyListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        create: (input?: import("./api.js").PtyCreateInput) => Effect.Effect<import("./api.js").PtyCreateOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        get: (input: import("./api.js").PtyGetInput) => Effect.Effect<import("./api.js").PtyGetOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        update: (input: import("./api.js").PtyUpdateInput) => Effect.Effect<import("./api.js").PtyUpdateOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        remove: (input: import("./api.js").PtyRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        connect: {
+            token: (input: import("./api.js").PtyConnectTokenInput) => Effect.Effect<import("./api.js").PtyConnectTokenOutput, ClientError | import("@opencode/protocol/errors").ForbiddenError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+    };
+    experimental: {
+        persistentPty: {
+            read: (input: import("./api.js").ExperimentalPersistentPtyReadInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyReadOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            list: (input: import("./api.js").ExperimentalPersistentPtyListInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            create: (input: import("./api.js").ExperimentalPersistentPtyCreateInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyCreateOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            shutdown: () => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            handoff: () => Effect.Effect<import("./api.js").ExperimentalPersistentPtyHandoffOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            get: (input: import("./api.js").ExperimentalPersistentPtyGetInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyGetOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            update: (input: import("./api.js").ExperimentalPersistentPtyUpdateInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyUpdateOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            snapshot: (input: import("./api.js").ExperimentalPersistentPtySnapshotInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtySnapshotOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            remove: (input: import("./api.js").ExperimentalPersistentPtyRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            connectToken: (input: import("./api.js").ExperimentalPersistentPtyConnectTokenInput) => Effect.Effect<import("@opencode/schema/pty-ticket").ConnectToken, ClientError | import("@opencode/protocol/errors").ForbiddenError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+    };
+    shell: {
+        list: (input?: import("./api.js").ShellListInput) => Effect.Effect<import("./api.js").ShellListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        create: (input: import("./api.js").ShellCreateInput) => Effect.Effect<import("./api.js").ShellCreateOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        get: (input: import("./api.js").ShellGetInput) => Effect.Effect<import("./api.js").ShellGetOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ShellNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        output: (input: import("./api.js").ShellOutputInput) => Effect.Effect<import("./api.js").ShellOutputOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ShellNotFoundError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        remove: (input: import("./api.js").ShellRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    reference: {
+        list: (input?: import("./api.js").ReferenceListInput) => Effect.Effect<import("./api.js").ReferenceListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    worktree: {
+        list: (input: import("./api.js").WorktreeListInput) => Effect.Effect<readonly {
+            readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+            readonly strategy?: string | undefined;
+        }[], ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        create: (input: import("./api.js").WorktreeCreateInput) => Effect.Effect<import("@opencode/schema/worktree").Info, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/groups/worktree").WorktreeError, never>;
+        remove: (input: import("./api.js").WorktreeRemoveInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/groups/worktree").WorktreeError, never>;
+        refresh: (input: import("./api.js").WorktreeRefreshInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/groups/worktree").WorktreeError, never>;
+    };
+    vcs: {
+        init: (input?: import("./api.js").VcsInitInput) => Effect.Effect<void, ClientError | import("@opencode/protocol/errors").ConflictError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/groups/vcs").VcsInitNotSupportedError, never>;
+        get: (input?: import("./api.js").VcsGetInput) => Effect.Effect<import("./api.js").VcsGetOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        base: (input?: import("./api.js").VcsBaseInput) => Effect.Effect<import("./api.js").VcsBaseOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        status: (input?: import("./api.js").VcsStatusInput) => Effect.Effect<import("./api.js").VcsStatusOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        branch: {
+            list: (input?: import("./api.js").VcsBranchListInput) => Effect.Effect<import("./api.js").VcsBranchListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+        diff: (input: import("./api.js").VcsDiffInput) => Effect.Effect<import("./api.js").VcsDiffOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    debug: {
+        location: {
+            list: () => Effect.Effect<import("./api.js").DebugLocationListOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+            evict: (input?: import("./api.js").DebugLocationEvictInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+    };
+    migration: {
+        v1: {
+            status: () => Effect.Effect<import("./api.js").MigrationV1StatusOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        };
+    };
+    websearch: {
+        providers: (input?: import("./api.js").WebsearchProvidersInput) => Effect.Effect<import("./api.js").WebsearchProvidersOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        query: (input: import("./api.js").WebsearchQueryInput) => Effect.Effect<import("./api.js").WebsearchQueryOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    config: {
+        get: (input?: import("./api.js").ConfigGetInput) => Effect.Effect<import("./api.js").ConfigGetOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        shells: () => Effect.Effect<import("./api.js").ConfigShellsOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+        update: (input: import("./api.js").ConfigUpdateInput) => Effect.Effect<void, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
+    };
+    event: {
+        subscribe: () => Stream.Stream<{
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly integrationID: string & import("effect/Brand").Brand<"Integration.ID">;
-                readonly credentialID: (string & import("effect/Brand").Brand<"Credential.ID">) | null;
-            };
-            readonly type: "credential.switched";
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "integration.updated";
-            readonly created: number;
+            readonly type: "skill.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {};
-            readonly type: "provider.updated";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "model.updated";
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"Permission.ID">;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly action: string;
-                readonly resources: readonly string[];
-                readonly metadata?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-                readonly message?: string | undefined;
-                readonly save?: readonly string[] | undefined;
-                readonly source?: {
-                    readonly type: "tool";
-                    readonly messageID: string;
-                    readonly id: string;
-                } | undefined;
-            };
-            readonly type: "permission.asked";
-            readonly created: number;
+            readonly type: "credential.switched";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly requestID: string & import("effect/Brand").Brand<"Permission.ID">;
-                readonly reply: "once" | "always" | "reject";
+                readonly integrationID: string & import("effect/Brand").Brand<"Integration.ID">;
+                readonly credentialID: (string & import("effect/Brand").Brand<"Credential.ID">) | null;
             };
-            readonly type: "permission.replied";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "agent.updated";
-            readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"Project.ID">;
-                readonly canonical: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly time: {
-                    readonly created: number;
-                    readonly active: number;
-                    readonly updated: number;
-                    readonly archived?: number | undefined;
-                };
-                readonly sandboxes: readonly string[];
-                readonly name?: string | undefined;
-                readonly vcs?: string | undefined;
-                readonly icon?: {
-                    readonly url?: string | undefined;
-                    readonly color?: string | undefined;
-                    readonly override?: string | undefined;
-                } | undefined;
-                readonly commands?: {
-                    readonly start?: string | undefined;
-                } | undefined;
-            };
-            readonly type: "project.updated";
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly info: {
-                    readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
-                    readonly metadata: {
-                        readonly [x: string]: unknown;
-                    };
-                    readonly command: string;
-                    readonly status: "timeout" | "running" | "exited" | "killed";
-                    readonly time: {
-                        readonly started: number;
-                        readonly completed?: number | undefined;
-                    };
-                    readonly cwd: string;
-                    readonly shell: string;
-                    readonly file: string;
-                    readonly pid?: number | undefined;
-                    readonly exit?: number | undefined;
-                    readonly signal?: string | undefined;
-                };
-            };
-            readonly type: "shell.created";
-            readonly created: number;
+            readonly type: "credential.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
+            readonly data: {};
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
-                readonly status: "timeout" | "running" | "exited" | "killed";
-                readonly exit?: number | undefined;
-            };
-            readonly type: "shell.exited";
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
+            readonly type: "session.created";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "shell.deleted";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
                 readonly location: {
                     readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                     readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
                 };
-                readonly version: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
+                readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+                readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | undefined;
                 readonly slug: string;
-                readonly metadata?: {
-                    readonly [x: string]: import("effect/Schema").Json;
-                } | undefined;
                 readonly title?: string | undefined;
+                readonly agent?: (string & import("effect/Brand").Brand<"Agent.ID">) | undefined;
                 readonly model?: {
                     readonly id: string & import("effect/Brand").Brand<"Model.ID">;
                     readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
                     readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
                 } | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: import("effect/Schema").Json;
+                } | undefined;
                 readonly permissions?: readonly {
                     readonly action: string;
                     readonly resource: string;
-                    readonly effect: "allow" | "deny" | "ask";
+                    readonly effect: "allow" | "ask" | "deny";
                 }[] | undefined;
-                readonly agent?: (string & import("effect/Brand").Brand<"Agent.ID">) | undefined;
-                readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
-                readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | undefined;
+                readonly version: string;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.agent.selected";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.created";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly agent: string & import("effect/Brand").Brand<"Agent.ID">;
                 readonly previous?: (string & import("effect/Brand").Brand<"Agent.ID">) | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.model.selected";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.agent.selected";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly model: {
@@ -553,134 +375,168 @@ export declare const make: (options?: {
                     readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
                 } | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.moved";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.model.selected";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly location: {
                     readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                     readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
                 readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.renamed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.moved";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly title: string;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly title: string;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.metadata.updated";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.renamed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly metadata: {
                     readonly [x: string]: import("effect/Schema").Json;
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.permissions";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.metadata.updated";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly permissions: readonly {
                     readonly action: string;
                     readonly resource: string;
-                    readonly effect: "allow" | "deny" | "ask";
+                    readonly effect: "allow" | "ask" | "deny";
                 }[];
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.viewed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.permissions";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly idle: number;
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly type: "session.archived";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
-                readonly idle: number;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.unarchived";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.viewed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly type: "session.usage.updated";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly cost: number & import("effect/Brand").Brand<"Money.USD">;
                 readonly tokens: {
                     readonly input: number;
@@ -691,38 +547,42 @@ export declare const make: (options?: {
                         readonly write: number;
                     };
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
-            readonly type: "session.usage.updated";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.deleted";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.forked";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.deleted";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly parentID: string & import("effect/Brand").Brand<"SessionID">;
@@ -737,66 +597,65 @@ export declare const make: (options?: {
                     readonly [x: string & import("effect/Brand").Brand<"Instruction.Key">]: string & import("effect/Brand").Brand<"Instruction.Hash">;
                 } | undefined;
                 readonly instructionEntries?: readonly {
-                    readonly removed: boolean;
                     readonly key: string;
                     readonly value: import("effect/Schema").Json;
+                    readonly removed: boolean;
                 }[] | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.inbox.delivered";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.forked";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.inbox.enqueued";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.inbox.delivered";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly item: {
                     readonly type: "user";
                     readonly payload: {
                         readonly text: string;
-                        readonly metadata?: {
-                            readonly [x: string]: unknown;
-                        } | undefined;
                         readonly files?: readonly {
                             readonly data: string;
+                            readonly mime: string;
                             readonly source: {
                                 readonly type: "inline";
                             } | {
                                 readonly type: "uri";
                                 readonly uri: string;
                             };
-                            readonly mime: string;
-                            readonly description?: string | undefined;
                             readonly name?: string | undefined;
+                            readonly description?: string | undefined;
                             readonly mention?: {
                                 readonly start: number;
                                 readonly end: number;
@@ -821,22 +680,25 @@ export declare const make: (options?: {
                                 readonly text: string;
                             } | undefined;
                         }[] | undefined;
+                        readonly metadata?: {
+                            readonly [x: string]: unknown;
+                        } | undefined;
                     };
-                    readonly delivery: "steer" | "queue";
+                    readonly delivery: "queue" | "steer";
                 } | {
                     readonly type: "synthetic";
                     readonly payload: {
                         readonly text: string;
+                        readonly description?: string | undefined;
                         readonly metadata?: {
                             readonly [x: string]: unknown;
                         } | undefined;
-                        readonly description?: string | undefined;
                     };
-                    readonly delivery: "steer" | "queue";
+                    readonly delivery: "queue" | "steer";
                 } | {
                     readonly type: "compaction";
                     readonly payload: {};
-                    readonly delivery: "steer" | "queue";
+                    readonly delivery: "queue" | "steer";
                 } | {
                     readonly type: "move";
                     readonly payload: {
@@ -847,107 +709,106 @@ export declare const make: (options?: {
                         readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
                         readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
                     };
-                    readonly delivery: "steer" | "queue";
+                    readonly delivery: "queue" | "steer";
                 };
-                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.inbox.cancelled";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.inbox.enqueued";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.inbox.delivery.changed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.inbox.cancelled";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly delivery: "steer" | "queue";
-                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                readonly delivery: "queue" | "steer";
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.execution.started";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.inbox.delivery.changed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.execution.succeeded";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.execution.started";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.execution.failed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.execution.succeeded";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly error: {
                     readonly type: string;
                     readonly message: string;
@@ -956,168 +817,168 @@ export declare const make: (options?: {
                         readonly body: string;
                     } | undefined;
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.execution.interrupted";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.execution.failed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly reason: "user" | "shutdown" | "superseded" | "inactivity";
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly reason: "inactivity" | "shutdown" | "superseded" | "user";
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.instructions.updated";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.execution.interrupted";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly delta: {
-                    readonly [x: string]: (string & import("effect/Brand").Brand<"Instruction.Hash">) | "removed";
+                    readonly [x: string]: "removed" | (string & import("effect/Brand").Brand<"Instruction.Hash">);
                 };
                 readonly text?: string | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.synthetic";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.instructions.updated";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly text: string;
+                readonly description?: string | undefined;
                 readonly metadata?: {
                     readonly [x: string]: unknown;
                 } | undefined;
-                readonly description?: string | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.skill.activated";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.synthetic";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
                 readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
                 readonly text: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.shell.started";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.skill.activated";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly shell: {
                     readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
-                    readonly metadata: {
-                        readonly [x: string]: unknown;
-                    };
+                    readonly status: "exited" | "killed" | "running" | "timeout";
                     readonly command: string;
-                    readonly status: "timeout" | "running" | "exited" | "killed";
-                    readonly time: {
-                        readonly started: number;
-                        readonly completed?: number | undefined;
-                    };
                     readonly cwd: string;
                     readonly shell: string;
                     readonly file: string;
                     readonly pid?: number | undefined;
                     readonly exit?: number | undefined;
                     readonly signal?: string | undefined;
+                    readonly metadata: {
+                        readonly [x: string]: unknown;
+                    };
+                    readonly time: {
+                        readonly started: number;
+                        readonly completed?: number | undefined;
+                    };
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.shell.ended";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.shell.started";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly shell: {
                     readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
-                    readonly metadata: {
-                        readonly [x: string]: unknown;
-                    };
+                    readonly status: "exited" | "killed" | "running" | "timeout";
                     readonly command: string;
-                    readonly status: "timeout" | "running" | "exited" | "killed";
-                    readonly time: {
-                        readonly started: number;
-                        readonly completed?: number | undefined;
-                    };
                     readonly cwd: string;
                     readonly shell: string;
                     readonly file: string;
                     readonly pid?: number | undefined;
                     readonly exit?: number | undefined;
                     readonly signal?: string | undefined;
+                    readonly metadata: {
+                        readonly [x: string]: unknown;
+                    };
+                    readonly time: {
+                        readonly started: number;
+                        readonly completed?: number | undefined;
+                    };
                 };
                 readonly output: {
                     readonly output: string;
@@ -1125,76 +986,80 @@ export declare const make: (options?: {
                     readonly size: number;
                     readonly truncated: boolean;
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.step.started";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.shell.ended";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                readonly agent: string & import("effect/Brand").Brand<"Agent.ID">;
                 readonly model: {
                     readonly id: string & import("effect/Brand").Brand<"Model.ID">;
                     readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
                     readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
                 };
-                readonly started: number;
-                readonly agent: string & import("effect/Brand").Brand<"Agent.ID">;
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
+                readonly started: number;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.step.streamed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.step.started";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.step.ended";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.step.streamed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                readonly finish: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
+                readonly rawFinish?: string | undefined;
+                readonly native?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
                 readonly cost: number & import("effect/Brand").Brand<"Money.USD">;
-                readonly finish: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "unknown";
                 readonly tokens: {
                     readonly input: number;
                     readonly output: number;
@@ -1204,32 +1069,28 @@ export declare const make: (options?: {
                         readonly write: number;
                     };
                 };
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-                readonly files?: readonly (string & import("effect/Brand").Brand<"RelativePath">)[] | undefined;
-                readonly providerState?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
                 readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
-                readonly rawFinish?: string | undefined;
+                readonly files?: readonly (string & import("effect/Brand").Brand<"RelativePath">)[] | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.step.failed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.step.ended";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly error: {
                     readonly type: string;
                     readonly message: string;
@@ -1238,15 +1099,12 @@ export declare const make: (options?: {
                         readonly body: string;
                     } | undefined;
                 };
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-                readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
-                readonly files?: readonly (string & import("effect/Brand").Brand<"RelativePath">)[] | undefined;
-                readonly providerState?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-                readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
                 readonly finish?: "content-filter" | undefined;
                 readonly rawFinish?: string | undefined;
+                readonly native?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
                 readonly tokens?: {
                     readonly input: number;
                     readonly output: number;
@@ -1256,261 +1114,265 @@ export declare const make: (options?: {
                         readonly write: number;
                     };
                 } | undefined;
+                readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
+                readonly files?: readonly (string & import("effect/Brand").Brand<"RelativePath">)[] | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.text.started";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.step.failed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly ordinal: number;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly durable: {
-                readonly aggregateID: string;
-                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.text.started";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.text.delta";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly ordinal: number;
                 readonly delta: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
-            readonly type: "session.text.delta";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.text.ended";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly text: string;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly ordinal: number;
-                readonly state?: {
+                readonly text: string;
+                readonly native?: {
                     readonly [x: string]: unknown;
                 } | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.reasoning.started";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.text.ended";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly ordinal: number;
-                readonly state?: {
+                readonly native?: {
                     readonly [x: string]: unknown;
                 } | undefined;
             };
-            readonly durable: {
-                readonly aggregateID: string;
-                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-            };
-            readonly type: "session.reasoning.started";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.reasoning.delta";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly ordinal: number;
                 readonly delta: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
-            readonly type: "session.reasoning.delta";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.reasoning.ended";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly text: string;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly ordinal: number;
-                readonly state?: {
+                readonly text: string;
+                readonly native?: {
                     readonly [x: string]: unknown;
                 } | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.tool.input.started";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.reasoning.ended";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                readonly id: string;
+                readonly name: string;
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly type: "session.tool.input.delta";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
-                readonly name: string;
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly id: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly delta: string;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.tool.input.ended";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.tool.input.started";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly delta: string;
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly id: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly text: string;
             };
-            readonly type: "session.tool.input.delta";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly text: string;
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-                readonly id: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            };
+            readonly type: "session.tool.called";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.tool.input.ended";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly id: string;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                readonly id: string;
                 readonly input: {
                     readonly [x: string]: unknown;
                 };
                 readonly executed: boolean;
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-                readonly state?: {
+                readonly native?: {
                     readonly [x: string]: unknown;
                 } | undefined;
             };
-            readonly durable: {
-                readonly aggregateID: string;
-                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-            };
-            readonly type: "session.tool.called";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.tool.progress";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                readonly id: string;
                 readonly metadata: {
                     readonly [x: string]: import("effect/Schema").Json;
                 };
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-                readonly id: string;
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
-            readonly type: "session.tool.progress";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.tool.success";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly id: string;
                 readonly content: readonly [{
                     readonly type: "text";
@@ -1529,35 +1391,34 @@ export declare const make: (options?: {
                     readonly mime: string;
                     readonly name?: string | undefined;
                 })[]];
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly executed: boolean;
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly metadata?: {
                     readonly [x: string]: import("effect/Schema").Json;
                 } | undefined;
-                readonly resultState?: {
+                readonly executed: boolean;
+                readonly native?: {
                     readonly [x: string]: unknown;
                 } | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.tool.failed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.tool.success";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly id: string;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                readonly id: string;
                 readonly error: {
                     readonly type: string;
                     readonly message: string;
@@ -1566,11 +1427,6 @@ export declare const make: (options?: {
                         readonly body: string;
                     } | undefined;
                 };
-                readonly executed: boolean;
-                readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-                readonly metadata?: {
-                    readonly [x: string]: import("effect/Schema").Json;
-                } | undefined;
                 readonly content?: readonly [{
                     readonly type: "text";
                     readonly text: string;
@@ -1588,27 +1444,32 @@ export declare const make: (options?: {
                     readonly mime: string;
                     readonly name?: string | undefined;
                 })[]] | undefined;
-                readonly resultState?: {
+                readonly metadata?: {
+                    readonly [x: string]: import("effect/Schema").Json;
+                } | undefined;
+                readonly executed: boolean;
+                readonly native?: {
                     readonly [x: string]: unknown;
                 } | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.retry.scheduled";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.tool.failed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly attempt: number;
                 readonly at: number;
@@ -1620,75 +1481,72 @@ export declare const make: (options?: {
                         readonly body: string;
                     } | undefined;
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.compaction.started";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.retry.scheduled";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly reason: "auto" | "manual";
-                readonly recent: string;
                 readonly inputID?: (string & import("effect/Brand").Brand<"Session.Message.ID">) | undefined;
             };
-            readonly durable: {
-                readonly aggregateID: string;
-                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-            };
-            readonly type: "session.compaction.started";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.compaction.delta";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly text: string;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly text: string;
             };
-            readonly type: "session.compaction.delta";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.compaction.ended";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly text: string;
                 readonly reason: "auto" | "manual";
-                readonly recent: string;
-                readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
                 readonly model?: {
                     readonly id: string & import("effect/Brand").Brand<"Model.ID">;
                     readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
                     readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
                 } | undefined;
-                readonly providerState?: {
+                readonly native?: {
                     readonly [x: string]: unknown;
                 } | undefined;
+                readonly text: string;
+                readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
                 readonly tokens?: {
                     readonly input: number;
                     readonly output: number;
@@ -1698,37 +1556,26 @@ export declare const make: (options?: {
                         readonly write: number;
                     };
                 } | undefined;
-                readonly providerContext?: {
-                    readonly version: 1;
-                    readonly provenance: {
-                        readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
-                        readonly provider: string;
-                        readonly modelID: string;
-                        readonly route: string;
-                        readonly protocol: string;
-                        readonly endpoint: string;
-                    };
-                    readonly messages: import("effect/Schema").Json;
-                } | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.compaction.failed";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.compaction.ended";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly reason: "auto" | "manual";
                 readonly error: {
                     readonly type: string;
                     readonly message: string;
@@ -1737,7 +1584,7 @@ export declare const make: (options?: {
                         readonly body: string;
                     } | undefined;
                 };
-                readonly reason: "auto" | "manual";
+                readonly inputID?: (string & import("effect/Brand").Brand<"Session.Message.ID">) | undefined;
                 readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
                 readonly tokens?: {
                     readonly input: number;
@@ -1748,27 +1595,68 @@ export declare const make: (options?: {
                         readonly write: number;
                     };
                 } | undefined;
-                readonly inputID?: (string & import("effect/Brand").Brand<"Session.Message.ID">) | undefined;
             };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.revert.cleared";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.compaction.failed";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
+            readonly type: "session.revert.committed";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly to: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            };
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.revert.staged";
+            readonly durable: {
+                readonly aggregateID: string;
+                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+            };
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly revert: {
                     readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+                    readonly partID?: string | undefined;
+                    readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
                     readonly files?: readonly {
                         readonly file: string;
                         readonly patch: string;
@@ -1776,758 +1664,895 @@ export declare const make: (options?: {
                         readonly deletions: number;
                         readonly status: "added" | "deleted" | "modified";
                     }[] | undefined;
-                    readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
-                    readonly partID?: string | undefined;
                 };
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly durable: {
-                readonly aggregateID: string;
-                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "session.revert.staged";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "command.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {};
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
+            readonly type: "config.updated";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {};
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "mcp.resources.changed";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly server: string;
             };
-            readonly durable: {
-                readonly aggregateID: string;
-                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "mcp.status.changed";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {
+                readonly server: string;
             };
-            readonly type: "session.revert.cleared";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "plugin.updated";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {};
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "tui.command.execute";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly command: string;
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
+            readonly type: "tui.prompt.append";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {
+                readonly text: string;
+            };
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "tui.session.select";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
-                readonly to: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
             };
-            readonly durable: {
-                readonly aggregateID: string;
-                readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-                readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "tui.toast.show";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {
+                readonly title?: string | undefined;
+                readonly message: string;
+                readonly variant: "error" | "info" | "success" | "warning";
+                readonly duration: number;
             };
-            readonly type: "session.revert.committed";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "location.shutdown";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {};
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "models-dev.refreshed";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {};
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
+            readonly type: "integration.updated";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {};
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "provider.updated";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {};
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "model.updated";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {};
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly file: string;
-                readonly event: "add" | "change" | "unlink";
-            };
-            readonly type: "filesystem.changed";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "agent.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {};
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
+            readonly type: "filesystem.changed";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
+            readonly data: {
+                readonly file: string;
+                readonly event: "add" | "change" | "unlink";
+            };
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "command.updated";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "reference.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
+            readonly data: {};
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "websearch.updated";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "permission.asked";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly action: string;
+                readonly resources: readonly string[];
+                readonly save?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly source?: {
+                    readonly type: "tool";
+                    readonly messageID: string;
+                    readonly id: string;
+                } | undefined;
+                readonly message?: string | undefined;
+                readonly id: string & import("effect/Brand").Brand<"Permission.ID">;
+            };
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "config.updated";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "permission.replied";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly requestID: string & import("effect/Brand").Brand<"Permission.ID">;
+                readonly reply: "always" | "once" | "reject";
             };
-            readonly type: "worktree.updated";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "project.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly id: string & import("effect/Brand").Brand<"Project.ID">;
+                readonly canonical: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly vcs?: string | undefined;
+                readonly name?: string | undefined;
+                readonly icon?: {
+                    readonly url?: string | undefined;
+                    readonly override?: string | undefined;
+                    readonly color?: string | undefined;
+                } | undefined;
+                readonly commands?: {
+                    readonly start?: string | undefined;
+                } | undefined;
+                readonly time: {
+                    readonly created: number;
+                    readonly updated: number;
+                    readonly active: number;
+                    readonly archived?: number | undefined;
+                };
+                readonly sandboxes: readonly string[];
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
-                readonly previous: string & import("effect/Brand").Brand<"Project.ID">;
-                readonly adopted?: readonly (string & import("effect/Brand").Brand<"Project.ID">)[] | undefined;
-            };
+            readonly type: "worktree.resolved";
             readonly durable: {
                 readonly aggregateID: string;
                 readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
                 readonly version: number & import("effect/Brand").Brand<"Event.Version">;
             };
-            readonly type: "worktree.resolved";
-            readonly created: number;
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly version: string;
+                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly previous: string & import("effect/Brand").Brand<"Project.ID">;
+                readonly adopted?: readonly (string & import("effect/Brand").Brand<"Project.ID">)[] | undefined;
             };
-            readonly type: "installation.updated";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "worktree.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly version: string;
+                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
             };
-            readonly type: "installation.update-available";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "pty.created";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
+            readonly data: {
+                readonly info: {
+                    readonly id: string & import("effect/Brand").Brand<"PtyID">;
+                    readonly title: string;
+                    readonly command: string;
+                    readonly args: readonly string[];
+                    readonly cwd: string;
+                    readonly status: "exited" | "running";
+                    readonly pid: number;
+                    readonly exitCode?: number | undefined;
+                };
+            };
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "location.shutdown";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "pty.deleted";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly server: string;
+                readonly id: string & import("effect/Brand").Brand<"PtyID">;
             };
-            readonly type: "mcp.resources.changed";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "pty.exited";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly server: string;
+                readonly id: string & import("effect/Brand").Brand<"PtyID">;
+                readonly exitCode: number;
             };
-            readonly type: "mcp.status.changed";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "pty.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
+            readonly data: {
+                readonly info: {
+                    readonly id: string & import("effect/Brand").Brand<"PtyID">;
+                    readonly title: string;
+                    readonly command: string;
+                    readonly args: readonly string[];
+                    readonly cwd: string;
+                    readonly status: "exited" | "running";
+                    readonly pid: number;
+                    readonly exitCode?: number | undefined;
+                };
+            };
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "models-dev.refreshed";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "persistent-pty.added";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly info: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly terminal: {
                     readonly id: string & import("effect/Brand").Brand<"PtyID">;
-                    readonly command: string;
                     readonly title: string;
-                    readonly status: "running" | "exited";
-                    readonly pid: number;
-                    readonly cwd: string;
+                    readonly command: string;
                     readonly args: readonly string[];
+                    readonly cwd: string;
+                    readonly status: "exited" | "running";
+                    readonly pid: number;
                     readonly exitCode?: number | undefined;
+                    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                    readonly foregroundProcess: string | null;
+                    readonly size: {
+                        readonly cols: number;
+                        readonly rows: number;
+                    };
+                    readonly output: {
+                        readonly head: number;
+                        readonly tail: number;
+                    };
                 };
             };
-            readonly type: "pty.created";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "persistent-pty.removed";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+                readonly ptyID: string & import("effect/Brand").Brand<"PtyID">;
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly type: "shell.created";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
                 readonly info: {
-                    readonly id: string & import("effect/Brand").Brand<"PtyID">;
+                    readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
+                    readonly status: "exited" | "killed" | "running" | "timeout";
                     readonly command: string;
-                    readonly title: string;
-                    readonly status: "running" | "exited";
-                    readonly pid: number;
                     readonly cwd: string;
-                    readonly args: readonly string[];
-                    readonly exitCode?: number | undefined;
+                    readonly shell: string;
+                    readonly file: string;
+                    readonly pid?: number | undefined;
+                    readonly exit?: number | undefined;
+                    readonly signal?: string | undefined;
+                    readonly metadata: {
+                        readonly [x: string]: unknown;
+                    };
+                    readonly time: {
+                        readonly started: number;
+                        readonly completed?: number | undefined;
+                    };
                 };
             };
-            readonly type: "pty.updated";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "shell.deleted";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"PtyID">;
-                readonly exitCode: number;
+                readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
             };
-            readonly type: "pty.exited";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "shell.exited";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly id: string & import("effect/Brand").Brand<"PtyID">;
+                readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
+                readonly exit?: number | undefined;
+                readonly status: "exited" | "killed" | "running" | "timeout";
             };
-            readonly type: "pty.deleted";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "form.cancelled";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
+            readonly data: {
+                readonly id: string & import("effect/Brand").Brand<"Form.ID">;
+                readonly sessionID: string;
+            };
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly created: number;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly type: "form.created";
+            readonly location?: {
+                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+            } | undefined;
             readonly data: {
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly terminal: {
-                    readonly id: string & import("effect/Brand").Brand<"PtyID">;
-                    readonly size: {
-                        readonly cols: number;
-                        readonly rows: number;
-                    };
-                    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                    readonly command: string;
+                readonly form: {
+                    readonly id: string & import("effect/Brand").Brand<"Form.ID">;
+                    readonly sessionID: string;
                     readonly title: string;
-                    readonly status: "running" | "exited";
-                    readonly output: {
-                        readonly head: number;
-                        readonly tail: number;
-                    };
-                    readonly pid: number;
-                    readonly cwd: string;
-                    readonly args: readonly string[];
-                    readonly foregroundProcess: string | null;
-                    readonly exitCode?: number | undefined;
+                    readonly metadata?: {
+                        readonly [x: string]: unknown;
+                    } | undefined;
+                    readonly fields: readonly [{
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "string";
+                        readonly format?: "date" | "date-time" | "email" | "uri" | undefined;
+                        readonly minLength?: number | undefined;
+                        readonly maxLength?: number | undefined;
+                        readonly pattern?: string | undefined;
+                        readonly placeholder?: string | undefined;
+                        readonly default?: string | undefined;
+                        readonly options?: readonly {
+                            readonly value: string;
+                            readonly label: string;
+                            readonly description?: string | undefined;
+                        }[] | undefined;
+                        readonly custom?: boolean | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "number";
+                        readonly minimum?: number | undefined;
+                        readonly maximum?: number | undefined;
+                        readonly default?: number | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "integer";
+                        readonly minimum?: number | undefined;
+                        readonly maximum?: number | undefined;
+                        readonly default?: number | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "boolean";
+                        readonly default?: boolean | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "multiselect";
+                        readonly options: readonly {
+                            readonly value: string;
+                            readonly label: string;
+                            readonly description?: string | undefined;
+                        }[];
+                        readonly minItems?: number | undefined;
+                        readonly maxItems?: number | undefined;
+                        readonly custom?: boolean | undefined;
+                        readonly default?: readonly string[] | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly type: "external";
+                        readonly url: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                    }, ...({
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "string";
+                        readonly format?: "date" | "date-time" | "email" | "uri" | undefined;
+                        readonly minLength?: number | undefined;
+                        readonly maxLength?: number | undefined;
+                        readonly pattern?: string | undefined;
+                        readonly placeholder?: string | undefined;
+                        readonly default?: string | undefined;
+                        readonly options?: readonly {
+                            readonly value: string;
+                            readonly label: string;
+                            readonly description?: string | undefined;
+                        }[] | undefined;
+                        readonly custom?: boolean | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "number";
+                        readonly minimum?: number | undefined;
+                        readonly maximum?: number | undefined;
+                        readonly default?: number | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "integer";
+                        readonly minimum?: number | undefined;
+                        readonly maximum?: number | undefined;
+                        readonly default?: number | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "boolean";
+                        readonly default?: boolean | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly hidden?: boolean | undefined;
+                        readonly when?: readonly {
+                            readonly key: string;
+                            readonly op: "eq" | "neq";
+                            readonly value: string | number | boolean;
+                        }[] | undefined;
+                        readonly type: "multiselect";
+                        readonly options: readonly {
+                            readonly value: string;
+                            readonly label: string;
+                            readonly description?: string | undefined;
+                        }[];
+                        readonly minItems?: number | undefined;
+                        readonly maxItems?: number | undefined;
+                        readonly custom?: boolean | undefined;
+                        readonly default?: readonly string[] | undefined;
+                    } | {
+                        readonly key: string;
+                        readonly type: "external";
+                        readonly url: string;
+                        readonly title?: string | undefined;
+                        readonly description?: string | undefined;
+                    })[]];
                 };
             };
-            readonly type: "persistent-pty.added";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "form.replied";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-                readonly ptyID: string & import("effect/Brand").Brand<"PtyID">;
+                readonly id: string & import("effect/Brand").Brand<"Form.ID">;
+                readonly sessionID: string;
+                readonly answer: {
+                    readonly [x: string]: string | number | boolean | readonly string[];
+                };
             };
-            readonly type: "persistent-pty.removed";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "websearch.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
+            readonly data: {};
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "plugin.updated";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.idle";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
+            readonly data: {
+                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            };
         } | {
             readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "reference.updated";
             readonly created: number;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly type: "session.status";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
                 readonly status: {
                     readonly type: "idle";
                 } | {
                     readonly type: "retry";
-                    readonly message: string;
                     readonly attempt: number;
-                    readonly next: number;
+                    readonly message: string;
                     readonly action?: {
+                        readonly reason: string;
+                        readonly provider: string;
+                        readonly title: string;
                         readonly message: string;
                         readonly label: string;
-                        readonly title: string;
-                        readonly provider: string;
-                        readonly reason: string;
                         readonly link?: string | undefined;
                     } | undefined;
+                    readonly next: number;
                 } | {
                     readonly type: "busy";
                 };
             };
-            readonly type: "session.status";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly type: "session.idle";
-            readonly created: number;
+            readonly type: "installation.update-available";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly text: string;
+                readonly version: string;
             };
-            readonly type: "tui.prompt.append";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly command: string;
-            };
-            readonly type: "tui.command.execute";
-            readonly created: number;
+            readonly type: "installation.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
-                readonly message: string;
-                readonly variant: "error" | "info" | "success" | "warning";
-                readonly duration: number;
-                readonly title?: string | undefined;
+                readonly version: string;
             };
-            readonly type: "tui.toast.show";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {
-                readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly type: "tui.session.select";
-            readonly created: number;
+            readonly type: "vcs.branch.updated";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly data: {
                 readonly branch?: string | undefined;
             };
-            readonly type: "vcs.branch.updated";
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly created: number;
-            readonly location?: {
-                readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-                readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-            } | undefined;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+            readonly type: `rpc.${string}`;
             readonly location: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
             };
             readonly data: {
                 readonly [x: string]: unknown;
             };
-            readonly type: `rpc.${string}`;
-            readonly created: number;
+        } | {
+            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-        } | {
-            readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-            readonly data: {};
-            readonly type: "server.connected";
             readonly location?: {
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
             } | undefined;
-            readonly metadata?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        }, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError | import("effect/encoding/Sse").Retry | import("effect/encoding/Sse").SseError, never>;
-    };
-    rpc: RpcClientRuntime.RpcApi<import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | import("@opencode/schema/rpc").SystemError | ClientError | import("effect/http/HttpClientError").HttpClientError, RpcCallOptions, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError | import("effect/encoding/Sse").Retry | import("effect/encoding/Sse").SseError> & {
-        call: (input: import("./api.js").RpcCallInput) => Effect.Effect<import("./api.js").RpcCallOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").RpcError | import("@opencode/protocol/errors").RpcInternalError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    server: {
-        info: () => Effect.Effect<import("./api.js").ServerInfoOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        pair: () => Effect.Effect<import("./api.js").ServerPairOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        connect: (input: import("./api.js").ServerConnectInput) => Effect.Effect<import("./api.js").ServerConnectOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    location: {
-        get: (input?: import("./api.js").LocationGetInput) => Effect.Effect<import("@opencode/schema/location").PublicInfo, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        reload: () => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    agent: {
-        list: (input?: import("./api.js").AgentListInput) => Effect.Effect<import("./api.js").AgentListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input: import("./api.js").AgentGetInput) => Effect.Effect<import("./api.js").AgentGetOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").AgentNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    plugin: {
-        list: (input?: import("./api.js").PluginListInput) => Effect.Effect<import("./api.js").PluginListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        check: (input?: import("./api.js").PluginCheckInput) => Effect.Effect<import("./api.js").PluginCheckOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        update: (input: import("./api.js").PluginUpdateInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    session: {
-        list: (input?: import("./api.js").SessionListInput) => Effect.Effect<import("./api.js").SessionListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").InvalidCursorError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        stats: (input?: import("./api.js").SessionStatsInput) => Effect.Effect<import("./api.js").SessionStatsOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        create: (input?: import("./api.js").SessionCreateInput) => Effect.Effect<import("@opencode/schema/session").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        import: (input: import("./api.js").SessionImportInput) => Effect.Effect<import("@opencode/schema/session").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        export: (input: import("./api.js").SessionExportInput) => Effect.Effect<import("./api.js").SessionExportOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        active: () => Effect.Effect<import("./api.js").SessionActiveOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input: import("./api.js").SessionGetInput) => Effect.Effect<import("@opencode/schema/session").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        remove: (input: import("./api.js").SessionRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        fork: (input: import("./api.js").SessionForkInput) => Effect.Effect<import("@opencode/schema/session").Info, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        switchAgent: (input: import("./api.js").SessionSwitchAgentInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        switchModel: (input: import("./api.js").SessionSwitchModelInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        update: (input: import("./api.js").SessionUpdateInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        move: (input: import("./api.js").SessionMoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        prompt: (input: import("./api.js").SessionPromptInput) => Effect.Effect<import("@opencode/schema/session-inbox").User, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        command: (input: import("./api.js").SessionCommandInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").CommandNotFoundError | import("@opencode/protocol/errors").CommandExecutionError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        skill: (input: import("./api.js").SessionSkillInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").SkillNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        synthetic: (input: import("./api.js").SessionSyntheticInput) => Effect.Effect<import("@opencode/schema/session-inbox").Synthetic, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        shell: (input: import("./api.js").SessionShellInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        compact: (input: import("./api.js").SessionCompactInput) => Effect.Effect<import("@opencode/schema/session-inbox").Compaction, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        wait: (input: import("./api.js").SessionWaitInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        revert: {
-            stage: (input: import("./api.js").SessionRevertStageInput) => Effect.Effect<import("@opencode/schema/session-revert").Revert, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionBusyError | import("@opencode/protocol/errors").UnknownError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            clear: (input: import("./api.js").SessionRevertClearInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionBusyError | import("@opencode/protocol/errors").UnknownError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            commit: (input: import("./api.js").SessionRevertCommitInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionBusyError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        context: (input: import("./api.js").SessionContextInput) => Effect.Effect<import("./api.js").SessionContextOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        diff: (input: import("./api.js").SessionDiffInput) => Effect.Effect<import("./api.js").SessionDiffOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        inbox: {
-            list: (input: import("./api.js").SessionInboxListInput) => Effect.Effect<import("./api.js").SessionInboxListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            cancel: (input: import("./api.js").SessionInboxCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            update: (input: import("./api.js").SessionInboxUpdateInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        instructions: {
-            entry: {
-                list: (input: import("./api.js").SessionInstructionsEntryListInput) => Effect.Effect<import("./api.js").SessionInstructionsEntryListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-                put: (input: import("./api.js").SessionInstructionsEntryPutInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/schema/instruction-entry").ValueTooLargeError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-                remove: (input: import("./api.js").SessionInstructionsEntryRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            };
-        };
-        generate: (input: import("./api.js").SessionGenerateInput) => Effect.Effect<import("./api.js").SessionGenerateOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        log: (input: import("./api.js").SessionLogInput) => Stream.Stream<import("./api.js").SessionLogOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError | import("effect/encoding/Sse").Retry | import("effect/encoding/Sse").SseError, never>;
-        interrupt: (input: import("./api.js").SessionInterruptInput) => Effect.Effect<import("./api.js").SessionInterruptOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        background: (input: import("./api.js").SessionBackgroundInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        message: {
-            get: (input: import("./api.js").SessionMessageGetInput) => Effect.Effect<import("@opencode/schema/session-message").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").MessageNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        form: {
-            list: (input: import("./api.js").SessionFormListInput) => Effect.Effect<import("./api.js").SessionFormListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            create: (input: import("./api.js").SessionFormCreateInput) => Effect.Effect<import("@opencode/schema/form").Info, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            get: (input: import("./api.js").SessionFormGetInput) => Effect.Effect<import("@opencode/schema/form").Detail, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").FormNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            reply: (input: import("./api.js").SessionFormReplyInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").FormNotFoundError | import("@opencode/protocol/errors").FormAlreadySettledError | import("@opencode/protocol/errors").FormInvalidAnswerError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            cancel: (input: import("./api.js").SessionFormCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").FormNotFoundError | import("@opencode/protocol/errors").FormAlreadySettledError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        environment: (input: import("./api.js").SessionEnvironmentInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        view: (input: import("./api.js").SessionViewInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    message: {
-        list: (input: import("./api.js").MessageListInput) => Effect.Effect<import("./api.js").MessageListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").UnknownError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").InvalidCursorError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    model: {
-        list: (input?: import("./api.js").ModelListInput) => Effect.Effect<import("./api.js").ModelListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        default: (input?: import("./api.js").ModelDefaultInput) => Effect.Effect<import("./api.js").ModelDefaultOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    generate: {
-        text: (input: import("./api.js").GenerateTextInput) => Effect.Effect<import("./api.js").GenerateTextOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    voice: {
-        session: (input: import("./api.js").VoiceSessionInput) => Effect.Effect<import("./api.js").VoiceSessionOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    provider: {
-        list: (input?: import("./api.js").ProviderListInput) => Effect.Effect<import("./api.js").ProviderListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input: import("./api.js").ProviderGetInput) => Effect.Effect<import("./api.js").ProviderGetOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").ProviderNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    integration: {
-        list: (input?: import("./api.js").IntegrationListInput) => Effect.Effect<import("./api.js").IntegrationListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input: import("./api.js").IntegrationGetInput) => Effect.Effect<import("./api.js").IntegrationGetOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        wellknown: {
-            add: (input: import("./api.js").IntegrationWellknownAddInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        connect: {
-            key: (input: import("./api.js").IntegrationConnectKeyInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            external: (input: import("./api.js").IntegrationConnectExternalInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        oauth: {
-            connect: (input: import("./api.js").IntegrationOauthConnectInput) => Effect.Effect<import("./api.js").IntegrationOauthConnectOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            status: (input: import("./api.js").IntegrationOauthStatusInput) => Effect.Effect<import("./api.js").IntegrationOauthStatusOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            complete: (input: import("./api.js").IntegrationOauthCompleteInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            cancel: (input: import("./api.js").IntegrationOauthCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        command: {
-            connect: (input: import("./api.js").IntegrationCommandConnectInput) => Effect.Effect<import("./api.js").IntegrationCommandConnectOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationMethodNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            status: (input: import("./api.js").IntegrationCommandStatusInput) => Effect.Effect<import("./api.js").IntegrationCommandStatusOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            cancel: (input: import("./api.js").IntegrationCommandCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-    };
-    mcp: {
-        list: (input?: import("./api.js").McpListInput) => Effect.Effect<import("./api.js").McpListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        add: (input: import("./api.js").McpAddInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        remove: (input: import("./api.js").McpRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").McpServerNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        connect: (input: import("./api.js").McpConnectInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").McpServerNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        disconnect: (input: import("./api.js").McpDisconnectInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").McpServerNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        resource: {
-            catalog: (input?: import("./api.js").McpResourceCatalogInput) => Effect.Effect<import("./api.js").McpResourceCatalogOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-    };
-    credential: {
-        list: () => Effect.Effect<import("./api.js").CredentialListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        create: (input: import("./api.js").CredentialCreateInput) => Effect.Effect<import("@opencode/schema/credential").Entry, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        update: (input: import("./api.js").CredentialUpdateInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        activate: (input: import("./api.js").CredentialActivateInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        remove: (input: import("./api.js").CredentialRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    project: {
-        list: (input?: import("./api.js").ProjectListInput) => Effect.Effect<import("./api.js").ProjectListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        update: (input: import("./api.js").ProjectUpdateInput) => Effect.Effect<import("@opencode/schema/project").Info, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    form: {
-        list: (input?: import("./api.js").FormListInput) => Effect.Effect<import("./api.js").FormListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    permission: {
-        request: {
-            list: (input?: import("./api.js").PermissionRequestListInput) => Effect.Effect<import("./api.js").PermissionRequestListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        saved: {
-            list: (input?: import("./api.js").PermissionSavedListInput) => Effect.Effect<import("./api.js").PermissionSavedListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            remove: (input: import("./api.js").PermissionSavedRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        create: (input: import("./api.js").PermissionCreateInput) => Effect.Effect<import("./api.js").PermissionCreateOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        list: (input: import("./api.js").PermissionListInput) => Effect.Effect<import("./api.js").PermissionListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input: import("./api.js").PermissionGetInput) => Effect.Effect<import("@opencode/schema/permission").Request, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").PermissionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        reply: (input: import("./api.js").PermissionReplyInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").SessionNotFoundError | import("@opencode/protocol/errors").PermissionNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    file: {
-        list: (input?: import("./api.js").FileListInput) => Effect.Effect<import("./api.js").FileListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").FileNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        find: (input: import("./api.js").FileFindInput) => Effect.Effect<import("./api.js").FileFindOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    command: {
-        list: (input?: import("./api.js").CommandListInput) => Effect.Effect<import("./api.js").CommandListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    skill: {
-        list: (input?: import("./api.js").SkillListInput) => Effect.Effect<import("./api.js").SkillListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    pty: {
-        list: (input?: import("./api.js").PtyListInput) => Effect.Effect<import("./api.js").PtyListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        create: (input?: import("./api.js").PtyCreateInput) => Effect.Effect<import("./api.js").PtyCreateOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input: import("./api.js").PtyGetInput) => Effect.Effect<import("./api.js").PtyGetOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        update: (input: import("./api.js").PtyUpdateInput) => Effect.Effect<import("./api.js").PtyUpdateOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        remove: (input: import("./api.js").PtyRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        connect: {
-            token: (input: import("./api.js").PtyConnectTokenInput) => Effect.Effect<import("./api.js").PtyConnectTokenOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ForbiddenError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-    };
-    experimental: {
-        persistentPty: {
-            read: (input: import("./api.js").ExperimentalPersistentPtyReadInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyReadOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            list: (input: import("./api.js").ExperimentalPersistentPtyListInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            create: (input: import("./api.js").ExperimentalPersistentPtyCreateInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyCreateOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            shutdown: () => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            handoff: () => Effect.Effect<import("./api.js").ExperimentalPersistentPtyHandoffOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            get: (input: import("./api.js").ExperimentalPersistentPtyGetInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyGetOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            update: (input: import("./api.js").ExperimentalPersistentPtyUpdateInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtyUpdateOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            snapshot: (input: import("./api.js").ExperimentalPersistentPtySnapshotInput) => Effect.Effect<import("./api.js").ExperimentalPersistentPtySnapshotOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            remove: (input: import("./api.js").ExperimentalPersistentPtyRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            connectToken: (input: import("./api.js").ExperimentalPersistentPtyConnectTokenInput) => Effect.Effect<import("@opencode/schema/pty-ticket").ConnectToken, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("@opencode/protocol/errors").ForbiddenError | import("@opencode/protocol/errors").PtyNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-    };
-    shell: {
-        list: (input?: import("./api.js").ShellListInput) => Effect.Effect<import("./api.js").ShellListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        create: (input: import("./api.js").ShellCreateInput) => Effect.Effect<import("./api.js").ShellCreateOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input: import("./api.js").ShellGetInput) => Effect.Effect<import("./api.js").ShellGetOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ShellNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        output: (input: import("./api.js").ShellOutputInput) => Effect.Effect<import("./api.js").ShellOutputOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ShellNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        remove: (input: import("./api.js").ShellRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    reference: {
-        list: (input?: import("./api.js").ReferenceListInput) => Effect.Effect<import("./api.js").ReferenceListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    worktree: {
-        list: (input: import("./api.js").WorktreeListInput) => Effect.Effect<readonly {
-            readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-            readonly strategy?: string | undefined;
-        }[], import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        create: (input: import("./api.js").WorktreeCreateInput) => Effect.Effect<import("@opencode/schema/worktree").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        remove: (input: import("./api.js").WorktreeRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        refresh: (input: import("./api.js").WorktreeRefreshInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    vcs: {
-        init: (input?: import("./api.js").VcsInitInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ConflictError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/vcs").VcsInitNotSupportedError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        get: (input?: import("./api.js").VcsGetInput) => Effect.Effect<import("./api.js").VcsGetOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        base: (input?: import("./api.js").VcsBaseInput) => Effect.Effect<import("./api.js").VcsBaseOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        status: (input?: import("./api.js").VcsStatusInput) => Effect.Effect<import("./api.js").VcsStatusOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        branch: {
-            list: (input?: import("./api.js").VcsBranchListInput) => Effect.Effect<import("./api.js").VcsBranchListOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-        diff: (input: import("./api.js").VcsDiffInput) => Effect.Effect<import("./api.js").VcsDiffOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-    };
-    debug: {
-        location: {
-            list: () => Effect.Effect<import("./api.js").DebugLocationListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-            evict: (input?: import("./api.js").DebugLocationEvictInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-    };
-    migration: {
-        v1: {
-            status: () => Effect.Effect<import("./api.js").MigrationV1StatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        };
-    };
-    websearch: {
-        providers: (input?: import("./api.js").WebsearchProvidersInput) => Effect.Effect<import("./api.js").WebsearchProvidersOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        query: (input: import("./api.js").WebsearchQueryInput) => Effect.Effect<import("./api.js").WebsearchQueryOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ServiceUnavailableError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
+            readonly type: "server.connected";
+            readonly data: {};
+        }, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/encoding/Sse").Retry | import("effect/Schema").SchemaError | import("effect/encoding/Sse").SseError | import("@opencode/protocol/errors").UnauthorizedError, never>;
     };
-    config: {
-        get: (input?: import("./api.js").ConfigGetInput) => Effect.Effect<import("./api.js").ConfigGetOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        shells: () => Effect.Effect<import("./api.js").ConfigShellsOutput, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
-        update: (input: import("./api.js").ConfigUpdateInput) => Effect.Effect<void, import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/http/HttpClientError").HttpClientError, never>;
+    rpc: RpcClientRuntime.RpcApi<ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("effect/Schema").SchemaError | import("@opencode/schema/rpc").SystemError | import("@opencode/protocol/errors").UnauthorizedError, RpcCallOptions, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("effect/encoding/Sse").Retry | import("effect/Schema").SchemaError | import("effect/encoding/Sse").SseError | import("@opencode/protocol/errors").UnauthorizedError> & {
+        call: (input: import("./api.js").RpcCallInput) => Effect.Effect<import("./api.js").RpcCallOutput, ClientError | import("effect/http/HttpClientError").HttpClientError | import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").LocationNotFoundError | import("@opencode/protocol/errors").RpcError | import("@opencode/protocol/errors").RpcInternalError | import("effect/Schema").SchemaError | import("@opencode/protocol/errors").UnauthorizedError, never>;
     };
 }, never, HttpClient.HttpClient>;