fix(opencode): use ACP-reported reasoning effort options

Expose thought_level options from OpenCode ACP to the web UI via RPC/API
instead of hardcoded presets, and validate effort values before setConfigOption.

Fixes #852

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: swear01

cli/src/opencode/opencodeRemoteLauncher.test.ts

@@ -255,7 +255,25 @@ describe('opencodeRemoteLauncher inline model switch', () => {
         expect(harness.promptCount).toBe(2);
     });
 
+    it('rejects unsupported reasoning effort values before calling setConfigOption', async () => {
+        harness.thoughtLevelOption = {
+            id: 'effort',
+            currentValue: 'low',
+            options: [
+                { value: 'low', name: 'Low' },
+                { value: 'medium', name: 'Medium' }
+            ]
+        };
+        const { session, setModelReasoningEffort } = createSessionStub([
+            { message: 'first', mode: createModeWithEffort(undefined, 'high') }
+        ]);
 
+        await opencodeRemoteLauncher(session as never);
+
+        expect(harness.setConfigOptionArgs).toEqual([]);
+        expect(setModelReasoningEffort).toHaveBeenCalledWith('low');
+        expect(harness.promptCount).toBe(1);
+    });
 
     it('resets to the backend launch-time default model when the queued mode.model is null', async () => {
         // Seed the backend with a launch-time default model so the launcher
@@ -414,6 +432,48 @@ describe('opencodeRemoteLauncher inline model switch', () => {
         });
     });
 
