@opencode-ai/client 0.0.0-next-16234 → 0.0.0-next-16273

package/dist/effect/api/api.d.ts

@@ -1,282 +1,1130 @@
 import type { Effect, Stream } from "effect";
-import type { HttpApiClient } from "effect/unstable/httpapi";
-import type { ClientApi } from "../../contract";
-type RawClient = HttpApiClient.ForApi<typeof ClientApi>;
-type EffectValue<A> = A extends Effect.Effect<infer Success, any, any> ? Success : never;
-type StreamValue<A> = A extends Stream.Stream<infer Success, any, any> ? Success : never;
-export type Endpoint0_0Output = EffectValue<ReturnType<RawClient["server.health"]["health.get"]>>;
+import type { Location } from "@opencode-ai/schema/location";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Plugin } from "@opencode-ai/schema/plugin";
+import type { Workspace } from "@opencode-ai/schema/workspace";
+import type { Session } from "@opencode-ai/schema/session";
+import type { AbsolutePath } from "@opencode-ai/schema/schema";
+import type { Project } from "@opencode-ai/schema/project";
+import type { RelativePath } from "@opencode-ai/schema/schema";
+import type { Brand } from "effect";
+import type { Model } from "@opencode-ai/schema/model";
+import type { SessionMessage } from "@opencode-ai/schema/session-message";
+import type { PromptInput } from "@opencode-ai/schema/prompt-input";
+import type { AgentAttachment } from "@opencode-ai/schema/prompt";
+import type { SessionPending } from "@opencode-ai/schema/session-pending";
+import type { Skill } from "@opencode-ai/schema/skill";
+import type { Event } from "@opencode-ai/schema/event";
+import type { InstructionEntry } from "@opencode-ai/schema/instruction-entry";
+import type { Schema } from "effect";
+import type { EventLog } from "@opencode-ai/schema/event-log";
+import type { Shell } from "@opencode-ai/schema/shell";
+import type { DateTime } from "effect";
+import type { Provider } from "@opencode-ai/schema/provider";
+import type { Integration } from "@opencode-ai/schema/integration";
+import type { Mcp } from "@opencode-ai/schema/mcp";
+import type { Credential } from "@opencode-ai/schema/credential";
+import type { Form } from "@opencode-ai/schema/form";
+import type { Permission } from "@opencode-ai/schema/permission";
+import type { PermissionSaved } from "@opencode-ai/schema/permission-saved";
+import type { FileSystem } from "@opencode-ai/schema/filesystem";
+import type { Command } from "@opencode-ai/schema/command";
+import type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event";
+import type { Pty } from "@opencode-ai/schema/pty";
+import type { Question } from "@opencode-ai/schema/question";
+import type { Reference } from "@opencode-ai/schema/reference";
+import type { ProjectCopy } from "@opencode-ai/schema/project-copy";
+import type { Vcs } from "@opencode-ai/schema/vcs";
+import type { FileDiff } from "@opencode-ai/schema/file-diff";
+import type { WebSearch } from "@opencode-ai/schema/websearch";
+export type Endpoint0_0Output = {
+    readonly healthy: true;
+    readonly version: string;
+    readonly pid: number;
+};
 export type HealthGetOperation<E = never> = () => Effect.Effect<Endpoint0_0Output, E>;
-type Endpoint0_1Request = Parameters<RawClient["server.health"]["health.stop"]>[0];
 export type Endpoint0_1Input = {
-    readonly instanceID: Endpoint0_1Request["payload"]["instanceID"];
+    readonly instanceID: string;
+};
+export type Endpoint0_1Output = {
+    readonly accepted: boolean;
 };
-export type Endpoint0_1Output = EffectValue<ReturnType<RawClient["server.health"]["health.stop"]>>;
 export type HealthStopOperation<E = never> = (input: Endpoint0_1Input) => Effect.Effect<Endpoint0_1Output, E>;
 export interface HealthApi<E = never> {
     readonly get: HealthGetOperation<E>;
     readonly stop: HealthStopOperation<E>;
 }
-export type Endpoint1_0Output = EffectValue<ReturnType<RawClient["server.server"]["server.get"]>>;
+export type Endpoint1_0Output = {
+    readonly urls: ReadonlyArray<string>;
+};
 export type ServerGetOperation<E = never> = () => Effect.Effect<Endpoint1_0Output, E>;
 export interface ServerApi<E = never> {
     readonly get: ServerGetOperation<E>;
 }
-type Endpoint2_0Request = Parameters<RawClient["server.location"]["location.get"]>[0];
 export type Endpoint2_0Input = {
-    readonly location?: Endpoint2_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint2_0Output = EffectValue<ReturnType<RawClient["server.location"]["location.get"]>>;
+export type Endpoint2_0Output = Location.Info;
 export type LocationGetOperation<E = never> = (input?: Endpoint2_0Input) => Effect.Effect<Endpoint2_0Output, E>;
 export interface LocationApi<E = never> {
     readonly get: LocationGetOperation<E>;
 }
-type Endpoint3_0Request = Parameters<RawClient["server.agent"]["agent.list"]>[0];
 export type Endpoint3_0Input = {
-    readonly location?: Endpoint3_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint3_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Agent.Info>;
 };
-export type Endpoint3_0Output = EffectValue<ReturnType<RawClient["server.agent"]["agent.list"]>>;
 export type AgentListOperation<E = never> = (input?: Endpoint3_0Input) => Effect.Effect<Endpoint3_0Output, E>;
+export type Endpoint3_1Input = {
+    readonly agentID: Agent.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint3_1Output = {
+    readonly location: Location.Info;
+    readonly data: Agent.Info;
+};
+export type AgentGetOperation<E = never> = (input: Endpoint3_1Input) => Effect.Effect<Endpoint3_1Output, E>;
 export interface AgentApi<E = never> {
     readonly list: AgentListOperation<E>;
+    readonly get: AgentGetOperation<E>;
 }
-type Endpoint4_0Request = Parameters<RawClient["server.plugin"]["plugin.list"]>[0];
 export type Endpoint4_0Input = {
-    readonly location?: Endpoint4_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint4_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Plugin.Info>;
 };
-export type Endpoint4_0Output = EffectValue<ReturnType<RawClient["server.plugin"]["plugin.list"]>>;
 export type PluginListOperation<E = never> = (input?: Endpoint4_0Input) => Effect.Effect<Endpoint4_0Output, E>;
 export interface PluginApi<E = never> {
     readonly list: PluginListOperation<E>;
 }
-type Endpoint5_0Request = Parameters<RawClient["server.session"]["session.list"]>[0];
 export type Endpoint5_0Input = {
-    readonly workspace?: Endpoint5_0Request["query"]["workspace"];
-    readonly limit?: Endpoint5_0Request["query"]["limit"];
-    readonly order?: Endpoint5_0Request["query"]["order"];
-    readonly search?: Endpoint5_0Request["query"]["search"];
-    readonly parentID?: Endpoint5_0Request["query"]["parentID"];
-    readonly directory?: Endpoint5_0Request["query"]["directory"];
-    readonly project?: Endpoint5_0Request["query"]["project"];
-    readonly subpath?: Endpoint5_0Request["query"]["subpath"];
-    readonly cursor?: Endpoint5_0Request["query"]["cursor"];
-};
-export type Endpoint5_0Output = EffectValue<ReturnType<RawClient["server.session"]["session.list"]>>;
+    readonly workspace?: Workspace.ID | undefined;
+    readonly limit?: number | undefined;
+    readonly order?: "asc" | "desc" | undefined;
+    readonly search?: string | undefined;
+    readonly parentID?: Session.ID | null | undefined;
+    readonly directory?: AbsolutePath | undefined;
+    readonly project?: Project.ID | undefined;
+    readonly subpath?: RelativePath | undefined;
+    readonly cursor?: (string & Brand.Brand<"SessionsCursor">) | undefined;
+};
+export type Endpoint5_0Output = {
+    readonly data: ReadonlyArray<Session.Info>;
+    readonly cursor: {
+        readonly previous?: (string & Brand.Brand<"SessionsCursor">) | undefined;
+        readonly next?: (string & Brand.Brand<"SessionsCursor">) | undefined;
+    };
+};
 export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effect.Effect<Endpoint5_0Output, E>;
-type Endpoint5_1Request = Parameters<RawClient["server.session"]["session.create"]>[0];
 export type Endpoint5_1Input = {
-    readonly id?: Endpoint5_1Request["payload"]["id"];
-    readonly agent?: Endpoint5_1Request["payload"]["agent"];
-    readonly model?: Endpoint5_1Request["payload"]["model"];
-    readonly location?: Endpoint5_1Request["payload"]["location"];
+    readonly id?: Session.ID | undefined;
+    readonly agent?: Agent.ID | undefined;
+    readonly model?: Model.Ref | undefined;
+    readonly location?: Location.Ref | undefined;
 };
-export type Endpoint5_1Output = EffectValue<ReturnType<RawClient["server.session"]["session.create"]>>["data"];
+export type Endpoint5_1Output = Session.Info;
 export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>;
-export type Endpoint5_2Output = EffectValue<ReturnType<RawClient["server.session"]["session.active"]>>["data"];
+export type Endpoint5_2Output = {
+    readonly [x: Session.ID]: {
+        readonly type: "running";
+    };
+};
 export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_2Output, E>;
-type Endpoint5_3Request = Parameters<RawClient["server.session"]["session.get"]>[0];
 export type Endpoint5_3Input = {
-    readonly sessionID: Endpoint5_3Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_3Output = EffectValue<ReturnType<RawClient["server.session"]["session.get"]>>["data"];
+export type Endpoint5_3Output = Session.Info;
 export type SessionGetOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>;
-type Endpoint5_4Request = Parameters<RawClient["server.session"]["session.remove"]>[0];
 export type Endpoint5_4Input = {
-    readonly sessionID: Endpoint5_4Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_4Output = EffectValue<ReturnType<RawClient["server.session"]["session.remove"]>>;
+export type Endpoint5_4Output = void;
 export type SessionRemoveOperation<E = never> = (input: Endpoint5_4Input) => Effect.Effect<Endpoint5_4Output, E>;
-type Endpoint5_5Request = Parameters<RawClient["server.session"]["session.fork"]>[0];
 export type Endpoint5_5Input = {
-    readonly sessionID: Endpoint5_5Request["params"]["sessionID"];
-    readonly messageID?: Endpoint5_5Request["payload"]["messageID"];
+    readonly sessionID: Session.ID;
+    readonly messageID?: SessionMessage.ID | undefined;
 };
-export type Endpoint5_5Output = EffectValue<ReturnType<RawClient["server.session"]["session.fork"]>>["data"];
+export type Endpoint5_5Output = Session.Info;
 export type SessionForkOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>;
-type Endpoint5_6Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0];
 export type Endpoint5_6Input = {
-    readonly sessionID: Endpoint5_6Request["params"]["sessionID"];
-    readonly agent: Endpoint5_6Request["payload"]["agent"];
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
 };
-export type Endpoint5_6Output = EffectValue<ReturnType<RawClient["server.session"]["session.switchAgent"]>>;
+export type Endpoint5_6Output = void;
 export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>;
-type Endpoint5_7Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0];
 export type Endpoint5_7Input = {
-    readonly sessionID: Endpoint5_7Request["params"]["sessionID"];
-    readonly model: Endpoint5_7Request["payload"]["model"];
+    readonly sessionID: Session.ID;
+    readonly model: Model.Ref;
 };
-export type Endpoint5_7Output = EffectValue<ReturnType<RawClient["server.session"]["session.switchModel"]>>;
+export type Endpoint5_7Output = void;
 export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>;
-type Endpoint5_8Request = Parameters<RawClient["server.session"]["session.rename"]>[0];
 export type Endpoint5_8Input = {
-    readonly sessionID: Endpoint5_8Request["params"]["sessionID"];
-    readonly title: Endpoint5_8Request["payload"]["title"];
+    readonly sessionID: Session.ID;
+    readonly title: string;
 };
-export type Endpoint5_8Output = EffectValue<ReturnType<RawClient["server.session"]["session.rename"]>>;
+export type Endpoint5_8Output = void;
 export type SessionRenameOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>;
-type Endpoint5_9Request = Parameters<RawClient["server.session"]["session.move"]>[0];
 export type Endpoint5_9Input = {
-    readonly sessionID: Endpoint5_9Request["params"]["sessionID"];
-    readonly directory: Endpoint5_9Request["payload"]["directory"];
-    readonly workspaceID?: Endpoint5_9Request["payload"]["workspaceID"];
+    readonly sessionID: Session.ID;
+    readonly directory: AbsolutePath;
+    readonly workspaceID?: Workspace.ID | undefined;
 };
-export type Endpoint5_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.move"]>>;
+export type Endpoint5_9Output = void;
 export type SessionMoveOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>;
-type Endpoint5_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0];
 export type Endpoint5_10Input = {
-    readonly sessionID: Endpoint5_10Request["params"]["sessionID"];
-    readonly id?: Endpoint5_10Request["payload"]["id"];
-    readonly text: Endpoint5_10Request["payload"]["text"];
-    readonly files?: Endpoint5_10Request["payload"]["files"];
-    readonly agents?: Endpoint5_10Request["payload"]["agents"];
-    readonly metadata?: Endpoint5_10Request["payload"]["metadata"];
-    readonly delivery?: Endpoint5_10Request["payload"]["delivery"];
-    readonly resume?: Endpoint5_10Request["payload"]["resume"];
-};
-export type Endpoint5_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"];
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
+    readonly text: string;
+    readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined;
+    readonly agents?: ReadonlyArray<AgentAttachment> | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly delivery?: "steer" | "queue" | undefined;
+    readonly resume?: boolean | undefined;
+};
+export type Endpoint5_10Output = SessionPending.User;
 export type SessionPromptOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>;
