Add files using upload-large-folder tool

packages/cli/bin/lildax.cjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+const childProcess = require("child_process")
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+const forwardedSignals = ["SIGINT", "SIGTERM", "SIGHUP"]
+
+function run(target) {
+  const child = childProcess.spawn(target, process.argv.slice(2), { stdio: "inherit" })
+  child.on("error", (error) => {
+    console.error(error.message)
+    process.exit(1)
+  })
+  const forwarders = {}
+  for (const signal of forwardedSignals) {
+    forwarders[signal] = () => {
+      try {
+        child.kill(signal)
+      } catch {}
+    }
+    process.on(signal, forwarders[signal])
+  }
+  child.on("exit", (code, signal) => {
+    for (const forwardedSignal of forwardedSignals) process.removeListener(forwardedSignal, forwarders[forwardedSignal])
+    if (signal) return process.kill(process.pid, signal)
+    process.exit(typeof code === "number" ? code : 0)
+  })
+}
+
+const envPath = process.env.OPENCODE_BIN_PATH
+const scriptDir = path.dirname(fs.realpathSync(__filename))
+const cached = path.join(scriptDir, ".lildax")
+const platform = { darwin: "darwin", linux: "linux", win32: "windows" }[os.platform()] || os.platform()
+const arch = { x64: "x64", arm64: "arm64", arm: "arm" }[os.arch()] || os.arch()
+const base = "@opencode-ai/cli-" + platform + "-" + arch
+const binary = platform === "windows" ? "lildax.exe" : "lildax"
+
+function supportsAvx2() {
+  if (arch !== "x64") return false
+  if (platform === "linux") {
+    try {
+      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
+    } catch {
+      return false
+    }
+  }
+  if (platform === "darwin") {
+    try {
+      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], { encoding: "utf8", timeout: 1500 })
+      return result.status === 0 && (result.stdout || "").trim() === "1"
+    } catch {
+      return false
+    }
+  }
+  if (platform === "windows") {
+    const command =
+      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
+    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
+      try {
+        const result = childProcess.spawnSync(executable, ["-NoProfile", "-NonInteractive", "-Command", command], {
+          encoding: "utf8",
+          timeout: 3000,
+          windowsHide: true,
+        })
+        if (result.status !== 0) continue
+        const output = (result.stdout || "").trim().toLowerCase()
+        if (output === "true" || output === "1") return true
+        if (output === "false" || output === "0") return false
+      } catch {
+        continue
+      }
+    }
+  }
+  return false
+}
+
+const names = (() => {
+  const baseline = arch === "x64" && !supportsAvx2()
+  if (platform === "linux") {
+    const musl = (() => {
+      try {
+        if (fs.existsSync("/etc/alpine-release")) return true
+        const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
+        return ((result.stdout || "") + (result.stderr || "")).toLowerCase().includes("musl")
+      } catch {
+        return false
+      }
+    })()
+    if (musl)
+      return arch === "x64"
+        ? baseline
+          ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
+          : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
+        : [`${base}-musl`, base]
+    return arch === "x64"
+      ? baseline
+        ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+        : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
+      : [base, `${base}-musl`]
+  }
+  return arch === "x64" ? (baseline ? [`${base}-baseline`, base] : [base, `${base}-baseline`]) : [base]
+})()
+
+function findBinary(startDir) {
+  let current = startDir
+  for (;;) {
+    const modules = path.join(current, "node_modules")
+    if (fs.existsSync(modules))
+      for (const name of names) {
+        const candidate = path.join(modules, name, "bin", binary)
+        if (fs.existsSync(candidate)) return candidate
+      }
+    const parent = path.dirname(current)
+    if (parent === current) return
+    current = parent
+  }
+}
+
+const resolved = envPath || (fs.existsSync(cached) ? cached : findBinary(scriptDir))
+if (!resolved) {
+  console.error(
+    "It seems that your package manager failed to install the right lildax CLI package. Try manually installing " +
+      names.map((name) => `"${name}"`).join(" or ") +
+      " package",
+  )
+  process.exit(1)
+}
+run(resolved)

packages/cli/script/build.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+import { rm } from "fs/promises"
+import path from "path"
+import { Script } from "@opencode-ai/script"
+import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
+import pkg from "../package.json"
+import { modelsData } from "./generate"
+
+const dir = path.resolve(import.meta.dirname, "..")
+const binary = "lildax"
+process.chdir(dir)
+
+await rm("dist", { recursive: true, force: true })
+
+const singleFlag = process.argv.includes("--single")
+const baselineFlag = process.argv.includes("--baseline")
+const skipInstall = process.argv.includes("--skip-install")
+const sourcemapsFlag = process.argv.includes("--sourcemaps")
+const plugin = createSolidTransformPlugin()
+
+const allTargets: {
+  os: string
+  arch: "arm64" | "x64"
+  abi?: "musl"
+  avx2?: false
+}[] = [
+  { os: "linux", arch: "arm64" },
+  { os: "linux", arch: "x64" },
+  { os: "linux", arch: "x64", avx2: false },
+  { os: "linux", arch: "arm64", abi: "musl" },
+  { os: "linux", arch: "x64", abi: "musl" },
+  { os: "linux", arch: "x64", abi: "musl", avx2: false },
+  { os: "darwin", arch: "arm64" },
+  { os: "darwin", arch: "x64" },
+  { os: "darwin", arch: "x64", avx2: false },
+  { os: "win32", arch: "arm64" },
+  { os: "win32", arch: "x64" },
+  { os: "win32", arch: "x64", avx2: false },
+]
+
+const targets = singleFlag
+  ? allTargets.filter((item) => {
+      if (item.os !== process.platform || item.arch !== process.arch) return false
+      if (item.avx2 === false) return baselineFlag
+      return item.abi === undefined
+    })
+  : allTargets
+
+if (!skipInstall) await $`bun install --os="*" --cpu="*" @opentui/core@${pkg.dependencies["@opentui/core"]}`
+
+for (const item of targets) {
+  const target = [
+    binary,
+    item.os === "win32" ? "windows" : item.os,
+    item.arch,
+    item.avx2 === false ? "baseline" : undefined,
+    item.abi,
+  ]
+    .filter(Boolean)
+    .join("-")
+  const name = target.replace(binary, "cli")
+  console.log(`building ${name}`)
+  const result = await Bun.build({
+    entrypoints: ["./src/index.ts"],
+    tsconfig: "./tsconfig.json",
+    plugins: [plugin],
+    external: ["node-gyp"],
+    format: "esm",
+    minify: true,
+    sourcemap: sourcemapsFlag ? "linked" : "none",
+    splitting: true,
+    compile: {
+      autoloadBunfig: false,
+      autoloadDotenv: false,
+      autoloadTsconfig: true,
+      autoloadPackageJson: true,
+      target: target.replace(binary, "bun") as Bun.Build.CompileTarget,
+      outfile: `./dist/${name}/bin/${binary}`,
+      execArgv: [`--user-agent=${binary}/${Script.version}`, "--use-system-ca", "--"],
+      windows: {},
+    },
+    define: {
+      OPENCODE_VERSION: `'${Script.version}'`,
+      OPENCODE_CLI_NAME: `'${binary}'`,
+      OPENCODE_MODELS_DEV: modelsData,
+      OPENCODE_CHANNEL: `'${Script.channel}'`,
+      OPENCODE_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "undefined",
+      // FFF_LIBC selects the fff native lib variant: "musl" or "gnu".
+      FFF_LIBC: item.os === "linux" ? `'${item.abi ?? "gnu"}'` : "undefined",
+      ...(item.os === "linux" ? { "process.env.OPENTUI_LIBC": JSON.stringify(item.abi ?? "glibc") } : {}),
+    },
+  })
+
+  if (!result.success) {
+    for (const log of result.logs) console.error(log)
+    process.exit(1)
+  }
+
+  await Bun.write(
+    `./dist/${name}/package.json`,
+    JSON.stringify(
+      {
+        name: `@opencode-ai/${name}`,
+        version: Script.version,
+        license: "MIT",
+        repository: { type: "git", url: "git+https://github.com/anomalyco/opencode.git" },
+        os: [item.os],
+        cpu: [item.arch],
+      },
+      null,
+      2,
+    ),
+  )
+}

packages/cli/script/generate.ts

@@ -0,0 +1,7 @@
+const modelsUrl = process.env.OPENCODE_MODELS_URL || "https://models.opencode.ai"
+
+export const modelsData = process.env.MODELS_DEV_API_JSON
+  ? await Bun.file(process.env.MODELS_DEV_API_JSON).text()
+  : await fetch(`${modelsUrl}/api.json`).then((response) => response.text())
+
+console.log("Loaded models.dev snapshot")

packages/cli/script/publish.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env bun
+import { $ } from "bun"
+import pkg from "../package.json"
+import { Script } from "@opencode-ai/script"
+import { fileURLToPath } from "url"
+
+const dir = fileURLToPath(new URL("..", import.meta.url))
+process.chdir(dir)
+
+async function published(name: string, version: string) {
+  return (await $`npm view ${name}@${version} version`.nothrow()).exitCode === 0
+}
+
+async function publish(dir: string, name: string, version: string) {
+  if (process.platform !== "win32") await $`chmod -R 755 .`.cwd(dir)
+  if (await published(name, version)) return console.log(`already published ${name}@${version}`)
+  await $`bun pm pack`.cwd(dir)
+  await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(dir)
+}
+
+const binaries: Record<string, string> = {}
+for (const filepath of new Bun.Glob("*/package.json").scanSync({ cwd: "./dist" })) {
+  const item = await Bun.file(`./dist/${filepath}`).json()
+  binaries[item.name] = item.version
+}
+console.log("binaries", binaries)
+const version = Object.values(binaries)[0]
+
+await $`mkdir -p ./dist/${pkg.name}/bin`
+await $`cp ./bin/lildax.cjs ./dist/${pkg.name}/bin/lildax`
+await Bun.file(`./dist/${pkg.name}/package.json`).write(
+  JSON.stringify(
+    {
+      name: pkg.name,
+      bin: { lildax: "./bin/lildax" },
+      version,
+      license: pkg.license,
+      repository: { type: "git", url: "git+https://github.com/anomalyco/opencode.git" },
+      os: ["darwin", "linux", "win32"],
+      cpu: ["arm64", "x64"],
+      optionalDependencies: binaries,
+    },
+    null,
+    2,
+  ),
+)
+
+await Promise.all(
+  Object.entries(binaries).map(([name, version]) =>
+    publish(`./dist/${name.replace("@opencode-ai/", "")}`, name, version),
+  ),
+)
+await publish(`./dist/${pkg.name}`, pkg.name, version)

packages/cli/src/commands/commands.ts

@@ -0,0 +1,52 @@
+import { Argument, Flag } from "effect/unstable/cli"
+import { Spec } from "../framework/spec"
+
+declare const OPENCODE_CLI_NAME: string | undefined
+
+export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
+  description: "OpenCode 2.0 preview command line interface",
+  commands: [
+    Spec.make("api", {
+      description: "Make a request to the running server",
+      params: {
+        request: Argument.string("operation | method path").pipe(
+          Argument.withDescription("OpenAPI operation ID, or an HTTP method followed by a path"),
+          Argument.variadic({ min: 1, max: 2 }),
+        ),
+        data: Flag.string("data").pipe(Flag.withAlias("d"), Flag.withDescription("Request body"), Flag.optional),
+        header: Flag.string("header").pipe(
+          Flag.withAlias("H"),
+          Flag.withDescription("Request header in name:value form"),
+          Flag.atMost(100),
+        ),
+        param: Flag.keyValuePair("param").pipe(Flag.withDescription("OpenAPI path or query parameter"), Flag.optional),
+      },
+    }),
+    Spec.make("debug", {
+      description: "Debugging and troubleshooting tools",
+      commands: [Spec.make("agents", { description: "List all agents" })],
+    }),
+    Spec.make("migrate", { description: "Migrate v1 data to v2" }),
+    Spec.make("service", {
+      description: "Manage the background server",
+      commands: [
+        Spec.make("start", { description: "Start the background server" }),
+        Spec.make("restart", { description: "Restart the background server" }),
+        Spec.make("status", { description: "Show background server status" }),
+        Spec.make("stop", { description: "Stop the background server" }),
+        Spec.make("password", {
+          description: "Get or set the server password",
+          params: { value: Argument.string("value").pipe(Argument.optional) },
+        }),
+      ],
+    }),
+    Spec.make("serve", {
+      description: "Start the v2 API server",
+      params: {
+        hostname: Flag.string("hostname").pipe(Flag.withDefault("127.0.0.1")),
+        port: Flag.integer("port").pipe(Flag.optional),
+        register: Flag.boolean("register").pipe(Flag.withDefault(false)),
+      },
+    }),
+  ],
+})

packages/cli/src/commands/handlers/api.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test"
+import { rawRequest, resolveOperation } from "./api"
+
+describe("api request resolution", () => {
+  test("resolves an operation ID with path and query parameters", () => {
+    expect(
+      resolveOperation(
+        {
+          paths: {
+            "/api/session/{sessionID}": {
+              get: { operationId: "v2.session.get" },
+            },
+          },
+        },
+        "v2.session.get",
+        { sessionID: "ses/a", workspace: "work" },
+      ),
+    ).toEqual({ method: "GET", path: "/api/session/ses%2Fa?workspace=work" })
+  })
+
+  test("rejects a missing path parameter", () => {
+    expect(() =>
+      resolveOperation(
+        { paths: { "/api/session/{sessionID}": { get: { operationId: "v2.session.get" } } } },
+        "v2.session.get",
+        {},
+      ),
+    ).toThrow("Missing path parameter: sessionID")
+  })
+
+  test("resolves curl-like method and path input", () => {
+    expect(rawRequest(["post", "/api/foo"])).toEqual({ method: "POST", path: "/api/foo" })
+    expect(rawRequest(["v2.session.list"])).toBeUndefined()
+  })
+})

packages/cli/src/commands/handlers/api.ts

@@ -0,0 +1,85 @@
+import { EOL } from "node:os"
+import { Effect, Option } from "effect"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { Daemon } from "../../services/daemon"
+
+const methods = new Set(["delete", "get", "head", "options", "patch", "post", "put"])
+
+type Operation = {
+  operationId?: string
+}
+
+type OpenApi = {
+  paths?: Record<string, Record<string, Operation>>
+}
+
+export default Runtime.handler(
+  Commands.commands.api,
+  Effect.fn("cli.api")(function* (input) {
+    const daemon = yield* Daemon.Service
+    const transport = yield* daemon.transport()
+    const params = Option.getOrElse(input.param, () => ({}))
+    const request = yield* resolveRequest(transport, input.request, params)
+    const headers = new Headers(transport.headers)
+    for (const header of input.header) {
+      const index = header.indexOf(":")
+      if (index < 1) return yield* Effect.fail(new Error(`Invalid header, expected name:value: ${header}`))
+      headers.set(header.slice(0, index).trim(), header.slice(index + 1).trim())
+    }
+    const body = Option.getOrUndefined(input.data)
+    if (body !== undefined && !headers.has("content-type")) headers.set("content-type", "application/json")
+
+    const response = yield* Effect.tryPromise(() =>
+      fetch(new URL(request.path, transport.url), {
+        method: request.method,
+        headers,
+        body,
+      }),
+    )
+    const output = yield* Effect.promise(() => response.text())
+    if (output) process.stdout.write(output + (output.endsWith(EOL) ? "" : EOL))
+  }),
+)
+
+export function resolveOperation(spec: OpenApi, operationID: string, params: Record<string, string>) {
+  for (const [path, operations] of Object.entries(spec.paths ?? {})) {
+    for (const [method, operation] of Object.entries(operations)) {
+      if (!methods.has(method) || operation.operationId !== operationID) continue
+      return { method: method.toUpperCase(), path: interpolate(path, params) }
+    }
+  }
+  throw new Error(`Operation not found: ${operationID}`)
+}
+
+export function rawRequest(input: readonly string[]) {
+  if (input.length !== 2 || !methods.has(input[0].toLowerCase()) || !input[1].startsWith("/")) return
+  return { method: input[0].toUpperCase(), path: input[1] }
+}
+
+function resolveRequest(
+  transport: { url: string; headers: RequestInit["headers"] },
+  input: readonly string[],
+  params: Record<string, string>,
+) {
+  const raw = rawRequest(input)
+  if (raw) return Effect.succeed(raw)
+  if (input.length !== 1) return Effect.fail(new Error("Expected an operation name or an HTTP method and path"))
+  return Effect.tryPromise(async () => {
+    const response = await fetch(new URL("/openapi.json", transport.url), { headers: transport.headers })
+    if (!response.ok) throw new Error(`Failed to load OpenAPI document: HTTP ${response.status}`)
+    return resolveOperation((await response.json()) as OpenApi, input[0], params)
+  })
+}
+
+function interpolate(path: string, params: Record<string, string>) {
+  const used = new Set<string>()
+  const pathname = path.replaceAll(/\{([^}]+)\}/g, (_, name: string) => {
+    const value = params[name]
+    if (value === undefined) throw new Error(`Missing path parameter: ${name}`)
+    used.add(name)
+    return encodeURIComponent(value)
+  })
+  const query = new URLSearchParams(Object.entries(params).filter(([name]) => !used.has(name))).toString()
+  return query ? `${pathname}?${query}` : pathname
+}

packages/cli/src/commands/handlers/debug/agents.ts

@@ -0,0 +1,21 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.debug.commands.agents,
+  Effect.fn("cli.debug.agents")(function* () {
+    const daemon = yield* Daemon.Service
+    const client = yield* daemon.client()
+    const response = yield* Effect.promise(() => client.v2.agent.list({ location: { directory: process.cwd() } }))
+    process.stdout.write(
+      JSON.stringify(
+        response.data?.data.toSorted((a, b) => a.id.localeCompare(b.id)),
+        null,
+        2,
+      ) + EOL,
+    )
+  }),
+)

packages/cli/src/commands/handlers/default.ts

@@ -0,0 +1,13 @@
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { Effect } from "effect"
+import { Daemon } from "../../services/daemon"
+
+export default Runtime.handler(Commands, () =>
+  Effect.gen(function* () {
+    const daemon = yield* Daemon.Service
+    const transport = yield* daemon.transport()
+    const { runTui } = yield* Effect.promise(() => import("../../tui"))
+    yield* runTui(transport)
+  }),
+)

packages/cli/src/commands/handlers/migrate.ts

@@ -0,0 +1,5 @@
+import * as Effect from "effect/Effect"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+
+export default Runtime.handler(Commands.commands.migrate, (_input) => Effect.log("No migrations to run."))

packages/cli/src/commands/handlers/serve.ts

@@ -0,0 +1,46 @@
+import { NodeHttpServer } from "@effect/platform-node"
+import { Credential } from "@opencode-ai/core/credential"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { PermissionSaved } from "@opencode-ai/core/permission/saved"
+import { Context, Layer, Option } from "effect"
+import * as Effect from "effect/Effect"
+import { HttpRouter, HttpServer } from "effect/unstable/http"
+import { createServer } from "node:http"
+import { createRoutes } from "@opencode-ai/server/routes"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { Daemon } from "../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.serve,
+  Effect.fn("cli.serve")(function* (input) {
+    return yield* Effect.scoped(
+      Effect.gen(function* () {
+        const daemon = yield* Daemon.Service
+        const address = yield* listen(input.hostname, input.port, yield* daemon.password())
+        if (input.register) yield* daemon.register(address)
+        console.log(`server listening on ${HttpServer.formatAddress(address)}`)
+        return yield* Effect.never
+      }),
+    )
+  }),
+)
+
+function listen(hostname: string, port: Option.Option<number>, password: string) {
+  if (Option.isSome(port)) return bind(hostname, port.value, password)
+  const next = (port: number): ReturnType<typeof bind> =>
+    bind(hostname, port, password).pipe(
+      Effect.catch((error) => (port === 65_535 ? Effect.fail(error) : next(port + 1))),
+    )
+  return next(4096)
+}
+
+function bind(hostname: string, port: number, password: string) {
+  return Layer.build(
+    HttpRouter.serve(createRoutes(password), { disableListenLog: true, disableLogger: true }).pipe(
+      Layer.provideMerge(NodeHttpServer.layer(() => createServer(), { port, host: hostname })),
+      Layer.provide(AppNodeBuilder.build(LayerNode.group([Credential.node, PermissionSaved.node]))),
+    ),
+  ).pipe(Effect.map((context) => Context.get(context, HttpServer.HttpServer).address))
+}

packages/cli/src/commands/handlers/service/password.ts

