From fb6265c2bcc5d94527d076a05bef1028888a45a9 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Mon, 25 May 2026 18:23:05 +0700
Subject: [PATCH 01/31] fix(config): catch parse errors gracefully during
 startup

Wrap ConfigParse.jsonc() and ConfigParse.effectSchema() calls in
loadConfig with Effect.catchCause to prevent sync-thrown JsonError
and InvalidError from becoming Effect defects. On parse/schema
failure, the bad file is skipped with a log.error and {} fallback
instead of crashing, matching the existing tui.jsonc error handling
pattern in tui.ts.

Without this, any invalid JSONC syntax or schema violation in
opencode.json/opencode.jsonc causes "4 of 6 requests failed:
Unexpected server error" on startup. Now the server starts with
default values and logs the config error details.

Fixes #29200
---
 packages/opencode/src/config/config.ts       |  42 +++---
 packages/opencode/test/config/config.test.ts | 127 +++++++++++++++----
 2 files changed, 127 insertions(+), 42 deletions(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 307b02ca4d9f..1487b8d4bcfe 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -413,24 +413,34 @@ export const layer = Layer.effect(
       env?: Record<string, string>,
     ) {
       const source = "path" in options ? options.path : options.source
-      const expanded = yield* Effect.promise(() =>
-        ConfigVariable.substitute(
-          "path" in options
-            ? { text, type: "path", path: options.path, env }
-            : { text, type: "virtual", ...options, env },
+      const result = yield* Effect.gen(function* () {
+        const expanded = yield* Effect.promise(() =>
+          ConfigVariable.substitute(
+            "path" in options
+              ? { text, type: "path", path: options.path, env }
+              : { text, type: "virtual", ...options, env },
+          ),
+        )
+        const parsed = ConfigParse.jsonc(expanded, source)
+        const data = ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
+        if (!("path" in options)) return data
+
+        yield* Effect.promise(() => resolveLoadedPlugins(data, options.path))
+        if (!data.$schema) {
+          data.$schema = "https://opencode.ai/config.json"
+          const updated = text.replace(/^\s*\{/, '{\n  "$schema": "https://opencode.ai/config.json",')
+          yield* fs.writeFileString(options.path, updated).pipe(Effect.catch(() => Effect.void))
+        }
+        return data
+      }).pipe(
+        Effect.catchCause((cause) =>
+          Effect.sync(() => {
+            log.error("invalid config", { path: source, cause })
+            return {} as Info
+          }),
         ),
       )
-      const parsed = ConfigParse.jsonc(expanded, source)
-      const data = ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
-      if (!("path" in options)) return data
-
-      yield* Effect.promise(() => resolveLoadedPlugins(data, options.path))
-      if (!data.$schema) {
-        data.$schema = "https://opencode.ai/config.json"
-        const updated = text.replace(/^\s*\{/, '{\n  "$schema": "https://opencode.ai/config.json",')
-        yield* fs.writeFileString(options.path, updated).pipe(Effect.catch(() => Effect.void))
-      }
-      return data
+      return result
     })
 
     const loadFile = Effect.fnUntraced(function* (filepath: string, env?: Record<string, string>) {
diff --git a/packages/opencode/test/config/config.test.ts b/packages/opencode/test/config/config.test.ts
index 6ce0acdb2a7b..4bdd148b433f 100644
--- a/packages/opencode/test/config/config.test.ts
+++ b/packages/opencode/test/config/config.test.ts
@@ -580,34 +580,109 @@ accountTokenIt.instance("resolves env templates in account config with account t
   }),
 )
 
-it.instance("validates config schema and throws on invalid fields", () =>
-  Effect.gen(function* () {
-    const test = yield* TestInstance
-    yield* writeConfigEffect(test.directory, {
-      $schema: "https://opencode.ai/config.json",
-      invalid_field: "should cause error",
-    })
-    const exit = yield* Config.use.get().pipe(Effect.exit)
-    expect(Exit.isFailure(exit)).toBe(true)
-  }),
-)
+test("handles invalid schema gracefully without crashing", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await writeConfig(dir, {
+        $schema: "https://opencode.ai/config.json",
+        invalid_field: "should cause error",
+      })
+    },
+  })
+  await WithInstance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await load()
+      expect(config.username).toBeDefined()
+    },
+  })
+})
 
-it.instance("throws error for invalid JSON", () =>
-  Effect.gen(function* () {
-    const test = yield* TestInstance
-    yield* AppFileSystem.use.writeWithDirs(path.join(test.directory, "opencode.json"), "{ invalid json }")
-    const exit = yield* Config.use.get().pipe(Effect.exit)
-    expect(Exit.isFailure(exit)).toBe(true)
-  }),
-)
+test("handles invalid JSON gracefully without crashing", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Filesystem.write(path.join(dir, "opencode.json"), "{ invalid json }")
+    },
+  })
+  await WithInstance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await load()
+      expect(config.username).toBeDefined()
+    },
+  })
+})
 
-it.instance("handles agent configuration", () =>
-  Effect.gen(function* () {
-    const test = yield* TestInstance
-    yield* writeConfigEffect(test.directory, {
-      $schema: "https://opencode.ai/config.json",
-      agent: {
-        test_agent: {
+test("handles invalid JSONC syntax gracefully without crashing", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Filesystem.write(
+        path.join(dir, "opencode.jsonc"),
+        `{
+          // comment
+          "model": "test/model",
+          "username": "testuser",
+        }`,
+      )
+    },
+  })
+  await WithInstance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await load()
+      expect(config.username).toBeDefined()
+    },
+  })
+})
+
+test("skips bad config file but merges others", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Filesystem.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          model: "global/model",
+          username: "globaluser",
+        }),
+      )
+      await Filesystem.write(
+        path.join(dir, "opencode.jsonc"),
+        "{ invalid json }",
+      )
+    },
+  })
+  await WithInstance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await load()
+      expect(config.model).toBe("global/model")
+      expect(config.username).toBe("globaluser")
+    },
+  })
+})
+
+test("handles agent configuration", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await writeConfig(dir, {
+        $schema: "https://opencode.ai/config.json",
+        agent: {
+          test_agent: {
+            model: "test/model",
+            temperature: 0.7,
+            description: "test agent",
+          },
+        },
+      })
+    },
+  })
+  await WithInstance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await load()
+      expect(config.agent?.["test_agent"]).toEqual(
+        expect.objectContaining({
           model: "test/model",
           temperature: 0.7,
           description: "test agent",

From de8dc4a747066f12f01f11c56154cc77eb0604ce Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Mon, 25 May 2026 19:21:32 +0700
Subject: [PATCH 02/31] fix(config): convert tests to it.instance pattern
 matching upstream

---
 packages/opencode/test/config/config.test.ts | 160 +++++++------------
 1 file changed, 61 insertions(+), 99 deletions(-)

diff --git a/packages/opencode/test/config/config.test.ts b/packages/opencode/test/config/config.test.ts
index 4bdd148b433f..32cc35011892 100644
--- a/packages/opencode/test/config/config.test.ts
+++ b/packages/opencode/test/config/config.test.ts
@@ -580,109 +580,71 @@ accountTokenIt.instance("resolves env templates in account config with account t
   }),
 )
 
-test("handles invalid schema gracefully without crashing", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await writeConfig(dir, {
-        $schema: "https://opencode.ai/config.json",
-        invalid_field: "should cause error",
-      })
-    },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await load()
-      expect(config.username).toBeDefined()
-    },
-  })
-})
-
-test("handles invalid JSON gracefully without crashing", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Filesystem.write(path.join(dir, "opencode.json"), "{ invalid json }")
-    },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await load()
-      expect(config.username).toBeDefined()
-    },
-  })
-})
+it.instance("handles invalid schema gracefully without crashing", () =>
+  Effect.gen(function* () {
+    const test = yield* TestInstance
+    yield* writeConfigEffect(test.directory, {
+      $schema: "https://opencode.ai/config.json",
+      invalid_field: "should cause error",
+    })
+    const config = yield* Config.use.get()
+    expect(config.username).toBeDefined()
+  }),
+)
 
-test("handles invalid JSONC syntax gracefully without crashing", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Filesystem.write(
-        path.join(dir, "opencode.jsonc"),
-        `{
-          // comment
-          "model": "test/model",
-          "username": "testuser",
-        }`,
-      )
-    },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await load()
-      expect(config.username).toBeDefined()
-    },
-  })
-})
+it.instance("handles invalid JSON gracefully without crashing", () =>
+  Effect.gen(function* () {
+    const test = yield* TestInstance
+    yield* AppFileSystem.use.writeWithDirs(path.join(test.directory, "opencode.json"), "{ invalid json }")
+    const config = yield* Config.use.get()
+    expect(config.username).toBeDefined()
+  }),
+)
 
-test("skips bad config file but merges others", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Filesystem.write(
-        path.join(dir, "opencode.json"),
-        JSON.stringify({
-          $schema: "https://opencode.ai/config.json",
-          model: "global/model",
-          username: "globaluser",
-        }),
-      )
-      await Filesystem.write(
-        path.join(dir, "opencode.jsonc"),
-        "{ invalid json }",
-      )
-    },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await load()
-      expect(config.model).toBe("global/model")
-      expect(config.username).toBe("globaluser")
-    },
-  })
-})
+it.instance("handles invalid JSONC syntax gracefully without crashing", () =>
+  Effect.gen(function* () {
+    const test = yield* TestInstance
+    yield* AppFileSystem.use.writeWithDirs(
+      path.join(test.directory, "opencode.jsonc"),
+      `{
+        // comment
+        "model": "test/model",
+        "username": "testuser",
+      }`,
+    )
+    const config = yield* Config.use.get()
+    expect(config.username).toBeDefined()
+  }),
+)
 