-type Endpoint5_11Request = Parameters<RawClient["server.session"]["session.command"]>[0];
 export type Endpoint5_11Input = {
-    readonly sessionID: Endpoint5_11Request["params"]["sessionID"];
-    readonly id?: Endpoint5_11Request["payload"]["id"];
-    readonly command: Endpoint5_11Request["payload"]["command"];
-    readonly arguments?: Endpoint5_11Request["payload"]["arguments"];
-    readonly agent?: Endpoint5_11Request["payload"]["agent"];
-    readonly model?: Endpoint5_11Request["payload"]["model"];
-    readonly files?: Endpoint5_11Request["payload"]["files"];
-    readonly agents?: Endpoint5_11Request["payload"]["agents"];
-    readonly delivery?: Endpoint5_11Request["payload"]["delivery"];
-    readonly resume?: Endpoint5_11Request["payload"]["resume"];
-};
-export type Endpoint5_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"];
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
+    readonly command: string;
+    readonly arguments?: string | undefined;
+    readonly agent?: Agent.ID | undefined;
+    readonly model?: Model.Ref | undefined;
+    readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined;
+    readonly agents?: ReadonlyArray<AgentAttachment> | undefined;
+    readonly delivery?: "steer" | "queue" | undefined;
+    readonly resume?: boolean | undefined;
+};
+export type Endpoint5_11Output = SessionPending.User;
 export type SessionCommandOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>;
-type Endpoint5_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0];
 export type Endpoint5_12Input = {
-    readonly sessionID: Endpoint5_12Request["params"]["sessionID"];
-    readonly id?: Endpoint5_12Request["payload"]["id"];
-    readonly skill: Endpoint5_12Request["payload"]["skill"];
-    readonly resume?: Endpoint5_12Request["payload"]["resume"];
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
+    readonly skill: Skill.ID;
+    readonly resume?: boolean | undefined;
 };
-export type Endpoint5_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>;
+export type Endpoint5_12Output = void;
 export type SessionSkillOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>;
-type Endpoint5_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0];
 export type Endpoint5_13Input = {
-    readonly sessionID: Endpoint5_13Request["params"]["sessionID"];
-    readonly id?: Endpoint5_13Request["payload"]["id"];
-    readonly text: Endpoint5_13Request["payload"]["text"];
-    readonly description?: Endpoint5_13Request["payload"]["description"];
-    readonly metadata?: Endpoint5_13Request["payload"]["metadata"];
-    readonly delivery?: Endpoint5_13Request["payload"]["delivery"];
-    readonly resume?: Endpoint5_13Request["payload"]["resume"];
-};
-export type Endpoint5_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>["data"];
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
+    readonly text: string;
+    readonly description?: string | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly delivery?: "steer" | "queue" | undefined;
+    readonly resume?: boolean | undefined;
+};
+export type Endpoint5_13Output = SessionPending.Synthetic;
 export type SessionSyntheticOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>;
-type Endpoint5_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0];
 export type Endpoint5_14Input = {
-    readonly sessionID: Endpoint5_14Request["params"]["sessionID"];
-    readonly id?: Endpoint5_14Request["payload"]["id"];
-    readonly command: Endpoint5_14Request["payload"]["command"];
+    readonly sessionID: Session.ID;
+    readonly id?: Event.ID | undefined;
+    readonly command: string;
 };
-export type Endpoint5_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>;
+export type Endpoint5_14Output = void;
 export type SessionShellOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>;
-type Endpoint5_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0];
 export type Endpoint5_15Input = {
-    readonly sessionID: Endpoint5_15Request["params"]["sessionID"];
-    readonly id?: Endpoint5_15Request["payload"]["id"];
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
 };
-export type Endpoint5_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"];
+export type Endpoint5_15Output = SessionPending.Compaction;
 export type SessionCompactOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>;
-type Endpoint5_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0];
 export type Endpoint5_16Input = {
-    readonly sessionID: Endpoint5_16Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>;
+export type Endpoint5_16Output = void;
 export type SessionWaitOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>;
-type Endpoint5_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0];
 export type Endpoint5_17Input = {
-    readonly sessionID: Endpoint5_17Request["params"]["sessionID"];
-    readonly messageID: Endpoint5_17Request["payload"]["messageID"];
-    readonly files?: Endpoint5_17Request["payload"]["files"];
+    readonly sessionID: Session.ID;
+    readonly messageID: SessionMessage.ID;
+    readonly files?: boolean | undefined;
 };
-export type Endpoint5_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"];
+export type Endpoint5_17Output = Session.Revert;
 export type SessionRevertStageOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>;
