diff --git a/bun.lock b/bun.lock
index 6e8f024ea2d..adc5d77d8ae 100644
--- a/bun.lock
+++ b/bun.lock
@@ -119,6 +119,7 @@
         "semver": "catalog:",
         "solid-js": "catalog:",
         "strip-ansi": "7.1.2",
+        "uqr": "0.1.3",
       },
       "devDependencies": {
         "@opencode-ai/script": "workspace:*",
@@ -1016,6 +1017,7 @@
         "remeda": "catalog:",
         "solid-js": "catalog:",
         "strip-ansi": "7.1.2",
+        "uqr": "0.1.3",
       },
       "devDependencies": {
         "@tsconfig/bun": "catalog:",
@@ -5950,6 +5952,8 @@
 
     "update-browserslist-db": ["update-browserslist-db@1.2.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="],
 
+    "uqr": ["uqr@0.1.3", "", {}, "sha512-0rjE8iEJe4YmT9TOhwsZtqCMRLc5DXZUI2UEYUUg63ikBkqqE5EYWaI0etFe/5KUcmcYwLih2RND1kq+hrUJXA=="],
+
     "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
 
     "urijs": ["urijs@1.19.11", "", {}, "sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ=="],
diff --git a/packages/cli/package.json b/packages/cli/package.json
index d924dd6a3a2..3c243a5da51 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -50,7 +50,8 @@
     "opentui-spinner": "catalog:",
     "semver": "catalog:",
     "solid-js": "catalog:",
-    "strip-ansi": "7.1.2"
+    "strip-ansi": "7.1.2",
+    "uqr": "0.1.3"
   },
   "devDependencies": {
     "@opencode-ai/script": "workspace:*",
diff --git a/packages/cli/src/commands/commands.ts b/packages/cli/src/commands/commands.ts
index d3a5e0b8136..f4a9b452bda 100644
--- a/packages/cli/src/commands/commands.ts
+++ b/packages/cli/src/commands/commands.ts
@@ -225,6 +225,7 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
         }),
       ],
     }),