+    it('registers a listOpencodeReasoningEffortOptions RPC handler that returns ACP options', async () => {
+        harness.thoughtLevelOption = {
+            id: 'effort',
+            currentValue: 'low',
+            options: [
+                { value: 'low', name: 'Low' },
+                { value: 'medium', name: 'Medium' }
+            ]
+        };
+        const { session, rpcHandlers } = createSessionStub([
+            { message: 'first', mode: createMode() }
+        ]);
+        await opencodeRemoteLauncher(session as never);
+
+        const handler = rpcHandlers.get('listOpencodeReasoningEffortOptions');
+        expect(handler).toBeDefined();
+        const result = await handler!(undefined) as Record<string, unknown>;
+        expect(result).toEqual({
+            success: true,
+            options: [
+                { value: 'low', name: 'Low' },
+                { value: 'medium', name: 'Medium' }
+            ],
+            currentValue: 'low'
+        });
+    });
+
+    it('listOpencodeReasoningEffortOptions handler returns unavailable when backend has no thought level option', async () => {
+        const { session, rpcHandlers } = createSessionStub([
+            { message: 'first', mode: createMode() }
+        ]);
+        await opencodeRemoteLauncher(session as never);
+
+        const handler = rpcHandlers.get('listOpencodeReasoningEffortOptions');
+        expect(handler).toBeDefined();
+        const result = await handler!(undefined) as Record<string, unknown>;
+        expect(result).toEqual({
+            success: false,
+            error: 'OpenCode reasoning effort options are not available'
+        });
+    });
+
     it('serializes setModel after the previous prompt resolves', async () => {
         const { session } = createSessionStub([
             { message: 'first', mode: createMode('ollama/a') },

cli/src/opencode/opencodeRemoteLauncher.ts

@@ -11,6 +11,7 @@ import { RPC_METHODS } from '@hapi/protocol/rpcMethods';
 import { createOpencodeBackend } from './utils/opencodeBackend';
 import { OpencodePermissionHandler } from './utils/permissionHandler';
 import { PLAN_MODE_INSTRUCTION, TITLE_INSTRUCTION } from './utils/systemPrompt';
+import { resolveThoughtLevelEffort } from './thoughtLevelEffort';
 
 type OpencodeRemoteLauncherOptions = {
     onReasoningEffortRollback?: (effort: string | null) => void;
@@ -123,6 +124,18 @@ class OpencodeRemoteLauncher extends RemoteLauncherBase {
             };
         });
 
+        session.client.rpcHandlerManager.registerHandler(RPC_METHODS.ListOpencodeReasoningEffortOptions, async () => {
+            const effortOption = backend.getThoughtLevelConfigOption?.(acpSessionId);
+            if (!effortOption) {
+                return { success: false, error: 'OpenCode reasoning effort options are not available' };
+            }
+            return {
+                success: true,
+                options: effortOption.options,
+                currentValue: effortOption.currentValue ?? null
+            };
+        });
+
         this.permissionHandler = new OpencodePermissionHandler(
             session.client,
             backend,
@@ -206,29 +219,43 @@ class OpencodeRemoteLauncher extends RemoteLauncherBase {
                 if (!backend.setConfigOption || !thoughtLevelOption || this.setEffortSupported === false) {
                     this.rollbackReasoningEffort(batch, this.currentBackendEffort);
                 } else {
-                    logger.debug(`[opencode-remote] Switching effort inline: ${this.currentBackendEffort ?? '(default)'} -> ${requestedEffort}`);
-                    try {
-                        await backend.setConfigOption(acpSessionId, thoughtLevelOption.id, requestedEffort);
-                        this.currentBackendEffort = requestedEffort;
-                        this.setEffortSupported = true;
-                    } catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        const methodNotFound = /method not found/i.test(message);
-                        if (methodNotFound && this.setEffortSupported === undefined) {
-                            this.setEffortSupported = false;
-                            logger.warn('[opencode-remote] OpenCode build does not support session/set_config_option; inline effort switching disabled for this session');
-                            session.sendSessionEvent({
-                                type: 'message',
-                                message: 'This OpenCode build does not support inline reasoning effort switching.'
-                            });
-                        } else {
-                            logger.warn('[opencode-remote] Inline effort switch failed', error);
-                            session.sendSessionEvent({
-                                type: 'message',
-                                message: `Failed to switch reasoning effort to ${requestedEffort}. Continuing with ${this.currentBackendEffort ?? '(default)'}.`
-                            });
+                    const resolvedEffort = resolveThoughtLevelEffort(
+                        requestedEffort,
+                        thoughtLevelOption,
+                        this.currentBackendEffort ?? this.defaultBackendEffort
+                    );
+                    if (!resolvedEffort || resolvedEffort === this.currentBackendEffort) {
+                        if (requestedEffort !== resolvedEffort) {
+                            logger.warn(
+                                `[opencode-remote] Unsupported reasoning effort "${requestedEffort}"; continuing with ${resolvedEffort ?? this.currentBackendEffort ?? '(default)'}`
+                            );
+                            this.rollbackReasoningEffort(batch, resolvedEffort ?? this.currentBackendEffort);
+                        }
+                    } else {
+                        logger.debug(`[opencode-remote] Switching effort inline: ${this.currentBackendEffort ?? '(default)'} -> ${resolvedEffort}`);
+                        try {
+                            await backend.setConfigOption(acpSessionId, thoughtLevelOption.id, resolvedEffort);
+                            this.currentBackendEffort = resolvedEffort;
+                            this.setEffortSupported = true;
+                        } catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            const methodNotFound = /method not found/i.test(message);
+                            if (methodNotFound && this.setEffortSupported === undefined) {
+                                this.setEffortSupported = false;
+                                logger.warn('[opencode-remote] OpenCode build does not support session/set_config_option; inline effort switching disabled for this session');
+                                session.sendSessionEvent({
+                                    type: 'message',
+                                    message: 'This OpenCode build does not support inline reasoning effort switching.'
+                                });
+                            } else {
+                                logger.warn('[opencode-remote] Inline effort switch failed', error);
+                                session.sendSessionEvent({
+                                    type: 'message',
+                                    message: `Failed to switch reasoning effort to ${resolvedEffort}. Continuing with ${this.currentBackendEffort ?? '(default)'}.`
+                                });
+                            }
+                            this.rollbackReasoningEffort(batch, this.currentBackendEffort);
                         }
-                        this.rollbackReasoningEffort(batch, this.currentBackendEffort);
                     }
                 }
             }

cli/src/opencode/thoughtLevelEffort.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { resolveThoughtLevelEffort } from './thoughtLevelEffort';
+
+const thoughtLevelOption = {
+    id: 'effort',
+    category: 'thought_level',
+    currentValue: 'low',
+    options: [
+        { value: 'low', name: 'Low' },
+        { value: 'medium', name: 'Medium' }
+    ]
+};
+
+describe('resolveThoughtLevelEffort', () => {
+    it('returns the requested value when it is supported', () => {
+        expect(resolveThoughtLevelEffort('medium', thoughtLevelOption, 'low')).toBe('medium');
+    });
+
+    it('falls back to the current backend effort when the request is unsupported', () => {
+        expect(resolveThoughtLevelEffort('high', thoughtLevelOption, 'low')).toBe('low');
+    });
+
+    it('falls back to the ACP current value when the backend effort is also unsupported', () => {
+        expect(resolveThoughtLevelEffort('high', thoughtLevelOption, 'max')).toBe('low');
+    });
+
+    it('falls back to the first supported option when nothing else matches', () => {
+        const option = {
+            ...thoughtLevelOption,
+            currentValue: 'high'
+        };
+        expect(resolveThoughtLevelEffort('max', option, null)).toBe('low');
+    });
+});

cli/src/opencode/thoughtLevelEffort.ts

@@ -0,0 +1,20 @@
+import type { AgentSessionConfigOptionDescriptor } from '@/agent/types';
+
+export function resolveThoughtLevelEffort(
+    requested: string,
+    thoughtLevelOption: AgentSessionConfigOptionDescriptor,
+    fallback: string | null
+): string | null {
+    const supported = new Set(thoughtLevelOption.options.map((option) => option.value));
+    if (supported.has(requested)) {
+        return requested;
+    }
+    if (fallback && supported.has(fallback)) {
+        return fallback;
+    }
+    const current = thoughtLevelOption.currentValue;
+    if (current && supported.has(current)) {
+        return current;
+    }
+    return thoughtLevelOption.options[0]?.value ?? null;
+}

hub/src/sync/rpcGateway.ts

@@ -13,6 +13,7 @@ import type {
     ListDirectoryResponse,
     OpencodeModelsResponse,
     OpencodeModelSummary,
+    OpencodeReasoningEffortResponse,
     PathExistsResponse,
     SlashCommandsResponse,
     UploadFileResponse
@@ -37,6 +38,7 @@ export type RpcCursorModel = CursorModelSummary
 export type RpcListCursorModelsResponse = CursorModelsResponse
 export type RpcOpencodeModel = OpencodeModelSummary
 export type RpcListOpencodeModelsResponse = OpencodeModelsResponse
+export type RpcListOpencodeReasoningEffortOptionsResponse = OpencodeReasoningEffortResponse
 
 export class RpcGateway {
     constructor(
@@ -258,6 +260,10 @@ export class RpcGateway {
         return await this.machineRpc(machineId, RPC_METHODS.ListOpencodeModelsForCwd, { cwd }) as RpcListOpencodeModelsResponse
     }
 
+    async listOpencodeReasoningEffortOptionsForSession(sessionId: string): Promise<RpcListOpencodeReasoningEffortOptionsResponse> {
+        return await this.sessionRpc(sessionId, RPC_METHODS.ListOpencodeReasoningEffortOptions, {}) as RpcListOpencodeReasoningEffortOptionsResponse
+    }
+
     private async sessionRpc(
         sessionId: string,
         method: string,

hub/src/sync/syncEngine.ts

@@ -29,6 +29,7 @@ import {
     type RpcListCodexModelsResponse,
     type RpcListCursorModelsResponse,
     type RpcListOpencodeModelsResponse,
+    type RpcListOpencodeReasoningEffortOptionsResponse,
     type RpcCursorModel,
     type RpcOpencodeModel,
     type RpcPathExistsResponse,
@@ -49,6 +50,7 @@ export type {
     RpcListCodexModelsResponse,
     RpcListCursorModelsResponse,
     RpcListOpencodeModelsResponse,
+    RpcListOpencodeReasoningEffortOptionsResponse,
     RpcCursorModel,
     RpcOpencodeModel,
     RpcPathExistsResponse,
@@ -1088,4 +1090,8 @@ export class SyncEngine {
     async listOpencodeModelsForCwd(machineId: string, cwd: string): Promise<RpcListOpencodeModelsResponse> {
         return await this.rpcGateway.listOpencodeModelsForCwd(machineId, cwd)
     }
+
+    async listOpencodeReasoningEffortOptionsForSession(sessionId: string): Promise<RpcListOpencodeReasoningEffortOptionsResponse> {
+        return await this.rpcGateway.listOpencodeReasoningEffortOptionsForSession(sessionId)
+    }
 }

hub/src/web/routes/sessions.test.ts

@@ -80,6 +80,14 @@ function createApp(session: Session, opts?: {
         ],
         currentModelId: 'ollama/exaone:4.5-33b-q8'
     })
+    const listOpencodeReasoningEffortOptionsForSession = async () => ({
+        success: true,
+        options: [
+            { value: 'low', name: 'Low' },
+            { value: 'medium', name: 'Medium' }
+        ],
+        currentValue: 'low'
+    })
     const listCursorModelsForSession = async () => ({
         success: true,
         availableModels: [
@@ -103,6 +111,7 @@ function createApp(session: Session, opts?: {
         listCodexModelsForSession,
         listCursorModelsForSession,
         listOpencodeModelsForSession,
+        listOpencodeReasoningEffortOptionsForSession,
         resumeSession,
         reopenSession,
         getSessionExport: opts?.getSessionExport ?? (() => ({
@@ -543,6 +552,33 @@ describe('sessions routes', () => {
         })
     })
 
+    it('returns OpenCode reasoning effort options for active OpenCode sessions', async () => {
+        const session = createSession({
+            metadata: { path: '/tmp/project', host: 'localhost', flavor: 'opencode' }
+        })
+        const { app } = createApp(session)
+
+        const response = await app.request('/api/sessions/session-1/opencode-reasoning-effort-options')
+
+        expect(response.status).toBe(200)
+        expect(await response.json()).toEqual({
+            success: true,
+            options: [
+                { value: 'low', name: 'Low' },
+                { value: 'medium', name: 'Medium' }
+            ],
+            currentValue: 'low'
+        })
+    })
+
+    it('rejects opencode-reasoning-effort-options for non-OpenCode sessions', async () => {
+        const { app } = createApp(createSession())
+
+        const response = await app.request('/api/sessions/session-1/opencode-reasoning-effort-options')
+
+        expect(response.status).toBe(400)
+    })
+
     it('returns OpenCode models for active OpenCode sessions', async () => {
         const session = createSession({
             metadata: { path: '/tmp/project', host: 'localhost', flavor: 'opencode' }

hub/src/web/routes/sessions.ts

@@ -688,6 +688,36 @@ export function createSessionsRoutes(getSyncEngine: () => SyncEngine | null): Ho
         }
     })
 
+    app.get('/sessions/:id/opencode-reasoning-effort-options', async (c) => {
+        const engine = requireSyncEngine(c, getSyncEngine)
+        if (engine instanceof Response) {
+            return engine
+        }
+
+        const sessionResult = requireSessionFromParam(c, engine, { requireActive: true })
+        if (sessionResult instanceof Response) {
+            return sessionResult
+        }
+
+        const flavor = sessionResult.session.metadata?.flavor ?? 'claude'
+        if (flavor !== 'opencode') {
+            return c.json({
+                success: false,
+                error: 'OpenCode reasoning effort options are only available for OpenCode sessions'
+            }, 400)
+        }
+
+        try {
+            const result = await engine.listOpencodeReasoningEffortOptionsForSession(sessionResult.sessionId)
+            return c.json(result)
+        } catch (error) {
+            return c.json({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to list OpenCode reasoning effort options'
+            }, 500)
+        }
+    })
+
     app.get('/sessions/:id/cursor-models', async (c) => {
         const engine = requireSyncEngine(c, getSyncEngine)
         if (engine instanceof Response) {

shared/src/apiTypes.ts

@@ -320,6 +320,18 @@ export type OpencodeModelsResponse = {
 
 export type ListOpencodeModelsResponse = OpencodeModelsResponse
 
+export type OpencodeReasoningEffortOption = {
+    value: string
+    name?: string
+}
+
+export type OpencodeReasoningEffortResponse = {
+    success: boolean
+    options?: OpencodeReasoningEffortOption[]
+    currentValue?: string | null
+    error?: string
+}
+
 export type CursorModelSummary = OpencodeModelSummary
 
 export type CursorModelsResponse = OpencodeModelsResponse

shared/src/rpcMethods.ts

@@ -28,7 +28,8 @@ export const RPC_METHODS = {
     ListCodexModels: 'listCodexModels',
     ListCursorModels: 'listCursorModels',
     ListOpencodeModels: 'listOpencodeModels',
-    ListOpencodeModelsForCwd: 'listOpencodeModelsForCwd'
+    ListOpencodeModelsForCwd: 'listOpencodeModelsForCwd',
+    ListOpencodeReasoningEffortOptions: 'listOpencodeReasoningEffortOptions'
 } as const
 
 export type RpcMethod = typeof RPC_METHODS[keyof typeof RPC_METHODS]