-type Endpoint5_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0];
 export type Endpoint5_18Input = {
-    readonly sessionID: Endpoint5_18Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>;
+export type Endpoint5_18Output = void;
 export type SessionRevertClearOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>;
-type Endpoint5_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0];
 export type Endpoint5_19Input = {
-    readonly sessionID: Endpoint5_19Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>;
+export type Endpoint5_19Output = void;
 export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>;
-type Endpoint5_20Request = Parameters<RawClient["server.session"]["session.context"]>[0];
 export type Endpoint5_20Input = {
-    readonly sessionID: Endpoint5_20Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_20Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"];
+export type Endpoint5_20Output = ReadonlyArray<SessionMessage.Info>;
 export type SessionContextOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>;
-type Endpoint5_21Request = Parameters<RawClient["server.session"]["session.pending.list"]>[0];
 export type Endpoint5_21Input = {
-    readonly sessionID: Endpoint5_21Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_21Output = EffectValue<ReturnType<RawClient["server.session"]["session.pending.list"]>>["data"];
+export type Endpoint5_21Output = ReadonlyArray<SessionPending.Info>;
 export type SessionPendingListOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>;
-type Endpoint5_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0];
 export type Endpoint5_22Input = {
-    readonly sessionID: Endpoint5_22Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_22Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.list"]>>["data"];
+export type Endpoint5_22Output = ReadonlyArray<InstructionEntry.Info>;
 export type SessionInstructionsEntryListOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>;
-type Endpoint5_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0];
 export type Endpoint5_23Input = {
-    readonly sessionID: Endpoint5_23Request["params"]["sessionID"];
-    readonly key: Endpoint5_23Request["params"]["key"];
-    readonly value: Endpoint5_23Request["payload"]["value"];
+    readonly sessionID: Session.ID;
+    readonly key: InstructionEntry.Key;
+    readonly value: Schema.Json;
 };
-export type Endpoint5_23Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>;
+export type Endpoint5_23Output = void;
 export type SessionInstructionsEntryPutOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>;
-type Endpoint5_24Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0];
 export type Endpoint5_24Input = {
-    readonly sessionID: Endpoint5_24Request["params"]["sessionID"];
-    readonly key: Endpoint5_24Request["params"]["key"];
+    readonly sessionID: Session.ID;
+    readonly key: InstructionEntry.Key;
 };
-export type Endpoint5_24Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.remove"]>>;
+export type Endpoint5_24Output = void;
 export type SessionInstructionsEntryRemoveOperation<E = never> = (input: Endpoint5_24Input) => Effect.Effect<Endpoint5_24Output, E>;
-type Endpoint5_25Request = Parameters<RawClient["server.session"]["session.generate"]>[0];
 export type Endpoint5_25Input = {
-    readonly sessionID: Endpoint5_25Request["params"]["sessionID"];
-    readonly prompt: Endpoint5_25Request["payload"]["prompt"];
+    readonly sessionID: Session.ID;
+    readonly prompt: string;
+};
+export type Endpoint5_25Output = {
+    readonly text: string;
 };
-export type Endpoint5_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.generate"]>>["data"];
 export type SessionGenerateOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>;
-type Endpoint5_26Request = Parameters<RawClient["server.session"]["session.log"]>[0];
 export type Endpoint5_26Input = {
-    readonly sessionID: Endpoint5_26Request["params"]["sessionID"];
-    readonly after?: Endpoint5_26Request["query"]["after"];
-    readonly follow?: Endpoint5_26Request["query"]["follow"];
-};
-export type Endpoint5_26Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>;
+    readonly sessionID: Session.ID;
+    readonly after?: Event.Seq | undefined;
+    readonly follow?: boolean | undefined;
+};
+export type Endpoint5_26Output = ({
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.agent.selected";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly agent: Agent.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.model.selected";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly model: Model.Ref;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.moved";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly location: Location.Ref;
+        readonly projectID?: Project.ID | undefined;
+        readonly subpath?: RelativePath | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.renamed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly title: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.deleted";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.forked";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly parentID: Session.ID;
+        readonly parentSeq: number;
+        readonly from?: SessionMessage.ID | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.input.promoted";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly inputID: SessionMessage.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.input.admitted";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly inputID: SessionMessage.ID;
+        readonly input: SessionPending.Message;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.execution.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.execution.succeeded";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.execution.failed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly error: {
+            readonly type: string;
+            readonly message: string;
+        };
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.execution.interrupted";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly reason: "user" | "shutdown" | "superseded";
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.instructions.updated";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly delta: {
+            readonly [x: string]: (string & Brand.Brand<"Instruction.Hash">) | "removed";
+        };
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.synthetic";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly text: string;
+        readonly description?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.skill.activated";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly id: Skill.ID;
+        readonly name: Skill.Name;
+        readonly text: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.shell.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly shell: Shell.Info;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.shell.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly shell: Shell.Info;
+        readonly output: {
+            readonly output: string;
+            readonly cursor: number;
+            readonly size: number;
+            readonly truncated: boolean;
+        };
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.step.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly agent: Agent.ID;
+        readonly model: Model.Ref;
+        readonly snapshot?: (string & Brand.Brand<"Snapshot.ID">) | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.step.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly finish: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly cost: number & Brand.Brand<"Money.USD">;
+        readonly tokens: {
+            readonly input: number;
+            readonly output: number;
+            readonly reasoning: number;
+            readonly cache: {
+                readonly read: number;
+                readonly write: number;
+            };
+        };
+        readonly snapshot?: (string & Brand.Brand<"Snapshot.ID">) | undefined;
+        readonly files?: ReadonlyArray<RelativePath> | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.step.failed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly error: {
+            readonly type: string;
+            readonly message: string;
+        };
+        readonly cost?: (number & Brand.Brand<"Money.USD">) | undefined;
+        readonly tokens?: {
+            readonly input: number;
+            readonly output: number;
+            readonly reasoning: number;
+            readonly cache: {
+                readonly read: number;
+                readonly write: number;
+            };
+        } | undefined;
+        readonly snapshot?: (string & Brand.Brand<"Snapshot.ID">) | undefined;
+        readonly files?: ReadonlyArray<RelativePath> | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.text.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly ordinal: number;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.text.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly ordinal: number;
+        readonly text: string;
+        readonly state?: SessionMessage.ProviderState | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.reasoning.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly ordinal: number;
+        readonly state?: SessionMessage.ProviderState | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.reasoning.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly ordinal: number;
+        readonly text: string;
+        readonly state?: SessionMessage.ProviderState | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.tool.input.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly callID: string;
+        readonly name: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.tool.input.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly callID: string;
+        readonly text: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.tool.called";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly callID: string;
+        readonly input: {
+            readonly [x: string]: unknown;
+        };
+        readonly executed: boolean;
+        readonly state?: SessionMessage.ProviderState | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.tool.success";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly callID: string;
+        readonly content: readonly [
+            ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            }),
+            ...Array<{
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            }>
+        ];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        } | undefined;
+        readonly executed: boolean;
+        readonly resultState?: SessionMessage.ProviderState | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.tool.failed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly callID: string;
+        readonly error: {
+            readonly type: string;
+            readonly message: string;
+        };
+        readonly content?: readonly [
+            ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            }),
+            ...Array<{
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            }>
+        ] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        } | undefined;
+        readonly executed: boolean;
+        readonly resultState?: SessionMessage.ProviderState | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.retry.scheduled";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly attempt: number;
+        readonly at: number;
+        readonly error: {
+            readonly type: string;
+            readonly message: string;
+        };
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.compaction.admitted";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly inputID: SessionMessage.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.compaction.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly reason: "auto" | "manual";
+        readonly recent: string;
+        readonly inputID?: SessionMessage.ID | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.compaction.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly reason: "auto" | "manual";
+        readonly text: string;
+        readonly recent: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.compaction.failed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly reason: "auto" | "manual";
+        readonly error: {
+            readonly type: string;
+            readonly message: string;
+        };
+        readonly inputID?: SessionMessage.ID | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.revert.staged";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly revert: Session.Revert;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.revert.cleared";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.revert.committed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly to: SessionMessage.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: DateTime.Utc;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.usage.recorded";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly source: "title" | "compaction";
+        readonly cost: number & Brand.Brand<"Money.USD">;
+        readonly tokens: {
+            readonly input: number;
+            readonly output: number;
+            readonly reasoning: number;
+            readonly cache: {
+                readonly read: number;
+                readonly write: number;
+            };
+        };
+    };
+}) | EventLog.Synced;
 export type SessionLogOperation<E = never> = (input: Endpoint5_26Input) => Stream.Stream<Endpoint5_26Output, E>;