+    Spec.make("link", { description: "Show server connection information" }),
     Spec.make("serve", {
       description: "Start the v2 API server",
       params: {
diff --git a/packages/cli/src/commands/handlers/link.ts b/packages/cli/src/commands/handlers/link.ts
new file mode 100644
index 00000000000..d4d5c02ab17
--- /dev/null
+++ b/packages/cli/src/commands/handlers/link.ts
@@ -0,0 +1,43 @@
+import { EOL } from "os"
+import { Effect } from "effect"
+import { Service } from "@opencode-ai/client/effect"
+import { OpenCode } from "@opencode-ai/client/promise"
+import { renderUnicodeCompact } from "uqr"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { ServiceConfig } from "../../services/service-config"
+
+export default Runtime.handler(
+  Commands.commands.link,
+  Effect.fn("cli.link")(function* () {
+    const transport = yield* Service.start(yield* ServiceConfig.options())
+    const password = yield* ServiceConfig.password()
+    const server = yield* Effect.tryPromise(() =>
+      OpenCode.make({ baseUrl: transport.url, headers: transport.headers }).server.get(),
+    )
+    const info = { urls: server.urls, username: "opencode", password }
+    process.stdout.write(
+      [
+        "",
+        `  URLs      ${info.urls[0] ?? "(none)"}`,
+        ...info.urls.slice(1).map((url) => `            ${url}`),
+        `  Username  ${info.username}`,
+        `  Password  ${info.password}`,
+        "",
+        "  Scan to connect",
+        "",
+        renderUnicodeCompact(JSON.stringify(info), { border: 2 })
+          .split(EOL)
+          .map((line) => "  " + line)
+          .join(EOL),
+        "",
+      ].join(EOL) + EOL,
+    )
+
+    const hostname = new URL(transport.url).hostname
+    if (!["localhost", "127.0.0.1", "[::1]"].includes(hostname)) return
+    process.stderr.write(
+      `  Run \`opencode service set hostname 0.0.0.0\` to access the service remotely.${EOL}${EOL}`,
+    )
+  }),
+)
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
index d6d758c95de..f25dd7938cf 100755
--- a/packages/cli/src/index.ts
+++ b/packages/cli/src/index.ts
@@ -36,6 +36,7 @@ const Handlers = Runtime.handlers(Commands, {
   migrate: () => import("./commands/handlers/migrate"),
   mini: () => import("./commands/handlers/mini"),
   run: () => import("./commands/handlers/run"),
+  link: () => import("./commands/handlers/link"),
   service: {
     start: () => import("./commands/handlers/service/start"),
     restart: () => import("./commands/handlers/service/restart"),
diff --git a/packages/cli/src/tui.ts b/packages/cli/src/tui.ts
index e9d25911acf..8babf9b2532 100644
--- a/packages/cli/src/tui.ts
+++ b/packages/cli/src/tui.ts
@@ -30,6 +30,7 @@ export function runTui(
     return yield* run({
       client: createOpencodeClient({ ...options, directory }),
       api,
+      link: linkCredentials(transport),
       discover: discover
         ? async () => {
             const next = await discover()
@@ -64,3 +65,12 @@ export function runTui(
     })
   }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)))
 }
+
+function linkCredentials(transport: Service.Transport) {
+  const authorization = new Headers(transport.headers).get("authorization")
+  if (!authorization?.startsWith("Basic ")) return { username: "opencode", password: "" }
+  const value = atob(authorization.slice("Basic ".length))
+  const separator = value.indexOf(":")
+  if (separator === -1) return { username: "opencode", password: "" }
+  return { username: value.slice(0, separator), password: value.slice(separator + 1) }
+}
diff --git a/packages/client/src/effect/api/api.ts b/packages/client/src/effect/api/api.ts
index 64d11eefaa2..d5c6474f45b 100644
--- a/packages/client/src/effect/api/api.ts
+++ b/packages/client/src/effect/api/api.ts
@@ -14,264 +14,271 @@ export interface HealthApi<E = never> {
   readonly get: HealthGetOperation<E>
 }
 
-type Endpoint1_0Request = Parameters<RawClient["server.location"]["location.get"]>[0]
-export type Endpoint1_0Input = { readonly location?: Endpoint1_0Request["query"]["location"] }
-export type Endpoint1_0Output = EffectValue<ReturnType<RawClient["server.location"]["location.get"]>>
-export type LocationGetOperation<E = never> = (input?: Endpoint1_0Input) => Effect.Effect<Endpoint1_0Output, E>
+export type Endpoint1_0Output = EffectValue<ReturnType<RawClient["server.server"]["server.get"]>>
+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"] }
+export type Endpoint2_0Output = EffectValue<ReturnType<RawClient["server.location"]["location.get"]>>
+export type LocationGetOperation<E = never> = (input?: Endpoint2_0Input) => Effect.Effect<Endpoint2_0Output, E>
 
 export interface LocationApi<E = never> {
   readonly get: LocationGetOperation<E>
 }
 
-type Endpoint2_0Request = Parameters<RawClient["server.agent"]["agent.list"]>[0]
-export type Endpoint2_0Input = { readonly location?: Endpoint2_0Request["query"]["location"] }
-export type Endpoint2_0Output = EffectValue<ReturnType<RawClient["server.agent"]["agent.list"]>>
-export type AgentListOperation<E = never> = (input?: Endpoint2_0Input) => Effect.Effect<Endpoint2_0Output, E>
+type Endpoint3_0Request = Parameters<RawClient["server.agent"]["agent.list"]>[0]
+export type Endpoint3_0Input = { readonly location?: Endpoint3_0Request["query"]["location"] }
+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 interface AgentApi<E = never> {
   readonly list: AgentListOperation<E>
 }
 
-type Endpoint3_0Request = Parameters<RawClient["server.plugin"]["plugin.list"]>[0]
-export type Endpoint3_0Input = { readonly location?: Endpoint3_0Request["query"]["location"] }
-export type Endpoint3_0Output = EffectValue<ReturnType<RawClient["server.plugin"]["plugin.list"]>>
-export type PluginListOperation<E = never> = (input?: Endpoint3_0Input) => Effect.Effect<Endpoint3_0Output, E>
+type Endpoint4_0Request = Parameters<RawClient["server.plugin"]["plugin.list"]>[0]
+export type Endpoint4_0Input = { readonly location?: Endpoint4_0Request["query"]["location"] }
+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 Endpoint4_0Request = Parameters<RawClient["server.session"]["session.list"]>[0]
-export type Endpoint4_0Input = {
-  readonly workspace?: Endpoint4_0Request["query"]["workspace"]
-  readonly limit?: Endpoint4_0Request["query"]["limit"]
-  readonly order?: Endpoint4_0Request["query"]["order"]
-  readonly search?: Endpoint4_0Request["query"]["search"]
-  readonly parentID?: Endpoint4_0Request["query"]["parentID"]
-  readonly directory?: Endpoint4_0Request["query"]["directory"]
-  readonly project?: Endpoint4_0Request["query"]["project"]
-  readonly subpath?: Endpoint4_0Request["query"]["subpath"]
-  readonly cursor?: Endpoint4_0Request["query"]["cursor"]
+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 Endpoint4_0Output = EffectValue<ReturnType<RawClient["server.session"]["session.list"]>>
-export type SessionListOperation<E = never> = (input?: Endpoint4_0Input) => Effect.Effect<Endpoint4_0Output, E>
+export type Endpoint5_0Output = EffectValue<ReturnType<RawClient["server.session"]["session.list"]>>
+export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effect.Effect<Endpoint5_0Output, E>
 
-type Endpoint4_1Request = Parameters<RawClient["server.session"]["session.create"]>[0]
-export type Endpoint4_1Input = {
-  readonly id?: Endpoint4_1Request["payload"]["id"]
-  readonly agent?: Endpoint4_1Request["payload"]["agent"]
-  readonly model?: Endpoint4_1Request["payload"]["model"]
-  readonly location?: Endpoint4_1Request["payload"]["location"]
+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"]
 }
-export type Endpoint4_1Output = EffectValue<ReturnType<RawClient["server.session"]["session.create"]>>["data"]
-export type SessionCreateOperation<E = never> = (input?: Endpoint4_1Input) => Effect.Effect<Endpoint4_1Output, E>
+export type Endpoint5_1Output = EffectValue<ReturnType<RawClient["server.session"]["session.create"]>>["data"]
+export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
 
-export type Endpoint4_2Output = EffectValue<ReturnType<RawClient["server.session"]["session.active"]>>["data"]
-export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint4_2Output, E>
+export type Endpoint5_2Output = EffectValue<ReturnType<RawClient["server.session"]["session.active"]>>["data"]
+export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_2Output, E>
 
-type Endpoint4_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
-export type Endpoint4_3Input = { readonly sessionID: Endpoint4_3Request["params"]["sessionID"] }
-export type Endpoint4_3Output = EffectValue<ReturnType<RawClient["server.session"]["session.get"]>>["data"]
-export type SessionGetOperation<E = never> = (input: Endpoint4_3Input) => Effect.Effect<Endpoint4_3Output, E>
+type Endpoint5_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
+export type Endpoint5_3Input = { readonly sessionID: Endpoint5_3Request["params"]["sessionID"] }
+export type Endpoint5_3Output = EffectValue<ReturnType<RawClient["server.session"]["session.get"]>>["data"]
+export type SessionGetOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>
 
-type Endpoint4_4Request = Parameters<RawClient["server.session"]["session.remove"]>[0]
-export type Endpoint4_4Input = { readonly sessionID: Endpoint4_4Request["params"]["sessionID"] }
-export type Endpoint4_4Output = EffectValue<ReturnType<RawClient["server.session"]["session.remove"]>>
-export type SessionRemoveOperation<E = never> = (input: Endpoint4_4Input) => Effect.Effect<Endpoint4_4Output, E>
+type Endpoint5_4Request = Parameters<RawClient["server.session"]["session.remove"]>[0]
+export type Endpoint5_4Input = { readonly sessionID: Endpoint5_4Request["params"]["sessionID"] }
+export type Endpoint5_4Output = EffectValue<ReturnType<RawClient["server.session"]["session.remove"]>>
+export type SessionRemoveOperation<E = never> = (input: Endpoint5_4Input) => Effect.Effect<Endpoint5_4Output, E>
 
-type Endpoint4_5Request = Parameters<RawClient["server.session"]["session.fork"]>[0]
-export type Endpoint4_5Input = {
-  readonly sessionID: Endpoint4_5Request["params"]["sessionID"]
-  readonly messageID?: Endpoint4_5Request["payload"]["messageID"]
+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"]
 }
-export type Endpoint4_5Output = EffectValue<ReturnType<RawClient["server.session"]["session.fork"]>>["data"]
-export type SessionForkOperation<E = never> = (input: Endpoint4_5Input) => Effect.Effect<Endpoint4_5Output, E>
+export type Endpoint5_5Output = EffectValue<ReturnType<RawClient["server.session"]["session.fork"]>>["data"]
+export type SessionForkOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>
 
-type Endpoint4_6Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
-export type Endpoint4_6Input = {
-  readonly sessionID: Endpoint4_6Request["params"]["sessionID"]
-  readonly agent: Endpoint4_6Request["payload"]["agent"]
+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"]
 }
-export type Endpoint4_6Output = EffectValue<ReturnType<RawClient["server.session"]["session.switchAgent"]>>
-export type SessionSwitchAgentOperation<E = never> = (input: Endpoint4_6Input) => Effect.Effect<Endpoint4_6Output, E>
+export type Endpoint5_6Output = EffectValue<ReturnType<RawClient["server.session"]["session.switchAgent"]>>
+export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>
 
-type Endpoint4_7Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
-export type Endpoint4_7Input = {
-  readonly sessionID: Endpoint4_7Request["params"]["sessionID"]
-  readonly model: Endpoint4_7Request["payload"]["model"]
+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"]
 }
-export type Endpoint4_7Output = EffectValue<ReturnType<RawClient["server.session"]["session.switchModel"]>>
-export type SessionSwitchModelOperation<E = never> = (input: Endpoint4_7Input) => Effect.Effect<Endpoint4_7Output, E>
+export type Endpoint5_7Output = EffectValue<ReturnType<RawClient["server.session"]["session.switchModel"]>>
+export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>
 
-type Endpoint4_8Request = Parameters<RawClient["server.session"]["session.rename"]>[0]
-export type Endpoint4_8Input = {
-  readonly sessionID: Endpoint4_8Request["params"]["sessionID"]
-  readonly title: Endpoint4_8Request["payload"]["title"]
+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"]
 }
-export type Endpoint4_8Output = EffectValue<ReturnType<RawClient["server.session"]["session.rename"]>>
-export type SessionRenameOperation<E = never> = (input: Endpoint4_8Input) => Effect.Effect<Endpoint4_8Output, E>
+export type Endpoint5_8Output = EffectValue<ReturnType<RawClient["server.session"]["session.rename"]>>
+export type SessionRenameOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>
 
-type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
-export type Endpoint4_9Input = {
-  readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
-  readonly destination: Endpoint4_9Request["payload"]["destination"]
-  readonly moveChanges?: Endpoint4_9Request["payload"]["moveChanges"]
+type Endpoint5_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
+export type Endpoint5_9Input = {
+  readonly sessionID: Endpoint5_9Request["params"]["sessionID"]
+  readonly destination: Endpoint5_9Request["payload"]["destination"]
+  readonly moveChanges?: Endpoint5_9Request["payload"]["moveChanges"]
 }
-export type Endpoint4_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.move"]>>
-export type SessionMoveOperation<E = never> = (input: Endpoint4_9Input) => Effect.Effect<Endpoint4_9Output, E>
+export type Endpoint5_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.move"]>>
+export type SessionMoveOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>
 
-type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
-export type Endpoint4_10Input = {
-  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
-  readonly id?: Endpoint4_10Request["payload"]["id"]
-  readonly prompt: Endpoint4_10Request["payload"]["prompt"]
-  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_10Request["payload"]["resume"]
+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 prompt: Endpoint5_10Request["payload"]["prompt"]
+  readonly delivery?: Endpoint5_10Request["payload"]["delivery"]
+  readonly resume?: Endpoint5_10Request["payload"]["resume"]
 }
-export type Endpoint4_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
-export type SessionPromptOperation<E = never> = (input: Endpoint4_10Input) => Effect.Effect<Endpoint4_10Output, E>
+export type Endpoint5_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
+export type SessionPromptOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>
 
-type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
-export type Endpoint4_11Input = {
-  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
-  readonly id?: Endpoint4_11Request["payload"]["id"]
-  readonly command: Endpoint4_11Request["payload"]["command"]
-  readonly arguments?: Endpoint4_11Request["payload"]["arguments"]
-  readonly agent?: Endpoint4_11Request["payload"]["agent"]
-  readonly model?: Endpoint4_11Request["payload"]["model"]
-  readonly files?: Endpoint4_11Request["payload"]["files"]
-  readonly agents?: Endpoint4_11Request["payload"]["agents"]
-  readonly delivery?: Endpoint4_11Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_11Request["payload"]["resume"]
+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 Endpoint4_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
-export type SessionCommandOperation<E = never> = (input: Endpoint4_11Input) => Effect.Effect<Endpoint4_11Output, E>
+export type Endpoint5_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
+export type SessionCommandOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
 
-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
-export type Endpoint4_12Input = {
-  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly id?: Endpoint4_12Request["payload"]["id"]
-  readonly skill: Endpoint4_12Request["payload"]["skill"]
-  readonly resume?: Endpoint4_12Request["payload"]["resume"]
+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"]
 }
-export type Endpoint4_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
-export type SessionSkillOperation<E = never> = (input: Endpoint4_12Input) => Effect.Effect<Endpoint4_12Output, E>
+export type Endpoint5_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
+export type SessionSkillOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
 
-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
-export type Endpoint4_13Input = {
-  readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
-  readonly text: Endpoint4_13Request["payload"]["text"]
-  readonly description?: Endpoint4_13Request["payload"]["description"]
-  readonly metadata?: Endpoint4_13Request["payload"]["metadata"]
-  readonly resume?: Endpoint4_13Request["payload"]["resume"]
+type Endpoint5_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+export type Endpoint5_13Input = {
+  readonly sessionID: Endpoint5_13Request["params"]["sessionID"]
+  readonly text: Endpoint5_13Request["payload"]["text"]
+  readonly description?: Endpoint5_13Request["payload"]["description"]
+  readonly metadata?: Endpoint5_13Request["payload"]["metadata"]
+  readonly resume?: Endpoint5_13Request["payload"]["resume"]
 }
-export type Endpoint4_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>
-export type SessionSyntheticOperation<E = never> = (input: Endpoint4_13Input) => Effect.Effect<Endpoint4_13Output, E>
+export type Endpoint5_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>
+export type SessionSyntheticOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
 
-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
-export type Endpoint4_14Input = {
-  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
-  readonly id?: Endpoint4_14Request["payload"]["id"]
-  readonly command: Endpoint4_14Request["payload"]["command"]
+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"]
 }
-export type Endpoint4_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
-export type SessionShellOperation<E = never> = (input: Endpoint4_14Input) => Effect.Effect<Endpoint4_14Output, E>
+export type Endpoint5_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
+export type SessionShellOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>
 
-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-export type Endpoint4_15Input = {
-  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
-  readonly id?: Endpoint4_15Request["payload"]["id"]
+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"]
 }
-export type Endpoint4_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
-export type SessionCompactOperation<E = never> = (input: Endpoint4_15Input) => Effect.Effect<Endpoint4_15Output, E>
+export type Endpoint5_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
+export type SessionCompactOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
 
-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-export type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
-export type Endpoint4_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
-export type SessionWaitOperation<E = never> = (input: Endpoint4_16Input) => Effect.Effect<Endpoint4_16Output, E>
+type Endpoint5_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+export type Endpoint5_16Input = { readonly sessionID: Endpoint5_16Request["params"]["sessionID"] }
+export type Endpoint5_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
+export type SessionWaitOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
 
-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-export type Endpoint4_17Input = {
-  readonly sessionID: Endpoint4_17Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_17Request["payload"]["messageID"]
-  readonly files?: Endpoint4_17Request["payload"]["files"]
+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"]
 }
-export type Endpoint4_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
-export type SessionRevertStageOperation<E = never> = (input: Endpoint4_17Input) => Effect.Effect<Endpoint4_17Output, E>
+export type Endpoint5_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
+export type SessionRevertStageOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
 
-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-export type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
-export type Endpoint4_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
-export type SessionRevertClearOperation<E = never> = (input: Endpoint4_18Input) => Effect.Effect<Endpoint4_18Output, E>
+type Endpoint5_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+export type Endpoint5_18Input = { readonly sessionID: Endpoint5_18Request["params"]["sessionID"] }
+export type Endpoint5_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
+export type SessionRevertClearOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
 
-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
-export type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
-export type Endpoint4_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
-export type SessionRevertCommitOperation<E = never> = (input: Endpoint4_19Input) => Effect.Effect<Endpoint4_19Output, E>
+type Endpoint5_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+export type Endpoint5_19Input = { readonly sessionID: Endpoint5_19Request["params"]["sessionID"] }
+export type Endpoint5_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
 
-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
-export type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
-export type Endpoint4_20Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
-export type SessionContextOperation<E = never> = (input: Endpoint4_20Input) => Effect.Effect<Endpoint4_20Output, E>
+type Endpoint5_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+export type Endpoint5_20Input = { readonly sessionID: Endpoint5_20Request["params"]["sessionID"] }
+export type Endpoint5_20Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
+export type SessionContextOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>
 
-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
-export type Endpoint4_21Input = { readonly sessionID: Endpoint4_21Request["params"]["sessionID"] }
-export type Endpoint4_21Output = EffectValue<
+type Endpoint5_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+export type Endpoint5_21Input = { readonly sessionID: Endpoint5_21Request["params"]["sessionID"] }
+export type Endpoint5_21Output = EffectValue<
   ReturnType<RawClient["server.session"]["session.instructions.entry.list"]>
 >["data"]
 export type SessionInstructionsEntryListOperation<E = never> = (
-  input: Endpoint4_21Input,
-) => Effect.Effect<Endpoint4_21Output, E>
+  input: Endpoint5_21Input,
+) => Effect.Effect<Endpoint5_21Output, E>
 
-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
-export type Endpoint4_22Input = {
-  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
-  readonly key: Endpoint4_22Request["params"]["key"]
-  readonly value: Endpoint4_22Request["payload"]["value"]
+type Endpoint5_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
+export type Endpoint5_22Input = {
+  readonly sessionID: Endpoint5_22Request["params"]["sessionID"]
+  readonly key: Endpoint5_22Request["params"]["key"]
+  readonly value: Endpoint5_22Request["payload"]["value"]
 }
-export type Endpoint4_22Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
+export type Endpoint5_22Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
 export type SessionInstructionsEntryPutOperation<E = never> = (
-  input: Endpoint4_22Input,
-) => Effect.Effect<Endpoint4_22Output, E>
+  input: Endpoint5_22Input,
+) => Effect.Effect<Endpoint5_22Output, E>
 
-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
-export type Endpoint4_23Input = {
-  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
-  readonly key: Endpoint4_23Request["params"]["key"]
+type Endpoint5_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
+export type Endpoint5_23Input = {
+  readonly sessionID: Endpoint5_23Request["params"]["sessionID"]
+  readonly key: Endpoint5_23Request["params"]["key"]
 }
-export type Endpoint4_23Output = EffectValue<
+export type Endpoint5_23Output = EffectValue<
   ReturnType<RawClient["server.session"]["session.instructions.entry.remove"]>
 >
 export type SessionInstructionsEntryRemoveOperation<E = never> = (
-  input: Endpoint4_23Input,
-) => Effect.Effect<Endpoint4_23Output, E>
+  input: Endpoint5_23Input,
+) => Effect.Effect<Endpoint5_23Output, E>
 
-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-export type Endpoint4_24Input = {
-  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
-  readonly after?: Endpoint4_24Request["query"]["after"]
-  readonly follow?: Endpoint4_24Request["query"]["follow"]
+type Endpoint5_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+export type Endpoint5_24Input = {
+  readonly sessionID: Endpoint5_24Request["params"]["sessionID"]
+  readonly after?: Endpoint5_24Request["query"]["after"]
+  readonly follow?: Endpoint5_24Request["query"]["follow"]
 }
-export type Endpoint4_24Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
-export type SessionLogOperation<E = never> = (input: Endpoint4_24Input) => Stream.Stream<Endpoint4_24Output, E>
+export type Endpoint5_24Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
+export type SessionLogOperation<E = never> = (input: Endpoint5_24Input) => Stream.Stream<Endpoint5_24Output, E>
 
-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-export type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
-export type Endpoint4_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
-export type SessionInterruptOperation<E = never> = (input: Endpoint4_25Input) => Effect.Effect<Endpoint4_25Output, E>
+type Endpoint5_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+export type Endpoint5_25Input = { readonly sessionID: Endpoint5_25Request["params"]["sessionID"] }
+export type Endpoint5_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
 
-type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
-export type Endpoint4_26Input = { readonly sessionID: Endpoint4_26Request["params"]["sessionID"] }
-export type Endpoint4_26Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
-export type SessionBackgroundOperation<E = never> = (input: Endpoint4_26Input) => Effect.Effect<Endpoint4_26Output, E>
+type Endpoint5_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+export type Endpoint5_26Input = { readonly sessionID: Endpoint5_26Request["params"]["sessionID"] }
+export type Endpoint5_26Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>
 
-type Endpoint4_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-export type Endpoint4_27Input = {
-  readonly sessionID: Endpoint4_27Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_27Request["params"]["messageID"]
+type Endpoint5_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+export type Endpoint5_27Input = {
+  readonly sessionID: Endpoint5_27Request["params"]["sessionID"]
+  readonly messageID: Endpoint5_27Request["params"]["messageID"]
 }
-export type Endpoint4_27Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
-export type SessionMessageOperation<E = never> = (input: Endpoint4_27Input) => Effect.Effect<Endpoint4_27Output, E>
+export type Endpoint5_27Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
+export type SessionMessageOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
 
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
@@ -310,132 +317,136 @@ export interface SessionApi<E = never> {
   readonly message: SessionMessageOperation<E>
 }
 
-type Endpoint5_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
-export type Endpoint5_0Input = {
-  readonly sessionID: Endpoint5_0Request["params"]["sessionID"]
-  readonly limit?: Endpoint5_0Request["query"]["limit"]
-  readonly order?: Endpoint5_0Request["query"]["order"]
-  readonly cursor?: Endpoint5_0Request["query"]["cursor"]
+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"]
 }
-export type Endpoint5_0Output = EffectValue<ReturnType<RawClient["server.message"]["session.messages"]>>
-export type MessageListOperation<E = never> = (input: Endpoint5_0Input) => Effect.Effect<Endpoint5_0Output, E>
+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 Endpoint6_0Request = Parameters<RawClient["server.model"]["model.list"]>[0]
-export type Endpoint6_0Input = { readonly location?: Endpoint6_0Request["query"]["location"] }
-export type Endpoint6_0Output = EffectValue<ReturnType<RawClient["server.model"]["model.list"]>>
-export type ModelListOperation<E = never> = (input?: Endpoint6_0Input) => Effect.Effect<Endpoint6_0Output, E>
+type Endpoint7_0Request = Parameters<RawClient["server.model"]["model.list"]>[0]
+export type Endpoint7_0Input = { readonly location?: Endpoint7_0Request["query"]["location"] }
+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 Endpoint6_1Request = Parameters<RawClient["server.model"]["model.default"]>[0]
-export type Endpoint6_1Input = { readonly location?: Endpoint6_1Request["query"]["location"] }
-export type Endpoint6_1Output = EffectValue<ReturnType<RawClient["server.model"]["model.default"]>>
-export type ModelDefaultOperation<E = never> = (input?: Endpoint6_1Input) => Effect.Effect<Endpoint6_1Output, E>
+type Endpoint7_1Request = Parameters<RawClient["server.model"]["model.default"]>[0]
+export type Endpoint7_1Input = { readonly location?: Endpoint7_1Request["query"]["location"] }
+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 Endpoint7_0Request = Parameters<RawClient["server.generate"]["generate.text"]>[0]
-export type Endpoint7_0Input = {
-  readonly location?: Endpoint7_0Request["query"]["location"]
-  readonly prompt: Endpoint7_0Request["payload"]["prompt"]
-  readonly model?: Endpoint7_0Request["payload"]["model"]
+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"]
 }
-export type Endpoint7_0Output = EffectValue<ReturnType<RawClient["server.generate"]["generate.text"]>>["data"]
-export type GenerateTextOperation<E = never> = (input: Endpoint7_0Input) => Effect.Effect<Endpoint7_0Output, E>
+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 Endpoint8_0Request = Parameters<RawClient["server.provider"]["provider.list"]>[0]
-export type Endpoint8_0Input = { readonly location?: Endpoint8_0Request["query"]["location"] }
-export type Endpoint8_0Output = EffectValue<ReturnType<RawClient["server.provider"]["provider.list"]>>
-export type ProviderListOperation<E = never> = (input?: Endpoint8_0Input) => Effect.Effect<Endpoint8_0Output, E>
+type Endpoint9_0Request = Parameters<RawClient["server.provider"]["provider.list"]>[0]
+export type Endpoint9_0Input = { readonly location?: Endpoint9_0Request["query"]["location"] }
+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 Endpoint8_1Request = Parameters<RawClient["server.provider"]["provider.get"]>[0]
-export type Endpoint8_1Input = {
-  readonly providerID: Endpoint8_1Request["params"]["providerID"]
-  readonly location?: Endpoint8_1Request["query"]["location"]
+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"]
 }
-export type Endpoint8_1Output = EffectValue<ReturnType<RawClient["server.provider"]["provider.get"]>>
-export type ProviderGetOperation<E = never> = (input: Endpoint8_1Input) => Effect.Effect<Endpoint8_1Output, E>
+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 Endpoint9_0Request = Parameters<RawClient["server.integration"]["integration.list"]>[0]
-export type Endpoint9_0Input = { readonly location?: Endpoint9_0Request["query"]["location"] }
-export type Endpoint9_0Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.list"]>>
-export type IntegrationListOperation<E = never> = (input?: Endpoint9_0Input) => Effect.Effect<Endpoint9_0Output, E>
+type Endpoint10_0Request = Parameters<RawClient["server.integration"]["integration.list"]>[0]
+export type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query"]["location"] }
+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 Endpoint9_1Request = Parameters<RawClient["server.integration"]["integration.get"]>[0]
-export type Endpoint9_1Input = {
-  readonly integrationID: Endpoint9_1Request["params"]["integrationID"]
-  readonly location?: Endpoint9_1Request["query"]["location"]
+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"]
 }
-export type Endpoint9_1Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.get"]>>
-export type IntegrationGetOperation<E = never> = (input: Endpoint9_1Input) => Effect.Effect<Endpoint9_1Output, E>
+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 Endpoint9_2Request = Parameters<RawClient["server.integration"]["integration.connect.key"]>[0]
-export type Endpoint9_2Input = {
-  readonly integrationID: Endpoint9_2Request["params"]["integrationID"]
-  readonly location?: Endpoint9_2Request["query"]["location"]
-  readonly key: Endpoint9_2Request["payload"]["key"]
-  readonly label?: Endpoint9_2Request["payload"]["label"]
+type Endpoint10_2Request = Parameters<RawClient["server.integration"]["integration.connect.key"]>[0]
+export type Endpoint10_2Input = {
+  readonly integrationID: Endpoint10_2Request["params"]["integrationID"]
+  readonly location?: Endpoint10_2Request["query"]["location"]
+  readonly key: Endpoint10_2Request["payload"]["key"]
+  readonly label?: Endpoint10_2Request["payload"]["label"]
 }
-export type Endpoint9_2Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.connect.key"]>>
-export type IntegrationConnectKeyOperation<E = never> = (input: Endpoint9_2Input) => Effect.Effect<Endpoint9_2Output, E>
+export type Endpoint10_2Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.connect.key"]>>
+export type IntegrationConnectKeyOperation<E = never> = (
+  input: Endpoint10_2Input,
+) => Effect.Effect<Endpoint10_2Output, E>
 
-type Endpoint9_3Request = Parameters<RawClient["server.integration"]["integration.connect.oauth"]>[0]
-export type Endpoint9_3Input = {
-  readonly integrationID: Endpoint9_3Request["params"]["integrationID"]
-  readonly location?: Endpoint9_3Request["query"]["location"]
-  readonly methodID: Endpoint9_3Request["payload"]["methodID"]
-  readonly inputs: Endpoint9_3Request["payload"]["inputs"]
-  readonly label?: Endpoint9_3Request["payload"]["label"]
+type Endpoint10_3Request = Parameters<RawClient["server.integration"]["integration.connect.oauth"]>[0]
+export type Endpoint10_3Input = {
+  readonly integrationID: Endpoint10_3Request["params"]["integrationID"]
+  readonly location?: Endpoint10_3Request["query"]["location"]
+  readonly methodID: Endpoint10_3Request["payload"]["methodID"]
+  readonly inputs: Endpoint10_3Request["payload"]["inputs"]
+  readonly label?: Endpoint10_3Request["payload"]["label"]
 }
-export type Endpoint9_3Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.connect.oauth"]>>
+export type Endpoint10_3Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.connect.oauth"]>>
 export type IntegrationConnectOauthOperation<E = never> = (
-  input: Endpoint9_3Input,
-) => Effect.Effect<Endpoint9_3Output, E>
+  input: Endpoint10_3Input,
+) => Effect.Effect<Endpoint10_3Output, E>
 
-type Endpoint9_4Request = Parameters<RawClient["server.integration"]["integration.attempt.status"]>[0]
-export type Endpoint9_4Input = {
-  readonly attemptID: Endpoint9_4Request["params"]["attemptID"]
-  readonly location?: Endpoint9_4Request["query"]["location"]
+type Endpoint10_4Request = Parameters<RawClient["server.integration"]["integration.attempt.status"]>[0]
+export type Endpoint10_4Input = {
+  readonly attemptID: Endpoint10_4Request["params"]["attemptID"]
+  readonly location?: Endpoint10_4Request["query"]["location"]
 }
-export type Endpoint9_4Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.attempt.status"]>>
+export type Endpoint10_4Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.attempt.status"]>>
 export type IntegrationAttemptStatusOperation<E = never> = (
-  input: Endpoint9_4Input,
-) => Effect.Effect<Endpoint9_4Output, E>
+  input: Endpoint10_4Input,
+) => Effect.Effect<Endpoint10_4Output, E>
 
-type Endpoint9_5Request = Parameters<RawClient["server.integration"]["integration.attempt.complete"]>[0]
-export type Endpoint9_5Input = {
-  readonly attemptID: Endpoint9_5Request["params"]["attemptID"]
-  readonly location?: Endpoint9_5Request["query"]["location"]
-  readonly code?: Endpoint9_5Request["payload"]["code"]
+type Endpoint10_5Request = Parameters<RawClient["server.integration"]["integration.attempt.complete"]>[0]
+export type Endpoint10_5Input = {
+  readonly attemptID: Endpoint10_5Request["params"]["attemptID"]
+  readonly location?: Endpoint10_5Request["query"]["location"]
+  readonly code?: Endpoint10_5Request["payload"]["code"]
 }
-export type Endpoint9_5Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.attempt.complete"]>>
+export type Endpoint10_5Output = EffectValue<
+  ReturnType<RawClient["server.integration"]["integration.attempt.complete"]>
+>
 export type IntegrationAttemptCompleteOperation<E = never> = (
-  input: Endpoint9_5Input,
-) => Effect.Effect<Endpoint9_5Output, E>
+  input: Endpoint10_5Input,
+) => Effect.Effect<Endpoint10_5Output, E>
 
-type Endpoint9_6Request = Parameters<RawClient["server.integration"]["integration.attempt.cancel"]>[0]
-export type Endpoint9_6Input = {
-  readonly attemptID: Endpoint9_6Request["params"]["attemptID"]
-  readonly location?: Endpoint9_6Request["query"]["location"]
+type Endpoint10_6Request = Parameters<RawClient["server.integration"]["integration.attempt.cancel"]>[0]
+export type Endpoint10_6Input = {
+  readonly attemptID: Endpoint10_6Request["params"]["attemptID"]
+  readonly location?: Endpoint10_6Request["query"]["location"]
 }
-export type Endpoint9_6Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.attempt.cancel"]>>
+export type Endpoint10_6Output = EffectValue<ReturnType<RawClient["server.integration"]["integration.attempt.cancel"]>>
 export type IntegrationAttemptCancelOperation<E = never> = (
-  input: Endpoint9_6Input,
-) => Effect.Effect<Endpoint9_6Output, E>
+  input: Endpoint10_6Input,
+) => Effect.Effect<Endpoint10_6Output, E>
 
 export interface IntegrationApi<E = never> {
   readonly list: IntegrationListOperation<E>
@@ -451,60 +462,60 @@ export interface IntegrationApi<E = never> {
   }
 }
 
-type Endpoint10_0Request = Parameters<RawClient["server.mcp"]["mcp.list"]>[0]
-export type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query"]["location"] }
-export type Endpoint10_0Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.list"]>>
-export type ServerMcpListOperation<E = never> = (input?: Endpoint10_0Input) => Effect.Effect<Endpoint10_0Output, E>
+type Endpoint11_0Request = Parameters<RawClient["server.mcp"]["mcp.list"]>[0]
+export type Endpoint11_0Input = { readonly location?: Endpoint11_0Request["query"]["location"] }
+export type Endpoint11_0Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.list"]>>
+export type ServerMcpListOperation<E = never> = (input?: Endpoint11_0Input) => Effect.Effect<Endpoint11_0Output, E>
 
-type Endpoint10_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
-export type Endpoint10_1Input = { readonly location?: Endpoint10_1Request["query"]["location"] }
-export type Endpoint10_1Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.resource.catalog"]>>
+type Endpoint11_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
+export type Endpoint11_1Input = { readonly location?: Endpoint11_1Request["query"]["location"] }
+export type Endpoint11_1Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.resource.catalog"]>>
 export type ServerMcpResourceCatalogOperation<E = never> = (
-  input?: Endpoint10_1Input,
-) => Effect.Effect<Endpoint10_1Output, E>
+  input?: Endpoint11_1Input,
+) => Effect.Effect<Endpoint11_1Output, E>
 
 export interface ServerMcpApi<E = never> {
   readonly list: ServerMcpListOperation<E>
   readonly resource: { readonly catalog: ServerMcpResourceCatalogOperation<E> }
 }
 
-type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
-export type Endpoint11_0Input = {
-  readonly credentialID: Endpoint11_0Request["params"]["credentialID"]
-  readonly location?: Endpoint11_0Request["query"]["location"]
-  readonly label: Endpoint11_0Request["payload"]["label"]
+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 Endpoint11_0Output = EffectValue<ReturnType<RawClient["server.credential"]["credential.update"]>>
-export type CredentialUpdateOperation<E = never> = (input: Endpoint11_0Input) => Effect.Effect<Endpoint11_0Output, E>
+export type Endpoint12_0Output = EffectValue<ReturnType<RawClient["server.credential"]["credential.update"]>>
+export type CredentialUpdateOperation<E = never> = (input: Endpoint12_0Input) => Effect.Effect<Endpoint12_0Output, E>
 
-type Endpoint11_1Request = Parameters<RawClient["server.credential"]["credential.remove"]>[0]
-export type Endpoint11_1Input = {
-  readonly credentialID: Endpoint11_1Request["params"]["credentialID"]
-  readonly location?: Endpoint11_1Request["query"]["location"]
+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"]
 }
-export type Endpoint11_1Output = EffectValue<ReturnType<RawClient["server.credential"]["credential.remove"]>>
-export type CredentialRemoveOperation<E = never> = (input: Endpoint11_1Input) => Effect.Effect<Endpoint11_1Output, E>
+export type Endpoint12_1Output = EffectValue<ReturnType<RawClient["server.credential"]["credential.remove"]>>
+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 Endpoint12_0Output = EffectValue<ReturnType<RawClient["server.project"]["project.list"]>>
-export type ProjectListOperation<E = never> = () => Effect.Effect<Endpoint12_0Output, E>
+export type Endpoint13_0Output = EffectValue<ReturnType<RawClient["server.project"]["project.list"]>>
+export type ProjectListOperation<E = never> = () => Effect.Effect<Endpoint13_0Output, E>
 
-type Endpoint12_1Request = Parameters<RawClient["server.project"]["project.current"]>[0]
-export type Endpoint12_1Input = { readonly location?: Endpoint12_1Request["query"]["location"] }
-export type Endpoint12_1Output = EffectValue<ReturnType<RawClient["server.project"]["project.current"]>>
-export type ProjectCurrentOperation<E = never> = (input?: Endpoint12_1Input) => Effect.Effect<Endpoint12_1Output, E>
+type Endpoint13_1Request = Parameters<RawClient["server.project"]["project.current"]>[0]
+export type Endpoint13_1Input = { readonly location?: Endpoint13_1Request["query"]["location"] }
+export type Endpoint13_1Output = EffectValue<ReturnType<RawClient["server.project"]["project.current"]>>
+export type ProjectCurrentOperation<E = never> = (input?: Endpoint13_1Input) => Effect.Effect<Endpoint13_1Output, E>
 
-type Endpoint12_2Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
-export type Endpoint12_2Input = {
-  readonly projectID: Endpoint12_2Request["params"]["projectID"]
-  readonly location?: Endpoint12_2Request["query"]["location"]
+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"]
 }
-export type Endpoint12_2Output = EffectValue<ReturnType<RawClient["server.project"]["project.directories"]>>
-export type ProjectDirectoriesOperation<E = never> = (input: Endpoint12_2Input) => Effect.Effect<Endpoint12_2Output, E>
+export type Endpoint13_2Output = EffectValue<ReturnType<RawClient["server.project"]["project.directories"]>>
+export type ProjectDirectoriesOperation<E = never> = (input: Endpoint13_2Input) => Effect.Effect<Endpoint13_2Output, E>
 
 export interface ProjectApi<E = never> {
   readonly list: ProjectListOperation<E>
@@ -512,61 +523,61 @@ export interface ProjectApi<E = never> {
   readonly directories: ProjectDirectoriesOperation<E>
 }
 
-type Endpoint13_0Request = Parameters<RawClient["server.form"]["form.request.list"]>[0]
-export type Endpoint13_0Input = { readonly location?: Endpoint13_0Request["query"]["location"] }
-export type Endpoint13_0Output = EffectValue<ReturnType<RawClient["server.form"]["form.request.list"]>>
-export type FormRequestListOperation<E = never> = (input?: Endpoint13_0Input) => Effect.Effect<Endpoint13_0Output, E>
+type Endpoint14_0Request = Parameters<RawClient["server.form"]["form.request.list"]>[0]
+export type Endpoint14_0Input = { readonly location?: Endpoint14_0Request["query"]["location"] }
+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 Endpoint13_1Request = Parameters<RawClient["server.form"]["session.form.list"]>[0]
-export type Endpoint13_1Input = { readonly sessionID: Endpoint13_1Request["params"]["sessionID"] }
-export type Endpoint13_1Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.list"]>>["data"]
-export type FormListOperation<E = never> = (input: Endpoint13_1Input) => Effect.Effect<Endpoint13_1Output, E>
+type Endpoint14_1Request = Parameters<RawClient["server.form"]["session.form.list"]>[0]
+export type Endpoint14_1Input = { readonly sessionID: Endpoint14_1Request["params"]["sessionID"] }
+export type Endpoint14_1Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.list"]>>["data"]
+export type FormListOperation<E = never> = (input: Endpoint14_1Input) => Effect.Effect<Endpoint14_1Output, E>
 
-type Endpoint13_2Request = Parameters<RawClient["server.form"]["session.form.create"]>[0]
-export type Endpoint13_2Input = {
-  readonly sessionID: Endpoint13_2Request["params"]["sessionID"]
-  readonly id?: Endpoint13_2Request["payload"]["id"]
-  readonly title: Endpoint13_2Request["payload"]["title"]
-  readonly metadata?: Endpoint13_2Request["payload"]["metadata"]
-  readonly mode: Endpoint13_2Request["payload"]["mode"]
-  readonly fields?: Endpoint13_2Request["payload"]["fields"]
-  readonly url?: Endpoint13_2Request["payload"]["url"]
+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 mode: Endpoint14_2Request["payload"]["mode"]
+  readonly fields?: Endpoint14_2Request["payload"]["fields"]
+  readonly url?: Endpoint14_2Request["payload"]["url"]
 }
-export type Endpoint13_2Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.create"]>>["data"]
-export type FormCreateOperation<E = never> = (input: Endpoint13_2Input) => Effect.Effect<Endpoint13_2Output, E>
+export type Endpoint14_2Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.create"]>>["data"]
+export type FormCreateOperation<E = never> = (input: Endpoint14_2Input) => Effect.Effect<Endpoint14_2Output, E>
 
-type Endpoint13_3Request = Parameters<RawClient["server.form"]["session.form.get"]>[0]
-export type Endpoint13_3Input = {
-  readonly sessionID: Endpoint13_3Request["params"]["sessionID"]
-  readonly formID: Endpoint13_3Request["params"]["formID"]
+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"]
 }
-export type Endpoint13_3Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.get"]>>["data"]
-export type FormGetOperation<E = never> = (input: Endpoint13_3Input) => Effect.Effect<Endpoint13_3Output, E>
+export type Endpoint14_3Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.get"]>>["data"]
+export type FormGetOperation<E = never> = (input: Endpoint14_3Input) => Effect.Effect<Endpoint14_3Output, E>
 
-type Endpoint13_4Request = Parameters<RawClient["server.form"]["session.form.state"]>[0]
-export type Endpoint13_4Input = {
-  readonly sessionID: Endpoint13_4Request["params"]["sessionID"]
-  readonly formID: Endpoint13_4Request["params"]["formID"]
+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"]
 }
-export type Endpoint13_4Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.state"]>>["data"]
-export type FormStateOperation<E = never> = (input: Endpoint13_4Input) => Effect.Effect<Endpoint13_4Output, E>
+export type Endpoint14_4Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.state"]>>["data"]
+export type FormStateOperation<E = never> = (input: Endpoint14_4Input) => Effect.Effect<Endpoint14_4Output, E>
 
-type Endpoint13_5Request = Parameters<RawClient["server.form"]["session.form.reply"]>[0]
-export type Endpoint13_5Input = {
-  readonly sessionID: Endpoint13_5Request["params"]["sessionID"]
-  readonly formID: Endpoint13_5Request["params"]["formID"]
-  readonly answer: Endpoint13_5Request["payload"]["answer"]
+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"]
 }
-export type Endpoint13_5Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.reply"]>>
-export type FormReplyOperation<E = never> = (input: Endpoint13_5Input) => Effect.Effect<Endpoint13_5Output, E>
+export type Endpoint14_5Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.reply"]>>
+export type FormReplyOperation<E = never> = (input: Endpoint14_5Input) => Effect.Effect<Endpoint14_5Output, E>
 
-type Endpoint13_6Request = Parameters<RawClient["server.form"]["session.form.cancel"]>[0]
-export type Endpoint13_6Input = {
-  readonly sessionID: Endpoint13_6Request["params"]["sessionID"]
-  readonly formID: Endpoint13_6Request["params"]["formID"]
+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"]
 }
-export type Endpoint13_6Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.cancel"]>>
-export type FormCancelOperation<E = never> = (input: Endpoint13_6Input) => Effect.Effect<Endpoint13_6Output, E>
+export type Endpoint14_6Output = EffectValue<ReturnType<RawClient["server.form"]["session.form.cancel"]>>
+export type FormCancelOperation<E = never> = (input: Endpoint14_6Input) => Effect.Effect<Endpoint14_6Output, E>
 
 export interface FormApi<E = never> {
   readonly request: { readonly list: FormRequestListOperation<E> }
@@ -578,71 +589,71 @@ export interface FormApi<E = never> {
   readonly cancel: FormCancelOperation<E>
 }
 
-type Endpoint14_0Request = Parameters<RawClient["server.permission"]["permission.request.list"]>[0]
-export type Endpoint14_0Input = { readonly location?: Endpoint14_0Request["query"]["location"] }
-export type Endpoint14_0Output = EffectValue<ReturnType<RawClient["server.permission"]["permission.request.list"]>>
+type Endpoint15_0Request = Parameters<RawClient["server.permission"]["permission.request.list"]>[0]
+export type Endpoint15_0Input = { readonly location?: Endpoint15_0Request["query"]["location"] }
+export type Endpoint15_0Output = EffectValue<ReturnType<RawClient["server.permission"]["permission.request.list"]>>
 export type PermissionRequestListOperation<E = never> = (
-  input?: Endpoint14_0Input,
-) => Effect.Effect<Endpoint14_0Output, E>
+  input?: Endpoint15_0Input,
+) => Effect.Effect<Endpoint15_0Output, E>
 
-type Endpoint14_1Request = Parameters<RawClient["server.permission"]["permission.saved.list"]>[0]
-export type Endpoint14_1Input = { readonly projectID?: Endpoint14_1Request["query"]["projectID"] }
-export type Endpoint14_1Output = EffectValue<
+type Endpoint15_1Request = Parameters<RawClient["server.permission"]["permission.saved.list"]>[0]
+export type Endpoint15_1Input = { readonly projectID?: Endpoint15_1Request["query"]["projectID"] }
+export type Endpoint15_1Output = EffectValue<
   ReturnType<RawClient["server.permission"]["permission.saved.list"]>
 >["data"]
 export type PermissionSavedListOperation<E = never> = (
-  input?: Endpoint14_1Input,
-) => Effect.Effect<Endpoint14_1Output, E>
+  input?: Endpoint15_1Input,
+) => Effect.Effect<Endpoint15_1Output, E>
 
-type Endpoint14_2Request = Parameters<RawClient["server.permission"]["permission.saved.remove"]>[0]
-export type Endpoint14_2Input = { readonly id: Endpoint14_2Request["params"]["id"] }
-export type Endpoint14_2Output = EffectValue<ReturnType<RawClient["server.permission"]["permission.saved.remove"]>>
+type Endpoint15_2Request = Parameters<RawClient["server.permission"]["permission.saved.remove"]>[0]
+export type Endpoint15_2Input = { readonly id: Endpoint15_2Request["params"]["id"] }
+export type Endpoint15_2Output = EffectValue<ReturnType<RawClient["server.permission"]["permission.saved.remove"]>>
 export type PermissionSavedRemoveOperation<E = never> = (
-  input: Endpoint14_2Input,
-) => Effect.Effect<Endpoint14_2Output, E>
+  input: Endpoint15_2Input,
+) => Effect.Effect<Endpoint15_2Output, E>
 
-type Endpoint14_3Request = Parameters<RawClient["server.permission"]["session.permission.create"]>[0]
-export type Endpoint14_3Input = {
-  readonly sessionID: Endpoint14_3Request["params"]["sessionID"]
-  readonly id?: Endpoint14_3Request["payload"]["id"]
-  readonly action: Endpoint14_3Request["payload"]["action"]
-  readonly resources: Endpoint14_3Request["payload"]["resources"]
-  readonly save?: Endpoint14_3Request["payload"]["save"]
-  readonly metadata?: Endpoint14_3Request["payload"]["metadata"]
-  readonly source?: Endpoint14_3Request["payload"]["source"]
-  readonly agent?: Endpoint14_3Request["payload"]["agent"]
+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 Endpoint14_3Output = EffectValue<
+export type Endpoint15_3Output = EffectValue<
   ReturnType<RawClient["server.permission"]["session.permission.create"]>
 >["data"]
-export type PermissionCreateOperation<E = never> = (input: Endpoint14_3Input) => Effect.Effect<Endpoint14_3Output, E>
+export type PermissionCreateOperation<E = never> = (input: Endpoint15_3Input) => Effect.Effect<Endpoint15_3Output, E>
 
-type Endpoint14_4Request = Parameters<RawClient["server.permission"]["session.permission.list"]>[0]
-export type Endpoint14_4Input = { readonly sessionID: Endpoint14_4Request["params"]["sessionID"] }
-export type Endpoint14_4Output = EffectValue<
+type Endpoint15_4Request = Parameters<RawClient["server.permission"]["session.permission.list"]>[0]
+export type Endpoint15_4Input = { readonly sessionID: Endpoint15_4Request["params"]["sessionID"] }
+export type Endpoint15_4Output = EffectValue<
   ReturnType<RawClient["server.permission"]["session.permission.list"]>
 >["data"]
-export type PermissionListOperation<E = never> = (input: Endpoint14_4Input) => Effect.Effect<Endpoint14_4Output, E>
+export type PermissionListOperation<E = never> = (input: Endpoint15_4Input) => Effect.Effect<Endpoint15_4Output, E>
 
-type Endpoint14_5Request = Parameters<RawClient["server.permission"]["session.permission.get"]>[0]
-export type Endpoint14_5Input = {
-  readonly sessionID: Endpoint14_5Request["params"]["sessionID"]
-  readonly requestID: Endpoint14_5Request["params"]["requestID"]
+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"]
 }
-export type Endpoint14_5Output = EffectValue<
+export type Endpoint15_5Output = EffectValue<
   ReturnType<RawClient["server.permission"]["session.permission.get"]>
 >["data"]
-export type PermissionGetOperation<E = never> = (input: Endpoint14_5Input) => Effect.Effect<Endpoint14_5Output, E>
+export type PermissionGetOperation<E = never> = (input: Endpoint15_5Input) => Effect.Effect<Endpoint15_5Output, E>
 
-type Endpoint14_6Request = Parameters<RawClient["server.permission"]["session.permission.reply"]>[0]
-export type Endpoint14_6Input = {
-  readonly sessionID: Endpoint14_6Request["params"]["sessionID"]
-  readonly requestID: Endpoint14_6Request["params"]["requestID"]
-  readonly reply: Endpoint14_6Request["payload"]["reply"]
-  readonly message?: Endpoint14_6Request["payload"]["message"]
+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"]
 }
-export type Endpoint14_6Output = EffectValue<ReturnType<RawClient["server.permission"]["session.permission.reply"]>>
-export type PermissionReplyOperation<E = never> = (input: Endpoint14_6Input) => Effect.Effect<Endpoint14_6Output, E>
+export type Endpoint15_6Output = EffectValue<ReturnType<RawClient["server.permission"]["session.permission.reply"]>>
+export type PermissionReplyOperation<E = never> = (input: Endpoint15_6Input) => Effect.Effect<Endpoint15_6Output, E>
 
 export interface PermissionApi<E = never> {
   readonly request: { readonly list: PermissionRequestListOperation<E> }
@@ -653,96 +664,96 @@ export interface PermissionApi<E = never> {
   readonly reply: PermissionReplyOperation<E>
 }
 
-type Endpoint15_0Request = Parameters<RawClient["server.fs"]["fs.list"]>[0]
-export type Endpoint15_0Input = {
-  readonly location?: Endpoint15_0Request["query"]["location"]
-  readonly path?: Endpoint15_0Request["query"]["path"]
+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"]
 }
-export type Endpoint15_0Output = EffectValue<ReturnType<RawClient["server.fs"]["fs.list"]>>
-export type FileListOperation<E = never> = (input?: Endpoint15_0Input) => Effect.Effect<Endpoint15_0Output, E>
+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 Endpoint15_1Request = Parameters<RawClient["server.fs"]["fs.find"]>[0]
-export type Endpoint15_1Input = {
-  readonly location?: Endpoint15_1Request["query"]["location"]
-  readonly query: Endpoint15_1Request["query"]["query"]
-  readonly type?: Endpoint15_1Request["query"]["type"]
-  readonly limit?: Endpoint15_1Request["query"]["limit"]
+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"]
 }
-export type Endpoint15_1Output = EffectValue<ReturnType<RawClient["server.fs"]["fs.find"]>>
-export type FileFindOperation<E = never> = (input: Endpoint15_1Input) => Effect.Effect<Endpoint15_1Output, E>
+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 Endpoint16_0Request = Parameters<RawClient["server.command"]["command.list"]>[0]
-export type Endpoint16_0Input = { readonly location?: Endpoint16_0Request["query"]["location"] }
-export type Endpoint16_0Output = EffectValue<ReturnType<RawClient["server.command"]["command.list"]>>
-export type CommandListOperation<E = never> = (input?: Endpoint16_0Input) => Effect.Effect<Endpoint16_0Output, E>
+type Endpoint17_0Request = Parameters<RawClient["server.command"]["command.list"]>[0]
+export type Endpoint17_0Input = { readonly location?: Endpoint17_0Request["query"]["location"] }
+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 Endpoint17_0Request = Parameters<RawClient["server.skill"]["skill.list"]>[0]
-export type Endpoint17_0Input = { readonly location?: Endpoint17_0Request["query"]["location"] }
-export type Endpoint17_0Output = EffectValue<ReturnType<RawClient["server.skill"]["skill.list"]>>
-export type SkillListOperation<E = never> = (input?: Endpoint17_0Input) => Effect.Effect<Endpoint17_0Output, E>
+type Endpoint18_0Request = Parameters<RawClient["server.skill"]["skill.list"]>[0]
+export type Endpoint18_0Input = { readonly location?: Endpoint18_0Request["query"]["location"] }
+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 Endpoint18_0Output = StreamValue<EffectValue<ReturnType<RawClient["server.event"]["event.subscribe"]>>>
-export type EventSubscribeOperation<E = never> = () => Stream.Stream<Endpoint18_0Output, E>
+export type Endpoint19_0Output = StreamValue<EffectValue<ReturnType<RawClient["server.event"]["event.subscribe"]>>>
+export type EventSubscribeOperation<E = never> = () => Stream.Stream<Endpoint19_0Output, E>
 
 export interface EventApi<E = never> {
   readonly subscribe: EventSubscribeOperation<E>
 }
 
-type Endpoint19_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
-export type Endpoint19_0Input = { readonly location?: Endpoint19_0Request["query"]["location"] }
-export type Endpoint19_0Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.list"]>>
-export type PtyListOperation<E = never> = (input?: Endpoint19_0Input) => Effect.Effect<Endpoint19_0Output, E>
+type Endpoint20_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+export type Endpoint20_0Input = { readonly location?: Endpoint20_0Request["query"]["location"] }
+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 Endpoint19_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
-export type Endpoint19_1Input = {
-  readonly location?: Endpoint19_1Request["query"]["location"]
-  readonly command?: Endpoint19_1Request["payload"]["command"]
-  readonly args?: Endpoint19_1Request["payload"]["args"]
-  readonly cwd?: Endpoint19_1Request["payload"]["cwd"]
-  readonly title?: Endpoint19_1Request["payload"]["title"]
-  readonly env?: Endpoint19_1Request["payload"]["env"]
+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 Endpoint19_1Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.create"]>>
-export type PtyCreateOperation<E = never> = (input?: Endpoint19_1Input) => Effect.Effect<Endpoint19_1Output, E>
+export type Endpoint20_1Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.create"]>>
+export type PtyCreateOperation<E = never> = (input?: Endpoint20_1Input) => Effect.Effect<Endpoint20_1Output, E>
 
-type Endpoint19_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
-export type Endpoint19_2Input = {
-  readonly ptyID: Endpoint19_2Request["params"]["ptyID"]
-  readonly location?: Endpoint19_2Request["query"]["location"]
+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"]
 }
-export type Endpoint19_2Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.get"]>>
-export type PtyGetOperation<E = never> = (input: Endpoint19_2Input) => Effect.Effect<Endpoint19_2Output, E>
+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 Endpoint19_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
-export type Endpoint19_3Input = {
-  readonly ptyID: Endpoint19_3Request["params"]["ptyID"]
-  readonly location?: Endpoint19_3Request["query"]["location"]
-  readonly title?: Endpoint19_3Request["payload"]["title"]
-  readonly size?: Endpoint19_3Request["payload"]["size"]
+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"]
 }
-export type Endpoint19_3Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.update"]>>
-export type PtyUpdateOperation<E = never> = (input: Endpoint19_3Input) => Effect.Effect<Endpoint19_3Output, E>
+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 Endpoint19_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
-export type Endpoint19_4Input = {
-  readonly ptyID: Endpoint19_4Request["params"]["ptyID"]
-  readonly location?: Endpoint19_4Request["query"]["location"]
+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"]
 }
-export type Endpoint19_4Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.remove"]>>
-export type PtyRemoveOperation<E = never> = (input: Endpoint19_4Input) => Effect.Effect<Endpoint19_4Output, E>
+export type Endpoint20_4Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.remove"]>>
+export type PtyRemoveOperation<E = never> = (input: Endpoint20_4Input) => Effect.Effect<Endpoint20_4Output, E>
 
 export interface PtyApi<E = never> {
   readonly list: PtyListOperation<E>
@@ -752,56 +763,56 @@ export interface PtyApi<E = never> {
   readonly remove: PtyRemoveOperation<E>
 }
 
-type Endpoint20_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0]
-export type Endpoint20_0Input = { readonly location?: Endpoint20_0Request["query"]["location"] }
-export type Endpoint20_0Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.list"]>>
-export type ShellListOperation<E = never> = (input?: Endpoint20_0Input) => Effect.Effect<Endpoint20_0Output, E>
+type Endpoint21_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0]
+export type Endpoint21_0Input = { readonly location?: Endpoint21_0Request["query"]["location"] }
+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 Endpoint20_1Request = Parameters<RawClient["server.shell"]["shell.create"]>[0]
-export type Endpoint20_1Input = {
-  readonly location?: Endpoint20_1Request["query"]["location"]
-  readonly command: Endpoint20_1Request["payload"]["command"]
-  readonly cwd?: Endpoint20_1Request["payload"]["cwd"]
-  readonly timeout: Endpoint20_1Request["payload"]["timeout"]
-  readonly metadata?: Endpoint20_1Request["payload"]["metadata"]
+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"]
 }
-export type Endpoint20_1Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.create"]>>
-export type ShellCreateOperation<E = never> = (input: Endpoint20_1Input) => Effect.Effect<Endpoint20_1Output, E>
+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 Endpoint20_2Request = Parameters<RawClient["server.shell"]["shell.get"]>[0]
-export type Endpoint20_2Input = {
-  readonly id: Endpoint20_2Request["params"]["id"]
-  readonly location?: Endpoint20_2Request["query"]["location"]
+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"]
 }
-export type Endpoint20_2Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.get"]>>
-export type ShellGetOperation<E = never> = (input: Endpoint20_2Input) => Effect.Effect<Endpoint20_2Output, E>
+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 Endpoint20_3Request = Parameters<RawClient["server.shell"]["shell.timeout"]>[0]
-export type Endpoint20_3Input = {
-  readonly id: Endpoint20_3Request["params"]["id"]
-  readonly location?: Endpoint20_3Request["query"]["location"]
-  readonly timeout: Endpoint20_3Request["payload"]["timeout"]
+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"]
 }
-export type Endpoint20_3Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.timeout"]>>
-export type ShellTimeoutOperation<E = never> = (input: Endpoint20_3Input) => Effect.Effect<Endpoint20_3Output, E>
+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 Endpoint20_4Request = Parameters<RawClient["server.shell"]["shell.output"]>[0]
-export type Endpoint20_4Input = {
-  readonly id: Endpoint20_4Request["params"]["id"]
-  readonly location?: Endpoint20_4Request["query"]["location"]
-  readonly cursor?: Endpoint20_4Request["query"]["cursor"]
-  readonly limit?: Endpoint20_4Request["query"]["limit"]
+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"]
 }
-export type Endpoint20_4Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.output"]>>
-export type ShellOutputOperation<E = never> = (input: Endpoint20_4Input) => Effect.Effect<Endpoint20_4Output, E>
+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 Endpoint20_5Request = Parameters<RawClient["server.shell"]["shell.remove"]>[0]
-export type Endpoint20_5Input = {
-  readonly id: Endpoint20_5Request["params"]["id"]
-  readonly location?: Endpoint20_5Request["query"]["location"]
+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"]
 }
-export type Endpoint20_5Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.remove"]>>
-export type ShellRemoveOperation<E = never> = (input: Endpoint20_5Input) => Effect.Effect<Endpoint20_5Output, E>
+export type Endpoint21_5Output = EffectValue<ReturnType<RawClient["server.shell"]["shell.remove"]>>
+export type ShellRemoveOperation<E = never> = (input: Endpoint21_5Input) => Effect.Effect<Endpoint21_5Output, E>
 
 export interface ShellApi<E = never> {
   readonly list: ShellListOperation<E>
@@ -812,34 +823,34 @@ export interface ShellApi<E = never> {
   readonly remove: ShellRemoveOperation<E>
 }
 
-type Endpoint21_0Request = Parameters<RawClient["server.question"]["question.request.list"]>[0]
-export type Endpoint21_0Input = { readonly location?: Endpoint21_0Request["query"]["location"] }
-export type Endpoint21_0Output = EffectValue<ReturnType<RawClient["server.question"]["question.request.list"]>>
+type Endpoint22_0Request = Parameters<RawClient["server.question"]["question.request.list"]>[0]
+export type Endpoint22_0Input = { readonly location?: Endpoint22_0Request["query"]["location"] }
+export type Endpoint22_0Output = EffectValue<ReturnType<RawClient["server.question"]["question.request.list"]>>
 export type QuestionRequestListOperation<E = never> = (
-  input?: Endpoint21_0Input,
-) => Effect.Effect<Endpoint21_0Output, E>
+  input?: Endpoint22_0Input,
+) => Effect.Effect<Endpoint22_0Output, E>
 
-type Endpoint21_1Request = Parameters<RawClient["server.question"]["session.question.list"]>[0]
-export type Endpoint21_1Input = { readonly sessionID: Endpoint21_1Request["params"]["sessionID"] }
-export type Endpoint21_1Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.list"]>>["data"]
-export type QuestionListOperation<E = never> = (input: Endpoint21_1Input) => Effect.Effect<Endpoint21_1Output, E>
+type Endpoint22_1Request = Parameters<RawClient["server.question"]["session.question.list"]>[0]
+export type Endpoint22_1Input = { readonly sessionID: Endpoint22_1Request["params"]["sessionID"] }
+export type Endpoint22_1Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.list"]>>["data"]
+export type QuestionListOperation<E = never> = (input: Endpoint22_1Input) => Effect.Effect<Endpoint22_1Output, E>
 
-type Endpoint21_2Request = Parameters<RawClient["server.question"]["session.question.reply"]>[0]
-export type Endpoint21_2Input = {
-  readonly sessionID: Endpoint21_2Request["params"]["sessionID"]
-  readonly requestID: Endpoint21_2Request["params"]["requestID"]
-  readonly answers: Endpoint21_2Request["payload"]["answers"]
+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"]
 }
-export type Endpoint21_2Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.reply"]>>
-export type QuestionReplyOperation<E = never> = (input: Endpoint21_2Input) => Effect.Effect<Endpoint21_2Output, E>
+export type Endpoint22_2Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.reply"]>>
+export type QuestionReplyOperation<E = never> = (input: Endpoint22_2Input) => Effect.Effect<Endpoint22_2Output, E>
 
-type Endpoint21_3Request = Parameters<RawClient["server.question"]["session.question.reject"]>[0]
-export type Endpoint21_3Input = {
-  readonly sessionID: Endpoint21_3Request["params"]["sessionID"]
-  readonly requestID: Endpoint21_3Request["params"]["requestID"]
+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"]
 }
-export type Endpoint21_3Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.reject"]>>
-export type QuestionRejectOperation<E = never> = (input: Endpoint21_3Input) => Effect.Effect<Endpoint21_3Output, E>
+export type Endpoint22_3Output = EffectValue<ReturnType<RawClient["server.question"]["session.question.reject"]>>
+export type QuestionRejectOperation<E = never> = (input: Endpoint22_3Input) => Effect.Effect<Endpoint22_3Output, E>
 
 export interface QuestionApi<E = never> {
   readonly request: { readonly list: QuestionRequestListOperation<E> }
@@ -848,43 +859,43 @@ export interface QuestionApi<E = never> {
   readonly reject: QuestionRejectOperation<E>
 }
 
-type Endpoint22_0Request = Parameters<RawClient["server.reference"]["reference.list"]>[0]
-export type Endpoint22_0Input = { readonly location?: Endpoint22_0Request["query"]["location"] }
-export type Endpoint22_0Output = EffectValue<ReturnType<RawClient["server.reference"]["reference.list"]>>
-export type ReferenceListOperation<E = never> = (input?: Endpoint22_0Input) => Effect.Effect<Endpoint22_0Output, E>
+type Endpoint23_0Request = Parameters<RawClient["server.reference"]["reference.list"]>[0]
+export type Endpoint23_0Input = { readonly location?: Endpoint23_0Request["query"]["location"] }
+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 Endpoint23_0Request = Parameters<RawClient["server.projectCopy"]["projectCopy.create"]>[0]
-export type Endpoint23_0Input = {
-  readonly projectID: Endpoint23_0Request["params"]["projectID"]
-  readonly location?: Endpoint23_0Request["query"]["location"]
-  readonly strategy: Endpoint23_0Request["payload"]["strategy"]
-  readonly directory: Endpoint23_0Request["payload"]["directory"]
-  readonly name?: Endpoint23_0Request["payload"]["name"]
+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 Endpoint23_0Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.create"]>>
-export type ProjectCopyCreateOperation<E = never> = (input: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>
+export type Endpoint24_0Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.create"]>>
+export type ProjectCopyCreateOperation<E = never> = (input: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>
 
-type Endpoint23_1Request = Parameters<RawClient["server.projectCopy"]["projectCopy.remove"]>[0]
-export type Endpoint23_1Input = {
-  readonly projectID: Endpoint23_1Request["params"]["projectID"]
-  readonly location?: Endpoint23_1Request["query"]["location"]
-  readonly directory: Endpoint23_1Request["payload"]["directory"]
-  readonly force: Endpoint23_1Request["payload"]["force"]
+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 Endpoint23_1Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.remove"]>>
-export type ProjectCopyRemoveOperation<E = never> = (input: Endpoint23_1Input) => Effect.Effect<Endpoint23_1Output, E>
+export type Endpoint24_1Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.remove"]>>
+export type ProjectCopyRemoveOperation<E = never> = (input: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>
 
-type Endpoint23_2Request = Parameters<RawClient["server.projectCopy"]["projectCopy.refresh"]>[0]
-export type Endpoint23_2Input = {
-  readonly projectID: Endpoint23_2Request["params"]["projectID"]
-  readonly location?: Endpoint23_2Request["query"]["location"]
+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"]
 }
-export type Endpoint23_2Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.refresh"]>>
-export type ProjectCopyRefreshOperation<E = never> = (input: Endpoint23_2Input) => Effect.Effect<Endpoint23_2Output, E>
+export type Endpoint24_2Output = EffectValue<ReturnType<RawClient["server.projectCopy"]["projectCopy.refresh"]>>
+export type ProjectCopyRefreshOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>
 
 export interface ProjectCopyApi<E = never> {
   readonly create: ProjectCopyCreateOperation<E>
@@ -892,32 +903,32 @@ export interface ProjectCopyApi<E = never> {
   readonly refresh: ProjectCopyRefreshOperation<E>
 }
 
-type Endpoint24_0Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
-export type Endpoint24_0Input = { readonly location?: Endpoint24_0Request["query"]["location"] }
-export type Endpoint24_0Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.status"]>>
-export type VcsStatusOperation<E = never> = (input?: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>
+type Endpoint25_0Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
+export type Endpoint25_0Input = { readonly location?: Endpoint25_0Request["query"]["location"] }
+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 Endpoint24_1Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0]
-export type Endpoint24_1Input = {
-  readonly location?: Endpoint24_1Request["query"]["location"]
-  readonly mode: Endpoint24_1Request["query"]["mode"]
-  readonly context?: Endpoint24_1Request["query"]["context"]
+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"]
 }
-export type Endpoint24_1Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.diff"]>>
-export type VcsDiffOperation<E = never> = (input: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>
+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 Endpoint25_0Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location"]>>
-export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint25_0Output, E>
+export type Endpoint26_0Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location"]>>
+export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>
 
-type Endpoint25_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
-export type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
-export type Endpoint25_1Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location.evict"]>>
-export type DebugLocationEvictOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
+type Endpoint26_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
+export type Endpoint26_1Input = { readonly location?: Endpoint26_1Request["query"]["location"] }
+export type Endpoint26_1Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location.evict"]>>
+export type DebugLocationEvictOperation<E = never> = (input?: Endpoint26_1Input) => Effect.Effect<Endpoint26_1Output, E>
 
 export interface DebugApi<E = never> {
   readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
@@ -925,6 +936,7 @@ export interface DebugApi<E = never> {
 
 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>
diff --git a/packages/client/src/effect/generated/client.ts b/packages/client/src/effect/generated/client.ts
index c83d9325a4a..a0804cf07f1 100644
--- a/packages/client/src/effect/generated/client.ts
+++ b/packages/client/src/effect/generated/client.ts
@@ -18,40 +18,45 @@ const Endpoint0_0 = (raw: RawClient["server.health"]) => () =>
 
 const adaptGroup0 = (raw: RawClient["server.health"]) => ({ get: Endpoint0_0(raw) })
 
-type Endpoint1_0Request = Parameters<RawClient["server.location"]["location.get"]>[0]
-type Endpoint1_0Input = { readonly location?: Endpoint1_0Request["query"]["location"] }
-const Endpoint1_0 = (raw: RawClient["server.location"]) => (input?: Endpoint1_0Input) =>
+const Endpoint1_0 = (raw: RawClient["server.server"]) => () =>
+  raw["server.get"]({}).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup1 = (raw: RawClient["server.server"]) => ({ get: Endpoint1_0(raw) })
+
+type Endpoint2_0Request = Parameters<RawClient["server.location"]["location.get"]>[0]
+type Endpoint2_0Input = { readonly location?: Endpoint2_0Request["query"]["location"] }
+const Endpoint2_0 = (raw: RawClient["server.location"]) => (input?: Endpoint2_0Input) =>
   raw["location.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup1 = (raw: RawClient["server.location"]) => ({ get: Endpoint1_0(raw) })
+const adaptGroup2 = (raw: RawClient["server.location"]) => ({ get: Endpoint2_0(raw) })
 
-type Endpoint2_0Request = Parameters<RawClient["server.agent"]["agent.list"]>[0]
-type Endpoint2_0Input = { readonly location?: Endpoint2_0Request["query"]["location"] }
-const Endpoint2_0 = (raw: RawClient["server.agent"]) => (input?: Endpoint2_0Input) =>
+type Endpoint3_0Request = Parameters<RawClient["server.agent"]["agent.list"]>[0]
+type Endpoint3_0Input = { readonly location?: Endpoint3_0Request["query"]["location"] }
+const Endpoint3_0 = (raw: RawClient["server.agent"]) => (input?: Endpoint3_0Input) =>
   raw["agent.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup2 = (raw: RawClient["server.agent"]) => ({ list: Endpoint2_0(raw) })
+const adaptGroup3 = (raw: RawClient["server.agent"]) => ({ list: Endpoint3_0(raw) })
 
-type Endpoint3_0Request = Parameters<RawClient["server.plugin"]["plugin.list"]>[0]
-type Endpoint3_0Input = { readonly location?: Endpoint3_0Request["query"]["location"] }
-const Endpoint3_0 = (raw: RawClient["server.plugin"]) => (input?: Endpoint3_0Input) =>
+type Endpoint4_0Request = Parameters<RawClient["server.plugin"]["plugin.list"]>[0]
+type Endpoint4_0Input = { readonly location?: Endpoint4_0Request["query"]["location"] }
+const Endpoint4_0 = (raw: RawClient["server.plugin"]) => (input?: Endpoint4_0Input) =>
   raw["plugin.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup3 = (raw: RawClient["server.plugin"]) => ({ list: Endpoint3_0(raw) })
+const adaptGroup4 = (raw: RawClient["server.plugin"]) => ({ list: Endpoint4_0(raw) })
 
-type Endpoint4_0Request = Parameters<RawClient["server.session"]["session.list"]>[0]
-type Endpoint4_0Input = {
-  readonly workspace?: Endpoint4_0Request["query"]["workspace"]
-  readonly limit?: Endpoint4_0Request["query"]["limit"]
-  readonly order?: Endpoint4_0Request["query"]["order"]
-  readonly search?: Endpoint4_0Request["query"]["search"]
-  readonly parentID?: Endpoint4_0Request["query"]["parentID"]
-  readonly directory?: Endpoint4_0Request["query"]["directory"]
-  readonly project?: Endpoint4_0Request["query"]["project"]
-  readonly subpath?: Endpoint4_0Request["query"]["subpath"]
-  readonly cursor?: Endpoint4_0Request["query"]["cursor"]
+type Endpoint5_0Request = Parameters<RawClient["server.session"]["session.list"]>[0]
+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"]
 }
-const Endpoint4_0 = (raw: RawClient["server.session"]) => (input?: Endpoint4_0Input) =>
+const Endpoint5_0 = (raw: RawClient["server.session"]) => (input?: Endpoint5_0Input) =>
   raw["session.list"]({
     query: {
       workspace: input?.["workspace"],
@@ -66,14 +71,14 @@ const Endpoint4_0 = (raw: RawClient["server.session"]) => (input?: Endpoint4_0In
     },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_1Request = Parameters<RawClient["server.session"]["session.create"]>[0]
-type Endpoint4_1Input = {
-  readonly id?: Endpoint4_1Request["payload"]["id"]
-  readonly agent?: Endpoint4_1Request["payload"]["agent"]
-  readonly model?: Endpoint4_1Request["payload"]["model"]
-  readonly location?: Endpoint4_1Request["payload"]["location"]
+type Endpoint5_1Request = Parameters<RawClient["server.session"]["session.create"]>[0]
+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"]
 }
-const Endpoint4_1 = (raw: RawClient["server.session"]) => (input?: Endpoint4_1Input) =>
+const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1Input) =>
   raw["session.create"]({
     payload: { id: input?.["id"], agent: input?.["agent"], model: input?.["model"], location: input?.["location"] },
   }).pipe(
@@ -81,87 +86,87 @@ const Endpoint4_1 = (raw: RawClient["server.session"]) => (input?: Endpoint4_1In
     Effect.map((value) => value.data),
   )
 
-const Endpoint4_2 = (raw: RawClient["server.session"]) => () =>
+const Endpoint5_2 = (raw: RawClient["server.session"]) => () =>
   raw["session.active"]({}).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
-type Endpoint4_3Input = { readonly sessionID: Endpoint4_3Request["params"]["sessionID"] }
-const Endpoint4_3 = (raw: RawClient["server.session"]) => (input: Endpoint4_3Input) =>
+type Endpoint5_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
+type Endpoint5_3Input = { readonly sessionID: Endpoint5_3Request["params"]["sessionID"] }
+const Endpoint5_3 = (raw: RawClient["server.session"]) => (input: Endpoint5_3Input) =>
   raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_4Request = Parameters<RawClient["server.session"]["session.remove"]>[0]
-type Endpoint4_4Input = { readonly sessionID: Endpoint4_4Request["params"]["sessionID"] }
-const Endpoint4_4 = (raw: RawClient["server.session"]) => (input: Endpoint4_4Input) =>
+type Endpoint5_4Request = Parameters<RawClient["server.session"]["session.remove"]>[0]
+type Endpoint5_4Input = { readonly sessionID: Endpoint5_4Request["params"]["sessionID"] }
+const Endpoint5_4 = (raw: RawClient["server.session"]) => (input: Endpoint5_4Input) =>
   raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_5Request = Parameters<RawClient["server.session"]["session.fork"]>[0]
-type Endpoint4_5Input = {
-  readonly sessionID: Endpoint4_5Request["params"]["sessionID"]
-  readonly messageID?: Endpoint4_5Request["payload"]["messageID"]
+type Endpoint5_5Request = Parameters<RawClient["server.session"]["session.fork"]>[0]
+type Endpoint5_5Input = {
+  readonly sessionID: Endpoint5_5Request["params"]["sessionID"]
+  readonly messageID?: Endpoint5_5Request["payload"]["messageID"]
 }
-const Endpoint4_5 = (raw: RawClient["server.session"]) => (input: Endpoint4_5Input) =>
+const Endpoint5_5 = (raw: RawClient["server.session"]) => (input: Endpoint5_5Input) =>
   raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { messageID: input["messageID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_6Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
-type Endpoint4_6Input = {
-  readonly sessionID: Endpoint4_6Request["params"]["sessionID"]
-  readonly agent: Endpoint4_6Request["payload"]["agent"]
+type Endpoint5_6Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
+type Endpoint5_6Input = {
+  readonly sessionID: Endpoint5_6Request["params"]["sessionID"]
+  readonly agent: Endpoint5_6Request["payload"]["agent"]
 }
-const Endpoint4_6 = (raw: RawClient["server.session"]) => (input: Endpoint4_6Input) =>
+const Endpoint5_6 = (raw: RawClient["server.session"]) => (input: Endpoint5_6Input) =>
   raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_7Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
-type Endpoint4_7Input = {
-  readonly sessionID: Endpoint4_7Request["params"]["sessionID"]
-  readonly model: Endpoint4_7Request["payload"]["model"]
+type Endpoint5_7Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
+type Endpoint5_7Input = {
+  readonly sessionID: Endpoint5_7Request["params"]["sessionID"]
+  readonly model: Endpoint5_7Request["payload"]["model"]
 }
-const Endpoint4_7 = (raw: RawClient["server.session"]) => (input: Endpoint4_7Input) =>
+const Endpoint5_7 = (raw: RawClient["server.session"]) => (input: Endpoint5_7Input) =>
   raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_8Request = Parameters<RawClient["server.session"]["session.rename"]>[0]
-type Endpoint4_8Input = {
-  readonly sessionID: Endpoint4_8Request["params"]["sessionID"]
-  readonly title: Endpoint4_8Request["payload"]["title"]
+type Endpoint5_8Request = Parameters<RawClient["server.session"]["session.rename"]>[0]
+type Endpoint5_8Input = {
+  readonly sessionID: Endpoint5_8Request["params"]["sessionID"]
+  readonly title: Endpoint5_8Request["payload"]["title"]
 }
-const Endpoint4_8 = (raw: RawClient["server.session"]) => (input: Endpoint4_8Input) =>
+const Endpoint5_8 = (raw: RawClient["server.session"]) => (input: Endpoint5_8Input) =>
   raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
-type Endpoint4_9Input = {
-  readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
-  readonly destination: Endpoint4_9Request["payload"]["destination"]
-  readonly moveChanges?: Endpoint4_9Request["payload"]["moveChanges"]
+type Endpoint5_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
+type Endpoint5_9Input = {
+  readonly sessionID: Endpoint5_9Request["params"]["sessionID"]
+  readonly destination: Endpoint5_9Request["payload"]["destination"]
+  readonly moveChanges?: Endpoint5_9Request["payload"]["moveChanges"]
 }
-const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Input) =>
+const Endpoint5_9 = (raw: RawClient["server.session"]) => (input: Endpoint5_9Input) =>
   raw["session.move"]({
     params: { sessionID: input["sessionID"] },
     payload: { destination: input["destination"], moveChanges: input["moveChanges"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
-type Endpoint4_10Input = {
-  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
-  readonly id?: Endpoint4_10Request["payload"]["id"]
-  readonly prompt: Endpoint4_10Request["payload"]["prompt"]
-  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_10Request["payload"]["resume"]
+type Endpoint5_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint5_10Input = {
+  readonly sessionID: Endpoint5_10Request["params"]["sessionID"]
+  readonly id?: Endpoint5_10Request["payload"]["id"]
+  readonly prompt: Endpoint5_10Request["payload"]["prompt"]
+  readonly delivery?: Endpoint5_10Request["payload"]["delivery"]
+  readonly resume?: Endpoint5_10Request["payload"]["resume"]
 }
-const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
+const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
   raw["session.prompt"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
@@ -170,20 +175,20 @@ const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
-type Endpoint4_11Input = {
-  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
-  readonly id?: Endpoint4_11Request["payload"]["id"]
-  readonly command: Endpoint4_11Request["payload"]["command"]
-  readonly arguments?: Endpoint4_11Request["payload"]["arguments"]
-  readonly agent?: Endpoint4_11Request["payload"]["agent"]
-  readonly model?: Endpoint4_11Request["payload"]["model"]
-  readonly files?: Endpoint4_11Request["payload"]["files"]
-  readonly agents?: Endpoint4_11Request["payload"]["agents"]
-  readonly delivery?: Endpoint4_11Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_11Request["payload"]["resume"]
+type Endpoint5_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+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"]
 }
-const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
+const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
   raw["session.command"]({
     params: { sessionID: input["sessionID"] },
     payload: {
@@ -202,28 +207,28 @@ const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
-type Endpoint4_12Input = {
-  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly id?: Endpoint4_12Request["payload"]["id"]
-  readonly skill: Endpoint4_12Request["payload"]["skill"]
-  readonly resume?: Endpoint4_12Request["payload"]["resume"]
+type Endpoint5_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+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"]
 }
-const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
+const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
   raw["session.skill"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
-type Endpoint4_13Input = {
-  readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
-  readonly text: Endpoint4_13Request["payload"]["text"]
-  readonly description?: Endpoint4_13Request["payload"]["description"]
-  readonly metadata?: Endpoint4_13Request["payload"]["metadata"]
-  readonly resume?: Endpoint4_13Request["payload"]["resume"]
+type Endpoint5_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint5_13Input = {
+  readonly sessionID: Endpoint5_13Request["params"]["sessionID"]
+  readonly text: Endpoint5_13Request["payload"]["text"]
+  readonly description?: Endpoint5_13Request["payload"]["description"]
+  readonly metadata?: Endpoint5_13Request["payload"]["metadata"]
+  readonly resume?: Endpoint5_13Request["payload"]["resume"]
 }
-const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
+const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
   raw["session.synthetic"]({
     params: { sessionID: input["sessionID"] },
     payload: {
@@ -234,41 +239,41 @@ const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13I
     },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
-type Endpoint4_14Input = {
-  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
-  readonly id?: Endpoint4_14Request["payload"]["id"]
-  readonly command: Endpoint4_14Request["payload"]["command"]
+type Endpoint5_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint5_14Input = {
+  readonly sessionID: Endpoint5_14Request["params"]["sessionID"]
+  readonly id?: Endpoint5_14Request["payload"]["id"]
+  readonly command: Endpoint5_14Request["payload"]["command"]
 }
-const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
+const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
   raw["session.shell"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], command: input["command"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint4_15Input = {
-  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
-  readonly id?: Endpoint4_15Request["payload"]["id"]
+type Endpoint5_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint5_15Input = {
+  readonly sessionID: Endpoint5_15Request["params"]["sessionID"]
+  readonly id?: Endpoint5_15Request["payload"]["id"]
 }
-const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
+const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
   raw["session.compact"]({ params: { sessionID: input["sessionID"] }, payload: { id: input["id"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
-const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
+type Endpoint5_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint5_16Input = { readonly sessionID: Endpoint5_16Request["params"]["sessionID"] }
+const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
   raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint4_17Input = {
-  readonly sessionID: Endpoint4_17Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_17Request["payload"]["messageID"]
-  readonly files?: Endpoint4_17Request["payload"]["files"]
+type Endpoint5_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint5_17Input = {
+  readonly sessionID: Endpoint5_17Request["params"]["sessionID"]
+  readonly messageID: Endpoint5_17Request["payload"]["messageID"]
+  readonly files?: Endpoint5_17Request["payload"]["files"]
 }
-const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
+const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
   raw["session.revert.stage"]({
     params: { sessionID: input["sessionID"] },
     payload: { messageID: input["messageID"], files: input["files"] },
@@ -277,61 +282,61 @@ const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
-const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
+type Endpoint5_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint5_18Input = { readonly sessionID: Endpoint5_18Request["params"]["sessionID"] }
+const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
   raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
-type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
-const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
+type Endpoint5_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint5_19Input = { readonly sessionID: Endpoint5_19Request["params"]["sessionID"] }
+const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
   raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
-type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
-const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
+type Endpoint5_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint5_20Input = { readonly sessionID: Endpoint5_20Request["params"]["sessionID"] }
+const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20Input) =>
   raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
-type Endpoint4_21Input = { readonly sessionID: Endpoint4_21Request["params"]["sessionID"] }
-const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
+type Endpoint5_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+type Endpoint5_21Input = { readonly sessionID: Endpoint5_21Request["params"]["sessionID"] }
+const Endpoint5_21 = (raw: RawClient["server.session"]) => (input: Endpoint5_21Input) =>
   raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
-type Endpoint4_22Input = {
-  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
-  readonly key: Endpoint4_22Request["params"]["key"]
-  readonly value: Endpoint4_22Request["payload"]["value"]
+type Endpoint5_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
+type Endpoint5_22Input = {
+  readonly sessionID: Endpoint5_22Request["params"]["sessionID"]
+  readonly key: Endpoint5_22Request["params"]["key"]
+  readonly value: Endpoint5_22Request["payload"]["value"]
 }
-const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
+const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22Input) =>
   raw["session.instructions.entry.put"]({
     params: { sessionID: input["sessionID"], key: input["key"] },
     payload: { value: input["value"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
-type Endpoint4_23Input = {
-  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
-  readonly key: Endpoint4_23Request["params"]["key"]
+type Endpoint5_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
+type Endpoint5_23Input = {
+  readonly sessionID: Endpoint5_23Request["params"]["sessionID"]
+  readonly key: Endpoint5_23Request["params"]["key"]
 }
-const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
+const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
   raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-type Endpoint4_24Input = {
-  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
-  readonly after?: Endpoint4_24Request["query"]["after"]
-  readonly follow?: Endpoint4_24Request["query"]["follow"]
+type Endpoint5_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint5_24Input = {
+  readonly sessionID: Endpoint5_24Request["params"]["sessionID"]
+  readonly after?: Endpoint5_24Request["query"]["after"]
+  readonly follow?: Endpoint5_24Request["query"]["follow"]
 }
-const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
+const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
   Stream.unwrap(
     raw["session.log"]({
       params: { sessionID: input["sessionID"] },
@@ -342,88 +347,88 @@ const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24I
     ),
   )
 
-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
-const Endpoint4_25 = (raw: RawClient["server.session"]) => (input: Endpoint4_25Input) =>
+type Endpoint5_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint5_25Input = { readonly sessionID: Endpoint5_25Request["params"]["sessionID"] }
+const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
   raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
-type Endpoint4_26Input = { readonly sessionID: Endpoint4_26Request["params"]["sessionID"] }
-const Endpoint4_26 = (raw: RawClient["server.session"]) => (input: Endpoint4_26Input) =>
+type Endpoint5_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint5_26Input = { readonly sessionID: Endpoint5_26Request["params"]["sessionID"] }
+const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
   raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint4_27Input = {
-  readonly sessionID: Endpoint4_27Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_27Request["params"]["messageID"]
+type Endpoint5_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint5_27Input = {
+  readonly sessionID: Endpoint5_27Request["params"]["sessionID"]
+  readonly messageID: Endpoint5_27Request["params"]["messageID"]
 }
-const Endpoint4_27 = (raw: RawClient["server.session"]) => (input: Endpoint4_27Input) =>
+const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
   raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-const adaptGroup4 = (raw: RawClient["server.session"]) => ({
-  list: Endpoint4_0(raw),
-  create: Endpoint4_1(raw),
-  active: Endpoint4_2(raw),
-  get: Endpoint4_3(raw),
-  remove: Endpoint4_4(raw),
-  fork: Endpoint4_5(raw),
-  switchAgent: Endpoint4_6(raw),
-  switchModel: Endpoint4_7(raw),
-  rename: Endpoint4_8(raw),
-  move: Endpoint4_9(raw),
-  prompt: Endpoint4_10(raw),
-  command: Endpoint4_11(raw),
-  skill: Endpoint4_12(raw),
-  synthetic: Endpoint4_13(raw),
-  shell: Endpoint4_14(raw),
-  compact: Endpoint4_15(raw),
-  wait: Endpoint4_16(raw),
-  revert: { stage: Endpoint4_17(raw), clear: Endpoint4_18(raw), commit: Endpoint4_19(raw) },
-  context: Endpoint4_20(raw),
-  instructions: { entry: { list: Endpoint4_21(raw), put: Endpoint4_22(raw), remove: Endpoint4_23(raw) } },
-  log: Endpoint4_24(raw),
-  interrupt: Endpoint4_25(raw),
-  background: Endpoint4_26(raw),
-  message: Endpoint4_27(raw),
+const adaptGroup5 = (raw: RawClient["server.session"]) => ({
+  list: Endpoint5_0(raw),
+  create: Endpoint5_1(raw),
+  active: Endpoint5_2(raw),
+  get: Endpoint5_3(raw),
+  remove: Endpoint5_4(raw),
+  fork: Endpoint5_5(raw),
+  switchAgent: Endpoint5_6(raw),
+  switchModel: Endpoint5_7(raw),
+  rename: Endpoint5_8(raw),
+  move: Endpoint5_9(raw),
+  prompt: Endpoint5_10(raw),
+  command: Endpoint5_11(raw),
+  skill: Endpoint5_12(raw),
+  synthetic: Endpoint5_13(raw),
+  shell: Endpoint5_14(raw),
+  compact: Endpoint5_15(raw),
+  wait: Endpoint5_16(raw),
+  revert: { stage: Endpoint5_17(raw), clear: Endpoint5_18(raw), commit: Endpoint5_19(raw) },
+  context: Endpoint5_20(raw),
+  instructions: { entry: { list: Endpoint5_21(raw), put: Endpoint5_22(raw), remove: Endpoint5_23(raw) } },
+  log: Endpoint5_24(raw),
+  interrupt: Endpoint5_25(raw),
+  background: Endpoint5_26(raw),
+  message: Endpoint5_27(raw),
 })
 
-type Endpoint5_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
-type Endpoint5_0Input = {
-  readonly sessionID: Endpoint5_0Request["params"]["sessionID"]
-  readonly limit?: Endpoint5_0Request["query"]["limit"]
-  readonly order?: Endpoint5_0Request["query"]["order"]
-  readonly cursor?: Endpoint5_0Request["query"]["cursor"]
+type Endpoint6_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
+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"]
 }
-const Endpoint5_0 = (raw: RawClient["server.message"]) => (input: Endpoint5_0Input) =>
+const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>
   raw["session.messages"]({
     params: { sessionID: input["sessionID"] },
     query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
   }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup5 = (raw: RawClient["server.message"]) => ({ list: Endpoint5_0(raw) })
+const adaptGroup6 = (raw: RawClient["server.message"]) => ({ list: Endpoint6_0(raw) })
 
-type Endpoint6_0Request = Parameters<RawClient["server.model"]["model.list"]>[0]
-type Endpoint6_0Input = { readonly location?: Endpoint6_0Request["query"]["location"] }
-const Endpoint6_0 = (raw: RawClient["server.model"]) => (input?: Endpoint6_0Input) =>
+type Endpoint7_0Request = Parameters<RawClient["server.model"]["model.list"]>[0]
+type Endpoint7_0Input = { readonly location?: Endpoint7_0Request["query"]["location"] }
+const Endpoint7_0 = (raw: RawClient["server.model"]) => (input?: Endpoint7_0Input) =>
   raw["model.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint6_1Request = Parameters<RawClient["server.model"]["model.default"]>[0]
-type Endpoint6_1Input = { readonly location?: Endpoint6_1Request["query"]["location"] }
-const Endpoint6_1 = (raw: RawClient["server.model"]) => (input?: Endpoint6_1Input) =>
+type Endpoint7_1Request = Parameters<RawClient["server.model"]["model.default"]>[0]
+type Endpoint7_1Input = { readonly location?: Endpoint7_1Request["query"]["location"] }
+const Endpoint7_1 = (raw: RawClient["server.model"]) => (input?: Endpoint7_1Input) =>
   raw["model.default"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup6 = (raw: RawClient["server.model"]) => ({ list: Endpoint6_0(raw), default: Endpoint6_1(raw) })
+const adaptGroup7 = (raw: RawClient["server.model"]) => ({ list: Endpoint7_0(raw), default: Endpoint7_1(raw) })
 
-type Endpoint7_0Request = Parameters<RawClient["server.generate"]["generate.text"]>[0]
-type Endpoint7_0Input = {
-  readonly location?: Endpoint7_0Request["query"]["location"]
-  readonly prompt: Endpoint7_0Request["payload"]["prompt"]
-  readonly model?: Endpoint7_0Request["payload"]["model"]
+type Endpoint8_0Request = Parameters<RawClient["server.generate"]["generate.text"]>[0]
+type Endpoint8_0Input = {
+  readonly location?: Endpoint8_0Request["query"]["location"]
+  readonly prompt: Endpoint8_0Request["payload"]["prompt"]
+  readonly model?: Endpoint8_0Request["payload"]["model"]
 }
-const Endpoint7_0 = (raw: RawClient["server.generate"]) => (input: Endpoint7_0Input) =>
+const Endpoint8_0 = (raw: RawClient["server.generate"]) => (input: Endpoint8_0Input) =>
   raw["generate.text"]({
     query: { location: input["location"] },
     payload: { prompt: input["prompt"], model: input["model"] },
@@ -432,202 +437,202 @@ const Endpoint7_0 = (raw: RawClient["server.generate"]) => (input: Endpoint7_0In
     Effect.map((value) => value.data),
   )
 
-const adaptGroup7 = (raw: RawClient["server.generate"]) => ({ text: Endpoint7_0(raw) })
+const adaptGroup8 = (raw: RawClient["server.generate"]) => ({ text: Endpoint8_0(raw) })
 
-type Endpoint8_0Request = Parameters<RawClient["server.provider"]["provider.list"]>[0]
-type Endpoint8_0Input = { readonly location?: Endpoint8_0Request["query"]["location"] }
-const Endpoint8_0 = (raw: RawClient["server.provider"]) => (input?: Endpoint8_0Input) =>
+type Endpoint9_0Request = Parameters<RawClient["server.provider"]["provider.list"]>[0]
+type Endpoint9_0Input = { readonly location?: Endpoint9_0Request["query"]["location"] }
+const Endpoint9_0 = (raw: RawClient["server.provider"]) => (input?: Endpoint9_0Input) =>
   raw["provider.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint8_1Request = Parameters<RawClient["server.provider"]["provider.get"]>[0]
-type Endpoint8_1Input = {
-  readonly providerID: Endpoint8_1Request["params"]["providerID"]
-  readonly location?: Endpoint8_1Request["query"]["location"]
+type Endpoint9_1Request = Parameters<RawClient["server.provider"]["provider.get"]>[0]
+type Endpoint9_1Input = {
+  readonly providerID: Endpoint9_1Request["params"]["providerID"]
+  readonly location?: Endpoint9_1Request["query"]["location"]
 }
-const Endpoint8_1 = (raw: RawClient["server.provider"]) => (input: Endpoint8_1Input) =>
+const Endpoint9_1 = (raw: RawClient["server.provider"]) => (input: Endpoint9_1Input) =>
   raw["provider.get"]({ params: { providerID: input["providerID"] }, query: { location: input["location"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-const adaptGroup8 = (raw: RawClient["server.provider"]) => ({ list: Endpoint8_0(raw), get: Endpoint8_1(raw) })
+const adaptGroup9 = (raw: RawClient["server.provider"]) => ({ list: Endpoint9_0(raw), get: Endpoint9_1(raw) })
 
-type Endpoint9_0Request = Parameters<RawClient["server.integration"]["integration.list"]>[0]
-type Endpoint9_0Input = { readonly location?: Endpoint9_0Request["query"]["location"] }
-const Endpoint9_0 = (raw: RawClient["server.integration"]) => (input?: Endpoint9_0Input) =>
+type Endpoint10_0Request = Parameters<RawClient["server.integration"]["integration.list"]>[0]
+type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query"]["location"] }
+const Endpoint10_0 = (raw: RawClient["server.integration"]) => (input?: Endpoint10_0Input) =>
   raw["integration.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint9_1Request = Parameters<RawClient["server.integration"]["integration.get"]>[0]
-type Endpoint9_1Input = {
-  readonly integrationID: Endpoint9_1Request["params"]["integrationID"]
-  readonly location?: Endpoint9_1Request["query"]["location"]
+type Endpoint10_1Request = Parameters<RawClient["server.integration"]["integration.get"]>[0]
+type Endpoint10_1Input = {
+  readonly integrationID: Endpoint10_1Request["params"]["integrationID"]
+  readonly location?: Endpoint10_1Request["query"]["location"]
 }
-const Endpoint9_1 = (raw: RawClient["server.integration"]) => (input: Endpoint9_1Input) =>
+const Endpoint10_1 = (raw: RawClient["server.integration"]) => (input: Endpoint10_1Input) =>
   raw["integration.get"]({
     params: { integrationID: input["integrationID"] },
     query: { location: input["location"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint9_2Request = Parameters<RawClient["server.integration"]["integration.connect.key"]>[0]
-type Endpoint9_2Input = {
-  readonly integrationID: Endpoint9_2Request["params"]["integrationID"]
-  readonly location?: Endpoint9_2Request["query"]["location"]
-  readonly key: Endpoint9_2Request["payload"]["key"]
-  readonly label?: Endpoint9_2Request["payload"]["label"]
+type Endpoint10_2Request = Parameters<RawClient["server.integration"]["integration.connect.key"]>[0]
+type Endpoint10_2Input = {
+  readonly integrationID: Endpoint10_2Request["params"]["integrationID"]
+  readonly location?: Endpoint10_2Request["query"]["location"]
+  readonly key: Endpoint10_2Request["payload"]["key"]
+  readonly label?: Endpoint10_2Request["payload"]["label"]
 }
-const Endpoint9_2 = (raw: RawClient["server.integration"]) => (input: Endpoint9_2Input) =>
+const Endpoint10_2 = (raw: RawClient["server.integration"]) => (input: Endpoint10_2Input) =>
   raw["integration.connect.key"]({
     params: { integrationID: input["integrationID"] },
     query: { location: input["location"] },
     payload: { key: input["key"], label: input["label"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint9_3Request = Parameters<RawClient["server.integration"]["integration.connect.oauth"]>[0]
-type Endpoint9_3Input = {
-  readonly integrationID: Endpoint9_3Request["params"]["integrationID"]
-  readonly location?: Endpoint9_3Request["query"]["location"]
-  readonly methodID: Endpoint9_3Request["payload"]["methodID"]
-  readonly inputs: Endpoint9_3Request["payload"]["inputs"]
-  readonly label?: Endpoint9_3Request["payload"]["label"]
+type Endpoint10_3Request = Parameters<RawClient["server.integration"]["integration.connect.oauth"]>[0]
+type Endpoint10_3Input = {
+  readonly integrationID: Endpoint10_3Request["params"]["integrationID"]
+  readonly location?: Endpoint10_3Request["query"]["location"]
+  readonly methodID: Endpoint10_3Request["payload"]["methodID"]
+  readonly inputs: Endpoint10_3Request["payload"]["inputs"]
+  readonly label?: Endpoint10_3Request["payload"]["label"]
 }
-const Endpoint9_3 = (raw: RawClient["server.integration"]) => (input: Endpoint9_3Input) =>
+const Endpoint10_3 = (raw: RawClient["server.integration"]) => (input: Endpoint10_3Input) =>
   raw["integration.connect.oauth"]({
     params: { integrationID: input["integrationID"] },
     query: { location: input["location"] },
     payload: { methodID: input["methodID"], inputs: input["inputs"], label: input["label"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint9_4Request = Parameters<RawClient["server.integration"]["integration.attempt.status"]>[0]
-type Endpoint9_4Input = {
-  readonly attemptID: Endpoint9_4Request["params"]["attemptID"]
-  readonly location?: Endpoint9_4Request["query"]["location"]
+type Endpoint10_4Request = Parameters<RawClient["server.integration"]["integration.attempt.status"]>[0]
+type Endpoint10_4Input = {
+  readonly attemptID: Endpoint10_4Request["params"]["attemptID"]
+  readonly location?: Endpoint10_4Request["query"]["location"]
 }
-const Endpoint9_4 = (raw: RawClient["server.integration"]) => (input: Endpoint9_4Input) =>
+const Endpoint10_4 = (raw: RawClient["server.integration"]) => (input: Endpoint10_4Input) =>
   raw["integration.attempt.status"]({
     params: { attemptID: input["attemptID"] },
     query: { location: input["location"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint9_5Request = Parameters<RawClient["server.integration"]["integration.attempt.complete"]>[0]
-type Endpoint9_5Input = {
-  readonly attemptID: Endpoint9_5Request["params"]["attemptID"]
-  readonly location?: Endpoint9_5Request["query"]["location"]
-  readonly code?: Endpoint9_5Request["payload"]["code"]
+type Endpoint10_5Request = Parameters<RawClient["server.integration"]["integration.attempt.complete"]>[0]
+type Endpoint10_5Input = {
+  readonly attemptID: Endpoint10_5Request["params"]["attemptID"]
+  readonly location?: Endpoint10_5Request["query"]["location"]
+  readonly code?: Endpoint10_5Request["payload"]["code"]
 }
-const Endpoint9_5 = (raw: RawClient["server.integration"]) => (input: Endpoint9_5Input) =>
+const Endpoint10_5 = (raw: RawClient["server.integration"]) => (input: Endpoint10_5Input) =>
   raw["integration.attempt.complete"]({
     params: { attemptID: input["attemptID"] },
     query: { location: input["location"] },
     payload: { code: input["code"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint9_6Request = Parameters<RawClient["server.integration"]["integration.attempt.cancel"]>[0]
-type Endpoint9_6Input = {
-  readonly attemptID: Endpoint9_6Request["params"]["attemptID"]
-  readonly location?: Endpoint9_6Request["query"]["location"]
+type Endpoint10_6Request = Parameters<RawClient["server.integration"]["integration.attempt.cancel"]>[0]
+type Endpoint10_6Input = {
+  readonly attemptID: Endpoint10_6Request["params"]["attemptID"]
+  readonly location?: Endpoint10_6Request["query"]["location"]
 }
-const Endpoint9_6 = (raw: RawClient["server.integration"]) => (input: Endpoint9_6Input) =>
+const Endpoint10_6 = (raw: RawClient["server.integration"]) => (input: Endpoint10_6Input) =>
   raw["integration.attempt.cancel"]({
     params: { attemptID: input["attemptID"] },
     query: { location: input["location"] },
   }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup9 = (raw: RawClient["server.integration"]) => ({
-  list: Endpoint9_0(raw),
-  get: Endpoint9_1(raw),
-  connect: { key: Endpoint9_2(raw), oauth: Endpoint9_3(raw) },
-  attempt: { status: Endpoint9_4(raw), complete: Endpoint9_5(raw), cancel: Endpoint9_6(raw) },
+const adaptGroup10 = (raw: RawClient["server.integration"]) => ({
+  list: Endpoint10_0(raw),
+  get: Endpoint10_1(raw),
+  connect: { key: Endpoint10_2(raw), oauth: Endpoint10_3(raw) },
+  attempt: { status: Endpoint10_4(raw), complete: Endpoint10_5(raw), cancel: Endpoint10_6(raw) },
 })
 
-type Endpoint10_0Request = Parameters<RawClient["server.mcp"]["mcp.list"]>[0]
-type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query"]["location"] }
-const Endpoint10_0 = (raw: RawClient["server.mcp"]) => (input?: Endpoint10_0Input) =>
+type Endpoint11_0Request = Parameters<RawClient["server.mcp"]["mcp.list"]>[0]
+type Endpoint11_0Input = { readonly location?: Endpoint11_0Request["query"]["location"] }
+const Endpoint11_0 = (raw: RawClient["server.mcp"]) => (input?: Endpoint11_0Input) =>
   raw["mcp.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint10_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
-type Endpoint10_1Input = { readonly location?: Endpoint10_1Request["query"]["location"] }
-const Endpoint10_1 = (raw: RawClient["server.mcp"]) => (input?: Endpoint10_1Input) =>
+type Endpoint11_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
+type Endpoint11_1Input = { readonly location?: Endpoint11_1Request["query"]["location"] }
+const Endpoint11_1 = (raw: RawClient["server.mcp"]) => (input?: Endpoint11_1Input) =>
   raw["mcp.resource.catalog"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({
-  list: Endpoint10_0(raw),
-  resource: { catalog: Endpoint10_1(raw) },
+const adaptGroup11 = (raw: RawClient["server.mcp"]) => ({
+  list: Endpoint11_0(raw),
+  resource: { catalog: Endpoint11_1(raw) },
 })
 
-type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
-type Endpoint11_0Input = {
-  readonly credentialID: Endpoint11_0Request["params"]["credentialID"]
-  readonly location?: Endpoint11_0Request["query"]["location"]
-  readonly label: Endpoint11_0Request["payload"]["label"]
+type Endpoint12_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
+type Endpoint12_0Input = {
+  readonly credentialID: Endpoint12_0Request["params"]["credentialID"]
+  readonly location?: Endpoint12_0Request["query"]["location"]
+  readonly label: Endpoint12_0Request["payload"]["label"]
 }
-const Endpoint11_0 = (raw: RawClient["server.credential"]) => (input: Endpoint11_0Input) =>
+const Endpoint12_0 = (raw: RawClient["server.credential"]) => (input: Endpoint12_0Input) =>
   raw["credential.update"]({
     params: { credentialID: input["credentialID"] },
     query: { location: input["location"] },
     payload: { label: input["label"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint11_1Request = Parameters<RawClient["server.credential"]["credential.remove"]>[0]
-type Endpoint11_1Input = {
-  readonly credentialID: Endpoint11_1Request["params"]["credentialID"]
-  readonly location?: Endpoint11_1Request["query"]["location"]
+type Endpoint12_1Request = Parameters<RawClient["server.credential"]["credential.remove"]>[0]
+type Endpoint12_1Input = {
+  readonly credentialID: Endpoint12_1Request["params"]["credentialID"]
+  readonly location?: Endpoint12_1Request["query"]["location"]
 }
-const Endpoint11_1 = (raw: RawClient["server.credential"]) => (input: Endpoint11_1Input) =>
+const Endpoint12_1 = (raw: RawClient["server.credential"]) => (input: Endpoint12_1Input) =>
   raw["credential.remove"]({
     params: { credentialID: input["credentialID"] },
     query: { location: input["location"] },
   }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup11 = (raw: RawClient["server.credential"]) => ({ update: Endpoint11_0(raw), remove: Endpoint11_1(raw) })
+const adaptGroup12 = (raw: RawClient["server.credential"]) => ({ update: Endpoint12_0(raw), remove: Endpoint12_1(raw) })
 
-const Endpoint12_0 = (raw: RawClient["server.project"]) => () =>
+const Endpoint13_0 = (raw: RawClient["server.project"]) => () =>
   raw["project.list"]({}).pipe(Effect.mapError(mapClientError))
 
-type Endpoint12_1Request = Parameters<RawClient["server.project"]["project.current"]>[0]
-type Endpoint12_1Input = { readonly location?: Endpoint12_1Request["query"]["location"] }
-const Endpoint12_1 = (raw: RawClient["server.project"]) => (input?: Endpoint12_1Input) =>
+type Endpoint13_1Request = Parameters<RawClient["server.project"]["project.current"]>[0]
+type Endpoint13_1Input = { readonly location?: Endpoint13_1Request["query"]["location"] }
+const Endpoint13_1 = (raw: RawClient["server.project"]) => (input?: Endpoint13_1Input) =>
   raw["project.current"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint12_2Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
-type Endpoint12_2Input = {
-  readonly projectID: Endpoint12_2Request["params"]["projectID"]
-  readonly location?: Endpoint12_2Request["query"]["location"]
+type Endpoint13_2Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
+type Endpoint13_2Input = {
+  readonly projectID: Endpoint13_2Request["params"]["projectID"]
+  readonly location?: Endpoint13_2Request["query"]["location"]
 }
-const Endpoint12_2 = (raw: RawClient["server.project"]) => (input: Endpoint12_2Input) =>
+const Endpoint13_2 = (raw: RawClient["server.project"]) => (input: Endpoint13_2Input) =>
   raw["project.directories"]({
     params: { projectID: input["projectID"] },
     query: { location: input["location"] },
   }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup12 = (raw: RawClient["server.project"]) => ({
-  list: Endpoint12_0(raw),
-  current: Endpoint12_1(raw),
-  directories: Endpoint12_2(raw),
+const adaptGroup13 = (raw: RawClient["server.project"]) => ({
+  list: Endpoint13_0(raw),
+  current: Endpoint13_1(raw),
+  directories: Endpoint13_2(raw),
 })
 
-type Endpoint13_0Request = Parameters<RawClient["server.form"]["form.request.list"]>[0]
-type Endpoint13_0Input = { readonly location?: Endpoint13_0Request["query"]["location"] }
-const Endpoint13_0 = (raw: RawClient["server.form"]) => (input?: Endpoint13_0Input) =>
+type Endpoint14_0Request = Parameters<RawClient["server.form"]["form.request.list"]>[0]
+type Endpoint14_0Input = { readonly location?: Endpoint14_0Request["query"]["location"] }
+const Endpoint14_0 = (raw: RawClient["server.form"]) => (input?: Endpoint14_0Input) =>
   raw["form.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint13_1Request = Parameters<RawClient["server.form"]["session.form.list"]>[0]
-type Endpoint13_1Input = { readonly sessionID: Endpoint13_1Request["params"]["sessionID"] }
-const Endpoint13_1 = (raw: RawClient["server.form"]) => (input: Endpoint13_1Input) =>
+type Endpoint14_1Request = Parameters<RawClient["server.form"]["session.form.list"]>[0]
+type Endpoint14_1Input = { readonly sessionID: Endpoint14_1Request["params"]["sessionID"] }
+const Endpoint14_1 = (raw: RawClient["server.form"]) => (input: Endpoint14_1Input) =>
   raw["session.form.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint13_2Request = Parameters<RawClient["server.form"]["session.form.create"]>[0]
-type Endpoint13_2Input = {
-  readonly sessionID: Endpoint13_2Request["params"]["sessionID"]
-  readonly id?: Endpoint13_2Request["payload"]["id"]
-  readonly title: Endpoint13_2Request["payload"]["title"]
-  readonly metadata?: Endpoint13_2Request["payload"]["metadata"]
-  readonly mode: Endpoint13_2Request["payload"]["mode"]
-  readonly fields?: Endpoint13_2Request["payload"]["fields"]
-  readonly url?: Endpoint13_2Request["payload"]["url"]
+type Endpoint14_2Request = Parameters<RawClient["server.form"]["session.form.create"]>[0]
+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 mode: Endpoint14_2Request["payload"]["mode"]
+  readonly fields?: Endpoint14_2Request["payload"]["fields"]
+  readonly url?: Endpoint14_2Request["payload"]["url"]
 }
-const Endpoint13_2 = (raw: RawClient["server.form"]) => (input: Endpoint13_2Input) =>
+const Endpoint14_2 = (raw: RawClient["server.form"]) => (input: Endpoint14_2Input) =>
   raw["session.form.create"]({
     params: { sessionID: input["sessionID"] },
     payload: {
@@ -643,90 +648,90 @@ const Endpoint13_2 = (raw: RawClient["server.form"]) => (input: Endpoint13_2Inpu
     Effect.map((value) => value.data),
   )
 
-type Endpoint13_3Request = Parameters<RawClient["server.form"]["session.form.get"]>[0]
-type Endpoint13_3Input = {
-  readonly sessionID: Endpoint13_3Request["params"]["sessionID"]
-  readonly formID: Endpoint13_3Request["params"]["formID"]
+type Endpoint14_3Request = Parameters<RawClient["server.form"]["session.form.get"]>[0]
+type Endpoint14_3Input = {
+  readonly sessionID: Endpoint14_3Request["params"]["sessionID"]
+  readonly formID: Endpoint14_3Request["params"]["formID"]
 }
-const Endpoint13_3 = (raw: RawClient["server.form"]) => (input: Endpoint13_3Input) =>
+const Endpoint14_3 = (raw: RawClient["server.form"]) => (input: Endpoint14_3Input) =>
   raw["session.form.get"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint13_4Request = Parameters<RawClient["server.form"]["session.form.state"]>[0]
-type Endpoint13_4Input = {
-  readonly sessionID: Endpoint13_4Request["params"]["sessionID"]
-  readonly formID: Endpoint13_4Request["params"]["formID"]
+type Endpoint14_4Request = Parameters<RawClient["server.form"]["session.form.state"]>[0]
+type Endpoint14_4Input = {
+  readonly sessionID: Endpoint14_4Request["params"]["sessionID"]
+  readonly formID: Endpoint14_4Request["params"]["formID"]
 }
-const Endpoint13_4 = (raw: RawClient["server.form"]) => (input: Endpoint13_4Input) =>
+const Endpoint14_4 = (raw: RawClient["server.form"]) => (input: Endpoint14_4Input) =>
   raw["session.form.state"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint13_5Request = Parameters<RawClient["server.form"]["session.form.reply"]>[0]
-type Endpoint13_5Input = {
-  readonly sessionID: Endpoint13_5Request["params"]["sessionID"]
-  readonly formID: Endpoint13_5Request["params"]["formID"]
-  readonly answer: Endpoint13_5Request["payload"]["answer"]
+type Endpoint14_5Request = Parameters<RawClient["server.form"]["session.form.reply"]>[0]
+type Endpoint14_5Input = {
+  readonly sessionID: Endpoint14_5Request["params"]["sessionID"]
+  readonly formID: Endpoint14_5Request["params"]["formID"]
+  readonly answer: Endpoint14_5Request["payload"]["answer"]
 }
-const Endpoint13_5 = (raw: RawClient["server.form"]) => (input: Endpoint13_5Input) =>
+const Endpoint14_5 = (raw: RawClient["server.form"]) => (input: Endpoint14_5Input) =>
   raw["session.form.reply"]({
     params: { sessionID: input["sessionID"], formID: input["formID"] },
     payload: { answer: input["answer"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint13_6Request = Parameters<RawClient["server.form"]["session.form.cancel"]>[0]
-type Endpoint13_6Input = {
-  readonly sessionID: Endpoint13_6Request["params"]["sessionID"]
-  readonly formID: Endpoint13_6Request["params"]["formID"]
+type Endpoint14_6Request = Parameters<RawClient["server.form"]["session.form.cancel"]>[0]
+type Endpoint14_6Input = {
+  readonly sessionID: Endpoint14_6Request["params"]["sessionID"]
+  readonly formID: Endpoint14_6Request["params"]["formID"]
 }
-const Endpoint13_6 = (raw: RawClient["server.form"]) => (input: Endpoint13_6Input) =>
+const Endpoint14_6 = (raw: RawClient["server.form"]) => (input: Endpoint14_6Input) =>
   raw["session.form.cancel"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-const adaptGroup13 = (raw: RawClient["server.form"]) => ({
-  request: { list: Endpoint13_0(raw) },
-  list: Endpoint13_1(raw),
-  create: Endpoint13_2(raw),
-  get: Endpoint13_3(raw),
-  state: Endpoint13_4(raw),
-  reply: Endpoint13_5(raw),
-  cancel: Endpoint13_6(raw),
+const adaptGroup14 = (raw: RawClient["server.form"]) => ({
+  request: { list: Endpoint14_0(raw) },
+  list: Endpoint14_1(raw),
+  create: Endpoint14_2(raw),
+  get: Endpoint14_3(raw),
+  state: Endpoint14_4(raw),
+  reply: Endpoint14_5(raw),
+  cancel: Endpoint14_6(raw),
 })
 
-type Endpoint14_0Request = Parameters<RawClient["server.permission"]["permission.request.list"]>[0]
-type Endpoint14_0Input = { readonly location?: Endpoint14_0Request["query"]["location"] }
-const Endpoint14_0 = (raw: RawClient["server.permission"]) => (input?: Endpoint14_0Input) =>
+type Endpoint15_0Request = Parameters<RawClient["server.permission"]["permission.request.list"]>[0]
+type Endpoint15_0Input = { readonly location?: Endpoint15_0Request["query"]["location"] }
+const Endpoint15_0 = (raw: RawClient["server.permission"]) => (input?: Endpoint15_0Input) =>
   raw["permission.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint14_1Request = Parameters<RawClient["server.permission"]["permission.saved.list"]>[0]
-type Endpoint14_1Input = { readonly projectID?: Endpoint14_1Request["query"]["projectID"] }
-const Endpoint14_1 = (raw: RawClient["server.permission"]) => (input?: Endpoint14_1Input) =>
+type Endpoint15_1Request = Parameters<RawClient["server.permission"]["permission.saved.list"]>[0]
+type Endpoint15_1Input = { readonly projectID?: Endpoint15_1Request["query"]["projectID"] }
+const Endpoint15_1 = (raw: RawClient["server.permission"]) => (input?: Endpoint15_1Input) =>
   raw["permission.saved.list"]({ query: { projectID: input?.["projectID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint14_2Request = Parameters<RawClient["server.permission"]["permission.saved.remove"]>[0]
-type Endpoint14_2Input = { readonly id: Endpoint14_2Request["params"]["id"] }
-const Endpoint14_2 = (raw: RawClient["server.permission"]) => (input: Endpoint14_2Input) =>
+type Endpoint15_2Request = Parameters<RawClient["server.permission"]["permission.saved.remove"]>[0]
+type Endpoint15_2Input = { readonly id: Endpoint15_2Request["params"]["id"] }
+const Endpoint15_2 = (raw: RawClient["server.permission"]) => (input: Endpoint15_2Input) =>
   raw["permission.saved.remove"]({ params: { id: input["id"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint14_3Request = Parameters<RawClient["server.permission"]["session.permission.create"]>[0]
-type Endpoint14_3Input = {
-  readonly sessionID: Endpoint14_3Request["params"]["sessionID"]
-  readonly id?: Endpoint14_3Request["payload"]["id"]
-  readonly action: Endpoint14_3Request["payload"]["action"]
-  readonly resources: Endpoint14_3Request["payload"]["resources"]
-  readonly save?: Endpoint14_3Request["payload"]["save"]
-  readonly metadata?: Endpoint14_3Request["payload"]["metadata"]
-  readonly source?: Endpoint14_3Request["payload"]["source"]
-  readonly agent?: Endpoint14_3Request["payload"]["agent"]
+type Endpoint15_3Request = Parameters<RawClient["server.permission"]["session.permission.create"]>[0]
+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"]
 }
-const Endpoint14_3 = (raw: RawClient["server.permission"]) => (input: Endpoint14_3Input) =>
+const Endpoint15_3 = (raw: RawClient["server.permission"]) => (input: Endpoint15_3Input) =>
   raw["session.permission.create"]({
     params: { sessionID: input["sessionID"] },
     payload: {
@@ -743,86 +748,86 @@ const Endpoint14_3 = (raw: RawClient["server.permission"]) => (input: Endpoint14
     Effect.map((value) => value.data),
   )
 
-type Endpoint14_4Request = Parameters<RawClient["server.permission"]["session.permission.list"]>[0]
-type Endpoint14_4Input = { readonly sessionID: Endpoint14_4Request["params"]["sessionID"] }
-const Endpoint14_4 = (raw: RawClient["server.permission"]) => (input: Endpoint14_4Input) =>
+type Endpoint15_4Request = Parameters<RawClient["server.permission"]["session.permission.list"]>[0]
+type Endpoint15_4Input = { readonly sessionID: Endpoint15_4Request["params"]["sessionID"] }
+const Endpoint15_4 = (raw: RawClient["server.permission"]) => (input: Endpoint15_4Input) =>
   raw["session.permission.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint14_5Request = Parameters<RawClient["server.permission"]["session.permission.get"]>[0]
-type Endpoint14_5Input = {
-  readonly sessionID: Endpoint14_5Request["params"]["sessionID"]
-  readonly requestID: Endpoint14_5Request["params"]["requestID"]
+type Endpoint15_5Request = Parameters<RawClient["server.permission"]["session.permission.get"]>[0]
+type Endpoint15_5Input = {
+  readonly sessionID: Endpoint15_5Request["params"]["sessionID"]
+  readonly requestID: Endpoint15_5Request["params"]["requestID"]
 }
-const Endpoint14_5 = (raw: RawClient["server.permission"]) => (input: Endpoint14_5Input) =>
+const Endpoint15_5 = (raw: RawClient["server.permission"]) => (input: Endpoint15_5Input) =>
   raw["session.permission.get"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint14_6Request = Parameters<RawClient["server.permission"]["session.permission.reply"]>[0]
-type Endpoint14_6Input = {
-  readonly sessionID: Endpoint14_6Request["params"]["sessionID"]
-  readonly requestID: Endpoint14_6Request["params"]["requestID"]
-  readonly reply: Endpoint14_6Request["payload"]["reply"]
-  readonly message?: Endpoint14_6Request["payload"]["message"]
+type Endpoint15_6Request = Parameters<RawClient["server.permission"]["session.permission.reply"]>[0]
+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"]
 }
-const Endpoint14_6 = (raw: RawClient["server.permission"]) => (input: Endpoint14_6Input) =>
+const Endpoint15_6 = (raw: RawClient["server.permission"]) => (input: Endpoint15_6Input) =>
   raw["session.permission.reply"]({
     params: { sessionID: input["sessionID"], requestID: input["requestID"] },
     payload: { reply: input["reply"], message: input["message"] },
   }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup14 = (raw: RawClient["server.permission"]) => ({
-  request: { list: Endpoint14_0(raw) },
-  saved: { list: Endpoint14_1(raw), remove: Endpoint14_2(raw) },
-  create: Endpoint14_3(raw),
-  list: Endpoint14_4(raw),
-  get: Endpoint14_5(raw),
-  reply: Endpoint14_6(raw),
+const adaptGroup15 = (raw: RawClient["server.permission"]) => ({
+  request: { list: Endpoint15_0(raw) },
+  saved: { list: Endpoint15_1(raw), remove: Endpoint15_2(raw) },
+  create: Endpoint15_3(raw),
+  list: Endpoint15_4(raw),
+  get: Endpoint15_5(raw),
+  reply: Endpoint15_6(raw),
 })
 
-type Endpoint15_0Request = Parameters<RawClient["server.fs"]["fs.list"]>[0]
-type Endpoint15_0Input = {
-  readonly location?: Endpoint15_0Request["query"]["location"]
-  readonly path?: Endpoint15_0Request["query"]["path"]
+type Endpoint16_0Request = Parameters<RawClient["server.fs"]["fs.list"]>[0]
+type Endpoint16_0Input = {
+  readonly location?: Endpoint16_0Request["query"]["location"]
+  readonly path?: Endpoint16_0Request["query"]["path"]
 }
-const Endpoint15_0 = (raw: RawClient["server.fs"]) => (input?: Endpoint15_0Input) =>
+const Endpoint16_0 = (raw: RawClient["server.fs"]) => (input?: Endpoint16_0Input) =>
   raw["fs.list"]({ query: { location: input?.["location"], path: input?.["path"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint15_1Request = Parameters<RawClient["server.fs"]["fs.find"]>[0]
-type Endpoint15_1Input = {
-  readonly location?: Endpoint15_1Request["query"]["location"]
-  readonly query: Endpoint15_1Request["query"]["query"]
-  readonly type?: Endpoint15_1Request["query"]["type"]
-  readonly limit?: Endpoint15_1Request["query"]["limit"]
+type Endpoint16_1Request = Parameters<RawClient["server.fs"]["fs.find"]>[0]
+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"]
 }
-const Endpoint15_1 = (raw: RawClient["server.fs"]) => (input: Endpoint15_1Input) =>
+const Endpoint16_1 = (raw: RawClient["server.fs"]) => (input: Endpoint16_1Input) =>
   raw["fs.find"]({
     query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
   }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup15 = (raw: RawClient["server.fs"]) => ({ list: Endpoint15_0(raw), find: Endpoint15_1(raw) })
+const adaptGroup16 = (raw: RawClient["server.fs"]) => ({ list: Endpoint16_0(raw), find: Endpoint16_1(raw) })
 
-type Endpoint16_0Request = Parameters<RawClient["server.command"]["command.list"]>[0]
-type Endpoint16_0Input = { readonly location?: Endpoint16_0Request["query"]["location"] }
-const Endpoint16_0 = (raw: RawClient["server.command"]) => (input?: Endpoint16_0Input) =>
+type Endpoint17_0Request = Parameters<RawClient["server.command"]["command.list"]>[0]
+type Endpoint17_0Input = { readonly location?: Endpoint17_0Request["query"]["location"] }
+const Endpoint17_0 = (raw: RawClient["server.command"]) => (input?: Endpoint17_0Input) =>
   raw["command.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup16 = (raw: RawClient["server.command"]) => ({ list: Endpoint16_0(raw) })
+const adaptGroup17 = (raw: RawClient["server.command"]) => ({ list: Endpoint17_0(raw) })
 
-type Endpoint17_0Request = Parameters<RawClient["server.skill"]["skill.list"]>[0]
-type Endpoint17_0Input = { readonly location?: Endpoint17_0Request["query"]["location"] }
-const Endpoint17_0 = (raw: RawClient["server.skill"]) => (input?: Endpoint17_0Input) =>
+type Endpoint18_0Request = Parameters<RawClient["server.skill"]["skill.list"]>[0]
+type Endpoint18_0Input = { readonly location?: Endpoint18_0Request["query"]["location"] }
+const Endpoint18_0 = (raw: RawClient["server.skill"]) => (input?: Endpoint18_0Input) =>
   raw["skill.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup17 = (raw: RawClient["server.skill"]) => ({ list: Endpoint17_0(raw) })
+const adaptGroup18 = (raw: RawClient["server.skill"]) => ({ list: Endpoint18_0(raw) })
 
-const Endpoint18_0 = (raw: RawClient["server.event"]) => () =>
+const Endpoint19_0 = (raw: RawClient["server.event"]) => () =>
   Stream.unwrap(
     raw["event.subscribe"]({}).pipe(
       Effect.mapError(mapClientError),
@@ -830,23 +835,23 @@ const Endpoint18_0 = (raw: RawClient["server.event"]) => () =>
     ),
   )
 
-const adaptGroup18 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint18_0(raw) })
+const adaptGroup19 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint19_0(raw) })
 
-type Endpoint19_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
-type Endpoint19_0Input = { readonly location?: Endpoint19_0Request["query"]["location"] }
-const Endpoint19_0 = (raw: RawClient["server.pty"]) => (input?: Endpoint19_0Input) =>
+type Endpoint20_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+type Endpoint20_0Input = { readonly location?: Endpoint20_0Request["query"]["location"] }
+const Endpoint20_0 = (raw: RawClient["server.pty"]) => (input?: Endpoint20_0Input) =>
   raw["pty.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint19_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
-type Endpoint19_1Input = {
-  readonly location?: Endpoint19_1Request["query"]["location"]
-  readonly command?: Endpoint19_1Request["payload"]["command"]
-  readonly args?: Endpoint19_1Request["payload"]["args"]
-  readonly cwd?: Endpoint19_1Request["payload"]["cwd"]
-  readonly title?: Endpoint19_1Request["payload"]["title"]
-  readonly env?: Endpoint19_1Request["payload"]["env"]
+type Endpoint20_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
+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"]
 }
-const Endpoint19_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint19_1Input) =>
+const Endpoint20_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint20_1Input) =>
   raw["pty.create"]({
     query: { location: input?.["location"] },
     payload: {
@@ -858,274 +863,275 @@ const Endpoint19_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint19_1Inpu
     },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint19_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
-type Endpoint19_2Input = {
-  readonly ptyID: Endpoint19_2Request["params"]["ptyID"]
-  readonly location?: Endpoint19_2Request["query"]["location"]
+type Endpoint20_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
+type Endpoint20_2Input = {
+  readonly ptyID: Endpoint20_2Request["params"]["ptyID"]
+  readonly location?: Endpoint20_2Request["query"]["location"]
 }
-const Endpoint19_2 = (raw: RawClient["server.pty"]) => (input: Endpoint19_2Input) =>
+const Endpoint20_2 = (raw: RawClient["server.pty"]) => (input: Endpoint20_2Input) =>
   raw["pty.get"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint19_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
-type Endpoint19_3Input = {
-  readonly ptyID: Endpoint19_3Request["params"]["ptyID"]
-  readonly location?: Endpoint19_3Request["query"]["location"]
-  readonly title?: Endpoint19_3Request["payload"]["title"]
-  readonly size?: Endpoint19_3Request["payload"]["size"]
+type Endpoint20_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
+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"]
 }
-const Endpoint19_3 = (raw: RawClient["server.pty"]) => (input: Endpoint19_3Input) =>
+const Endpoint20_3 = (raw: RawClient["server.pty"]) => (input: Endpoint20_3Input) =>
   raw["pty.update"]({
     params: { ptyID: input["ptyID"] },
     query: { location: input["location"] },
     payload: { title: input["title"], size: input["size"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint19_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
-type Endpoint19_4Input = {
-  readonly ptyID: Endpoint19_4Request["params"]["ptyID"]
-  readonly location?: Endpoint19_4Request["query"]["location"]
+type Endpoint20_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
+type Endpoint20_4Input = {
+  readonly ptyID: Endpoint20_4Request["params"]["ptyID"]
+  readonly location?: Endpoint20_4Request["query"]["location"]
 }
-const Endpoint19_4 = (raw: RawClient["server.pty"]) => (input: Endpoint19_4Input) =>
+const Endpoint20_4 = (raw: RawClient["server.pty"]) => (input: Endpoint20_4Input) =>
   raw["pty.remove"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-const adaptGroup19 = (raw: RawClient["server.pty"]) => ({
-  list: Endpoint19_0(raw),
-  create: Endpoint19_1(raw),
-  get: Endpoint19_2(raw),
-  update: Endpoint19_3(raw),
-  remove: Endpoint19_4(raw),
+const adaptGroup20 = (raw: RawClient["server.pty"]) => ({
+  list: Endpoint20_0(raw),
+  create: Endpoint20_1(raw),
+  get: Endpoint20_2(raw),
+  update: Endpoint20_3(raw),
+  remove: Endpoint20_4(raw),
 })
 
-type Endpoint20_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0]
-type Endpoint20_0Input = { readonly location?: Endpoint20_0Request["query"]["location"] }
-const Endpoint20_0 = (raw: RawClient["server.shell"]) => (input?: Endpoint20_0Input) =>
+type Endpoint21_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0]
+type Endpoint21_0Input = { readonly location?: Endpoint21_0Request["query"]["location"] }
+const Endpoint21_0 = (raw: RawClient["server.shell"]) => (input?: Endpoint21_0Input) =>
   raw["shell.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint20_1Request = Parameters<RawClient["server.shell"]["shell.create"]>[0]
-type Endpoint20_1Input = {
-  readonly location?: Endpoint20_1Request["query"]["location"]
-  readonly command: Endpoint20_1Request["payload"]["command"]
-  readonly cwd?: Endpoint20_1Request["payload"]["cwd"]
-  readonly timeout: Endpoint20_1Request["payload"]["timeout"]
-  readonly metadata?: Endpoint20_1Request["payload"]["metadata"]
+type Endpoint21_1Request = Parameters<RawClient["server.shell"]["shell.create"]>[0]
+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"]
 }
-const Endpoint20_1 = (raw: RawClient["server.shell"]) => (input: Endpoint20_1Input) =>
+const Endpoint21_1 = (raw: RawClient["server.shell"]) => (input: Endpoint21_1Input) =>
   raw["shell.create"]({
     query: { location: input["location"] },
     payload: { command: input["command"], cwd: input["cwd"], timeout: input["timeout"], metadata: input["metadata"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint20_2Request = Parameters<RawClient["server.shell"]["shell.get"]>[0]
-type Endpoint20_2Input = {
-  readonly id: Endpoint20_2Request["params"]["id"]
-  readonly location?: Endpoint20_2Request["query"]["location"]
+type Endpoint21_2Request = Parameters<RawClient["server.shell"]["shell.get"]>[0]
+type Endpoint21_2Input = {
+  readonly id: Endpoint21_2Request["params"]["id"]
+  readonly location?: Endpoint21_2Request["query"]["location"]
 }
-const Endpoint20_2 = (raw: RawClient["server.shell"]) => (input: Endpoint20_2Input) =>
+const Endpoint21_2 = (raw: RawClient["server.shell"]) => (input: Endpoint21_2Input) =>
   raw["shell.get"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint20_3Request = Parameters<RawClient["server.shell"]["shell.timeout"]>[0]
-type Endpoint20_3Input = {
-  readonly id: Endpoint20_3Request["params"]["id"]
-  readonly location?: Endpoint20_3Request["query"]["location"]
-  readonly timeout: Endpoint20_3Request["payload"]["timeout"]
+type Endpoint21_3Request = Parameters<RawClient["server.shell"]["shell.timeout"]>[0]
+type Endpoint21_3Input = {
+  readonly id: Endpoint21_3Request["params"]["id"]
+  readonly location?: Endpoint21_3Request["query"]["location"]
+  readonly timeout: Endpoint21_3Request["payload"]["timeout"]
 }
-const Endpoint20_3 = (raw: RawClient["server.shell"]) => (input: Endpoint20_3Input) =>
+const Endpoint21_3 = (raw: RawClient["server.shell"]) => (input: Endpoint21_3Input) =>
   raw["shell.timeout"]({
     params: { id: input["id"] },
     query: { location: input["location"] },
     payload: { timeout: input["timeout"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint20_4Request = Parameters<RawClient["server.shell"]["shell.output"]>[0]
-type Endpoint20_4Input = {
-  readonly id: Endpoint20_4Request["params"]["id"]
-  readonly location?: Endpoint20_4Request["query"]["location"]
-  readonly cursor?: Endpoint20_4Request["query"]["cursor"]
-  readonly limit?: Endpoint20_4Request["query"]["limit"]
+type Endpoint21_4Request = Parameters<RawClient["server.shell"]["shell.output"]>[0]
+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"]
 }
-const Endpoint20_4 = (raw: RawClient["server.shell"]) => (input: Endpoint20_4Input) =>
+const Endpoint21_4 = (raw: RawClient["server.shell"]) => (input: Endpoint21_4Input) =>
   raw["shell.output"]({
     params: { id: input["id"] },
     query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint20_5Request = Parameters<RawClient["server.shell"]["shell.remove"]>[0]
-type Endpoint20_5Input = {
-  readonly id: Endpoint20_5Request["params"]["id"]
-  readonly location?: Endpoint20_5Request["query"]["location"]
+type Endpoint21_5Request = Parameters<RawClient["server.shell"]["shell.remove"]>[0]
+type Endpoint21_5Input = {
+  readonly id: Endpoint21_5Request["params"]["id"]
+  readonly location?: Endpoint21_5Request["query"]["location"]
 }
-const Endpoint20_5 = (raw: RawClient["server.shell"]) => (input: Endpoint20_5Input) =>
+const Endpoint21_5 = (raw: RawClient["server.shell"]) => (input: Endpoint21_5Input) =>
   raw["shell.remove"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-const adaptGroup20 = (raw: RawClient["server.shell"]) => ({
-  list: Endpoint20_0(raw),
-  create: Endpoint20_1(raw),
-  get: Endpoint20_2(raw),
-  timeout: Endpoint20_3(raw),
-  output: Endpoint20_4(raw),
-  remove: Endpoint20_5(raw),
+const adaptGroup21 = (raw: RawClient["server.shell"]) => ({
+  list: Endpoint21_0(raw),
+  create: Endpoint21_1(raw),
+  get: Endpoint21_2(raw),
+  timeout: Endpoint21_3(raw),
+  output: Endpoint21_4(raw),
+  remove: Endpoint21_5(raw),
 })
 
-type Endpoint21_0Request = Parameters<RawClient["server.question"]["question.request.list"]>[0]
-type Endpoint21_0Input = { readonly location?: Endpoint21_0Request["query"]["location"] }
-const Endpoint21_0 = (raw: RawClient["server.question"]) => (input?: Endpoint21_0Input) =>
+type Endpoint22_0Request = Parameters<RawClient["server.question"]["question.request.list"]>[0]
+type Endpoint22_0Input = { readonly location?: Endpoint22_0Request["query"]["location"] }
+const Endpoint22_0 = (raw: RawClient["server.question"]) => (input?: Endpoint22_0Input) =>
   raw["question.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint21_1Request = Parameters<RawClient["server.question"]["session.question.list"]>[0]
-type Endpoint21_1Input = { readonly sessionID: Endpoint21_1Request["params"]["sessionID"] }
-const Endpoint21_1 = (raw: RawClient["server.question"]) => (input: Endpoint21_1Input) =>
+type Endpoint22_1Request = Parameters<RawClient["server.question"]["session.question.list"]>[0]
+type Endpoint22_1Input = { readonly sessionID: Endpoint22_1Request["params"]["sessionID"] }
+const Endpoint22_1 = (raw: RawClient["server.question"]) => (input: Endpoint22_1Input) =>
   raw["session.question.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint21_2Request = Parameters<RawClient["server.question"]["session.question.reply"]>[0]
-type Endpoint21_2Input = {
-  readonly sessionID: Endpoint21_2Request["params"]["sessionID"]
-  readonly requestID: Endpoint21_2Request["params"]["requestID"]
-  readonly answers: Endpoint21_2Request["payload"]["answers"]
+type Endpoint22_2Request = Parameters<RawClient["server.question"]["session.question.reply"]>[0]
+type Endpoint22_2Input = {
+  readonly sessionID: Endpoint22_2Request["params"]["sessionID"]
+  readonly requestID: Endpoint22_2Request["params"]["requestID"]
+  readonly answers: Endpoint22_2Request["payload"]["answers"]
 }
-const Endpoint21_2 = (raw: RawClient["server.question"]) => (input: Endpoint21_2Input) =>
+const Endpoint22_2 = (raw: RawClient["server.question"]) => (input: Endpoint22_2Input) =>
   raw["session.question.reply"]({
     params: { sessionID: input["sessionID"], requestID: input["requestID"] },
     payload: { answers: input["answers"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint21_3Request = Parameters<RawClient["server.question"]["session.question.reject"]>[0]
-type Endpoint21_3Input = {
-  readonly sessionID: Endpoint21_3Request["params"]["sessionID"]
-  readonly requestID: Endpoint21_3Request["params"]["requestID"]
+type Endpoint22_3Request = Parameters<RawClient["server.question"]["session.question.reject"]>[0]
+type Endpoint22_3Input = {
+  readonly sessionID: Endpoint22_3Request["params"]["sessionID"]
+  readonly requestID: Endpoint22_3Request["params"]["requestID"]
 }
-const Endpoint21_3 = (raw: RawClient["server.question"]) => (input: Endpoint21_3Input) =>
+const Endpoint22_3 = (raw: RawClient["server.question"]) => (input: Endpoint22_3Input) =>
   raw["session.question.reject"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-const adaptGroup21 = (raw: RawClient["server.question"]) => ({
-  request: { list: Endpoint21_0(raw) },
-  list: Endpoint21_1(raw),
-  reply: Endpoint21_2(raw),
-  reject: Endpoint21_3(raw),
+const adaptGroup22 = (raw: RawClient["server.question"]) => ({
+  request: { list: Endpoint22_0(raw) },
+  list: Endpoint22_1(raw),
+  reply: Endpoint22_2(raw),
+  reject: Endpoint22_3(raw),
 })
 
-type Endpoint22_0Request = Parameters<RawClient["server.reference"]["reference.list"]>[0]
-type Endpoint22_0Input = { readonly location?: Endpoint22_0Request["query"]["location"] }
-const Endpoint22_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint22_0Input) =>
+type Endpoint23_0Request = Parameters<RawClient["server.reference"]["reference.list"]>[0]
+type Endpoint23_0Input = { readonly location?: Endpoint23_0Request["query"]["location"] }
+const Endpoint23_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint23_0Input) =>
   raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup22 = (raw: RawClient["server.reference"]) => ({ list: Endpoint22_0(raw) })
+const adaptGroup23 = (raw: RawClient["server.reference"]) => ({ list: Endpoint23_0(raw) })
 
-type Endpoint23_0Request = Parameters<RawClient["server.projectCopy"]["projectCopy.create"]>[0]
-type Endpoint23_0Input = {
-  readonly projectID: Endpoint23_0Request["params"]["projectID"]
-  readonly location?: Endpoint23_0Request["query"]["location"]
-  readonly strategy: Endpoint23_0Request["payload"]["strategy"]
-  readonly directory: Endpoint23_0Request["payload"]["directory"]
-  readonly name?: Endpoint23_0Request["payload"]["name"]
+type Endpoint24_0Request = Parameters<RawClient["server.projectCopy"]["projectCopy.create"]>[0]
+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"]
 }
-const Endpoint23_0 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint23_0Input) =>
+const Endpoint24_0 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint24_0Input) =>
   raw["projectCopy.create"]({
     params: { projectID: input["projectID"] },
     query: { location: input["location"] },
     payload: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint23_1Request = Parameters<RawClient["server.projectCopy"]["projectCopy.remove"]>[0]
-type Endpoint23_1Input = {
-  readonly projectID: Endpoint23_1Request["params"]["projectID"]
-  readonly location?: Endpoint23_1Request["query"]["location"]
-  readonly directory: Endpoint23_1Request["payload"]["directory"]
-  readonly force: Endpoint23_1Request["payload"]["force"]
+type Endpoint24_1Request = Parameters<RawClient["server.projectCopy"]["projectCopy.remove"]>[0]
+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"]
 }
-const Endpoint23_1 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint23_1Input) =>
+const Endpoint24_1 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint24_1Input) =>
   raw["projectCopy.remove"]({
     params: { projectID: input["projectID"] },
     query: { location: input["location"] },
     payload: { directory: input["directory"], force: input["force"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint23_2Request = Parameters<RawClient["server.projectCopy"]["projectCopy.refresh"]>[0]
-type Endpoint23_2Input = {
-  readonly projectID: Endpoint23_2Request["params"]["projectID"]
-  readonly location?: Endpoint23_2Request["query"]["location"]
+type Endpoint24_2Request = Parameters<RawClient["server.projectCopy"]["projectCopy.refresh"]>[0]
+type Endpoint24_2Input = {
+  readonly projectID: Endpoint24_2Request["params"]["projectID"]
+  readonly location?: Endpoint24_2Request["query"]["location"]
 }
-const Endpoint23_2 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint23_2Input) =>
+const Endpoint24_2 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint24_2Input) =>
   raw["projectCopy.refresh"]({
     params: { projectID: input["projectID"] },
     query: { location: input["location"] },
   }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup23 = (raw: RawClient["server.projectCopy"]) => ({
-  create: Endpoint23_0(raw),
-  remove: Endpoint23_1(raw),
-  refresh: Endpoint23_2(raw),
+const adaptGroup24 = (raw: RawClient["server.projectCopy"]) => ({
+  create: Endpoint24_0(raw),
+  remove: Endpoint24_1(raw),
+  refresh: Endpoint24_2(raw),
 })
 
-type Endpoint24_0Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
-type Endpoint24_0Input = { readonly location?: Endpoint24_0Request["query"]["location"] }
-const Endpoint24_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint24_0Input) =>
+type Endpoint25_0Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
+type Endpoint25_0Input = { readonly location?: Endpoint25_0Request["query"]["location"] }
+const Endpoint25_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_0Input) =>
   raw["vcs.status"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint24_1Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0]
-type Endpoint24_1Input = {
-  readonly location?: Endpoint24_1Request["query"]["location"]
-  readonly mode: Endpoint24_1Request["query"]["mode"]
-  readonly context?: Endpoint24_1Request["query"]["context"]
+type Endpoint25_1Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0]
+type Endpoint25_1Input = {
+  readonly location?: Endpoint25_1Request["query"]["location"]
+  readonly mode: Endpoint25_1Request["query"]["mode"]
+  readonly context?: Endpoint25_1Request["query"]["context"]
 }
-const Endpoint24_1 = (raw: RawClient["server.vcs"]) => (input: Endpoint24_1Input) =>
+const Endpoint25_1 = (raw: RawClient["server.vcs"]) => (input: Endpoint25_1Input) =>
   raw["vcs.diff"]({ query: { location: input["location"], mode: input["mode"], context: input["context"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-const adaptGroup24 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint24_0(raw), diff: Endpoint24_1(raw) })
+const adaptGroup25 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint25_0(raw), diff: Endpoint25_1(raw) })
 
-const Endpoint25_0 = (raw: RawClient["server.debug"]) => () =>
+const Endpoint26_0 = (raw: RawClient["server.debug"]) => () =>
   raw["debug.location"]({}).pipe(Effect.mapError(mapClientError))
 
-type Endpoint25_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
-type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
-const Endpoint25_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint25_1Input) =>
+type Endpoint26_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
+type Endpoint26_1Input = { readonly location?: Endpoint26_1Request["query"]["location"] }
+const Endpoint26_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint26_1Input) =>
   raw["debug.location.evict"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-const adaptGroup25 = (raw: RawClient["server.debug"]) => ({
-  location: { list: Endpoint25_0(raw), evict: Endpoint25_1(raw) },
+const adaptGroup26 = (raw: RawClient["server.debug"]) => ({
+  location: { list: Endpoint26_0(raw), evict: Endpoint26_1(raw) },
 })
 
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
-  location: adaptGroup1(raw["server.location"]),
-  agent: adaptGroup2(raw["server.agent"]),
-  plugin: adaptGroup3(raw["server.plugin"]),
-  session: adaptGroup4(raw["server.session"]),
-  message: adaptGroup5(raw["server.message"]),
-  model: adaptGroup6(raw["server.model"]),
-  generate: adaptGroup7(raw["server.generate"]),
-  provider: adaptGroup8(raw["server.provider"]),
-  integration: adaptGroup9(raw["server.integration"]),
-  "server.mcp": adaptGroup10(raw["server.mcp"]),
-  credential: adaptGroup11(raw["server.credential"]),
-  project: adaptGroup12(raw["server.project"]),
-  form: adaptGroup13(raw["server.form"]),
-  permission: adaptGroup14(raw["server.permission"]),
-  file: adaptGroup15(raw["server.fs"]),
-  command: adaptGroup16(raw["server.command"]),
-  skill: adaptGroup17(raw["server.skill"]),
-  event: adaptGroup18(raw["server.event"]),
-  pty: adaptGroup19(raw["server.pty"]),
-  shell: adaptGroup20(raw["server.shell"]),
-  question: adaptGroup21(raw["server.question"]),
-  reference: adaptGroup22(raw["server.reference"]),
-  projectCopy: adaptGroup23(raw["server.projectCopy"]),
-  vcs: adaptGroup24(raw["server.vcs"]),
-  debug: adaptGroup25(raw["server.debug"]),
+  server: adaptGroup1(raw["server.server"]),
+  location: adaptGroup2(raw["server.location"]),
+  agent: adaptGroup3(raw["server.agent"]),
+  plugin: adaptGroup4(raw["server.plugin"]),
+  session: adaptGroup5(raw["server.session"]),
+  message: adaptGroup6(raw["server.message"]),
+  model: adaptGroup7(raw["server.model"]),
+  generate: adaptGroup8(raw["server.generate"]),
+  provider: adaptGroup9(raw["server.provider"]),
+  integration: adaptGroup10(raw["server.integration"]),
+  "server.mcp": adaptGroup11(raw["server.mcp"]),
+  credential: adaptGroup12(raw["server.credential"]),
+  project: adaptGroup13(raw["server.project"]),
+  form: adaptGroup14(raw["server.form"]),
+  permission: adaptGroup15(raw["server.permission"]),
+  file: adaptGroup16(raw["server.fs"]),
+  command: adaptGroup17(raw["server.command"]),
+  skill: adaptGroup18(raw["server.skill"]),
+  event: adaptGroup19(raw["server.event"]),
+  pty: adaptGroup20(raw["server.pty"]),
+  shell: adaptGroup21(raw["server.shell"]),
+  question: adaptGroup22(raw["server.question"]),
+  reference: adaptGroup23(raw["server.reference"]),
+  projectCopy: adaptGroup24(raw["server.projectCopy"]),
+  vcs: adaptGroup25(raw["server.vcs"]),
+  debug: adaptGroup26(raw["server.debug"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>
diff --git a/packages/client/src/promise/generated/client.ts b/packages/client/src/promise/generated/client.ts
index cc1b6b18540..63c7eac36ad 100644
--- a/packages/client/src/promise/generated/client.ts
+++ b/packages/client/src/promise/generated/client.ts
@@ -1,5 +1,6 @@
 import type {
   HealthGetOutput,
+  ServerGetOutput,
   LocationGetInput,
   LocationGetOutput,
   AgentListInput,
@@ -328,6 +329,13 @@ export function make(options: ClientOptions) {
           requestOptions,
         ),
     },
+    server: {
+      get: (requestOptions?: RequestOptions) =>
+        request<ServerGetOutput>(
+          { method: "GET", path: `/api/server`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
+          requestOptions,
+        ),
+    },
     location: {
       get: (input?: LocationGetInput, requestOptions?: RequestOptions) =>
         request<LocationGetOutput>(
diff --git a/packages/client/src/promise/generated/types.ts b/packages/client/src/promise/generated/types.ts
index 4795ac83e6f..078695bf575 100644
--- a/packages/client/src/promise/generated/types.ts
+++ b/packages/client/src/promise/generated/types.ts
@@ -159,6 +159,8 @@ export const isProjectCopyError = (value: unknown): value is ProjectCopyError =>
 
 export type HealthGetOutput = { readonly healthy: true; readonly version: string; readonly pid: number }
 
+export type ServerGetOutput = { readonly urls: ReadonlyArray<string> }
+
 export type LocationGetInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
diff --git a/packages/client/test/promise.test.ts b/packages/client/test/promise.test.ts
index e67d7379422..d21150877fe 100644
--- a/packages/client/test/promise.test.ts
+++ b/packages/client/test/promise.test.ts
@@ -6,6 +6,7 @@ test("exposes every standard HTTP API group", () => {
 
   expect(Object.keys(client)).toEqual([
     "health",
+    "server",
     "location",
     "agent",
     "plugin",
@@ -45,6 +46,21 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
 })
 
+test("server.get uses the public HTTP contract", async () => {
+  let request: Request | undefined
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input) => {
+      request = input instanceof Request ? input : new Request(input)
+      return Response.json({ urls: ["http://192.168.1.10:4096"] })
+    },
+  })
+
+  expect(await client.server.get()).toEqual({ urls: ["http://192.168.1.10:4096"] })
+  expect(request?.method).toBe("GET")
+  expect(request?.url).toBe("http://localhost:3000/api/server")
+})
+
 test("MCP resource catalog uses the public HTTP contract", async () => {
   let request: Request | undefined
   const client = OpenCode.make({
diff --git a/packages/protocol/src/api.ts b/packages/protocol/src/api.ts
index 2f91fae3322..a7a6ef9fd2b 100644
--- a/packages/protocol/src/api.ts
+++ b/packages/protocol/src/api.ts
@@ -16,6 +16,7 @@ import type { Definition } from "@opencode-ai/schema/event"
 import { AgentGroup } from "./groups/agent.js"
 import { PluginGroup } from "./groups/plugin.js"
 import { HealthGroup } from "./groups/health.js"
+import { ServerGroup } from "./groups/server.js"
 import { DebugGroup } from "./groups/debug.js"
 import { PtyGroup } from "./groups/pty.js"
 import { ShellGroup } from "./groups/shell.js"
@@ -82,6 +83,7 @@ type ApiGroups<
   Event extends HttpApiGroup.Any,
 > =
   | typeof HealthGroup
+  | typeof ServerGroup
   | typeof DebugGroup
   | LocationGroups<LocationId>
   | FormGroups<LocationId, LocationService, FormLocationId, FormLocationService>
@@ -143,6 +145,7 @@ const makeApiFromGroup = <
 > =>
   HttpApi.make("server")
     .add(HealthGroup)
+    .add(ServerGroup)
     .add(LocationGroup.middleware(locationMiddleware))
     .add(AgentGroup.middleware(locationMiddleware))
     .add(PluginGroup.middleware(locationMiddleware))
diff --git a/packages/protocol/src/client.ts b/packages/protocol/src/client.ts
index 03f9a340157..27201783cdd 100644
--- a/packages/protocol/src/client.ts
+++ b/packages/protocol/src/client.ts
@@ -34,6 +34,7 @@ export const ClientApi: ClientApiShape = makeDefaultApi({
 
 export const groupNames = {
   "server.health": "health",
+  "server.server": "server",
   "server.debug": "debug",
   "server.location": "location",
   "server.agent": "agent",
diff --git a/packages/protocol/src/groups/server.ts b/packages/protocol/src/groups/server.ts
new file mode 100644
index 00000000000..1ca59921ad5
--- /dev/null
+++ b/packages/protocol/src/groups/server.ts
@@ -0,0 +1,16 @@
+import { Schema } from "effect"
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+
+export const ServerGroup = HttpApiGroup.make("server.server")
+  .add(
+    HttpApiEndpoint.get("server.get", "/api/server", {
+      success: Schema.Struct({ urls: Schema.Array(Schema.String) }),
+    }).annotateMerge(
+      OpenApi.annotations({
+        identifier: "v2.server.get",
+        summary: "Get server information",
+        description: "Return the URLs that can be used to connect to this server.",
+      }),
+    ),
+  )
+  .annotateMerge(OpenApi.annotations({ title: "server" }))
diff --git a/packages/sdk/js/src/v2/gen/sdk.gen.ts b/packages/sdk/js/src/v2/gen/sdk.gen.ts
index 03d76cc5de5..54e5759ac4c 100644
--- a/packages/sdk/js/src/v2/gen/sdk.gen.ts
+++ b/packages/sdk/js/src/v2/gen/sdk.gen.ts
@@ -362,6 +362,8 @@ import type {
   V2QuestionRequestListResponses,
   V2ReferenceListErrors,
   V2ReferenceListResponses,
+  V2ServerGetErrors,
+  V2ServerGetResponses,
   V2SessionActiveErrors,
   V2SessionActiveResponses,
   V2SessionBackgroundErrors,
@@ -5113,6 +5115,20 @@ export class Health extends HeyApiClient {
   }
 }
 
+export class Server extends HeyApiClient {
+  /**
+   * Get server information
+   *
+   * Return the URLs that can be used to connect to this server.
+   */
+  public get<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>) {
+    return (options?.client ?? this.client).get<V2ServerGetResponses, V2ServerGetErrors, ThrowOnError>({
+      url: "/api/server",
+      ...options,
+    })
+  }
+}
+
 export class Location extends HeyApiClient {
   /**
    * Get location
@@ -8259,6 +8275,11 @@ export class V2 extends HeyApiClient {
     return (this._health ??= new Health({ client: this.client }))
   }
 
+  private _server?: Server
+  get server(): Server {
+    return (this._server ??= new Server({ client: this.client }))
+  }
+
   private _location?: Location
   get location(): Location {
     return (this._location ??= new Location({ client: this.client }))
diff --git a/packages/sdk/js/src/v2/gen/types.gen.ts b/packages/sdk/js/src/v2/gen/types.gen.ts
index 87d7ae6b9c4..e0bad3abc0f 100644
--- a/packages/sdk/js/src/v2/gen/types.gen.ts
+++ b/packages/sdk/js/src/v2/gen/types.gen.ts
@@ -15154,6 +15154,37 @@ export type V2HealthGetResponses = {
 
 export type V2HealthGetResponse = V2HealthGetResponses[keyof V2HealthGetResponses]
 
+export type V2ServerGetData = {
+  body?: never
+  path?: never
+  query?: never
+  url: "/api/server"
+}
+
+export type V2ServerGetErrors = {
+  /**
+   * InvalidRequestError
+   */
+  400: InvalidRequestErrorV2
+  /**
+   * UnauthorizedError
+   */
+  401: UnauthorizedError
+}
+
+export type V2ServerGetError = V2ServerGetErrors[keyof V2ServerGetErrors]
+
+export type V2ServerGetResponses = {
+  /**
+   * Success
+   */
+  200: {
+    urls: Array<string>
+  }
+}
+
+export type V2ServerGetResponse = V2ServerGetResponses[keyof V2ServerGetResponses]
+
 export type V2LocationGetData = {
   body?: never
   path?: never
diff --git a/packages/server/src/handlers.ts b/packages/server/src/handlers.ts
index 896cbbc5920..5dfbefe11c1 100644
--- a/packages/server/src/handlers.ts
+++ b/packages/server/src/handlers.ts
@@ -13,6 +13,7 @@ import { EventHandler } from "./handlers/event"
 import { AgentHandler } from "./handlers/agent"
 import { PluginHandler } from "./handlers/plugin"
 import { HealthHandler } from "./handlers/health"
+import { ServerHandler } from "./handlers/server"
 import { DebugHandler } from "./handlers/debug"
 import { PtyHandler } from "./handlers/pty"
 import { ShellHandler } from "./handlers/shell"
@@ -28,6 +29,7 @@ import { VcsHandler } from "./handlers/vcs"
 
 export const handlers = Layer.mergeAll(
   HealthHandler,
+  ServerHandler,
   DebugHandler,
   LocationHandler,
   AgentHandler,
diff --git a/packages/server/src/handlers/server.ts b/packages/server/src/handlers/server.ts
new file mode 100644
index 00000000000..0eec917cd42
--- /dev/null
+++ b/packages/server/src/handlers/server.ts
@@ -0,0 +1,13 @@
+import { Effect } from "effect"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import { Api } from "../api"
+import { ServerInfo } from "../server-info"
+
+export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) =>
+  handlers.handle("server.get", () =>
+    Effect.gen(function* () {
+      const info = yield* ServerInfo.Service
+      return { urls: info.urls() }
+    }),
+  ),
+)
diff --git a/packages/server/src/process.ts b/packages/server/src/process.ts
index 971d77734b6..28e9a49117b 100644
--- a/packages/server/src/process.ts
+++ b/packages/server/src/process.ts
@@ -8,6 +8,7 @@ import { HttpApi, HttpApiClient } from "effect/unstable/httpapi"
 import { createServer } from "node:http"
 import { ServerAuth } from "./auth"
 import { createRoutes } from "./routes"
+import { ServerInfo } from "./server-info"
 
 export type Options = {
   readonly hostname: string
@@ -48,7 +49,12 @@ function listen(options: Options) {
 function bind(hostname: string, port: number, password: string) {
   const server = createServer()
   return Layer.build(
-    createRoutes(password).pipe(
+    createRoutes(password, () => {
+      const address = server.address()
+      if (address === null || typeof address === "string") return []
+      const host = address.family === "IPv6" ? `[${address.address}]` : address.address
+      return ServerInfo.connectionURLs(`http://${host}:${address.port}`, hostname)
+    }).pipe(
       Layer.flatMap((context) =>
         HttpServer.serve(Context.get(context, HttpRouter.HttpRouter).asHttpEffect(), HttpMiddleware.logger),
       ),
diff --git a/packages/server/src/routes.ts b/packages/server/src/routes.ts
index 773b01ad2ff..0a398105fff 100644
--- a/packages/server/src/routes.ts
+++ b/packages/server/src/routes.ts
@@ -30,6 +30,7 @@ import { PtyEnvironment } from "./pty-environment"
 import { layer } from "./location"
 import { formLocationLayer } from "./middleware/form-location"
 import { sessionLocationLayer } from "./middleware/session-location"
+import { ServerInfo } from "./server-info"
 
 const applicationServices = LayerNode.group([
   Database.node,
@@ -50,11 +51,12 @@ const applicationServices = LayerNode.group([
   LocationServiceMap.node,
 ])
 
-export function createRoutes(password?: string) {
+export function createRoutes(password?: string, serviceURLs: () => ReadonlyArray<string> = () => []) {
   return makeRoutes(
     password
       ? ServerAuth.Config.configLayer({ username: "opencode", password: Option.some(password) })
       : ServerAuth.Config.layer,
+    serviceURLs,
   )
 }
 
@@ -62,7 +64,10 @@ export function createEmbeddedRoutes() {
   return makeRoutes(ServerAuth.Config.configLayer({ username: "opencode", password: Option.none() }))
 }
 
-function makeRoutes<AuthError, AuthServices>(auth: Layer.Layer<ServerAuth.Config, AuthError, AuthServices>) {
+function makeRoutes<AuthError, AuthServices>(
+  auth: Layer.Layer<ServerAuth.Config, AuthError, AuthServices>,
+  serviceURLs: () => ReadonlyArray<string> = () => [],
+) {
   const pluginRuntimeCell = PluginRuntime.makeCell()
   const replacements: LayerNode.Replacements = [
     [SessionExecution.node, SessionExecutionLocal.node],
@@ -87,7 +92,10 @@ function makeRoutes<AuthError, AuthServices>(auth: Layer.Layer<ServerAuth.Config
   return serviceLayer.pipe(
     Layer.flatMap((context) => {
       const services = Layer.succeedContext(context)
-      const requestServices = Layer.succeedContext(Context.pick(PermissionSaved.Service, Project.Service)(context))
+      const requestServices = Layer.merge(
+        Layer.succeedContext(Context.pick(PermissionSaved.Service, Project.Service)(context)),
+        ServerInfo.layer(serviceURLs),
+      )
       return HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(
         Layer.provide(handlers.pipe(Layer.provide(services))),
         Layer.provide(formLocationLayer),
diff --git a/packages/server/src/server-info.ts b/packages/server/src/server-info.ts
new file mode 100644
index 00000000000..7d1ba4b094f
--- /dev/null
+++ b/packages/server/src/server-info.ts
@@ -0,0 +1,32 @@
+import { Context, Layer } from "effect"
+import { networkInterfaces } from "node:os"
+
+export class Service extends Context.Service<Service, { readonly urls: () => ReadonlyArray<string> }>()(
+  "@opencode-ai/server/ServerInfo",
+) {}
+
+export function layer(urls: () => ReadonlyArray<string>) {
+  return Layer.succeed(Service, Service.of({ urls }))
+}
+
+export function connectionURLs(value: string, requestedHostname?: string) {
+  const url = new URL(value)
+  const hostname = requestedHostname ?? url.hostname
+  const family = hostname === "0.0.0.0" ? "IPv4" : hostname === "::" || hostname === "[::]" ? "IPv6" : undefined
+  if (family === undefined) return [value]
+
+  return [
+    ...new Set(
+      Object.values(networkInterfaces())
+        .flatMap((entries) => entries ?? [])
+        .filter((entry) => !entry.internal && entry.family === family)
+        .map((entry) => {
+          const result = new URL(value)
+          result.hostname = family === "IPv6" ? `[${entry.address}]` : entry.address
+          return result.toString().replace(/\/$/, "")
+        }),
+    ),
+  ]
+}
+
+export * as ServerInfo from "./server-info"
diff --git a/packages/tui/package.json b/packages/tui/package.json
index da2af805046..03cd6c2a308 100644
--- a/packages/tui/package.json
+++ b/packages/tui/package.json
@@ -69,8 +69,9 @@
     "open": "10.1.2",
     "opentui-spinner": "catalog:",
     "remeda": "catalog:",
+    "solid-js": "catalog:",
     "strip-ansi": "7.1.2",
-    "solid-js": "catalog:"
+    "uqr": "0.1.3"
   },
   "devDependencies": {
     "@tsconfig/bun": "catalog:",
diff --git a/packages/tui/src/app.tsx b/packages/tui/src/app.tsx
index c5535ad32d2..d5224db87bd 100644
--- a/packages/tui/src/app.tsx
+++ b/packages/tui/src/app.tsx
@@ -45,6 +45,7 @@ import { useConnected } from "./component/use-connected"
 import { DialogMcp } from "./component/dialog-mcp"
 import { DialogStatus } from "./component/dialog-status"
 import { DialogDebug } from "./component/dialog-debug"
+import { DialogLink, type DialogLinkCredentials } from "./component/dialog-link"
 import { DialogThemeList } from "./component/dialog-theme-list"
 import { DialogHelp } from "./ui/dialog-help"
 import { DialogAgent } from "./component/dialog-agent"
@@ -121,6 +122,7 @@ const appBindingCommands = [
   "provider.connect",
   "console.org.switch",
   "opencode.status",
+  "server.link",
   "opencode.debug",
   "theme.switch",
   "theme.switch_mode",
@@ -146,6 +148,7 @@ export type TuiInput = {
   api: OpenCodeClient
   discover?: () => Promise<{ client: OpencodeClient; api: OpenCodeClient }>
   reload?: () => Promise<void>
+  link?: DialogLinkCredentials
   args: Args
   config: TuiConfig.Resolved
   onSnapshot?: () => Promise<string[]>
@@ -335,6 +338,7 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
                                                                       <App
                                                                         onSnapshot={input.onSnapshot}
                                                                         pluginHost={input.pluginHost}
+                                                                        link={input.link}
                                                                       />
                                                                     </LocationProvider>
                                                                   </EditorContextProvider>
@@ -380,7 +384,11 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
   })
 })
 
-function App(props: { onSnapshot?: () => Promise<string[]>; pluginHost: TuiPluginHost }) {
+function App(props: {
+  onSnapshot?: () => Promise<string[]>
+  pluginHost: TuiPluginHost
+  link?: DialogLinkCredentials
+}) {
   const log = useLog({ component: "app" })
   const startup = useTuiStartup()
   const tuiConfig = useTuiConfig()
@@ -813,6 +821,15 @@ function App(props: { onSnapshot?: () => Promise<string[]>; pluginHost: TuiPlugi
         },
         category: "System",
       },
+      {
+        name: "server.link",
+        title: "Show server connection information",
+        slashName: "link",
+        run: () => {
+          dialog.replace(() => <DialogLink credentials={props.link} />)
+        },
+        category: "System",
+      },
       ...(sdk.reload
         ? [
             {
diff --git a/packages/tui/src/component/dialog-link.tsx b/packages/tui/src/component/dialog-link.tsx
new file mode 100644
index 00000000000..6e5a4712ab6
--- /dev/null
+++ b/packages/tui/src/component/dialog-link.tsx
@@ -0,0 +1,126 @@
+import { TextAttributes } from "@opentui/core"
+import { useTerminalDimensions } from "@opentui/solid"
+import { createMemo, createResource, createSignal, For, Show } from "solid-js"
+import { renderUnicodeCompact } from "uqr"
+import { useSDK } from "../context/sdk"
+import { useTheme } from "../context/theme"
+import { useDialog } from "../ui/dialog"
+import { errorMessage } from "../util/error"
+
+export type DialogLinkCredentials = {
+  readonly username: string
+  readonly password: string
+}
+
+export function DialogLink(props: { credentials?: DialogLinkCredentials }) {
+  const sdk = useSDK()
+  const dialog = useDialog()
+  const dimensions = useTerminalDimensions()
+  const { theme } = useTheme()
+  const [loadError, setLoadError] = createSignal<unknown>()
+  const [showPassword, setShowPassword] = createSignal(false)
+  const [passwordHover, setPasswordHover] = createSignal(false)
+
+  dialog.setSize("large")
+  dialog.setCentered(true)
+
+  const [server] = createResource(() =>
+    sdk.client.v2.server
+      .get({ throwOnError: true })
+      .then((result) => result.data)
+      .catch((error) => {
+        setLoadError(error)
+        return undefined
+      }),
+  )
+  const info = createMemo(() => {
+    const current = server()
+    if (!current) return
+    return {
+      urls: current.urls,
+      username: props.credentials?.username ?? "opencode",
+      password: props.credentials?.password ?? "",
+    }
+  })
+  const horizontal = createMemo(() => dimensions().width >= 96)
+  const content = () => {
+    const value = info()
+    if (!value) return
+    return (
+      <box
+        flexDirection={horizontal() ? "row" : "column"}
+        alignItems={horizontal() ? "flex-start" : "center"}
+        gap={2}
+      >
+        <box width={horizontal() ? 29 : "100%"} flexShrink={0} gap={1}>
+          <box>
+            <text fg={theme.textMuted}>URLs</text>
+            <For each={value.urls}>{(url) => <text fg={theme.text}>{url}</text>}</For>
+          </box>
+          <box>
+            <text fg={theme.textMuted}>Username</text>
+            <text fg={theme.text}>{value.username}</text>
+          </box>
+          <box>
+            <text fg={theme.textMuted}>Password</text>
+            <text
+              fg={passwordHover() ? theme.text : theme.textMuted}
+              wrapMode="word"
+              onMouseOver={() => setPasswordHover(true)}
+              onMouseOut={() => setPasswordHover(false)}
+              onMouseUp={() => setShowPassword((current) => !current)}
+            >
+              {showPassword() ? value.password : "************"}
+            </text>
+          </box>
+          <Show
+            when={value.urls.some((url) => ["localhost", "127.0.0.1", "[::1]"].includes(new URL(url).hostname))}
+          >
+            <text fg={theme.textMuted} wrapMode="word">
+              Run `opencode service set hostname 0.0.0.0` to access the service remotely.
+            </text>
+          </Show>
+        </box>
+        <box
+          width={horizontal() ? undefined : "100%"}
+          flexGrow={horizontal() ? 1 : 0}
+          flexShrink={0}
+          alignItems={horizontal() ? "flex-end" : "center"}
+        >
+          <text fg={theme.text}>{renderUnicodeCompact(JSON.stringify(value), { border: 1 })}</text>
+        </box>
+      </box>
+    )
+  }
+
+  return (
+    <box paddingLeft={2} paddingRight={2} paddingBottom={1} gap={1}>
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme.text} attributes={TextAttributes.BOLD}>
+          Link
+        </text>
+        <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
+          esc
+        </text>
+      </box>
+      <Show when={loadError()}>
+        {(error) => <text fg={theme.error}>{errorMessage(error())}</text>}
+      </Show>
+      <Show when={info()} fallback={<text fg={theme.textMuted}>Loading server information...</text>}>
+        <Show
+          when={dimensions().height >= 36}
+          fallback={
+            <scrollbox
+              height={Math.max(8, dimensions().height - Math.floor(dimensions().height / 4) - 6)}
+              scrollbarOptions={{ visible: false }}
+            >
+              {content()}
+            </scrollbox>
+          }
+        >
+          {content()}
+        </Show>
+      </Show>
+    </box>
+  )
+}
diff --git a/packages/tui/src/ui/dialog.tsx b/packages/tui/src/ui/dialog.tsx
index 50281630bc5..ee7d546b98d 100644
--- a/packages/tui/src/ui/dialog.tsx
+++ b/packages/tui/src/ui/dialog.tsx
@@ -11,6 +11,7 @@ import { useClipboard } from "../context/clipboard"
 export function Dialog(
   props: ParentProps<{
     size?: "medium" | "large" | "xlarge"
+    centered?: boolean
     onClose: () => void
   }>,
 ) {
@@ -40,9 +41,10 @@ export function Dialog(
       width={dimensions().width}
       height={dimensions().height}
       alignItems="center"
+      justifyContent={props.centered ? "center" : undefined}
       position="absolute"
       zIndex={3000}
-      paddingTop={dimensions().height / 4}
+      paddingTop={props.centered ? 0 : dimensions().height / 4}
       left={0}
       top={0}
       backgroundColor={RGBA.fromInts(0, 0, 0, 150)}
@@ -73,6 +75,7 @@ function init() {
       onClose?: () => void
     }[],
     size: "medium" as "medium" | "large" | "xlarge",
+    centered: false,
   })
 
   const renderer = useRenderer()
@@ -143,6 +146,7 @@ function init() {
       }
       batch(() => {
         setStore("size", "medium")
+        setStore("centered", false)
         setStore("stack", [])
       })
       refocus()
@@ -156,6 +160,7 @@ function init() {
         if (item.onClose) item.onClose()
       }
       setStore("size", "medium")
+      setStore("centered", false)
       setStore("stack", [
         {
           element: input,
@@ -169,9 +174,15 @@ function init() {
     get size() {
       return store.size
     },
+    get centered() {
+      return store.centered
+    },
     setSize(size: "medium" | "large" | "xlarge") {
       setStore("size", size)
     },
+    setCentered(centered: boolean) {
+      setStore("centered", centered)
+    },
   }
 }
 
@@ -213,7 +224,7 @@ export function DialogProvider(props: ParentProps) {
         onMouseUp={!Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT ? copySelection : undefined}
       >
         <Show when={value.stack.length}>
-          <Dialog onClose={() => value.clear()} size={value.size}>
+          <Dialog onClose={() => value.clear()} size={value.size} centered={value.centered}>
             {value.stack.at(-1)!.element}
           </Dialog>
         </Show>