@@ -0,0 +1,16 @@
+import { EOL } from "os"
+import { Option } from "effect"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.password,
+  Effect.fn("cli.service.password")(function* (input) {
+    const daemon = yield* Daemon.Service
+    const value = Option.getOrUndefined(input.value)
+    if (value !== undefined) yield* daemon.stop()
+    process.stdout.write((yield* daemon.password(value)) + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/restart.ts

@@ -0,0 +1,14 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.restart,
+  Effect.fn("cli.service.restart")(function* () {
+    const daemon = yield* Daemon.Service
+    yield* daemon.stop()
+    process.stdout.write((yield* daemon.start()) + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/start.ts

@@ -0,0 +1,12 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.start,
+  Effect.fn("cli.service.start")(function* () {
+    process.stdout.write((yield* (yield* Daemon.Service).start()) + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/status.ts

@@ -0,0 +1,13 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.status,
+  Effect.fn("cli.service.status")(function* () {
+    const url = yield* (yield* Daemon.Service).status()
+    process.stdout.write((url ? `running ${url}` : "stopped") + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/stop.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.stop,
+  Effect.fn("cli.service.stop")(function* () {
+    yield* (yield* Daemon.Service).stop()
+  }),
+)

packages/cli/src/framework/runtime.ts

@@ -0,0 +1,79 @@
+import * as Effect from "effect/Effect"
+import * as Command from "effect/unstable/cli/Command"
+import { Spec } from "./spec"
+import { Daemon } from "../services/daemon"
+
+export type Input<Value> =
+  Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
+    ? Input<Command>
+    : Value extends Command.Command<infer _Name, infer Input, infer _Context, infer _Error, infer _Requirements>
+      ? Input
+      : never
+
+type RuntimeHandler = (input: unknown) => Effect.Effect<void, unknown, Daemon.Service>
+type Loader<Node extends Spec.Any> = () => Promise<{
+  default: (input: Input<Node>) => Effect.Effect<void, any, Daemon.Service>
+}>
+type ProvidedCommand = Command.Command<string, unknown, unknown, unknown, Daemon.Service>
+
+export type Handlers<Node extends Spec.Any> = keyof Node["commands"] extends never
+  ? Loader<Node>
+  : { readonly $?: Loader<Node> } & { readonly [Key in keyof Node["commands"]]: Handlers<Node["commands"][Key]> }
+
+interface LazyHandler {
+  readonly spec: Command.Command.Any
+  readonly load: () => Promise<{ default: RuntimeHandler }>
+}
+
+type RuntimeHandlers =
+  | (() => Promise<{ default: RuntimeHandler }>)
+  | {
+      readonly $?: () => Promise<{ default: RuntimeHandler }>
+      readonly [key: string]: RuntimeHandlers | (() => Promise<{ default: RuntimeHandler }>) | undefined
+    }
+
+export function handler<const Node extends Spec.Any, Error, Requirements>(
+  _node: Node,
+  run: (input: Input<Node>) => Effect.Effect<void, Error, Requirements>,
+) {
+  return run
+}
+
+export function handlers<const Root extends Spec.Any>(root: Root, handlers: Handlers<Root>) {
+  const result: LazyHandler[] = []
+
+  function add(node: Spec.Any, value: RuntimeHandlers) {
+    if (typeof value === "function") {
+      result.push({ spec: node.spec, load: value as () => Promise<{ default: RuntimeHandler }> })
+      return
+    }
+    if (value.$) result.push({ spec: node.spec, load: value.$ as () => Promise<{ default: RuntimeHandler }> })
+    for (const [name, child] of Object.entries(node.commands)) add(child, value[name] as RuntimeHandlers)
+  }
+
+  add(root, handlers as RuntimeHandlers)
+  return result
+}
+
+export function run(commands: Spec.Any, handlers: ReadonlyArray<LazyHandler>, options: { readonly version: string }) {
+  return Command.run(provide(commands, handlers), options) as Effect.Effect<void, unknown, Command.Environment>
+}
+
+function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): ProvidedCommand {
+  const handler = handlers.find((handler) => handler.spec === node.spec)
+  const spec = handler
+    ? node.spec.pipe(
+        Command.withHandler((input) =>
+          Effect.gen(function* () {
+            yield* Effect.flatMap(Effect.promise(handler.load), (module) => module.default(input))
+          }),
+        ),
+      )
+    : node.spec
+  if (!Object.keys(node.commands).length) return spec as ProvidedCommand
+  return spec.pipe(
+    Command.withSubcommands(Object.values(node.commands).map((child) => provide(child, handlers))),
+  ) as ProvidedCommand
+}
+
+export * as Runtime from "./runtime"

packages/cli/src/framework/spec.ts

@@ -0,0 +1,42 @@
+import * as Command from "effect/unstable/cli/Command"
+
+type Options<Config extends Command.Command.Config, Commands extends ReadonlyArray<Any>> = {
+  readonly description?: string
+  readonly params?: Config
+  readonly commands?: Commands
+}
+
+export interface Node<
+  Name extends string,
+  Spec extends Command.Command<Name, any, any, any, any>,
+  Commands extends Children,
+> {
+  readonly name: Name
+  readonly spec: Spec
+  readonly commands: Commands
+}
+
+export type Any = Node<string, Command.Command<any, any, any, any, any>, Children>
+export type Children = Readonly<Record<string, Any>>
+
+export function make<
+  const Name extends string,
+  const Config extends Command.Command.Config = {},
+  const Commands extends ReadonlyArray<Any> = [],
+>(name: Name, options: Options<Config, Commands> = {}) {
+  const command = Command.make(name, options.params ?? ({} as Config))
+  const spec = options.description ? command.pipe(Command.withDescription(options.description)) : command
+  return {
+    name,
+    spec,
+    commands: Object.fromEntries(
+      (options.commands ?? []).map((command) => [command.name, command]),
+    ) as ChildrenOf<Commands>,
+  }
+}
+
+type ChildrenOf<Commands extends ReadonlyArray<Any>> = {
+  readonly [Node in Commands[number] as Node["name"]]: Node
+}
+
+export * as Spec from "./spec"

packages/cli/src/index.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env bun
+
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as Effect from "effect/Effect"
+import { Commands } from "./commands/commands"
+import { Runtime } from "./framework/runtime"
+import { Daemon } from "./services/daemon"
+
+const Handlers = Runtime.handlers(Commands, {
+  $: () => import("./commands/handlers/default"),
+  api: () => import("./commands/handlers/api"),
+  debug: {
+    agents: () => import("./commands/handlers/debug/agents"),
+  },
+  migrate: () => import("./commands/handlers/migrate"),
+  service: {
+    start: () => import("./commands/handlers/service/start"),
+    restart: () => import("./commands/handlers/service/restart"),
+    status: () => import("./commands/handlers/service/status"),
+    stop: () => import("./commands/handlers/service/stop"),
+    password: () => import("./commands/handlers/service/password"),
+  },
+  serve: () => import("./commands/handlers/serve"),
+})
+
+Runtime.run(Commands, Handlers, { version: "local" }).pipe(
+  Effect.provide(Daemon.layer),
+  Effect.provide(NodeServices.layer),
+  Effect.scoped,
+  NodeRuntime.runMain,
+)

packages/cli/src/services/daemon.ts

@@ -0,0 +1,192 @@
+import { Global } from "@opencode-ai/core/global"
+import { InstallationVersion } from "@opencode-ai/core/installation/version"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
+import { ServerAuth } from "@opencode-ai/server/auth"
+import { Context, Effect, FileSystem, Layer, Option, Schedule, Schema, Scope } from "effect"
+import { HttpServer } from "effect/unstable/http"
+import { randomBytes, randomUUID } from "crypto"
+import { spawn } from "node:child_process"
+import path from "path"
+
+export interface Interface {
+  readonly client: () => Effect.Effect<ReturnType<typeof createOpencodeClient>, unknown>
+  readonly transport: () => Effect.Effect<{ url: string; headers: RequestInit["headers"] }, unknown>
+  readonly start: () => Effect.Effect<string, Error>
+  readonly status: () => Effect.Effect<string | undefined>
+  readonly stop: () => Effect.Effect<void, unknown>
+  readonly password: (value?: string) => Effect.Effect<string, unknown>
+  readonly register: (address: HttpServer.Address) => Effect.Effect<void, unknown, Scope.Scope>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Daemon") {}
+
+const Registration = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  version: Schema.optional(Schema.String),
+  url: Schema.String,
+  pid: Schema.Int.check(Schema.isGreaterThan(0)),
+})
+type Registration = typeof Registration.Type
+
+function sameRegistration(left: Registration, right: Registration) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
+}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const directory = Global.Path.state
+    const file = path.join(directory, "server.json")
+    const passwordFile = path.join(directory, "password")
+    const decodeRegistration = Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))
+
+    const password = Effect.fn("cli.daemon.password")(function* (value?: string) {
+      const existing = yield* fs.readFileString(passwordFile).pipe(Effect.catch(() => Effect.succeed(undefined)))
+      if (value === undefined && existing) return existing
+
+      // Keep one private credential across server restarts so discovered clients
+      // can reconnect without exposing a password flag or environment variable.
+      const generated = value ?? randomBytes(32).toString("base64url")
+      const temp = passwordFile + ".tmp"
+      yield* fs.makeDirectory(directory, { recursive: true })
+      yield* fs.writeFileString(temp, generated, { mode: 0o600 })
+      yield* fs.rename(temp, passwordFile)
+      return generated
+    })
+
+    const registration = Effect.fnUntraced(function* () {
+      return yield* fs.readFileString(file).pipe(Effect.flatMap(decodeRegistration))
+    })
+
+    const createClient = Effect.fnUntraced(function* (url: string) {
+      return createOpencodeClient({ baseUrl: url, headers: ServerAuth.headers({ password: yield* password() }) })
+    })
+
+    const healthy = Effect.fnUntraced(function* () {
+      const info = yield* registration()
+      const client = yield* createClient(info.url)
+      const response = yield* Effect.tryPromise(() => client.v2.health.get({ signal: AbortSignal.timeout(2_000) }))
+      if (response.data?.healthy === true) return info
+      return yield* Effect.fail(new Error("Registered server is not healthy"))
+    })
+
+    const compatible = Effect.fnUntraced(function* () {
+      const info = yield* healthy()
+      if (info.version === InstallationVersion) return info
+      return yield* Effect.fail(new Error("Registered server version does not match the client"))
+    })
+
+    const signal = (pid: number, signal: NodeJS.Signals) =>
+      Effect.try({ try: () => process.kill(pid, signal), catch: (cause) => cause }).pipe(Effect.ignore)
+
+    const awaitStopped = 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`))
+    })
+
+    const stopProcess = Effect.fnUntraced(function* (info: Registration) {
+      const current = yield* healthy().pipe(Effect.option)
+      if (Option.isNone(current) || !sameRegistration(current.value, info)) return
+
+      yield* signal(info.pid, "SIGTERM")
+      const stopped = yield* awaitStopped(info.pid).pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+        Effect.option,
+      )
+      if (Option.isSome(stopped)) return
+
+      const latest = yield* healthy().pipe(Effect.option)
+      if (Option.isNone(latest) || !sameRegistration(latest.value, info)) return
+      yield* signal(info.pid, "SIGKILL")
+      yield* awaitStopped(info.pid).pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+      )
+    })
+
+    const start = Effect.fn("cli.daemon.start")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      const found = Option.getOrUndefined(existing)
+      const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
+      if (found?.version === InstallationVersion && compiled) return found.url
+      if (found) yield* stopProcess(found).pipe(Effect.ignore)
+
+      const entrypoint = compiled ? undefined : process.argv[1]
+      if (!compiled && entrypoint === undefined)
+        return yield* Effect.fail(new Error("Failed to resolve CLI entrypoint"))
+      yield* Effect.try({
+        try: () => {
+          spawn(process.execPath, [...(entrypoint ? [entrypoint] : []), "serve", "--register"], {
+            detached: true,
+            stdio: "ignore",
+          }).unref()
+        },
+        catch: (cause) => new Error("Failed to start server", { cause }),
+      })
+
+      return yield* compatible().pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+        Effect.map((info) => info.url),
+        Effect.mapError(() => new Error("Failed to start server")),
+      )
+    })
+
+    const transport = Effect.fn("cli.daemon.transport")(function* () {
+      return { url: yield* start(), headers: ServerAuth.headers({ password: yield* password() }) }
+    })
+
+    const client = Effect.fn("cli.daemon.client")(function* () {
+      const connection = yield* transport()
+      return createOpencodeClient({ baseUrl: connection.url, headers: connection.headers })
+    })
+
+    const status = Effect.fn("cli.daemon.status")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      const found = Option.getOrUndefined(existing)
+      if (found?.version === InstallationVersion) return found.url
+      if (found) return undefined
+      yield* fs.remove(file).pipe(Effect.ignore)
+      return undefined
+    })
+
+    const stop = Effect.fn("cli.daemon.stop")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      // A stale registration may point at a PID that has since been reused by
+      // another process. Only signal the PID after authenticating the server.
+      if (Option.isNone(existing)) return yield* fs.remove(file).pipe(Effect.ignore)
+      yield* stopProcess(existing.value)
+      yield* fs.remove(file).pipe(Effect.ignore)
+    })
+
+    const register = Effect.fn("cli.daemon.register")(function* (address: HttpServer.Address) {
+      const id = randomUUID()
+      const temp = file + "." + id + ".tmp"
+      yield* fs.makeDirectory(directory, { recursive: true })
+      yield* fs.writeFileString(
+        temp,
+        JSON.stringify({ id, version: InstallationVersion, url: HttpServer.formatAddress(address), pid: process.pid }),
+        { mode: 0o600 },
+      )
+      yield* fs.rename(temp, file)
+      yield* registration().pipe(
+        Effect.flatMap((info) => (info.id === id ? Effect.void : signal(process.pid, "SIGTERM"))),
+        Effect.catch(() => signal(process.pid, "SIGTERM")),
+        Effect.repeat(Schedule.spaced("10 seconds")),
+        Effect.forkScoped,
+      )
+      yield* Effect.addFinalizer(() =>
+        registration().pipe(
+          Effect.flatMap((info) => (info.id === id ? fs.remove(file) : Effect.void)),
+          Effect.ignore,
+        ),
+      )
+    })
+
+    return Service.of({ client, transport, start, status, stop, password, register })
+  }),
+)
+
+export * as Daemon from "./daemon"

packages/cli/src/tui.ts

@@ -0,0 +1,37 @@
+import { run } from "@opencode-ai/tui"
+import { TuiConfig } from "@opencode-ai/tui/config"
+import { Effect } from "effect"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { Global } from "@opencode-ai/core/global"
+
+export function runTui(transport: { url: string; headers: RequestInit["headers"] }) {
+  const config = TuiConfig.resolve({}, { terminalSuspend: false })
+  return run({
+    ...transport,
+    args: {},
+    config,
+    fetch: gracefulFetch,
+    pluginHost: {
+      async start() {},
+      async dispose() {},
+    },
+  }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)))
+}
+
+const legacyDefaults: Record<string, unknown> = {
+  "/config/providers": { providers: [], default: {} },
+  "/provider": { all: [], default: {}, connected: [] },
+  "/agent": [],
+  "/config": {},
+}
+
+const gracefulFetch = Object.assign(
+  async (input: RequestInfo | URL, init?: RequestInit) => {
+    const response = await fetch(input, init)
+    if (response.status !== 404) return response
+    const fallback = legacyDefaults[new URL(input instanceof Request ? input.url : input).pathname]
+    if (fallback === undefined) return response
+    return Response.json(fallback)
+  },
+  { preconnect: fetch.preconnect },
+)

packages/client/script/build.ts

@@ -0,0 +1,30 @@
+import { NodeFileSystem } from "@effect/platform-node"
+import { compile, emitEffectImported, emitPromise, write } from "@opencode-ai/httpapi-codegen"
+import { ClientApi, endpointNames, groupNames, omitEndpoints } from "../src/contract"
+import { Effect } from "effect"
+import { fileURLToPath } from "url"
+
+const contract = compile(ClientApi, { groupNames, endpointNames, omitEndpoints })
+
+await Effect.runPromise(
+  Effect.all(
+    [
+      write(
+        emitPromise(contract, {
+          outputTypes: {
+            "events.subscribe": {
+              name: "OpenCodeEventEncoded",
+              import: 'import type { OpenCodeEventEncoded } from "@opencode-ai/protocol/groups/event"',
+            },
+          },
+        }),
+        fileURLToPath(new URL("../src/generated", import.meta.url)),
+      ),
+      write(
+        emitEffectImported(contract, { module: "../contract", api: "ClientApi" }),
+        fileURLToPath(new URL("../src/generated-effect", import.meta.url)),
+      ),
+    ],
+    { concurrency: 2, discard: true },
+  ).pipe(Effect.provide(NodeFileSystem.layer)),
+)

packages/client/src/contract.ts

@@ -0,0 +1,53 @@
+import { makeDefaultApi } from "@opencode-ai/protocol/api"
+import { InvalidRequestError, SessionNotFoundError } from "@opencode-ai/protocol/errors"
+import { HttpApiMiddleware } from "effect/unstable/httpapi"
+
+class LocationMiddleware extends HttpApiMiddleware.Service<LocationMiddleware>()(
+  "@opencode-ai/client/LocationMiddleware",
+) {}
+
+class SessionLocationMiddleware extends HttpApiMiddleware.Service<SessionLocationMiddleware>()(
+  "@opencode-ai/client/SessionLocationMiddleware",
+  { error: [InvalidRequestError, SessionNotFoundError] },
+) {}
+
+export const ClientApi = makeDefaultApi({
+  locationMiddleware: LocationMiddleware,
+  sessionLocationMiddleware: SessionLocationMiddleware,
+})
+
+export const groupNames = {
+  "server.health": "health",
+  "server.location": "location",
+  "server.agent": "agents",
+  "server.session": "sessions",
+  "server.message": "messages",
+  "server.model": "models",
+  "server.provider": "providers",
+  "server.integration": "integrations",
+  "server.credential": "credentials",
+  "server.permission": "permissions",
+  "server.fs": "files",
+  "server.command": "commands",
+  "server.skill": "skills",
+  "server.event": "events",
+  "server.pty": "ptys",
+  "server.question": "questions",
+  "server.reference": "references",
+  "server.projectCopy": "projectCopies",
+} as const
+
+export const endpointNames = {
+  "session.messages": "list",
+  "integration.connect.key": "connectKey",
+  "integration.connect.oauth": "connectOauth",
+  "integration.attempt.status": "attemptStatus",
+  "integration.attempt.complete": "attemptComplete",
+  "integration.attempt.cancel": "attemptCancel",
+  "permission.request.list": "listRequests",
+  "permission.saved.list": "listSaved",
+  "permission.saved.remove": "removeSaved",
+  "question.request.list": "listRequests",
+} as const
+
+export const omitEndpoints = new Set(["fs.read", "pty.connect", "pty.connectToken"])

packages/client/src/effect.ts

@@ -0,0 +1,25 @@
+// 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-effect/index"
+export { Agent } from "@opencode-ai/schema/agent"
+export { Command } from "@opencode-ai/schema/command"
+export { Credential } from "@opencode-ai/schema/credential"
+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/generated-effect/.httpapi-codegen.json

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

packages/client/src/generated-effect/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/generated-effect/client.ts

@@ -0,0 +1,706 @@
+// 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.session"]["session.list"]>[0]
+type Endpoint3_0Input = {
+  readonly workspace?: Endpoint3_0Request["query"]["workspace"]
+  readonly limit?: Endpoint3_0Request["query"]["limit"]
+  readonly order?: Endpoint3_0Request["query"]["order"]
+  readonly search?: Endpoint3_0Request["query"]["search"]
+  readonly directory?: Endpoint3_0Request["query"]["directory"]
+  readonly project?: Endpoint3_0Request["query"]["project"]
+  readonly subpath?: Endpoint3_0Request["query"]["subpath"]
+  readonly cursor?: Endpoint3_0Request["query"]["cursor"]
+}
+const Endpoint3_0 = (raw: RawClient["server.session"]) => (input?: Endpoint3_0Input) =>
+  raw["session.list"]({
+    query: {
+      workspace: input?.["workspace"],
+      limit: input?.["limit"],
+      order: input?.["order"],
+      search: input?.["search"],
+      directory: input?.["directory"],
+      project: input?.["project"],
+      subpath: input?.["subpath"],
+      cursor: input?.["cursor"],
+    },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_1Request = Parameters<RawClient["server.session"]["session.create"]>[0]
+type Endpoint3_1Input = {
+  readonly id?: Endpoint3_1Request["payload"]["id"]
+  readonly agent?: Endpoint3_1Request["payload"]["agent"]
+  readonly model?: Endpoint3_1Request["payload"]["model"]
+  readonly location?: Endpoint3_1Request["payload"]["location"]
+}
+const Endpoint3_1 = (raw: RawClient["server.session"]) => (input?: Endpoint3_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 Endpoint3_2 = (raw: RawClient["server.session"]) => () =>
+  raw["session.active"]({}).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint3_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
+type Endpoint3_3Input = { readonly sessionID: Endpoint3_3Request["params"]["sessionID"] }
+const Endpoint3_3 = (raw: RawClient["server.session"]) => (input: Endpoint3_3Input) =>
+  raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint3_4Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
+type Endpoint3_4Input = {
+  readonly sessionID: Endpoint3_4Request["params"]["sessionID"]
+  readonly agent: Endpoint3_4Request["payload"]["agent"]
+}
+const Endpoint3_4 = (raw: RawClient["server.session"]) => (input: Endpoint3_4Input) =>
+  raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint3_5Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
+type Endpoint3_5Input = {
+  readonly sessionID: Endpoint3_5Request["params"]["sessionID"]
+  readonly model: Endpoint3_5Request["payload"]["model"]
+}
+const Endpoint3_5 = (raw: RawClient["server.session"]) => (input: Endpoint3_5Input) =>
+  raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint3_6Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint3_6Input = {
+  readonly sessionID: Endpoint3_6Request["params"]["sessionID"]
+  readonly id?: Endpoint3_6Request["payload"]["id"]
+  readonly prompt: Endpoint3_6Request["payload"]["prompt"]
+  readonly delivery?: Endpoint3_6Request["payload"]["delivery"]
+  readonly resume?: Endpoint3_6Request["payload"]["resume"]
+}
+const Endpoint3_6 = (raw: RawClient["server.session"]) => (input: Endpoint3_6Input) =>
+  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 Endpoint3_7Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint3_7Input = { readonly sessionID: Endpoint3_7Request["params"]["sessionID"] }
+const Endpoint3_7 = (raw: RawClient["server.session"]) => (input: Endpoint3_7Input) =>
+  raw["session.compact"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_8Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint3_8Input = { readonly sessionID: Endpoint3_8Request["params"]["sessionID"] }
+const Endpoint3_8 = (raw: RawClient["server.session"]) => (input: Endpoint3_8Input) =>
+  raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_9Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint3_9Input = {
+  readonly sessionID: Endpoint3_9Request["params"]["sessionID"]
+  readonly messageID: Endpoint3_9Request["payload"]["messageID"]
+  readonly files?: Endpoint3_9Request["payload"]["files"]
+}
+const Endpoint3_9 = (raw: RawClient["server.session"]) => (input: Endpoint3_9Input) =>
+  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 Endpoint3_10Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint3_10Input = { readonly sessionID: Endpoint3_10Request["params"]["sessionID"] }
+const Endpoint3_10 = (raw: RawClient["server.session"]) => (input: Endpoint3_10Input) =>
+  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_11Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint3_11Input = { readonly sessionID: Endpoint3_11Request["params"]["sessionID"] }
+const Endpoint3_11 = (raw: RawClient["server.session"]) => (input: Endpoint3_11Input) =>
+  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_12Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint3_12Input = { readonly sessionID: Endpoint3_12Request["params"]["sessionID"] }
+const Endpoint3_12 = (raw: RawClient["server.session"]) => (input: Endpoint3_12Input) =>
+  raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint3_13Request = Parameters<RawClient["server.session"]["session.history"]>[0]
+type Endpoint3_13Input = {
+  readonly sessionID: Endpoint3_13Request["params"]["sessionID"]
+  readonly limit?: Endpoint3_13Request["query"]["limit"]
+  readonly after?: Endpoint3_13Request["query"]["after"]
+}
+const Endpoint3_13 = (raw: RawClient["server.session"]) => (input: Endpoint3_13Input) =>
+  raw["session.history"]({
+    params: { sessionID: input["sessionID"] },
+    query: { limit: input["limit"], after: input["after"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_14Request = Parameters<RawClient["server.session"]["session.events"]>[0]
+type Endpoint3_14Input = {
+  readonly sessionID: Endpoint3_14Request["params"]["sessionID"]
+  readonly after?: Endpoint3_14Request["query"]["after"]
+}
+const Endpoint3_14 = (raw: RawClient["server.session"]) => (input: Endpoint3_14Input) =>
+  Stream.unwrap(
+    raw["session.events"]({ params: { sessionID: input["sessionID"] }, query: { after: input["after"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
+    ),
+  )
+
+type Endpoint3_15Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint3_15Input = { readonly sessionID: Endpoint3_15Request["params"]["sessionID"] }
+const Endpoint3_15 = (raw: RawClient["server.session"]) => (input: Endpoint3_15Input) =>
+  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_16Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint3_16Input = {
+  readonly sessionID: Endpoint3_16Request["params"]["sessionID"]
+  readonly messageID: Endpoint3_16Request["params"]["messageID"]
+}
+const Endpoint3_16 = (raw: RawClient["server.session"]) => (input: Endpoint3_16Input) =>
+  raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+const adaptGroup3 = (raw: RawClient["server.session"]) => ({
+  list: Endpoint3_0(raw),
+  create: Endpoint3_1(raw),
+  active: Endpoint3_2(raw),
+  get: Endpoint3_3(raw),
+  switchAgent: Endpoint3_4(raw),
+  switchModel: Endpoint3_5(raw),
+  prompt: Endpoint3_6(raw),
+  compact: Endpoint3_7(raw),
+  wait: Endpoint3_8(raw),
+  stage: Endpoint3_9(raw),
+  clear: Endpoint3_10(raw),
+  commit: Endpoint3_11(raw),
+  context: Endpoint3_12(raw),
+  history: Endpoint3_13(raw),
+  events: Endpoint3_14(raw),
+  interrupt: Endpoint3_15(raw),
+  message: Endpoint3_16(raw),
+})
+
+type Endpoint4_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
+type Endpoint4_0Input = {
+  readonly sessionID: Endpoint4_0Request["params"]["sessionID"]
+  readonly limit?: Endpoint4_0Request["query"]["limit"]
+  readonly order?: Endpoint4_0Request["query"]["order"]
+  readonly cursor?: Endpoint4_0Request["query"]["cursor"]
+}
+const Endpoint4_0 = (raw: RawClient["server.message"]) => (input: Endpoint4_0Input) =>
+  raw["session.messages"]({
+    params: { sessionID: input["sessionID"] },
+    query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup4 = (raw: RawClient["server.message"]) => ({ list: Endpoint4_0(raw) })
+
+type Endpoint5_0Request = Parameters<RawClient["server.model"]["model.list"]>[0]
+type Endpoint5_0Input = { readonly location?: Endpoint5_0Request["query"]["location"] }
+const Endpoint5_0 = (raw: RawClient["server.model"]) => (input?: Endpoint5_0Input) =>
+  raw["model.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup5 = (raw: RawClient["server.model"]) => ({ list: Endpoint5_0(raw) })
+
+type Endpoint6_0Request = Parameters<RawClient["server.provider"]["provider.list"]>[0]
+type Endpoint6_0Input = { readonly location?: Endpoint6_0Request["query"]["location"] }
+const Endpoint6_0 = (raw: RawClient["server.provider"]) => (input?: Endpoint6_0Input) =>
+  raw["provider.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint6_1Request = Parameters<RawClient["server.provider"]["provider.get"]>[0]
+type Endpoint6_1Input = {
+  readonly providerID: Endpoint6_1Request["params"]["providerID"]
+  readonly location?: Endpoint6_1Request["query"]["location"]
+}
+const Endpoint6_1 = (raw: RawClient["server.provider"]) => (input: Endpoint6_1Input) =>
+  raw["provider.get"]({ params: { providerID: input["providerID"] }, query: { location: input["location"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+const adaptGroup6 = (raw: RawClient["server.provider"]) => ({ list: Endpoint6_0(raw), get: Endpoint6_1(raw) })
+
+type Endpoint7_0Request = Parameters<RawClient["server.integration"]["integration.list"]>[0]
+type Endpoint7_0Input = { readonly location?: Endpoint7_0Request["query"]["location"] }
+const Endpoint7_0 = (raw: RawClient["server.integration"]) => (input?: Endpoint7_0Input) =>
+  raw["integration.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint7_1Request = Parameters<RawClient["server.integration"]["integration.get"]>[0]
+type Endpoint7_1Input = {
+  readonly integrationID: Endpoint7_1Request["params"]["integrationID"]
+  readonly location?: Endpoint7_1Request["query"]["location"]
+}
+const Endpoint7_1 = (raw: RawClient["server.integration"]) => (input: Endpoint7_1Input) =>
+  raw["integration.get"]({
+    params: { integrationID: input["integrationID"] },
+    query: { location: input["location"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint7_2Request = Parameters<RawClient["server.integration"]["integration.connect.key"]>[0]
+type Endpoint7_2Input = {
+  readonly integrationID: Endpoint7_2Request["params"]["integrationID"]
+  readonly location?: Endpoint7_2Request["query"]["location"]
+  readonly key: Endpoint7_2Request["payload"]["key"]
+  readonly label?: Endpoint7_2Request["payload"]["label"]
+}
+const Endpoint7_2 = (raw: RawClient["server.integration"]) => (input: Endpoint7_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 Endpoint7_3Request = Parameters<RawClient["server.integration"]["integration.connect.oauth"]>[0]
+type Endpoint7_3Input = {
+  readonly integrationID: Endpoint7_3Request["params"]["integrationID"]
+  readonly location?: Endpoint7_3Request["query"]["location"]
+  readonly methodID: Endpoint7_3Request["payload"]["methodID"]
+  readonly inputs: Endpoint7_3Request["payload"]["inputs"]
+  readonly label?: Endpoint7_3Request["payload"]["label"]
+}
+const Endpoint7_3 = (raw: RawClient["server.integration"]) => (input: Endpoint7_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 Endpoint7_4Request = Parameters<RawClient["server.integration"]["integration.attempt.status"]>[0]
+type Endpoint7_4Input = {
+  readonly attemptID: Endpoint7_4Request["params"]["attemptID"]
+  readonly location?: Endpoint7_4Request["query"]["location"]
+}
+const Endpoint7_4 = (raw: RawClient["server.integration"]) => (input: Endpoint7_4Input) =>
+  raw["integration.attempt.status"]({
+    params: { attemptID: input["attemptID"] },
+    query: { location: input["location"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint7_5Request = Parameters<RawClient["server.integration"]["integration.attempt.complete"]>[0]
+type Endpoint7_5Input = {
+  readonly attemptID: Endpoint7_5Request["params"]["attemptID"]
+  readonly location?: Endpoint7_5Request["query"]["location"]
+  readonly code?: Endpoint7_5Request["payload"]["code"]
+}
+const Endpoint7_5 = (raw: RawClient["server.integration"]) => (input: Endpoint7_5Input) =>
+  raw["integration.attempt.complete"]({
+    params: { attemptID: input["attemptID"] },
+    query: { location: input["location"] },
+    payload: { code: input["code"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint7_6Request = Parameters<RawClient["server.integration"]["integration.attempt.cancel"]>[0]
+type Endpoint7_6Input = {
+  readonly attemptID: Endpoint7_6Request["params"]["attemptID"]
+  readonly location?: Endpoint7_6Request["query"]["location"]
+}
+const Endpoint7_6 = (raw: RawClient["server.integration"]) => (input: Endpoint7_6Input) =>
+  raw["integration.attempt.cancel"]({
+    params: { attemptID: input["attemptID"] },
+    query: { location: input["location"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup7 = (raw: RawClient["server.integration"]) => ({
+  list: Endpoint7_0(raw),
+  get: Endpoint7_1(raw),
+  connectKey: Endpoint7_2(raw),
+  connectOauth: Endpoint7_3(raw),
+  attemptStatus: Endpoint7_4(raw),
+  attemptComplete: Endpoint7_5(raw),
+  attemptCancel: Endpoint7_6(raw),
+})
+
+type Endpoint8_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
+type Endpoint8_0Input = {
+  readonly credentialID: Endpoint8_0Request["params"]["credentialID"]
+  readonly location?: Endpoint8_0Request["query"]["location"]
+  readonly label: Endpoint8_0Request["payload"]["label"]
+}
+const Endpoint8_0 = (raw: RawClient["server.credential"]) => (input: Endpoint8_0Input) =>
+  raw["credential.update"]({
+    params: { credentialID: input["credentialID"] },
+    query: { location: input["location"] },
+    payload: { label: input["label"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint8_1Request = Parameters<RawClient["server.credential"]["credential.remove"]>[0]
+type Endpoint8_1Input = {
+  readonly credentialID: Endpoint8_1Request["params"]["credentialID"]
+  readonly location?: Endpoint8_1Request["query"]["location"]
+}
+const Endpoint8_1 = (raw: RawClient["server.credential"]) => (input: Endpoint8_1Input) =>
+  raw["credential.remove"]({
+    params: { credentialID: input["credentialID"] },
+    query: { location: input["location"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup8 = (raw: RawClient["server.credential"]) => ({ update: Endpoint8_0(raw), remove: Endpoint8_1(raw) })
+
+type Endpoint9_0Request = Parameters<RawClient["server.permission"]["permission.request.list"]>[0]
+type Endpoint9_0Input = { readonly location?: Endpoint9_0Request["query"]["location"] }
+const Endpoint9_0 = (raw: RawClient["server.permission"]) => (input?: Endpoint9_0Input) =>
+  raw["permission.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint9_1Request = Parameters<RawClient["server.permission"]["permission.saved.list"]>[0]
+type Endpoint9_1Input = { readonly projectID?: Endpoint9_1Request["query"]["projectID"] }
+const Endpoint9_1 = (raw: RawClient["server.permission"]) => (input?: Endpoint9_1Input) =>
+  raw["permission.saved.list"]({ query: { projectID: input?.["projectID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint9_2Request = Parameters<RawClient["server.permission"]["permission.saved.remove"]>[0]
+type Endpoint9_2Input = { readonly id: Endpoint9_2Request["params"]["id"] }
+const Endpoint9_2 = (raw: RawClient["server.permission"]) => (input: Endpoint9_2Input) =>
+  raw["permission.saved.remove"]({ params: { id: input["id"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint9_3Request = Parameters<RawClient["server.permission"]["session.permission.create"]>[0]
+type Endpoint9_3Input = {
+  readonly sessionID: Endpoint9_3Request["params"]["sessionID"]
+  readonly id?: Endpoint9_3Request["payload"]["id"]
+  readonly action: Endpoint9_3Request["payload"]["action"]
+  readonly resources: Endpoint9_3Request["payload"]["resources"]
+  readonly save?: Endpoint9_3Request["payload"]["save"]
+  readonly metadata?: Endpoint9_3Request["payload"]["metadata"]
+  readonly source?: Endpoint9_3Request["payload"]["source"]
+  readonly agent?: Endpoint9_3Request["payload"]["agent"]
+}
+const Endpoint9_3 = (raw: RawClient["server.permission"]) => (input: Endpoint9_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 Endpoint9_4Request = Parameters<RawClient["server.permission"]["session.permission.list"]>[0]
+type Endpoint9_4Input = { readonly sessionID: Endpoint9_4Request["params"]["sessionID"] }
+const Endpoint9_4 = (raw: RawClient["server.permission"]) => (input: Endpoint9_4Input) =>
+  raw["session.permission.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint9_5Request = Parameters<RawClient["server.permission"]["session.permission.get"]>[0]
+type Endpoint9_5Input = {
+  readonly sessionID: Endpoint9_5Request["params"]["sessionID"]
+  readonly requestID: Endpoint9_5Request["params"]["requestID"]
+}
+const Endpoint9_5 = (raw: RawClient["server.permission"]) => (input: Endpoint9_5Input) =>
+  raw["session.permission.get"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint9_6Request = Parameters<RawClient["server.permission"]["session.permission.reply"]>[0]
+type Endpoint9_6Input = {
+  readonly sessionID: Endpoint9_6Request["params"]["sessionID"]
+  readonly requestID: Endpoint9_6Request["params"]["requestID"]
+  readonly reply: Endpoint9_6Request["payload"]["reply"]
+  readonly message?: Endpoint9_6Request["payload"]["message"]
+}
+const Endpoint9_6 = (raw: RawClient["server.permission"]) => (input: Endpoint9_6Input) =>
+  raw["session.permission.reply"]({
+    params: { sessionID: input["sessionID"], requestID: input["requestID"] },
+    payload: { reply: input["reply"], message: input["message"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup9 = (raw: RawClient["server.permission"]) => ({
+  listRequests: Endpoint9_0(raw),
+  listSaved: Endpoint9_1(raw),
+  removeSaved: Endpoint9_2(raw),
+  create: Endpoint9_3(raw),
+  list: Endpoint9_4(raw),
+  get: Endpoint9_5(raw),
+  reply: Endpoint9_6(raw),
+})
+
+type Endpoint10_0Request = Parameters<RawClient["server.fs"]["fs.list"]>[0]
+type Endpoint10_0Input = {
+  readonly location?: Endpoint10_0Request["query"]["location"]
+  readonly path?: Endpoint10_0Request["query"]["path"]
+}
+const Endpoint10_0 = (raw: RawClient["server.fs"]) => (input?: Endpoint10_0Input) =>
+  raw["fs.list"]({ query: { location: input?.["location"], path: input?.["path"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint10_1Request = Parameters<RawClient["server.fs"]["fs.find"]>[0]
+type Endpoint10_1Input = {
+  readonly location?: Endpoint10_1Request["query"]["location"]
+  readonly query: Endpoint10_1Request["query"]["query"]
+  readonly type?: Endpoint10_1Request["query"]["type"]
+  readonly limit?: Endpoint10_1Request["query"]["limit"]
+}
+const Endpoint10_1 = (raw: RawClient["server.fs"]) => (input: Endpoint10_1Input) =>
+  raw["fs.find"]({
+    query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup10 = (raw: RawClient["server.fs"]) => ({ list: Endpoint10_0(raw), find: Endpoint10_1(raw) })
+
+type Endpoint11_0Request = Parameters<RawClient["server.command"]["command.list"]>[0]
+type Endpoint11_0Input = { readonly location?: Endpoint11_0Request["query"]["location"] }
+const Endpoint11_0 = (raw: RawClient["server.command"]) => (input?: Endpoint11_0Input) =>
+  raw["command.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup11 = (raw: RawClient["server.command"]) => ({ list: Endpoint11_0(raw) })
+
+type Endpoint12_0Request = Parameters<RawClient["server.skill"]["skill.list"]>[0]
+type Endpoint12_0Input = { readonly location?: Endpoint12_0Request["query"]["location"] }
+const Endpoint12_0 = (raw: RawClient["server.skill"]) => (input?: Endpoint12_0Input) =>
+  raw["skill.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup12 = (raw: RawClient["server.skill"]) => ({ list: Endpoint12_0(raw) })
+
+const Endpoint13_0 = (raw: RawClient["server.event"]) => () =>
+  Stream.unwrap(
+    raw["event.subscribe"]({}).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
+    ),
+  )
+
+const adaptGroup13 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint13_0(raw) })
+
+type Endpoint14_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+type Endpoint14_0Input = { readonly location?: Endpoint14_0Request["query"]["location"] }
+const Endpoint14_0 = (raw: RawClient["server.pty"]) => (input?: Endpoint14_0Input) =>
+  raw["pty.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint14_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
+type Endpoint14_1Input = {
+  readonly location?: Endpoint14_1Request["query"]["location"]
+  readonly command?: Endpoint14_1Request["payload"]["command"]
+  readonly args?: Endpoint14_1Request["payload"]["args"]
+  readonly cwd?: Endpoint14_1Request["payload"]["cwd"]
+  readonly title?: Endpoint14_1Request["payload"]["title"]
+  readonly env?: Endpoint14_1Request["payload"]["env"]
+}
+const Endpoint14_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint14_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 Endpoint14_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
+type Endpoint14_2Input = {
+  readonly ptyID: Endpoint14_2Request["params"]["ptyID"]
+  readonly location?: Endpoint14_2Request["query"]["location"]
+}
+const Endpoint14_2 = (raw: RawClient["server.pty"]) => (input: Endpoint14_2Input) =>
+  raw["pty.get"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint14_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
+type Endpoint14_3Input = {
+  readonly ptyID: Endpoint14_3Request["params"]["ptyID"]
+  readonly location?: Endpoint14_3Request["query"]["location"]
+  readonly title?: Endpoint14_3Request["payload"]["title"]
+  readonly size?: Endpoint14_3Request["payload"]["size"]
+}
+const Endpoint14_3 = (raw: RawClient["server.pty"]) => (input: Endpoint14_3Input) =>
+  raw["pty.update"]({
+    params: { ptyID: input["ptyID"] },
+    query: { location: input["location"] },
+    payload: { title: input["title"], size: input["size"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint14_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
+type Endpoint14_4Input = {
+  readonly ptyID: Endpoint14_4Request["params"]["ptyID"]
+  readonly location?: Endpoint14_4Request["query"]["location"]
+}
+const Endpoint14_4 = (raw: RawClient["server.pty"]) => (input: Endpoint14_4Input) =>
+  raw["pty.remove"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+const adaptGroup14 = (raw: RawClient["server.pty"]) => ({
+  list: Endpoint14_0(raw),
+  create: Endpoint14_1(raw),
+  get: Endpoint14_2(raw),
+  update: Endpoint14_3(raw),
+  remove: Endpoint14_4(raw),
+})
+
+type Endpoint15_0Request = Parameters<RawClient["server.question"]["question.request.list"]>[0]
+type Endpoint15_0Input = { readonly location?: Endpoint15_0Request["query"]["location"] }
+const Endpoint15_0 = (raw: RawClient["server.question"]) => (input?: Endpoint15_0Input) =>
+  raw["question.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint15_1Request = Parameters<RawClient["server.question"]["session.question.list"]>[0]
+type Endpoint15_1Input = { readonly sessionID: Endpoint15_1Request["params"]["sessionID"] }
+const Endpoint15_1 = (raw: RawClient["server.question"]) => (input: Endpoint15_1Input) =>
+  raw["session.question.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    Effect.mapError(mapClientError),
+    Effect.map((value) => value.data),
+  )
+
+type Endpoint15_2Request = Parameters<RawClient["server.question"]["session.question.reply"]>[0]
+type Endpoint15_2Input = {
+  readonly sessionID: Endpoint15_2Request["params"]["sessionID"]
+  readonly requestID: Endpoint15_2Request["params"]["requestID"]
+  readonly answers: Endpoint15_2Request["payload"]["answers"]
+}
+const Endpoint15_2 = (raw: RawClient["server.question"]) => (input: Endpoint15_2Input) =>
+  raw["session.question.reply"]({
+    params: { sessionID: input["sessionID"], requestID: input["requestID"] },
+    payload: { answers: input["answers"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint15_3Request = Parameters<RawClient["server.question"]["session.question.reject"]>[0]
+type Endpoint15_3Input = {
+  readonly sessionID: Endpoint15_3Request["params"]["sessionID"]
+  readonly requestID: Endpoint15_3Request["params"]["requestID"]
+}
+const Endpoint15_3 = (raw: RawClient["server.question"]) => (input: Endpoint15_3Input) =>
+  raw["session.question.reject"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+const adaptGroup15 = (raw: RawClient["server.question"]) => ({
+  listRequests: Endpoint15_0(raw),
+  list: Endpoint15_1(raw),
+  reply: Endpoint15_2(raw),
+  reject: Endpoint15_3(raw),
+})
+
+type Endpoint16_0Request = Parameters<RawClient["server.reference"]["reference.list"]>[0]
+type Endpoint16_0Input = { readonly location?: Endpoint16_0Request["query"]["location"] }
+const Endpoint16_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint16_0Input) =>
+  raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup16 = (raw: RawClient["server.reference"]) => ({ list: Endpoint16_0(raw) })
+
+type Endpoint17_0Request = Parameters<RawClient["server.projectCopy"]["projectCopy.create"]>[0]
+type Endpoint17_0Input = {
+  readonly projectID: Endpoint17_0Request["params"]["projectID"]
+  readonly location?: Endpoint17_0Request["query"]["location"]
+  readonly strategy: Endpoint17_0Request["payload"]["strategy"]
+  readonly directory: Endpoint17_0Request["payload"]["directory"]
+  readonly name?: Endpoint17_0Request["payload"]["name"]
+}
+const Endpoint17_0 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint17_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 Endpoint17_1Request = Parameters<RawClient["server.projectCopy"]["projectCopy.remove"]>[0]
+type Endpoint17_1Input = {
+  readonly projectID: Endpoint17_1Request["params"]["projectID"]
+  readonly location?: Endpoint17_1Request["query"]["location"]
+  readonly directory: Endpoint17_1Request["payload"]["directory"]
+  readonly force: Endpoint17_1Request["payload"]["force"]
+}
+const Endpoint17_1 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint17_1Input) =>
+  raw["projectCopy.remove"]({
+    params: { projectID: input["projectID"] },
+    query: { location: input["location"] },
+    payload: { directory: input["directory"], force: input["force"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint17_2Request = Parameters<RawClient["server.projectCopy"]["projectCopy.refresh"]>[0]
+type Endpoint17_2Input = {
+  readonly projectID: Endpoint17_2Request["params"]["projectID"]
+  readonly location?: Endpoint17_2Request["query"]["location"]
+}
+const Endpoint17_2 = (raw: RawClient["server.projectCopy"]) => (input: Endpoint17_2Input) =>
+  raw["projectCopy.refresh"]({
+    params: { projectID: input["projectID"] },
+    query: { location: input["location"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup17 = (raw: RawClient["server.projectCopy"]) => ({
+  create: Endpoint17_0(raw),
+  remove: Endpoint17_1(raw),
+  refresh: Endpoint17_2(raw),
+})
+
+const adaptClient = (raw: RawClient) => ({
+  health: adaptGroup0(raw["server.health"]),
+  location: adaptGroup1(raw["server.location"]),
+  agents: adaptGroup2(raw["server.agent"]),
+  sessions: adaptGroup3(raw["server.session"]),
+  messages: adaptGroup4(raw["server.message"]),
+  models: adaptGroup5(raw["server.model"]),
+  providers: adaptGroup6(raw["server.provider"]),
+  integrations: adaptGroup7(raw["server.integration"]),
+  credentials: adaptGroup8(raw["server.credential"]),
+  permissions: adaptGroup9(raw["server.permission"]),
+  files: adaptGroup10(raw["server.fs"]),
+  commands: adaptGroup11(raw["server.command"]),
+  skills: adaptGroup12(raw["server.skill"]),
+  events: adaptGroup13(raw["server.event"]),
+  ptys: adaptGroup14(raw["server.pty"]),
+  questions: adaptGroup15(raw["server.question"]),
+  references: adaptGroup16(raw["server.reference"]),
+  projectCopies: adaptGroup17(raw["server.projectCopy"]),
+})
+
+export const make = (options?: { readonly baseUrl?: URL | string }) =>
+  HttpApiClient.make(ClientApi, options).pipe(Effect.map(adaptClient))

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

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

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

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

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

@@ -0,0 +1,11 @@
+export type ClientErrorReason = "Transport" | "UnexpectedStatus" | "UnsupportedContentType" | "MalformedResponse"
+
+export class ClientError extends Error {
+  override readonly name = "ClientError"
+  constructor(
+    readonly reason: ClientErrorReason,
+    options?: ErrorOptions,
+  ) {
+    super(reason, options)
+  }
+}

packages/client/src/generated/client.ts

@@ -0,0 +1,1029 @@
+import type {
+  HealthGetOutput,
+  LocationGetInput,
+  LocationGetOutput,
+  AgentsListInput,
+  AgentsListOutput,
+  SessionsListInput,
+  SessionsListOutput,
+  SessionsCreateInput,
+  SessionsCreateOutput,
+  SessionsActiveOutput,
+  SessionsGetInput,
+  SessionsGetOutput,
+  SessionsSwitchAgentInput,
+  SessionsSwitchAgentOutput,
+  SessionsSwitchModelInput,
+  SessionsSwitchModelOutput,
+  SessionsPromptInput,
+  SessionsPromptOutput,
+  SessionsCompactInput,
+  SessionsCompactOutput,
+  SessionsWaitInput,
+  SessionsWaitOutput,
+  SessionsStageInput,
+  SessionsStageOutput,
+  SessionsClearInput,
+  SessionsClearOutput,
+  SessionsCommitInput,
+  SessionsCommitOutput,
+  SessionsContextInput,
+  SessionsContextOutput,
+  SessionsHistoryInput,
+  SessionsHistoryOutput,
+  SessionsEventsInput,
+  SessionsEventsOutput,
+  SessionsInterruptInput,
+  SessionsInterruptOutput,
+  SessionsMessageInput,
+  SessionsMessageOutput,
+  MessagesListInput,
+  MessagesListOutput,
+  ModelsListInput,
+  ModelsListOutput,
+  ProvidersListInput,
+  ProvidersListOutput,
+  ProvidersGetInput,
+  ProvidersGetOutput,
+  IntegrationsListInput,
+  IntegrationsListOutput,
+  IntegrationsGetInput,
+  IntegrationsGetOutput,
+  IntegrationsConnectKeyInput,
+  IntegrationsConnectKeyOutput,
+  IntegrationsConnectOauthInput,
+  IntegrationsConnectOauthOutput,
+  IntegrationsAttemptStatusInput,
+  IntegrationsAttemptStatusOutput,
+  IntegrationsAttemptCompleteInput,
+  IntegrationsAttemptCompleteOutput,
+  IntegrationsAttemptCancelInput,
+  IntegrationsAttemptCancelOutput,
+  CredentialsUpdateInput,
+  CredentialsUpdateOutput,
+  CredentialsRemoveInput,
+  CredentialsRemoveOutput,
+  PermissionsListRequestsInput,
+  PermissionsListRequestsOutput,
+  PermissionsListSavedInput,
+  PermissionsListSavedOutput,
+  PermissionsRemoveSavedInput,
+  PermissionsRemoveSavedOutput,
+  PermissionsCreateInput,
+  PermissionsCreateOutput,
+  PermissionsListInput,
+  PermissionsListOutput,
+  PermissionsGetInput,
+  PermissionsGetOutput,
+  PermissionsReplyInput,
+  PermissionsReplyOutput,
+  FilesListInput,
+  FilesListOutput,
+  FilesFindInput,
+  FilesFindOutput,
+  CommandsListInput,
+  CommandsListOutput,
+  SkillsListInput,
+  SkillsListOutput,
+  EventsSubscribeOutput,
+  PtysListInput,
+  PtysListOutput,
+  PtysCreateInput,
+  PtysCreateOutput,
+  PtysGetInput,
+  PtysGetOutput,
+  PtysUpdateInput,
+  PtysUpdateOutput,
+  PtysRemoveInput,
+  PtysRemoveOutput,
+  QuestionsListRequestsInput,
+  QuestionsListRequestsOutput,
+  QuestionsListInput,
+  QuestionsListOutput,
+  QuestionsReplyInput,
+  QuestionsReplyOutput,
+  QuestionsRejectInput,
+  QuestionsRejectOutput,
+  ReferencesListInput,
+  ReferencesListOutput,
+  ProjectCopiesCreateInput,
+  ProjectCopiesCreateOutput,
+  ProjectCopiesRemoveInput,
+  ProjectCopiesRemoveOutput,
+  ProjectCopiesRefreshInput,
+  ProjectCopiesRefreshOutput,
+} from "./types"
+import { ClientError } from "./client-error"
+
+export interface ClientOptions {
+  readonly baseUrl: string
+  readonly fetch?: typeof globalThis.fetch
+  readonly headers?: HeadersInit
+}
+
+export interface RequestOptions {
+  readonly signal?: AbortSignal
+  readonly headers?: HeadersInit
+}
+
+interface RequestDescriptor {
+  readonly method: string
+  readonly path: string
+  readonly query?: Record<string, unknown>
+  readonly headers?: Record<string, unknown>
+  readonly body?: unknown
+  readonly successStatus: number
+  readonly declaredStatuses: ReadonlyArray<number>
+  readonly empty: boolean
+}
+
+export function make(options: ClientOptions) {
+  const fetch = options.fetch ?? globalThis.fetch
+
+  const prepare = (descriptor: RequestDescriptor, requestOptions?: RequestOptions) => {
+    const url = new URL(descriptor.path, options.baseUrl)
+    for (const [key, value] of Object.entries(descriptor.query ?? {})) appendQuery(url.searchParams, key, value)
+    const headers = new Headers(options.headers)
+    for (const [key, value] of Object.entries(descriptor.headers ?? {})) {
+      if (value !== undefined && value !== null) headers.set(key, String(value))
+    }
+    for (const [key, value] of new Headers(requestOptions?.headers)) headers.set(key, value)
+    if (descriptor.body !== undefined && !headers.has("content-type")) headers.set("content-type", "application/json")
+    return {
+      url,
+      init: {
+        method: descriptor.method,
+        signal: requestOptions?.signal,
+        headers,
+        body: descriptor.body === undefined ? undefined : JSON.stringify(descriptor.body),
+      } satisfies RequestInit,
+    }
+  }
+
+  const execute = async (descriptor: RequestDescriptor, requestOptions?: RequestOptions) => {
+    try {
+      const prepared = prepare(descriptor, requestOptions)
+      return await fetch(prepared.url, prepared.init)
+    } catch (cause) {
+      throw new ClientError("Transport", { cause })
+    }
+  }
+
+  const responseError = async (response: Response, descriptor: RequestDescriptor): Promise<never> => {
+    if (descriptor.declaredStatuses.includes(response.status)) throw await json(response)
+    try {
+      await response.body?.cancel()
+    } catch {}
+    throw new ClientError("UnexpectedStatus", { cause: { status: response.status } })
+  }
+
+  const request = async <A>(descriptor: RequestDescriptor, requestOptions?: RequestOptions): Promise<A> => {
+    const response = await execute(descriptor, requestOptions)
+    if (response.status !== descriptor.successStatus) return responseError(response, descriptor)
+    if (descriptor.empty) {
+      try {
+        await response.body?.cancel()
+      } catch {}
+      return undefined as A
+    }
+    return (await json(response)) as A
+  }
+
+  const sse = <A>(descriptor: RequestDescriptor, requestOptions?: RequestOptions): AsyncIterable<A> => ({
+    async *[Symbol.asyncIterator]() {
+      const response = await execute(descriptor, requestOptions)
+      if (response.status !== descriptor.successStatus) await responseError(response, descriptor)
+      if (!isContentType(response, "text/event-stream")) {
+        try {
+          await response.body?.cancel()
+        } catch {}
+        throw new ClientError("UnsupportedContentType")
+      }
+      if (response.body === null) throw new ClientError("MalformedResponse")
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ""
+      try {
+        while (true) {
+          let next
+          try {
+            next = await reader.read()
+          } catch (cause) {
+            throw new ClientError("Transport", { cause })
+          }
+          buffer += decoder.decode(next.value, { stream: !next.done })
+          if (buffer.length > 1_048_576) throw new ClientError("MalformedResponse")
+          const trailingCarriageReturn = !next.done && buffer.endsWith("\r")
+          if (trailingCarriageReturn) buffer = buffer.slice(0, -1)
+          buffer = buffer.replaceAll("\r\n", "\n").replaceAll("\r", "\n")
+          if (trailingCarriageReturn) buffer += "\r"
+          if (next.done && buffer !== "") buffer += "\n\n"
+          let boundary = buffer.indexOf("\n\n")
+          while (boundary >= 0) {
+            const block = buffer.slice(0, boundary)
+            buffer = buffer.slice(boundary + 2)
+            const data = block
+              .split("\n")
+              .flatMap((line) => (line.startsWith("data:") ? [line.slice(5).trimStart()] : []))
+              .join("\n")
+            if (data !== "") {
+              try {
+                yield JSON.parse(data) as A
+              } catch (cause) {
+                throw new ClientError("MalformedResponse", { cause })
+              }
+            }
+            boundary = buffer.indexOf("\n\n")
+          }
+          if (next.done) return
+        }
+      } finally {
+        try {
+          await reader.cancel()
+        } catch {}
+        reader.releaseLock()
+      }
+    },
+  })
+
+  return {
+    health: {
+      get: (requestOptions?: RequestOptions) =>
+        request<HealthGetOutput>(
+          { method: "GET", path: `/api/health`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
+          requestOptions,
+        ),
+    },
+    location: {
+      get: (input?: LocationGetInput, requestOptions?: RequestOptions) =>
+        request<LocationGetOutput>(
+          {
+            method: "GET",
+            path: `/api/location`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    agents: {
+      list: (input?: AgentsListInput, requestOptions?: RequestOptions) =>
+        request<AgentsListOutput>(
+          {
+            method: "GET",
+            path: `/api/agent`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    sessions: {
+      list: (input?: SessionsListInput, requestOptions?: RequestOptions) =>
+        request<SessionsListOutput>(
+          {
+            method: "GET",
+            path: `/api/session`,
+            query: {
+              workspace: input?.["workspace"],
+              limit: input?.["limit"],
+              order: input?.["order"],
+              search: input?.["search"],
+              directory: input?.["directory"],
+              project: input?.["project"],
+              subpath: input?.["subpath"],
+              cursor: input?.["cursor"],
+            },
+            successStatus: 200,
+            declaredStatuses: [400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      create: (input?: SessionsCreateInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionsCreateOutput }>(
+          {
+            method: "POST",
+            path: `/api/session`,
+            body: {
+              id: input?.["id"],
+              agent: input?.["agent"],
+              model: input?.["model"],
+              location: input?.["location"],
+            },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      active: (requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionsActiveOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/active`,
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      get: (input: SessionsGetInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionsGetOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      switchAgent: (input: SessionsSwitchAgentInput, requestOptions?: RequestOptions) =>
+        request<SessionsSwitchAgentOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
+            body: { agent: input["agent"] },
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      switchModel: (input: SessionsSwitchModelInput, requestOptions?: RequestOptions) =>
+        request<SessionsSwitchModelOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
+            body: { model: input["model"] },
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      prompt: (input: SessionsPromptInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionsPromptOutput }>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
+            body: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
+            successStatus: 200,
+            declaredStatuses: [409, 404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      compact: (input: SessionsCompactInput, requestOptions?: RequestOptions) =>
+        request<SessionsCompactOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
+            successStatus: 204,
+            declaredStatuses: [404, 503, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      wait: (input: SessionsWaitInput, requestOptions?: RequestOptions) =>
+        request<SessionsWaitOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/wait`,
+            successStatus: 204,
+            declaredStatuses: [404, 503, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      stage: (input: SessionsStageInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionsStageOutput }>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
+            body: { messageID: input["messageID"], files: input["files"] },
+            successStatus: 200,
+            declaredStatuses: [404, 500, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      clear: (input: SessionsClearInput, requestOptions?: RequestOptions) =>
+        request<SessionsClearOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/clear`,
+            successStatus: 204,
+            declaredStatuses: [404, 500, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      commit: (input: SessionsCommitInput, requestOptions?: RequestOptions) =>
+        request<SessionsCommitOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      context: (input: SessionsContextInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionsContextOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
+            successStatus: 200,
+            declaredStatuses: [404, 500, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      history: (input: SessionsHistoryInput, requestOptions?: RequestOptions) =>
+        request<SessionsHistoryOutput>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/history`,
+            query: { limit: input["limit"], after: input["after"] },
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      events: (input: SessionsEventsInput, requestOptions?: RequestOptions): AsyncIterable<SessionsEventsOutput> =>
+        sse<SessionsEventsOutput>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/event`,
+            query: { after: input["after"] },
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      interrupt: (input: SessionsInterruptInput, requestOptions?: RequestOptions) =>
+        request<SessionsInterruptOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      message: (input: SessionsMessageInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionsMessageOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+    },
+    messages: {
+      list: (input: MessagesListInput, requestOptions?: RequestOptions) =>
+        request<MessagesListOutput>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
+            query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
+            successStatus: 200,
+            declaredStatuses: [400, 404, 500, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    models: {
+      list: (input?: ModelsListInput, requestOptions?: RequestOptions) =>
+        request<ModelsListOutput>(
+          {
+            method: "GET",
+            path: `/api/model`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    providers: {
+      list: (input?: ProvidersListInput, requestOptions?: RequestOptions) =>
+        request<ProvidersListOutput>(
+          {
+            method: "GET",
+            path: `/api/provider`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      get: (input: ProvidersGetInput, requestOptions?: RequestOptions) =>
+        request<ProvidersGetOutput>(
+          {
+            method: "GET",
+            path: `/api/provider/${encodeURIComponent(input.providerID)}`,
+            query: { location: input["location"] },
+            successStatus: 200,
+            declaredStatuses: [404, 503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    integrations: {
+      list: (input?: IntegrationsListInput, requestOptions?: RequestOptions) =>
+        request<IntegrationsListOutput>(
+          {
+            method: "GET",
+            path: `/api/integration`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      get: (input: IntegrationsGetInput, requestOptions?: RequestOptions) =>
+        request<IntegrationsGetOutput>(
+          {
+            method: "GET",
+            path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
+            query: { location: input["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      connectKey: (input: IntegrationsConnectKeyInput, requestOptions?: RequestOptions) =>
+        request<IntegrationsConnectKeyOutput>(
+          {
+            method: "POST",
+            path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
+            query: { location: input["location"] },
+            body: { key: input["key"], label: input["label"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      connectOauth: (input: IntegrationsConnectOauthInput, requestOptions?: RequestOptions) =>
+        request<IntegrationsConnectOauthOutput>(
+          {
+            method: "POST",
+            path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
+            query: { location: input["location"] },
+            body: { methodID: input["methodID"], inputs: input["inputs"], label: input["label"] },
+            successStatus: 200,
+            declaredStatuses: [400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      attemptStatus: (input: IntegrationsAttemptStatusInput, requestOptions?: RequestOptions) =>
+        request<IntegrationsAttemptStatusOutput>(
+          {
+            method: "GET",
+            path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
+            query: { location: input["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      attemptComplete: (input: IntegrationsAttemptCompleteInput, requestOptions?: RequestOptions) =>
+        request<IntegrationsAttemptCompleteOutput>(
+          {
+            method: "POST",
+            path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}/complete`,
+            query: { location: input["location"] },
+            body: { code: input["code"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      attemptCancel: (input: IntegrationsAttemptCancelInput, requestOptions?: RequestOptions) =>
+        request<IntegrationsAttemptCancelOutput>(
+          {
+            method: "DELETE",
+            path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
+            query: { location: input["location"] },
+            successStatus: 204,
+            declaredStatuses: [401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
+    },
+    credentials: {
+      update: (input: CredentialsUpdateInput, requestOptions?: RequestOptions) =>
+        request<CredentialsUpdateOutput>(
+          {
+            method: "PATCH",
+            path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+            query: { location: input["location"] },
+            body: { label: input["label"] },
+            successStatus: 204,
+            declaredStatuses: [401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      remove: (input: CredentialsRemoveInput, requestOptions?: RequestOptions) =>
+        request<CredentialsRemoveOutput>(
+          {
+            method: "DELETE",
+            path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+            query: { location: input["location"] },
+            successStatus: 204,
+            declaredStatuses: [401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
+    },
+    permissions: {
+      listRequests: (input?: PermissionsListRequestsInput, requestOptions?: RequestOptions) =>
+        request<PermissionsListRequestsOutput>(
+          {
+            method: "GET",
+            path: `/api/permission/request`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      listSaved: (input?: PermissionsListSavedInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: PermissionsListSavedOutput }>(
+          {
+            method: "GET",
+            path: `/api/permission/saved`,
+            query: { projectID: input?.["projectID"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      removeSaved: (input: PermissionsRemoveSavedInput, requestOptions?: RequestOptions) =>
+        request<PermissionsRemoveSavedOutput>(
+          {
+            method: "DELETE",
+            path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
+            successStatus: 204,
+            declaredStatuses: [401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      create: (input: PermissionsCreateInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: PermissionsCreateOutput }>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+            body: {
+              id: input["id"],
+              action: input["action"],
+              resources: input["resources"],
+              save: input["save"],
+              metadata: input["metadata"],
+              source: input["source"],
+              agent: input["agent"],
+            },
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      list: (input: PermissionsListInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: PermissionsListOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      get: (input: PermissionsGetInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: PermissionsGetOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      reply: (input: PermissionsReplyInput, requestOptions?: RequestOptions) =>
+        request<PermissionsReplyOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
+            body: { reply: input["reply"], message: input["message"] },
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+    },
+    files: {
+      list: (input?: FilesListInput, requestOptions?: RequestOptions) =>
+        request<FilesListOutput>(
+          {
+            method: "GET",
+            path: `/api/fs/list`,
+            query: { location: input?.["location"], path: input?.["path"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      find: (input: FilesFindInput, requestOptions?: RequestOptions) =>
+        request<FilesFindOutput>(
+          {
+            method: "GET",
+            path: `/api/fs/find`,
+            query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    commands: {
+      list: (input?: CommandsListInput, requestOptions?: RequestOptions) =>
+        request<CommandsListOutput>(
+          {
+            method: "GET",
+            path: `/api/command`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    skills: {
+      list: (input?: SkillsListInput, requestOptions?: RequestOptions) =>
+        request<SkillsListOutput>(
+          {
+            method: "GET",
+            path: `/api/skill`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    events: {
+      subscribe: (requestOptions?: RequestOptions): AsyncIterable<EventsSubscribeOutput> =>
+        sse<EventsSubscribeOutput>(
+          { method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
+          requestOptions,
+        ),
+    },
+    ptys: {
+      list: (input?: PtysListInput, requestOptions?: RequestOptions) =>
+        request<PtysListOutput>(
+          {
+            method: "GET",
+            path: `/api/pty`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      create: (input?: PtysCreateInput, requestOptions?: RequestOptions) =>
+        request<PtysCreateOutput>(
+          {
+            method: "POST",
+            path: `/api/pty`,
+            query: { location: input?.["location"] },
+            body: {
+              command: input?.["command"],
+              args: input?.["args"],
+              cwd: input?.["cwd"],
+              title: input?.["title"],
+              env: input?.["env"],
+            },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      get: (input: PtysGetInput, requestOptions?: RequestOptions) =>
+        request<PtysGetOutput>(
+          {
+            method: "GET",
+            path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+            query: { location: input["location"] },
+            successStatus: 200,
+            declaredStatuses: [404, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      update: (input: PtysUpdateInput, requestOptions?: RequestOptions) =>
+        request<PtysUpdateOutput>(
+          {
+            method: "PUT",
+            path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+            query: { location: input["location"] },
+            body: { title: input["title"], size: input["size"] },
+            successStatus: 200,
+            declaredStatuses: [404, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      remove: (input: PtysRemoveInput, requestOptions?: RequestOptions) =>
+        request<PtysRemoveOutput>(
+          {
+            method: "DELETE",
+            path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+            query: { location: input["location"] },
+            successStatus: 204,
+            declaredStatuses: [404, 401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
+    },
+    questions: {
+      listRequests: (input?: QuestionsListRequestsInput, requestOptions?: RequestOptions) =>
+        request<QuestionsListRequestsOutput>(
+          {
+            method: "GET",
+            path: `/api/question/request`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      list: (input: QuestionsListInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: QuestionsListOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/question`,
+            successStatus: 200,
+            declaredStatuses: [404, 400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      reply: (input: QuestionsReplyInput, requestOptions?: RequestOptions) =>
+        request<QuestionsReplyOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reply`,
+            body: { answers: input["answers"] },
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      reject: (input: QuestionsRejectInput, requestOptions?: RequestOptions) =>
+        request<QuestionsRejectOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reject`,
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+    },
+    references: {
+      list: (input?: ReferencesListInput, requestOptions?: RequestOptions) =>
+        request<ReferencesListOutput>(
+          {
+            method: "GET",
+            path: `/api/reference`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
+    projectCopies: {
+      create: (input: ProjectCopiesCreateInput, requestOptions?: RequestOptions) =>
+        request<ProjectCopiesCreateOutput>(
+          {
+            method: "POST",
+            path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
+            query: { location: input["location"] },
+            body: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
+            successStatus: 200,
+            declaredStatuses: [400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
+      remove: (input: ProjectCopiesRemoveInput, requestOptions?: RequestOptions) =>
+        request<ProjectCopiesRemoveOutput>(
+          {
+            method: "DELETE",
+            path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
+            query: { location: input["location"] },
+            body: { directory: input["directory"], force: input["force"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      refresh: (input: ProjectCopiesRefreshInput, requestOptions?: RequestOptions) =>
+        request<ProjectCopiesRefreshOutput>(
+          {
+            method: "POST",
+            path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy/refresh`,
+            query: { location: input["location"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
+    },
+  }
+}
+
+function appendQuery(params: URLSearchParams, key: string, value: unknown): void {
+  if (value === undefined || value === null) return
+  if (Array.isArray(value)) {
+    for (const item of value) appendQuery(params, key, item)
+    return
+  }
+  if (typeof value === "object") {
+    for (const [child, item] of Object.entries(value)) appendQuery(params, `${key}[${child}]`, item)
+    return
+  }
+  params.append(key, String(value))
+}
+
+async function json(response: Response): Promise<unknown> {
+  if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
+    try {
+      await response.body?.cancel()
+    } catch {}
+    throw new ClientError("UnsupportedContentType")
+  }
+  let text: string
+  try {
+    text = await response.text()
+  } catch (cause) {
+    throw new ClientError("Transport", { cause })
+  }
+  if (text === "") throw new ClientError("MalformedResponse")
+  try {
+    return JSON.parse(text)
+  } catch (cause) {
+    throw new ClientError("MalformedResponse", { cause })
+  }
+}
+
+function isContentType(response: Response, expected: string) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected
+}

packages/client/src/generated/index.ts

@@ -0,0 +1,3 @@
+export { ClientError, type ClientErrorReason } from "./client-error"
+export * as OpenCode from "./client"
+export * from "./types"

packages/client/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./generated/index"
+export type { EventsSubscribeOutput as OpenCodeEvent } from "./generated/types"

packages/client/test/contract-identity.test.ts

@@ -0,0 +1,58 @@
+import { expect, test } from "bun:test"
+import { Schema } from "effect"
+import { AgentV2 } from "@opencode-ai/core/agent"
+import { Location as CoreLocation } from "@opencode-ai/core/location"
+import { ModelV2 } from "@opencode-ai/core/model"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { SessionInput as CoreSessionInput } from "@opencode-ai/core/session/input"
+import { SessionMessage as CoreSessionMessage } from "@opencode-ai/core/session/message"
+import { Prompt as CorePrompt } from "@opencode-ai/core/session/prompt"
+import { Agent } from "@opencode-ai/schema/agent"
+import { Location } from "@opencode-ai/schema/location"
+import { Model } from "@opencode-ai/schema/model"
+import { Project } from "@opencode-ai/schema/project"
+import { Provider } from "@opencode-ai/schema/provider"
+import { Prompt } from "@opencode-ai/schema/prompt"
+import { Session } from "@opencode-ai/schema/session"
+import { SessionInput } from "@opencode-ai/schema/session-input"
+import { SessionMessage } from "@opencode-ai/schema/session-message"
+import { Workspace } from "@opencode-ai/schema/workspace"
+import { Api } from "@opencode-ai/server/api"
+import { compile, emitPromise } from "@opencode-ai/httpapi-codegen"
+import { ClientApi, endpointNames, groupNames, omitEndpoints } from "../src/contract"
+
+test("Core and Server reuse the authoritative Schema and Protocol values", () => {
+  expect(AgentV2.ID).toBe(Agent.ID)
+  expect(CoreLocation.Ref).toBe(Location.Ref)
+  expect(ModelV2.Ref).toBe(Model.Ref)
+  expect(SessionV2.Info).toBe(Session.Info)
+  expect(CoreSessionInput.Admitted).toBe(SessionInput.Admitted)
+  expect(CoreSessionMessage.Message).toBe(SessionMessage.Message)
+  expect(CorePrompt).toBe(Prompt)
+  expect(Api.groups["server.session"].identifier).toBe("server.session")
+  expect(Object.keys(ClientApi.groups)).toEqual(Object.keys(Api.groups))
+  expect(Session.ID.create()).toStartWith("ses_")
+  expect(Project.ID.global).toBe("global")
+  expect(Provider.ID.anthropic).toBe("anthropic")
+  expect(Workspace.ID.create()).toStartWith("wrk_")
+})
+
+test("client and Server contracts generate identically", () => {
+  const server = compile(Api, { groupNames, endpointNames, omitEndpoints })
+  const client = compile(ClientApi, { groupNames, endpointNames, omitEndpoints })
+
+  expect(emitPromise(client)).toEqual(emitPromise(server))
+})
+
+test("shared DTO schemas construct and decode plain objects", () => {
+  const made = Prompt.make({ text: "hello" })
+  const decoded = Schema.decodeUnknownSync(Prompt)({ text: "hello" })
+  const content = Schema.decodeUnknownSync(SessionMessage.AssistantText)({ type: "text", id: "part_1", text: "hi" })
+
+  expect(Object.getPrototypeOf(made)).toBe(Object.prototype)
+  expect(Object.getPrototypeOf(decoded)).toBe(Object.prototype)
+  expect(Object.getPrototypeOf(content)).toBe(Object.prototype)
+  expect(Prompt.ast.annotations?.identifier).toBe("Prompt")
+  expect(SessionMessage.AssistantText.ast.annotations?.identifier).toBe("Session.Message.Assistant.Text")
+  expect(CoreSessionMessage.AssistantText).toBe(SessionMessage.AssistantText)
+})

packages/client/test/effect.test.ts

@@ -0,0 +1,246 @@
+import { expect, test } from "bun:test"
+import { DateTime, Effect, Stream } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
+import { AbsolutePath, Agent, Location, Model, OpenCode, Prompt, Session, SessionMessage } from "../src/effect"
+
+test("sessions.get returns the decoded Effect projection", async () => {
+  const httpClient = HttpClient.make((request) =>
+    Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(session))),
+  )
+  const result = await Effect.gen(function* () {
+    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
+    return yield* client.sessions.get({ sessionID: Session.ID.make("ses_test") })
+  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
+
+  expect(DateTime.toEpochMillis(result.time.created)).toBe(1_717_171_717_000)
+})
+
+test("events.subscribe exposes and decodes the native Effect event stream", async () => {
+  const httpClient = HttpClient.make((request) =>
+    Effect.succeed(
+      HttpClientResponse.fromWeb(
+        request,
+        new Response(
+          `data: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
+            `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
+          { headers: { "content-type": "text/event-stream" } },
+        ),
+      ),
+    ),
+  )
+  const events = await Effect.gen(function* () {
+    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
+    return yield* client.events.subscribe().pipe(Stream.runCollect)
+  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
+
+  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.next.model.switched"])
+  const durable = events[1]
+  if (durable?.type !== "session.next.model.switched") throw new Error("Expected model event")
+  expect(DateTime.toEpochMillis(durable.data.timestamp)).toBe(1_717_171_717_000)
+  expect(durable.durable).toEqual({ aggregateID: "ses_test", seq: 1, version: 1 })
+})
+
+test("events.subscribe terminates on Effect protocol decode failures", async () => {
+  const httpClient = HttpClient.make((request) =>
+    Effect.succeed(
+      HttpClientResponse.fromWeb(
+        request,
+        new Response(`data: {"type":"server.connected"}\n\n`, {
+          headers: { "content-type": "text/event-stream" },
+        }),
+      ),
+    ),
+  )
+  const error = await Effect.gen(function* () {
+    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
+    return yield* client.events.subscribe().pipe(Stream.runCollect, Effect.flip)
+  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
+
+  expect(error._tag).toBe("ClientError")
+})
+
+test("session methods retain decoded Effect inputs and outputs", async () => {
+  const historyQueries: Array<Record<string, string>> = []
+  let historyPage = 0
+  const httpClient = HttpClient.make((request) => {
+    const url = request.url
+    if (url.includes("/event")) {
+      return Effect.succeed(
+        HttpClientResponse.fromWeb(
+          request,
+          new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\n`, {
+            headers: { "content-type": "text/event-stream" },
+          }),
+        ),
+      )
+    }
+    if (url.includes("/history")) {
+      historyPage++
+      historyQueries.push(Object.fromEntries(request.urlParams.params))
+      return Effect.succeed(
+        HttpClientResponse.fromWeb(
+          request,
+          Response.json(
+            historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
+          ),
+        ),
+      )
+    }
+    if (url.includes("/prompt")) {
+      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(admission)))
+    }
+    if (url.includes("/context")) {
+      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ data: [] })))
+    }
+    if (url.includes("/message/")) {
+      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ data: modelSwitchedMessage })))
+    }
+    if (url.endsWith("/api/session/active")) {
+      return Effect.succeed(
+        HttpClientResponse.fromWeb(request, Response.json({ data: { ses_test: { type: "running" } } })),
+      )
+    }
+    if (request.method === "POST" && url.endsWith("/api/session")) {
+      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(session)))
+    }
+    if (request.method === "POST") {
+      return Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status: 204 })))
+    }
+    return Effect.succeed(
+      HttpClientResponse.fromWeb(request, Response.json({ data: [session.data], cursor: { next: "next" } })),
+    )
+  })
+  const result = await Effect.gen(function* () {
+    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
+    const page = yield* client.sessions.list({ limit: 10 })
+    const active = yield* client.sessions.active()
+    const created = yield* client.sessions.create({
+      location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
+    })
+    yield* client.sessions.switchAgent({ sessionID: Session.ID.make("ses_test"), agent: Agent.ID.make("build") })
+    yield* client.sessions.switchModel({
+      sessionID: Session.ID.make("ses_test"),
+      model: Model.Ref.make({ id: "claude", providerID: "anthropic" }),
+    })
+    const admitted = yield* client.sessions.prompt({
+      sessionID: Session.ID.make("ses_test"),
+      prompt: Prompt.make({ text: "Hello" }),
+      resume: false,
+    })
+    yield* client.sessions.compact({ sessionID: Session.ID.make("ses_test") })
+    yield* client.sessions.wait({ sessionID: Session.ID.make("ses_test") })
+    const context = yield* client.sessions.context({ sessionID: Session.ID.make("ses_test") })
+    const history = yield* client.sessions.history({
+      sessionID: Session.ID.make("ses_test"),
+      after: 0,
+      limit: 1,
+    })
+    const historyNext = history.hasMore
+      ? yield* client.sessions.history({
+          sessionID: Session.ID.make("ses_test"),
+          after: history.data.at(-1)?.durable?.seq,
+          limit: 2,
+        })
+      : undefined
+    const events = yield* client.sessions
+      .events({ sessionID: Session.ID.make("ses_test"), after: 0 })
+      .pipe(Stream.runCollect)
+    yield* client.sessions.interrupt({ sessionID: Session.ID.make("ses_test") })
+    const message = yield* client.sessions.message({
+      sessionID: Session.ID.make("ses_test"),
+      messageID: SessionMessage.ID.make("msg_model"),
+    })
+    return { page, active, created, admitted, context, history, historyNext, events, message }
+  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
+
+  expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
+  expect(result.active).toEqual({ ses_test: { type: "running" } })
+  expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
+  expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
+  expect(result.created.id).toBe("ses_test")
+  expect(Object.getPrototypeOf(result.admitted)).toBe(Object.prototype)
+  expect(Object.getPrototypeOf(result.admitted.prompt)).toBe(Object.prototype)
+  expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
+  expect(result.context).toEqual([])
+  expect(DateTime.toEpochMillis(result.history.data[0].data.timestamp)).toBe(1_717_171_717_000)
+  expect(result.history).toEqual(expect.objectContaining({ hasMore: true }))
+  expect(result.historyNext).toEqual({ data: [], hasMore: false })
+  expect(historyQueries[0]).toEqual({ limit: "1", after: "0" })
+  expect(historyQueries[1]).toEqual({ limit: "2", after: "1" })
+  expect(DateTime.toEpochMillis(result.events[0].data.timestamp)).toBe(1_717_171_717_000)
+  expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
+})
+
+test("sessions.history retains the typed SessionNotFoundError", async () => {
+  const httpClient = HttpClient.make((request) =>
+    Effect.succeed(
+      HttpClientResponse.fromWeb(
+        request,
+        Response.json(
+          { _tag: "SessionNotFoundError", sessionID: "ses_missing", message: "Session not found" },
+          { status: 404 },
+        ),
+      ),
+    ),
+  )
+  const error = await Effect.gen(function* () {
+    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
+    return yield* client.sessions
+      .history({
+        sessionID: Session.ID.make("ses_missing"),
+      })
+      .pipe(Effect.flip)
+  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
+
+  expect(error._tag).toBe("SessionNotFoundError")
+})
+
+const session = {
+  data: {
+    id: "ses_test",
+    projectID: "project",
+    cost: 0,
+    tokens: {
+      input: 1,
+      output: 2,
+      reasoning: 3,
+      cache: { read: 4, write: 5 },
+    },
+    time: {
+      created: 1_717_171_717_000,
+      updated: 1_717_171_717_000,
+    },
+    title: "Test",
+    location: { directory: "/tmp/project" },
+  },
+}
+
+const admission = {
+  data: {
+    admittedSeq: 0,
+    id: "msg_test",
+    sessionID: "ses_test",
+    prompt: { text: "Hello" },
+    delivery: "steer",
+    timeCreated: 1_717_171_717_000,
+  },
+}
+
+const modelSwitchedMessage = {
+  id: "msg_model",
+  type: "model-switched",
+  time: { created: 1_717_171_717_000 },
+  model: { id: "claude", providerID: "anthropic" },
+}
+
+const modelSwitchedEvent = {
+  id: "evt_model",
+  type: "session.next.model.switched",
+  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
+  data: {
+    timestamp: 1_717_171_717_000,
+    sessionID: "ses_test",
+    messageID: "msg_model",
+    model: { id: "claude", providerID: "anthropic" },
+  },
+}

packages/client/test/import-boundaries.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test"
+import { realpathSync } from "node:fs"
+import { mkdtemp, rm } from "node:fs/promises"
+import { join, resolve, sep } from "node:path"
+
+const directory = resolve(import.meta.dir, "..")
+const effect = realpathSync(resolve(import.meta.dir, "../node_modules/effect"))
+const schema = resolve(import.meta.dir, "../../schema")
+const protocol = resolve(import.meta.dir, "../../protocol")
+const core = resolve(import.meta.dir, "../../core")
+const server = resolve(import.meta.dir, "../../server")
+
+describe("public import boundaries", () => {
+  test("isolates each public entrypoint", async () => {
+    const root = await bundleInputs("@opencode-ai/client", "browser")
+
+    expect(within(root, effect)).toEqual([])
+    expect(within(root, schema)).toEqual([])
+    expect(within(root, protocol)).toEqual([])
+    expect(within(root, core)).toEqual([])
+    expect(within(root, server)).toEqual([])
+
+    const network = await bundleInputs("@opencode-ai/client/effect", "browser")
+
+    expect(within(network, effect).length).toBeGreaterThan(0)
+    expect(within(network, schema).length).toBeGreaterThan(0)
+    expect(within(network, protocol).length).toBeGreaterThan(0)
+    expect(within(network, core)).toEqual([])
+    expect(within(network, server)).toEqual([])
+  })
+})
+
+async function bundleInputs(specifier: string, target: "browser" | "bun") {
+  const temporary = await mkdtemp(join(import.meta.dir, ".import-boundary-"))
+  const entrypoint = join(temporary, "index.ts")
+  const metafile = join(temporary, "meta.json")
+  try {
+    await Bun.write(entrypoint, `export * from ${JSON.stringify(specifier)}`)
+    const child = Bun.spawn(
+      [
+        process.execPath,
+        "build",
+        entrypoint,
+        `--target=${target}`,
+        "--format=esm",
+        "--packages=bundle",
+        `--metafile=${metafile}`,
+        `--outdir=${join(temporary, "out")}`,
+      ],
+      { cwd: directory, stdout: "pipe", stderr: "pipe" },
+    )
+    const [exitCode, stdout, stderr] = await Promise.all([
+      child.exited,
+      new Response(child.stdout).text(),
+      new Response(child.stderr).text(),
+    ])
+    if (exitCode !== 0) throw new Error(stdout + stderr)
+    const metadata = await Bun.file(metafile).json()
+    return Object.keys(metadata.inputs).map((input) => resolve(directory, input))
+  } finally {
+    await rm(temporary, { recursive: true, force: true })
+  }
+}
+
+function within(inputs: ReadonlyArray<string>, directory: string) {
+  const prefix = directory.endsWith(sep) ? directory : directory + sep
+  return inputs.filter((input) => input === directory || input.startsWith(prefix))
+}

packages/client/test/promise.test.ts

@@ -0,0 +1,255 @@
+import { expect, test } from "bun:test"
+import { isSessionNotFoundError, isUnauthorizedError, OpenCode } from "../src"
+
+test("exposes every standard HTTP API group", () => {
+  const client = OpenCode.make({ baseUrl: "http://localhost:3000" })
+
+  expect(Object.keys(client)).toEqual([
+    "health",
+    "location",
+    "agents",
+    "sessions",
+    "messages",
+    "models",
+    "providers",
+    "integrations",
+    "credentials",
+    "permissions",
+    "files",
+    "commands",
+    "skills",
+    "events",
+    "ptys",
+    "questions",
+    "references",
+    "projectCopies",
+  ])
+  expect(Object.keys(client.messages)).toEqual(["list"])
+  expect(Object.keys(client.integrations)).toEqual([
+    "list",
+    "get",
+    "connectKey",
+    "connectOauth",
+    "attemptStatus",
+    "attemptComplete",
+    "attemptCancel",
+  ])
+  expect(Object.keys(client.files)).toEqual(["list", "find"])
+  expect(Object.keys(client.ptys)).toEqual(["list", "create", "get", "update", "remove"])
+})
+
+test("sessions.get returns the wire projection", async () => {
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input) => {
+      expect(typeof input === "string" ? input : input instanceof URL ? input.href : input.url).toBe(
+        "http://localhost:3000/api/session/ses_test",
+      )
+      return Response.json(session)
+    },
+  })
+
+  const result = await client.sessions.get({ sessionID: "ses_test" })
+
+  expect(result.time.created).toBe(1_717_171_717_000)
+})
+
+test("events.subscribe exposes the Promise event stream wire projection", async () => {
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async () =>
+      new Response(
+        `: heartbeat\n\ndata: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
+          `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
+        { headers: { "content-type": "text/event-stream" } },
+      ),
+  })
+  const events = []
+  for await (const event of client.events.subscribe()) events.push(event)
+
+  expect(events).toEqual([{ id: "evt_connected", type: "server.connected", data: {} }, modelSwitchedEvent])
+  expect(events[1]?.type === "session.next.model.switched" && events[1].data.timestamp).toBe(1_717_171_717_000)
+})
+
+test("events.subscribe terminates on malformed Promise SSE data", async () => {
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async () => new Response("data: {not-json}\n\n", { headers: { "content-type": "text/event-stream" } }),
+  })
+
+  await expect(client.events.subscribe()[Symbol.asyncIterator]().next()).rejects.toMatchObject({
+    name: "ClientError",
+    reason: "MalformedResponse",
+  })
+})
+
+test("session methods use the public HTTP contract", async () => {
+  const requests: Array<{ url: string; init?: RequestInit }> = []
+  let historyPage = 0
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url
+      requests.push({ url, init })
+      if (url.includes("/event")) {
+        return new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\n`, {
+          headers: { "content-type": "text/event-stream" },
+        })
+      }
+      if (url.includes("/history")) {
+        historyPage++
+        return Response.json(
+          historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
+        )
+      }
+      if (url.includes("/prompt")) return Response.json(admission)
+      if (url.includes("/context")) return Response.json({ data: [] })
+      if (url.includes("/message/")) return Response.json({ data: modelSwitchedMessage })
+      if (url.endsWith("/api/session/active")) return Response.json({ data: { ses_test: { type: "running" } } })
+      if (init?.method === "POST" && url.endsWith("/api/session")) return Response.json(session)
+      if (init?.method === "POST") return new Response(null, { status: 204 })
+      return Response.json({ data: [session.data], cursor: { next: "next" } })
+    },
+  })
+
+  const page = await client.sessions.list({ limit: 10, order: "desc" })
+  const active = await client.sessions.active()
+  const created = await client.sessions.create({ location: { directory: "/tmp/project" } })
+  await client.sessions.switchAgent({ sessionID: "ses_test", agent: "build" })
+  await client.sessions.switchModel({
+    sessionID: "ses_test",
+    model: { id: "claude", providerID: "anthropic" },
+  })
+  const admitted = await client.sessions.prompt({
+    sessionID: "ses_test",
+    prompt: { text: "Hello" },
+    resume: false,
+  })
+  await client.sessions.compact({ sessionID: "ses_test" })
+  await client.sessions.wait({ sessionID: "ses_test" })
+  const context = await client.sessions.context({ sessionID: "ses_test" })
+  const history = await client.sessions.history({ sessionID: "ses_test", after: 0, limit: 1 })
+  const historyAfter = history.data.at(-1)?.durable?.seq
+  const historyNext = history.hasMore
+    ? await client.sessions.history({ sessionID: "ses_test", after: historyAfter, limit: 2 })
+    : undefined
+  const events = []
+  for await (const event of client.sessions.events({ sessionID: "ses_test", after: 0 })) events.push(event)
+  await client.sessions.interrupt({ sessionID: "ses_test" })
+  const message = await client.sessions.message({ sessionID: "ses_test", messageID: "msg_model" })
+
+  expect(page.cursor.next).toBe("next")
+  expect(active).toEqual({ ses_test: { type: "running" } })
+  expect(created.id).toBe("ses_test")
+  expect(admitted.id).toBe("msg_test")
+  expect(context).toEqual([])
+  expect(history).toEqual({ data: [modelSwitchedEvent], hasMore: true })
+  expect(historyNext).toEqual({ data: [], hasMore: false })
+  expect(events).toEqual([modelSwitchedEvent])
+  expect(message).toEqual(modelSwitchedMessage)
+  expect(requests.map((request) => [request.init?.method, request.url])).toEqual([
+    ["GET", "http://localhost:3000/api/session?limit=10&order=desc"],
+    ["GET", "http://localhost:3000/api/session/active"],
+    ["POST", "http://localhost:3000/api/session"],
+    ["POST", "http://localhost:3000/api/session/ses_test/agent"],
+    ["POST", "http://localhost:3000/api/session/ses_test/model"],
+    ["POST", "http://localhost:3000/api/session/ses_test/prompt"],
+    ["POST", "http://localhost:3000/api/session/ses_test/compact"],
+    ["POST", "http://localhost:3000/api/session/ses_test/wait"],
+    ["GET", "http://localhost:3000/api/session/ses_test/context"],
+    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=1&after=0"],
+    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=2&after=1"],
+    ["GET", "http://localhost:3000/api/session/ses_test/event?after=0"],
+    ["POST", "http://localhost:3000/api/session/ses_test/interrupt"],
+    ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
+  ])
+  const body = requests.find((request) => request.url.endsWith("/api/session/ses_test/prompt"))?.init?.body
+  if (typeof body !== "string") throw new Error("Expected JSON request body")
+  expect(JSON.parse(body)).toEqual({
+    prompt: { text: "Hello" },
+    resume: false,
+  })
+})
+
+test("middleware errors remain declared client errors", async () => {
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async () =>
+      Response.json({ _tag: "UnauthorizedError", message: "Authentication required" }, { status: 401 }),
+  })
+
+  try {
+    await client.sessions.create({})
+    throw new Error("Expected request to fail")
+  } catch (error) {
+    expect(isUnauthorizedError(error)).toBe(true)
+  }
+})
+
+test("sessions.history decodes SessionNotFoundError", async () => {
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async () =>
+      Response.json(
+        { _tag: "SessionNotFoundError", sessionID: "ses_missing", message: "Session not found" },
+        { status: 404 },
+      ),
+  })
+
+  try {
+    await client.sessions.history({ sessionID: "ses_missing" })
+    throw new Error("Expected request to fail")
+  } catch (error) {
+    expect(isSessionNotFoundError(error)).toBe(true)
+  }
+})
+
+const session = {
+  data: {
+    id: "ses_test",
+    projectID: "project",
+    cost: 0,
+    tokens: {
+      input: 1,
+      output: 2,
+      reasoning: 3,
+      cache: { read: 4, write: 5 },
+    },
+    time: {
+      created: 1_717_171_717_000,
+      updated: 1_717_171_717_000,
+    },
+    title: "Test",
+    location: { directory: "/tmp/project" },
+  },
+}
+
+const admission = {
+  data: {
+    admittedSeq: 0,
+    id: "msg_test",
+    sessionID: "ses_test",
+    prompt: { text: "Hello" },
+    delivery: "steer",
+    timeCreated: 1_717_171_717_000,
+  },
+}
+
+const modelSwitchedMessage = {
+  id: "msg_model",
+  type: "model-switched",
+  time: { created: 1_717_171_717_000 },
+  model: { id: "claude", providerID: "anthropic" },
+}
+
+const modelSwitchedEvent = {
+  id: "evt_model",
+  type: "session.next.model.switched",
+  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
+  data: {
+    timestamp: 1_717_171_717_000,
+    sessionID: "ses_test",
+    messageID: "msg_model",
+    model: { id: "claude", providerID: "anthropic" },
+  },
+}

packages/codemode/src/codemode.ts

@@ -0,0 +1,159 @@
+import { Effect, Schema } from "effect"
+import { executeWithLimits } from "./interpreter/runtime.js"
+import { type HostTools, type Services, type ToolDescription, ToolRuntime } from "./tool-runtime.js"
+import type { Definition } from "./tool.js"
+
+/** A tool call admitted during an execution. */
+export type { ToolCall, ToolCallEnded, ToolCallHooks, ToolCallStarted, ToolDescription } from "./tool-runtime.js"
+
+/** Resource budgets enforced independently during each CodeMode program execution. */
+export type ExecutionLimits = {
+  /** Maximum wall-clock execution time in milliseconds. No default: absent means no timeout. */
+  readonly timeoutMs?: number
+  /** Maximum number of tool calls admitted by the runtime. No default: absent means unlimited. */
+  readonly maxToolCalls?: number
+  /** Maximum UTF-8 bytes of model-facing output. No default: absent means no truncation. */
+  readonly maxOutputBytes?: number
+}
+
+/** Controls how much of the tool catalog is inlined in agent instructions. */
+export type DiscoveryOptions = {
+  /** Approximate token budget (chars/4, default 2000) for full catalog entries. */
+  readonly catalogBudget?: number
+}
+
+type ToolTree<R = never> = {
+  readonly [name: string]: Definition<R> | ToolTree<R>
+}
+
+export type ResolvedExecutionLimits = {
+  readonly timeoutMs: number | undefined
+  readonly maxToolCalls: number | undefined
+  readonly maxOutputBytes: number | undefined
+}
+
+/** Options for one CodeMode execution. */
+export type ExecuteOptions<Tools extends Record<string, unknown> = {}> = {
+  /** Source for one program in the supported JavaScript subset. */
+  code: string
+  /** Explicit tool tree exposed to the program as `tools`. */
+  tools?: Tools & ToolTree<Services<Tools>>
+  /** Per-execution overrides for the default resource limits. */
+  limits?: ExecutionLimits
+  /** Observes decoded tool input immediately before tool execution. */
+  onToolCallStart?: (call: ToolRuntime.ToolCallStarted) => Effect.Effect<void, never, Services<Tools>>
+  /** Observes each admitted tool call as it settles, with outcome and duration. */
+  onToolCallEnd?: (call: ToolRuntime.ToolCallEnded) => Effect.Effect<void, never, Services<Tools>>
+}
+
+/** A JSON value that can cross the confined interpreter boundary. */
+export type DataValue = Schema.Json
+
+/** Configuration shared by `CodeMode.make` and `CodeMode.execute`. */
+export type Options<Tools extends Record<string, unknown> = {}> = Omit<ExecuteOptions<Tools>, "code"> & {
+  /** Progressive-disclosure configuration for the agent-facing tool catalog. */
+  readonly discovery?: DiscoveryOptions
+}
+
+/** Schema for a host tool input containing CodeMode source. */
+export const Input = Schema.Struct({ code: Schema.String })
+export type Input = typeof Input.Type
+
+export const DiagnosticKind = Schema.Literals([
+  "ParseError",
+  "UnsupportedSyntax",
+  "UnknownTool",
+  "InvalidToolInput",
+  "InvalidToolOutput",
+  "InvalidDataValue",
+  "ToolCallLimitExceeded",
+  "TimeoutExceeded",
+  "ToolFailure",
+  "ExecutionFailure",
+])
+/** Stable categories produced by program, schema, tool, and limit failures. */
+export type DiagnosticKind = typeof DiagnosticKind.Type
+
+export const Diagnostic = Schema.Struct({
+  kind: DiagnosticKind,
+  message: Schema.String,
+  location: Schema.optionalKey(Schema.Struct({ line: Schema.Number, column: Schema.Number })),
+  suggestions: Schema.optionalKey(Schema.Array(Schema.String)),
+})
+/** A normalized program diagnostic safe to return across an agent tool boundary. */
+export type Diagnostic = typeof Diagnostic.Type
+
+const ToolCallSchema = Schema.Struct({ name: Schema.String })
+export const Success = Schema.Struct({
+  ok: Schema.Literal(true),
+  value: Schema.Json,
+  logs: Schema.optionalKey(Schema.Array(Schema.String)),
+  truncated: Schema.optionalKey(Schema.Boolean),
+  toolCalls: Schema.Array(ToolCallSchema),
+})
+/** Successful execution after the result has crossed the plain-data boundary. */
+export type Success = typeof Success.Type
+
+export const Failure = Schema.Struct({
+  ok: Schema.Literal(false),
+  error: Diagnostic,
+  logs: Schema.optionalKey(Schema.Array(Schema.String)),
+  truncated: Schema.optionalKey(Schema.Boolean),
+  toolCalls: Schema.Array(ToolCallSchema),
+})
+/** Failed execution with calls admitted before the diagnostic was produced. */
+export type Failure = typeof Failure.Type
+
+/** Schema for the structured success or diagnostic returned by CodeMode execution. */
+export const Result = Schema.Union([Success, Failure])
+/** Result of executing a CodeMode program. Program failures are data, not Effect failures. */
+export type Result = typeof Result.Type
+
+/** Reusable confined runtime over one explicit tool tree. */
+export type Runtime<R = never> = {
+  readonly catalog: () => ReadonlyArray<ToolDescription>
+  readonly instructions: () => string
+  readonly execute: (code: string) => Effect.Effect<Result, never, R>
+}
+
+const validateLimit = <Value extends number | undefined>(
+  name: keyof ExecutionLimits,
+  value: Value,
+  minimum: number,
+): Value => {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < minimum)) {
+    throw new RangeError(`${name} must be a safe integer greater than or equal to ${minimum}.`)
+  }
+  return value
+}
+
+const resolveExecutionLimits = (limits?: ExecutionLimits): ResolvedExecutionLimits => ({
+  timeoutMs: validateLimit("timeoutMs", limits?.timeoutMs, 1),
+  maxToolCalls: validateLimit("maxToolCalls", limits?.maxToolCalls, 0),
+  maxOutputBytes: validateLimit("maxOutputBytes", limits?.maxOutputBytes, 0),
+})
+
+/** Executes one Effect-native CodeMode program without constructing a reusable runtime. */
+export const execute = <const Tools extends Record<string, unknown>>(
+  options: ExecuteOptions<Tools>,
+): Effect.Effect<Result, never, Services<Tools>> => {
+  const tools = (options.tools ?? {}) as HostTools<Services<Tools>>
+  ToolRuntime.assertValidTools(tools)
+  return executeWithLimits(options, resolveExecutionLimits(options.limits), ToolRuntime.searchIndex(tools))
+}
+
+/** Creates an Effect-native runtime over explicit, schema-described tools. */
+export const make = <const Tools extends Record<string, unknown> = {}>(
+  options: Options<Tools> = {} as Options<Tools>,
+): Runtime<Services<Tools>> => {
+  const tools = (options.tools ?? {}) as HostTools<Services<Tools>>
+  ToolRuntime.assertValidTools(tools)
+  const limits = resolveExecutionLimits(options.limits)
+  const prepared = ToolRuntime.prepare(tools, options.discovery?.catalogBudget)
+
+  return {
+    catalog: () => prepared.catalog,
+    instructions: () => prepared.instructions,
+    execute: (code) => executeWithLimits<Tools>({ ...options, code }, limits, prepared.searchIndex),
+  }
+}

packages/codemode/src/index.ts

@@ -0,0 +1,4 @@
+export * as CodeMode from "./codemode.js"
+export * as Tool from "./tool.js"
+export * as OpenAPI from "./openapi/index.js"
+export { ToolError, toolError } from "./tool-error.js"

packages/codemode/src/interpreter/model.ts

@@ -0,0 +1,201 @@
+import type { SafeObject } from "../tool-runtime.js"
+import type { SandboxURL } from "../values.js"
+
+export type SourcePosition = {
+  line: number
+  column: number
+}
+
+export type SourceLocation = {
+  start: SourcePosition
+  end: SourcePosition
+}
+
+export type AstNode = {
+  type: string
+  loc?: SourceLocation
+  [key: string]: unknown
+}
+
+export type ProgramNode = AstNode & {
+  type: "Program"
+  body: Array<AstNode>
+}
+
+export type Binding = {
+  mutable: boolean
+  value: unknown
+  initialized?: boolean
+}
+
+export type StatementResult =
+  | { kind: "none" }
+  | { kind: "value"; value: unknown }
+  | { kind: "return"; value: unknown }
+  | { kind: "break" }
+  | { kind: "continue" }
+
+export type MemberReference = {
+  target: SafeObject | Array<unknown> | SandboxURL
+  key: string | number
+}
+
+export class CodeModeFunction {
+  constructor(
+    readonly parameters: ReadonlyArray<AstNode>,
+    readonly body: AstNode,
+    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>,
+  ) {}
+}
+
+export class IntrinsicReference {
+  constructor(
+    readonly receiver: unknown,
+    readonly name: string,
+  ) {}
+}
+
+export class ComputedValue {
+  constructor(readonly value: unknown) {}
+}
+
+export class PromiseNamespace {}
+
+export type PromiseMethodName = "all" | "allSettled" | "race" | "resolve" | "reject"
+
+export class PromiseMethodReference {
+  constructor(readonly name: PromiseMethodName) {}
+}
+
+export type GlobalNamespaceName =
+  | "Object"
+  | "Math"
+  | "JSON"
+  | "Array"
+  | "console"
+  | "Date"
+  | "RegExp"
+  | "Map"
+  | "Set"
+  | "URL"
+  | "URLSearchParams"
+
+export class GlobalNamespace {
+  constructor(readonly name: GlobalNamespaceName) {}
+}
+
+export class GlobalMethodReference {
+  constructor(
+    readonly namespace: GlobalNamespaceName | "Number" | "String",
+    readonly name: string,
+  ) {}
+}
+
+export class CoercionFunction {
+  constructor(readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat") {}
+}
+
+export class UriFunction {
+  constructor(readonly name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent") {}
+}
+
+export class ProgramThrow {
+  constructor(readonly value: unknown) {}
+}
+
+export class ErrorConstructorReference {
+  constructor(readonly name: string) {}
+}
+
+export type DiagnosticKind =
+  | "ParseError"
+  | "UnsupportedSyntax"
+  | "UnknownTool"
+  | "InvalidToolInput"
+  | "InvalidToolOutput"
+  | "InvalidDataValue"
+  | "ToolCallLimitExceeded"
+  | "TimeoutExceeded"
+  | "ToolFailure"
+  | "ExecutionFailure"
+
+export const OptionalShortCircuit: unique symbol = Symbol("codemode.optional-short-circuit")
+
+export const supportedSyntaxMessage =
+  "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, and Promise.all/allSettled/race/resolve/reject over arrays mixing promises and plain values for parallel tool calls (promise chaining with .then/.catch is not supported - use await with try/catch)."
+
+export class InterpreterRuntimeError extends Error {
+  readonly node?: AstNode
+  errorName: string = "Error"
+
+  constructor(
+    message: string,
+    node?: AstNode,
+    readonly kind: DiagnosticKind = "ExecutionFailure",
+    readonly suggestions?: ReadonlyArray<string>,
+  ) {
+    super(message)
+    this.name = "InterpreterRuntimeError"
+    if (node) this.node = node
+  }
+
+  as(errorName: string): this {
+    this.errorName = errorName
+    return this
+  }
+}
+
+export const unsupportedSyntax = (kind: string, node: AstNode): InterpreterRuntimeError =>
+  new InterpreterRuntimeError(
+    `Syntax '${kind}' is not supported in CodeMode. ${supportedSyntaxMessage}`,
+    node,
+    "UnsupportedSyntax",
+    [supportedSyntaxMessage],
+  )
+
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null
+
+export const asNode = (value: unknown, context: string): AstNode => {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`)
+  }
+  return value as AstNode
+}
+
+export const getArray = (node: AstNode, key: string): Array<unknown> => {
+  const value = node[key]
+  if (!Array.isArray(value)) throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node)
+  return value
+}
+
+export const getString = (node: AstNode, key: string): string => {
+  const value = node[key]
+  if (typeof value !== "string") throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node)
+  return value
+}
+
+export const getBoolean = (node: AstNode, key: string): boolean => {
+  const value = node[key]
+  if (typeof value !== "boolean") throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node)
+  return value
+}
+
+export const getOptionalNode = (node: AstNode, key: string): AstNode | undefined => {
+  const value = node[key]
+  if (value === undefined || value === null) return undefined
+  return asNode(value, key)
+}
+
+export const getNode = (node: AstNode, key: string): AstNode => asNode(node[key], key)
+
+export const sourceLocation = (node: AstNode): { readonly line: number; readonly column: number } => ({
+  line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
+  column: Math.max(1, (node.loc?.start.column ?? 4) - 3),
+})
+
+export const formatLocation = (node?: AstNode): string => {
+  if (!node?.loc) return ""
+  const location = sourceLocation(node)
+  return ` (line ${location.line}, col ${location.column})`
+}

packages/codemode/src/openapi/TODO.md

@@ -0,0 +1,19 @@
+# OpenAPI Follow-ups
+
+The initial adapter intentionally skips operations it cannot execute correctly. Future work may add:
+
+- Cookie parameters, authentication, and cookie-header merging.
+- Matrix, label, space-delimited, pipe-delimited, `allowReserved`, and parameter `content` serialization.
+- External references and complete nested `$defs` support.
+- Relative or templated server URLs and server variables.
+- Base URLs containing query strings or fragments.
+- Runtime response-schema validation and full content negotiation.
+- Binary response values and explicit byte-oriented return types.
+- Request/response projection for `readOnly` and `writeOnly` properties.
+- SSE, WebSocket, and other streaming transports.
+- Recovery of responses rejected by a status-filtering `HttpClient`.
+- Configurable request and response size limits.
+- Adapter-enforced redirect policy independent of the supplied `HttpClient`.
+- Strict UTF-8 and empty-body validation for JSON responses.
+- Compile-time rejection of parameter schemas with nested values unsupported by their serialization style; runtime rejects them before auth resolution.
+- Complete malformed-security-scheme validation and broader auth-combination coverage.

packages/codemode/src/openapi/index.ts

@@ -0,0 +1,130 @@
+import { HttpClient } from "effect/unstable/http"
+import { make, type Definition } from "../tool.js"
+import { invoke } from "./runtime.js"
+import {
+  componentDefinitions,
+  inputSchema,
+  isRecord,
+  methods,
+  nonEmptyString,
+  operationInput,
+  operationOutput,
+  operationPath,
+  operationSecurityRequirements,
+  securityRequirements,
+  securitySchemes,
+  specServerUrl,
+  validateBaseUrl,
+} from "./spec.js"
+import type { Operation, Options, Result, Skipped, Tools } from "./types.js"
+
+export type {
+  AuthResolver,
+  Credential,
+  Document,
+  Operation,
+  Options,
+  Result,
+  SecurityScheme,
+  Skipped,
+  Tools,
+} from "./types.js"
+
+/**
+ * Builds a CodeMode tool subtree from an OpenAPI 3.x document, one tool per
+ * operation. Auth is resolved host-side via `auth.resolve` and never
+ * model-visible. Tools require `HttpClient.HttpClient`; unrepresentable
+ * operations land in `skipped`.
+ */
+export const fromSpec = (options: Options): Result => {
+  const document = options.spec
+  const schemes = securitySchemes(document)
+  const defaultSecurity = securityRequirements(document.security)
+  const definitions = componentDefinitions(document)
+  const paths = isRecord(document.paths) ? document.paths : {}
+  const used = new Set<string>()
+  const namespaces = new Set<string>()
+  const skipped: Array<Skipped> = []
+  const tools = Object.create(null) as Tools
+
+  for (const [path, pathValue] of Object.entries(paths)) {
+    if (!isRecord(pathValue)) continue
+    for (const [method, operationValue] of Object.entries(pathValue)) {
+      if (!methods.has(method) || !isRecord(operationValue)) continue
+      const segments = operationPath(method, path, operationValue, used, namespaces)
+      const operation: Operation = {
+        operationId: nonEmptyString(operationValue.operationId),
+        method: method.toUpperCase(),
+        path,
+        summary: nonEmptyString(operationValue.summary),
+        description: nonEmptyString(operationValue.description),
+      }
+      const output = operationOutput(document, operationValue, definitions)
+      if (!output.ok) {
+        skipped.push({ method: operation.method, path, reason: output.reason })
+        continue
+      }
+
+      const resolvedBaseUrl = (() => {
+        if (options.baseUrl !== undefined) return validateBaseUrl(options.baseUrl)
+        if (operationValue.servers !== undefined) return specServerUrl(operationValue)
+        if (pathValue.servers !== undefined) return specServerUrl(pathValue)
+        return specServerUrl(document)
+      })()
+      if (!resolvedBaseUrl.ok) {
+        skipped.push({ method: operation.method, path, reason: resolvedBaseUrl.reason })
+        continue
+      }
+      const parsedInput = operationInput(document, pathValue, operationValue)
+      if (!parsedInput.ok) {
+        skipped.push({ method: operation.method, path, reason: parsedInput.reason })
+        continue
+      }
+      const input = parsedInput.value
+
+      const security = operationSecurityRequirements(operationValue.security, defaultSecurity, schemes)
+      if (!security.ok) {
+        skipped.push({ method: operation.method, path, reason: security.reason })
+        continue
+      }
+      const plan = {
+        operation,
+        url: `${resolvedBaseUrl.value.replace(/\/+$/, "")}${path}`,
+        fields: input.fields,
+        body: input.body,
+        security: security.value,
+        schemes,
+        auth: options.auth,
+        headers: options.headers ?? {},
+      }
+      used.add(segments.join("."))
+      for (const index of segments.slice(0, -1).keys()) namespaces.add(segments.slice(0, index + 1).join("."))
+      setTool(
+        tools,
+        segments,
+        make({
+          description: operation.description ?? operation.summary ?? `${operation.method} ${path}`,
+          input: inputSchema(input.fields, definitions),
+          output: output.value,
+          run: (input) => invoke(plan, input),
+        }),
+      )
+    }
+  }
+
+  return { tools, skipped }
+}
+
+const setTool = (tools: Tools, path: ReadonlyArray<string>, definition: Definition<HttpClient.HttpClient>): void => {
+  const [head, ...rest] = path
+  if (head === undefined) return
+  if (rest.length === 0) {
+    tools[head] = definition
+    return
+  }
+  const child = tools[head]
+  if (child === undefined || !isRecord(child) || child._tag === "CodeModeTool") {
+    tools[head] = Object.create(null) as Tools
+  }
+  setTool(tools[head] as Tools, rest, definition)
+}

packages/codemode/src/openapi/runtime.ts

@@ -0,0 +1,326 @@
+import { Effect, Option, Schema, Stream } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse, type HttpMethod } from "effect/unstable/http"
+import { ToolError, toolError } from "../tool-error.js"
+import { isRecord, own } from "./spec.js"
+import type { AppliedAuth, Credential, Plan, SecurityScheme } from "./types.js"
+
+const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+const maxErrorBodyChars = 1_024
+const maxResponseBodyBytes = 50 * 1024 * 1024
+
+export const invoke = (plan: Plan, input: unknown): Effect.Effect<unknown, unknown, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const value = isRecord(input) ? input : {}
+
+    let request = yield* buildRequest(plan, value)
+
+    const auth = yield* resolveAuth(plan)
+    for (const [name, item] of Object.entries(auth.query)) {
+      request = HttpClientRequest.setUrlParam(request, name, item)
+    }
+    request = HttpClientRequest.setHeaders(request, auth.headers)
+
+    const client = yield* HttpClient.HttpClient
+    const response = yield* client
+      .execute(request)
+      .pipe(
+        Effect.catch((cause) =>
+          Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} failed: transport error`, cause)),
+        ),
+      )
+    const text = yield* readResponseBody(response, plan)
+    const mediaType = response.headers["content-type"]?.split(";")[0]?.trim().toLowerCase()
+    const json = mediaType === "application/json" || mediaType?.endsWith("+json") === true
+    const decoded = text === "" ? Option.some(null) : json ? decodeJson(text) : Option.none()
+    const parsed = json ? Option.getOrElse(decoded, () => text) : text === "" ? null : text
+    if (response.status < 200 || response.status >= 300) {
+      const rendered = typeof parsed === "string" ? parsed : (JSON.stringify(parsed) ?? "")
+      const summary =
+        rendered === "" || rendered === "null"
+          ? "no response body"
+          : rendered.length > maxErrorBodyChars
+            ? `${rendered.slice(0, maxErrorBodyChars)}...`
+            : rendered
+      return yield* Effect.fail(
+        toolError(`${plan.operation.method} ${plan.operation.path} failed with HTTP ${response.status}: ${summary}`),
+      )
+    }
+    if (json && Option.isNone(decoded)) {
+      return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} returned malformed JSON.`))
+    }
+    return parsed
+  })
+
+const buildRequest = (
+  plan: Plan,
+  input: Readonly<Record<string, unknown>>,
+): Effect.Effect<HttpClientRequest.HttpClientRequest, ToolError> =>
+  Effect.gen(function* () {
+    // Validate every model-controlled value before auth resolution, which may refresh tokens.
+    const url = buildUrl(plan, input)
+    if (url instanceof ToolError) return yield* Effect.fail(url)
+    const missing = plan.fields.find(
+      (field) => field.required && field.location !== "path" && own(input, field.inputName) === undefined,
+    )
+    if (missing !== undefined) {
+      const label = missing.location === "body" ? "body field" : `${missing.location} parameter`
+      return yield* Effect.fail(toolError(`Missing required ${label} '${missing.inputName}'.`))
+    }
+
+    let request = HttpClientRequest.make(plan.operation.method as HttpMethod.HttpMethod)(url)
+    for (const field of plan.fields) {
+      if (field.location !== "query") continue
+      const item = own(input, field.inputName)
+      if (item === undefined) continue
+      const serialized = serializeQuery(request, field, item)
+      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
+      request = serialized
+    }
+
+    // Host headers first, then declared header parameters.
+    request = HttpClientRequest.setHeaders(request, plan.headers)
+    for (const field of plan.fields) {
+      if (field.location !== "header") continue
+      const item = own(input, field.inputName)
+      if (item === undefined) continue
+      const serialized = serializeSimple(field, item, String)
+      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
+      request = HttpClientRequest.setHeader(request, field.name, serialized)
+    }
+
+    const setBody = (value: unknown, mediaType: string) =>
+      HttpClientRequest.bodyJson(request, value).pipe(
+        Effect.map((next) => HttpClientRequest.setHeader(next, "content-type", mediaType)),
+        Effect.mapError((cause) =>
+          toolError(`Invalid JSON body for ${plan.operation.method} ${plan.operation.path}.`, cause),
+        ),
+      )
+    if (plan.body?.mode === "value") {
+      const field = plan.fields.find((field) => field.location === "body")
+      const body = field === undefined ? undefined : own(input, field.inputName)
+      if (body !== undefined) request = yield* setBody(body, plan.body.mediaType)
+    }
+    if (plan.body?.mode === "object") {
+      const entries = plan.fields.flatMap((field) => {
+        if (field.location !== "body") return []
+        const item = own(input, field.inputName)
+        return item === undefined ? [] : [[field.name, item] as const]
+      })
+      if (plan.body.required || entries.length > 0) {
+        request = yield* setBody(Object.fromEntries(entries), plan.body.mediaType)
+      }
+    }
+    return request
+  })
+
+const resolveAuth = (plan: Plan): Effect.Effect<AppliedAuth, unknown> =>
+  Effect.gen(function* () {
+    const none: AppliedAuth = { headers: {}, query: {} }
+    if (plan.security.length === 0) return none
+
+    const unavailable: Array<string> = []
+    alternatives: for (const requirement of plan.security) {
+      const names = Object.keys(requirement)
+      if (names.length === 0) return none
+      const credentials: Array<readonly [string, SecurityScheme, Credential]> = []
+      for (const name of names) {
+        const scheme = own(plan.schemes, name)
+        if (scheme === undefined || plan.auth === undefined) {
+          unavailable.push(name)
+          continue alternatives
+        }
+        const credential = yield* plan.auth.resolve({
+          name,
+          definition: scheme,
+          scopes: requirement[name] ?? [],
+          operation: plan.operation,
+        })
+        if (credential === undefined) {
+          unavailable.push(name)
+          continue alternatives
+        }
+        credentials.push([name, scheme, credential])
+      }
+      const applied = applyCredentials(credentials)
+      return applied instanceof ToolError ? yield* Effect.fail(applied) : applied
+    }
+
+    return yield* Effect.fail(
+      toolError(
+        `${plan.operation.method} ${plan.operation.path} requires authentication; no credential available for: ${[...new Set(unavailable)].join(", ")}.`,
+      ),
+    )
+  })
+
+const applyCredentials = (
+  credentials: ReadonlyArray<readonly [string, SecurityScheme, Credential]>,
+): AppliedAuth | ToolError => {
+  const headers = new Map<string, string>()
+  const query = new Map<string, string>()
+  const add = (carrier: "header" | "query", name: string, value: string): ToolError | undefined => {
+    const target = carrier === "header" ? headers : query
+    if (target.has(name)) return toolError(`Authentication resolves multiple credentials for ${carrier} '${name}'.`)
+    target.set(name, value)
+  }
+  for (const [name, definition, credential] of credentials) {
+    if (credential.type === "bearer") {
+      const duplicate = add("header", "authorization", `Bearer ${credential.token}`)
+      if (duplicate !== undefined) return duplicate
+      continue
+    }
+    if (credential.type === "basic") {
+      // Buffer instead of btoa: btoa throws on non-Latin-1 credentials.
+      const duplicate = add(
+        "header",
+        "authorization",
+        `Basic ${Buffer.from(`${credential.username}:${credential.password}`, "utf8").toString("base64")}`,
+      )
+      if (duplicate !== undefined) return duplicate
+      continue
+    }
+    if (credential.type === "header") {
+      const duplicate = add("header", credential.name.toLowerCase(), credential.value)
+      if (duplicate !== undefined) return duplicate
+      continue
+    }
+    // apiKey: the carrier comes from the scheme declaration.
+    if (definition.type !== "apiKey") {
+      return toolError(
+        `Security scheme '${name}' is not an apiKey scheme; resolve a bearer, basic, or header credential for it.`,
+      )
+    }
+    if (definition.in === "cookie") return toolError(`Cookie authentication '${name}' is not supported.`)
+    const parameter = definition.in === "header" ? definition.name.toLowerCase() : definition.name
+    const duplicate = add(definition.in, parameter, credential.value)
+    if (duplicate !== undefined) return duplicate
+  }
+  return { headers: Object.fromEntries(headers), query: Object.fromEntries(query) }
+}
+
+const buildUrl = (plan: Plan, input: Readonly<Record<string, unknown>>): string | ToolError => {
+  let url = plan.url
+  for (const field of plan.fields) {
+    if (field.location !== "path") continue
+    const item = own(input, field.inputName)
+    if (item === undefined) {
+      return toolError(`Missing required path parameter '${field.inputName}'.`)
+    }
+    const fieldValue = serializeSimple(field, item, (value) =>
+      encodeURIComponent(value).replace(
+        /[!'()*]/g,
+        (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`,
+      ),
+    )
+    if (fieldValue instanceof ToolError) return fieldValue
+    // '.'/'..' survive encoding and URL normalization collapses them, letting a
+    // model-supplied value retarget the request to a different endpoint.
+    if (fieldValue === "" || fieldValue === "." || fieldValue === "..") {
+      return toolError(`Invalid path parameter '${field.inputName}'.`)
+    }
+    url = url.replaceAll(`{${field.name}}`, fieldValue)
+  }
+  const unresolved = url.match(/\{[^{}]+\}/)
+  if (unresolved !== null) return toolError(`Unresolved path parameter ${unresolved[0]}.`)
+  return url
+}
+
+const serializeSimple = (
+  field: Plan["fields"][number],
+  value: unknown,
+  encode: (value: string) => string,
+): string | ToolError => {
+  const scalar = (item: unknown): string | ToolError =>
+    item !== null && typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean"
+      ? toolError(`Parameter '${field.inputName}' contains an unsupported nested value.`)
+      : encode(String(item))
+  if (Array.isArray(value)) {
+    const items = value.map(scalar)
+    const invalid = items.find((item): item is ToolError => item instanceof ToolError)
+    return invalid ?? items.join(",")
+  }
+  if (!isRecord(value)) return scalar(value)
+  const entries = Object.entries(value).flatMap<string | ToolError>(([name, item]) => {
+    const rendered = scalar(item)
+    if (rendered instanceof ToolError) return [rendered]
+    return field.explode ? [`${encode(name)}=${rendered}`] : [encode(name), rendered]
+  })
+  const invalid = entries.find((item): item is ToolError => item instanceof ToolError)
+  return invalid ?? entries.join(",")
+}
+
+const serializeQuery = (
+  request: HttpClientRequest.HttpClientRequest,
+  field: Plan["fields"][number],
+  value: unknown,
+): HttpClientRequest.HttpClientRequest | ToolError => {
+  if (field.style === "deepObject") {
+    if (!isRecord(value)) return toolError(`Deep-object parameter '${field.inputName}' must be an object.`)
+    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
+      if (current instanceof ToolError) return current
+      if (item === undefined || (item !== null && typeof item === "object")) {
+        return toolError(`Deep-object parameter '${field.inputName}' contains an unsupported nested value.`)
+      }
+      return HttpClientRequest.appendUrlParam(current, `${field.name}[${name}]`, String(item))
+    }, request)
+  }
+  if (Array.isArray(value)) {
+    const rendered = serializeSimple(field, value, String)
+    if (rendered instanceof ToolError) return rendered
+    if (!field.explode) return HttpClientRequest.appendUrlParam(request, field.name, rendered)
+    if (value.some((item) => item === undefined || (item !== null && typeof item === "object"))) {
+      return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
+    }
+    return value.reduce((current, item) => HttpClientRequest.appendUrlParam(current, field.name, String(item)), request)
+  }
+  if (isRecord(value) && field.explode) {
+    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
+      if (current instanceof ToolError) return current
+      if (item === undefined || (item !== null && typeof item === "object")) {
+        return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
+      }
+      return HttpClientRequest.appendUrlParam(current, name, String(item))
+    }, request)
+  }
+  const rendered = serializeSimple(field, value, String)
+  return rendered instanceof ToolError ? rendered : HttpClientRequest.appendUrlParam(request, field.name, rendered)
+}
+
+const readResponseBody = (
+  response: HttpClientResponse.HttpClientResponse,
+  plan: Plan,
+): Effect.Effect<string, ToolError> =>
+  Effect.gen(function* () {
+    const contentLength = response.headers["content-length"]
+    const parsedSize = contentLength === undefined ? undefined : Number.parseInt(contentLength, 10)
+    const declaredSize =
+      parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined
+    if (declaredSize !== undefined && declaredSize > maxResponseBodyBytes) {
+      return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
+    }
+    let body = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, declaredSize ?? 64 * 1024))
+    let size = 0
+    yield* Stream.runForEach(response.stream, (chunk) => {
+      if (size + chunk.byteLength > maxResponseBodyBytes) {
+        return Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
+      }
+      if (size + chunk.byteLength > body.byteLength) {
+        const grown = Buffer.allocUnsafe(
+          Math.min(maxResponseBodyBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)),
+        )
+        body.copy(grown, 0, 0, size)
+        body = grown
+      }
+      body.set(chunk, size)
+      size += chunk.byteLength
+      return Effect.void
+    }).pipe(
+      Effect.catch((cause) => {
+        if (cause instanceof ToolError) return Effect.fail(cause)
+        if (cause.reason._tag === "EmptyBodyError") return Effect.void
+        return Effect.fail(
+          toolError(`${plan.operation.method} ${plan.operation.path} failed while reading the response body.`, cause),
+        )
+      }),
+    )
+    return new TextDecoder().decode(body.subarray(0, size))
+  })

packages/codemode/src/openapi/spec.ts

@@ -0,0 +1,511 @@
+import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema"
+import type { JsonSchema } from "../tool.js"
+import { isBlockedMember } from "../tool-runtime.js"
+import type {
+  Body,
+  Document,
+  InputField,
+  OperationInput,
+  Parsed,
+  SecurityRequirement,
+  SecurityScheme,
+} from "./types.js"
+
+export const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"])
+const parameterLocations = ["path", "query", "header"] as const
+const ignoredHeaderParameters = new Set(["accept", "content-type", "authorization"])
+
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const asArray = (value: unknown): ReadonlyArray<unknown> => (Array.isArray(value) ? value : [])
+
+export const nonEmptyString = (value: unknown): string | undefined =>
+  typeof value === "string" && value !== "" ? value : undefined
+
+// Guards record lookups keyed by spec- or model-controlled names against
+// prototype-inherited values (e.g. a parameter named `toString`).
+export const own = <T>(record: Readonly<Record<string, T>>, key: string): T | undefined =>
+  Object.hasOwn(record, key) ? record[key] : undefined
+
+export const resolve = (document: Document, value: unknown): unknown => {
+  const next = (current: unknown, seen: ReadonlySet<string>): unknown => {
+    if (!isRecord(current)) return current
+    const ref = nonEmptyString(current.$ref)
+    if (ref === undefined || !ref.startsWith("#/") || seen.has(ref)) return current
+    const target = ref
+      .slice(2)
+      .split("/")
+      .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
+      .reduce<unknown>((item, segment) => (isRecord(item) ? own(item, segment) : undefined), document)
+    return target === undefined ? current : next(target, new Set([...seen, ref]))
+  }
+  return next(value, new Set())
+}
+
+const projectSchema = (document: Document, value: unknown): JsonSchema => {
+  if (!isRecord(value)) return {}
+  const normalized = nonEmptyString(document.openapi)?.startsWith("3.0")
+    ? fromSchemaOpenApi3_0(value)
+    : fromSchemaOpenApi3_1(value)
+  return Object.keys(normalized.definitions).length === 0
+    ? normalized.schema
+    : { ...normalized.schema, $defs: normalized.definitions }
+}
+
+export const componentDefinitions = (document: Document): Readonly<Record<string, JsonSchema>> => {
+  const components = isRecord(document.components) ? document.components : {}
+  const schemas = isRecord(components.schemas) ? components.schemas : {}
+  return Object.fromEntries(Object.entries(schemas).map(([name, value]) => [name, projectSchema(document, value)]))
+}
+
+const withDefinitions = (schema: JsonSchema, definitions: Readonly<Record<string, JsonSchema>>): JsonSchema => {
+  if (Object.keys(definitions).length === 0) return schema
+  const local = isRecord(schema.$defs) ? schema.$defs : {}
+  return { ...schema, $defs: { ...definitions, ...local } }
+}
+
+const isJsonMediaType = (mediaType: string): boolean => {
+  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
+  return normalized === "application/json" || normalized.endsWith("+json")
+}
+
+const isBinaryMediaType = (document: Document, mediaType: string, value: unknown): boolean => {
+  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
+  if (!isJsonMediaType(normalized) && !normalized.startsWith("text/")) return true
+  if (!isRecord(value)) return false
+  const schema = resolve(document, value.schema)
+  return isRecord(schema) && schema.format === "binary"
+}
+
+const jsonContent = (
+  content: Record<string, unknown>,
+): { readonly mediaType: string; readonly schema: unknown } | undefined => {
+  const entry = Object.entries(content).find(([mediaType]) => isJsonMediaType(mediaType))
+  return entry !== undefined && isRecord(entry[1]) ? { mediaType: entry[0], schema: entry[1].schema } : undefined
+}
+
+const isFlattenableObjectBody = (
+  schema: unknown,
+  requestRequired: boolean,
+): schema is Record<string, unknown> & { readonly properties: Record<string, unknown> } =>
+  isRecord(schema) &&
+  requestRequired &&
+  schema.type === "object" &&
+  isRecord(schema.properties) &&
+  schema.additionalProperties === false &&
+  schema.nullable !== true &&
+  schema.allOf === undefined &&
+  schema.anyOf === undefined &&
+  schema.oneOf === undefined
+
+type PlannedField = Omit<InputField, "inputName">
+
+const operationParameters = (
+  document: Document,
+  pathItem: Record<string, unknown>,
+  operation: Record<string, unknown>,
+): Parsed<ReadonlyArray<PlannedField>> => {
+  // Operation-level parameters override path-level ones sharing (location, name).
+  const declared = new Map<
+    string,
+    { readonly name: string; readonly location: string; readonly parameter: Record<string, unknown> }
+  >()
+  for (const raw of [...asArray(pathItem.parameters), ...asArray(operation.parameters)]) {
+    const resolved = resolve(document, raw)
+    if (!isRecord(resolved)) return { ok: false, reason: "parameter declaration is invalid or unresolved" }
+    const name = nonEmptyString(resolved.name)
+    const location = nonEmptyString(resolved.in)
+    if (name === undefined || location === undefined)
+      return { ok: false, reason: "parameter declaration is missing name or location" }
+    declared.set(`${location}:${name}`, { name, location, parameter: resolved })
+  }
+  const unordered: Array<PlannedField> = []
+  for (const item of declared.values()) {
+    const name = item.name
+    const location = item.location
+    const resolved = item.parameter
+    if (location === "cookie") return { ok: false, reason: `cookie parameter '${name}' is not supported` }
+    if (location !== "path" && location !== "query" && location !== "header") {
+      return { ok: false, reason: `parameter '${name}' uses unsupported location '${location}'` }
+    }
+    if (location === "header" && ignoredHeaderParameters.has(name.toLowerCase())) continue
+    if (resolved.schema === undefined && resolved.content === undefined) {
+      return { ok: false, reason: `parameter '${name}' declares neither schema nor content` }
+    }
+    if (resolved.content !== undefined)
+      return { ok: false, reason: `parameter '${name}' uses unsupported content encoding` }
+    if (resolved.style !== undefined && nonEmptyString(resolved.style) === undefined) {
+      return { ok: false, reason: `parameter '${name}' has an invalid style` }
+    }
+    if (resolved.explode !== undefined && typeof resolved.explode !== "boolean") {
+      return { ok: false, reason: `parameter '${name}' has an invalid explode value` }
+    }
+    if (resolved.allowReserved !== undefined && typeof resolved.allowReserved !== "boolean") {
+      return { ok: false, reason: `parameter '${name}' has an invalid allowReserved value` }
+    }
+    if (resolved.allowReserved === true)
+      return { ok: false, reason: `parameter '${name}' uses unsupported allowReserved encoding` }
+    const declaredStyle = nonEmptyString(resolved.style) ?? (location === "query" ? "form" : "simple")
+    if (location === "query" && declaredStyle !== "form" && declaredStyle !== "deepObject") {
+      return { ok: false, reason: `query parameter '${name}' uses unsupported style '${declaredStyle}'` }
+    }
+    if (location !== "query" && declaredStyle !== "simple") {
+      return { ok: false, reason: `${location} parameter '${name}' uses unsupported style '${declaredStyle}'` }
+    }
+    const style = declaredStyle === "deepObject" ? "deepObject" : declaredStyle === "form" ? "form" : "simple"
+    const explode = typeof resolved.explode === "boolean" ? resolved.explode : style === "form"
+    if (style === "deepObject" && !explode) {
+      return { ok: false, reason: `query parameter '${name}' uses deepObject with explode=false` }
+    }
+    const base = projectSchema(document, resolved.schema)
+    const description = nonEmptyString(resolved.description)
+    unordered.push({
+      name,
+      location,
+      required: resolved.required === true || location === "path",
+      style,
+      explode,
+      schema: {
+        ...base,
+        ...(base.description === undefined && description !== undefined ? { description } : {}),
+      },
+    })
+  }
+  return {
+    ok: true,
+    value: parameterLocations.flatMap((location) => unordered.filter((field) => field.location === location)),
+  }
+}
+
+const operationBody = (
+  document: Document,
+  operation: Record<string, unknown>,
+): Parsed<{ readonly fields: ReadonlyArray<PlannedField>; readonly body: Body | undefined }> => {
+  const resolved = resolve(document, operation.requestBody)
+  if (!isRecord(resolved)) return { ok: true, value: { fields: [], body: undefined } }
+  const content = isRecord(resolved.content) ? resolved.content : {}
+  const selected = jsonContent(content)
+  if (selected === undefined) {
+    return {
+      ok: false,
+      reason: `request body has no JSON content (declared: ${Object.keys(content).join(", ") || "none"})`,
+    }
+  }
+  const schema = resolve(document, selected.schema)
+  const required = resolved.required === true
+  if (!isFlattenableObjectBody(schema, required)) {
+    return {
+      ok: true,
+      value: {
+        fields: [
+          {
+            name: "body",
+            location: "body",
+            required,
+            schema: projectSchema(document, selected.schema),
+            style: undefined,
+            explode: undefined,
+          },
+        ],
+        body: { required, mode: "value", mediaType: selected.mediaType },
+      },
+    }
+  }
+  const requiredProperties = new Set(
+    Array.isArray(schema.required) ? schema.required.filter((item): item is string => typeof item === "string") : [],
+  )
+  return {
+    ok: true,
+    value: {
+      fields: Object.entries(schema.properties).map(([name, value]) => ({
+        name,
+        location: "body" as const,
+        required: required && requiredProperties.has(name),
+        schema: projectSchema(document, value),
+        style: undefined,
+        explode: undefined,
+      })),
+      body: { required, mode: "object", mediaType: selected.mediaType },
+    },
+  }
+}
+
+export const operationInput = (
+  document: Document,
+  pathItem: Record<string, unknown>,
+  operation: Record<string, unknown>,
+): Parsed<OperationInput> => {
+  const parameters = operationParameters(document, pathItem, operation)
+  if (!parameters.ok) return parameters
+  const requestBody = operationBody(document, operation)
+  if (!requestBody.ok) return requestBody
+  const fields = [...parameters.value, ...requestBody.value.fields]
+
+  const conflicts = new Set(
+    [...Map.groupBy(fields, (field) => field.name)]
+      .filter(([, matches]) => new Set(matches.map((field) => field.location)).size > 1)
+      .map(([name]) => name),
+  )
+  const used = new Set<string>()
+  return {
+    ok: true,
+    value: {
+      fields: fields.map((field) => {
+        const visibleName = isBlockedMember(field.name) ? `${field.name}_2` : field.name
+        const base = conflicts.has(field.name) ? `${field.location}_${visibleName}` : visibleName
+        const next = (index: number): string => {
+          const candidate = index === 1 ? base : `${base}_${index}`
+          return used.has(candidate) ? next(index + 1) : candidate
+        }
+        const inputName = next(1)
+        used.add(inputName)
+        return { ...field, inputName }
+      }),
+      body: requestBody.value.body,
+    },
+  }
+}
+
+export const inputSchema = (
+  fields: ReadonlyArray<InputField>,
+  definitions: Readonly<Record<string, JsonSchema>>,
+): JsonSchema => {
+  const required = fields.filter((field) => field.required).map((field) => field.inputName)
+  return withDefinitions(
+    {
+      type: "object",
+      properties: Object.fromEntries(fields.map((field) => [field.inputName, field.schema])),
+      ...(required.length === 0 ? {} : { required }),
+    },
+    definitions,
+  )
+}
+
+const successfulResponses = (
+  document: Document,
+  operation: Record<string, unknown>,
+): Parsed<ReadonlyArray<Record<string, unknown>>> => {
+  if (!isRecord(operation.responses)) return { ok: true, value: [] }
+  const entries = Object.entries(operation.responses)
+  const selected = [
+    ...entries.filter(([status]) => /^2\d\d$/.test(status)).sort(([a], [b]) => a.localeCompare(b)),
+    ...entries.filter(([status]) => status.toUpperCase() === "2XX"),
+  ]
+  const responses: Array<Record<string, unknown>> = []
+  for (const [, value] of selected) {
+    const resolved = resolve(document, value)
+    if (!isRecord(resolved) || nonEmptyString(resolved.$ref) !== undefined) {
+      return { ok: false, reason: "successful response declaration is invalid or unresolved" }
+    }
+    responses.push(resolved)
+  }
+  return { ok: true, value: responses }
+}
+
+export const operationOutput = (
+  document: Document,
+  operation: Record<string, unknown>,
+  definitions: Readonly<Record<string, JsonSchema>>,
+): Parsed<JsonSchema | undefined> => {
+  if (operation["x-websocket"] === true) return { ok: false, reason: "WebSocket operations are not supported" }
+  const responses = successfulResponses(document, operation)
+  if (!responses.ok) return responses
+  const streams = responses.value.some(
+    (response) =>
+      isRecord(response.content) &&
+      Object.keys(response.content).some(
+        (mediaType) => mediaType.split(";")[0]?.trim().toLowerCase() === "text/event-stream",
+      ),
+  )
+  if (streams) return { ok: false, reason: "SSE operations are not supported" }
+  const binary = responses.value.some(
+    (response) =>
+      isRecord(response.content) &&
+      Object.entries(response.content).some(([mediaType, value]) => isBinaryMediaType(document, mediaType, value)),
+  )
+  if (binary) return { ok: false, reason: "binary responses are not supported" }
+
+  const outcomes: Array<JsonSchema> = []
+  for (const response of responses.value) {
+    if (response.content !== undefined && !isRecord(response.content)) return { ok: true, value: undefined }
+    const content = isRecord(response.content) ? response.content : {}
+    if (Object.keys(content).length === 0) {
+      outcomes.push({ type: "null" })
+      continue
+    }
+    for (const [mediaType, value] of Object.entries(content)) {
+      if (!isJsonMediaType(mediaType)) {
+        outcomes.push({ type: "string" })
+        continue
+      }
+      if (!isRecord(value) || value.schema === undefined) return { ok: true, value: undefined }
+      outcomes.push(projectSchema(document, value.schema))
+    }
+  }
+  if (outcomes.length === 0) return { ok: true, value: undefined }
+  return {
+    ok: true,
+    value: withDefinitions(outcomes.length === 1 ? (outcomes[0] ?? {}) : { anyOf: outcomes }, definitions),
+  }
+}
+
+const sanitizeOperationSegment = (raw: string): string => {
+  const base =
+    raw
+      .replaceAll(/[^A-Za-z0-9_$]+/g, "_")
+      .replace(/^_+|_+$/g, "")
+      .replace(/^([0-9])/, "_$1") || "operation"
+  return isBlockedMember(base) ? `${base}_2` : base
+}
+
+const fallbackOperationId = (method: string, path: string): string =>
+  [
+    method,
+    ...path
+      .split("/")
+      .filter((part) => part !== "")
+      .flatMap((part) => (part.startsWith("{") && part.endsWith("}") ? ["by", part.slice(1, -1)] : [part]))
+      .flatMap((part) => part.split(/[^A-Za-z0-9]+/).filter((word) => word !== "")),
+  ]
+    .map((word, index) => {
+      const lower = word.toLowerCase()
+      return index === 0 ? lower : `${lower.charAt(0).toUpperCase()}${lower.slice(1)}`
+    })
+    .join("")
+
+export const operationPath = (
+  method: string,
+  path: string,
+  operation: Record<string, unknown>,
+  used: ReadonlySet<string>,
+  namespaces: ReadonlySet<string>,
+): ReadonlyArray<string> => {
+  const raw = nonEmptyString(operation.operationId)
+  const segments = (raw === undefined ? [fallbackOperationId(method, path)] : raw.split(".")).map(
+    sanitizeOperationSegment,
+  )
+  if (isOperationPathAvailable(segments, used, namespaces)) return segments
+  const conflict = segments.slice(0, -1).findIndex((_, index) => used.has(segments.slice(0, index + 1).join(".")))
+  if (conflict >= 0 && conflict + 1 < segments.length) {
+    const collapsed = segments.flatMap((segment, index) => {
+      if (index === conflict) {
+        const next = segments[index + 1] ?? ""
+        return [`${segment}${next.charAt(0).toUpperCase()}${next.slice(1)}`]
+      }
+      return index === conflict + 1 ? [] : [segment]
+    })
+    if (isOperationPathAvailable(collapsed, used, namespaces)) return collapsed
+  }
+  const fallback = segments.join("_")
+  const next = (index: number): string => {
+    const candidate = `${fallback}_${index}`
+    return isOperationPathAvailable([candidate], used, namespaces) ? candidate : next(index + 1)
+  }
+  return [next(2)]
+}
+
+const isOperationPathAvailable = (
+  segments: ReadonlyArray<string>,
+  used: ReadonlySet<string>,
+  namespaces: ReadonlySet<string>,
+): boolean => {
+  const key = segments.join(".")
+  if (used.has(key) || namespaces.has(key)) return false
+  return segments.slice(0, -1).every((_, index) => !used.has(segments.slice(0, index + 1).join(".")))
+}
+
+export const specServerUrl = (source: Record<string, unknown>): Parsed<string> => {
+  const server = asArray(source.servers).find(isRecord)
+  const url = server === undefined ? undefined : nonEmptyString(server.url)
+  if (url === undefined) return { ok: false, reason: "spec declares no servers; pass baseUrl" }
+  if (/\{[^{}]+\}/.test(url)) {
+    return { ok: false, reason: `server URL '${url}' is not an absolute URL; pass baseUrl` }
+  }
+  return validateBaseUrl(url)
+}
+
+export const validateBaseUrl = (value: string): Parsed<string> => {
+  if (!/^https?:\/\//i.test(value)) return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
+  const url = URL.parse(value)
+  if (url === null || (url.protocol !== "http:" && url.protocol !== "https:")) {
+    return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
+  }
+  if (url.search !== "" || url.hash !== "") {
+    return { ok: false, reason: `server URL '${value}' contains an unsupported query string or fragment` }
+  }
+  return { ok: true, value }
+}
+
+export const securityRequirements = (value: unknown): Parsed<ReadonlyArray<SecurityRequirement>> => {
+  if (value === undefined) return { ok: true, value: [] }
+  if (!Array.isArray(value)) return { ok: false, reason: "security declaration is not an array" }
+  const requirements: Array<SecurityRequirement> = []
+  for (const item of value) {
+    if (!isRecord(item)) return { ok: false, reason: "security requirement is not an object" }
+    const requirement = Object.create(null) as Record<string, ReadonlyArray<string>>
+    for (const [name, scopes] of Object.entries(item)) {
+      if (!Array.isArray(scopes)) return { ok: false, reason: "security requirement scopes are not string arrays" }
+      const parsed = scopes.filter((scope): scope is string => typeof scope === "string")
+      if (parsed.length !== scopes.length) {
+        return { ok: false, reason: "security requirement scopes are not string arrays" }
+      }
+      requirement[name] = parsed
+    }
+    requirements.push(requirement)
+  }
+  return { ok: true, value: requirements }
+}
+
+export const operationSecurityRequirements = (
+  value: unknown,
+  defaults: Parsed<ReadonlyArray<SecurityRequirement>>,
+  schemes: Readonly<Record<string, SecurityScheme>>,
+): Parsed<ReadonlyArray<SecurityRequirement>> => {
+  const parsed = value === undefined ? defaults : securityRequirements(value)
+  if (!parsed.ok) return parsed
+  const supported = parsed.value.filter((requirement) =>
+    Object.keys(requirement).every((name) => {
+      const scheme = own(schemes, name)
+      return scheme !== undefined && !(scheme.type === "apiKey" && scheme.in === "cookie")
+    }),
+  )
+  if (parsed.value.length === 0 || supported.length > 0) return { ok: true, value: supported }
+
+  const names = [...new Set(parsed.value.flatMap((requirement) => Object.keys(requirement)))]
+  const cookieScheme = names.find((name) => {
+    const definition = own(schemes, name)
+    return definition?.type === "apiKey" && definition.in === "cookie"
+  })
+  return {
+    ok: false,
+    reason:
+      cookieScheme === undefined
+        ? `security requirement references missing or malformed scheme: ${names.join(", ")}`
+        : `cookie authentication '${cookieScheme}' is not supported`,
+  }
+}
+
+export const securitySchemes = (document: Document): Readonly<Record<string, SecurityScheme>> => {
+  const components = isRecord(document.components) ? document.components : {}
+  const declared = isRecord(components.securitySchemes) ? components.securitySchemes : {}
+  return Object.fromEntries(
+    Object.entries(declared).flatMap<readonly [string, SecurityScheme]>(([name, value]) => {
+      const resolved = resolve(document, value)
+      if (!isRecord(resolved)) return []
+      const type = nonEmptyString(resolved.type)
+      if (type === "apiKey") {
+        const carrier = nonEmptyString(resolved.in)
+        const parameter = nonEmptyString(resolved.name)
+        if (parameter === undefined || (carrier !== "header" && carrier !== "query" && carrier !== "cookie")) return []
+        return [[name, { type, name: parameter, in: carrier }] as const]
+      }
+      if (type === "http") {
+        const scheme = nonEmptyString(resolved.scheme)?.toLowerCase()
+        return scheme === undefined ? [] : [[name, { type, scheme }] as const]
+      }
+      if (type === "oauth2" || type === "openIdConnect") return [[name, { type }] as const]
+      return []
+    }),
+  )
+}

packages/codemode/src/openapi/types.ts

@@ -0,0 +1,112 @@
+import { Effect } from "effect"
+import { HttpClient } from "effect/unstable/http"
+import type { Definition, JsonSchema } from "../tool.js"
+
+/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
+export type Document = Record<string, unknown>
+
+/** The operation identity handed to auth resolution and errors. */
+export type Operation = {
+  readonly operationId: string | undefined
+  readonly method: string
+  readonly path: string
+  readonly summary: string | undefined
+  readonly description: string | undefined
+}
+
+/** A resolved OpenAPI security scheme from `components.securitySchemes`. */
+export type SecurityScheme =
+  | { readonly type: "apiKey"; readonly name: string; readonly in: "header" | "query" | "cookie" }
+  | { readonly type: "http"; readonly scheme: string }
+  | { readonly type: "oauth2" }
+  | { readonly type: "openIdConnect" }
+
+/**
+ * Credential material returned by a host auth resolver. The carrier for `apiKey`
+ * comes from the scheme definition, not the credential. `header` is the escape
+ * hatch for nonstandard schemes.
+ */
+export type Credential =
+  | { readonly type: "bearer"; readonly token: string }
+  | { readonly type: "basic"; readonly username: string; readonly password: string }
+  | { readonly type: "apiKey"; readonly value: string }
+  | { readonly type: "header"; readonly name: string; readonly value: string }
+
+/**
+ * Resolves credential material for one named security scheme at call time.
+ * `undefined` means unavailable, try the next OR alternative; a failure aborts
+ * the call rather than falling through.
+ */
+export type AuthResolver = (context: {
+  readonly name: string
+  readonly definition: SecurityScheme
+  readonly scopes: ReadonlyArray<string>
+  readonly operation: Operation
+}) => Effect.Effect<Credential | undefined, unknown>
+
+export type Options = {
+  readonly spec: Document
+  /** Overrides all document, path, and operation `servers`. Required when no applicable absolute server URL exists. */
+  readonly baseUrl?: string | undefined
+  /** Host credential resolution, keyed by security scheme name. */
+  readonly auth?: { readonly resolve: AuthResolver } | undefined
+  /** Static headers on every request. Not model-visible; declared header params may override them, auth always wins. */
+  readonly headers?: Readonly<Record<string, string>> | undefined
+}
+
+/** An operation that could not be represented as a tool, and why. */
+export type Skipped = {
+  readonly method: string
+  readonly path: string
+  readonly reason: string
+}
+
+export type Tools = { [name: string]: Definition<HttpClient.HttpClient> | Tools }
+
+export type Result = {
+  /** Tool subtree; the host places it under a key in its `tools` tree. */
+  readonly tools: Tools
+  readonly skipped: ReadonlyArray<Skipped>
+}
+
+export type Parsed<T> = { readonly ok: true; readonly value: T } | { readonly ok: false; readonly reason: string }
+
+export type InputLocation = "path" | "query" | "header" | "body"
+
+export type InputField = {
+  /** Model-visible field name after cross-location collision handling. */
+  readonly inputName: string
+  /** Original parameter or body-property name used on the wire. */
+  readonly name: string
+  readonly location: InputLocation
+  readonly required: boolean
+  readonly schema: JsonSchema
+  readonly style: "simple" | "form" | "deepObject" | undefined
+  readonly explode: boolean | undefined
+}
+
+export type Body = { readonly required: boolean; readonly mode: "object" | "value"; readonly mediaType: string }
+
+export type OperationInput = {
+  readonly fields: ReadonlyArray<InputField>
+  readonly body: Body | undefined
+}
+
+/** One OR alternative: scheme name -> required scopes. Empty object = unauthenticated is acceptable. */
+export type SecurityRequirement = Readonly<Record<string, ReadonlyArray<string>>>
+
+export type Plan = {
+  readonly operation: Operation
+  readonly url: string
+  readonly fields: ReadonlyArray<InputField>
+  readonly body: Body | undefined
+  readonly security: ReadonlyArray<SecurityRequirement>
+  readonly schemes: Readonly<Record<string, SecurityScheme>>
+  readonly auth: { readonly resolve: AuthResolver } | undefined
+  readonly headers: Readonly<Record<string, string>>
+}
+
+export type AppliedAuth = {
+  readonly headers: Readonly<Record<string, string>>
+  readonly query: Readonly<Record<string, string>>
+}

packages/codemode/src/stdlib/collections.ts

@@ -0,0 +1,51 @@
+export const arrayMethods = new Set([
+  "map",
+  "filter",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "some",
+  "every",
+  "includes",
+  "join",
+  "reduce",
+  "reduceRight",
+  "flatMap",
+  "forEach",
+  "sort",
+  "toSorted",
+  "slice",
+  "concat",
+  "indexOf",
+  "lastIndexOf",
+  "at",
+  "flat",
+  "reverse",
+  "toReversed",
+  "with",
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "fill",
+  "copyWithin",
+  "keys",
+  "values",
+  "entries",
+])
+
+export const mapMethods = new Set(["get", "set", "has", "delete", "clear", "forEach", "keys", "values", "entries"])
+
+export const setMethods = new Set(["add", "has", "delete", "clear", "forEach", "keys", "values", "entries"])
+
+export const spreadItems = (value: unknown): Array<unknown> | undefined => {
+  if (Array.isArray(value)) return value
+  if (typeof value === "string") return Array.from(value)
+  if (value instanceof SandboxMap) return Array.from(value.map.entries(), ([key, item]) => [key, item])
+  if (value instanceof SandboxSet) return Array.from(value.set.values())
+  if (value instanceof SandboxURLSearchParams) return Array.from(value.params.entries(), ([key, item]) => [key, item])
+  return undefined
+}
+import { SandboxMap, SandboxSet, SandboxURLSearchParams } from "../values.js"

packages/codemode/src/stdlib/console.ts

@@ -0,0 +1,4 @@
+export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"])
+
+/** Console formatting recursion ceiling; deeper values render as "...". */
+export const MAX_CONSOLE_DEPTH = 32

packages/codemode/src/stdlib/date.ts

@@ -0,0 +1,94 @@
+export const dateMethods = new Set([
+  "getTime",
+  "valueOf",
+  "toISOString",
+  "toJSON",
+  "toString",
+  "getFullYear",
+  "getMonth",
+  "getDate",
+  "getDay",
+  "getHours",
+  "getMinutes",
+  "getSeconds",
+  "getMilliseconds",
+  "getUTCFullYear",
+  "getUTCMonth",
+  "getUTCDate",
+  "getUTCDay",
+  "getUTCHours",
+  "getUTCMinutes",
+  "getUTCSeconds",
+  "getUTCMilliseconds",
+  "getTimezoneOffset",
+])
+
+export const dateStatics = new Set(["now", "parse", "UTC"])
+
+export const invokeDateStatic = (name: string, args: Array<unknown>, node: AstNode): number => {
+  switch (name) {
+    case "now":
+      return Date.now()
+    case "parse":
+      return Date.parse(coerceToString(args[0]))
+    case "UTC":
+      return Date.UTC(...(args.map((arg) => coerceToNumber(arg)) as Parameters<typeof Date.UTC>))
+    default:
+      throw new InterpreterRuntimeError(`Date.${name} is not available in CodeMode.`, node)
+  }
+}
+
+export const invokeDateMethod = (value: SandboxDate, name: string, node: AstNode): unknown => {
+  const hosted = new Date(value.time)
+  switch (name) {
+    case "getTime":
+    case "valueOf":
+      return value.time
+    case "toISOString":
+      if (!Number.isFinite(value.time)) throw new InterpreterRuntimeError("Invalid time value.", node)
+      return hosted.toISOString()
+    case "toJSON":
+      return Number.isFinite(value.time) ? hosted.toISOString() : null
+    case "toString":
+      return coerceToString(value)
+    case "getFullYear":
+      return hosted.getFullYear()
+    case "getMonth":
+      return hosted.getMonth()
+    case "getDate":
+      return hosted.getDate()
+    case "getDay":
+      return hosted.getDay()
+    case "getHours":
+      return hosted.getHours()
+    case "getMinutes":
+      return hosted.getMinutes()
+    case "getSeconds":
+      return hosted.getSeconds()
+    case "getMilliseconds":
+      return hosted.getMilliseconds()
+    case "getUTCFullYear":
+      return hosted.getUTCFullYear()
+    case "getUTCMonth":
+      return hosted.getUTCMonth()
+    case "getUTCDate":
+      return hosted.getUTCDate()
+    case "getUTCDay":
+      return hosted.getUTCDay()
+    case "getUTCHours":
+      return hosted.getUTCHours()
+    case "getUTCMinutes":
+      return hosted.getUTCMinutes()
+    case "getUTCSeconds":
+      return hosted.getUTCSeconds()
+    case "getUTCMilliseconds":
+      return hosted.getUTCMilliseconds()
+    case "getTimezoneOffset":
+      return hosted.getTimezoneOffset()
+    default:
+      throw new InterpreterRuntimeError(`Date method '${name}' is not available in CodeMode.`, node)
+  }
+}
+import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
+import { SandboxDate } from "../values.js"
+import { coerceToNumber, coerceToString } from "./value.js"