-test("handles agent configuration", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await writeConfig(dir, {
+it.instance("skips bad config file but merges others", () =>
+  Effect.gen(function* () {
+    const test = yield* TestInstance
+    yield* AppFileSystem.use.writeWithDirs(
+      path.join(test.directory, "opencode.json"),
+      JSON.stringify({
         $schema: "https://opencode.ai/config.json",
-        agent: {
-          test_agent: {
-            model: "test/model",
-            temperature: 0.7,
-            description: "test agent",
-          },
-        },
-      })
-    },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await load()
-      expect(config.agent?.["test_agent"]).toEqual(
-        expect.objectContaining({
+        model: "global/model",
+        username: "globaluser",
+      }),
+    )
+    yield* AppFileSystem.use.writeWithDirs(
+      path.join(test.directory, "opencode.jsonc"),
+      "{ invalid json }",
+    )
+    const config = yield* Config.use.get()
+    expect(config.model).toBe("global/model")
+    expect(config.username).toBe("globaluser")
+  }),
+)
+
+it.instance("handles agent configuration", () =>
+  Effect.gen(function* () {
+    const test = yield* TestInstance
+    yield* writeConfigEffect(test.directory, {
+      $schema: "https://opencode.ai/config.json",
+      agent: {
+        test_agent: {
           model: "test/model",
           temperature: 0.7,
           description: "test agent",

From 85ed2e48211c8139a3e7344c8d83b86ecd8ffcb2 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Mon, 25 May 2026 19:27:15 +0700
Subject: [PATCH 03/31] fix(config): narrow catchCause to parse/schema only,
 strengthen tests

---
 packages/opencode/src/config/config.ts       | 39 ++++++++++----------
 packages/opencode/test/config/config.test.ts |  4 +-
 2 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 1487b8d4bcfe..53e9008bcf11 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -413,34 +413,33 @@ export const layer = Layer.effect(
       env?: Record<string, string>,
     ) {
       const source = "path" in options ? options.path : options.source
-      const result = yield* Effect.gen(function* () {
-        const expanded = yield* Effect.promise(() =>
-          ConfigVariable.substitute(
-            "path" in options
-              ? { text, type: "path", path: options.path, env }
-              : { text, type: "virtual", ...options, env },
-          ),
-        )
+      const expanded = yield* Effect.promise(() =>
+        ConfigVariable.substitute(
+          "path" in options
+            ? { text, type: "path", path: options.path, env }
+            : { text, type: "virtual", ...options, env },
+        ),
+      )
+      const data = yield* Effect.sync(() => {
         const parsed = ConfigParse.jsonc(expanded, source)
-        const data = ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
-        if (!("path" in options)) return data
-
-        yield* Effect.promise(() => resolveLoadedPlugins(data, options.path))
-        if (!data.$schema) {
-          data.$schema = "https://opencode.ai/config.json"
-          const updated = text.replace(/^\s*\{/, '{\n  "$schema": "https://opencode.ai/config.json",')
-          yield* fs.writeFileString(options.path, updated).pipe(Effect.catch(() => Effect.void))
-        }
-        return data
+        return ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
       }).pipe(
         Effect.catchCause((cause) =>
           Effect.sync(() => {
             log.error("invalid config", { path: source, cause })
-            return {} as Info
+            return Schema.decodeSync(Info)({})
           }),
         ),
       )
-      return result
+      if (!("path" in options)) return data
+
+      yield* Effect.promise(() => resolveLoadedPlugins(data, options.path))
+      if (!data.$schema) {
+        data.$schema = "https://opencode.ai/config.json"
+        const updated = text.replace(/^\s*\{/, '{\n  "$schema": "https://opencode.ai/config.json",')
+        yield* fs.writeFileString(options.path, updated).pipe(Effect.catch(() => Effect.void))
+      }
+      return data
     })
 
     const loadFile = Effect.fnUntraced(function* (filepath: string, env?: Record<string, string>) {
diff --git a/packages/opencode/test/config/config.test.ts b/packages/opencode/test/config/config.test.ts
index 32cc35011892..fdc7dc62d948 100644
--- a/packages/opencode/test/config/config.test.ts
+++ b/packages/opencode/test/config/config.test.ts
@@ -589,6 +589,7 @@ it.instance("handles invalid schema gracefully without crashing", () =>
     })
     const config = yield* Config.use.get()
     expect(config.username).toBeDefined()
+    expect("invalid_field" in config).toBe(false)
   }),
 )
 
@@ -609,8 +610,7 @@ it.instance("handles invalid JSONC syntax gracefully without crashing", () =>
       `{
         // comment
         "model": "test/model",
-        "username": "testuser",
-      }`,
+        "username": "testuser",`,
     )
     const config = yield* Config.use.get()
     expect(config.username).toBeDefined()

From 109a6eb483d5cc5bb02e951120820ec91e6d660b Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Mon, 25 May 2026 20:14:35 +0700
Subject: [PATCH 04/31] fix(config): catch plugin resolution errors per-file to
 preserve multi-file merge

---
 packages/opencode/src/config/config.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 53e9008bcf11..272e4db83e19 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -433,7 +433,13 @@ export const layer = Layer.effect(
       )
       if (!("path" in options)) return data
 
-      yield* Effect.promise(() => resolveLoadedPlugins(data, options.path))
+      yield* Effect.promise(() => resolveLoadedPlugins(data, options.path)).pipe(
+        Effect.catchCause((cause) =>
+          Effect.sync(() => {
+            log.error("plugin resolution failed", { path: source, cause })
+          }),
+        ),
+      )
       if (!data.$schema) {
         data.$schema = "https://opencode.ai/config.json"
         const updated = text.replace(/^\s*\{/, '{\n  "$schema": "https://opencode.ai/config.json",')

From e426b11e46f02d895742babb3bb2c4b9ca517e35 Mon Sep 17 00:00:00 2001
From: Braxton Schafer <braxton@cmdcentral.xyz>
Date: Mon, 25 May 2026 09:24:19 -0500
Subject: [PATCH 05/31] feat(tui): make prompt size responsive and configurable
 (#28255)

---
 .../src/cli/cmd/tui/component/prompt/index.tsx      | 10 ++++++++--
 .../opencode/src/cli/cmd/tui/config/tui-schema.ts   | 10 ++++++++++
 packages/opencode/src/cli/cmd/tui/routes/home.tsx   | 13 +++++++++++--
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx b/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx
index 0566e07b3451..e8affacda742 100644
--- a/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx
@@ -1464,11 +1464,15 @@ export function Prompt(props: PromptProps) {
       }),
     }
   })
+  const maxHeight = createMemo(
+    () => tuiConfig.prompt?.max_height ?? Math.max(6, Math.floor(dimensions().height / 3)),
+  )
 
   return (
     <>
-      <box ref={(r: BoxRenderable) => (anchor = r)} visible={props.visible !== false}>
+      <box ref={(r: BoxRenderable) => (anchor = r)} visible={props.visible !== false} width="100%">
         <box
+          width="100%"
           border={["left"]}
           borderColor={borderHighlight()}
           customBorderChars={{
@@ -1483,14 +1487,16 @@ export function Prompt(props: PromptProps) {
             flexShrink={0}
             backgroundColor={theme.backgroundElement}
             flexGrow={1}
+            width="100%"
           >
             <textarea
+              width="100%"
               placeholder={placeholderText()}
               placeholderColor={theme.textMuted}
               textColor={leader() ? theme.textMuted : theme.text}
               focusedTextColor={leader() ? theme.textMuted : theme.text}
               minHeight={1}
-              maxHeight={6}
+              maxHeight={maxHeight()}
               onContentChange={() => {
                 const value = input.plainText
                 setStore("prompt", "input", value)
diff --git a/packages/opencode/src/cli/cmd/tui/config/tui-schema.ts b/packages/opencode/src/cli/cmd/tui/config/tui-schema.ts
index 2c99f2a5ef61..3cdfe8770aa4 100644
--- a/packages/opencode/src/cli/cmd/tui/config/tui-schema.ts
+++ b/packages/opencode/src/cli/cmd/tui/config/tui-schema.ts
@@ -61,6 +61,15 @@ export const Attention = Schema.Struct({
   sounds: Schema.optional(TuiAttentionSounds),
 }).annotate({ description: "Attention notification and sound settings" })
 
+const PromptSize = Schema.Int.check(Schema.isGreaterThan(0))
+
+export const Prompt = Schema.Struct({
+  max_height: Schema.optional(PromptSize).annotate({ description: "Prompt textarea max height" }),
+  max_width: Schema.optional(Schema.Union([PromptSize, Schema.Literal("auto")])).annotate({
+    description: "Home prompt max width: a positive integer for a fixed cap, or 'auto' to scale with terminal width",
+  }),
+}).annotate({ description: "Prompt size settings" })
+
 export const TuiInfo = Schema.Struct({
   $schema: Schema.optional(Schema.String),
   theme: Schema.optional(Schema.String),
@@ -69,6 +78,7 @@ export const TuiInfo = Schema.Struct({
   plugin_enabled: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
   leader_timeout: Schema.optional(KeymapLeaderTimeout),
   attention: Schema.optional(Attention),
+  prompt: Schema.optional(Prompt),
   scroll_speed: Schema.optional(ScrollSpeed).annotate({
     description: "TUI scroll speed",
   }),
diff --git a/packages/opencode/src/cli/cmd/tui/routes/home.tsx b/packages/opencode/src/cli/cmd/tui/routes/home.tsx
index bbdbecf3295f..16797573c007 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/home.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/home.tsx
@@ -1,5 +1,5 @@
 import { Prompt, type PromptRef } from "@tui/component/prompt"
-import { createEffect, createSignal, onMount } from "solid-js"
+import { createEffect, createMemo, createSignal, onMount } from "solid-js"
 import { Logo } from "../component/logo"
 import { useSync } from "../context/sync"
 import { Toast } from "../ui/toast"
@@ -9,6 +9,8 @@ import { usePromptRef } from "../context/prompt"
 import { useLocal } from "../context/local"
 import { TuiPluginRuntime } from "@/cli/cmd/tui/plugin/runtime"
 import { useEditorContext } from "@tui/context/editor"
+import { useTerminalDimensions } from "@opentui/solid"
+import { useTuiConfig } from "../context/tui-config"
 
 let once = false
 const placeholder = {
@@ -24,6 +26,13 @@ export function Home() {
   const args = useArgs()
   const local = useLocal()
   const editor = useEditorContext()
+  const dimensions = useTerminalDimensions()
+  const tuiConfig = useTuiConfig()
+  const promptMaxWidth = createMemo(() => {
+    const configured = tuiConfig.prompt?.max_width
+    if (configured === "auto") return Math.max(75, Math.floor(dimensions().width * 0.7))
+    return configured ?? 75
+  })
   let sent = false
 
   onMount(() => {
@@ -67,7 +76,7 @@ export function Home() {
           </TuiPluginRuntime.Slot>
         </box>
         <box height={1} minHeight={0} flexShrink={1} />
-        <box width="100%" maxWidth={75} zIndex={1000} paddingTop={1} flexShrink={0}>
+        <box width="100%" maxWidth={promptMaxWidth()} zIndex={1000} paddingTop={1} flexShrink={0}>
           <TuiPluginRuntime.Slot name="home_prompt" mode="replace" ref={bind}>
             <Prompt ref={bind} right={<TuiPluginRuntime.Slot name="home_prompt_right" />} placeholders={placeholder} />
           </TuiPluginRuntime.Slot>

From 054ca3a2e94b87fa9a7f0d16548e5607aa54a311 Mon Sep 17 00:00:00 2001
From: "opencode-agent[bot]" <opencode-agent[bot]@users.noreply.github.com>
Date: Mon, 25 May 2026 14:25:37 +0000
Subject: [PATCH 06/31] chore: generate

---
 packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx b/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx
index e8affacda742..64b7181e6313 100644
--- a/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx
@@ -1464,9 +1464,7 @@ export function Prompt(props: PromptProps) {
       }),
     }
   })
-  const maxHeight = createMemo(
-    () => tuiConfig.prompt?.max_height ?? Math.max(6, Math.floor(dimensions().height / 3)),
-  )
+  const maxHeight = createMemo(() => tuiConfig.prompt?.max_height ?? Math.max(6, Math.floor(dimensions().height / 3)))
 
   return (
     <>

From 24a0fe7b3f4035b2a860f2eff51ef3a0cf96aa33 Mon Sep 17 00:00:00 2001
From: Victor Navarro <vn4varro@gmail.com>
Date: Mon, 25 May 2026 16:39:56 +0200
Subject: [PATCH 07/31] perf: use redis/upstash for ip rate limits (#28694)

---
 bun.lock                                      |  3 +
 infra/console.ts                              |  2 +
 infra/secret.ts                               |  3 +
 packages/console/app/package.json             |  1 +
 .../app/src/routes/zen/util/ipRateLimiter.ts  | 76 ++++++++++++-------
 .../console/app/src/routes/zen/util/redis.ts  | 18 +++++
 sst-env.d.ts                                  |  8 ++
 7 files changed, 83 insertions(+), 28 deletions(-)
 create mode 100644 packages/console/app/src/routes/zen/util/redis.ts

diff --git a/bun.lock b/bun.lock
index 51cc671ad1e5..740bbf0c4509 100644
--- a/bun.lock
+++ b/bun.lock
@@ -102,6 +102,7 @@
         "@solidjs/router": "catalog:",
         "@solidjs/start": "catalog:",
         "@stripe/stripe-js": "8.6.1",
+        "@upstash/redis": "1.38.0",
         "chart.js": "4.5.1",
         "nitro": "3.0.1-alpha.1",
         "solid-js": "catalog:",
@@ -2469,6 +2470,8 @@
 
     "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="],
 
+    "@upstash/redis": ["@upstash/redis@1.38.0", "", { "dependencies": { "uncrypto": "^0.1.3" } }, "sha512-wu+dZBptlLy0+MCUEoHmzrY/TnmgDey3+c7EbIGwrLqAvkP8yi5MWZHYGIFtAygmL4Bkz2TdFu+eU0vFPncIcg=="],
+
     "@valibot/to-json-schema": ["@valibot/to-json-schema@1.6.0", "", { "peerDependencies": { "valibot": "^1.3.0" } }, "sha512-d6rYyK5KVa2XdqamWgZ4/Nr+cXhxjy7lmpe6Iajw15J/jmU+gyxl2IEd1Otg1d7Rl3gOQL5reulnSypzBtYy1A=="],
 
     "@vercel/oidc": ["@vercel/oidc@3.2.0", "", {}, "sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug=="],
diff --git a/infra/console.ts b/infra/console.ts
index 2a74c1270594..cf1fba823728 100644
--- a/infra/console.ts
+++ b/infra/console.ts
@@ -250,6 +250,8 @@ new sst.cloudflare.x.SolidStart("Console", {
     bucket,
     bucketNew,
     database,
+    SECRET.UpstashRedisRestUrl,
+    SECRET.UpstashRedisRestToken,
     AUTH_API_URL,
     STRIPE_WEBHOOK_SECRET,
     DISCORD_INCIDENT_WEBHOOK_URL,
diff --git a/infra/secret.ts b/infra/secret.ts
index d4e8b148fc3a..8a89c01f8b62 100644
--- a/infra/secret.ts
+++ b/infra/secret.ts
@@ -8,4 +8,7 @@ export const SECRET = {
   R2AccessKey: new sst.Secret("R2AccessKey", "unknown"),
   R2SecretKey: new sst.Secret("R2SecretKey", "unknown"),
   HoneycombWebhookSecret: new random.RandomPassword("HoneycombWebhookSecret", { length: 24 }),
+  UpstashRedisRestUrl: new sst.Secret("UpstashRedisRestUrl"),
+  UpstashRedisRestToken: new sst.Secret("UpstashRedisRestToken"),
 }
+
diff --git a/packages/console/app/package.json b/packages/console/app/package.json
index 86e7da2531ee..b93c15cdcea1 100644
--- a/packages/console/app/package.json
+++ b/packages/console/app/package.json
@@ -26,6 +26,7 @@
     "@solidjs/router": "catalog:",
     "@solidjs/start": "catalog:",
     "@stripe/stripe-js": "8.6.1",
+    "@upstash/redis": "1.38.0",
     "chart.js": "4.5.1",
     "nitro": "3.0.1-alpha.1",
     "solid-js": "catalog:",
diff --git a/packages/console/app/src/routes/zen/util/ipRateLimiter.ts b/packages/console/app/src/routes/zen/util/ipRateLimiter.ts
index 177d78514ac0..81f73a4e5ab3 100644
--- a/packages/console/app/src/routes/zen/util/ipRateLimiter.ts
+++ b/packages/console/app/src/routes/zen/util/ipRateLimiter.ts
@@ -2,6 +2,7 @@ import { Database, eq, and, sql, inArray } from "@opencode-ai/console-core/drizz
 import { IpRateLimitTable } from "@opencode-ai/console-core/schema/ip.sql.js"
 import { FreeUsageLimitError } from "./error"
 import { logger } from "./logger"
+import { buildRateLimitKey, getRedis } from "./redis"
 import { i18n } from "~/i18n"
 import { localeFromRequest } from "~/lib/language"
 import { Subscription } from "@opencode-ai/console-core/subscription.js"
@@ -23,43 +24,62 @@ export function createRateLimiter(modelId: string, rateLimit: number | undefined
   const now = Date.now()
   const lifetimeInterval = ""
   const dailyInterval = rateLimit ? `${buildYYYYMMDD(now)}${modelId.substring(0, 2)}` : buildYYYYMMDD(now)
-
-  let _isNew: boolean
+  const retryAfter = getRetryAfterDay(now)
+  const redis = getRedis()
+  const lifetimeKey = buildRateLimitKey("ip", ip)
+  const dailyKey = buildRateLimitKey("ip", ip, dailyInterval)
+  let isNew = false
 
   return {
     check: async () => {
-      const rows = await Database.use((tx) =>
-        tx
-          .select({ interval: IpRateLimitTable.interval, count: IpRateLimitTable.count })
-          .from(IpRateLimitTable)
-          .where(
-            and(
-              eq(IpRateLimitTable.ip, ip),
-              isDefaultModel
-                ? inArray(IpRateLimitTable.interval, [lifetimeInterval, dailyInterval])
-                : inArray(IpRateLimitTable.interval, [dailyInterval]),
+      const [counts, rows] = await Promise.all([
+        redis.mget<(string | number | null)[]>(isDefaultModel ? [lifetimeKey, dailyKey] : [dailyKey]).catch(() => []),
+        Database.use((tx) =>
+          tx
+            .select({ interval: IpRateLimitTable.interval, count: IpRateLimitTable.count })
+            .from(IpRateLimitTable)
+            .where(
+              and(
+                eq(IpRateLimitTable.ip, ip),
+                isDefaultModel
+                  ? inArray(IpRateLimitTable.interval, [lifetimeInterval, dailyInterval])
+                  : inArray(IpRateLimitTable.interval, [dailyInterval]),
+              ),
             ),
-          ),
-      )
-      const lifetimeCount = rows.find((r) => r.interval === lifetimeInterval)?.count ?? 0
-      const dailyCount = rows.find((r) => r.interval === dailyInterval)?.count ?? 0
+        ),
+      ])
+      const redisLifetimeCount = isDefaultModel ? Number(counts[0] ?? 0) : 0
+      const redisDailyCount = Number(counts[isDefaultModel ? 1 : 0] ?? 0)
+      const databaseLifetimeCount = rows.find((r) => r.interval === lifetimeInterval)?.count ?? 0
+      const databaseDailyCount = rows.find((r) => r.interval === dailyInterval)?.count ?? 0
+      const lifetimeCount = Math.max(redisLifetimeCount, databaseLifetimeCount)
+      const dailyCount = Math.max(redisDailyCount, databaseDailyCount)
       logger.debug(`rate limit lifetime: ${lifetimeCount}, daily: ${dailyCount}`)
 
-      _isNew = isDefaultModel && lifetimeCount < dailyLimit * 7
+      isNew = isDefaultModel && lifetimeCount < dailyLimit * 7
+      if (isDefaultModel && databaseLifetimeCount > redisLifetimeCount)
+        await redis.set(lifetimeKey, databaseLifetimeCount).catch(() => {})
 
-      if ((_isNew && dailyCount >= dailyLimit * 2) || (!_isNew && dailyCount >= dailyLimit))
-        throw new FreeUsageLimitError(dict["zen.api.error.rateLimitExceeded"], getRetryAfterDay(now))
+      if ((isNew && dailyCount >= dailyLimit * 2) || (!isNew && dailyCount >= dailyLimit))
+        throw new FreeUsageLimitError(dict["zen.api.error.rateLimitExceeded"], retryAfter)
     },
     track: async () => {
-      await Database.use((tx) =>
-        tx
-          .insert(IpRateLimitTable)
-          .values([
-            { ip, interval: dailyInterval, count: 1 },
-            ...(_isNew ? [{ ip, interval: lifetimeInterval, count: 1 }] : []),
-          ])
-          .onDuplicateKeyUpdate({ set: { count: sql`${IpRateLimitTable.count} + 1` } }),
-      )
+      const pipeline = redis.pipeline()
+      pipeline.incr(dailyKey)
+      pipeline.expire(dailyKey, retryAfter)
+      if (isNew) pipeline.incr(lifetimeKey)
+      await Promise.all([
+        pipeline.exec().catch(() => {}),
+        Database.use((tx) =>
+          tx
+            .insert(IpRateLimitTable)
+            .values([
+              { ip, interval: dailyInterval, count: 1 },
+              ...(isNew ? [{ ip, interval: lifetimeInterval, count: 1 }] : []),
+            ])
+            .onDuplicateKeyUpdate({ set: { count: sql`${IpRateLimitTable.count} + 1` } }),
+        ),
+      ])
     },
   }
 }
diff --git a/packages/console/app/src/routes/zen/util/redis.ts b/packages/console/app/src/routes/zen/util/redis.ts
new file mode 100644
index 000000000000..512523298a85
--- /dev/null
+++ b/packages/console/app/src/routes/zen/util/redis.ts
@@ -0,0 +1,18 @@
+import { Resource } from "@opencode-ai/console-resource"
+import { Redis } from "@upstash/redis/cloudflare"
+
+let redis: Redis | undefined
+
+export function getRedis() {
+  if (redis) return redis
+  redis = new Redis({
+    url: Resource.UpstashRedisRestUrl.value,
+    token: Resource.UpstashRedisRestToken.value,
+    enableTelemetry: false,
+  })
+  return redis
+}
+
+export function buildRateLimitKey(kind: string, identifier: string, interval?: string) {
+  return `${Resource.App.stage}:ratelimit:${kind}:${identifier}${interval ? `:${interval}` : ""}`
+}
diff --git a/sst-env.d.ts b/sst-env.d.ts
index 1eaebd1e59cb..aa79ec87d38d 100644
--- a/sst-env.d.ts
+++ b/sst-env.d.ts
@@ -137,6 +137,14 @@ declare module "sst" {
       "type": "sst.cloudflare.SolidStart"
       "url": string
     }
+    "UpstashRedisRestToken": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
+    "UpstashRedisRestUrl": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
     "Web": {
       "type": "sst.cloudflare.Astro"
       "url": string

From 68d183316ea33bca84d73e136f87fdd00d3489cf Mon Sep 17 00:00:00 2001
From: "opencode-agent[bot]" <opencode-agent[bot]@users.noreply.github.com>
Date: Mon, 25 May 2026 14:41:16 +0000
Subject: [PATCH 08/31] chore: generate

---
 infra/secret.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/infra/secret.ts b/infra/secret.ts
index 8a89c01f8b62..eafbd91ed293 100644
--- a/infra/secret.ts
+++ b/infra/secret.ts
@@ -11,4 +11,3 @@ export const SECRET = {
   UpstashRedisRestUrl: new sst.Secret("UpstashRedisRestUrl"),
   UpstashRedisRestToken: new sst.Secret("UpstashRedisRestToken"),
 }
-

From d5b6345607e10faa1fe0ebff5f3a17ae0dbc5c7b Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 20:19:06 +0530
Subject: [PATCH 09/31] test(acp): add compatibility baseline (#29222)

---
 .../acp/acp-compatibility-baseline.test.ts    | 322 ++++++++++++++++++
 .../opencode/test/cli/acp/acp-test-client.ts  |  96 ++++++
 2 files changed, 418 insertions(+)
 create mode 100644 packages/opencode/test/cli/acp/acp-compatibility-baseline.test.ts
 create mode 100644 packages/opencode/test/cli/acp/acp-test-client.ts

diff --git a/packages/opencode/test/cli/acp/acp-compatibility-baseline.test.ts b/packages/opencode/test/cli/acp/acp-compatibility-baseline.test.ts
new file mode 100644
index 000000000000..535203938319
--- /dev/null
+++ b/packages/opencode/test/cli/acp/acp-compatibility-baseline.test.ts
@@ -0,0 +1,322 @@
+import { describe, expect } from "bun:test"
+import type {
+  CloseSessionResponse,
+  InitializeResponse,
+  NewSessionResponse,
+  ResumeSessionResponse,
+  SessionNotification,
+  SetSessionConfigOptionResponse,
+} from "@agentclientprotocol/sdk"
+import { Effect } from "effect"
+import { mkdir } from "node:fs/promises"
+import path from "node:path"
+import { cliIt } from "../../lib/cli-process"
+import { testProviderConfig } from "../../lib/test-provider"
+import {
+  createAcpClient,
+  expectOk,
+  firstAlternateValue,
+  flattenSelectOptions,
+  selectConfigOption,
+} from "./acp-test-client"
+
+describe("opencode acp verifier compatibility baseline", () => {
+  cliIt.live(
+    "initialize advertises close and resume capabilities",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp())
+        const initialized = expectOk(
+          yield* acp.request<InitializeResponse>("initialize", {
+            protocolVersion: 1,
+          }),
+        )
+
+        expect(initialized.protocolVersion).toBe(1)
+        expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
+        expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "first session timing diagnostic stays bounded and returns model options",
+    ({ home, llm, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(
+          yield* opencode.acp({
+            env: {
+              OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
+            },
+          }),
+        )
+        const started = Date.now()
+        yield* acp.request<InitializeResponse>("initialize", {
+          protocolVersion: 1,
+          clientCapabilities: {},
+          clientInfo: { name: "opencode-local-acp-baseline", version: "0.1.0" },
+        })
+        const session = expectOk(
+          yield* acp.request<NewSessionResponse>("session/new", {
+            cwd: home,
+            mcpServers: [],
+          }),
+        )
+        const durationMs = Date.now() - started
+        expect(durationMs).toBeLessThan(15_000)
+
+        const model = selectConfigOption(session.configOptions, "model")
+        expect(model?.category).toBe("model")
+        expect(model?.currentValue).toBe("test/test-model")
+        expect(model ? flattenSelectOptions(model).length : 0).toBeGreaterThanOrEqual(2)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "warm newSession timing diagnostic stays bounded",
+    ({ home, llm, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(
+          yield* opencode.acp({
+            env: {
+              OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
+            },
+          }),
+        )
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+        yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] })
+
+        const started = Date.now()
+        const session = expectOk(
+          yield* acp.request<NewSessionResponse>("session/new", {
+            cwd: home,
+            mcpServers: [],
+          }),
+        )
+        const durationMs = Date.now() - started
+        expect(durationMs).toBeLessThan(15_000)
+        expect(session.sessionId).toBeTruthy()
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "model switch timing diagnostic updates currentValue",
+    ({ home, llm, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(
+          yield* opencode.acp({
+            env: {
+              OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
+            },
+          }),
+        )
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+        const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
+        const model = selectConfigOption(session.configOptions, "model")
+        expect(model).toBeDefined()
+        const nextModel = model
+          ? flattenSelectOptions(model).find((option) => option.value === "test/second-model")?.value
+          : undefined
+        expect(nextModel).toBe("test/second-model")
+
+        const started = Date.now()
+        const updated = expectOk(
+          yield* acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
+            sessionId: session.sessionId,
+            configId: "model",
+            value: nextModel,
+          }),
+        )
+        const durationMs = Date.now() - started
+
+        expect(durationMs).toBeLessThan(15_000)
+        expect(selectConfigOption(updated.configOptions, "model")?.currentValue).toBe(nextModel)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "effort option is listed for variant-capable models and can switch",
+    ({ home, llm, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(
+          yield* opencode.acp({
+            env: {
+              OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
+            },
+          }),
+        )
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+        const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
+        const effort = selectConfigOption(session.configOptions, "effort")
+        expect(effort?.category).toBe("thought_level")
+        const nextEffort = effort ? firstAlternateValue(effort) : undefined
+        expect(nextEffort).toBe("high")
+
+        const updated = expectOk(
+          yield* acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
+            sessionId: session.sessionId,
+            configId: "effort",
+            value: nextEffort,
+          }),
+        )
+
+        expect(selectConfigOption(updated.configOptions, "effort")?.currentValue).toBe(nextEffort)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "default test provider documents missing effort option when the model has no variants",
+    ({ home, llm, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(
+          yield* opencode.acp({
+            env: {
+              OPENCODE_CONFIG_CONTENT: JSON.stringify(noVariantConfig(llm.url)),
+            },
+          }),
+        )
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+        const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
+
+        expect(selectConfigOption(session.configOptions, "model")?.currentValue).toBe("test/test-model")
+        expect(selectConfigOption(session.configOptions, "effort")).toBeUndefined()
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "skill slash command timing diagnostic appears through available_commands_update",
+    ({ home, llm, opencode }) =>
+      Effect.gen(function* () {
+        const skills = path.join(home, "skills")
+        yield* Effect.promise(() => mkdir(path.join(skills, "verifier-skill"), { recursive: true }))
+        yield* Effect.promise(() => Bun.write(path.join(skills, "verifier-skill", "SKILL.md"), verifierSkill))
+        const acp = createAcpClient(
+          yield* opencode.acp({
+            env: {
+              OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url, skills)),
+            },
+          }),
+        )
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+        const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
+
+        const update = yield* acp.waitForNotification<SessionNotification>(
+          "session/update",
+          (params) =>
+            params.sessionId === session.sessionId &&
+            params.update.sessionUpdate === "available_commands_update" &&
+            params.update.availableCommands.some((command) => command.name === "verifier-skill"),
+        )
+
+        expect(update.params?.sessionId).toBe(session.sessionId)
+
+        const secondSession = expectOk(
+          yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }),
+        )
+        const started = Date.now()
+        yield* acp.waitForNotification<SessionNotification>(
+          "session/update",
+          (params) =>
+            params.sessionId === secondSession.sessionId &&
+            params.update.sessionUpdate === "available_commands_update" &&
+            params.update.availableCommands.some((command) => command.name === "verifier-skill"),
+        )
+        const durationMs = Date.now() - started
+        expect(durationMs).toBeLessThan(15_000)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "close request succeeds for a live session",
+    ({ home, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp())
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+        const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
+
+        expectOk(yield* acp.request<CloseSessionResponse>("session/close", { sessionId: session.sessionId }))
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "resume request succeeds for a created session",
+    ({ home, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp())
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+        const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
+
+        const resumed = expectOk(
+          yield* acp.request<ResumeSessionResponse>("session/resume", {
+            sessionId: session.sessionId,
+            cwd: home,
+            mcpServers: [],
+          }),
+        )
+        expect(resumed.configOptions?.length).toBeGreaterThan(0)
+      }),
+    60_000,
+  )
+})
+
+function verifierConfig(llmUrl: string, skills?: string) {
+  const config = testProviderConfig(llmUrl)
+  return {
+    ...config,
+    model: "test/test-model",
+    ...(skills ? { skills: { paths: [skills] } } : {}),
+    provider: {
+      test: {
+        ...config.provider.test,
+        models: {
+          "test-model": {
+            ...config.provider.test.models["test-model"],
+            variants: {
+              low: {},
+              high: {},
+            },
+          },
+          "second-model": {
+            ...config.provider.test.models["test-model"],
+            id: "second-model",
+            name: "Second Test Model",
+          },
+        },
+      },
+    },
+  }
+}
+
+function noVariantConfig(llmUrl: string) {
+  const config = verifierConfig(llmUrl)
+  return {
+    ...config,
+    provider: {
+      test: {
+        ...config.provider.test,
+        models: {
+          "test-model": {
+            ...config.provider.test.models["test-model"],
+            variants: undefined,
+          },
+          "second-model": config.provider.test.models["second-model"],
+        },
+      },
+    },
+  }
+}
+
+const verifierSkill = `---
+name: verifier-skill
+description: Verifier compatibility skill.
+---
+
+# Verifier Skill
+`
diff --git a/packages/opencode/test/cli/acp/acp-test-client.ts b/packages/opencode/test/cli/acp/acp-test-client.ts
new file mode 100644
index 000000000000..f8a5700b8b0f
--- /dev/null
+++ b/packages/opencode/test/cli/acp/acp-test-client.ts
@@ -0,0 +1,96 @@
+import { expect } from "bun:test"
+import type { SessionConfigOption, SessionConfigSelectOption } from "@agentclientprotocol/sdk"
+import { Duration, Effect } from "effect"
+import type { AcpHandle } from "../../lib/cli-process"
+
+type JsonRpcRequest = {
+  readonly jsonrpc: "2.0"
+  readonly id: number
+  readonly method: string
+  readonly params?: unknown
+}
+
+type JsonRpcResponse<T = unknown> = {
+  readonly jsonrpc: "2.0"
+  readonly id: number
+  readonly result?: T
+  readonly error?: unknown
+}
+
+type JsonRpcNotification<T = unknown> = {
+  readonly jsonrpc: "2.0"
+  readonly method: string
+  readonly params?: T
+}
+
+export type AcpClient = {
+  readonly request: <T>(method: string, params?: unknown) => Effect.Effect<JsonRpcResponse<T>, unknown>
+  readonly receive: Effect.Effect<unknown>
+  readonly waitForNotification: <T>(
+    method: string,
+    predicate: (params: T) => boolean,
+    timeoutMs?: number,
+  ) => Effect.Effect<JsonRpcNotification<T>, unknown>
+}
+
+export function createAcpClient(acp: AcpHandle): AcpClient {
+  const state = { nextId: 1 }
+
+  const request = <T>(method: string, params?: unknown) =>
+    Effect.gen(function* () {
+      const id = state.nextId++
+      const message: JsonRpcRequest =
+        params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params }
+      yield* acp.send(message)
+
+      while (true) {
+        const received = yield* acp.receive.pipe(Effect.timeout(Duration.seconds(15)))
+        if (isJsonRpcResponse<T>(received) && received.id === id) return received
+      }
+    })
+
+  const waitForNotification = <T>(method: string, predicate: (params: T) => boolean, timeoutMs = 15_000) =>
+    Effect.gen(function* () {
+      while (true) {
+        const received = yield* acp.receive.pipe(Effect.timeout(Duration.millis(timeoutMs)))
+        if (!isJsonRpcNotification<T>(received)) continue
+        if (received.method === method && predicate(received.params as T)) return received
+      }
+    })
+
+  return {
+    request,
+    receive: acp.receive,
+    waitForNotification,
+  }
+}
+
+export function expectOk<T>(response: JsonRpcResponse<T>) {
+  expect(response.error).toBeUndefined()
+  expect(response.result).toBeDefined()
+  return response.result as T
+}
+
+export function selectConfigOption(options: SessionConfigOption[] | null | undefined, id: string) {
+  return options?.find(
+    (option): option is Extract<SessionConfigOption, { type: "select" }> => option.id === id && option.type === "select",
+  )
+}
+
+export function firstAlternateValue(option: Extract<SessionConfigOption, { type: "select" }>) {
+  return flattenSelectOptions(option).find((item) => item.value !== option.currentValue)?.value
+}
+
+export function flattenSelectOptions(option: Extract<SessionConfigOption, { type: "select" }>) {
+  return option.options.flatMap((item): SessionConfigSelectOption[] => ("value" in item ? [item] : item.options))
+}
+
+function isJsonRpcResponse<T>(input: unknown): input is JsonRpcResponse<T> {
+  if (!input || typeof input !== "object") return false
+  return "id" in input && "jsonrpc" in input
+}
+
+function isJsonRpcNotification<T>(input: unknown): input is JsonRpcNotification<T> {
+  if (!input || typeof input !== "object") return false
+  return "method" in input && !("id" in input) && "jsonrpc" in input
+}

From 658b9387448302604057ef88a3e34d0453b591f1 Mon Sep 17 00:00:00 2001
From: "opencode-agent[bot]" <opencode-agent[bot]@users.noreply.github.com>
Date: Mon, 25 May 2026 14:50:18 +0000
Subject: [PATCH 10/31] chore: generate

---
 packages/opencode/test/cli/acp/acp-test-client.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/opencode/test/cli/acp/acp-test-client.ts b/packages/opencode/test/cli/acp/acp-test-client.ts
index f8a5700b8b0f..1588d344d744 100644
--- a/packages/opencode/test/cli/acp/acp-test-client.ts
+++ b/packages/opencode/test/cli/acp/acp-test-client.ts
@@ -73,7 +73,8 @@ export function expectOk<T>(response: JsonRpcResponse<T>) {
 
 export function selectConfigOption(options: SessionConfigOption[] | null | undefined, id: string) {
   return options?.find(
-    (option): option is Extract<SessionConfigOption, { type: "select" }> => option.id === id && option.type === "select",
+    (option): option is Extract<SessionConfigOption, { type: "select" }> =>
+      option.id === id && option.type === "select",
   )
 }
 

From 5477b4e23e05e4488451dab92b0208923c297413 Mon Sep 17 00:00:00 2001
From: "opencode-agent[bot]" <opencode-agent[bot]@users.noreply.github.com>
Date: Mon, 25 May 2026 15:03:04 +0000
Subject: [PATCH 11/31] chore: update nix node_modules hashes

---
 nix/hashes.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/nix/hashes.json b/nix/hashes.json
index 75a54eac62a0..8578dab16a33 100644
--- a/nix/hashes.json
+++ b/nix/hashes.json
@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-Nol27sqG6za6oR32MqZrmRxch0/XFeQ61C9Yqtxo7Hk=",
-    "aarch64-linux": "sha256-+jfkGr4tuv/s/v890XaFTRqUxwA8H8KVMiys6sEXi/4=",
-    "aarch64-darwin": "sha256-FYtKluNazzuQcrr2iHm7B2pJfYrAHkbcj4kWs2FtBgc=",
-    "x86_64-darwin": "sha256-PpyWDkzb0p50US7Bs3m3A4PZ0JM3dccGgTKYN9JFYR0="
+    "x86_64-linux": "sha256-Wdo61RItv595JUIh3ElBXtj0B4y2KpsAJ2WbNNBsO1E=",
+    "aarch64-linux": "sha256-lVNN5fqBj+qxmxN/NiDxZF3kaJ4wDD1ZCylh7yuS1PA=",
+    "aarch64-darwin": "sha256-1NXdnraknHeLyzSCSKYyG4W86KLwn8hCqHkaLfhLdzM=",
+    "x86_64-darwin": "sha256-UVupTsKwLnJ2E0IBx9/JraBJ4U6O1obI/OR3RE64/jU="
   }
 }

From ca9d85772001dfcc45ba4b0edf9c4c2222333796 Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 20:33:40 +0530
Subject: [PATCH 12/31] feat(acp): add initial acp-next skeleton behind runtime
 flag (#29226)

---
 packages/opencode/src/acp-next/agent.ts       |  60 ++++++++++
 packages/opencode/src/acp-next/service.ts     | 102 +++++++++++++++++
 packages/opencode/src/cli/cmd/acp.ts          |   5 +-
 packages/opencode/src/effect/runtime-flags.ts |   1 +
 .../cli/acp-next/acp-next-process.test.ts     | 104 ++++++++++++++++++
 5 files changed, 271 insertions(+), 1 deletion(-)
 create mode 100644 packages/opencode/src/acp-next/agent.ts
 create mode 100644 packages/opencode/src/acp-next/service.ts
 create mode 100644 packages/opencode/test/cli/acp-next/acp-next-process.test.ts

diff --git a/packages/opencode/src/acp-next/agent.ts b/packages/opencode/src/acp-next/agent.ts
new file mode 100644
index 000000000000..b656b6331f65
--- /dev/null
+++ b/packages/opencode/src/acp-next/agent.ts
@@ -0,0 +1,60 @@
+import {
+  RequestError,
+  type Agent as ACPAgent,
+  type AgentSideConnection,
+  type AuthenticateRequest,
+  type CancelNotification,
+  type InitializeRequest,
+  type NewSessionRequest,
+  type PromptRequest,
+} from "@agentclientprotocol/sdk"
+import { Effect } from "effect"
+import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+import * as ACPNextService from "./service"
+
+export function init({ sdk: _sdk }: { sdk: OpencodeClient }) {
+  return {
+    create: (_connection: AgentSideConnection) => {
+      return new Agent(ACPNextService.make())
+    },
+  }
+}
+
+export class Agent implements ACPAgent {
+  constructor(private readonly service: ACPNextService.Interface) {}
+
+  initialize(params: InitializeRequest) {
+    return run(this.service.initialize(params))
+  }
+
+  authenticate(params: AuthenticateRequest) {
+    return run(this.service.authenticate(params))
+  }
+
+  newSession(params: NewSessionRequest) {
+    return run(this.service.newSession(params))
+  }
+
+  prompt(params: PromptRequest) {
+    return run(this.service.prompt(params))
+  }
+
+  cancel(params: CancelNotification) {
+    return run(this.service.cancel(params))
+  }
+}
+
+function run<A>(effect: Effect.Effect<A, ACPNextService.Error>) {
+  return Effect.runPromise(effect.pipe(Effect.mapError(toRequestError)))
+}
+
+function toRequestError(error: ACPNextService.Error) {
+  switch (error._tag) {
+    case "ACPNextUnknownAuthMethodError":
+      return RequestError.invalidParams({ methodId: error.methodId }, `unknown auth method: ${error.methodId}`)
+    case "ACPNextUnsupportedOperationError":
+      return RequestError.methodNotFound(error.method)
+  }
+}
+
+export * as ACPNext from "./agent"
diff --git a/packages/opencode/src/acp-next/service.ts b/packages/opencode/src/acp-next/service.ts
new file mode 100644
index 000000000000..b90c9c17547e
--- /dev/null
+++ b/packages/opencode/src/acp-next/service.ts
@@ -0,0 +1,102 @@
+import {
+  type AuthenticateRequest,
+  type AuthenticateResponse,
+  type AuthMethod,
+  type CancelNotification,
+  type InitializeRequest,
+  type InitializeResponse,
+  type NewSessionRequest,
+  type NewSessionResponse,
+  type PromptRequest,
+  type PromptResponse,
+} from "@agentclientprotocol/sdk"
+import { InstallationVersion } from "@opencode-ai/core/installation/version"
+import { Context, Effect, Schema } from "effect"
+
+export const AuthMethodID = "opencode-login"
+
+export class UnknownAuthMethodError extends Schema.TaggedErrorClass<UnknownAuthMethodError>()(
+  "ACPNextUnknownAuthMethodError",
+  {
+    methodId: Schema.String,
+  },
+) {}
+
+export class UnsupportedOperationError extends Schema.TaggedErrorClass<UnsupportedOperationError>()(
+  "ACPNextUnsupportedOperationError",
+  {
+    method: Schema.String,
+  },
+) {}
+
+export type Error = UnknownAuthMethodError | UnsupportedOperationError
+
+export type Interface = {
+  readonly initialize: (input: InitializeRequest) => Effect.Effect<InitializeResponse, Error>
+  readonly authenticate: (input: AuthenticateRequest) => Effect.Effect<AuthenticateResponse, Error>
+  readonly newSession: (input: NewSessionRequest) => Effect.Effect<NewSessionResponse, Error>
+  readonly prompt: (input: PromptRequest) => Effect.Effect<PromptResponse, Error>
+  readonly cancel: (input: CancelNotification) => Effect.Effect<void, Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/ACPNext/Service") {}
+
+export function make(): Interface {
+  const initialize = Effect.fn("ACPNext.initialize")(function* (params: InitializeRequest) {
+    const authMethod: AuthMethod = {
+      description: "Run `opencode auth login` in the terminal",
+      name: "Login with opencode",
+      id: AuthMethodID,
+    }
+
+    if (params.clientCapabilities?._meta?.["terminal-auth"] === true) {
+      authMethod._meta = {
+        "terminal-auth": {
+          command: "opencode",
+          args: ["auth", "login"],
+          label: "OpenCode Login",
+        },
+      }
+    }
+
+    return {
+      protocolVersion: 1,
+      agentCapabilities: {
+        mcpCapabilities: {
+          http: true,
+          sse: true,
+        },
+        promptCapabilities: {
+          embeddedContext: true,
+          image: true,
+        },
+      },
+      authMethods: [authMethod],
+      agentInfo: {
+        name: "OpenCode",
+        version: InstallationVersion,
+      },
+    }
+  })
+
+  const authenticate = Effect.fn("ACPNext.authenticate")(function* (params: AuthenticateRequest) {
+    if (params.methodId !== AuthMethodID) {
+      return yield* new UnknownAuthMethodError({ methodId: params.methodId })
+    }
+    return {}
+  })
+
+  return {
+    initialize,
+    authenticate,
+    newSession: Effect.fn("ACPNext.newSession")(function* (_input: NewSessionRequest) {
+      return yield* new UnsupportedOperationError({ method: "session/new" })
+    }),
+    prompt: Effect.fn("ACPNext.prompt")(function* (_input: PromptRequest) {
+      return yield* new UnsupportedOperationError({ method: "session/prompt" })
+    }),
+    cancel: Effect.fn("ACPNext.cancel")(function* (_input: CancelNotification) {
+      return yield* new UnsupportedOperationError({ method: "session/cancel" })
+    }),
+  }
+}
diff --git a/packages/opencode/src/cli/cmd/acp.ts b/packages/opencode/src/cli/cmd/acp.ts
index b3b7df486b31..b113a278f965 100644
--- a/packages/opencode/src/cli/cmd/acp.ts
+++ b/packages/opencode/src/cli/cmd/acp.ts
@@ -3,10 +3,12 @@ import { Effect } from "effect"
 import { effectCmd } from "../effect-cmd"
 import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
 import { ACP } from "@/acp/agent"
+import { ACPNext } from "@/acp-next/agent"
 import { Server } from "@/server/server"
 import { ServerAuth } from "@/server/auth"
 import { createOpencodeClient } from "@opencode-ai/sdk/v2"
 import { withNetworkOptions, resolveNetworkOptions } from "../network"
+import { RuntimeFlags } from "@/effect/runtime-flags"
 
 const log = Log.create({ service: "acp-command" })
 
@@ -22,6 +24,7 @@ export const AcpCommand = effectCmd({
   },
   handler: Effect.fn("Cli.acp")(function* (args) {
     process.env.OPENCODE_CLIENT = "acp"
+    const flags = yield* RuntimeFlags.Service
     const opts = yield* resolveNetworkOptions(args)
     const server = yield* Effect.promise(() => Server.listen(opts))
 
@@ -54,7 +57,7 @@ export const AcpCommand = effectCmd({
     })
 
     const stream = ndJsonStream(input, output)
-    const agent = ACP.init({ sdk })
+    const agent = flags.acpNext ? ACPNext.init({ sdk }) : ACP.init({ sdk })
 
     new AgentSideConnection((conn) => {
       return agent.create(conn, { sdk })
diff --git a/packages/opencode/src/effect/runtime-flags.ts b/packages/opencode/src/effect/runtime-flags.ts
index efa8a264bac4..520bcb30f893 100644
--- a/packages/opencode/src/effect/runtime-flags.ts
+++ b/packages/opencode/src/effect/runtime-flags.ts
@@ -48,6 +48,7 @@ export class Service extends ConfigService.Service<Service>()("@opencode/Runtime
   experimentalEventSystem: enabledByExperimental("OPENCODE_EXPERIMENTAL_EVENT_SYSTEM"),
   experimentalWorkspaces: enabledByExperimental("OPENCODE_EXPERIMENTAL_WORKSPACES"),
   experimentalIconDiscovery: enabledByExperimental("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY"),
+  acpNext: bool("OPENCODE_ACP_NEXT"),
   outputTokenMax: positiveInteger("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
   bashDefaultTimeoutMs: positiveInteger("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
   experimentalNativeLlm: bool("OPENCODE_EXPERIMENTAL_NATIVE_LLM"),
diff --git a/packages/opencode/test/cli/acp-next/acp-next-process.test.ts b/packages/opencode/test/cli/acp-next/acp-next-process.test.ts
new file mode 100644
index 000000000000..08d15b9bfc23
--- /dev/null
+++ b/packages/opencode/test/cli/acp-next/acp-next-process.test.ts
@@ -0,0 +1,104 @@
+import { describe, expect } from "bun:test"
+import type { AuthenticateResponse, InitializeResponse } from "@agentclientprotocol/sdk"
+import { Effect } from "effect"
+import { cliIt } from "../../lib/cli-process"
+import { createAcpClient, expectOk } from "../acp/acp-test-client"
+
+describe("opencode acp-next (subprocess)", () => {
+  cliIt.live(
+    "responds to initialize behind OPENCODE_ACP_NEXT",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
+        const initialized = expectOk(
+          yield* acp.request<InitializeResponse>("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: { _meta: { "terminal-auth": true } },
+          }),
+        )
+
+        expect(initialized.protocolVersion).toBe(1)
+        expect(initialized.agentCapabilities?.promptCapabilities?.embeddedContext).toBe(true)
+        expect(initialized.agentCapabilities?.promptCapabilities?.image).toBe(true)
+        expect(initialized.agentCapabilities?.mcpCapabilities?.http).toBe(true)
+        expect(initialized.agentCapabilities?.mcpCapabilities?.sse).toBe(true)
+        expect(initialized.agentCapabilities?.sessionCapabilities).toBeUndefined()
+        expect(initialized.agentInfo?.name).toBe("OpenCode")
+        expect(initialized.authMethods?.[0]?.id).toBe("opencode-login")
+        expect(initialized.authMethods?.[0]?._meta?.["terminal-auth"]).toBeDefined()
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "authenticate succeeds for the advertised auth method and rejects unknown methods safely",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
+        const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
+        const methodId = initialized.authMethods?.[0]?.id
+        expect(methodId).toBe("opencode-login")
+
+        expectOk(yield* acp.request<AuthenticateResponse>("authenticate", { methodId }))
+
+        const rejected = yield* acp.request<AuthenticateResponse>("authenticate", { methodId: "missing-auth-method" })
+        expect(errorCode(rejected.error)).toBe(-32602)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "SDK-required session stubs fail with safe unsupported errors",
+    ({ home, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+
+        const newSession = yield* acp.request("session/new", { cwd: home, mcpServers: [] })
+        expect(errorCode(newSession.error)).toBe(-32601)
+
+        const prompt = yield* acp.request("session/prompt", {
+          sessionId: "ses_missing",
+          prompt: [{ type: "text", text: "hello" }],
+        })
+        expect(errorCode(prompt.error)).toBe(-32601)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "exits cleanly when flagged stdin is closed",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const exitedPromise = yield* Effect.scoped(
+          Effect.gen(function* () {
+            const acp = yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } })
+            return acp.exited
+          }),
+        )
+
+        const code = yield* Effect.promise(() => exitedPromise)
+        expect(typeof code === "number" || code === null).toBe(true)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "default unflagged path still uses production ACP",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp())
+        const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
+
+        expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
+        expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})
+      }),
+    60_000,
+  )
+})
+
+function errorCode(error: unknown) {
+  if (!error || typeof error !== "object") return undefined
+  if (!("code" in error)) return undefined
+  return typeof error.code === "number" ? error.code : undefined
+}

From 416f01d4db6871fe377159cadb8ec145e540d840 Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 20:53:58 +0530
Subject: [PATCH 13/31] feat(acp-next): add content conversion helpers (#29231)

---
 packages/opencode/src/acp-next/content.ts     | 246 ++++++++++++++++++
 .../opencode/test/acp-next/content.test.ts    | 201 ++++++++++++++
 2 files changed, 447 insertions(+)
 create mode 100644 packages/opencode/src/acp-next/content.ts
 create mode 100644 packages/opencode/test/acp-next/content.test.ts

diff --git a/packages/opencode/src/acp-next/content.ts b/packages/opencode/src/acp-next/content.ts
new file mode 100644
index 000000000000..6d36fa60d8f1
--- /dev/null
+++ b/packages/opencode/src/acp-next/content.ts
@@ -0,0 +1,246 @@
+import type { ContentBlock, ContentChunk, ResourceLink, Role } from "@agentclientprotocol/sdk"
+import path from "node:path"
+import { pathToFileURL } from "node:url"
+import type { MessageV2 } from "@/session/message-v2"
+
+export type PromptPart = MessageV2.TextPartInput | MessageV2.FilePartInput
+
+export type ReplayPart =
+  | {
+      type: "text"
+      text: string
+      synthetic?: boolean
+      ignored?: boolean
+    }
+  | {
+      type: "file"
+      url: string
+      mime: string
+      filename?: string
+    }
+  | {
+      type: "reasoning"
+      text: string
+    }
+
+export function promptContentToParts(content: readonly ContentBlock[]): PromptPart[] {
+  return content.flatMap(contentBlockToParts)
+}
+
+export function contentBlockToParts(block: ContentBlock): PromptPart[] {
+  switch (block.type) {
+    case "text":
+      return [
+        {
+          type: "text",
+          text: block.text,
+          ...audienceFlags(block.annotations?.audience ?? undefined),
+        },
+      ]
+
+    case "image":
+      if (block.data) {
+        return [
+          {
+            type: "file",
+            url: `data:${block.mimeType};base64,${block.data}`,
+            filename: filenameFromUri(block.uri ?? undefined) ?? "image",
+            mime: block.mimeType,
+          },
+        ]
+      }
+      if (block.uri?.startsWith("data:")) {
+        return [
+          {
+            type: "file",
+            url: block.uri,
+            filename: filenameFromUri(block.uri) ?? "image",
+            mime: block.mimeType,
+          },
+        ]
+      }
+      if (block.uri?.startsWith("http://") || block.uri?.startsWith("https://")) {
+        return [
+          {
+            type: "file",
+            url: block.uri,
+            filename: filenameFromUri(block.uri) ?? "image",
+            mime: block.mimeType,
+          },
+        ]
+      }
+      return []
+
+    case "resource_link":
+      return [resourceLinkToPart(block)]
+
+    case "resource":
+      if ("text" in block.resource) {
+        return [{ type: "text", text: block.resource.text }]
+      }
+      if (block.resource.mimeType) {
+        return [
+          {
+            type: "file",
+            url: block.resource.uri.startsWith("data:")
+              ? block.resource.uri
+              : `data:${block.resource.mimeType};base64,${block.resource.blob}`,
+            filename: filenameFromUri(block.resource.uri) ?? "file",
+            mime: block.resource.mimeType,
+          },
+        ]
+      }
+      return []
+
+    default:
+      return []
+  }
+}
+
+export function partsToContentChunks(parts: readonly ReplayPart[]): ContentChunk[] {
+  return parts.flatMap(partToContentChunks)
+}
+
+export function partToContentChunks(part: ReplayPart): ContentChunk[] {
+  switch (part.type) {
+    case "text":
+      if (!part.text) return []
+      return [
+        {
+          content: {
+            type: "text",
+            text: part.text,
+            ...partAudience(part),
+          },
+        },
+      ]
+
+    case "file":
+      return filePartToContentChunks(part)
+
+    case "reasoning":
+      if (!part.text) return []
+      return [
+        {
+          content: {
+            type: "text",
+            text: part.text,
+          },
+        },
+      ]
+  }
+}
+
+function resourceLinkToPart(link: ResourceLink): PromptPart {
+  const parsed = uriToFilePart(link.uri, link.mimeType ?? "text/plain", link.name)
+  if (parsed.type === "file") return parsed
+  return { type: "text", text: parsed.text }
+}
+
+function uriToFilePart(uri: string, mime: string, filename?: string): MessageV2.FilePartInput | MessageV2.TextPartInput {
+  try {
+    if (uri.startsWith("file://")) {
+      return {
+        type: "file",
+        url: uri,
+        filename: filename ?? filenameFromUri(uri) ?? "file",
+        mime,
+      }
+    }
+    if (uri.startsWith("zed://")) {
+      const pathname = new URL(uri).searchParams.get("path")
+      if (pathname) {
+        return {
+          type: "file",
+          url: pathToFileURL(pathname).href,
+          filename: filename ?? (path.basename(pathname) || "file"),
+          mime,
+        }
+      }
+    }
+    return { type: "text", text: uri }
+  } catch {
+    return { type: "text", text: uri }
+  }
+}
+
+function filePartToContentChunks(part: Extract<ReplayPart, { type: "file" }>): ContentChunk[] {
+  if (part.url.startsWith("file://")) {
+    return [
+      {
+        content: {
+          type: "resource_link",
+          uri: part.url,
+          name: part.filename ?? "file",
+          mimeType: part.mime,
+        },
+      },
+    ]
+  }
+  if (!part.url.startsWith("data:")) return []
+
+  const data = decodeDataUrl(part.url)
+  if (!data) return []
+  if (data.mime.startsWith("image/")) {
+    return [
+      {
+        content: {
+          type: "image",
+          mimeType: data.mime,
+          data: data.base64,
+          uri: pathToFileURL(part.filename ?? "image").href,
+        },
+      },
+    ]
+  }
+
+  return [
+    {
+      content: {
+        type: "resource",
+        resource:
+          data.mime.startsWith("text/") || data.mime === "application/json"
+            ? {
+                uri: pathToFileURL(part.filename ?? "file").href,
+                mimeType: data.mime,
+                text: Buffer.from(data.base64, "base64").toString("utf8"),
+              }
+            : {
+                uri: pathToFileURL(part.filename ?? "file").href,
+                mimeType: data.mime,
+                blob: data.base64,
+              },
+      },
+    },
+  ]
+}
+
+function decodeDataUrl(url: string) {
+  const match = /^data:([^;]+);base64,(.*)$/.exec(url)
+  if (!match) return
+  return { mime: match[1], base64: match[2] }
+}
+
+function audienceFlags(audience: readonly Role[] | null | undefined) {
+  if (audience?.length === 1 && audience[0] === "assistant") return { synthetic: true }
+  if (audience?.length === 1 && audience[0] === "user") return { ignored: true }
+  return {}
+}
+
+function partAudience(part: Extract<ReplayPart, { type: "text" }>) {
+  const audience: Role[] | undefined = part.synthetic ? ["assistant"] : part.ignored ? ["user"] : undefined
+  if (!audience) return {}
+  return { annotations: { audience } }
+}
+
+function filenameFromUri(uri: string | undefined) {
+  if (!uri) return
+  if (uri.startsWith("data:")) return
+  try {
+    const parsed = new URL(uri)
+    const name = path.basename(parsed.pathname)
+    return name || undefined
+  } catch {
+    return path.basename(uri) || undefined
+  }
+}
diff --git a/packages/opencode/test/acp-next/content.test.ts b/packages/opencode/test/acp-next/content.test.ts
new file mode 100644
index 000000000000..88f8608345b1
--- /dev/null
+++ b/packages/opencode/test/acp-next/content.test.ts
@@ -0,0 +1,201 @@
+import { describe, expect, test } from "bun:test"
+import type { ContentBlock } from "@agentclientprotocol/sdk"
+import { pathToFileURL } from "node:url"
+import { contentBlockToParts, partsToContentChunks, promptContentToParts } from "../../src/acp-next/content"
+
+describe("acp-next content conversion", () => {
+  test("plain text block becomes a text part", () => {
+    expect(contentBlockToParts({ type: "text", text: "hello" })).toEqual([{ type: "text", text: "hello" }])
+  })
+
+  test("assistant-only text audience becomes synthetic", () => {
+    expect(
+      contentBlockToParts({
+        type: "text",
+        text: "internal",
+        annotations: { audience: ["assistant"] },
+      }),
+    ).toEqual([{ type: "text", text: "internal", synthetic: true }])
+  })
+
+  test("user-only text audience becomes ignored", () => {
+    expect(
+      contentBlockToParts({
+        type: "text",
+        text: "visible to user",
+        annotations: { audience: ["user"] },
+      }),
+    ).toEqual([{ type: "text", text: "visible to user", ignored: true }])
+  })
+
+  test("image block with base64 data becomes a data URL file part", () => {
+    expect(
+      contentBlockToParts({
+        type: "image",
+        data: "AAAA",
+        mimeType: "image/png",
+        uri: "file:///tmp/screenshot.png",
+      }),
+    ).toEqual([
+      {
+        type: "file",
+        url: "data:image/png;base64,AAAA",
+        filename: "screenshot.png",
+        mime: "image/png",
+      },
+    ])
+  })
+
+  test("image block with http URI becomes a file part", () => {
+    expect(
+      contentBlockToParts({
+        type: "image",
+        data: "",
+        mimeType: "image/jpeg",
+        uri: "http://example.com/assets/photo.jpg",
+      }),
+    ).toEqual([
+      {
+        type: "file",
+        url: "http://example.com/assets/photo.jpg",
+        filename: "photo.jpg",
+        mime: "image/jpeg",
+      },
+    ])
+  })
+
+  test("resource_link file URL becomes a file part with name and fallback mime", () => {
+    expect(
+      contentBlockToParts({
+        type: "resource_link",
+        uri: "file:///tmp/notes.txt",
+        name: "client-notes.txt",
+      }),
+    ).toEqual([
+      {
+        type: "file",
+        url: "file:///tmp/notes.txt",
+        filename: "client-notes.txt",
+        mime: "text/plain",
+      },
+    ])
+  })
+
+  test("resource_link zed path becomes a file URL part", () => {
+    expect(
+      contentBlockToParts({
+        type: "resource_link",
+        uri: "zed://workspace?path=/tmp/project/src/app.ts",
+        name: "app.ts",
+        mimeType: "text/typescript",
+      }),
+    ).toEqual([
+      {
+        type: "file",
+        url: pathToFileURL("/tmp/project/src/app.ts").href,
+        filename: "app.ts",
+        mime: "text/typescript",
+      },
+    ])
+  })
+
+  test("resource with text becomes a text part", () => {
+    expect(
+      contentBlockToParts({
+        type: "resource",
+        resource: {
+          uri: "file:///tmp/context.txt",
+          mimeType: "text/plain",
+          text: "context",
+        },
+      }),
+    ).toEqual([{ type: "text", text: "context" }])
+  })
+
+  test("resource with blob and mimeType becomes a data URL file part", () => {
+    expect(
+      contentBlockToParts({
+        type: "resource",
+        resource: {
+          uri: "file:///tmp/report.pdf",
+          mimeType: "application/pdf",
+          blob: "JVBERg==",
+        },
+      }),
+    ).toEqual([
+      {
+        type: "file",
+        url: "data:application/pdf;base64,JVBERg==",
+        filename: "report.pdf",
+        mime: "application/pdf",
+      },
+    ])
+  })
+
+  test("data URL resource is preserved as a file part", () => {
+    expect(
+      contentBlockToParts({
+        type: "resource",
+        resource: {
+          uri: "data:text/plain;base64,aGVsbG8=",
+          mimeType: "text/plain",
+          blob: "ignored",
+        },
+      }),
+    ).toEqual([
+      {
+        type: "file",
+        url: "data:text/plain;base64,aGVsbG8=",
+        filename: "file",
+        mime: "text/plain",
+      },
+    ])
+  })
+
+  test("unsupported blocks are ignored", () => {
+    expect(promptContentToParts([{ type: "audio", data: "AAAA", mimeType: "audio/wav" }])).toEqual([])
+    expect(promptContentToParts([{ type: "unknown", text: "skip" } as unknown as ContentBlock])).toEqual([])
+  })
+})
+
+describe("acp-next replay conversion", () => {
+  test("replays text audience annotations", () => {
+    expect(partsToContentChunks([{ type: "text", text: "cached", synthetic: true }])).toEqual([
+      {
+        content: {
+          type: "text",
+          text: "cached",
+          annotations: { audience: ["assistant"] },
+        },
+      },
+    ])
+  })
+
+  test("replays file and data URL parts as ACP content", () => {
+    expect(
+      partsToContentChunks([
+        { type: "file", url: "file:///tmp/readme.md", filename: "readme.md", mime: "text/markdown" },
+        { type: "file", url: "data:text/plain;base64,aGVsbG8=", filename: "note.txt", mime: "text/plain" },
+      ]),
+    ).toEqual([
+      {
+        content: {
+          type: "resource_link",
+          uri: "file:///tmp/readme.md",
+          name: "readme.md",
+          mimeType: "text/markdown",
+        },
+      },
+      {
+        content: {
+          type: "resource",
+          resource: {
+            uri: pathToFileURL("note.txt").href,
+            mimeType: "text/plain",
+            text: "hello",
+          },
+        },
+      },
+    ])
+  })
+})

From ed010b7d545e2b559ca41cc6e781656136818414 Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 20:54:57 +0530
Subject: [PATCH 14/31] test(acp-next): add config option helpers (#29234)

---
 .../opencode/src/acp-next/config-option.ts    | 203 ++++++++++++++++
 .../test/acp-next/config-option.test.ts       | 229 ++++++++++++++++++
 2 files changed, 432 insertions(+)
 create mode 100644 packages/opencode/src/acp-next/config-option.ts
 create mode 100644 packages/opencode/test/acp-next/config-option.test.ts

diff --git a/packages/opencode/src/acp-next/config-option.ts b/packages/opencode/src/acp-next/config-option.ts
new file mode 100644
index 000000000000..b730ae075336
--- /dev/null
+++ b/packages/opencode/src/acp-next/config-option.ts
@@ -0,0 +1,203 @@
+import type { SessionConfigOption } from "@agentclientprotocol/sdk"
+
+export const DEFAULT_VARIANT_VALUE = "default"
+
+export type ConfigOptionModel = {
+  id: string
+  name: string
+  variants?: Record<string, Record<string, unknown>>
+}
+
+export type ConfigOptionProvider = {
+  id: string
+  name: string
+  models: Record<string, ConfigOptionModel>
+}
+
+export type ConfigOptionMode = {
+  id: string
+  name: string
+  description?: string
+}
+
+export type ModelSelection = {
+  model: {
+    providerID: string
+    modelID: string
+  }
+  variant?: string
+}
+
+export function buildModelSelectOption(input: {
+  providers: readonly ConfigOptionProvider[]
+  currentModel: ModelSelection["model"]
+  currentVariant?: string
+  includeVariants?: boolean
+}): SessionConfigOption {
+  return {
+    id: "model",
+    name: "Model",
+    category: "model",
+    type: "select",
+    currentValue: formatCurrentModelId({
+      model: input.currentModel,
+      variant: input.currentVariant,
+      variants: variantsForModel(input.providers, input.currentModel),
+      includeVariant: input.includeVariants ?? false,
+    }),
+    options: buildModelSelectOptions(input.providers, { includeVariants: input.includeVariants ?? false }),
+  }
+}
+
+export function buildEffortSelectOption(input: {
+  variants: readonly string[]
+  currentVariant?: string
+}): SessionConfigOption | undefined {
+  if (input.variants.length === 0) return undefined
+
+  return {
+    id: "effort",
+    name: "Effort",
+    description: "Available effort levels for this model",
+    category: "thought_level",
+    type: "select",
+    currentValue: selectVariant(input.currentVariant, input.variants),
+    options: input.variants.map((variant) => ({
+      value: variant,
+      name: formatVariantName(variant),
+    })),
+  }
+}
+
+export function buildModeSelectOption(input: {
+  modes: readonly ConfigOptionMode[]
+  currentModeId: string
+}): SessionConfigOption {
+  return {
+    id: "mode",
+    name: "Session Mode",
+    category: "mode",
+    type: "select",
+    currentValue: input.currentModeId,
+    options: input.modes.map((mode) => ({
+      value: mode.id,
+      name: mode.name,
+      ...(mode.description ? { description: mode.description } : {}),
+    })),
+  }
+}
+
+export function buildConfigOptions(input: {
+  providers: readonly ConfigOptionProvider[]
+  currentModel: ModelSelection["model"]
+  currentVariant?: string
+  includeModelVariants?: boolean
+  modes?: readonly ConfigOptionMode[]
+  currentModeId?: string
+}): SessionConfigOption[] {
+  const variants = variantsForModel(input.providers, input.currentModel)
+  const effort = buildEffortSelectOption({ variants, currentVariant: input.currentVariant })
+
+  return [
+    buildModelSelectOption({
+      providers: input.providers,
+      currentModel: input.currentModel,
+      currentVariant: input.currentVariant,
+      includeVariants: input.includeModelVariants ?? false,
+    }),
+    ...(effort ? [effort] : []),
+    ...(input.modes && input.currentModeId
+      ? [buildModeSelectOption({ modes: input.modes, currentModeId: input.currentModeId })]
+      : []),
+  ]
+}
+
+export function parseModelSelection(modelId: string, providers: readonly ConfigOptionProvider[]): ModelSelection {
+  const provider = providers.find((item) => modelId.startsWith(`${item.id}/`))
+  if (provider) {
+    const modelID = modelId.slice(provider.id.length + 1)
+    if (provider.models[modelID]) {
+      return { model: { providerID: provider.id, modelID } }
+    }
+
+    const separator = modelID.lastIndexOf("/")
+    if (separator > -1) {
+      const baseModelID = modelID.slice(0, separator)
+      const variant = modelID.slice(separator + 1)
+      if (provider.models[baseModelID]?.variants?.[variant]) {
+        return { model: { providerID: provider.id, modelID: baseModelID }, variant }
+      }
+    }
+
+    return { model: { providerID: provider.id, modelID } }
+  }
+
+  const separator = modelId.indexOf("/")
+  if (separator === -1) {
+    return { model: { providerID: modelId, modelID: "" } }
+  }
+
+  return {
+    model: {
+      providerID: modelId.slice(0, separator),
+      modelID: modelId.slice(separator + 1),
+    },
+  }
+}
+
+export function formatCurrentModelId(input: {
+  model: ModelSelection["model"]
+  variant?: string
+  variants?: readonly string[]
+  includeVariant?: boolean
+}) {
+  const base = `${input.model.providerID}/${input.model.modelID}`
+  if (!input.includeVariant || !input.variants?.length) return base
+  return `${base}/${selectVariant(input.variant, input.variants)}`
+}
+
+export function formatVariantName(variant: string) {
+  return variant
+    .split(/[_-]/)
+    .map((part) => (part ? part.charAt(0).toUpperCase() + part.slice(1) : part))
+    .join(" ")
+}
+
+function buildModelSelectOptions(
+  providers: readonly ConfigOptionProvider[],
+  options: { includeVariants: boolean },
+): Array<{ value: string; name: string }> {
+  return providers.flatMap((provider) =>
+    Object.values(provider.models)
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .flatMap((model) => {
+        const base = {
+          value: `${provider.id}/${model.id}`,
+          name: `${provider.name}/${model.name}`,
+        }
+        if (!options.includeVariants || !model.variants) return [base]
+
+        return [
+          base,
+          ...Object.keys(model.variants)
+            .filter((variant) => variant !== DEFAULT_VARIANT_VALUE)
+            .map((variant) => ({
+              value: `${provider.id}/${model.id}/${variant}`,
+              name: `${provider.name}/${model.name} (${formatVariantName(variant)})`,
+            })),
+        ]
+      }),
+  )
+}
+
+function variantsForModel(providers: readonly ConfigOptionProvider[], model: ModelSelection["model"]) {
+  return Object.keys(
+    providers.find((provider) => provider.id === model.providerID)?.models[model.modelID]?.variants ?? {},
+  )
+}
+
+function selectVariant(variant: string | undefined, variants: readonly string[]) {
+  if (variant && variants.includes(variant)) return variant
+  if (variants.includes(DEFAULT_VARIANT_VALUE)) return DEFAULT_VARIANT_VALUE
+  return variants[0]
+}
diff --git a/packages/opencode/test/acp-next/config-option.test.ts b/packages/opencode/test/acp-next/config-option.test.ts
new file mode 100644
index 000000000000..d538ee81c01a
--- /dev/null
+++ b/packages/opencode/test/acp-next/config-option.test.ts
@@ -0,0 +1,229 @@
+import { describe, expect, test } from "bun:test"
+import {
+  buildConfigOptions,
+  buildEffortSelectOption,
+  buildModeSelectOption,
+  buildModelSelectOption,
+  formatCurrentModelId,
+  formatVariantName,
+  parseModelSelection,
+  type ConfigOptionProvider,
+} from "@/acp-next/config-option"
+
+const providers: ConfigOptionProvider[] = [
+  {
+    id: "anthropic",
+    name: "Anthropic",
+    models: {
+      "claude/sonnet-4": {
+        id: "claude/sonnet-4",
+        name: "Claude Sonnet 4",
+        variants: {
+          default: {},
+          high: {},
+          "very-high": {},
+        },
+      },
+      "claude-haiku": {
+        id: "claude-haiku",
+        name: "Claude Haiku",
+      },
+    },
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    models: {
+      "gpt-5": {
+        id: "gpt-5",
+        name: "GPT-5",
+        variants: {
+          minimal: {},
+          low: {},
+        },
+      },
+    },
+  },
+]
+
+describe("acp-next config options", () => {
+  test("builds the model select option with ACP verifier category", () => {
+    expect(
+      buildModelSelectOption({
+        providers,
+        currentModel: { providerID: "anthropic", modelID: "claude/sonnet-4" },
+        currentVariant: "high",
+      }),
+    ).toEqual({
+      id: "model",
+      name: "Model",
+      category: "model",
+      type: "select",
+      currentValue: "anthropic/claude/sonnet-4",
+      options: [
+        { value: "anthropic/claude-haiku", name: "Anthropic/Claude Haiku" },
+        { value: "anthropic/claude/sonnet-4", name: "Anthropic/Claude Sonnet 4" },
+        { value: "openai/gpt-5", name: "OpenAI/GPT-5" },
+      ],
+    })
+  })
+
+  test("includes variant ids in the model option only when requested", () => {
+    const option = buildModelSelectOption({
+      providers,
+      currentModel: { providerID: "anthropic", modelID: "claude/sonnet-4" },
+      currentVariant: "high",
+      includeVariants: true,
+    })
+
+    expect(option.currentValue).toBe("anthropic/claude/sonnet-4/high")
+    if (option.type !== "select") throw new Error("expected select option")
+    expect(option.options).toContainEqual({
+      value: "anthropic/claude/sonnet-4/high",
+      name: "Anthropic/Claude Sonnet 4 (High)",
+    })
+    expect(option.options).not.toContainEqual({
+      value: "anthropic/claude/sonnet-4/default",
+      name: "Anthropic/Claude Sonnet 4 (Default)",
+    })
+  })
+
+  test("builds effort option from variants and falls back to default when current variant is invalid", () => {
+    expect(buildEffortSelectOption({ variants: ["low", "default", "high"], currentVariant: "missing" })).toEqual({
+      id: "effort",
+      name: "Effort",
+      description: "Available effort levels for this model",
+      category: "thought_level",
+      type: "select",
+      currentValue: "default",
+      options: [
+        { value: "low", name: "Low" },
+        { value: "default", name: "Default" },
+        { value: "high", name: "High" },
+      ],
+    })
+  })
+
+  test("effort fallback uses the first variant when default is absent", () => {
+    expect(buildEffortSelectOption({ variants: ["minimal", "low"], currentVariant: "missing" })?.currentValue).toBe(
+      "minimal",
+    )
+  })
+
+  test("omits effort option when there are no variants", () => {
+    expect(buildEffortSelectOption({ variants: [] })).toBeUndefined()
+  })
+
+  test("builds the mode select option with descriptions when present", () => {
+    expect(
+      buildModeSelectOption({
+        currentModeId: "build",
+        modes: [
+          { id: "build", name: "Build", description: "Make code changes" },
+          { id: "plan", name: "Plan" },
+        ],
+      }),
+    ).toEqual({
+      id: "mode",
+      name: "Session Mode",
+      category: "mode",
+      type: "select",
+      currentValue: "build",
+      options: [
+        { value: "build", name: "Build", description: "Make code changes" },
+        { value: "plan", name: "Plan" },
+      ],
+    })
+  })
+
+  test("builds full config options with model, effort, and mode in stable order", () => {
+    const options = buildConfigOptions({
+      providers,
+      currentModel: { providerID: "anthropic", modelID: "claude/sonnet-4" },
+      currentVariant: "very-high",
+      modes: [
+        { id: "build", name: "Build" },
+        { id: "plan", name: "Plan" },
+      ],
+      currentModeId: "plan",
+    })
+
+    expect(options.map((option) => option.id)).toEqual(["model", "effort", "mode"])
+    expect(options.map((option) => option.category)).toEqual(["model", "thought_level", "mode"])
+    expect(options[1]?.currentValue).toBe("very-high")
+  })
+
+  test("full config options omit effort for models without variants", () => {
+    expect(
+      buildConfigOptions({
+        providers,
+        currentModel: { providerID: "anthropic", modelID: "claude-haiku" },
+      }).map((option) => option.id),
+    ).toEqual(["model"])
+  })
+
+  test("parses provider/model selections", () => {
+    expect(parseModelSelection("openai/gpt-5", providers)).toEqual({
+      model: { providerID: "openai", modelID: "gpt-5" },
+    })
+  })
+
+  test("parses provider/model/variant selections when the base model exposes that variant", () => {
+    expect(parseModelSelection("openai/gpt-5/low", providers)).toEqual({
+      model: { providerID: "openai", modelID: "gpt-5" },
+      variant: "low",
+    })
+  })
+
+  test("prefers exact slash-containing model ids before treating the tail as a variant", () => {
+    expect(parseModelSelection("anthropic/claude/sonnet-4", providers)).toEqual({
+      model: { providerID: "anthropic", modelID: "claude/sonnet-4" },
+    })
+  })
+
+  test("parses trailing variants for slash-containing model ids", () => {
+    expect(parseModelSelection("anthropic/claude/sonnet-4/high", providers)).toEqual({
+      model: { providerID: "anthropic", modelID: "claude/sonnet-4" },
+      variant: "high",
+    })
+  })
+
+  test("keeps unknown trailing segments in the model id when they are not valid variants", () => {
+    expect(parseModelSelection("anthropic/claude/sonnet-4/missing", providers)).toEqual({
+      model: { providerID: "anthropic", modelID: "claude/sonnet-4/missing" },
+    })
+  })
+
+  test("formats current model ids with and without selected variants", () => {
+    expect(
+      formatCurrentModelId({
+        model: { providerID: "openai", modelID: "gpt-5" },
+        variant: "low",
+        variants: ["minimal", "low"],
+      }),
+    ).toBe("openai/gpt-5")
+    expect(
+      formatCurrentModelId({
+        model: { providerID: "openai", modelID: "gpt-5" },
+        variant: "low",
+        variants: ["minimal", "low"],
+        includeVariant: true,
+      }),
+    ).toBe("openai/gpt-5/low")
+  })
+
+  test("formats current model ids with variant fallback", () => {
+    expect(
+      formatCurrentModelId({
+        model: { providerID: "anthropic", modelID: "claude/sonnet-4" },
+        variant: "missing",
+        variants: ["default", "high"],
+        includeVariant: true,
+      }),
+    ).toBe("anthropic/claude/sonnet-4/default")
+  })
+
+  test("formats variant names for display", () => {
+    expect(formatVariantName("very_high-effort")).toBe("Very High Effort")
+  })
+})

From ae594f9ce02d01f1c5fce76c5bf90dad5e16afb9 Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 20:55:22 +0530
Subject: [PATCH 15/31] feat(acp-next): add pure tool conversion helpers
 (#29232)

---
 packages/opencode/src/acp-next/tool.ts       | 174 +++++++++++++++++++
 packages/opencode/test/acp-next/tool.test.ts | 169 ++++++++++++++++++
 2 files changed, 343 insertions(+)
 create mode 100644 packages/opencode/src/acp-next/tool.ts
 create mode 100644 packages/opencode/test/acp-next/tool.test.ts

diff --git a/packages/opencode/src/acp-next/tool.ts b/packages/opencode/src/acp-next/tool.ts
new file mode 100644
index 000000000000..128c4c9c856e
--- /dev/null
+++ b/packages/opencode/src/acp-next/tool.ts
@@ -0,0 +1,174 @@
+import type { ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk"
+
+export type ToolInput = Record<string, unknown>
+
+export type ToolAttachment = {
+  readonly mime?: string
+  readonly url?: string
+  readonly [key: string]: unknown
+}
+
+export type CompletedToolState = {
+  readonly status: "completed"
+  readonly input: ToolInput
+  readonly output: string
+  readonly metadata?: unknown
+  readonly attachments?: ReadonlyArray<ToolAttachment>
+}
+
+export type ImageAttachment = {
+  readonly mimeType: string
+  readonly data: string
+}
+
+export function toToolKind(toolName: string): ToolKind {
+  const tool = toolName.toLocaleLowerCase()
+
+  switch (tool) {
+    case "bash":
+    case "shell":
+      return "execute"
+
+    case "webfetch":
+      return "fetch"
+
+    case "edit":
+    case "patch":
+    case "write":
+      return "edit"
+
+    case "grep":
+    case "glob":
+    case "repo_clone":
+    case "repo_overview":
+    case "context":
+    case "context7_resolve_library_id":
+    case "context7_get_library_docs":
+      return "search"
+
+    case "read":
+      return "read"
+
+    default:
+      return "other"
+  }
+}
+
+export function toLocations(toolName: string, input: ToolInput): ToolCallLocation[] {
+  const tool = toolName.toLocaleLowerCase()
+
+  switch (tool) {
+    case "read":
+    case "edit":
+    case "write":
+      return locationFrom(input.filePath)
+
+    case "grep":
+    case "glob":
+    case "repo_clone":
+    case "repo_overview":
+    case "context":
+    case "context7_resolve_library_id":
+    case "context7_get_library_docs":
+      return locationFrom(input.path)
+
+    case "bash":
+    case "shell":
+      return []
+
+    default:
+      return []
+  }
+}
+
+export function completedToolContent(toolName: string, state: CompletedToolState): ToolCallContent[] {
+  const content: ToolCallContent[] = [
+    {
+      type: "content",
+      content: {
+        type: "text",
+        text: state.output,
+      },
+    },
+  ]
+
+  if (toToolKind(toolName) === "edit") {
+    content.push(...diffContent(state.input))
+  }
+
+  content.push(...imageContents(state.attachments ?? []))
+  return content
+}
+
+export function completedToolRawOutput(state: CompletedToolState) {
+  return {
+    output: state.output,
+    ...(state.metadata !== undefined ? { metadata: state.metadata } : {}),
+    ...(state.attachments?.length ? { attachments: state.attachments } : {}),
+  }
+}
+
+export function imageContents(attachments: ReadonlyArray<ToolAttachment>): ToolCallContent[] {
+  return extractImageAttachments(attachments).map((attachment): ToolCallContent => {
+    return {
+      type: "content",
+      content: {
+        type: "image",
+        mimeType: attachment.mimeType,
+        data: attachment.data,
+      },
+    }
+  })
+}
+
+export function extractImageAttachments(attachments: ReadonlyArray<ToolAttachment>): ImageAttachment[] {
+  return attachments.flatMap((attachment): ImageAttachment[] => {
+    const data = dataUrlImage(attachment)
+    return data ? [data] : []
+  })
+}
+
+export function shellOutputSnapshot(state: { readonly metadata?: unknown }) {
+  if (!state.metadata || typeof state.metadata !== "object") return undefined
+  return stringValue((state.metadata as Record<string, unknown>).output)
+}
+
+export const mapToolKind = toToolKind
+export const extractLocations = toLocations
+export const buildCompletedToolContent = completedToolContent
+export const buildCompletedRawOutput = completedToolRawOutput
+export const extractShellOutputSnapshot = shellOutputSnapshot
+
+function locationFrom(value: unknown): ToolCallLocation[] {
+  const path = stringValue(value)
+  return path ? [{ path }] : []
+}
+
+function diffContent(input: ToolInput): ToolCallContent[] {
+  const oldText = stringValue(input.oldString)
+  const newText = stringValue(input.newString) ?? stringValue(input.content)
+  if (oldText === undefined || newText === undefined) return []
+
+  return [
+    {
+      type: "diff",
+      path: stringValue(input.filePath) ?? "",
+      oldText,
+      newText,
+    },
+  ]
+}
+
+function dataUrlImage(attachment: ToolAttachment) {
+  const match = stringValue(attachment.url)?.match(/^data:([^;,]+)(?:;[^,]*)*;base64,(.*)$/)
+  const mime = match?.[1] ?? stringValue(attachment.mime)
+  if (!mime?.startsWith("image/")) return undefined
+
+  const data = match?.[2]
+  if (data === undefined) return undefined
+  return { mimeType: mime, data }
+}
+
+function stringValue(value: unknown) {
+  return typeof value === "string" ? value : undefined
+}
diff --git a/packages/opencode/test/acp-next/tool.test.ts b/packages/opencode/test/acp-next/tool.test.ts
new file mode 100644
index 000000000000..0e0cc1e3ffc6
--- /dev/null
+++ b/packages/opencode/test/acp-next/tool.test.ts
@@ -0,0 +1,169 @@
+import { describe, expect, test } from "bun:test"
+import {
+  completedToolContent,
+  completedToolRawOutput,
+  extractImageAttachments,
+  imageContents,
+  shellOutputSnapshot,
+  toLocations,
+  toToolKind,
+} from "../../src/acp-next/tool"
+
+describe("acp-next tool conversion", () => {
+  test("maps OpenCode tool ids to ACP tool kinds", () => {
+    expect(toToolKind("bash")).toBe("execute")
+    expect(toToolKind("shell")).toBe("execute")
+    expect(toToolKind("webfetch")).toBe("fetch")
+    expect(toToolKind("edit")).toBe("edit")
+    expect(toToolKind("patch")).toBe("edit")
+    expect(toToolKind("write")).toBe("edit")
+    expect(toToolKind("grep")).toBe("search")
+    expect(toToolKind("glob")).toBe("search")
+    expect(toToolKind("repo_clone")).toBe("search")
+    expect(toToolKind("repo_overview")).toBe("search")
+    expect(toToolKind("context7_resolve_library_id")).toBe("search")
+    expect(toToolKind("context7_get_library_docs")).toBe("search")
+    expect(toToolKind("read")).toBe("read")
+    expect(toToolKind("custom_tool")).toBe("other")
+  })
+
+  test("extracts file locations from tool input", () => {
+    expect(toLocations("read", { filePath: "/tmp/a.ts" })).toEqual([{ path: "/tmp/a.ts" }])
+    expect(toLocations("edit", { filePath: "/tmp/b.ts" })).toEqual([{ path: "/tmp/b.ts" }])
+    expect(toLocations("write", { filePath: "/tmp/c.ts" })).toEqual([{ path: "/tmp/c.ts" }])
+    expect(toLocations("grep", { path: "/repo/src" })).toEqual([{ path: "/repo/src" }])
+    expect(toLocations("glob", { path: "/repo/test" })).toEqual([{ path: "/repo/test" }])
+    expect(toLocations("repo_clone", { path: "/repo" })).toEqual([{ path: "/repo" }])
+    expect(toLocations("repo_overview", { path: "/repo" })).toEqual([{ path: "/repo" }])
+    expect(toLocations("context7_get_library_docs", { path: "/docs" })).toEqual([{ path: "/docs" }])
+    expect(toLocations("bash", { filePath: "/tmp/nope.ts", path: "/tmp" })).toEqual([])
+    expect(toLocations("read", { path: "/tmp/missing-file-path.ts" })).toEqual([])
+  })
+
+  test("builds completed content with text, edit diffs, and image attachments", () => {
+    const image = Buffer.from("image-data").toString("base64")
+
+    expect(
+      completedToolContent("edit", {
+        status: "completed",
+        input: {
+          filePath: "/tmp/file.ts",
+          oldString: "before",
+          newString: "after",
+        },
+        output: "edited /tmp/file.ts",
+        attachments: [
+          {
+            type: "file",
+            mime: "image/png",
+            filename: "image.png",
+            url: `data:image/png;base64,${image}`,
+          },
+          {
+            type: "file",
+            mime: "text/plain",
+            filename: "note.txt",
+            url: "data:text/plain;base64,bm90ZQ==",
+          },
+        ],
+      }),
+    ).toEqual([
+      {
+        type: "content",
+        content: { type: "text", text: "edited /tmp/file.ts" },
+      },
+      {
+        type: "diff",
+        path: "/tmp/file.ts",
+        oldText: "before",
+        newText: "after",
+      },
+      {
+        type: "content",
+        content: { type: "image", mimeType: "image/png", data: image },
+      },
+    ])
+  })
+
+  test("omits edit diffs until old and new text fields exist", () => {
+    expect(
+      completedToolContent("write", {
+        status: "completed",
+        input: {
+          filePath: "/tmp/file.ts",
+          content: "created",
+        },
+        output: "wrote /tmp/file.ts",
+      }),
+    ).toEqual([
+      {
+        type: "content",
+        content: { type: "text", text: "wrote /tmp/file.ts" },
+      },
+    ])
+  })
+
+  test("builds completed raw output with optional metadata and attachments", () => {
+    const attachments = [
+      {
+        type: "file",
+        mime: "image/jpeg",
+        filename: "photo.jpg",
+        url: "data:image/jpeg;base64,AAAA",
+      },
+    ]
+
+    expect(
+      completedToolRawOutput({
+        status: "completed",
+        input: {},
+        output: "done",
+        metadata: { exit: 0 },
+        attachments,
+      }),
+    ).toEqual({
+      output: "done",
+      metadata: { exit: 0 },
+      attachments,
+    })
+
+    expect(
+      completedToolRawOutput({
+        status: "completed",
+        input: {},
+        output: "done",
+      }),
+    ).toEqual({ output: "done" })
+  })
+
+  test("extracts image attachments only from data URLs", () => {
+    const attachments = [
+      {
+        mime: "image/webp",
+        url: "data:image/webp;charset=utf-8;base64,AAAA",
+      },
+      {
+        mime: "image/png",
+        url: "https://example.com/image.png",
+      },
+      {
+        mime: "text/plain",
+        url: "data:text/plain;base64,BBBB",
+      },
+    ]
+
+    expect(extractImageAttachments(attachments)).toEqual([{ mimeType: "image/webp", data: "AAAA" }])
+    expect(imageContents(attachments)).toEqual([
+      {
+        type: "content",
+        content: { type: "image", mimeType: "image/webp", data: "AAAA" },
+      },
+    ])
+  })
+
+  test("reads shell output snapshot from string metadata output", () => {
+    expect(shellOutputSnapshot({ metadata: { output: "line 1\nline 2" } })).toBe("line 1\nline 2")
+    expect(shellOutputSnapshot({ metadata: { output: 42 } })).toBeUndefined()
+    expect(shellOutputSnapshot({ metadata: undefined })).toBeUndefined()
+  })
+})

From 72c169344c1d1a7c8d53b3d636f19295ab3bdbc8 Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 20:55:39 +0530
Subject: [PATCH 16/31] fix(acp-next): map typed errors to request errors
 (#29233)

---
 packages/opencode/src/acp-next/agent.ts       | 15 +--
 packages/opencode/src/acp-next/error.ts       | 93 +++++++++++++++++++
 packages/opencode/src/acp-next/service.ts     | 27 ++----
 packages/opencode/test/acp-next/error.test.ts | 71 ++++++++++++++
 4 files changed, 176 insertions(+), 30 deletions(-)
 create mode 100644 packages/opencode/src/acp-next/error.ts
 create mode 100644 packages/opencode/test/acp-next/error.test.ts

diff --git a/packages/opencode/src/acp-next/agent.ts b/packages/opencode/src/acp-next/agent.ts
index b656b6331f65..4290117f585d 100644
--- a/packages/opencode/src/acp-next/agent.ts
+++ b/packages/opencode/src/acp-next/agent.ts
@@ -10,6 +10,7 @@ import {
 } from "@agentclientprotocol/sdk"
 import { Effect } from "effect"
 import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+import * as ACPNextError from "./error"
 import * as ACPNextService from "./service"
 
 export function init({ sdk: _sdk }: { sdk: OpencodeClient }) {
@@ -45,16 +46,10 @@ export class Agent implements ACPAgent {
 }
 
 function run<A>(effect: Effect.Effect<A, ACPNextService.Error>) {
-  return Effect.runPromise(effect.pipe(Effect.mapError(toRequestError)))
-}
-
-function toRequestError(error: ACPNextService.Error) {
-  switch (error._tag) {
-    case "ACPNextUnknownAuthMethodError":
-      return RequestError.invalidParams({ methodId: error.methodId }, `unknown auth method: ${error.methodId}`)
-    case "ACPNextUnsupportedOperationError":
-      return RequestError.methodNotFound(error.method)
-  }
+  return Effect.runPromise(effect.pipe(Effect.mapError(ACPNextError.toRequestError))).catch((defect: unknown) => {
+    if (defect instanceof RequestError) throw defect
+    throw ACPNextError.toRequestError(ACPNextError.fromUnknownDefect(defect))
+  })
 }
 
 export * as ACPNext from "./agent"
diff --git a/packages/opencode/src/acp-next/error.ts b/packages/opencode/src/acp-next/error.ts
new file mode 100644
index 000000000000..1d4af53b5030
--- /dev/null
+++ b/packages/opencode/src/acp-next/error.ts
@@ -0,0 +1,93 @@
+import { RequestError } from "@agentclientprotocol/sdk"
+import { Schema } from "effect"
+
+export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()(
+  "ACPNextSessionNotFoundError",
+  {
+    sessionId: Schema.String,
+  },
+) {}
+
+export class InvalidConfigOptionError extends Schema.TaggedErrorClass<InvalidConfigOptionError>()(
+  "ACPNextInvalidConfigOptionError",
+  {
+    configId: Schema.String,
+  },
+) {}
+
+export class InvalidModelError extends Schema.TaggedErrorClass<InvalidModelError>()("ACPNextInvalidModelError", {
+  modelId: Schema.String,
+  providerId: Schema.optional(Schema.String),
+}) {}
+
+export class InvalidEffortError extends Schema.TaggedErrorClass<InvalidEffortError>()("ACPNextInvalidEffortError", {
+  effort: Schema.String,
+}) {}
+
+export class InvalidModeError extends Schema.TaggedErrorClass<InvalidModeError>()("ACPNextInvalidModeError", {
+  mode: Schema.String,
+}) {}
+
+export class AuthRequiredError extends Schema.TaggedErrorClass<AuthRequiredError>()("ACPNextAuthRequiredError", {
+  providerId: Schema.optional(Schema.String),
+}) {}
+
+export class UnknownAuthMethodError extends Schema.TaggedErrorClass<UnknownAuthMethodError>()(
+  "ACPNextUnknownAuthMethodError",
+  {
+    methodId: Schema.String,
+  },
+) {}
+
+export class UnsupportedOperationError extends Schema.TaggedErrorClass<UnsupportedOperationError>()(
+  "ACPNextUnsupportedOperationError",
+  {
+    method: Schema.String,
+  },
+) {}
+
+export class ServiceFailureError extends Schema.TaggedErrorClass<ServiceFailureError>()("ACPNextServiceFailureError", {
+  safeMessage: Schema.String,
+  service: Schema.optional(Schema.String),
+}) {}
+
+export type Error =
+  | SessionNotFoundError
+  | InvalidConfigOptionError
+  | InvalidModelError
+  | InvalidEffortError
+  | InvalidModeError
+  | AuthRequiredError
+  | UnknownAuthMethodError
+  | UnsupportedOperationError
+  | ServiceFailureError
+
+export function toRequestError(error: Error) {
+  switch (error._tag) {
+    case "ACPNextSessionNotFoundError":
+      return RequestError.invalidParams({ sessionId: error.sessionId }, `session not found: ${error.sessionId}`)
+    case "ACPNextInvalidConfigOptionError":
+      return RequestError.invalidParams({ configId: error.configId }, `unknown config option: ${error.configId}`)
+    case "ACPNextInvalidModelError":
+      return RequestError.invalidParams(
+        { providerId: error.providerId, modelId: error.modelId },
+        `model not found: ${error.modelId}`,
+      )
+    case "ACPNextInvalidEffortError":
+      return RequestError.invalidParams({ effort: error.effort }, `effort not found: ${error.effort}`)
+    case "ACPNextInvalidModeError":
+      return RequestError.invalidParams({ mode: error.mode }, `mode not found: ${error.mode}`)
+    case "ACPNextAuthRequiredError":
+      return RequestError.authRequired({ providerId: error.providerId }, "provider authentication required")
+    case "ACPNextUnknownAuthMethodError":
+      return RequestError.invalidParams({ methodId: error.methodId }, `unknown auth method: ${error.methodId}`)
+    case "ACPNextUnsupportedOperationError":
+      return RequestError.methodNotFound(error.method)
+    case "ACPNextServiceFailureError":
+      return RequestError.internalError({ service: error.service }, error.safeMessage)
+  }
+}
+
+export function fromUnknownDefect(_defect: unknown, safeMessage = "Internal service failure") {
+  return new ServiceFailureError({ safeMessage })
+}
diff --git a/packages/opencode/src/acp-next/service.ts b/packages/opencode/src/acp-next/service.ts
index b90c9c17547e..8ee1a8bd292c 100644
--- a/packages/opencode/src/acp-next/service.ts
+++ b/packages/opencode/src/acp-next/service.ts
@@ -11,25 +11,12 @@ import {
   type PromptResponse,
 } from "@agentclientprotocol/sdk"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { Context, Effect, Schema } from "effect"
+import { Context, Effect } from "effect"
+import * as ACPNextError from "./error"
 
 export const AuthMethodID = "opencode-login"
 
-export class UnknownAuthMethodError extends Schema.TaggedErrorClass<UnknownAuthMethodError>()(
-  "ACPNextUnknownAuthMethodError",
-  {
-    methodId: Schema.String,
-  },
-) {}
-
-export class UnsupportedOperationError extends Schema.TaggedErrorClass<UnsupportedOperationError>()(
-  "ACPNextUnsupportedOperationError",
-  {
-    method: Schema.String,
-  },
-) {}
-
-export type Error = UnknownAuthMethodError | UnsupportedOperationError
+export type Error = ACPNextError.Error
 
 export type Interface = {
   readonly initialize: (input: InitializeRequest) => Effect.Effect<InitializeResponse, Error>
@@ -81,7 +68,7 @@ export function make(): Interface {
 
   const authenticate = Effect.fn("ACPNext.authenticate")(function* (params: AuthenticateRequest) {
     if (params.methodId !== AuthMethodID) {
-      return yield* new UnknownAuthMethodError({ methodId: params.methodId })
+      return yield* new ACPNextError.UnknownAuthMethodError({ methodId: params.methodId })
     }
     return {}
   })
@@ -90,13 +77,13 @@ export function make(): Interface {
     initialize,
     authenticate,
     newSession: Effect.fn("ACPNext.newSession")(function* (_input: NewSessionRequest) {
-      return yield* new UnsupportedOperationError({ method: "session/new" })
+      return yield* new ACPNextError.UnsupportedOperationError({ method: "session/new" })
     }),
     prompt: Effect.fn("ACPNext.prompt")(function* (_input: PromptRequest) {
-      return yield* new UnsupportedOperationError({ method: "session/prompt" })
+      return yield* new ACPNextError.UnsupportedOperationError({ method: "session/prompt" })
     }),
     cancel: Effect.fn("ACPNext.cancel")(function* (_input: CancelNotification) {
-      return yield* new UnsupportedOperationError({ method: "session/cancel" })
+      return yield* new ACPNextError.UnsupportedOperationError({ method: "session/cancel" })
     }),
   }
 }
diff --git a/packages/opencode/test/acp-next/error.test.ts b/packages/opencode/test/acp-next/error.test.ts
new file mode 100644
index 000000000000..a82c6c576e11
--- /dev/null
+++ b/packages/opencode/test/acp-next/error.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test"
+import { RequestError } from "@agentclientprotocol/sdk"
+import * as ACPNextError from "../../src/acp-next/error"
+
+describe("acp-next.error", () => {
+  test("maps validation failures to invalid params", () => {
+    const cases: ACPNextError.Error[] = [
+      new ACPNextError.SessionNotFoundError({ sessionId: "ses_missing" }),
+      new ACPNextError.InvalidConfigOptionError({ configId: "temperature" }),
+      new ACPNextError.InvalidModelError({ providerId: "anthropic", modelId: "claude-missing" }),
+      new ACPNextError.InvalidEffortError({ effort: "extreme" }),
+      new ACPNextError.InvalidModeError({ mode: "turbo" }),
+    ]
+
+    expect(cases.map((error) => ACPNextError.toRequestError(error).code)).toEqual([
+      -32602, -32602, -32602, -32602, -32602,
+    ])
+  })
+
+  test("includes safe validation details", () => {
+    expect(ACPNextError.toRequestError(new ACPNextError.SessionNotFoundError({ sessionId: "ses_123" }))).toMatchObject({
+      code: -32602,
+      data: { sessionId: "ses_123" },
+    })
+    expect(ACPNextError.toRequestError(new ACPNextError.InvalidModelError({ modelId: "gpt-missing" }))).toMatchObject({
+      code: -32602,
+      data: { modelId: "gpt-missing" },
+    })
+  })
+
+  test("maps auth required to the SDK auth error", () => {
+    const requestError = ACPNextError.toRequestError(new ACPNextError.AuthRequiredError({ providerId: "anthropic" }))
+
+    expect(requestError).toBeInstanceOf(RequestError)
+    expect(requestError.code).toBe(-32000)
+    expect(requestError.message).toBe("Authentication required: provider authentication required")
+    expect(requestError.data).toEqual({ providerId: "anthropic" })
+  })
+
+  test("maps unsupported operations to method not found", () => {
+    const requestError = ACPNextError.toRequestError(
+      new ACPNextError.UnsupportedOperationError({ method: "session/new" }),
+    )
+
+    expect(requestError.code).toBe(-32601)
+    expect(requestError.data).toEqual({ method: "session/new" })
+  })
+
+  test("maps service failures to safe internal errors", () => {
+    const requestError = ACPNextError.toRequestError(
+      new ACPNextError.ServiceFailureError({ service: "provider", safeMessage: "Provider request failed" }),
+    )
+
+    expect(requestError.code).toBe(-32603)
+    expect(requestError.message).toBe("Internal error: Provider request failed")
+    expect(requestError.data).toEqual({ service: "provider" })
+  })
+
+  test("wraps unknown defects without leaking raw details", () => {
+    const requestError = ACPNextError.toRequestError(
+      ACPNextError.fromUnknownDefect(new Error("stack has sk-ant-secret and oauth refresh token")),
+    )
+    const serialized = JSON.stringify(requestError.toErrorResponse())
+
+    expect(requestError.code).toBe(-32603)
+    expect(requestError.message).toBe("Internal error: Internal service failure")
+    expect(serialized).not.toContain("sk-ant-secret")
+    expect(serialized).not.toContain("oauth refresh token")
+    expect(serialized).not.toContain("stack")
+  })
+})

From ddddceb24f0971a5422c70bfcb793216030655f1 Mon Sep 17 00:00:00 2001
From: "opencode-agent[bot]" <opencode-agent[bot]@users.noreply.github.com>
Date: Mon, 25 May 2026 15:26:53 +0000
Subject: [PATCH 17/31] chore: generate

---
 packages/opencode/src/acp-next/content.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/packages/opencode/src/acp-next/content.ts b/packages/opencode/src/acp-next/content.ts
index 6d36fa60d8f1..f83a75ef197e 100644
--- a/packages/opencode/src/acp-next/content.ts
+++ b/packages/opencode/src/acp-next/content.ts
@@ -137,7 +137,11 @@ function resourceLinkToPart(link: ResourceLink): PromptPart {
   return { type: "text", text: parsed.text }
 }
 
-function uriToFilePart(uri: string, mime: string, filename?: string): MessageV2.FilePartInput | MessageV2.TextPartInput {
+function uriToFilePart(
+  uri: string,
+  mime: string,
+  filename?: string,
+): MessageV2.FilePartInput | MessageV2.TextPartInput {
   try {
     if (uri.startsWith("file://")) {
       return {

From cb2006f35208880179a74fc70ef8c81d04cce982 Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 21:55:52 +0530
Subject: [PATCH 18/31] feat(acp-next): add directory snapshot service (#29241)

---
 packages/opencode/src/acp-next/directory.ts   | 193 ++++++++++++++++++
 .../opencode/test/acp-next/directory.test.ts  | 185 +++++++++++++++++
 2 files changed, 378 insertions(+)
 create mode 100644 packages/opencode/src/acp-next/directory.ts
 create mode 100644 packages/opencode/test/acp-next/directory.test.ts

diff --git a/packages/opencode/src/acp-next/directory.ts b/packages/opencode/src/acp-next/directory.ts
new file mode 100644
index 000000000000..bf8eb557519c
--- /dev/null
+++ b/packages/opencode/src/acp-next/directory.ts
@@ -0,0 +1,193 @@
+import { Agent } from "@/agent/agent"
+import { Command } from "@/command"
+import { InstanceRef } from "@/effect/instance-ref"
+import { InstanceStore } from "@/project/instance-store"
+import { ModelID, ProviderID } from "@/provider/schema"
+import { Provider } from "@/provider/provider"
+import { Context, Effect, Layer, SynchronizedRef } from "effect"
+
+export type ModelOption = {
+  readonly providerID: ProviderID
+  readonly providerName: string
+  readonly modelID: ModelID
+  readonly modelName: string
+}
+
+export type ModeOption = {
+  readonly id: string
+  readonly name: string
+  readonly description?: string
+}
+
+export type ModelVariants = NonNullable<Provider.Model["variants"]>
+
+export type DefaultModel = {
+  readonly providerID: ProviderID
+  readonly modelID: ModelID
+}
+
+export type Snapshot = {
+  readonly directory: string
+  readonly providers: Record<ProviderID, Provider.Info>
+  readonly modelOptions: readonly ModelOption[]
+  readonly variantsByModel: Readonly<Record<string, ModelVariants>>
+  readonly availableModes: readonly ModeOption[]
+  readonly defaultModeID: string
+  readonly availableCommands: readonly Command.Info[]
+  readonly defaultModel?: DefaultModel
+}
+
+export interface LoaderInterface {
+  readonly load: (directory: string) => Effect.Effect<Snapshot>
+}
+
+export interface Interface {
+  readonly get: (directory: string) => Effect.Effect<Snapshot>
+  readonly refresh: (directory: string) => Effect.Effect<Snapshot>
+  readonly variants: (snapshot: Snapshot, model: DefaultModel) => ModelVariants | undefined
+}
+
+export class Loader extends Context.Service<Loader, LoaderInterface>()("@opencode/ACPNextDirectoryLoader") {}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/ACPNextDirectory") {}
+
+export const modelKey = (model: DefaultModel) => `${model.providerID}/${model.modelID}`
+
+export const variants = (snapshot: Snapshot, model: DefaultModel) => snapshot.variantsByModel[modelKey(model)]
+
+export const build = (input: {
+  readonly directory: string
+  readonly providers: Record<ProviderID, Provider.Info>
+  readonly modes: readonly ModeOption[]
+  readonly defaultModeID: string
+  readonly commands: readonly Command.Info[]
+  readonly defaultModel?: DefaultModel
+}): Snapshot => {
+  const modelOptions = Provider.sort(
+    Object.values(input.providers).flatMap((provider) =>
+      Object.values(provider.models).map((model) => ({
+        id: model.id,
+        providerID: provider.id,
+        providerName: provider.name,
+        modelID: model.id,
+        modelName: model.name,
+      })),
+    ),
+  ).map((model) => ({
+    providerID: model.providerID,
+    providerName: model.providerName,
+    modelID: model.modelID,
+    modelName: model.modelName,
+  }))
+
+  return {
+    directory: input.directory,
+    providers: input.providers,
+    modelOptions,
+    variantsByModel: Object.fromEntries(
+      Object.values(input.providers).flatMap((provider) =>
+        Object.values(provider.models).flatMap((model) =>
+          model.variants ? [[modelKey({ providerID: provider.id, modelID: model.id }), model.variants]] : [],
+        ),
+      ),
+    ),
+    availableModes: input.modes,
+    defaultModeID: input.modes.some((mode) => mode.id === input.defaultModeID)
+      ? input.defaultModeID
+      : (input.modes[0]?.id ?? input.defaultModeID),
+    availableCommands: input.commands,
+    ...(input.defaultModel ? { defaultModel: input.defaultModel } : {}),
+  }
+}
+
+export const loaderLayer = Layer.effect(
+  Loader,
+  Effect.gen(function* () {
+    const store = yield* InstanceStore.Service
+    const provider = yield* Provider.Service
+    const agent = yield* Agent.Service
+    const command = yield* Command.Service
+
+    return Loader.of({
+      load: Effect.fn("ACPNextDirectoryLoader.load")(function* (directory) {
+        const ctx = yield* store.load({ directory })
+        return yield* Effect.gen(function* () {
+          const providers = yield* provider.list()
+          const [agents, defaultAgent, commands, defaultModel] = yield* Effect.all(
+            [
+              agent.list(),
+              agent.defaultInfo(),
+              command.list(),
+              provider.defaultModel().pipe(Effect.option),
+            ],
+            { concurrency: "unbounded" },
+          )
+          return build({
+            directory,
+            providers,
+            modes: agents
+              .filter((item) => item.mode !== "subagent" && item.hidden !== true)
+              .map((item) => ({
+                id: item.name,
+                name: item.name,
+                ...(item.description ? { description: item.description } : {}),
+              })),
+            defaultModeID: defaultAgent.name,
+            commands: commands.toSorted((a, b) => a.name.localeCompare(b.name)),
+            ...(defaultModel._tag === "Some" ? { defaultModel: defaultModel.value } : {}),
+          })
+        }).pipe(Effect.provideService(InstanceRef, ctx))
+      }),
+    })
+  }),
+)
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const loader = yield* Loader
+    const snapshots = yield* SynchronizedRef.make(new Map<string, Effect.Effect<Snapshot>>())
+
+    const cached = Effect.fnUntraced(function* (directory: string) {
+      return yield* SynchronizedRef.modifyEffect(
+        snapshots,
+        Effect.fnUntraced(function* (items) {
+          const current = items.get(directory)
+          if (current) return [current, items] as const
+          const next = yield* Effect.cached(loader.load(directory))
+          return [next, new Map(items).set(directory, next)] as const
+        }),
+      )
+    })
+
+    const get = Effect.fn("ACPNextDirectory.get")(function* (directory: string) {
+      return yield* (yield* cached(directory))
+    })
+
+    const refresh = Effect.fn("ACPNextDirectory.refresh")(function* (directory: string) {
+      return yield* SynchronizedRef.modifyEffect(
+        snapshots,
+        Effect.fnUntraced(function* (items) {
+          const next = yield* Effect.cached(loader.load(directory))
+          return [next, new Map(items).set(directory, next)] as const
+        }),
+      ).pipe(Effect.flatten)
+    })
+
+    return Service.of({
+      get,
+      refresh,
+      variants,
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(loaderLayer),
+  Layer.provide(Provider.defaultLayer),
+  Layer.provide(Agent.defaultLayer),
+  Layer.provide(Command.defaultLayer),
+  Layer.provide(InstanceStore.defaultLayer),
+)
+
+export * as Directory from "./directory"
diff --git a/packages/opencode/test/acp-next/directory.test.ts b/packages/opencode/test/acp-next/directory.test.ts
new file mode 100644
index 000000000000..050ff06d45bb
--- /dev/null
+++ b/packages/opencode/test/acp-next/directory.test.ts
@@ -0,0 +1,185 @@
+import { describe, expect } from "bun:test"
+import { Directory } from "@/acp-next/directory"
+import { Command } from "@/command"
+import { ModelID, ProviderID } from "@/provider/schema"
+import { Provider } from "@/provider/provider"
+import { Effect, Layer } from "effect"
+import { it } from "../lib/effect"
+
+const command = (name: string): Command.Info => ({
+  name,
+  source: "command",
+  template: `run ${name}`,
+  hints: [],
+})
+
+const model = (providerID: ProviderID, id: string, variants?: Directory.ModelVariants): Provider.Model => ({
+  id: ModelID.make(id),
+  providerID,
+  api: {
+    id,
+    url: "https://example.com",
+    npm: "@ai-sdk/openai-compatible",
+  },
+  name: id,
+  family: "test",
+  capabilities: {
+    temperature: true,
+    reasoning: Boolean(variants),
+    attachment: false,
+    toolcall: true,
+    input: { text: true, audio: false, image: false, video: false, pdf: false },
+    output: { text: true, audio: false, image: false, video: false, pdf: false },
+    interleaved: false,
+  },
+  cost: {
+    input: 0,
+    output: 0,
+    cache: { read: 0, write: 0 },
+  },
+  limit: {
+    context: 128000,
+    output: 4096,
+  },
+  status: "active",
+  options: {},
+  headers: {},
+  release_date: "2026-01-01",
+  ...(variants ? { variants } : {}),
+})
+
+const snapshot = (directory: string) => {
+  const providerID = ProviderID.make(`provider-${directory}`)
+  const modelID = ModelID.make(`model-${directory}`)
+  const providers = {
+    [providerID]: {
+      id: providerID,
+      name: `Provider ${directory}`,
+      source: "config",
+      env: [],
+      options: {},
+      models: {
+        [modelID]: model(providerID, modelID, {
+          low: { reasoningEffort: "low" },
+          high: { reasoningEffort: "high" },
+        }),
+        [ModelID.make(`plain-${directory}`)]: model(providerID, `plain-${directory}`),
+      },
+    },
+  } satisfies Record<ProviderID, Provider.Info>
+
+  return Directory.build({
+    directory,
+    providers,
+    modes: [
+      { id: "build", name: `build-${directory}` },
+      { id: "plan", name: `plan-${directory}`, description: "plan first" },
+    ],
+    defaultModeID: "build",
+    commands: [command(`init-${directory}`), command(`review-${directory}`)],
+    defaultModel: { providerID, modelID },
+  })
+}
+
+const fakeLayer = (calls: string[]) =>
+  Directory.layer.pipe(
+    Layer.provide(
+      Layer.succeed(
+        Directory.Loader,
+        Directory.Loader.of({
+          load: (directory) =>
+            Effect.sync(() => {
+              calls.push(directory)
+              return snapshot(directory)
+            }),
+        }),
+      ),
+    ),
+  )
+
+describe("ACP next directory snapshot", () => {
+  it.effect("two concurrent callers share one load", () => {
+    const calls: string[] = []
+    return Effect.gen(function* () {
+      const directory = yield* Directory.Service
+      const [first, second] = yield* Effect.all([directory.get("alpha"), directory.get("alpha")], {
+        concurrency: "unbounded",
+      })
+
+      expect(calls).toEqual(["alpha"])
+      expect(first).toBe(second)
+    }).pipe(Effect.provide(fakeLayer(calls)))
+  })
+
+  it.effect("warm calls use cached data", () => {
+    const calls: string[] = []
+    return Effect.gen(function* () {
+      const directory = yield* Directory.Service
+      const first = yield* directory.get("alpha")
+      const second = yield* directory.get("alpha")
+
+      expect(calls).toEqual(["alpha"])
+      expect(first).toBe(second)
+    }).pipe(Effect.provide(fakeLayer(calls)))
+  })
+
+  it.effect("different directories get different snapshots", () => {
+    const calls: string[] = []
+    return Effect.gen(function* () {
+      const directory = yield* Directory.Service
+      const [alpha, beta] = yield* Effect.all([directory.get("alpha"), directory.get("beta")], {
+        concurrency: "unbounded",
+      })
+
+      expect(calls.toSorted()).toEqual(["alpha", "beta"])
+      expect(alpha.directory).toBe("alpha")
+      expect(beta.directory).toBe("beta")
+      expect(alpha.defaultModel?.providerID).not.toBe(beta.defaultModel?.providerID)
+    }).pipe(Effect.provide(fakeLayer(calls)))
+  })
+
+  it.effect("model variant lookup works", () =>
+    Effect.gen(function* () {
+      const directory = yield* Directory.Service
+      const alpha = yield* directory.get("alpha")
+      const model = alpha.defaultModel!
+
+      expect(directory.variants(alpha, model)).toEqual({
+        low: { reasoningEffort: "low" },
+        high: { reasoningEffort: "high" },
+      })
+      expect(directory.variants(alpha, { ...model, modelID: ModelID.make("missing") })).toBeUndefined()
+    }).pipe(Effect.provide(fakeLayer([]))),
+  )
+
+  it.effect("commands and modes are included", () =>
+    Effect.gen(function* () {
+      const directory = yield* Directory.Service
+      const alpha = yield* directory.get("alpha")
+
+      expect(alpha.availableCommands.map((item) => item.name)).toEqual(["init-alpha", "review-alpha"])
+      expect(alpha.availableModes).toEqual([
+        { id: "build", name: "build-alpha" },
+        { id: "plan", name: "plan-alpha", description: "plan first" },
+      ])
+      expect(alpha.defaultModeID).toBe("build")
+    }).pipe(Effect.provide(fakeLayer([]))),
+  )
+
+  it.effect("falls back when the default mode is not available", () =>
+    Effect.sync(() => {
+      expect(
+        Directory.build({
+          directory: "alpha",
+          providers: {},
+          modes: [
+            { id: "build", name: "Build" },
+            { id: "plan", name: "Plan" },
+          ],
+          defaultModeID: "hidden",
+          commands: [],
+        }).defaultModeID,
+      ).toBe("build")
+    }),
+  )
+})

From fbfa968625eb52c6179c5e08b4fe7ee6314c9fd1 Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 21:56:05 +0530
Subject: [PATCH 19/31] feat(acp-next): add session state service (#29240)

---
 packages/opencode/src/acp-next/session.ts     | 218 ++++++++++++++++++
 .../opencode/test/acp-next/session.test.ts    | 199 ++++++++++++++++
 2 files changed, 417 insertions(+)
 create mode 100644 packages/opencode/src/acp-next/session.ts
 create mode 100644 packages/opencode/test/acp-next/session.test.ts

diff --git a/packages/opencode/src/acp-next/session.ts b/packages/opencode/src/acp-next/session.ts
new file mode 100644
index 000000000000..f14dc469b5bd
--- /dev/null
+++ b/packages/opencode/src/acp-next/session.ts
@@ -0,0 +1,218 @@
+import type { McpServer } from "@agentclientprotocol/sdk"
+import { Context, Effect, Layer, Ref } from "effect"
+import type { ModelID, ProviderID } from "../provider/schema"
+import * as ACPNextError from "./error"
+
+export type SelectedModel = {
+  providerID: ProviderID
+  modelID: ModelID
+}
+
+export type KnownMessagePartMetadata = {
+  messageId: string
+  partId: string
+  toolCallId?: string
+  metadata?: unknown
+}
+
+export type Info = {
+  id: string
+  cwd: string
+  mcpServers: readonly McpServer[]
+  createdAt: Date
+  model?: SelectedModel
+  variant?: string
+  modeId?: string
+  knownParts: ReadonlyMap<string, KnownMessagePartMetadata>
+}
+
+export type StoreInput = {
+  id: string
+  cwd: string
+  mcpServers?: readonly McpServer[]
+  createdAt?: Date
+  model?: SelectedModel
+  variant?: string
+  modeId?: string
+}
+
+export type RecordPartMetadataInput = {
+  sessionId: string
+  messageId: string
+  partId: string
+  toolCallId?: string
+  metadata?: unknown
+}
+
+export type PartMetadataLookupInput = {
+  sessionId: string
+  messageId: string
+  partId: string
+}
+
+export type Interface = {
+  readonly create: (input: StoreInput) => Effect.Effect<Info>
+  readonly load: (input: StoreInput) => Effect.Effect<Info>
+  readonly get: (sessionId: string) => Effect.Effect<Info, ACPNextError.SessionNotFoundError>
+  readonly tryGet: (sessionId: string) => Effect.Effect<Info | undefined>
+  readonly remove: (sessionId: string) => Effect.Effect<Info | undefined>
+  readonly setModel: (
+    sessionId: string,
+    model: SelectedModel | undefined,
+  ) => Effect.Effect<Info, ACPNextError.SessionNotFoundError>
+  readonly getModel: (sessionId: string) => Effect.Effect<SelectedModel | undefined, ACPNextError.SessionNotFoundError>
+  readonly setVariant: (
+    sessionId: string,
+    variant: string | undefined,
+  ) => Effect.Effect<Info, ACPNextError.SessionNotFoundError>
+  readonly getVariant: (sessionId: string) => Effect.Effect<string | undefined, ACPNextError.SessionNotFoundError>
+  readonly setMode: (
+    sessionId: string,
+    modeId: string | undefined,
+  ) => Effect.Effect<Info, ACPNextError.SessionNotFoundError>
+  readonly getMode: (sessionId: string) => Effect.Effect<string | undefined, ACPNextError.SessionNotFoundError>
+  readonly recordPartMetadata: (
+    input: RecordPartMetadataInput,
+  ) => Effect.Effect<KnownMessagePartMetadata, ACPNextError.SessionNotFoundError>
+  readonly getPartMetadata: (
+    input: PartMetadataLookupInput,
+  ) => Effect.Effect<KnownMessagePartMetadata | undefined, ACPNextError.SessionNotFoundError>
+  readonly tryGetPartMetadata: (input: PartMetadataLookupInput) => Effect.Effect<KnownMessagePartMetadata | undefined>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/ACPNext/Session") {}
+
+type State = Map<string, Info>
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const sessions = yield* Ref.make<State>(new Map())
+
+    const store = Effect.fn("ACPNext.Session.store")(function* (input: StoreInput) {
+      const session = makeSession(input)
+      yield* Ref.update(sessions, (state) => new Map(state).set(session.id, session))
+      return snapshot(session)
+    })
+
+    const tryGet = Effect.fn("ACPNext.Session.tryGet")(function* (sessionId: string) {
+      const session = (yield* Ref.get(sessions)).get(sessionId)
+      if (!session) return
+      return snapshot(session)
+    })
+
+    const get = Effect.fn("ACPNext.Session.get")(function* (sessionId: string) {
+      const session = yield* tryGet(sessionId)
+      if (session) return session
+      return yield* new ACPNextError.SessionNotFoundError({ sessionId })
+    })
+
+    const update = Effect.fn("ACPNext.Session.update")(function* (
+      sessionId: string,
+      fn: (session: Info) => Info,
+    ) {
+      const result = yield* Ref.modify(sessions, (state) => {
+        const session = state.get(sessionId)
+        if (!session) return [undefined, state] as const
+        const next = fn(session)
+        return [snapshot(next), new Map(state).set(sessionId, next)] as const
+      })
+      if (result) return result
+      return yield* new ACPNextError.SessionNotFoundError({ sessionId })
+    })
+
+    const remove = Effect.fn("ACPNext.Session.remove")(function* (sessionId: string) {
+      return yield* Ref.modify(sessions, (state) => {
+        const session = state.get(sessionId)
+        if (!session) return [undefined, state] as const
+        const next = new Map(state)
+        next.delete(sessionId)
+        return [snapshot(session), next] as const
+      })
+    })
+
+    const setModel: Interface["setModel"] = Effect.fn("ACPNext.Session.setModel")((sessionId, model) =>
+      update(sessionId, (session) => ({ ...session, model })),
+    )
+
+    const setVariant: Interface["setVariant"] = Effect.fn("ACPNext.Session.setVariant")((sessionId, variant) =>
+      update(sessionId, (session) => ({ ...session, variant })),
+    )
+
+    const setMode: Interface["setMode"] = Effect.fn("ACPNext.Session.setMode")((sessionId, modeId) =>
+      update(sessionId, (session) => ({ ...session, modeId })),
+    )
+
+    const recordPartMetadata: Interface["recordPartMetadata"] = Effect.fn("ACPNext.Session.recordPartMetadata")(
+      (input) => {
+        const metadata = {
+          messageId: input.messageId,
+          partId: input.partId,
+          toolCallId: input.toolCallId,
+          metadata: input.metadata,
+        }
+        return update(input.sessionId, (session) => ({
+          ...session,
+          knownParts: new Map(session.knownParts).set(partMetadataKey(input), metadata),
+        })).pipe(Effect.as(metadata))
+      },
+    )
+
+    return Service.of({
+      create: store,
+      load: store,
+      get,
+      tryGet,
+      remove,
+      setModel,
+      getModel: Effect.fn("ACPNext.Session.getModel")(function* (sessionId) {
+        return (yield* get(sessionId)).model
+      }),
+      setVariant,
+      getVariant: Effect.fn("ACPNext.Session.getVariant")(function* (sessionId) {
+        return (yield* get(sessionId)).variant
+      }),
+      setMode,
+      getMode: Effect.fn("ACPNext.Session.getMode")(function* (sessionId) {
+        return (yield* get(sessionId)).modeId
+      }),
+      recordPartMetadata,
+      getPartMetadata: Effect.fn("ACPNext.Session.getPartMetadata")(function* (input) {
+        return (yield* get(input.sessionId)).knownParts.get(partMetadataKey(input))
+      }),
+      tryGetPartMetadata: Effect.fn("ACPNext.Session.tryGetPartMetadata")(function* (input) {
+        return (yield* tryGet(input.sessionId))?.knownParts.get(partMetadataKey(input))
+      }),
+    })
+  }),
+)
+
+export const defaultLayer = layer
+
+function makeSession(input: StoreInput): Info {
+  return {
+    id: input.id,
+    cwd: input.cwd,
+    mcpServers: [...(input.mcpServers ?? [])],
+    createdAt: input.createdAt ? new Date(input.createdAt) : new Date(),
+    model: input.model,
+    variant: input.variant,
+    modeId: input.modeId,
+    knownParts: new Map(),
+  }
+}
+
+function snapshot(session: Info): Info {
+  return {
+    ...session,
+    mcpServers: [...session.mcpServers],
+    createdAt: new Date(session.createdAt),
+    knownParts: new Map(session.knownParts),
+  }
+}
+
+function partMetadataKey(input: { messageId: string; partId: string }) {
+  return `${input.messageId}:${input.partId}`
+}
+
+export * as ACPNextSession from "./session"
diff --git a/packages/opencode/test/acp-next/session.test.ts b/packages/opencode/test/acp-next/session.test.ts
new file mode 100644
index 000000000000..0c1cb16cc784
--- /dev/null
+++ b/packages/opencode/test/acp-next/session.test.ts
@@ -0,0 +1,199 @@
+import { describe, expect } from "bun:test"
+import type { McpServer } from "@agentclientprotocol/sdk"
+import { Effect } from "effect"
+import * as ACPNextError from "@/acp-next/error"
+import * as ACPNextSession from "@/acp-next/session"
+import { ModelID, ProviderID } from "@/provider/schema"
+import { testEffect } from "../lib/effect"
+
+const sessionTest = testEffect(ACPNextSession.defaultLayer)
+
+const model = (providerID: string, modelID: string): ACPNextSession.SelectedModel => ({
+  providerID: ProviderID.make(providerID),
+  modelID: ModelID.make(modelID),
+})
+
+const mcpServer: McpServer = {
+  name: "local-tools",
+  command: "node",
+  args: ["server.js"],
+  env: [],
+}
+
+describe("acp-next session state", () => {
+  sessionTest.effect("creates and retrieves session state", () =>
+    Effect.gen(function* () {
+      const createdAt = new Date("2026-05-25T00:00:00.000Z")
+      const created = yield* ACPNextSession.Service.use((session) =>
+        session.create({
+          id: "ses_1",
+          cwd: "/workspace",
+          mcpServers: [mcpServer],
+          createdAt,
+          model: model("anthropic", "claude-sonnet"),
+          variant: "high",
+          modeId: "build",
+        }),
+      )
+      const loaded = yield* ACPNextSession.Service.use((session) => session.get("ses_1"))
+
+      expect(created).toMatchObject({
+        id: "ses_1",
+        cwd: "/workspace",
+        mcpServers: [mcpServer],
+        model: model("anthropic", "claude-sonnet"),
+        variant: "high",
+        modeId: "build",
+      })
+      expect(loaded.createdAt).toEqual(createdAt)
+      expect(loaded.knownParts.size).toBe(0)
+    }),
+  )
+
+  sessionTest.effect("fails required lookups with typed SessionNotFound", () =>
+    Effect.gen(function* () {
+      const error = yield* ACPNextSession.Service.use((session) => session.get("ses_missing")).pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(ACPNextError.SessionNotFoundError)
+      expect(error.sessionId).toBe("ses_missing")
+    }),
+  )
+
+  sessionTest.effect("tryGet lets event routing ignore unknown sessions", () =>
+    Effect.gen(function* () {
+      const missing = yield* ACPNextSession.Service.use((session) => session.tryGet("ses_missing"))
+      const missingPart = yield* ACPNextSession.Service.use((session) =>
+        session.tryGetPartMetadata({ sessionId: "ses_missing", messageId: "msg_1", partId: "part_1" }),
+      )
+
+      expect(missing).toBeUndefined()
+      expect(missingPart).toBeUndefined()
+    }),
+  )
+
+  sessionTest.effect("updates selected model while preserving session identity and inputs", () =>
+    Effect.gen(function* () {
+      yield* ACPNextSession.Service.use((session) =>
+        session.create({
+          id: "ses_model",
+          cwd: "/workspace",
+          mcpServers: [mcpServer],
+          model: model("anthropic", "claude-sonnet"),
+          variant: "high",
+          modeId: "build",
+        }),
+      )
+
+      const updated = yield* ACPNextSession.Service.use((session) =>
+        session.setModel("ses_model", model("openai", "gpt-5")),
+      )
+
+      expect(updated.id).toBe("ses_model")
+      expect(updated.cwd).toBe("/workspace")
+      expect(updated.mcpServers).toEqual([mcpServer])
+      expect(updated.model).toEqual(model("openai", "gpt-5"))
+      expect(updated.variant).toBe("high")
+      expect(updated.modeId).toBe("build")
+    }),
+  )
+
+  sessionTest.effect("updates selected variant and mode independently", () =>
+    Effect.gen(function* () {
+      yield* ACPNextSession.Service.use((session) =>
+        session.load({
+          id: "ses_config",
+          cwd: "/workspace",
+          model: model("anthropic", "claude-sonnet"),
+          variant: "low",
+          modeId: "plan",
+        }),
+      )
+
+      yield* ACPNextSession.Service.use((session) => session.setVariant("ses_config", "high"))
+      expect(yield* ACPNextSession.Service.use((session) => session.getVariant("ses_config"))).toBe("high")
+      expect(yield* ACPNextSession.Service.use((session) => session.getMode("ses_config"))).toBe("plan")
+
+      yield* ACPNextSession.Service.use((session) => session.setMode("ses_config", "build"))
+      expect(yield* ACPNextSession.Service.use((session) => session.getVariant("ses_config"))).toBe("high")
+      expect(yield* ACPNextSession.Service.use((session) => session.getMode("ses_config"))).toBe("build")
+    }),
+  )
+
+  sessionTest.effect("records known message part metadata for delta routing", () =>
+    Effect.gen(function* () {
+      yield* ACPNextSession.Service.use((session) => session.create({ id: "ses_parts", cwd: "/workspace" }))
+
+      const metadata = yield* ACPNextSession.Service.use((session) =>
+        session.recordPartMetadata({
+          sessionId: "ses_parts",
+          messageId: "msg_1",
+          partId: "part_1",
+          toolCallId: "tool_1",
+          metadata: { output: "first chunk" },
+        }),
+      )
+      const routed = yield* ACPNextSession.Service.use((session) =>
+        session.getPartMetadata({ sessionId: "ses_parts", messageId: "msg_1", partId: "part_1" }),
+      )
+
+      expect(metadata).toEqual({
+        messageId: "msg_1",
+        partId: "part_1",
+        toolCallId: "tool_1",
+        metadata: { output: "first chunk" },
+      })
+      expect(routed).toEqual(metadata)
+    }),
+  )
+
+  sessionTest.effect("keeps repeated part ids distinct across messages", () =>
+    Effect.gen(function* () {
+      yield* ACPNextSession.Service.use((session) => session.create({ id: "ses_duplicate_parts", cwd: "/workspace" }))
+      yield* ACPNextSession.Service.use((session) =>
+        session.recordPartMetadata({
+          sessionId: "ses_duplicate_parts",
+          messageId: "msg_1",
+          partId: "part_1",
+          metadata: { output: "from first message" },
+        }),
+      )
+      yield* ACPNextSession.Service.use((session) =>
+        session.recordPartMetadata({
+          sessionId: "ses_duplicate_parts",
+          messageId: "msg_2",
+          partId: "part_1",
+          metadata: { output: "from second message" },
+        }),
+      )
+
+      const first = yield* ACPNextSession.Service.use((session) =>
+        session.getPartMetadata({ sessionId: "ses_duplicate_parts", messageId: "msg_1", partId: "part_1" }),
+      )
+      const second = yield* ACPNextSession.Service.use((session) =>
+        session.getPartMetadata({ sessionId: "ses_duplicate_parts", messageId: "msg_2", partId: "part_1" }),
+      )
+
+      expect(first?.metadata).toEqual({ output: "from first message" })
+      expect(second?.metadata).toEqual({ output: "from second message" })
+    }),
+  )
+
+  sessionTest.effect("removing a session clears its known part metadata", () =>
+    Effect.gen(function* () {
+      yield* ACPNextSession.Service.use((session) => session.create({ id: "ses_remove", cwd: "/workspace" }))
+      yield* ACPNextSession.Service.use((session) =>
+        session.recordPartMetadata({ sessionId: "ses_remove", messageId: "msg_1", partId: "part_1" }),
+      )
+
+      const removed = yield* ACPNextSession.Service.use((session) => session.remove("ses_remove"))
+      const missing = yield* ACPNextSession.Service.use((session) => session.tryGet("ses_remove"))
+      const missingPart = yield* ACPNextSession.Service.use((session) =>
+        session.tryGetPartMetadata({ sessionId: "ses_remove", messageId: "msg_1", partId: "part_1" }),
+      )
+
+      expect(removed?.knownParts.size).toBe(1)
+      expect(missing).toBeUndefined()
+      expect(missingPart).toBeUndefined()
+    }),
+  )
+})

From 292b626e99e8719d192d2f8a95d57ae17f6dc2f3 Mon Sep 17 00:00:00 2001
From: "opencode-agent[bot]" <opencode-agent[bot]@users.noreply.github.com>
Date: Mon, 25 May 2026 16:27:24 +0000
Subject: [PATCH 20/31] chore: generate

---
 packages/opencode/src/acp-next/directory.ts |  9 ++----
 packages/opencode/src/acp-next/session.ts   | 33 ++++++++++-----------
 2 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/packages/opencode/src/acp-next/directory.ts b/packages/opencode/src/acp-next/directory.ts
index bf8eb557519c..a991fb19996c 100644
--- a/packages/opencode/src/acp-next/directory.ts
+++ b/packages/opencode/src/acp-next/directory.ts
@@ -114,12 +114,7 @@ export const loaderLayer = Layer.effect(
         return yield* Effect.gen(function* () {
           const providers = yield* provider.list()
           const [agents, defaultAgent, commands, defaultModel] = yield* Effect.all(
-            [
-              agent.list(),
-              agent.defaultInfo(),
-              command.list(),
-              provider.defaultModel().pipe(Effect.option),
-            ],
+            [agent.list(), agent.defaultInfo(), command.list(), provider.defaultModel().pipe(Effect.option)],
             { concurrency: "unbounded" },
           )
           return build({
@@ -161,7 +156,7 @@ export const layer = Layer.effect(
     })
 
     const get = Effect.fn("ACPNextDirectory.get")(function* (directory: string) {
-      return yield* (yield* cached(directory))
+      return yield* yield* cached(directory)
     })
 
     const refresh = Effect.fn("ACPNextDirectory.refresh")(function* (directory: string) {
diff --git a/packages/opencode/src/acp-next/session.ts b/packages/opencode/src/acp-next/session.ts
index f14dc469b5bd..7a969c867f5f 100644
--- a/packages/opencode/src/acp-next/session.ts
+++ b/packages/opencode/src/acp-next/session.ts
@@ -107,10 +107,7 @@ export const layer = Layer.effect(
       return yield* new ACPNextError.SessionNotFoundError({ sessionId })
     })
 
-    const update = Effect.fn("ACPNext.Session.update")(function* (
-      sessionId: string,
-      fn: (session: Info) => Info,
-    ) {
+    const update = Effect.fn("ACPNext.Session.update")(function* (sessionId: string, fn: (session: Info) => Info) {
       const result = yield* Ref.modify(sessions, (state) => {
         const session = state.get(sessionId)
         if (!session) return [undefined, state] as const
@@ -143,20 +140,20 @@ export const layer = Layer.effect(
       update(sessionId, (session) => ({ ...session, modeId })),
     )
 
-    const recordPartMetadata: Interface["recordPartMetadata"] = Effect.fn("ACPNext.Session.recordPartMetadata")(
-      (input) => {
-        const metadata = {
-          messageId: input.messageId,
-          partId: input.partId,
-          toolCallId: input.toolCallId,
-          metadata: input.metadata,
-        }
-        return update(input.sessionId, (session) => ({
-          ...session,
-          knownParts: new Map(session.knownParts).set(partMetadataKey(input), metadata),
-        })).pipe(Effect.as(metadata))
-      },
-    )
+    const recordPartMetadata: Interface["recordPartMetadata"] = Effect.fn("ACPNext.Session.recordPartMetadata")((
+      input,
+    ) => {
+      const metadata = {
+        messageId: input.messageId,
+        partId: input.partId,
+        toolCallId: input.toolCallId,
+        metadata: input.metadata,
+      }
+      return update(input.sessionId, (session) => ({
+        ...session,
+        knownParts: new Map(session.knownParts).set(partMetadataKey(input), metadata),
+      })).pipe(Effect.as(metadata))
+    })
 
     return Service.of({
       create: store,

From 8fefc501cb28dd53cbe5a8d528b3984b7049084a Mon Sep 17 00:00:00 2001
From: Shoubhit Dash <shoubhit2005@gmail.com>
Date: Mon, 25 May 2026 22:17:11 +0530
Subject: [PATCH 21/31] feat(acp-next): add usage service (#29249)

---
 packages/opencode/src/acp-next/usage.ts       | 251 ++++++++++++++
 packages/opencode/test/acp-next/usage.test.ts | 314 ++++++++++++++++++
 2 files changed, 565 insertions(+)
 create mode 100644 packages/opencode/src/acp-next/usage.ts
 create mode 100644 packages/opencode/test/acp-next/usage.test.ts

diff --git a/packages/opencode/src/acp-next/usage.ts b/packages/opencode/src/acp-next/usage.ts
new file mode 100644
index 000000000000..bcf86709f9c2
--- /dev/null
+++ b/packages/opencode/src/acp-next/usage.ts
@@ -0,0 +1,251 @@
+import type { AgentSideConnection, Usage } from "@agentclientprotocol/sdk"
+import * as Log from "@opencode-ai/core/util/log"
+import { InstanceRef } from "@/effect/instance-ref"
+import { InstanceStore } from "@/project/instance-store"
+import { ModelID, ProviderID } from "@/provider/schema"
+import { Provider } from "@/provider/provider"
+import { Context, Effect, Layer, SynchronizedRef } from "effect"
+
+const log = Log.create({ service: "acp-next-usage" })
+
+export type AssistantTokenCost = {
+  readonly cost: number
+  readonly tokens: {
+    readonly input: number
+    readonly output: number
+    readonly reasoning: number
+    readonly cache: {
+      readonly read: number
+      readonly write: number
+    }
+  }
+}
+
+export type AssistantMessage = AssistantTokenCost & {
+  readonly role: "assistant"
+  readonly providerID?: string
+  readonly modelID?: string
+}
+
+export type SessionMessage = {
+  readonly info: { readonly role: string } | AssistantMessage
+}
+
+export type MessagesInput = {
+  readonly sessionID: string
+  readonly directory: string
+}
+
+export type SDK = {
+  readonly session: {
+    readonly messages: (
+      parameters: { readonly sessionID: string; readonly directory: string },
+      options: { readonly throwOnError: true },
+    ) => Promise<{ readonly data?: readonly SessionMessage[] | null }>
+  }
+}
+
+export interface MessageLoaderInterface {
+  readonly messages: (input: MessagesInput) => Effect.Effect<readonly SessionMessage[], unknown>
+}
+
+export interface ContextLimitLoaderInterface {
+  readonly providers: (directory: string) => Effect.Effect<Record<ProviderID, Provider.Info>, unknown>
+}
+
+export type UsageConnection = Pick<AgentSideConnection, "sessionUpdate">
+
+export interface Interface {
+  readonly buildUsage: (message: AssistantTokenCost) => Usage
+  readonly latestAssistantMessage: (messages: readonly SessionMessage[]) => AssistantMessage | undefined
+  readonly totalSessionCost: (messages: readonly SessionMessage[]) => number
+  readonly contextLimit: (input: {
+    readonly directory: string
+    readonly providerID: ProviderID
+    readonly modelID: ModelID
+  }) => Effect.Effect<number | undefined>
+  readonly sendUpdate: (input: {
+    readonly connection: UsageConnection
+    readonly sessionID: string
+    readonly directory: string
+  }) => Effect.Effect<void>
+}
+
+export class MessageLoader extends Context.Service<MessageLoader, MessageLoaderInterface>()(
+  "@opencode/ACPNextUsageMessageLoader",
+) {}
+
+export class ContextLimitLoader extends Context.Service<ContextLimitLoader, ContextLimitLoaderInterface>()(
+  "@opencode/ACPNextUsageContextLimitLoader",
+) {}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/ACPNextUsage") {}
+
+export function messageLoaderFromSDK(sdk: SDK): MessageLoaderInterface {
+  return MessageLoader.of({
+    messages: (input) =>
+      Effect.promise(() =>
+        sdk.session.messages({ sessionID: input.sessionID, directory: input.directory }, { throwOnError: true }).then(
+          (response) => response.data ?? [],
+        ),
+      ),
+  })
+}
+
+export const messageLoaderLayer = (sdk: SDK) => Layer.succeed(MessageLoader, messageLoaderFromSDK(sdk))
+
+export function buildUsage(message: AssistantTokenCost): Usage {
+  const cachedReadTokens = message.tokens.cache.read
+  const cachedWriteTokens = message.tokens.cache.write
+  const thoughtTokens = message.tokens.reasoning
+
+  return {
+    inputTokens: message.tokens.input,
+    outputTokens: message.tokens.output,
+    totalTokens:
+      message.tokens.input + message.tokens.output + thoughtTokens + cachedReadTokens + cachedWriteTokens,
+    ...(thoughtTokens > 0 ? { thoughtTokens } : {}),
+    ...(cachedReadTokens > 0 ? { cachedReadTokens } : {}),
+    ...(cachedWriteTokens > 0 ? { cachedWriteTokens } : {}),
+  }
+}
+
+export function latestAssistantMessage(messages: readonly SessionMessage[]): AssistantMessage | undefined {
+  return messages
+    .filter((message): message is { readonly info: AssistantMessage } => message.info.role === "assistant")
+    .at(-1)?.info
+}
+
+export function totalSessionCost(messages: readonly SessionMessage[]): number {
+  return messages
+    .filter((message): message is { readonly info: AssistantMessage } => message.info.role === "assistant")
+    .reduce((sum, message) => sum + message.info.cost, 0)
+}
+
+export function findContextLimit(
+  providers: Record<ProviderID, Provider.Info>,
+  providerID: ProviderID,
+  modelID: ModelID,
+): number | undefined {
+  return providers[providerID]?.models[modelID]?.limit.context
+}
+
+export const contextLimitLoaderLayer = Layer.effect(
+  ContextLimitLoader,
+  Effect.gen(function* () {
+    const store = yield* InstanceStore.Service
+    const provider = yield* Provider.Service
+
+    return ContextLimitLoader.of({
+      providers: Effect.fn("ACPNextUsageContextLimitLoader.providers")(function* (directory) {
+        const ctx = yield* store.load({ directory })
+        return yield* Effect.gen(function* () {
+          return yield* provider.list()
+        }).pipe(Effect.provideService(InstanceRef, ctx))
+      }),
+    })
+  }),
+)
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const messageLoader = yield* MessageLoader
+    const contextLimitLoader = yield* ContextLimitLoader
+    const limits = yield* SynchronizedRef.make(new Map<string, Effect.Effect<number | undefined>>())
+
+    const cachedLimit = Effect.fnUntraced(function* (input: {
+      readonly directory: string
+      readonly providerID: ProviderID
+      readonly modelID: ModelID
+    }) {
+      return yield* SynchronizedRef.modifyEffect(
+        limits,
+        Effect.fnUntraced(function* (items) {
+          const key = `${input.directory}\u0000${input.providerID}\u0000${input.modelID}`
+          const current = items.get(key)
+          if (current) return [current, items] as const
+          const next = yield* Effect.cached(
+            contextLimitLoader.providers(input.directory).pipe(
+              Effect.map((providers) => findContextLimit(providers, input.providerID, input.modelID)),
+              Effect.catch((error) =>
+                Effect.sync(() => {
+                  log.error("failed to get providers for usage context limit", { error })
+                  return undefined
+                }),
+              ),
+            ),
+          )
+          return [next, new Map(items).set(key, next)] as const
+        }),
+      )
+    })
+
+    const contextLimit = Effect.fn("ACPNextUsage.contextLimit")(function* (input: {
+      readonly directory: string
+      readonly providerID: ProviderID
+      readonly modelID: ModelID
+    }) {
+      return yield* (yield* cachedLimit(input))
+    })
+
+    const sendUpdate = Effect.fn("ACPNextUsage.sendUpdate")(function* (input: {
+      readonly connection: UsageConnection
+      readonly sessionID: string
+      readonly directory: string
+    }) {
+      const messages = yield* messageLoader.messages({ sessionID: input.sessionID, directory: input.directory }).pipe(
+        Effect.catch((error) =>
+          Effect.sync(() => {
+            log.error("failed to fetch messages for usage update", { error })
+            return undefined
+          }),
+        ),
+      )
+      if (!messages) return
+
+      const message = latestAssistantMessage(messages)
+      if (!message) return
+      if (!message.providerID || !message.modelID) return
+
+      const size = yield* contextLimit({
+        directory: input.directory,
+        providerID: ProviderID.make(message.providerID),
+        modelID: ModelID.make(message.modelID),
+      })
+      if (!size) return
+
+      yield* Effect.promise(() =>
+        input.connection
+          .sessionUpdate({
+            sessionId: input.sessionID,
+            update: {
+              sessionUpdate: "usage_update",
+              used: message.tokens.input + message.tokens.cache.read,
+              size,
+              cost: { amount: totalSessionCost(messages), currency: "USD" },
+            },
+          })
+          .catch((error) => {
+            log.error("failed to send usage update", { error })
+          }),
+      )
+    })
+
+    return Service.of({
+      buildUsage,
+      latestAssistantMessage,
+      totalSessionCost,
+      contextLimit,
+      sendUpdate,
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(contextLimitLoaderLayer),
+  Layer.provide(Provider.defaultLayer),
+  Layer.provide(InstanceStore.defaultLayer),
+)
+
+export * as UsageService from "./usage"
diff --git a/packages/opencode/test/acp-next/usage.test.ts b/packages/opencode/test/acp-next/usage.test.ts
new file mode 100644
index 000000000000..77c17d4f72ea
--- /dev/null
+++ b/packages/opencode/test/acp-next/usage.test.ts
@@ -0,0 +1,314 @@
+import { describe, expect, test } from "bun:test"
+import type { SessionNotification } from "@agentclientprotocol/sdk"
+import { UsageService } from "@/acp-next/usage"
+import { ModelID, ProviderID } from "@/provider/schema"
+import { Provider } from "@/provider/provider"
+import { Effect, Layer } from "effect"
+import { it } from "../lib/effect"
+
+const assistant = (
+  input: Partial<UsageService.AssistantMessage> & Pick<UsageService.AssistantMessage, "cost">,
+): UsageService.SessionMessage => ({
+  info: {
+    role: "assistant",
+    providerID: "anthropic",
+    modelID: "claude-sonnet",
+    tokens: {
+      input: 10,
+      output: 20,
+      reasoning: 0,
+      cache: { read: 0, write: 0 },
+    },
+    ...input,
+  },
+})
+
+const user = (): UsageService.SessionMessage => ({
+  info: { role: "user" },
+})
+
+const assistantWithoutProvider = (): UsageService.SessionMessage => ({
+  info: {
+    role: "assistant",
+    modelID: "claude-sonnet",
+    cost: 1,
+    tokens: {
+      input: 10,
+      output: 20,
+      reasoning: 0,
+      cache: { read: 0, write: 0 },
+    },
+  },
+})
+
+const model = (providerID: ProviderID, modelID: ModelID, context: number): Provider.Model => ({
+  id: modelID,
+  providerID,
+  api: {
+    id: modelID,
+    url: "https://example.com",
+    npm: "@ai-sdk/openai-compatible",
+  },
+  name: modelID,
+  family: "test",
+  capabilities: {
+    temperature: true,
+    reasoning: false,
+    attachment: false,
+    toolcall: true,
+    input: { text: true, audio: false, image: false, video: false, pdf: false },
+    output: { text: true, audio: false, image: false, video: false, pdf: false },
+    interleaved: false,
+  },
+  cost: {
+    input: 0,
+    output: 0,
+    cache: { read: 0, write: 0 },
+  },
+  limit: {
+    context,
+    output: 4096,
+  },
+  status: "active",
+  options: {},
+  headers: {},
+  release_date: "2026-01-01",
+})
+
+const providers = (context = 128_000): Record<ProviderID, Provider.Info> => {
+  const providerID = ProviderID.make("anthropic")
+  const modelID = ModelID.make("claude-sonnet")
+  return {
+    [providerID]: {
+      id: providerID,
+      name: "Anthropic",
+      source: "config",
+      env: [],
+      options: {},
+      models: {
+        [modelID]: model(providerID, modelID, context),
+      },
+    },
+  }
+}
+
+const fakeLayer = (input: {
+  readonly messages?: Effect.Effect<readonly UsageService.SessionMessage[], unknown>
+  readonly providers?: (directory: string) => Effect.Effect<Record<ProviderID, Provider.Info>, unknown>
+}) =>
+  UsageService.layer.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        Layer.succeed(
+          UsageService.MessageLoader,
+          UsageService.MessageLoader.of({
+            messages: () => input.messages ?? Effect.succeed([]),
+          }),
+        ),
+        Layer.succeed(
+          UsageService.ContextLimitLoader,
+          UsageService.ContextLimitLoader.of({
+            providers: input.providers ?? (() => Effect.succeed(providers())),
+          }),
+        ),
+      ),
+    ),
+  )
+
+const connection = (updates: SessionNotification[]) => ({
+  sessionUpdate(params: SessionNotification) {
+    updates.push(params)
+    return Promise.resolve()
+  },
+})
+
+describe("acp-next usage", () => {
+  test("builds ACP Usage from assistant token shape", () => {
+    expect(
+      UsageService.buildUsage({
+        cost: 0.02,
+        tokens: {
+          input: 100,
+          output: 40,
+          reasoning: 7,
+          cache: { read: 11, write: 13 },
+        },
+      }),
+    ).toEqual({
+      inputTokens: 100,
+      outputTokens: 40,
+      thoughtTokens: 7,
+      cachedReadTokens: 11,
+      cachedWriteTokens: 13,
+      totalTokens: 171,
+    })
+  })
+
+  test("omits optional token fields when they are zero", () => {
+    expect(
+      UsageService.buildUsage({
+        cost: 0,
+        tokens: {
+          input: 3,
+          output: 4,
+          reasoning: 0,
+          cache: { read: 0, write: 0 },
+        },
+      }),
+    ).toEqual({
+      inputTokens: 3,
+      outputTokens: 4,
+      totalTokens: 7,
+    })
+  })
+
+  test("finds the latest assistant message", () => {
+    expect(
+      UsageService.latestAssistantMessage([assistant({ cost: 1, modelID: "older" }), user(), assistant({ cost: 2 })]),
+    ).toMatchObject({ cost: 2 })
+  })
+
+  test("calculates total session cost from assistant messages", () => {
+    expect(UsageService.totalSessionCost([assistant({ cost: 1.25 }), user(), assistant({ cost: 2.5 })])).toBe(3.75)
+  })
+
+  it.effect("loads context limits from providers and caches by directory/provider/model", () => {
+    const calls: string[] = []
+    return Effect.gen(function* () {
+      const usage = yield* UsageService.Service
+      const first = yield* usage.contextLimit({
+        directory: "/workspace",
+        providerID: ProviderID.make("anthropic"),
+        modelID: ModelID.make("claude-sonnet"),
+      })
+      const second = yield* usage.contextLimit({
+        directory: "/workspace",
+        providerID: ProviderID.make("anthropic"),
+        modelID: ModelID.make("claude-sonnet"),
+      })
+
+      expect(first).toBe(200_000)
+      expect(second).toBe(200_000)
+      expect(calls).toEqual(["/workspace"])
+    }).pipe(
+      Effect.provide(
+        fakeLayer({
+          providers: (directory) =>
+            Effect.sync(() => {
+              calls.push(directory)
+              return providers(200_000)
+            }),
+        }),
+      ),
+    )
+  })
+
+  it.effect("sends ACP usage_update with context size and cumulative assistant cost", () => {
+    const updates: SessionNotification[] = []
+    return Effect.gen(function* () {
+      const usage = yield* UsageService.Service
+      yield* usage.sendUpdate({
+        connection: connection(updates),
+        sessionID: "ses_1",
+        directory: "/workspace",
+      })
+
+      expect(updates).toEqual([
+        {
+          sessionId: "ses_1",
+          update: {
+            sessionUpdate: "usage_update",
+            used: 15,
+            size: 128_000,
+            cost: { amount: 3, currency: "USD" },
+          },
+        },
+      ])
+    }).pipe(
+      Effect.provide(
+        fakeLayer({
+          messages: Effect.succeed([
+            assistant({ cost: 1 }),
+            assistant({
+              cost: 2,
+              tokens: {
+                input: 10,
+                output: 20,
+                reasoning: 0,
+                cache: { read: 5, write: 0 },
+              },
+            }),
+          ]),
+        }),
+      ),
+    )
+  })
+
+  it.effect("skips usage update when messages cannot be fetched", () => {
+    const updates: SessionNotification[] = []
+    return Effect.gen(function* () {
+      const usage = yield* UsageService.Service
+      yield* usage.sendUpdate({
+        connection: connection(updates),
+        sessionID: "ses_1",
+        directory: "/workspace",
+      })
+
+      expect(updates).toEqual([])
+    }).pipe(Effect.provide(fakeLayer({ messages: Effect.fail(new Error("boom")) })))
+  })
+
+  it.effect("skips usage update when no assistant message exists", () => {
+    const updates: SessionNotification[] = []
+    return Effect.gen(function* () {
+      const usage = yield* UsageService.Service
+      yield* usage.sendUpdate({
+        connection: connection(updates),
+        sessionID: "ses_1",
+        directory: "/workspace",
+      })
+
+      expect(updates).toEqual([])
+    }).pipe(Effect.provide(fakeLayer({ messages: Effect.succeed([user()]) })))
+  })
+
+  it.effect("skips usage update when assistant message has no provider or model", () => {
+    const updates: SessionNotification[] = []
+    return Effect.gen(function* () {
+      const usage = yield* UsageService.Service
+      yield* usage.sendUpdate({
+        connection: connection(updates),
+        sessionID: "ses_1",
+        directory: "/workspace",
+      })
+
+      expect(updates).toEqual([])
+    }).pipe(
+      Effect.provide(
+        fakeLayer({
+          messages: Effect.succeed([assistantWithoutProvider()]),
+        }),
+      ),
+    )
+  })
+
+  it.effect("skips usage update when context size is unknown", () => {
+    const updates: SessionNotification[] = []
+    return Effect.gen(function* () {
+      const usage = yield* UsageService.Service
+      yield* usage.sendUpdate({
+        connection: connection(updates),
+        sessionID: "ses_1",
+        directory: "/workspace",
+      })
+
+      expect(updates).toEqual([])
+    }).pipe(
+      Effect.provide(
+        fakeLayer({
+          messages: Effect.succeed([assistant({ cost: 1, providerID: "missing" })]),
+        }),
+      ),
+    )
+  })
+})

From 651599055f0405d4006593eb4bde7dbbcd01f6b6 Mon Sep 17 00:00:00 2001
From: "opencode-agent[bot]" <opencode-agent[bot]@users.noreply.github.com>
Date: Mon, 25 May 2026 16:49:25 +0000
Subject: [PATCH 22/31] chore: generate

---
 packages/opencode/src/acp-next/usage.ts | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/packages/opencode/src/acp-next/usage.ts b/packages/opencode/src/acp-next/usage.ts
index bcf86709f9c2..a37f370c6880 100644
--- a/packages/opencode/src/acp-next/usage.ts
+++ b/packages/opencode/src/acp-next/usage.ts
@@ -85,9 +85,9 @@ export function messageLoaderFromSDK(sdk: SDK): MessageLoaderInterface {
   return MessageLoader.of({
     messages: (input) =>
       Effect.promise(() =>
-        sdk.session.messages({ sessionID: input.sessionID, directory: input.directory }, { throwOnError: true }).then(
-          (response) => response.data ?? [],
-        ),
+        sdk.session
+          .messages({ sessionID: input.sessionID, directory: input.directory }, { throwOnError: true })
+          .then((response) => response.data ?? []),
       ),
   })
 }
@@ -102,8 +102,7 @@ export function buildUsage(message: AssistantTokenCost): Usage {
   return {
     inputTokens: message.tokens.input,
     outputTokens: message.tokens.output,
-    totalTokens:
-      message.tokens.input + message.tokens.output + thoughtTokens + cachedReadTokens + cachedWriteTokens,
+    totalTokens: message.tokens.input + message.tokens.output + thoughtTokens + cachedReadTokens + cachedWriteTokens,
     ...(thoughtTokens > 0 ? { thoughtTokens } : {}),
     ...(cachedReadTokens > 0 ? { cachedReadTokens } : {}),
     ...(cachedWriteTokens > 0 ? { cachedWriteTokens } : {}),
@@ -186,7 +185,7 @@ export const layer = Layer.effect(
       readonly providerID: ProviderID
       readonly modelID: ModelID
     }) {
-      return yield* (yield* cachedLimit(input))
+      return yield* yield* cachedLimit(input)
     })
 
     const sendUpdate = Effect.fn("ACPNextUsage.sendUpdate")(function* (input: {

From 45456faa3d6ed9d940d9a9c7752b2263e1d78aea Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 01:25:49 +0700
Subject: [PATCH 23/31] fix(config): skip  auto-injection on parse failure

---
 packages/opencode/src/config/config.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 272e4db83e19..15994d676718 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -420,9 +420,12 @@ export const layer = Layer.effect(
             : { text, type: "virtual", ...options, env },
         ),
       )
+      let parsedOk = false
       const data = yield* Effect.sync(() => {
         const parsed = ConfigParse.jsonc(expanded, source)
-        return ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
+        const result = ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
+        parsedOk = true
+        return result
       }).pipe(
         Effect.catchCause((cause) =>
           Effect.sync(() => {
@@ -440,7 +443,7 @@ export const layer = Layer.effect(
           }),
         ),
       )
-      if (!data.$schema) {
+      if (parsedOk && !data.$schema) {
         data.$schema = "https://opencode.ai/config.json"
         const updated = text.replace(/^\s*\{/, '{\n  "$schema": "https://opencode.ai/config.json",')
         yield* fs.writeFileString(options.path, updated).pipe(Effect.catch(() => Effect.void))

From 3922a82d251dc390dde35b65df9106cecdb86112 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 01:44:26 +0700
Subject: [PATCH 24/31] fix(config): sanitize log.error to avoid leaking config
 content

---
 packages/opencode/src/config/config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 15994d676718..b7834009f08b 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -429,7 +429,7 @@ export const layer = Layer.effect(
       }).pipe(
         Effect.catchCause((cause) =>
           Effect.sync(() => {
-            log.error("invalid config", { path: source, cause })
+            log.error("invalid config: config file could not be parsed", { path: source })
             return Schema.decodeSync(Info)({})
           }),
         ),

From 6378082ed6f1abe169cbf839b5005531f4d22720 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 01:46:09 +0700
Subject: [PATCH 25/31] fix(config): use Cause.pretty for safe config error
 logging

---
 packages/opencode/src/config/config.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index b7834009f08b..936cf6352190 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -1,3 +1,4 @@
+import * as Cause from "effect/Cause"
 import * as Log from "@opencode-ai/core/util/log"
 import { serviceUse } from "@opencode-ai/core/effect/service-use"
 import path from "path"
@@ -429,7 +430,7 @@ export const layer = Layer.effect(
       }).pipe(
         Effect.catchCause((cause) =>
           Effect.sync(() => {
-            log.error("invalid config: config file could not be parsed", { path: source })
+            log.error("invalid config: config file could not be parsed", { path: source, cause: Cause.pretty(cause) })
             return Schema.decodeSync(Info)({})
           }),
         ),

From 702fd0e1b17607fc15eb7e1bd998d0ab143b7ab1 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 01:50:43 +0700
Subject: [PATCH 26/31] fix(config): address review comments on PR #29208

- Use safe fallback for Info decode ({} as Info) instead of Schema.decodeSync
- Use Cause.pretty for plugin resolution error logging
- Strengthen test assertion with specific value
---
 packages/opencode/src/config/config.ts       | 4 ++--
 packages/opencode/test/config/config.test.ts | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 936cf6352190..551454f03e67 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -431,7 +431,7 @@ export const layer = Layer.effect(
         Effect.catchCause((cause) =>
           Effect.sync(() => {
             log.error("invalid config: config file could not be parsed", { path: source, cause: Cause.pretty(cause) })
-            return Schema.decodeSync(Info)({})
+            return {} as Info
           }),
         ),
       )
@@ -440,7 +440,7 @@ export const layer = Layer.effect(
       yield* Effect.promise(() => resolveLoadedPlugins(data, options.path)).pipe(
         Effect.catchCause((cause) =>
           Effect.sync(() => {
-            log.error("plugin resolution failed", { path: source, cause })
+            log.error("plugin resolution failed", { path: source, cause: Cause.pretty(cause) })
           }),
         ),
       )
diff --git a/packages/opencode/test/config/config.test.ts b/packages/opencode/test/config/config.test.ts
index fdc7dc62d948..9a0f702124d9 100644
--- a/packages/opencode/test/config/config.test.ts
+++ b/packages/opencode/test/config/config.test.ts
@@ -585,10 +585,11 @@ it.instance("handles invalid schema gracefully without crashing", () =>
     const test = yield* TestInstance
     yield* writeConfigEffect(test.directory, {
       $schema: "https://opencode.ai/config.json",
+      model: "test/model",
       invalid_field: "should cause error",
     })
     const config = yield* Config.use.get()
-    expect(config.username).toBeDefined()
+    expect(config.model).toBe("test/model")
     expect("invalid_field" in config).toBe(false)
   }),
 )

From b11570aafa509704f8577104c119f2fe1d899a10 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 01:58:56 +0700
Subject: [PATCH 27/31] fix(config): address copilot review comments

- Strip unknown config keys before schema validation to preserve valid fields
- Sanitize log.error calls to avoid leaking config content via cause
- Handle plugin resolution per-item to avoid partial mutation on failure
- Add test for plugin resolution failure
---
 packages/opencode/src/config/config.ts       | 35 +++++++++++++++-----
 packages/opencode/test/config/config.test.ts | 13 ++++++++
 2 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 551454f03e67..d70b6c16b32a 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -1,4 +1,3 @@
-import * as Cause from "effect/Cause"
 import * as Log from "@opencode-ai/core/util/log"
 import { serviceUse } from "@opencode-ai/core/effect/service-use"
 import path from "path"
@@ -73,6 +72,23 @@ function normalizeLoadedConfig(data: unknown, source: string) {
   return copy
 }
 
+const infoKeys = new Set([
+  "$schema", "shell", "logLevel", "server", "command", "skills",
+  "reference", "watcher", "snapshot", "plugin", "share", "autoshare",
+  "autoupdate", "disabled_providers", "enabled_providers", "model",
+  "small_model", "default_agent", "username", "mode", "agent",
+  "instructions", "account_token", "url", "headers",
+])
+
+function stripUnknownKeys(data: unknown): unknown {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return data
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(data)) {
+    if (infoKeys.has(key)) result[key] = value
+  }
+  return result
+}
+
 async function substituteWellKnownRemoteConfig(input: {
   value: unknown
   dir: string
@@ -118,9 +134,11 @@ const WellKnownConfig = Schema.Struct({
 async function resolveLoadedPlugins<T extends { plugin?: ConfigPlugin.Spec[] }>(config: T, filepath: string) {
   if (!config.plugin) return config
   for (let i = 0; i < config.plugin.length; i++) {
-    // Normalize path-like plugin specs while we still know which config file declared them.
-    // This prevents `./plugin.ts` from being reinterpreted relative to some later merge location.
-    config.plugin[i] = await ConfigPlugin.resolvePluginSpec(config.plugin[i], filepath)
+    try {
+      config.plugin[i] = await ConfigPlugin.resolvePluginSpec(config.plugin[i], filepath)
+    } catch {
+      log.error("plugin resolution failed", { spec: config.plugin[i], path: filepath })
+    }
   }
   return config
 }
@@ -424,13 +442,14 @@ export const layer = Layer.effect(
       let parsedOk = false
       const data = yield* Effect.sync(() => {
         const parsed = ConfigParse.jsonc(expanded, source)
-        const result = ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
+        const cleaned = stripUnknownKeys(normalizeLoadedConfig(parsed, source))
+        const result = ConfigParse.schema(Info, cleaned, source)
         parsedOk = true
         return result
       }).pipe(
         Effect.catchCause((cause) =>
           Effect.sync(() => {
-            log.error("invalid config: config file could not be parsed", { path: source, cause: Cause.pretty(cause) })
+            log.error("invalid config: config file could not be parsed", { path: source })
             return {} as Info
           }),
         ),
@@ -438,9 +457,9 @@ export const layer = Layer.effect(
       if (!("path" in options)) return data
 
       yield* Effect.promise(() => resolveLoadedPlugins(data, options.path)).pipe(
-        Effect.catchCause((cause) =>
+        Effect.catchCause(() =>
           Effect.sync(() => {
-            log.error("plugin resolution failed", { path: source, cause: Cause.pretty(cause) })
+            log.error("plugin resolution failed", { path: source })
           }),
         ),
       )
diff --git a/packages/opencode/test/config/config.test.ts b/packages/opencode/test/config/config.test.ts
index 9a0f702124d9..710a4e8fa178 100644
--- a/packages/opencode/test/config/config.test.ts
+++ b/packages/opencode/test/config/config.test.ts
@@ -639,6 +639,19 @@ it.instance("skips bad config file but merges others", () =>
   }),
 )
 
+it.instance("handles plugin resolution failure gracefully", () =>
+  Effect.gen(function* () {
+    const test = yield* TestInstance
+    yield* writeConfigEffect(test.directory, {
+      $schema: "https://opencode.ai/config.json",
+      model: "has-plugin",
+      plugin: ["./non-existent-plugin.ts"],
+    })
+    const config = yield* Config.use.get()
+    expect(config.model).toBe("has-plugin")
+  }),
+)
+
 it.instance("handles agent configuration", () =>
   Effect.gen(function* () {
     const test = yield* TestInstance

From a72cb353abd45af3bd409885ff804727de047b1a Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 02:00:59 +0700
Subject: [PATCH 28/31] fix(config): warn for each unknown key stripped from
 config

---
 packages/opencode/src/config/config.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index d70b6c16b32a..45e4b37a4814 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -85,6 +85,7 @@ function stripUnknownKeys(data: unknown): unknown {
   const result: Record<string, unknown> = {}
   for (const [key, value] of Object.entries(data)) {
     if (infoKeys.has(key)) result[key] = value
+    else log.warn("config key is not recognized and will be ignored", { key })
   }
   return result
 }

From b8eedcf1b389e08cd9d458f8bf0413377ac8a822 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 02:08:48 +0700
Subject: [PATCH 29/31] fix(config): add infoKeys sync comment, drop unused
 cause param

---
 packages/opencode/src/config/config.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 45e4b37a4814..47a7d1597cca 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -72,6 +72,7 @@ function normalizeLoadedConfig(data: unknown, source: string) {
   return copy
 }
 
+// Must stay in sync with Info schema keys below
 const infoKeys = new Set([
   "$schema", "shell", "logLevel", "server", "command", "skills",
   "reference", "watcher", "snapshot", "plugin", "share", "autoshare",
@@ -448,7 +449,7 @@ export const layer = Layer.effect(
         parsedOk = true
         return result
       }).pipe(
-        Effect.catchCause((cause) =>
+        Effect.catchCause(() =>
           Effect.sync(() => {
             log.error("invalid config: config file could not be parsed", { path: source })
             return {} as Info

From 998034f4bde8e095f545772f27a09039ae6bd4ab Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 02:15:58 +0700
Subject: [PATCH 30/31] fix(config): complete infoKeys allowlist, add safe
 error detail to logs

---
 packages/opencode/src/config/config.ts | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 47a7d1597cca..548a3306d6e8 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -1,3 +1,4 @@
+import * as Cause from "effect/Cause"
 import * as Log from "@opencode-ai/core/util/log"
 import { serviceUse } from "@opencode-ai/core/effect/service-use"
 import path from "path"
@@ -78,7 +79,9 @@ const infoKeys = new Set([
   "reference", "watcher", "snapshot", "plugin", "share", "autoshare",
   "autoupdate", "disabled_providers", "enabled_providers", "model",
   "small_model", "default_agent", "username", "mode", "agent",
-  "instructions", "account_token", "url", "headers",
+  "provider", "mcp", "formatter", "lsp", "instructions",
+  "layout", "permission", "tools", "attachment", "enterprise",
+  "tool_output", "compaction", "experimental",
 ])
 
 function stripUnknownKeys(data: unknown): unknown {
@@ -138,8 +141,8 @@ async function resolveLoadedPlugins<T extends { plugin?: ConfigPlugin.Spec[] }>(
   for (let i = 0; i < config.plugin.length; i++) {
     try {
       config.plugin[i] = await ConfigPlugin.resolvePluginSpec(config.plugin[i], filepath)
-    } catch {
-      log.error("plugin resolution failed", { spec: config.plugin[i], path: filepath })
+    } catch (e) {
+      log.error("plugin resolution failed", { spec: config.plugin[i], path: filepath, error: String(e) })
     }
   }
   return config
@@ -449,9 +452,13 @@ export const layer = Layer.effect(
         parsedOk = true
         return result
       }).pipe(
-        Effect.catchCause(() =>
+        Effect.catchCause((cause) =>
           Effect.sync(() => {
-            log.error("invalid config: config file could not be parsed", { path: source })
+            const errors = cause.reasons
+              .filter(Cause.isDieReason)
+              .map((r) => (r.defect instanceof Error ? r.defect.name : "UnknownError"))
+              .join(", ")
+            log.error("invalid config: config file could not be parsed", { path: source, error: errors })
             return {} as Info
           }),
         ),

From 828e25569814601429bfcc4a317dfe0a35c22638 Mon Sep 17 00:00:00 2001
From: Tom Hale <tom@hale.ee>
Date: Tue, 26 May 2026 02:20:40 +0700
Subject: [PATCH 31/31] fix(config): derive config keys dynamically from Info
 schema AST

---
 packages/opencode/src/config/config.ts | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts
index 548a3306d6e8..7aa7d4a7fefe 100644
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -73,22 +73,12 @@ function normalizeLoadedConfig(data: unknown, source: string) {
   return copy
 }
 
-// Must stay in sync with Info schema keys below
-const infoKeys = new Set([
-  "$schema", "shell", "logLevel", "server", "command", "skills",
-  "reference", "watcher", "snapshot", "plugin", "share", "autoshare",
-  "autoupdate", "disabled_providers", "enabled_providers", "model",
-  "small_model", "default_agent", "username", "mode", "agent",
-  "provider", "mcp", "formatter", "lsp", "instructions",
-  "layout", "permission", "tools", "attachment", "enterprise",
-  "tool_output", "compaction", "experimental",
-])
-
 function stripUnknownKeys(data: unknown): unknown {
   if (typeof data !== "object" || data === null || Array.isArray(data)) return data
+  const known = new Set(Info.ast.propertySignatures.map((p) => String(p.name)))
   const result: Record<string, unknown> = {}
   for (const [key, value] of Object.entries(data)) {
-    if (infoKeys.has(key)) result[key] = value
+    if (known.has(key)) result[key] = value
     else log.warn("config key is not recognized and will be ignored", { key })
   }
   return result