refactor(client): split package into promise and effect entrypoints

packages/client/src/effect/generated/.httpapi-codegen.json

@@ -0,0 +1,5 @@
+[
+  "client-error.ts",
+  "client.ts",
+  "index.ts"
+]

packages/client/src/effect/generated/client-error.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect"
+
+export class ClientError extends Schema.TaggedErrorClass<ClientError>()("ClientError", {
+  cause: Schema.Defect(),
+}) {}

packages/client/src/effect/generated/client.ts

@@ -0,0 +1,949 @@
+// Generated by @opencode-ai/httpapi-codegen. Do not edit.
+import { Effect, Stream, Schema } from "effect"
+import { Sse } from "effect/unstable/encoding"
+import { HttpClientError } from "effect/unstable/http"
+import { HttpApiClient } from "effect/unstable/httpapi"
+import { ClientApi } from "../../contract"
+import { ClientError } from "./client-error"
+
+type RawClient = HttpApiClient.ForApi<typeof ClientApi>
+
+const mapClientError = <E>(error: E) =>
+  HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error)
+    ? new ClientError({ cause: error })
+    : error
+
+const Endpoint0_0 = (raw: RawClient["server.health"]) => () =>
+  raw["health.get"]({}).pipe(Effect.mapError(mapClientError))
+
+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) =>
+  raw["location.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup1 = (raw: RawClient["server.location"]) => ({ get: Endpoint1_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) =>
+  raw["agent.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup2 = (raw: RawClient["server.agent"]) => ({ list: Endpoint2_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) =>
+  raw["plugin.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup3 = (raw: RawClient["server.plugin"]) => ({ list: Endpoint3_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"]
+}
+const Endpoint4_0 = (raw: RawClient["server.session"]) => (input?: Endpoint4_0Input) =>
+  raw["session.list"]({
+    query: {
+      workspace: input?.["workspace"],
+      limit: input?.["limit"],
+      order: input?.["order"],
+      search: input?.["search"],
+      parentID: input?.["parentID"],
+      directory: input?.["directory"],
+      project: input?.["project"],
+      subpath: input?.["subpath"],
+      cursor: input?.["cursor"],
+    },
+  }).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"]
+}
+const Endpoint4_1 = (raw: RawClient["server.session"]) => (input?: Endpoint4_1Input) =>
+  raw["session.create"]({
+    payload: { id: input?.["id"], agent: input?.["agent"], model: input?.["model"], location: input?.["location"] },
+  }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+const Endpoint4_2 = (raw: RawClient["server.session"]) => () =>
+  raw["session.active"]({}).pipe(Effect.mapError(mapClientError))
+
+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) =>
+  raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint4_4Request = Parameters<RawClient["server.session"]["session.fork"]>[0]
+type Endpoint4_4Input = {
+  readonly sessionID: Endpoint4_4Request["params"]["sessionID"]
+  readonly messageID?: Endpoint4_4Request["payload"]["messageID"]
+}
+const Endpoint4_4 = (raw: RawClient["server.session"]) => (input: Endpoint4_4Input) =>
+  raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { messageID: input["messageID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint4_5Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
+type Endpoint4_5Input = {
+  readonly sessionID: Endpoint4_5Request["params"]["sessionID"]
+  readonly agent: Endpoint4_5Request["payload"]["agent"]
+}
+const Endpoint4_5 = (raw: RawClient["server.session"]) => (input: Endpoint4_5Input) =>
+  raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint4_6Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
+type Endpoint4_6Input = {
+  readonly sessionID: Endpoint4_6Request["params"]["sessionID"]
+  readonly model: Endpoint4_6Request["payload"]["model"]
+}
+const Endpoint4_6 = (raw: RawClient["server.session"]) => (input: Endpoint4_6Input) =>
+  raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint4_7Request = Parameters<RawClient["server.session"]["session.rename"]>[0]
+type Endpoint4_7Input = {
+  readonly sessionID: Endpoint4_7Request["params"]["sessionID"]
+  readonly title: Endpoint4_7Request["payload"]["title"]
+}
+const Endpoint4_7 = (raw: RawClient["server.session"]) => (input: Endpoint4_7Input) =>
+  raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint4_8Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint4_8Input = {
+  readonly sessionID: Endpoint4_8Request["params"]["sessionID"]
+  readonly id?: Endpoint4_8Request["payload"]["id"]
+  readonly prompt: Endpoint4_8Request["payload"]["prompt"]
+  readonly delivery?: Endpoint4_8Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_8Request["payload"]["resume"]
+}
+const Endpoint4_8 = (raw: RawClient["server.session"]) => (input: Endpoint4_8Input) =>
+  raw["session.prompt"]({
+    params: { sessionID: input["sessionID"] },
+    payload: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
+  }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint4_9Input = {
+  readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
+  readonly id?: Endpoint4_9Request["payload"]["id"]
+  readonly command: Endpoint4_9Request["payload"]["command"]
+  readonly arguments?: Endpoint4_9Request["payload"]["arguments"]
+  readonly agent?: Endpoint4_9Request["payload"]["agent"]
+  readonly model?: Endpoint4_9Request["payload"]["model"]
+  readonly files?: Endpoint4_9Request["payload"]["files"]
+  readonly agents?: Endpoint4_9Request["payload"]["agents"]
+  readonly delivery?: Endpoint4_9Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_9Request["payload"]["resume"]
+}
+const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Input) =>
+  raw["session.command"]({
+    params: { sessionID: input["sessionID"] },
+    payload: {
+      id: input["id"],
+      command: input["command"],
+      arguments: input["arguments"],
+      agent: input["agent"],
+      model: input["model"],
+      files: input["files"],
+      agents: input["agents"],
+      delivery: input["delivery"],
+      resume: input["resume"],
+    },
+  }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint4_10Input = {
+  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
+  readonly id?: Endpoint4_10Request["payload"]["id"]
+  readonly skill: Endpoint4_10Request["payload"]["skill"]
+  readonly resume?: Endpoint4_10Request["payload"]["resume"]
+}
+const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
+  raw["session.skill"]({
+    params: { sessionID: input["sessionID"] },
+    payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint4_11Input = {
+  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
+  readonly text: Endpoint4_11Request["payload"]["text"]
+  readonly description?: Endpoint4_11Request["payload"]["description"]
+  readonly metadata?: Endpoint4_11Request["payload"]["metadata"]
+}
+const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
+  raw["session.synthetic"]({
+    params: { sessionID: input["sessionID"] },
+    payload: { text: input["text"], description: input["description"], metadata: input["metadata"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint4_12Input = { readonly sessionID: Endpoint4_12Request["params"]["sessionID"] }
+const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
+  raw["session.compact"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint4_13Input = { readonly sessionID: Endpoint4_13Request["params"]["sessionID"] }
+const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
+  raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint4_14Input = {
+  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_14Request["payload"]["messageID"]
+  readonly files?: Endpoint4_14Request["payload"]["files"]
+}
+const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
+  raw["session.revert.stage"]({
+    params: { sessionID: input["sessionID"] },
+    payload: { messageID: input["messageID"], files: input["files"] },
+  }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint4_15Input = { readonly sessionID: Endpoint4_15Request["params"]["sessionID"] }
+const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
+  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
+const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
+  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
+const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
+  raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.context.entry.list"]>[0]
+type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
+const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
+  raw["session.context.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context.entry.put"]>[0]
+type Endpoint4_19Input = {
+  readonly sessionID: Endpoint4_19Request["params"]["sessionID"]
+  readonly key: Endpoint4_19Request["params"]["key"]
+  readonly value: Endpoint4_19Request["payload"]["value"]
+}
+const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
+  raw["session.context.entry.put"]({
+    params: { sessionID: input["sessionID"], key: input["key"] },
+    payload: { value: input["value"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context.entry.remove"]>[0]
+type Endpoint4_20Input = {
+  readonly sessionID: Endpoint4_20Request["params"]["sessionID"]
+  readonly key: Endpoint4_20Request["params"]["key"]
+}
+const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
+  raw["session.context.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint4_21Input = {
+  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
+  readonly after?: Endpoint4_21Request["query"]["after"]
+  readonly follow?: Endpoint4_21Request["query"]["follow"]
+}
+const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
+  Stream.unwrap(
+    raw["session.log"]({
+      params: { sessionID: input["sessionID"] },
+      query: { after: input["after"], follow: input["follow"] },
+    }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
+    ),
+  )
+
+type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint4_22Input = { readonly sessionID: Endpoint4_22Request["params"]["sessionID"] }
+const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
+  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_23Input = { readonly sessionID: Endpoint4_23Request["params"]["sessionID"] }
+const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
+  raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint4_24Input = {
+  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_24Request["params"]["messageID"]
+}
+const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
+  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),
+  fork: Endpoint4_4(raw),
+  switchAgent: Endpoint4_5(raw),
+  switchModel: Endpoint4_6(raw),
+  rename: Endpoint4_7(raw),
+  prompt: Endpoint4_8(raw),
+  command: Endpoint4_9(raw),
+  skill: Endpoint4_10(raw),
+  synthetic: Endpoint4_11(raw),
+  compact: Endpoint4_12(raw),
+  wait: Endpoint4_13(raw),
+  revertStage: Endpoint4_14(raw),
+  revertClear: Endpoint4_15(raw),
+  revertCommit: Endpoint4_16(raw),
+  context: Endpoint4_17(raw),
+  listContextEntries: Endpoint4_18(raw),
+  putContextEntry: Endpoint4_19(raw),
+  removeContextEntry: Endpoint4_20(raw),
+  log: Endpoint4_21(raw),
+  interrupt: Endpoint4_22(raw),
+  background: Endpoint4_23(raw),
+  message: Endpoint4_24(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"]
+}
+const Endpoint5_0 = (raw: RawClient["server.message"]) => (input: Endpoint5_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) })
+
+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) =>
+  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) =>
+  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) })
+
+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"]
+}
+const Endpoint7_0 = (raw: RawClient["server.generate"]) => (input: Endpoint7_0Input) =>
+  raw["generate.text"]({
+    query: { location: input["location"] },
+    payload: { prompt: input["prompt"], model: input["model"] },
+  }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+const adaptGroup7 = (raw: RawClient["server.generate"]) => ({ text: Endpoint7_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) =>
+  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"]
+}
+const Endpoint8_1 = (raw: RawClient["server.provider"]) => (input: Endpoint8_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) })
+
+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) =>
+  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"]
+}
+const Endpoint9_1 = (raw: RawClient["server.integration"]) => (input: Endpoint9_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"]
+}
+const Endpoint9_2 = (raw: RawClient["server.integration"]) => (input: Endpoint9_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"]
+}
+const Endpoint9_3 = (raw: RawClient["server.integration"]) => (input: Endpoint9_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"]
+}
+const Endpoint9_4 = (raw: RawClient["server.integration"]) => (input: Endpoint9_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"]
+}
+const Endpoint9_5 = (raw: RawClient["server.integration"]) => (input: Endpoint9_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"]
+}
+const Endpoint9_6 = (raw: RawClient["server.integration"]) => (input: Endpoint9_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),
+  connectKey: Endpoint9_2(raw),
+  connectOauth: Endpoint9_3(raw),
+  attemptStatus: Endpoint9_4(raw),
+  attemptComplete: Endpoint9_5(raw),
+  attemptCancel: Endpoint9_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) =>
+  raw["mcp.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({ list: Endpoint10_0(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"]
+}
+const Endpoint11_0 = (raw: RawClient["server.credential"]) => (input: Endpoint11_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"]
+}
+const Endpoint11_1 = (raw: RawClient["server.credential"]) => (input: Endpoint11_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) })
+
+type Endpoint12_0Request = Parameters<RawClient["server.project"]["project.current"]>[0]
+type Endpoint12_0Input = { readonly location?: Endpoint12_0Request["query"]["location"] }
+const Endpoint12_0 = (raw: RawClient["server.project"]) => (input?: Endpoint12_0Input) =>
+  raw["project.current"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint12_1Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
+type Endpoint12_1Input = {
+  readonly projectID: Endpoint12_1Request["params"]["projectID"]
+  readonly location?: Endpoint12_1Request["query"]["location"]
+}
+const Endpoint12_1 = (raw: RawClient["server.project"]) => (input: Endpoint12_1Input) =>
+  raw["project.directories"]({
+    params: { projectID: input["projectID"] },
+    query: { location: input["location"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup12 = (raw: RawClient["server.project"]) => ({
+  current: Endpoint12_0(raw),
+  directories: Endpoint12_1(raw),
+})
+
+type Endpoint13_0Request = Parameters<RawClient["server.permission"]["permission.request.list"]>[0]
+type Endpoint13_0Input = { readonly location?: Endpoint13_0Request["query"]["location"] }
+const Endpoint13_0 = (raw: RawClient["server.permission"]) => (input?: Endpoint13_0Input) =>
+  raw["permission.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint13_1Request = Parameters<RawClient["server.permission"]["permission.saved.list"]>[0]
+type Endpoint13_1Input = { readonly projectID?: Endpoint13_1Request["query"]["projectID"] }
+const Endpoint13_1 = (raw: RawClient["server.permission"]) => (input?: Endpoint13_1Input) =>
+  raw["permission.saved.list"]({ query: { projectID: input?.["projectID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint13_2Request = Parameters<RawClient["server.permission"]["permission.saved.remove"]>[0]
+type Endpoint13_2Input = { readonly id: Endpoint13_2Request["params"]["id"] }
+const Endpoint13_2 = (raw: RawClient["server.permission"]) => (input: Endpoint13_2Input) =>
+  raw["permission.saved.remove"]({ params: { id: input["id"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint13_3Request = Parameters<RawClient["server.permission"]["session.permission.create"]>[0]
+type Endpoint13_3Input = {
+  readonly sessionID: Endpoint13_3Request["params"]["sessionID"]
+  readonly id?: Endpoint13_3Request["payload"]["id"]
+  readonly action: Endpoint13_3Request["payload"]["action"]
+  readonly resources: Endpoint13_3Request["payload"]["resources"]
+  readonly save?: Endpoint13_3Request["payload"]["save"]
+  readonly metadata?: Endpoint13_3Request["payload"]["metadata"]
+  readonly source?: Endpoint13_3Request["payload"]["source"]
+  readonly agent?: Endpoint13_3Request["payload"]["agent"]
+}
+const Endpoint13_3 = (raw: RawClient["server.permission"]) => (input: Endpoint13_3Input) =>
+  raw["session.permission.create"]({
+    params: { sessionID: input["sessionID"] },
+    payload: {
+      id: input["id"],
+      action: input["action"],
+      resources: input["resources"],
+      save: input["save"],
+      metadata: input["metadata"],
+      source: input["source"],
+      agent: input["agent"],
+    },
+  }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint13_4Request = Parameters<RawClient["server.permission"]["session.permission.list"]>[0]
+type Endpoint13_4Input = { readonly sessionID: Endpoint13_4Request["params"]["sessionID"] }
+const Endpoint13_4 = (raw: RawClient["server.permission"]) => (input: Endpoint13_4Input) =>
+  raw["session.permission.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint13_5Request = Parameters<RawClient["server.permission"]["session.permission.get"]>[0]
+type Endpoint13_5Input = {
+  readonly sessionID: Endpoint13_5Request["params"]["sessionID"]
+  readonly requestID: Endpoint13_5Request["params"]["requestID"]
+}
+const Endpoint13_5 = (raw: RawClient["server.permission"]) => (input: Endpoint13_5Input) =>
+  raw["session.permission.get"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint13_6Request = Parameters<RawClient["server.permission"]["session.permission.reply"]>[0]
+type Endpoint13_6Input = {
+  readonly sessionID: Endpoint13_6Request["params"]["sessionID"]
+  readonly requestID: Endpoint13_6Request["params"]["requestID"]
+  readonly reply: Endpoint13_6Request["payload"]["reply"]
+  readonly message?: Endpoint13_6Request["payload"]["message"]
+}
+const Endpoint13_6 = (raw: RawClient["server.permission"]) => (input: Endpoint13_6Input) =>
+  raw["session.permission.reply"]({
+    params: { sessionID: input["sessionID"], requestID: input["requestID"] },
+    payload: { reply: input["reply"], message: input["message"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup13 = (raw: RawClient["server.permission"]) => ({
+  listRequests: Endpoint13_0(raw),
+  listSaved: Endpoint13_1(raw),
+  removeSaved: Endpoint13_2(raw),
+  create: Endpoint13_3(raw),
+  list: Endpoint13_4(raw),
+  get: Endpoint13_5(raw),
+  reply: Endpoint13_6(raw),
+})
+
+type Endpoint14_0Request = Parameters<RawClient["server.fs"]["fs.list"]>[0]
+type Endpoint14_0Input = {
+  readonly location?: Endpoint14_0Request["query"]["location"]
+  readonly path?: Endpoint14_0Request["query"]["path"]
+}
+const Endpoint14_0 = (raw: RawClient["server.fs"]) => (input?: Endpoint14_0Input) =>
+  raw["fs.list"]({ query: { location: input?.["location"], path: input?.["path"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint14_1Request = Parameters<RawClient["server.fs"]["fs.find"]>[0]
+type Endpoint14_1Input = {
+  readonly location?: Endpoint14_1Request["query"]["location"]
+  readonly query: Endpoint14_1Request["query"]["query"]
+  readonly type?: Endpoint14_1Request["query"]["type"]
+  readonly limit?: Endpoint14_1Request["query"]["limit"]
+}
+const Endpoint14_1 = (raw: RawClient["server.fs"]) => (input: Endpoint14_1Input) =>
+  raw["fs.find"]({
+    query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup14 = (raw: RawClient["server.fs"]) => ({ list: Endpoint14_0(raw), find: Endpoint14_1(raw) })
+
+type Endpoint15_0Request = Parameters<RawClient["server.command"]["command.list"]>[0]
+type Endpoint15_0Input = { readonly location?: Endpoint15_0Request["query"]["location"] }
+const Endpoint15_0 = (raw: RawClient["server.command"]) => (input?: Endpoint15_0Input) =>
+  raw["command.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup15 = (raw: RawClient["server.command"]) => ({ list: Endpoint15_0(raw) })
+
+type Endpoint16_0Request = Parameters<RawClient["server.skill"]["skill.list"]>[0]
+type Endpoint16_0Input = { readonly location?: Endpoint16_0Request["query"]["location"] }
+const Endpoint16_0 = (raw: RawClient["server.skill"]) => (input?: Endpoint16_0Input) =>
+  raw["skill.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup16 = (raw: RawClient["server.skill"]) => ({ list: Endpoint16_0(raw) })
+
+const Endpoint17_0 = (raw: RawClient["server.event"]) => () =>
+  Stream.unwrap(
+    raw["event.subscribe"]({}).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
+    ),
+  )
+
+const Endpoint17_1 = (raw: RawClient["server.event"]) => () =>
+  Stream.unwrap(
+    raw["event.changes"]({}).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
+    ),
+  )
+
+const adaptGroup17 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint17_0(raw), changes: Endpoint17_1(raw) })
+
+type Endpoint18_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+type Endpoint18_0Input = { readonly location?: Endpoint18_0Request["query"]["location"] }
+const Endpoint18_0 = (raw: RawClient["server.pty"]) => (input?: Endpoint18_0Input) =>
+  raw["pty.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint18_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
+type Endpoint18_1Input = {
+  readonly location?: Endpoint18_1Request["query"]["location"]
+  readonly command?: Endpoint18_1Request["payload"]["command"]
+  readonly args?: Endpoint18_1Request["payload"]["args"]
+  readonly cwd?: Endpoint18_1Request["payload"]["cwd"]
+  readonly title?: Endpoint18_1Request["payload"]["title"]
+  readonly env?: Endpoint18_1Request["payload"]["env"]
+}
+const Endpoint18_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint18_1Input) =>
+  raw["pty.create"]({
+    query: { location: input?.["location"] },
+    payload: {
+      command: input?.["command"],
+      args: input?.["args"],
+      cwd: input?.["cwd"],
+      title: input?.["title"],
+      env: input?.["env"],
+    },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint18_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
+type Endpoint18_2Input = {
+  readonly ptyID: Endpoint18_2Request["params"]["ptyID"]
+  readonly location?: Endpoint18_2Request["query"]["location"]
+}
+const Endpoint18_2 = (raw: RawClient["server.pty"]) => (input: Endpoint18_2Input) =>
+  raw["pty.get"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint18_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
+type Endpoint18_3Input = {
+  readonly ptyID: Endpoint18_3Request["params"]["ptyID"]
+  readonly location?: Endpoint18_3Request["query"]["location"]
+  readonly title?: Endpoint18_3Request["payload"]["title"]
+  readonly size?: Endpoint18_3Request["payload"]["size"]
+}
+const Endpoint18_3 = (raw: RawClient["server.pty"]) => (input: Endpoint18_3Input) =>
+  raw["pty.update"]({
+    params: { ptyID: input["ptyID"] },
+    query: { location: input["location"] },
+    payload: { title: input["title"], size: input["size"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint18_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
+type Endpoint18_4Input = {
+  readonly ptyID: Endpoint18_4Request["params"]["ptyID"]
+  readonly location?: Endpoint18_4Request["query"]["location"]
+}
+const Endpoint18_4 = (raw: RawClient["server.pty"]) => (input: Endpoint18_4Input) =>
+  raw["pty.remove"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+const adaptGroup18 = (raw: RawClient["server.pty"]) => ({
+  list: Endpoint18_0(raw),
+  create: Endpoint18_1(raw),
+  get: Endpoint18_2(raw),
+  update: Endpoint18_3(raw),
+  remove: Endpoint18_4(raw),
+})
+
+type Endpoint19_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0]
+type Endpoint19_0Input = { readonly location?: Endpoint19_0Request["query"]["location"] }
+const Endpoint19_0 = (raw: RawClient["server.shell"]) => (input?: Endpoint19_0Input) =>
+  raw["shell.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint19_1Request = Parameters<RawClient["server.shell"]["shell.create"]>[0]
+type Endpoint19_1Input = {
+  readonly location?: Endpoint19_1Request["query"]["location"]
+  readonly command: Endpoint19_1Request["payload"]["command"]
+  readonly cwd?: Endpoint19_1Request["payload"]["cwd"]
+  readonly timeout?: Endpoint19_1Request["payload"]["timeout"]
+  readonly metadata?: Endpoint19_1Request["payload"]["metadata"]
+}
+const Endpoint19_1 = (raw: RawClient["server.shell"]) => (input: Endpoint19_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 Endpoint19_2Request = Parameters<RawClient["server.shell"]["shell.get"]>[0]
+type Endpoint19_2Input = {
+  readonly id: Endpoint19_2Request["params"]["id"]
+  readonly location?: Endpoint19_2Request["query"]["location"]
+}
+const Endpoint19_2 = (raw: RawClient["server.shell"]) => (input: Endpoint19_2Input) =>
+  raw["shell.get"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint19_3Request = Parameters<RawClient["server.shell"]["shell.output"]>[0]
+type Endpoint19_3Input = {
+  readonly id: Endpoint19_3Request["params"]["id"]
+  readonly location?: Endpoint19_3Request["query"]["location"]
+  readonly cursor?: Endpoint19_3Request["query"]["cursor"]
+  readonly limit?: Endpoint19_3Request["query"]["limit"]
+}
+const Endpoint19_3 = (raw: RawClient["server.shell"]) => (input: Endpoint19_3Input) =>
+  raw["shell.output"]({
+    params: { id: input["id"] },
+    query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint19_4Request = Parameters<RawClient["server.shell"]["shell.remove"]>[0]
+type Endpoint19_4Input = {
+  readonly id: Endpoint19_4Request["params"]["id"]
+  readonly location?: Endpoint19_4Request["query"]["location"]
+}
+const Endpoint19_4 = (raw: RawClient["server.shell"]) => (input: Endpoint19_4Input) =>
+  raw["shell.remove"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+const adaptGroup19 = (raw: RawClient["server.shell"]) => ({
+  list: Endpoint19_0(raw),
+  create: Endpoint19_1(raw),
+  get: Endpoint19_2(raw),
+  output: Endpoint19_3(raw),
+  remove: Endpoint19_4(raw),
+})
+
+type Endpoint20_0Request = Parameters<RawClient["server.question"]["question.request.list"]>[0]
+type Endpoint20_0Input = { readonly location?: Endpoint20_0Request["query"]["location"] }
+const Endpoint20_0 = (raw: RawClient["server.question"]) => (input?: Endpoint20_0Input) =>
+  raw["question.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint20_1Request = Parameters<RawClient["server.question"]["session.question.list"]>[0]
+type Endpoint20_1Input = { readonly sessionID: Endpoint20_1Request["params"]["sessionID"] }
+const Endpoint20_1 = (raw: RawClient["server.question"]) => (input: Endpoint20_1Input) =>
+  raw["session.question.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint20_2Request = Parameters<RawClient["server.question"]["session.question.reply"]>[0]
+type Endpoint20_2Input = {
+  readonly sessionID: Endpoint20_2Request["params"]["sessionID"]
+  readonly requestID: Endpoint20_2Request["params"]["requestID"]
+  readonly answers: Endpoint20_2Request["payload"]["answers"]
+}
+const Endpoint20_2 = (raw: RawClient["server.question"]) => (input: Endpoint20_2Input) =>
+  raw["session.question.reply"]({
+    params: { sessionID: input["sessionID"], requestID: input["requestID"] },
+    payload: { answers: input["answers"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint20_3Request = Parameters<RawClient["server.question"]["session.question.reject"]>[0]
+type Endpoint20_3Input = {
+  readonly sessionID: Endpoint20_3Request["params"]["sessionID"]
+  readonly requestID: Endpoint20_3Request["params"]["requestID"]
+}
+const Endpoint20_3 = (raw: RawClient["server.question"]) => (input: Endpoint20_3Input) =>
+  raw["session.question.reject"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+const adaptGroup20 = (raw: RawClient["server.question"]) => ({
+  listRequests: Endpoint20_0(raw),
+  list: Endpoint20_1(raw),
+  reply: Endpoint20_2(raw),
+  reject: Endpoint20_3(raw),
+})
+
+type Endpoint21_0Request = Parameters<RawClient["server.reference"]["reference.list"]>[0]
+type Endpoint21_0Input = { readonly location?: Endpoint21_0Request["query"]["location"] }
+const Endpoint21_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint21_0Input) =>
+  raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup21 = (raw: RawClient["server.reference"]) => ({ list: Endpoint21_0(raw) })
+
+type Endpoint22_0Request = Parameters<RawClient["server.projectCopy"]["projectCopy.create"]>[0]
+type Endpoint22_0Input = {
+  readonly projectID: Endpoint22_0Request["params"]["projectID"]
+  readonly location?: Endpoint22_0Request["query"]["location"]
+  readonly strategy: Endpoint22_0Request["payload"]["strategy"]
+  readonly directory: Endpoint22_0Request["payload"]["directory"]
+  readonly name?: Endpoint22_0Request["payload"]["name"]
+}
+const Endpoint22_0 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint22_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 Endpoint22_1Request = Parameters<RawClient["server.projectCopy"]["projectCopy.remove"]>[0]
+type Endpoint22_1Input = {
+  readonly projectID: Endpoint22_1Request["params"]["projectID"]
+  readonly location?: Endpoint22_1Request["query"]["location"]
+  readonly directory: Endpoint22_1Request["payload"]["directory"]
+  readonly force: Endpoint22_1Request["payload"]["force"]
+}
+const Endpoint22_1 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint22_1Input) =>
+  raw["projectCopy.remove"]({
+    params: { projectID: input["projectID"] },
+    query: { location: input["location"] },
+    payload: { directory: input["directory"], force: input["force"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint22_2Request = Parameters<RawClient["server.projectCopy"]["projectCopy.refresh"]>[0]
+type Endpoint22_2Input = {
+  readonly projectID: Endpoint22_2Request["params"]["projectID"]
+  readonly location?: Endpoint22_2Request["query"]["location"]
+}
+const Endpoint22_2 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint22_2Input) =>
+  raw["projectCopy.refresh"]({
+    params: { projectID: input["projectID"] },
+    query: { location: input["location"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup22 = (raw: RawClient["server.projectCopy"]) => ({
+  create: Endpoint22_0(raw),
+  remove: Endpoint22_1(raw),
+  refresh: Endpoint22_2(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"]),
+  permission: adaptGroup13(raw["server.permission"]),
+  file: adaptGroup14(raw["server.fs"]),
+  command: adaptGroup15(raw["server.command"]),
+  skill: adaptGroup16(raw["server.skill"]),
+  event: adaptGroup17(raw["server.event"]),
+  pty: adaptGroup18(raw["server.pty"]),
+  shell: adaptGroup19(raw["server.shell"]),
+  question: adaptGroup20(raw["server.question"]),
+  reference: adaptGroup21(raw["server.reference"]),
+  projectCopy: adaptGroup22(raw["server.projectCopy"]),
+})
+
+export const make = (options?: { readonly baseUrl?: URL | string }) =>
+  HttpApiClient.make(ClientApi, options).pipe(Effect.map(adaptClient))

packages/client/src/effect/generated/index.ts

@@ -0,0 +1,2 @@
+export { ClientError } from "./client-error"
+export * as OpenCode from "./client"

packages/client/src/effect/index.ts

@@ -0,0 +1,29 @@
+// TODO: Keep additional network capabilities inside Schema and Protocol as the client grows; /effect must never import
+// Core or Server. Preserve these datatype exports so internal model reorganizations do not require caller migrations.
+export * from "./generated/index"
+export { Service } from "./service.js"
+export type { Transport, ServiceOptions } from "./service.js"
+export { Agent } from "@opencode-ai/schema/agent"
+export { Command } from "@opencode-ai/schema/command"
+export { Credential } from "@opencode-ai/schema/credential"
+export { Event } from "@opencode-ai/schema/event"
+export { EventLog } from "@opencode-ai/schema/event-log"
+export { FileSystem } from "@opencode-ai/schema/filesystem"
+export { Integration } from "@opencode-ai/schema/integration"
+export { Location } from "@opencode-ai/schema/location"
+export { Model } from "@opencode-ai/schema/model"
+export { Permission } from "@opencode-ai/schema/permission"
+export { PermissionSaved } from "@opencode-ai/schema/permission-saved"
+export { Project } from "@opencode-ai/schema/project"
+export { ProjectCopy } from "@opencode-ai/schema/project-copy"
+export { Provider } from "@opencode-ai/schema/provider"
+export { Pty } from "@opencode-ai/schema/pty"
+export { Question } from "@opencode-ai/schema/question"
+export { Reference } from "@opencode-ai/schema/reference"
+export { AbsolutePath, RelativePath } from "@opencode-ai/schema/schema"
+export { Session } from "@opencode-ai/schema/session"
+export { SessionInput } from "@opencode-ai/schema/session-input"
+export { SessionMessage } from "@opencode-ai/schema/session-message"
+export { Skill } from "@opencode-ai/schema/skill"
+export { Prompt } from "@opencode-ai/schema/prompt"
+export type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"

packages/client/src/effect/service.ts

@@ -0,0 +1,165 @@
+import { Effect, FileSystem, Option, Schedule, Schema } from "effect"
+import { spawn } from "node:child_process"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+// Find, start, and stop the local opencode background service.
+//
+// The service daemon advertises itself through a registration file in the
+// user's state directory: url, pid, version, and the private password, with
+// 0600 permissions. That file is the complete discovery contract — reading it
+// is all a client needs to connect. The daemon's own configuration (port,
+// persisted password) is CLI-owned and never read here.
+
+export type Transport = {
+  readonly url: string
+  readonly headers?: RequestInit["headers"]
+}
+
+export type ServiceOptions = {
+  // Absolute path to the service registration file. Defaults to
+  // opencode/service.json in the XDG state directory.
+  readonly file?: string
+  // When set, discovery only returns a server reporting this exact version,
+  // and start() replaces a healthy server whose version differs.
+  readonly version?: string
+  // Argv used to spawn the service. Defaults to ["opencode", "serve",
+  // "--service"] resolved from PATH.
+  readonly command?: ReadonlyArray<string>
+}
+
+// Read-only lookup: registration file plus health check and version gate.
+// Never spawns; escalation to start() is the caller's policy.
+export const discover = Effect.fn("service.discover")(function* (options: ServiceOptions = {}) {
+  const registration = yield* read(options.file)
+  if (registration === undefined) return undefined
+  if (options.version !== undefined && registration.version !== options.version) return undefined
+  const found = yield* probe(registration)
+  return found?.transport
+})
+
+// Idempotent ensure-running: reuses a healthy compatible server, replaces a
+// version-mismatched one, and otherwise spawns the service command detached.
+export const start = Effect.fn("service.start")(function* (options: ServiceOptions = {}) {
+  const compatible = yield* discover(options)
+  if (compatible !== undefined) return compatible
+  const mismatched = yield* find(options)
+  if (mismatched !== undefined) yield* kill(mismatched.registration, options).pipe(Effect.ignore)
+
+  const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
+  if (command === undefined) return yield* Effect.fail(new Error("Missing service command"))
+  yield* Effect.try({
+    try: () => {
+      spawn(command, args, { detached: true, stdio: "ignore" }).unref()
+    },
+    catch: (cause) => new Error("Failed to start server", { cause }),
+  })
+
+  return yield* discover(options).pipe(
+    Effect.flatMap((found) =>
+      found === undefined ? Effect.fail(new Error("Server is not ready")) : Effect.succeed(found),
+    ),
+    Effect.retry(poll),
+    Effect.mapError(() => new Error("Failed to start server")),
+  )
+})
+
+export const stop = Effect.fn("service.stop")(function* (options: ServiceOptions = {}) {
+  const fs = yield* FileSystem.FileSystem
+  const existing = yield* find(options)
+  if (existing !== undefined) yield* kill(existing.registration, options)
+  yield* fs.remove(options.file ?? fallback()).pipe(Effect.ignore)
+})
+
+function fallback() {
+  const state = process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state")
+  return join(state, "opencode", "service.json")
+}
+
+function auth(password: string): RequestInit["headers"] {
+  return { authorization: "Basic " + btoa("opencode:" + password) }
+}
+
+const Registration = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  version: Schema.optional(Schema.String),
+  url: Schema.String,
+  pid: Schema.Int.check(Schema.isGreaterThan(0)),
+  password: Schema.optional(Schema.String),
+})
+type Registration = typeof Registration.Type
+
+const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))
+
+// A missing or corrupt file means no valid registration; callers treat both
+// the same (the registering server self-evicts, clients rediscover).
+const read = Effect.fnUntraced(function* (file?: string) {
+  const fs = yield* FileSystem.FileSystem
+  const text = yield* fs.readFileString(file ?? fallback()).pipe(Effect.option)
+  if (Option.isNone(text)) return undefined
+  return yield* decode(text.value).pipe(Effect.option, Effect.map(Option.getOrUndefined))
+})
+
+type LocalService = {
+  readonly registration: Registration
+  readonly transport: Transport
+}
+
+const probe = Effect.fnUntraced(function* (registration: Registration) {
+  const headers = registration.password === undefined ? undefined : auth(registration.password)
+  const healthy = yield* Effect.tryPromise(() =>
+    fetch(new URL("/api/health", registration.url), {
+      headers,
+      signal: AbortSignal.timeout(2_000),
+    }),
+  ).pipe(
+    Effect.map((response) => response.ok),
+    Effect.orElseSucceed(() => false),
+  )
+  if (!healthy) return undefined
+  return { registration, transport: { url: registration.url, headers } } satisfies LocalService
+})
+
+// Health-checked lookup without the version gate: lifecycle operations must be
+// able to see (and replace or stop) a server from a different version.
+const find = Effect.fnUntraced(function* (options: ServiceOptions) {
+  const registration = yield* read(options.file)
+  if (registration === undefined) return undefined
+  return yield* probe(registration)
+})
+
+// 50ms cadence bounded at ~5s, shared by stop escalation and start readiness.
+const poll = Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))
+
+const signal = (pid: number, name: NodeJS.Signals) =>
+  Effect.try({ try: () => process.kill(pid, name), catch: (cause) => cause }).pipe(Effect.ignore)
+
+const stopped = Effect.fnUntraced(function* (pid: number) {
+  const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(
+    Effect.orElseSucceed(() => false),
+  )
+  if (!running) return true
+  return yield* Effect.fail(new Error(`Server process ${pid} is still running`))
+})
+
+function same(left: Registration, right: Registration) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
+}
+
+const kill = Effect.fnUntraced(function* (info: Registration, options: ServiceOptions) {
+  // A stale registration may point at a PID that has since been reused by
+  // another process. Only signal the PID after authenticating the server.
+  const current = yield* find(options)
+  if (current === undefined || !same(current.registration, info)) return
+
+  yield* signal(info.pid, "SIGTERM")
+  const done = yield* stopped(info.pid).pipe(Effect.retry(poll), Effect.option)
+  if (Option.isSome(done)) return
+
+  const latest = yield* find(options)
+  if (latest === undefined || !same(latest.registration, info)) return
+  yield* signal(info.pid, "SIGKILL")
+  yield* stopped(info.pid).pipe(Effect.retry(poll))
+})
+
+export * as Service from "./service.js"