-type Endpoint5_27Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0];
 export type Endpoint5_27Input = {
-    readonly sessionID: Endpoint5_27Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_27Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>;
+export type Endpoint5_27Output = void;
 export type SessionInterruptOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>;
-type Endpoint5_28Request = Parameters<RawClient["server.session"]["session.background"]>[0];
 export type Endpoint5_28Input = {
-    readonly sessionID: Endpoint5_28Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint5_28Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>;
+export type Endpoint5_28Output = void;
 export type SessionBackgroundOperation<E = never> = (input: Endpoint5_28Input) => Effect.Effect<Endpoint5_28Output, E>;
-type Endpoint5_29Request = Parameters<RawClient["server.session"]["session.message"]>[0];
 export type Endpoint5_29Input = {
-    readonly sessionID: Endpoint5_29Request["params"]["sessionID"];
-    readonly messageID: Endpoint5_29Request["params"]["messageID"];
+    readonly sessionID: Session.ID;
+    readonly messageID: SessionMessage.ID;
 };
-export type Endpoint5_29Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"];
+export type Endpoint5_29Output = SessionMessage.Info;
 export type SessionMessageOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>;
 export interface SessionApi<E = never> {
     readonly list: SessionListOperation<E>;
@@ -318,150 +1166,221 @@ export interface SessionApi<E = never> {
     readonly background: SessionBackgroundOperation<E>;
     readonly message: SessionMessageOperation<E>;
 }
-type Endpoint6_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0];
 export type Endpoint6_0Input = {
-    readonly sessionID: Endpoint6_0Request["params"]["sessionID"];
-    readonly limit?: Endpoint6_0Request["query"]["limit"];
-    readonly order?: Endpoint6_0Request["query"]["order"];
-    readonly cursor?: Endpoint6_0Request["query"]["cursor"];
+    readonly sessionID: Session.ID;
+    readonly limit?: number | undefined;
+    readonly order?: "asc" | "desc" | undefined;
+    readonly cursor?: string | undefined;
+};
+export type Endpoint6_0Output = {
+    readonly data: ReadonlyArray<SessionMessage.Info>;
+    readonly cursor: {
+        readonly previous?: string | undefined;
+        readonly next?: string | undefined;
+    };
 };
-export type Endpoint6_0Output = EffectValue<ReturnType<RawClient["server.message"]["session.messages"]>>;
 export type MessageListOperation<E = never> = (input: Endpoint6_0Input) => Effect.Effect<Endpoint6_0Output, E>;
 export interface MessageApi<E = never> {
     readonly list: MessageListOperation<E>;
 }
-type Endpoint7_0Request = Parameters<RawClient["server.model"]["model.list"]>[0];
 export type Endpoint7_0Input = {
-    readonly location?: Endpoint7_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint7_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Model.Info>;
 };
-export type Endpoint7_0Output = EffectValue<ReturnType<RawClient["server.model"]["model.list"]>>;
 export type ModelListOperation<E = never> = (input?: Endpoint7_0Input) => Effect.Effect<Endpoint7_0Output, E>;
-type Endpoint7_1Request = Parameters<RawClient["server.model"]["model.default"]>[0];
 export type Endpoint7_1Input = {
-    readonly location?: Endpoint7_1Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint7_1Output = {
+    readonly location: Location.Info;
+    readonly data: Model.Info | undefined;
 };
-export type Endpoint7_1Output = EffectValue<ReturnType<RawClient["server.model"]["model.default"]>>;
 export type ModelDefaultOperation<E = never> = (input?: Endpoint7_1Input) => Effect.Effect<Endpoint7_1Output, E>;
 export interface ModelApi<E = never> {
     readonly list: ModelListOperation<E>;
     readonly default: ModelDefaultOperation<E>;
 }
-type Endpoint8_0Request = Parameters<RawClient["server.generate"]["generate.text"]>[0];
 export type Endpoint8_0Input = {
-    readonly location?: Endpoint8_0Request["query"]["location"];
-    readonly prompt: Endpoint8_0Request["payload"]["prompt"];
-    readonly model?: Endpoint8_0Request["payload"]["model"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly prompt: string;
+    readonly model?: Model.Ref | undefined;
+};
+export type Endpoint8_0Output = {
+    readonly text: string;
 };
-export type Endpoint8_0Output = EffectValue<ReturnType<RawClient["server.generate"]["generate.text"]>>["data"];
 export type GenerateTextOperation<E = never> = (input: Endpoint8_0Input) => Effect.Effect<Endpoint8_0Output, E>;
 export interface GenerateApi<E = never> {
     readonly text: GenerateTextOperation<E>;
 }
-type Endpoint9_0Request = Parameters<RawClient["server.provider"]["provider.list"]>[0];
 export type Endpoint9_0Input = {
-    readonly location?: Endpoint9_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint9_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Provider.Info>;
 };
-export type Endpoint9_0Output = EffectValue<ReturnType<RawClient["server.provider"]["provider.list"]>>;
 export type ProviderListOperation<E = never> = (input?: Endpoint9_0Input) => Effect.Effect<Endpoint9_0Output, E>;
-type Endpoint9_1Request = Parameters<RawClient["server.provider"]["provider.get"]>[0];
 export type Endpoint9_1Input = {
-    readonly providerID: Endpoint9_1Request["params"]["providerID"];
-    readonly location?: Endpoint9_1Request["query"]["location"];
+    readonly providerID: Provider.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint9_1Output = {
+    readonly location: Location.Info;
+    readonly data: Provider.Info;
 };
-export type Endpoint9_1Output = EffectValue<ReturnType<RawClient["server.provider"]["provider.get"]>>;
 export type ProviderGetOperation<E = never> = (input: Endpoint9_1Input) => Effect.Effect<Endpoint9_1Output, E>;
 export interface ProviderApi<E = never> {
     readonly list: ProviderListOperation<E>;
     readonly get: ProviderGetOperation<E>;
 }
-type Endpoint10_0Request = Parameters<RawClient["server.integration"]["integration.list"]>[0];
 export type Endpoint10_0Input = {
-    readonly location?: Endpoint10_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint10_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Integration.Info>;
 };
-export type Endpoint10_0Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.list"]>>;
 export type IntegrationListOperation<E = never> = (input?: Endpoint10_0Input) => Effect.Effect<Endpoint10_0Output, E>;
-type Endpoint10_1Request = Parameters<RawClient["server.integration"]["integration.get"]>[0];
 export type Endpoint10_1Input = {
-    readonly integrationID: Endpoint10_1Request["params"]["integrationID"];
-    readonly location?: Endpoint10_1Request["query"]["location"];
+    readonly integrationID: Integration.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint10_1Output = {
+    readonly location: Location.Info;
+    readonly data: Integration.Info | undefined;
 };
-export type Endpoint10_1Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.get"]>>;
 export type IntegrationGetOperation<E = never> = (input: Endpoint10_1Input) => Effect.Effect<Endpoint10_1Output, E>;
-type Endpoint10_2Request = Parameters<RawClient["server.integration"]["integration.wellknown.add"]>[0];
 export type Endpoint10_2Input = {
-    readonly location?: Endpoint10_2Request["query"]["location"];
-    readonly url: Endpoint10_2Request["payload"]["url"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly url: string;
 };
-export type Endpoint10_2Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.wellknown.add"]>>;
+export type Endpoint10_2Output = void;
 export type IntegrationWellknownAddOperation<E = never> = (input: Endpoint10_2Input) => Effect.Effect<Endpoint10_2Output, E>;
-type Endpoint10_3Request = Parameters<RawClient["server.integration"]["integration.connect.key"]>[0];
 export type Endpoint10_3Input = {
-    readonly integrationID: Endpoint10_3Request["params"]["integrationID"];
-    readonly location?: Endpoint10_3Request["query"]["location"];
-    readonly key: Endpoint10_3Request["payload"]["key"];
-    readonly label?: Endpoint10_3Request["payload"]["label"];
-};
-export type Endpoint10_3Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.connect.key"]>>;
+    readonly integrationID: Integration.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly key: string;
+    readonly label?: string | undefined;
+};
+export type Endpoint10_3Output = void;
 export type IntegrationConnectKeyOperation<E = never> = (input: Endpoint10_3Input) => Effect.Effect<Endpoint10_3Output, E>;
-type Endpoint10_4Request = Parameters<RawClient["server.integration"]["integration.oauth.connect"]>[0];
 export type Endpoint10_4Input = {
-    readonly integrationID: Endpoint10_4Request["params"]["integrationID"];
-    readonly location?: Endpoint10_4Request["query"]["location"];
-    readonly methodID: Endpoint10_4Request["payload"]["methodID"];
-    readonly inputs: Endpoint10_4Request["payload"]["inputs"];
-    readonly label?: Endpoint10_4Request["payload"]["label"];
+    readonly integrationID: Integration.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly methodID: Integration.MethodID;
+    readonly inputs: {
+        readonly [x: string]: string;
+    };
+    readonly label?: string | undefined;
+};
+export type Endpoint10_4Output = {
+    readonly location: Location.Info;
+    readonly data: Integration.Attempt;
 };
-export type Endpoint10_4Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.oauth.connect"]>>;
 export type IntegrationOauthConnectOperation<E = never> = (input: Endpoint10_4Input) => Effect.Effect<Endpoint10_4Output, E>;
-type Endpoint10_5Request = Parameters<RawClient["server.integration"]["integration.oauth.status"]>[0];
 export type Endpoint10_5Input = {
-    readonly integrationID: Endpoint10_5Request["params"]["integrationID"];
-    readonly attemptID: Endpoint10_5Request["params"]["attemptID"];
-    readonly location?: Endpoint10_5Request["query"]["location"];
+    readonly integrationID: Integration.ID;
+    readonly attemptID: Integration.AttemptID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint10_5Output = {
+    readonly location: Location.Info;
+    readonly data: Integration.AttemptStatus;
 };
-export type Endpoint10_5Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.oauth.status"]>>;
 export type IntegrationOauthStatusOperation<E = never> = (input: Endpoint10_5Input) => Effect.Effect<Endpoint10_5Output, E>;
-type Endpoint10_6Request = Parameters<RawClient["server.integration"]["integration.oauth.complete"]>[0];
 export type Endpoint10_6Input = {
-    readonly integrationID: Endpoint10_6Request["params"]["integrationID"];
-    readonly attemptID: Endpoint10_6Request["params"]["attemptID"];
-    readonly location?: Endpoint10_6Request["query"]["location"];
-    readonly code?: Endpoint10_6Request["payload"]["code"];
-};
-export type Endpoint10_6Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.oauth.complete"]>>;
+    readonly integrationID: Integration.ID;
+    readonly attemptID: Integration.AttemptID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly code?: string | undefined;
+};
+export type Endpoint10_6Output = void;
 export type IntegrationOauthCompleteOperation<E = never> = (input: Endpoint10_6Input) => Effect.Effect<Endpoint10_6Output, E>;
-type Endpoint10_7Request = Parameters<RawClient["server.integration"]["integration.oauth.cancel"]>[0];
 export type Endpoint10_7Input = {
-    readonly integrationID: Endpoint10_7Request["params"]["integrationID"];
-    readonly attemptID: Endpoint10_7Request["params"]["attemptID"];
-    readonly location?: Endpoint10_7Request["query"]["location"];
-};
-export type Endpoint10_7Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.oauth.cancel"]>>;
+    readonly integrationID: Integration.ID;
+    readonly attemptID: Integration.AttemptID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint10_7Output = void;
 export type IntegrationOauthCancelOperation<E = never> = (input: Endpoint10_7Input) => Effect.Effect<Endpoint10_7Output, E>;
-type Endpoint10_8Request = Parameters<RawClient["server.integration"]["integration.command.connect"]>[0];
 export type Endpoint10_8Input = {
-    readonly integrationID: Endpoint10_8Request["params"]["integrationID"];
-    readonly location?: Endpoint10_8Request["query"]["location"];
-    readonly methodID: Endpoint10_8Request["payload"]["methodID"];
-    readonly label?: Endpoint10_8Request["payload"]["label"];
+    readonly integrationID: Integration.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly methodID: Integration.MethodID;
+    readonly label?: string | undefined;
+};
+export type Endpoint10_8Output = {
+    readonly location: Location.Info;
+    readonly data: Integration.CommandAttempt;
 };
-export type Endpoint10_8Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.command.connect"]>>;
 export type IntegrationCommandConnectOperation<E = never> = (input: Endpoint10_8Input) => Effect.Effect<Endpoint10_8Output, E>;
-type Endpoint10_9Request = Parameters<RawClient["server.integration"]["integration.command.status"]>[0];
 export type Endpoint10_9Input = {
-    readonly integrationID: Endpoint10_9Request["params"]["integrationID"];
-    readonly attemptID: Endpoint10_9Request["params"]["attemptID"];
-    readonly location?: Endpoint10_9Request["query"]["location"];
+    readonly integrationID: Integration.ID;
+    readonly attemptID: Integration.AttemptID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint10_9Output = {
+    readonly location: Location.Info;
+    readonly data: Integration.CommandAttemptStatus;
 };
-export type Endpoint10_9Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.command.status"]>>;
 export type IntegrationCommandStatusOperation<E = never> = (input: Endpoint10_9Input) => Effect.Effect<Endpoint10_9Output, E>;
-type Endpoint10_10Request = Parameters<RawClient["server.integration"]["integration.command.cancel"]>[0];
 export type Endpoint10_10Input = {
-    readonly integrationID: Endpoint10_10Request["params"]["integrationID"];
-    readonly attemptID: Endpoint10_10Request["params"]["attemptID"];
-    readonly location?: Endpoint10_10Request["query"]["location"];
-};
-export type Endpoint10_10Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.command.cancel"]>>;
+    readonly integrationID: Integration.ID;
+    readonly attemptID: Integration.AttemptID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint10_10Output = void;
 export type IntegrationCommandCancelOperation<E = never> = (input: Endpoint10_10Input) => Effect.Effect<Endpoint10_10Output, E>;
 export interface IntegrationApi<E = never> {
     readonly list: IntegrationListOperation<E>;
@@ -484,46 +1403,64 @@ export interface IntegrationApi<E = never> {
         readonly cancel: IntegrationCommandCancelOperation<E>;
     };
 }
-type Endpoint11_0Request = Parameters<RawClient["server.mcp"]["mcp.list"]>[0];
 export type Endpoint11_0Input = {
-    readonly location?: Endpoint11_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint11_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Mcp.Server>;
 };
-export type Endpoint11_0Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.list"]>>;
 export type McpListOperation<E = never> = (input?: Endpoint11_0Input) => Effect.Effect<Endpoint11_0Output, E>;
-type Endpoint11_1Request = Parameters<RawClient["server.mcp"]["mcp.add"]>[0];
 export type Endpoint11_1Input = {
-    readonly server: Endpoint11_1Request["params"]["server"];
-    readonly location?: Endpoint11_1Request["query"]["location"];
-    readonly config: Endpoint11_1Request["payload"]["config"];
-};
-export type Endpoint11_1Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.add"]>>;
+    readonly server: string;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly config: Mcp.LocalConfig | Mcp.RemoteConfig;
+};
+export type Endpoint11_1Output = void;
 export type McpAddOperation<E = never> = (input: Endpoint11_1Input) => Effect.Effect<Endpoint11_1Output, E>;
-type Endpoint11_2Request = Parameters<RawClient["server.mcp"]["mcp.remove"]>[0];
 export type Endpoint11_2Input = {
-    readonly server: Endpoint11_2Request["params"]["server"];
-    readonly location?: Endpoint11_2Request["query"]["location"];
+    readonly server: string;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint11_2Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.remove"]>>;
+export type Endpoint11_2Output = void;
 export type McpRemoveOperation<E = never> = (input: Endpoint11_2Input) => Effect.Effect<Endpoint11_2Output, E>;
-type Endpoint11_3Request = Parameters<RawClient["server.mcp"]["mcp.connect"]>[0];
 export type Endpoint11_3Input = {
-    readonly server: Endpoint11_3Request["params"]["server"];
-    readonly location?: Endpoint11_3Request["query"]["location"];
+    readonly server: string;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint11_3Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.connect"]>>;
+export type Endpoint11_3Output = void;
 export type McpConnectOperation<E = never> = (input: Endpoint11_3Input) => Effect.Effect<Endpoint11_3Output, E>;
-type Endpoint11_4Request = Parameters<RawClient["server.mcp"]["mcp.disconnect"]>[0];
 export type Endpoint11_4Input = {
-    readonly server: Endpoint11_4Request["params"]["server"];
-    readonly location?: Endpoint11_4Request["query"]["location"];
+    readonly server: string;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint11_4Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.disconnect"]>>;
+export type Endpoint11_4Output = void;
 export type McpDisconnectOperation<E = never> = (input: Endpoint11_4Input) => Effect.Effect<Endpoint11_4Output, E>;
-type Endpoint11_5Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0];
 export type Endpoint11_5Input = {
-    readonly location?: Endpoint11_5Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint11_5Output = {
+    readonly location: Location.Info;
+    readonly data: Mcp.ResourceCatalog;
 };
-export type Endpoint11_5Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.resource.catalog"]>>;
 export type McpResourceCatalogOperation<E = never> = (input?: Endpoint11_5Input) => Effect.Effect<Endpoint11_5Output, E>;
 export interface McpApi<E = never> {
     readonly list: McpListOperation<E>;
@@ -535,95 +1472,102 @@ export interface McpApi<E = never> {
         readonly catalog: McpResourceCatalogOperation<E>;
     };
 }
-type Endpoint12_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0];
 export type Endpoint12_0Input = {
-    readonly credentialID: Endpoint12_0Request["params"]["credentialID"];
-    readonly location?: Endpoint12_0Request["query"]["location"];
-    readonly label: Endpoint12_0Request["payload"]["label"];
-};
-export type Endpoint12_0Output = EffectValue<ReturnType<RawClient["server.credential"]["credential.update"]>>;
+    readonly credentialID: Credential.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly label: string;
+};
+export type Endpoint12_0Output = void;
 export type CredentialUpdateOperation<E = never> = (input: Endpoint12_0Input) => Effect.Effect<Endpoint12_0Output, E>;
-type Endpoint12_1Request = Parameters<RawClient["server.credential"]["credential.remove"]>[0];
 export type Endpoint12_1Input = {
-    readonly credentialID: Endpoint12_1Request["params"]["credentialID"];
-    readonly location?: Endpoint12_1Request["query"]["location"];
+    readonly credentialID: Credential.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint12_1Output = EffectValue<ReturnType<RawClient["server.credential"]["credential.remove"]>>;
+export type Endpoint12_1Output = void;
 export type CredentialRemoveOperation<E = never> = (input: Endpoint12_1Input) => Effect.Effect<Endpoint12_1Output, E>;
 export interface CredentialApi<E = never> {
     readonly update: CredentialUpdateOperation<E>;
     readonly remove: CredentialRemoveOperation<E>;
 }
-export type Endpoint13_0Output = EffectValue<ReturnType<RawClient["server.project"]["project.list"]>>;
+export type Endpoint13_0Output = ReadonlyArray<Project.Info>;
 export type ProjectListOperation<E = never> = () => Effect.Effect<Endpoint13_0Output, E>;
-type Endpoint13_1Request = Parameters<RawClient["server.project"]["project.current"]>[0];
 export type Endpoint13_1Input = {
-    readonly location?: Endpoint13_1Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint13_1Output = EffectValue<ReturnType<RawClient["server.project"]["project.current"]>>;
+export type Endpoint13_1Output = Project.Current;
 export type ProjectCurrentOperation<E = never> = (input?: Endpoint13_1Input) => Effect.Effect<Endpoint13_1Output, E>;
-type Endpoint13_2Request = Parameters<RawClient["server.project"]["project.directories"]>[0];
 export type Endpoint13_2Input = {
-    readonly projectID: Endpoint13_2Request["params"]["projectID"];
-    readonly location?: Endpoint13_2Request["query"]["location"];
+    readonly projectID: Project.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint13_2Output = EffectValue<ReturnType<RawClient["server.project"]["project.directories"]>>;
+export type Endpoint13_2Output = Project.Directories;
 export type ProjectDirectoriesOperation<E = never> = (input: Endpoint13_2Input) => Effect.Effect<Endpoint13_2Output, E>;
 export interface ProjectApi<E = never> {
     readonly list: ProjectListOperation<E>;
     readonly current: ProjectCurrentOperation<E>;
     readonly directories: ProjectDirectoriesOperation<E>;
 }
-type Endpoint14_0Request = Parameters<RawClient["server.form"]["form.request.list"]>[0];
 export type Endpoint14_0Input = {
-    readonly location?: Endpoint14_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint14_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Form.Info>;
 };
-export type Endpoint14_0Output = EffectValue<ReturnType<RawClient["server.form"]["form.request.list"]>>;
 export type FormRequestListOperation<E = never> = (input?: Endpoint14_0Input) => Effect.Effect<Endpoint14_0Output, E>;
-type Endpoint14_1Request = Parameters<RawClient["server.form"]["session.form.list"]>[0];
 export type Endpoint14_1Input = {
-    readonly sessionID: Endpoint14_1Request["params"]["sessionID"];
+    readonly sessionID: string;
 };
-export type Endpoint14_1Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.list"]>>["data"];
+export type Endpoint14_1Output = ReadonlyArray<Form.Info>;
 export type FormListOperation<E = never> = (input: Endpoint14_1Input) => Effect.Effect<Endpoint14_1Output, E>;
-type Endpoint14_2Request = Parameters<RawClient["server.form"]["session.form.create"]>[0];
 export type Endpoint14_2Input = {
-    readonly sessionID: Endpoint14_2Request["params"]["sessionID"];
-    readonly id?: Endpoint14_2Request["payload"]["id"];
-    readonly title: Endpoint14_2Request["payload"]["title"];
-    readonly metadata?: Endpoint14_2Request["payload"]["metadata"];
-    readonly fields: Endpoint14_2Request["payload"]["fields"];
+    readonly sessionID: string;
+    readonly id?: Form.ID | undefined;
+    readonly title: string;
+    readonly metadata?: Form.Metadata | undefined;
+    readonly fields: Form.Fields;
 };
-export type Endpoint14_2Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.create"]>>["data"];
+export type Endpoint14_2Output = Form.Info;
 export type FormCreateOperation<E = never> = (input: Endpoint14_2Input) => Effect.Effect<Endpoint14_2Output, E>;
-type Endpoint14_3Request = Parameters<RawClient["server.form"]["session.form.get"]>[0];
 export type Endpoint14_3Input = {
-    readonly sessionID: Endpoint14_3Request["params"]["sessionID"];
-    readonly formID: Endpoint14_3Request["params"]["formID"];
+    readonly sessionID: string;
+    readonly formID: Form.ID;
 };
-export type Endpoint14_3Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.get"]>>["data"];
+export type Endpoint14_3Output = Form.Info;
 export type FormGetOperation<E = never> = (input: Endpoint14_3Input) => Effect.Effect<Endpoint14_3Output, E>;
-type Endpoint14_4Request = Parameters<RawClient["server.form"]["session.form.state"]>[0];
 export type Endpoint14_4Input = {
-    readonly sessionID: Endpoint14_4Request["params"]["sessionID"];
-    readonly formID: Endpoint14_4Request["params"]["formID"];
+    readonly sessionID: string;
+    readonly formID: Form.ID;
 };
-export type Endpoint14_4Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.state"]>>["data"];
+export type Endpoint14_4Output = Form.State;
 export type FormStateOperation<E = never> = (input: Endpoint14_4Input) => Effect.Effect<Endpoint14_4Output, E>;
-type Endpoint14_5Request = Parameters<RawClient["server.form"]["session.form.reply"]>[0];
 export type Endpoint14_5Input = {
-    readonly sessionID: Endpoint14_5Request["params"]["sessionID"];
-    readonly formID: Endpoint14_5Request["params"]["formID"];
-    readonly answer: Endpoint14_5Request["payload"]["answer"];
+    readonly sessionID: string;
+    readonly formID: Form.ID;
+    readonly answer: Form.Answer;
 };
-export type Endpoint14_5Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.reply"]>>;
+export type Endpoint14_5Output = void;
 export type FormReplyOperation<E = never> = (input: Endpoint14_5Input) => Effect.Effect<Endpoint14_5Output, E>;
-type Endpoint14_6Request = Parameters<RawClient["server.form"]["session.form.cancel"]>[0];
 export type Endpoint14_6Input = {
-    readonly sessionID: Endpoint14_6Request["params"]["sessionID"];
-    readonly formID: Endpoint14_6Request["params"]["formID"];
+    readonly sessionID: string;
+    readonly formID: Form.ID;
 };
-export type Endpoint14_6Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.cancel"]>>;
+export type Endpoint14_6Output = void;
 export type FormCancelOperation<E = never> = (input: Endpoint14_6Input) => Effect.Effect<Endpoint14_6Output, E>;
 export interface FormApi<E = never> {
     readonly request: {
@@ -636,58 +1580,62 @@ export interface FormApi<E = never> {
     readonly reply: FormReplyOperation<E>;
     readonly cancel: FormCancelOperation<E>;
 }
-type Endpoint15_0Request = Parameters<RawClient["server.permission"]["permission.request.list"]>[0];
 export type Endpoint15_0Input = {
-    readonly location?: Endpoint15_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint15_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Permission.Request>;
 };
-export type Endpoint15_0Output = EffectValue<ReturnType<RawClient["server.permission"]["permission.request.list"]>>;
 export type PermissionRequestListOperation<E = never> = (input?: Endpoint15_0Input) => Effect.Effect<Endpoint15_0Output, E>;
-type Endpoint15_1Request = Parameters<RawClient["server.permission"]["permission.saved.list"]>[0];
 export type Endpoint15_1Input = {
-    readonly projectID?: Endpoint15_1Request["query"]["projectID"];
+    readonly projectID?: Project.ID | undefined;
 };
-export type Endpoint15_1Output = EffectValue<ReturnType<RawClient["server.permission"]["permission.saved.list"]>>["data"];
+export type Endpoint15_1Output = ReadonlyArray<PermissionSaved.Info>;
 export type PermissionSavedListOperation<E = never> = (input?: Endpoint15_1Input) => Effect.Effect<Endpoint15_1Output, E>;
-type Endpoint15_2Request = Parameters<RawClient["server.permission"]["permission.saved.remove"]>[0];
 export type Endpoint15_2Input = {
-    readonly id: Endpoint15_2Request["params"]["id"];
+    readonly id: PermissionSaved.ID;
 };
-export type Endpoint15_2Output = EffectValue<ReturnType<RawClient["server.permission"]["permission.saved.remove"]>>;
+export type Endpoint15_2Output = void;
 export type PermissionSavedRemoveOperation<E = never> = (input: Endpoint15_2Input) => Effect.Effect<Endpoint15_2Output, E>;
-type Endpoint15_3Request = Parameters<RawClient["server.permission"]["session.permission.create"]>[0];
 export type Endpoint15_3Input = {
-    readonly sessionID: Endpoint15_3Request["params"]["sessionID"];
-    readonly id?: Endpoint15_3Request["payload"]["id"];
-    readonly action: Endpoint15_3Request["payload"]["action"];
-    readonly resources: Endpoint15_3Request["payload"]["resources"];
-    readonly save?: Endpoint15_3Request["payload"]["save"];
-    readonly metadata?: Endpoint15_3Request["payload"]["metadata"];
-    readonly source?: Endpoint15_3Request["payload"]["source"];
-    readonly agent?: Endpoint15_3Request["payload"]["agent"];
-};
-export type Endpoint15_3Output = EffectValue<ReturnType<RawClient["server.permission"]["session.permission.create"]>>["data"];
+    readonly sessionID: Session.ID;
+    readonly id?: Permission.ID | undefined;
+    readonly action: string;
+    readonly resources: ReadonlyArray<string>;
+    readonly save?: ReadonlyArray<string> | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly source?: Permission.Source | undefined;
+    readonly agent?: Agent.ID | undefined;
+};
+export type Endpoint15_3Output = {
+    readonly id: Permission.ID;
+    readonly effect: Permission.Effect;
+};
 export type PermissionCreateOperation<E = never> = (input: Endpoint15_3Input) => Effect.Effect<Endpoint15_3Output, E>;
-type Endpoint15_4Request = Parameters<RawClient["server.permission"]["session.permission.list"]>[0];
 export type Endpoint15_4Input = {
-    readonly sessionID: Endpoint15_4Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint15_4Output = EffectValue<ReturnType<RawClient["server.permission"]["session.permission.list"]>>["data"];
+export type Endpoint15_4Output = ReadonlyArray<Permission.Request>;
 export type PermissionListOperation<E = never> = (input: Endpoint15_4Input) => Effect.Effect<Endpoint15_4Output, E>;
-type Endpoint15_5Request = Parameters<RawClient["server.permission"]["session.permission.get"]>[0];
 export type Endpoint15_5Input = {
-    readonly sessionID: Endpoint15_5Request["params"]["sessionID"];
-    readonly requestID: Endpoint15_5Request["params"]["requestID"];
+    readonly sessionID: Session.ID;
+    readonly requestID: Permission.ID;
 };
-export type Endpoint15_5Output = EffectValue<ReturnType<RawClient["server.permission"]["session.permission.get"]>>["data"];
+export type Endpoint15_5Output = Permission.Request;
 export type PermissionGetOperation<E = never> = (input: Endpoint15_5Input) => Effect.Effect<Endpoint15_5Output, E>;
-type Endpoint15_6Request = Parameters<RawClient["server.permission"]["session.permission.reply"]>[0];
 export type Endpoint15_6Input = {
-    readonly sessionID: Endpoint15_6Request["params"]["sessionID"];
-    readonly requestID: Endpoint15_6Request["params"]["requestID"];
-    readonly reply: Endpoint15_6Request["payload"]["reply"];
-    readonly message?: Endpoint15_6Request["payload"]["message"];
+    readonly sessionID: Session.ID;
+    readonly requestID: Permission.ID;
+    readonly reply: Permission.Reply;
+    readonly message?: string | undefined;
 };
-export type Endpoint15_6Output = EffectValue<ReturnType<RawClient["server.permission"]["session.permission.reply"]>>;
+export type Endpoint15_6Output = void;
 export type PermissionReplyOperation<E = never> = (input: Endpoint15_6Input) => Effect.Effect<Endpoint15_6Output, E>;
 export interface PermissionApi<E = never> {
     readonly request: {
@@ -702,88 +1650,135 @@ export interface PermissionApi<E = never> {
     readonly get: PermissionGetOperation<E>;
     readonly reply: PermissionReplyOperation<E>;
 }
-type Endpoint16_0Request = Parameters<RawClient["server.fs"]["fs.list"]>[0];
 export type Endpoint16_0Input = {
-    readonly location?: Endpoint16_0Request["query"]["location"];
-    readonly path?: Endpoint16_0Request["query"]["path"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly path?: RelativePath | undefined;
+};
+export type Endpoint16_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<FileSystem.Entry>;
 };
-export type Endpoint16_0Output = EffectValue<ReturnType<RawClient["server.fs"]["fs.list"]>>;
 export type FileListOperation<E = never> = (input?: Endpoint16_0Input) => Effect.Effect<Endpoint16_0Output, E>;
-type Endpoint16_1Request = Parameters<RawClient["server.fs"]["fs.find"]>[0];
 export type Endpoint16_1Input = {
-    readonly location?: Endpoint16_1Request["query"]["location"];
-    readonly query: Endpoint16_1Request["query"]["query"];
-    readonly type?: Endpoint16_1Request["query"]["type"];
-    readonly limit?: Endpoint16_1Request["query"]["limit"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly query: string;
+    readonly type?: "file" | "directory" | undefined;
+    readonly limit?: number | undefined;
+};
+export type Endpoint16_1Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<FileSystem.Entry>;
 };
-export type Endpoint16_1Output = EffectValue<ReturnType<RawClient["server.fs"]["fs.find"]>>;
 export type FileFindOperation<E = never> = (input: Endpoint16_1Input) => Effect.Effect<Endpoint16_1Output, E>;
 export interface FileApi<E = never> {
     readonly list: FileListOperation<E>;
     readonly find: FileFindOperation<E>;
 }
-type Endpoint17_0Request = Parameters<RawClient["server.command"]["command.list"]>[0];
 export type Endpoint17_0Input = {
-    readonly location?: Endpoint17_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint17_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Command.Info>;
 };
-export type Endpoint17_0Output = EffectValue<ReturnType<RawClient["server.command"]["command.list"]>>;
 export type CommandListOperation<E = never> = (input?: Endpoint17_0Input) => Effect.Effect<Endpoint17_0Output, E>;
 export interface CommandApi<E = never> {
     readonly list: CommandListOperation<E>;
 }
-type Endpoint18_0Request = Parameters<RawClient["server.skill"]["skill.list"]>[0];
 export type Endpoint18_0Input = {
-    readonly location?: Endpoint18_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint18_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Skill.Info>;
 };
-export type Endpoint18_0Output = EffectValue<ReturnType<RawClient["server.skill"]["skill.list"]>>;
 export type SkillListOperation<E = never> = (input?: Endpoint18_0Input) => Effect.Effect<Endpoint18_0Output, E>;
 export interface SkillApi<E = never> {
     readonly list: SkillListOperation<E>;
 }
-export type Endpoint19_0Output = StreamValue<EffectValue<ReturnType<RawClient["server.event"]["event.subscribe"]>>>;
+export type Endpoint19_0Output = OpenCodeEvent;
 export type EventSubscribeOperation<E = never> = () => Stream.Stream<Endpoint19_0Output, E>;
 export interface EventApi<E = never> {
     readonly subscribe: EventSubscribeOperation<E>;
 }
-type Endpoint20_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0];
 export type Endpoint20_0Input = {
-    readonly location?: Endpoint20_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint20_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Pty.Info>;
 };
-export type Endpoint20_0Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.list"]>>;
 export type PtyListOperation<E = never> = (input?: Endpoint20_0Input) => Effect.Effect<Endpoint20_0Output, E>;
-type Endpoint20_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0];
 export type Endpoint20_1Input = {
-    readonly location?: Endpoint20_1Request["query"]["location"];
-    readonly command?: Endpoint20_1Request["payload"]["command"];
-    readonly args?: Endpoint20_1Request["payload"]["args"];
-    readonly cwd?: Endpoint20_1Request["payload"]["cwd"];
-    readonly title?: Endpoint20_1Request["payload"]["title"];
-    readonly env?: Endpoint20_1Request["payload"]["env"];
-};
-export type Endpoint20_1Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.create"]>>;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly command?: string | undefined;
+    readonly args?: ReadonlyArray<string> | undefined;
+    readonly cwd?: string | undefined;
+    readonly title?: string | undefined;
+    readonly env?: {
+        readonly [x: string]: string;
+    } | undefined;
+};
+export type Endpoint20_1Output = {
+    readonly location: Location.Info;
+    readonly data: Pty.Info;
+};
 export type PtyCreateOperation<E = never> = (input?: Endpoint20_1Input) => Effect.Effect<Endpoint20_1Output, E>;
-type Endpoint20_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0];
 export type Endpoint20_2Input = {
-    readonly ptyID: Endpoint20_2Request["params"]["ptyID"];
-    readonly location?: Endpoint20_2Request["query"]["location"];
+    readonly ptyID: Pty.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint20_2Output = {
+    readonly location: Location.Info;
+    readonly data: Pty.Info;
 };
-export type Endpoint20_2Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.get"]>>;
 export type PtyGetOperation<E = never> = (input: Endpoint20_2Input) => Effect.Effect<Endpoint20_2Output, E>;
-type Endpoint20_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0];
 export type Endpoint20_3Input = {
-    readonly ptyID: Endpoint20_3Request["params"]["ptyID"];
-    readonly location?: Endpoint20_3Request["query"]["location"];
-    readonly title?: Endpoint20_3Request["payload"]["title"];
-    readonly size?: Endpoint20_3Request["payload"]["size"];
+    readonly ptyID: Pty.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly title?: string | undefined;
+    readonly size?: {
+        readonly rows: number;
+        readonly cols: number;
+    } | undefined;
+};
+export type Endpoint20_3Output = {
+    readonly location: Location.Info;
+    readonly data: Pty.Info;
 };
-export type Endpoint20_3Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.update"]>>;
 export type PtyUpdateOperation<E = never> = (input: Endpoint20_3Input) => Effect.Effect<Endpoint20_3Output, E>;
-type Endpoint20_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0];
 export type Endpoint20_4Input = {
-    readonly ptyID: Endpoint20_4Request["params"]["ptyID"];
-    readonly location?: Endpoint20_4Request["query"]["location"];
+    readonly ptyID: Pty.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint20_4Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.remove"]>>;
+export type Endpoint20_4Output = void;
 export type PtyRemoveOperation<E = never> = (input: Endpoint20_4Input) => Effect.Effect<Endpoint20_4Output, E>;
 export interface PtyApi<E = never> {
     readonly list: PtyListOperation<E>;
@@ -792,52 +1787,86 @@ export interface PtyApi<E = never> {
     readonly update: PtyUpdateOperation<E>;
     readonly remove: PtyRemoveOperation<E>;
 }
-type Endpoint21_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0];
 export type Endpoint21_0Input = {
-    readonly location?: Endpoint21_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint21_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Shell.Info>;
 };
-export type Endpoint21_0Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.list"]>>;
 export type ShellListOperation<E = never> = (input?: Endpoint21_0Input) => Effect.Effect<Endpoint21_0Output, E>;
-type Endpoint21_1Request = Parameters<RawClient["server.shell"]["shell.create"]>[0];
 export type Endpoint21_1Input = {
-    readonly location?: Endpoint21_1Request["query"]["location"];
-    readonly command: Endpoint21_1Request["payload"]["command"];
-    readonly cwd?: Endpoint21_1Request["payload"]["cwd"];
-    readonly timeout: Endpoint21_1Request["payload"]["timeout"];
-    readonly metadata?: Endpoint21_1Request["payload"]["metadata"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly command: string;
+    readonly cwd?: string | undefined;
+    readonly timeout: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+};
+export type Endpoint21_1Output = {
+    readonly location: Location.Info;
+    readonly data: Shell.Info;
 };
-export type Endpoint21_1Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.create"]>>;
 export type ShellCreateOperation<E = never> = (input: Endpoint21_1Input) => Effect.Effect<Endpoint21_1Output, E>;
-type Endpoint21_2Request = Parameters<RawClient["server.shell"]["shell.get"]>[0];
 export type Endpoint21_2Input = {
-    readonly id: Endpoint21_2Request["params"]["id"];
-    readonly location?: Endpoint21_2Request["query"]["location"];
+    readonly id: Shell.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint21_2Output = {
+    readonly location: Location.Info;
+    readonly data: Shell.Info;
 };
-export type Endpoint21_2Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.get"]>>;
 export type ShellGetOperation<E = never> = (input: Endpoint21_2Input) => Effect.Effect<Endpoint21_2Output, E>;
-type Endpoint21_3Request = Parameters<RawClient["server.shell"]["shell.timeout"]>[0];
 export type Endpoint21_3Input = {
-    readonly id: Endpoint21_3Request["params"]["id"];
-    readonly location?: Endpoint21_3Request["query"]["location"];
-    readonly timeout: Endpoint21_3Request["payload"]["timeout"];
+    readonly id: Shell.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly timeout: number;
+};
+export type Endpoint21_3Output = {
+    readonly location: Location.Info;
+    readonly data: Shell.Info;
 };
-export type Endpoint21_3Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.timeout"]>>;
 export type ShellTimeoutOperation<E = never> = (input: Endpoint21_3Input) => Effect.Effect<Endpoint21_3Output, E>;
-type Endpoint21_4Request = Parameters<RawClient["server.shell"]["shell.output"]>[0];
 export type Endpoint21_4Input = {
-    readonly id: Endpoint21_4Request["params"]["id"];
-    readonly location?: Endpoint21_4Request["query"]["location"];
-    readonly cursor?: Endpoint21_4Request["query"]["cursor"];
-    readonly limit?: Endpoint21_4Request["query"]["limit"];
+    readonly id: Shell.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly cursor?: number | undefined;
+    readonly limit?: number | undefined;
+};
+export type Endpoint21_4Output = {
+    readonly location: Location.Info;
+    readonly data: {
+        readonly output: string;
+        readonly cursor: number;
+        readonly size: number;
+        readonly truncated: boolean;
+    };
 };
-export type Endpoint21_4Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.output"]>>;
 export type ShellOutputOperation<E = never> = (input: Endpoint21_4Input) => Effect.Effect<Endpoint21_4Output, E>;
-type Endpoint21_5Request = Parameters<RawClient["server.shell"]["shell.remove"]>[0];
 export type Endpoint21_5Input = {
-    readonly id: Endpoint21_5Request["params"]["id"];
-    readonly location?: Endpoint21_5Request["query"]["location"];
+    readonly id: Shell.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint21_5Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.remove"]>>;
+export type Endpoint21_5Output = void;
 export type ShellRemoveOperation<E = never> = (input: Endpoint21_5Input) => Effect.Effect<Endpoint21_5Output, E>;
 export interface ShellApi<E = never> {
     readonly list: ShellListOperation<E>;
@@ -847,32 +1876,34 @@ export interface ShellApi<E = never> {
     readonly output: ShellOutputOperation<E>;
     readonly remove: ShellRemoveOperation<E>;
 }
-type Endpoint22_0Request = Parameters<RawClient["server.question"]["question.request.list"]>[0];
 export type Endpoint22_0Input = {
-    readonly location?: Endpoint22_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint22_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Question.Request>;
 };
-export type Endpoint22_0Output = EffectValue<ReturnType<RawClient["server.question"]["question.request.list"]>>;
 export type QuestionRequestListOperation<E = never> = (input?: Endpoint22_0Input) => Effect.Effect<Endpoint22_0Output, E>;
-type Endpoint22_1Request = Parameters<RawClient["server.question"]["session.question.list"]>[0];
 export type Endpoint22_1Input = {
-    readonly sessionID: Endpoint22_1Request["params"]["sessionID"];
+    readonly sessionID: Session.ID;
 };
-export type Endpoint22_1Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.list"]>>["data"];
+export type Endpoint22_1Output = ReadonlyArray<Question.Request>;
 export type QuestionListOperation<E = never> = (input: Endpoint22_1Input) => Effect.Effect<Endpoint22_1Output, E>;
-type Endpoint22_2Request = Parameters<RawClient["server.question"]["session.question.reply"]>[0];
 export type Endpoint22_2Input = {
-    readonly sessionID: Endpoint22_2Request["params"]["sessionID"];
-    readonly requestID: Endpoint22_2Request["params"]["requestID"];
-    readonly answers: Endpoint22_2Request["payload"]["answers"];
+    readonly sessionID: Session.ID;
+    readonly requestID: Question.ID;
+    readonly answers: ReadonlyArray<Question.Answer>;
 };
-export type Endpoint22_2Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.reply"]>>;
+export type Endpoint22_2Output = void;
 export type QuestionReplyOperation<E = never> = (input: Endpoint22_2Input) => Effect.Effect<Endpoint22_2Output, E>;
-type Endpoint22_3Request = Parameters<RawClient["server.question"]["session.question.reject"]>[0];
 export type Endpoint22_3Input = {
-    readonly sessionID: Endpoint22_3Request["params"]["sessionID"];
-    readonly requestID: Endpoint22_3Request["params"]["requestID"];
+    readonly sessionID: Session.ID;
+    readonly requestID: Question.ID;
 };
-export type Endpoint22_3Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.reject"]>>;
+export type Endpoint22_3Output = void;
 export type QuestionRejectOperation<E = never> = (input: Endpoint22_3Input) => Effect.Effect<Endpoint22_3Output, E>;
 export interface QuestionApi<E = never> {
     readonly request: {
@@ -882,71 +1913,94 @@ export interface QuestionApi<E = never> {
     readonly reply: QuestionReplyOperation<E>;
     readonly reject: QuestionRejectOperation<E>;
 }
-type Endpoint23_0Request = Parameters<RawClient["server.reference"]["reference.list"]>[0];
 export type Endpoint23_0Input = {
-    readonly location?: Endpoint23_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint23_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Reference.Info>;
 };
-export type Endpoint23_0Output = EffectValue<ReturnType<RawClient["server.reference"]["reference.list"]>>;
 export type ReferenceListOperation<E = never> = (input?: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>;
 export interface ReferenceApi<E = never> {
     readonly list: ReferenceListOperation<E>;
 }
-type Endpoint24_0Request = Parameters<RawClient["server.projectCopy"]["projectCopy.create"]>[0];
 export type Endpoint24_0Input = {
-    readonly projectID: Endpoint24_0Request["params"]["projectID"];
-    readonly location?: Endpoint24_0Request["query"]["location"];
-    readonly strategy: Endpoint24_0Request["payload"]["strategy"];
-    readonly directory: Endpoint24_0Request["payload"]["directory"];
-    readonly name?: Endpoint24_0Request["payload"]["name"];
-};
-export type Endpoint24_0Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.create"]>>;
+    readonly projectID: Project.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly strategy: ProjectCopy.StrategyID;
+    readonly directory: AbsolutePath;
+    readonly name?: string | undefined;
+};
+export type Endpoint24_0Output = ProjectCopy.Copy;
 export type ProjectCopyCreateOperation<E = never> = (input: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>;
-type Endpoint24_1Request = Parameters<RawClient["server.projectCopy"]["projectCopy.remove"]>[0];
 export type Endpoint24_1Input = {
-    readonly projectID: Endpoint24_1Request["params"]["projectID"];
-    readonly location?: Endpoint24_1Request["query"]["location"];
-    readonly directory: Endpoint24_1Request["payload"]["directory"];
-    readonly force: Endpoint24_1Request["payload"]["force"];
-};
-export type Endpoint24_1Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.remove"]>>;
+    readonly projectID: Project.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly directory: AbsolutePath;
+    readonly force: boolean;
+};
+export type Endpoint24_1Output = void;
 export type ProjectCopyRemoveOperation<E = never> = (input: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>;
-type Endpoint24_2Request = Parameters<RawClient["server.projectCopy"]["projectCopy.refresh"]>[0];
 export type Endpoint24_2Input = {
-    readonly projectID: Endpoint24_2Request["params"]["projectID"];
-    readonly location?: Endpoint24_2Request["query"]["location"];
+    readonly projectID: Project.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint24_2Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.refresh"]>>;
+export type Endpoint24_2Output = void;
 export type ProjectCopyRefreshOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>;
 export interface ProjectCopyApi<E = never> {
     readonly create: ProjectCopyCreateOperation<E>;
     readonly remove: ProjectCopyRemoveOperation<E>;
     readonly refresh: ProjectCopyRefreshOperation<E>;
 }
-type Endpoint25_0Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0];
 export type Endpoint25_0Input = {
-    readonly location?: Endpoint25_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint25_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Vcs.FileStatus>;
 };
-export type Endpoint25_0Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.status"]>>;
 export type VcsStatusOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>;
-type Endpoint25_1Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0];
 export type Endpoint25_1Input = {
-    readonly location?: Endpoint25_1Request["query"]["location"];
-    readonly mode: Endpoint25_1Request["query"]["mode"];
-    readonly context?: Endpoint25_1Request["query"]["context"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly mode: Vcs.Mode;
+    readonly context?: number | undefined;
+};
+export type Endpoint25_1Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<FileDiff.Info>;
 };
-export type Endpoint25_1Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.diff"]>>;
 export type VcsDiffOperation<E = never> = (input: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>;
 export interface VcsApi<E = never> {
     readonly status: VcsStatusOperation<E>;
     readonly diff: VcsDiffOperation<E>;
 }
-export type Endpoint26_0Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location"]>>;
+export type Endpoint26_0Output = ReadonlyArray<Location.Ref>;
 export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>;
-type Endpoint26_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0];
 export type Endpoint26_1Input = {
-    readonly location?: Endpoint26_1Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
 };
-export type Endpoint26_1Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location.evict"]>>;
+export type Endpoint26_1Output = void;
 export type DebugLocationEvictOperation<E = never> = (input?: Endpoint26_1Input) => Effect.Effect<Endpoint26_1Output, E>;
 export interface DebugApi<E = never> {
     readonly location: {
@@ -954,19 +2008,29 @@ export interface DebugApi<E = never> {
         readonly evict: DebugLocationEvictOperation<E>;
     };
 }
-type Endpoint27_0Request = Parameters<RawClient["server.websearch"]["websearch.providers"]>[0];
 export type Endpoint27_0Input = {
-    readonly location?: Endpoint27_0Request["query"]["location"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint27_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<WebSearch.Provider>;
 };
-export type Endpoint27_0Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.providers"]>>;
 export type WebsearchProvidersOperation<E = never> = (input?: Endpoint27_0Input) => Effect.Effect<Endpoint27_0Output, E>;
-type Endpoint27_1Request = Parameters<RawClient["server.websearch"]["websearch.query"]>[0];
 export type Endpoint27_1Input = {
-    readonly location?: Endpoint27_1Request["query"]["location"];
-    readonly query: Endpoint27_1Request["payload"]["query"];
-    readonly providerID?: Endpoint27_1Request["payload"]["providerID"];
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly query: string;
+    readonly providerID?: WebSearch.ID | undefined;
+};
+export type Endpoint27_1Output = {
+    readonly location: Location.Info;
+    readonly data: WebSearch.Response;
 };
-export type Endpoint27_1Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.query"]>>;
 export type WebsearchQueryOperation<E = never> = (input: Endpoint27_1Input) => Effect.Effect<Endpoint27_1Output, E>;
 export interface WebsearchApi<E = never> {
     readonly providers: WebsearchProvidersOperation<E>;
@@ -1002,4 +2066,3 @@ export interface AppApi<E = never> {
     readonly debug: DebugApi<E>;
     readonly websearch: WebsearchApi<E>;
 }
-export {};