@opencode-ai/client 0.0.0-dev-17471

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

@@ -0,0 +1,2155 @@
+import type { Effect, Stream } from "effect";
+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 { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import type { PromptInput } from "@opencode-ai/schema/prompt-input";
+import type { AgentAttachment } from "@opencode-ai/schema/prompt";
+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 { Provider } from "@opencode-ai/schema/provider";
+import type { Integration } from "@opencode-ai/schema/integration";
+import type { Form } from "@opencode-ai/schema/form";
+import type { Mcp } from "@opencode-ai/schema/mcp";
+import type { Credential } from "@opencode-ai/schema/credential";
+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 { Reference } from "@opencode-ai/schema/reference";
+import type { Worktree } from "@opencode-ai/schema/worktree";
+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";
+import type { Config } from "@opencode-ai/schema/config";
+export type Endpoint0_0Output = {
+    readonly healthy: true;
+    readonly version: string;
+    readonly pid: number;
+};
+export type HealthGetOperation<E = never> = () => Effect.Effect<Endpoint0_0Output, E>;
+export type Endpoint0_1Input = {
+    readonly instanceID: string;
+};
+export type Endpoint0_1Output = {
+    readonly accepted: boolean;
+};
+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 = {
+    readonly urls: ReadonlyArray<string>;
+};
+export type ServerGetOperation<E = never> = () => Effect.Effect<Endpoint1_0Output, E>;
+export interface ServerApi<E = never> {
+    readonly get: ServerGetOperation<E>;
+}
+export type Endpoint2_0Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+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>;
+}
+export type Endpoint3_0Input = {
+    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 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>;
+}
+export type Endpoint4_0Input = {
+    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 PluginListOperation<E = never> = (input?: Endpoint4_0Input) => Effect.Effect<Endpoint4_0Output, E>;
+export interface PluginApi<E = never> {
+    readonly list: PluginListOperation<E>;
+}
+export type Endpoint5_0Input = {
+    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>;
+export type Endpoint5_1Input = {
+    readonly id?: Session.ID | undefined;
+    readonly title?: string | undefined;
+    readonly agent?: Agent.ID | undefined;
+    readonly model?: Model.Ref | undefined;
+    readonly location?: Location.Ref | undefined;
+};
+export type Endpoint5_1Output = Session.Info;
+export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>;
+export type Endpoint5_2Input = {
+    readonly info: Session.Info;
+    readonly messages: ReadonlyArray<SessionMessage.Info>;
+    readonly location?: Location.Ref | undefined;
+};
+export type Endpoint5_2Output = Session.Info;
+export type SessionImportOperation<E = never> = (input: Endpoint5_2Input) => Effect.Effect<Endpoint5_2Output, E>;
+export type Endpoint5_3Input = {
+    readonly sessionID: Session.ID;
+    readonly sanitize?: boolean | undefined;
+};
+export type Endpoint5_3Output = {
+    readonly info: Session.Info;
+    readonly messages: ReadonlyArray<SessionMessage.Info>;
+};
+export type SessionExportOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>;
+export type Endpoint5_4Output = {
+    readonly [x: Session.ID]: {
+        readonly type: "running";
+    };
+};
+export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_4Output, E>;
+export type Endpoint5_5Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_5Output = Session.Info;
+export type SessionGetOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>;
+export type Endpoint5_6Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_6Output = void;
+export type SessionRemoveOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>;
+export type Endpoint5_7Input = {
+    readonly sessionID: Session.ID;
+    readonly boundary: Session.ForkRequestBoundary;
+};
+export type Endpoint5_7Output = Session.Info;
+export type SessionForkOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>;
+export type Endpoint5_8Input = {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+};
+export type Endpoint5_8Output = void;
+export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>;
+export type Endpoint5_9Input = {
+    readonly sessionID: Session.ID;
+    readonly model: Model.Ref;
+};
+export type Endpoint5_9Output = void;
+export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>;
+export type Endpoint5_10Input = {
+    readonly sessionID: Session.ID;
+    readonly title: string;
+};
+export type Endpoint5_10Output = void;
+export type SessionRenameOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>;
+export type Endpoint5_11Input = {
+    readonly sessionID: Session.ID;
+    readonly directory: AbsolutePath;
+    readonly workspaceID?: Workspace.ID | undefined;
+    readonly delivery?: SessionInbox.Delivery | undefined;
+};
+export type Endpoint5_11Output = void;
+export type SessionMoveOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>;
+export type Endpoint5_12Input = {
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
+    readonly text: string;
+    readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined;
+    readonly agents?: ReadonlyArray<AgentAttachment> | undefined;
+    readonly skills?: ReadonlyArray<PromptInput.SkillAttachment> | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly delivery?: SessionInbox.Delivery | undefined;
+    readonly resume?: boolean | undefined;
+};
+export type Endpoint5_12Output = SessionInbox.User;
+export type SessionPromptOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>;
+export type Endpoint5_13Input = {
+    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 skills?: ReadonlyArray<PromptInput.SkillAttachment> | undefined;
+    readonly delivery?: SessionInbox.Delivery | undefined;
+    readonly resume?: boolean | undefined;
+};
+export type Endpoint5_13Output = SessionInbox.User;
+export type SessionCommandOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>;
+export type Endpoint5_14Input = {
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
+    readonly skill: Skill.ID;
+    readonly resume?: boolean | undefined;
+};
+export type Endpoint5_14Output = void;
+export type SessionSkillOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>;
+export type Endpoint5_15Input = {
+    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?: SessionInbox.Delivery | undefined;
+    readonly resume?: boolean | undefined;
+};
+export type Endpoint5_15Output = SessionInbox.Synthetic;
+export type SessionSyntheticOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>;
+export type Endpoint5_16Input = {
+    readonly sessionID: Session.ID;
+    readonly id?: Event.ID | undefined;
+    readonly command: string;
+};
+export type Endpoint5_16Output = void;
+export type SessionShellOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>;
+export type Endpoint5_17Input = {
+    readonly sessionID: Session.ID;
+    readonly id?: SessionMessage.ID | undefined;
+    readonly delivery?: SessionInbox.Delivery | undefined;
+};
+export type Endpoint5_17Output = SessionInbox.Compaction;
+export type SessionCompactOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>;
+export type Endpoint5_18Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_18Output = void;
+export type SessionWaitOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>;
+export type Endpoint5_19Input = {
+    readonly sessionID: Session.ID;
+    readonly messageID: SessionMessage.ID;
+    readonly files?: boolean | undefined;
+};
+export type Endpoint5_19Output = Session.Revert;
+export type SessionRevertStageOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>;
+export type Endpoint5_20Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_20Output = void;
+export type SessionRevertClearOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>;
+export type Endpoint5_21Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_21Output = void;
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>;
+export type Endpoint5_22Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_22Output = ReadonlyArray<SessionMessage.Info>;
+export type SessionContextOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>;
+export type Endpoint5_23Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_23Output = ReadonlyArray<SessionInbox.Info>;
+export type SessionInboxListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>;
+export type Endpoint5_24Input = {
+    readonly sessionID: Session.ID;
+    readonly inboxID: SessionMessage.ID;
+};
+export type Endpoint5_24Output = void;
+export type SessionInboxCancelOperation<E = never> = (input: Endpoint5_24Input) => Effect.Effect<Endpoint5_24Output, E>;
+export type Endpoint5_25Input = {
+    readonly sessionID: Session.ID;
+    readonly inboxID: SessionMessage.ID;
+};
+export type Endpoint5_25Output = void;
+export type SessionInboxSteerOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>;
+export type Endpoint5_26Input = {
+    readonly sessionID: Session.ID;
+    readonly inboxID: SessionMessage.ID;
+};
+export type Endpoint5_26Output = void;
+export type SessionInboxQueueOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>;
+export type Endpoint5_27Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_27Output = ReadonlyArray<InstructionEntry.Info>;
+export type SessionInstructionsEntryListOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>;
+export type Endpoint5_28Input = {
+    readonly sessionID: Session.ID;
+    readonly key: InstructionEntry.Key;
+    readonly value: Schema.Json;
+};
+export type Endpoint5_28Output = void;
+export type SessionInstructionsEntryPutOperation<E = never> = (input: Endpoint5_28Input) => Effect.Effect<Endpoint5_28Output, E>;
+export type Endpoint5_29Input = {
+    readonly sessionID: Session.ID;
+    readonly key: InstructionEntry.Key;
+};
+export type Endpoint5_29Output = void;
+export type SessionInstructionsEntryRemoveOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>;
+export type Endpoint5_30Input = {
+    readonly sessionID: Session.ID;
+    readonly prompt: string;
+};
+export type Endpoint5_30Output = {
+    readonly text: string;
+};
+export type SessionGenerateOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>;
+export type Endpoint5_31Input = {
+    readonly sessionID: Session.ID;
+    readonly after?: Event.Seq | undefined;
+    readonly follow?: boolean | undefined;
+};
+export type Endpoint5_31Output = ({
+    readonly id: Event.ID;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.created";
+    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 projectID: Project.ID;
+        readonly location: Location.Ref;
+        readonly subpath?: RelativePath | undefined;
+        readonly parentID?: Session.ID | undefined;
+        readonly slug: string;
+        readonly title?: string | undefined;
+        readonly agent?: Agent.ID | undefined;
+        readonly model?: Model.Ref | undefined;
+        readonly version: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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 previous?: Agent.ID | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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 previous?: Model.Ref | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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;
+        readonly subpath?: RelativePath | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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: number;
+    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: number;
+    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 boundary: Session.ForkBoundary;
+        readonly instructions?: {
+            readonly [x: string & Brand.Brand<"Instruction.Key">]: string & Brand.Brand<"Instruction.Hash">;
+        } | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.inbox.delivered";
+    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 inboxID: SessionMessage.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.inbox.enqueued";
+    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 inboxID: SessionMessage.ID;
+        readonly item: SessionInbox.Item;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.inbox.cancelled";
+    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 inboxID: SessionMessage.ID;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.inbox.delivery.changed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly inboxID: SessionMessage.ID;
+        readonly delivery: SessionInbox.Delivery;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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: number;
+    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: number;
+    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 status?: number | undefined;
+        };
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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: number;
+    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 text?: string | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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: number;
+    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: number;
+    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: number;
+    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: number;
+    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: number;
+    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: number;
+    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 status?: number | undefined;
+        };
+        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: number;
+    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: number;
+    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: number;
+    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: number;
+    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: number;
+    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 id: string;
+        readonly name: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: "session.tool.input.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: Event.Seq;
+        readonly version: Event.Version;
+    };
+    readonly location?: Location.Ref | undefined;
+    readonly data: {
+        readonly sessionID: Session.ID;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly id: string;
+        readonly text: string;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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 id: string;
+        readonly input: {
+            readonly [x: string]: unknown;
+        };
+        readonly executed: boolean;
+        readonly state?: SessionMessage.ProviderState | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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 id: 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: number;
+    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 id: string;
+        readonly error: {
+            readonly type: string;
+            readonly message: string;
+            readonly status?: number | undefined;
+        };
+        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: number;
+    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 status?: number | undefined;
+        };
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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: number;
+    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: number;
+    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 status?: number | undefined;
+        };
+        readonly inputID?: SessionMessage.ID | undefined;
+    };
+} | {
+    readonly id: Event.ID;
+    readonly created: number;
+    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: number;
+    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: number;
+    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: number;
+    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_31Input) => Stream.Stream<Endpoint5_31Output, E>;
+export type Endpoint5_32Input = {
+    readonly sessionID: Session.ID;
+    readonly continue?: boolean | undefined;
+};
+export type Endpoint5_32Output = void;
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_32Input) => Effect.Effect<Endpoint5_32Output, E>;
+export type Endpoint5_33Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint5_33Output = void;
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_33Input) => Effect.Effect<Endpoint5_33Output, E>;
+export type Endpoint5_34Input = {
+    readonly sessionID: Session.ID;
+    readonly messageID: SessionMessage.ID;
+};
+export type Endpoint5_34Output = SessionMessage.Info;
+export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>;
+export interface SessionApi<E = never> {
+    readonly list: SessionListOperation<E>;
+    readonly create: SessionCreateOperation<E>;
+    readonly import: SessionImportOperation<E>;
+    readonly export: SessionExportOperation<E>;
+    readonly active: SessionActiveOperation<E>;
+    readonly get: SessionGetOperation<E>;
+    readonly remove: SessionRemoveOperation<E>;
+    readonly fork: SessionForkOperation<E>;
+    readonly switchAgent: SessionSwitchAgentOperation<E>;
+    readonly switchModel: SessionSwitchModelOperation<E>;
+    readonly rename: SessionRenameOperation<E>;
+    readonly move: SessionMoveOperation<E>;
+    readonly prompt: SessionPromptOperation<E>;
+    readonly command: SessionCommandOperation<E>;
+    readonly skill: SessionSkillOperation<E>;
+    readonly synthetic: SessionSyntheticOperation<E>;
+    readonly shell: SessionShellOperation<E>;
+    readonly compact: SessionCompactOperation<E>;
+    readonly wait: SessionWaitOperation<E>;
+    readonly revert: {
+        readonly stage: SessionRevertStageOperation<E>;
+        readonly clear: SessionRevertClearOperation<E>;
+        readonly commit: SessionRevertCommitOperation<E>;
+    };
+    readonly context: SessionContextOperation<E>;
+    readonly inbox: {
+        readonly list: SessionInboxListOperation<E>;
+        readonly cancel: SessionInboxCancelOperation<E>;
+        readonly steer: SessionInboxSteerOperation<E>;
+        readonly queue: SessionInboxQueueOperation<E>;
+    };
+    readonly instructions: {
+        readonly entry: {
+            readonly list: SessionInstructionsEntryListOperation<E>;
+            readonly put: SessionInstructionsEntryPutOperation<E>;
+            readonly remove: SessionInstructionsEntryRemoveOperation<E>;
+        };
+    };
+    readonly generate: SessionGenerateOperation<E>;
+    readonly log: SessionLogOperation<E>;
+    readonly interrupt: SessionInterruptOperation<E>;
+    readonly background: SessionBackgroundOperation<E>;
+    readonly message: SessionMessageOperation<E>;
+}
+export type Endpoint6_0Input = {
+    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 MessageListOperation<E = never> = (input: Endpoint6_0Input) => Effect.Effect<Endpoint6_0Output, E>;
+export interface MessageApi<E = never> {
+    readonly list: MessageListOperation<E>;
+}
+export type Endpoint7_0Input = {
+    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 ModelListOperation<E = never> = (input?: Endpoint7_0Input) => Effect.Effect<Endpoint7_0Output, E>;
+export type Endpoint7_1Input = {
+    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 ModelDefaultOperation<E = never> = (input?: Endpoint7_1Input) => Effect.Effect<Endpoint7_1Output, E>;
+export interface ModelApi<E = never> {
+    readonly list: ModelListOperation<E>;
+    readonly default: ModelDefaultOperation<E>;
+}
+export type Endpoint8_0Input = {
+    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 GenerateTextOperation<E = never> = (input: Endpoint8_0Input) => Effect.Effect<Endpoint8_0Output, E>;
+export interface GenerateApi<E = never> {
+    readonly text: GenerateTextOperation<E>;
+}
+export type Endpoint9_0Input = {
+    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 ProviderListOperation<E = never> = (input?: Endpoint9_0Input) => Effect.Effect<Endpoint9_0Output, E>;
+export type Endpoint9_1Input = {
+    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 ProviderGetOperation<E = never> = (input: Endpoint9_1Input) => Effect.Effect<Endpoint9_1Output, E>;
+export interface ProviderApi<E = never> {
+    readonly list: ProviderListOperation<E>;
+    readonly get: ProviderGetOperation<E>;
+}
+export type Endpoint10_0Input = {
+    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 IntegrationListOperation<E = never> = (input?: Endpoint10_0Input) => Effect.Effect<Endpoint10_0Output, E>;
+export type Endpoint10_1Input = {
+    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 IntegrationGetOperation<E = never> = (input: Endpoint10_1Input) => Effect.Effect<Endpoint10_1Output, E>;
+export type Endpoint10_2Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly url: string;
+};
+export type Endpoint10_2Output = void;
+export type IntegrationWellknownAddOperation<E = never> = (input: Endpoint10_2Input) => Effect.Effect<Endpoint10_2Output, E>;
+export type Endpoint10_3Input = {
+    readonly integrationID: Integration.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly key: string;
+    readonly answer?: Form.Answer | undefined;
+    readonly label?: string | undefined;
+};
+export type Endpoint10_3Output = void;
+export type IntegrationConnectKeyOperation<E = never> = (input: Endpoint10_3Input) => Effect.Effect<Endpoint10_3Output, E>;
+export type Endpoint10_4Input = {
+    readonly integrationID: Integration.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly methodID: Integration.MethodID;
+    readonly answer?: Form.Answer | undefined;
+    readonly label?: string | undefined;
+};
+export type Endpoint10_4Output = {
+    readonly location: Location.Info;
+    readonly data: Integration.Attempt;
+};
+export type IntegrationOauthConnectOperation<E = never> = (input: Endpoint10_4Input) => Effect.Effect<Endpoint10_4Output, E>;
+export type Endpoint10_5Input = {
+    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 IntegrationOauthStatusOperation<E = never> = (input: Endpoint10_5Input) => Effect.Effect<Endpoint10_5Output, E>;
+export type Endpoint10_6Input = {
+    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>;
+export type Endpoint10_7Input = {
+    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>;
+export type Endpoint10_8Input = {
+    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 IntegrationCommandConnectOperation<E = never> = (input: Endpoint10_8Input) => Effect.Effect<Endpoint10_8Output, E>;
+export type Endpoint10_9Input = {
+    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 IntegrationCommandStatusOperation<E = never> = (input: Endpoint10_9Input) => Effect.Effect<Endpoint10_9Output, E>;
+export type Endpoint10_10Input = {
+    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>;
+    readonly get: IntegrationGetOperation<E>;
+    readonly wellknown: {
+        readonly add: IntegrationWellknownAddOperation<E>;
+    };
+    readonly connect: {
+        readonly key: IntegrationConnectKeyOperation<E>;
+    };
+    readonly oauth: {
+        readonly connect: IntegrationOauthConnectOperation<E>;
+        readonly status: IntegrationOauthStatusOperation<E>;
+        readonly complete: IntegrationOauthCompleteOperation<E>;
+        readonly cancel: IntegrationOauthCancelOperation<E>;
+    };
+    readonly command: {
+        readonly connect: IntegrationCommandConnectOperation<E>;
+        readonly status: IntegrationCommandStatusOperation<E>;
+        readonly cancel: IntegrationCommandCancelOperation<E>;
+    };
+}
+export type Endpoint11_0Input = {
+    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 McpListOperation<E = never> = (input?: Endpoint11_0Input) => Effect.Effect<Endpoint11_0Output, E>;
+export type Endpoint11_1Input = {
+    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>;
+export type Endpoint11_2Input = {
+    readonly server: string;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint11_2Output = void;
+export type McpRemoveOperation<E = never> = (input: Endpoint11_2Input) => Effect.Effect<Endpoint11_2Output, E>;
+export type Endpoint11_3Input = {
+    readonly server: string;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint11_3Output = void;
+export type McpConnectOperation<E = never> = (input: Endpoint11_3Input) => Effect.Effect<Endpoint11_3Output, E>;
+export type Endpoint11_4Input = {
+    readonly server: string;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint11_4Output = void;
+export type McpDisconnectOperation<E = never> = (input: Endpoint11_4Input) => Effect.Effect<Endpoint11_4Output, E>;
+export type Endpoint11_5Input = {
+    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 McpResourceCatalogOperation<E = never> = (input?: Endpoint11_5Input) => Effect.Effect<Endpoint11_5Output, E>;
+export interface McpApi<E = never> {
+    readonly list: McpListOperation<E>;
+    readonly add: McpAddOperation<E>;
+    readonly remove: McpRemoveOperation<E>;
+    readonly connect: McpConnectOperation<E>;
+    readonly disconnect: McpDisconnectOperation<E>;
+    readonly resource: {
+        readonly catalog: McpResourceCatalogOperation<E>;
+    };
+}
+export type Endpoint12_0Input = {
+    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>;
+export type Endpoint12_1Input = {
+    readonly credentialID: Credential.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+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 = ReadonlyArray<Project.Info>;
+export type ProjectListOperation<E = never> = () => Effect.Effect<Endpoint13_0Output, E>;
+export type Endpoint13_1Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint13_1Output = Project.Current;
+export type ProjectCurrentOperation<E = never> = (input?: Endpoint13_1Input) => Effect.Effect<Endpoint13_1Output, E>;
+export interface ProjectApi<E = never> {
+    readonly list: ProjectListOperation<E>;
+    readonly current: ProjectCurrentOperation<E>;
+}
+export type Endpoint14_0Input = {
+    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 FormRequestListOperation<E = never> = (input?: Endpoint14_0Input) => Effect.Effect<Endpoint14_0Output, E>;
+export type Endpoint14_1Input = {
+    readonly sessionID: string;
+};
+export type Endpoint14_1Output = ReadonlyArray<Form.Info>;
+export type FormListOperation<E = never> = (input: Endpoint14_1Input) => Effect.Effect<Endpoint14_1Output, E>;
+export type Endpoint14_2Input = {
+    readonly sessionID: string;
+    readonly id?: Form.ID | undefined;
+    readonly title: string;
+    readonly metadata?: Form.Metadata | undefined;
+    readonly fields: Form.Fields;
+};
+export type Endpoint14_2Output = Form.Info;
+export type FormCreateOperation<E = never> = (input: Endpoint14_2Input) => Effect.Effect<Endpoint14_2Output, E>;
+export type Endpoint14_3Input = {
+    readonly sessionID: string;
+    readonly formID: Form.ID;
+};
+export type Endpoint14_3Output = Form.Info;
+export type FormGetOperation<E = never> = (input: Endpoint14_3Input) => Effect.Effect<Endpoint14_3Output, E>;
+export type Endpoint14_4Input = {
+    readonly sessionID: string;
+    readonly formID: Form.ID;
+};
+export type Endpoint14_4Output = Form.State;
+export type FormStateOperation<E = never> = (input: Endpoint14_4Input) => Effect.Effect<Endpoint14_4Output, E>;
+export type Endpoint14_5Input = {
+    readonly sessionID: string;
+    readonly formID: Form.ID;
+    readonly answer: Form.Answer;
+};
+export type Endpoint14_5Output = void;
+export type FormReplyOperation<E = never> = (input: Endpoint14_5Input) => Effect.Effect<Endpoint14_5Output, E>;
+export type Endpoint14_6Input = {
+    readonly sessionID: string;
+    readonly formID: Form.ID;
+};
+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: {
+        readonly list: FormRequestListOperation<E>;
+    };
+    readonly list: FormListOperation<E>;
+    readonly create: FormCreateOperation<E>;
+    readonly get: FormGetOperation<E>;
+    readonly state: FormStateOperation<E>;
+    readonly reply: FormReplyOperation<E>;
+    readonly cancel: FormCancelOperation<E>;
+}
+export type Endpoint15_0Input = {
+    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 PermissionRequestListOperation<E = never> = (input?: Endpoint15_0Input) => Effect.Effect<Endpoint15_0Output, E>;
+export type Endpoint15_1Input = {
+    readonly projectID?: Project.ID | undefined;
+};
+export type Endpoint15_1Output = ReadonlyArray<PermissionSaved.Info>;
+export type PermissionSavedListOperation<E = never> = (input?: Endpoint15_1Input) => Effect.Effect<Endpoint15_1Output, E>;
+export type Endpoint15_2Input = {
+    readonly id: PermissionSaved.ID;
+};
+export type Endpoint15_2Output = void;
+export type PermissionSavedRemoveOperation<E = never> = (input: Endpoint15_2Input) => Effect.Effect<Endpoint15_2Output, E>;
+export type Endpoint15_3Input = {
+    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>;
+export type Endpoint15_4Input = {
+    readonly sessionID: Session.ID;
+};
+export type Endpoint15_4Output = ReadonlyArray<Permission.Request>;
+export type PermissionListOperation<E = never> = (input: Endpoint15_4Input) => Effect.Effect<Endpoint15_4Output, E>;
+export type Endpoint15_5Input = {
+    readonly sessionID: Session.ID;
+    readonly requestID: Permission.ID;
+};
+export type Endpoint15_5Output = Permission.Request;
+export type PermissionGetOperation<E = never> = (input: Endpoint15_5Input) => Effect.Effect<Endpoint15_5Output, E>;
+export type Endpoint15_6Input = {
+    readonly sessionID: Session.ID;
+    readonly requestID: Permission.ID;
+    readonly reply: Permission.Reply;
+    readonly message?: string | undefined;
+};
+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: {
+        readonly list: PermissionRequestListOperation<E>;
+    };
+    readonly saved: {
+        readonly list: PermissionSavedListOperation<E>;
+        readonly remove: PermissionSavedRemoveOperation<E>;
+    };
+    readonly create: PermissionCreateOperation<E>;
+    readonly list: PermissionListOperation<E>;
+    readonly get: PermissionGetOperation<E>;
+    readonly reply: PermissionReplyOperation<E>;
+}
+export type Endpoint16_0Input = {
+    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 FileListOperation<E = never> = (input?: Endpoint16_0Input) => Effect.Effect<Endpoint16_0Output, E>;
+export type Endpoint16_1Input = {
+    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 FileFindOperation<E = never> = (input: Endpoint16_1Input) => Effect.Effect<Endpoint16_1Output, E>;
+export interface FileApi<E = never> {
+    readonly list: FileListOperation<E>;
+    readonly find: FileFindOperation<E>;
+}
+export type Endpoint17_0Input = {
+    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 CommandListOperation<E = never> = (input?: Endpoint17_0Input) => Effect.Effect<Endpoint17_0Output, E>;
+export interface CommandApi<E = never> {
+    readonly list: CommandListOperation<E>;
+}
+export type Endpoint18_0Input = {
+    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 SkillListOperation<E = never> = (input?: Endpoint18_0Input) => Effect.Effect<Endpoint18_0Output, E>;
+export interface SkillApi<E = never> {
+    readonly list: SkillListOperation<E>;
+}
+export type Endpoint19_0Output = OpenCodeEvent;
+export type EventSubscribeOperation<E = never> = () => Stream.Stream<Endpoint19_0Output, E>;
+export interface EventApi<E = never> {
+    readonly subscribe: EventSubscribeOperation<E>;
+}
+export type Endpoint20_0Input = {
+    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 PtyListOperation<E = never> = (input?: Endpoint20_0Input) => Effect.Effect<Endpoint20_0Output, E>;
+export type Endpoint20_1Input = {
+    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>;
+export type Endpoint20_2Input = {
+    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 PtyGetOperation<E = never> = (input: Endpoint20_2Input) => Effect.Effect<Endpoint20_2Output, E>;
+export type Endpoint20_3Input = {
+    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 PtyUpdateOperation<E = never> = (input: Endpoint20_3Input) => Effect.Effect<Endpoint20_3Output, E>;
+export type Endpoint20_4Input = {
+    readonly ptyID: Pty.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+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>;
+    readonly create: PtyCreateOperation<E>;
+    readonly get: PtyGetOperation<E>;
+    readonly update: PtyUpdateOperation<E>;
+    readonly remove: PtyRemoveOperation<E>;
+}
+export type Endpoint21_0Input = {
+    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 ShellListOperation<E = never> = (input?: Endpoint21_0Input) => Effect.Effect<Endpoint21_0Output, E>;
+export type Endpoint21_1Input = {
+    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 ShellCreateOperation<E = never> = (input: Endpoint21_1Input) => Effect.Effect<Endpoint21_1Output, E>;
+export type Endpoint21_2Input = {
+    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 ShellGetOperation<E = never> = (input: Endpoint21_2Input) => Effect.Effect<Endpoint21_2Output, E>;
+export type Endpoint21_3Input = {
+    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 ShellTimeoutOperation<E = never> = (input: Endpoint21_3Input) => Effect.Effect<Endpoint21_3Output, E>;
+export type Endpoint21_4Input = {
+    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 ShellOutputOperation<E = never> = (input: Endpoint21_4Input) => Effect.Effect<Endpoint21_4Output, E>;
+export type Endpoint21_5Input = {
+    readonly id: Shell.ID;
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+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>;
+    readonly create: ShellCreateOperation<E>;
+    readonly get: ShellGetOperation<E>;
+    readonly timeout: ShellTimeoutOperation<E>;
+    readonly output: ShellOutputOperation<E>;
+    readonly remove: ShellRemoveOperation<E>;
+}
+export type Endpoint22_0Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint22_0Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Reference.Info>;
+};
+export type ReferenceListOperation<E = never> = (input?: Endpoint22_0Input) => Effect.Effect<Endpoint22_0Output, E>;
+export interface ReferenceApi<E = never> {
+    readonly list: ReferenceListOperation<E>;
+}
+export type Endpoint23_0Input = {
+    readonly projectID: Project.ID;
+};
+export type Endpoint23_0Output = Worktree.List;
+export type WorktreeListOperation<E = never> = (input: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>;
+export type Endpoint23_1Input = {
+    readonly projectID: Project.ID;
+    readonly strategy: Worktree.StrategyID;
+    readonly from?: AbsolutePath | undefined;
+    readonly directory: AbsolutePath;
+    readonly name?: string | undefined;
+};
+export type Endpoint23_1Output = Worktree.Info;
+export type WorktreeCreateOperation<E = never> = (input: Endpoint23_1Input) => Effect.Effect<Endpoint23_1Output, E>;
+export type Endpoint23_2Input = {
+    readonly projectID: Project.ID;
+    readonly directory: AbsolutePath;
+    readonly force: boolean;
+};
+export type Endpoint23_2Output = void;
+export type WorktreeRemoveOperation<E = never> = (input: Endpoint23_2Input) => Effect.Effect<Endpoint23_2Output, E>;
+export type Endpoint23_3Input = {
+    readonly projectID: Project.ID;
+};
+export type Endpoint23_3Output = void;
+export type WorktreeRefreshOperation<E = never> = (input: Endpoint23_3Input) => Effect.Effect<Endpoint23_3Output, E>;
+export interface WorktreeApi<E = never> {
+    readonly list: WorktreeListOperation<E>;
+    readonly create: WorktreeCreateOperation<E>;
+    readonly remove: WorktreeRemoveOperation<E>;
+    readonly refresh: WorktreeRefreshOperation<E>;
+}
+export type Endpoint24_0Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint24_0Output = {
+    readonly location: Location.Info;
+    readonly data: Vcs.Info;
+};
+export type VcsGetOperation<E = never> = (input?: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>;
+export type Endpoint24_1Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint24_1Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<Vcs.FileStatus>;
+};
+export type VcsStatusOperation<E = never> = (input?: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>;
+export type Endpoint24_2Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+    readonly mode: Vcs.Mode;
+    readonly context?: number | undefined;
+};
+export type Endpoint24_2Output = {
+    readonly location: Location.Info;
+    readonly data: ReadonlyArray<FileDiff.Info>;
+};
+export type VcsDiffOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>;
+export interface VcsApi<E = never> {
+    readonly get: VcsGetOperation<E>;
+    readonly status: VcsStatusOperation<E>;
+    readonly diff: VcsDiffOperation<E>;
+}
+export type Endpoint25_0Output = ReadonlyArray<Location.Ref>;
+export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint25_0Output, E>;
+export type Endpoint25_1Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint25_1Output = void;
+export type DebugLocationEvictOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>;
+export interface DebugApi<E = never> {
+    readonly location: {
+        readonly list: DebugLocationListOperation<E>;
+        readonly evict: DebugLocationEvictOperation<E>;
+    };
+}
+export type Endpoint26_0Output = {
+    readonly status: "required" | "completed";
+} | {
+    readonly status: "running";
+    readonly progress: {
+        readonly label: string;
+        readonly numerator?: number | undefined;
+        readonly denominator?: number | undefined;
+    };
+} | {
+    readonly status: "error";
+    readonly error: string;
+};
+export type MigrationV1StatusOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>;
+export interface MigrationApi<E = never> {
+    readonly v1: {
+        readonly status: MigrationV1StatusOperation<E>;
+    };
+}
+export type Endpoint27_0Input = {
+    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 WebsearchProvidersOperation<E = never> = (input?: Endpoint27_0Input) => Effect.Effect<Endpoint27_0Output, E>;
+export type Endpoint27_1Input = {
+    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 WebsearchQueryOperation<E = never> = (input: Endpoint27_1Input) => Effect.Effect<Endpoint27_1Output, E>;
+export interface WebsearchApi<E = never> {
+    readonly providers: WebsearchProvidersOperation<E>;
+    readonly query: WebsearchQueryOperation<E>;
+}
+export type Endpoint28_0Input = {
+    readonly location?: {
+        readonly directory?: string | undefined;
+        readonly workspace?: string | undefined;
+    } | undefined;
+};
+export type Endpoint28_0Output = ReadonlyArray<Config.Entry>;
+export type ConfigGetOperation<E = never> = (input?: Endpoint28_0Input) => Effect.Effect<Endpoint28_0Output, E>;
+export interface ConfigApi<E = never> {
+    readonly get: ConfigGetOperation<E>;
+}
+export interface AppApi<E = never> {
+    readonly health: HealthApi<E>;
+    readonly server: ServerApi<E>;
+    readonly location: LocationApi<E>;
+    readonly agent: AgentApi<E>;
+    readonly plugin: PluginApi<E>;
+    readonly session: SessionApi<E>;
+    readonly message: MessageApi<E>;
+    readonly model: ModelApi<E>;
+    readonly generate: GenerateApi<E>;
+    readonly provider: ProviderApi<E>;
+    readonly integration: IntegrationApi<E>;
+    readonly mcp: McpApi<E>;
+    readonly credential: CredentialApi<E>;
+    readonly project: ProjectApi<E>;
+    readonly form: FormApi<E>;
+    readonly permission: PermissionApi<E>;
+    readonly file: FileApi<E>;
+    readonly command: CommandApi<E>;
+    readonly skill: SkillApi<E>;
+    readonly event: EventApi<E>;
+    readonly pty: PtyApi<E>;
+    readonly shell: ShellApi<E>;
+    readonly reference: ReferenceApi<E>;
+    readonly worktree: WorktreeApi<E>;
+    readonly vcs: VcsApi<E>;
+    readonly debug: DebugApi<E>;
+    readonly migration: MigrationApi<E>;
+    readonly websearch: WebsearchApi<E>;
+    readonly config: ConfigApi<E>;
+}