fix(opencode): expose model-specific reasoning effort options (#1716)

* fix(cli): discover opencode thought_level via set_config_option on model switch

* fix(cli): apply and refresh opencode model switches so thought_level stays discoverable

* fix(web): track opencode effort options across model switches

* feat(cli,hub,web): dynamic opencode effort options in new-session form

* test(cli): avoid platform-specific process event narrowing

* fix(opencode): address variant discovery review findings

* fix(opencode): synchronize effort options with model targets

* fix(opencode): roll back rejected model targets

* fix(cli): guard opencode variant probe workspace paths

* fix(web): clear stale opencode effort on model switch

* fix(cli): clear stale opencode effort metadata

* fix(web): reset stale effort options on model switch

* fix(web): reset opencode effort poll budget

* test(web): enforce opencode effort poll budget
This commit is contained in:
Junmo Kim
2026-09-09 09:31:30 +08:00
committed by GitHub
parent 905d89e03a
commit 7031d60eb4
33 changed files with 1729 additions and 55 deletions
@@ -0,0 +1,21 @@
import { logger } from '@/ui/logger';
import { RPC_METHODS } from '@hapi/protocol/rpcMethods';
import type { RpcHandlerManager } from '@/api/rpc/RpcHandlerManager';
import {
listOpencodeModelVariants,
type ListOpencodeModelVariantsResponse
} from '../opencodeModelVariants';
import { getErrorMessage, rpcError } from '../rpcResponses';
export function registerOpencodeModelVariantsHandlers(rpcHandlerManager: RpcHandlerManager): void {
rpcHandlerManager.registerHandler<{ cwd?: string | null } | undefined, ListOpencodeModelVariantsResponse>(RPC_METHODS.ListOpencodeModelVariants, async (data) => {
logger.debug('List OpenCode model variants request');
try {
return await listOpencodeModelVariants({ cwd: data?.cwd ?? null });
} catch (error) {
logger.debug('Failed to list OpenCode model variants:', error);
return rpcError(getErrorMessage(error, 'Failed to list OpenCode model variants'));
}
});
}
@@ -0,0 +1,270 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { extractOpencodeAcpPorts, extractOpencodeAcpServers, parseOpencodeProviderVariants, listOpencodeModelVariants } from './opencodeModelVariants'
describe('parseOpencodeProviderVariants', () => {
it('collects variants for models that have at least one variant keyed by providerID/modelId', () => {
const payload = {
all: [
{
id: 'opencode-go',
models: {
'ox-alpha-free': {
id: 'ox-alpha-free',
providerID: 'opencode-go',
variants: { low: {}, high: {}, max: {} }
},
'bare-model': {
id: 'bare-model',
providerID: 'opencode-go'
}
}
},
{
id: 'other',
models: {
'muse-spark': {
id: 'muse-spark',
providerID: 'other',
variants: { minimal: null }
}
}
}
]
}
expect(parseOpencodeProviderVariants(payload)).toEqual({
'opencode-go/ox-alpha-free': ['low', 'high', 'max'],
'other/muse-spark': ['minimal']
})
})
it('skips models with empty or invalid variant maps and malformed entries', () => {
const payload = {
all: [
{
id: 'p1',
models: {
'no-variants': { id: 'no-variants', providerID: 'p1', variants: {} },
'bad-variants': { id: 'bad-variants', providerID: 'p1', variants: 'nope' },
'missing-id': { providerID: 'p1', variants: { low: {} } },
'missing-provider': { id: 'x', variants: { low: {} } },
ok: { id: 'ok', providerID: 'p1', variants: { high: {} } }
}
},
'not-an-object',
{ noModels: true }
]
}
expect(parseOpencodeProviderVariants(payload)).toEqual({
'p1/ok': ['high']
})
})
it('returns an empty map for non-object payloads', () => {
expect(parseOpencodeProviderVariants(null)).toEqual({})
expect(parseOpencodeProviderVariants('string')).toEqual({})
expect(parseOpencodeProviderVariants({})).toEqual({})
expect(parseOpencodeProviderVariants({ all: 'nope' })).toEqual({})
})
})
describe('extractOpencodeAcpPorts', () => {
it('extracts ports from live opencode acp process args', () => {
const ps = [
'/home/user/.local/bin/hapi-runner opencode --hapi-starting-mode remote --model opencode-go/ox-alpha-free',
'opencode acp --cwd /home/user --port 42495 --hostname 127.0.0.1',
'opencode acp --cwd /tmp --port 38971 --hostname 127.0.0.1',
'opencode serve --port 46123',
'bun run hub/src/index.ts'
].join('\n');
expect(extractOpencodeAcpPorts(ps)).toEqual([42495, 38971]);
});
it('dedupes and rejects malformed ports', () => {
const ps = [
'opencode acp --port 70000',
'opencode acp --port 42495',
'opencode acp --port 42495 --hostname 127.0.0.1',
'opencode acp --cwd /x'
].join('\n');
expect(extractOpencodeAcpPorts(ps)).toEqual([42495]);
});
});
describe('listOpencodeModelVariants resident lifecycle', () => {
const providerPayload = {
all: [{ id: 'p', models: { m: { id: 'm', providerID: 'p', variants: { low: {}, high: {} } } } }]
};
function makeProc(argv: string[]) {
return {
argv,
kill: vi.fn(),
exitCode: null,
stdout: new ReadableStream<Uint8Array>({ start(c) { c.close(); } })
};
}
let procs: ReturnType<typeof makeProc>[];
let mod: typeof import('./opencodeModelVariants');
beforeEach(async () => {
vi.useFakeTimers();
vi.resetModules();
procs = [];
vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify(providerPayload), { status: 200 })));
vi.stubGlobal('Bun', {
spawn: vi.fn((argv: string[], opts?: { cwd?: string }) => {
const proc = makeProc(argv);
(proc as unknown as { spawnCwd?: string }).spawnCwd = opts?.cwd;
if (argv[0] === 'ps') {
proc.stdout = new ReadableStream<Uint8Array>({
start(c) { c.enqueue(new TextEncoder().encode('')); c.close(); }
});
}
procs.push(proc);
return proc;
})
});
mod = await import('./opencodeModelVariants');
});
afterEach(() => {
vi.useRealTimers();
vi.unstubAllGlobals();
});
const serveProcs = () => procs.filter((p) => p.argv[0] === 'opencode');
it('spawns serve once, keeps it resident, and answers subsequent calls without respawn', async () => {
const first = mod.listOpencodeModelVariants();
await vi.advanceTimersByTimeAsync(300);
const r1 = await first;
expect(r1.success).toBe(true);
expect(serveProcs().length).toBe(1);
await mod.listOpencodeModelVariants();
await mod.listOpencodeModelVariants();
expect(serveProcs().length).toBe(1);
});
it('reaps the resident serve after the idle timeout and respawns on the next call', async () => {
const first = mod.listOpencodeModelVariants();
await vi.advanceTimersByTimeAsync(300);
await first;
const initialServe = serveProcs()[0];
await vi.advanceTimersByTimeAsync(10 * 60 * 1000);
expect(initialServe.kill).toHaveBeenCalled();
const second = mod.listOpencodeModelVariants();
await vi.advanceTimersByTimeAsync(300);
const r2 = await second;
expect(r2.success).toBe(true);
expect(serveProcs().length).toBe(2);
expect(serveProcs()[1].kill).not.toHaveBeenCalled();
});
it('does not reuse a project server when no cwd was requested', async () => {
// Seed the ps scan with a live acp server in /a, then request with cwd=null.
vi.stubGlobal('Bun', {
spawn: vi.fn((argv: string[]) => {
const proc = makeProc(argv);
if (argv[0] === 'ps') {
proc.stdout = new ReadableStream<Uint8Array>({
start(c) {
c.enqueue(new TextEncoder().encode('opencode acp --cwd /a --port 42495 --hostname 127.0.0.1'));
c.close();
}
});
}
procs.push(proc);
return proc;
})
});
mod = await import('./opencodeModelVariants');
const result = mod.listOpencodeModelVariants();
await vi.advanceTimersByTimeAsync(300);
const r = await result;
// The /a server must be skipped; the answer comes from a fresh spawn.
expect(r.success).toBe(true);
const liveFetchProc = procs.find((p) => p.argv[0] === 'ps');
void liveFetchProc;
expect(serveProcs().length).toBe(1);
});
it('kills the resident and respawns when the requested cwd changes', async () => {
const first = mod.listOpencodeModelVariants({ cwd: '/a' });
await vi.advanceTimersByTimeAsync(300);
await first;
const firstServe = serveProcs()[0];
const second = mod.listOpencodeModelVariants({ cwd: '/b' });
await vi.advanceTimersByTimeAsync(300);
const r2 = await second;
expect(r2.success).toBe(true);
expect(firstServe.kill).toHaveBeenCalled();
const newServe = serveProcs()[1];
expect(newServe).toBeDefined();
expect(newServe.kill).not.toHaveBeenCalled();
});
it('kills an unresponsive resident before replacing it', async () => {
const first = mod.listOpencodeModelVariants({ cwd: '/a' });
await vi.advanceTimersByTimeAsync(300);
await first;
const firstServe = serveProcs()[0];
const fetchMock = vi.mocked(fetch);
fetchMock.mockRejectedValueOnce(new Error('server unavailable'));
const second = mod.listOpencodeModelVariants({ cwd: '/a' });
await vi.advanceTimersByTimeAsync(300);
await second;
expect(firstServe.kill).toHaveBeenCalled();
expect(serveProcs().length).toBe(2);
});
it('does not coalesce concurrent calls for different cwds', async () => {
const first = mod.listOpencodeModelVariants({ cwd: '/a' });
const second = mod.listOpencodeModelVariants({ cwd: '/b' });
await vi.advanceTimersByTimeAsync(300);
const [r1, r2] = await Promise.all([first, second]);
expect(r1.success).toBe(true);
expect(r2.success).toBe(true);
// One serve per cwd — the two requests must not share a catalog.
expect(serveProcs().length).toBe(2);
// The loser of the resident slot must not leak: the replaced serve is
// killed once the second spawn takes over.
expect(serveProcs()[0].kill).toHaveBeenCalled();
});
it('registers an exit hook that kills the resident serve', async () => {
const exitSpy = vi.spyOn(process, 'on');
const first = mod.listOpencodeModelVariants();
await vi.advanceTimersByTimeAsync(300);
await first;
const calls = exitSpy.mock.calls as unknown as Array<[string, (...args: unknown[]) => void]>;
const hook = calls.find(([event]) => event === 'exit')?.[1];
expect(hook).toBeDefined();
const residentServe = serveProcs()[0];
hook?.();
expect(residentServe.kill).toHaveBeenCalled();
exitSpy.mockRestore();
});
});
describe('extractOpencodeAcpServers', () => {
it('extracts port and cwd pairs', () => {
const ps = [
'opencode acp --cwd /home/user --port 42495 --hostname 127.0.0.1',
'opencode acp --port 38971'
].join('\n');
expect(extractOpencodeAcpServers(ps)).toEqual([
{ port: 42495, cwd: '/home/user' },
{ port: 38971, cwd: null }
]);
});
});
@@ -0,0 +1,272 @@
import { isObject } from '@hapi/protocol';
import type { OpencodeModelVariantsResponse } from '@hapi/protocol/apiTypes';
export type ListOpencodeModelVariantsResponse = OpencodeModelVariantsResponse;
const PROBE_TIMEOUT_MS = 10_000;
const POLL_INTERVAL_MS = 300;
/**
* Extract a `{ 'providerId/modelId': string[] }` map of model variants from an
* OpenCode server `GET /provider` payload. Only models with at least one
* variant are collected; malformed entries are skipped defensively.
*/
export function parseOpencodeProviderVariants(payload: unknown): Record<string, string[]> {
if (!isObject(payload) || !Array.isArray(payload.all)) {
return {};
}
const out: Record<string, string[]> = {};
for (const provider of payload.all) {
if (!isObject(provider) || !isObject(provider.models)) {
continue;
}
for (const [, rawModel] of Object.entries(provider.models)) {
if (!isObject(rawModel)) continue;
const modelId = typeof rawModel.id === 'string' && rawModel.id.trim() ? rawModel.id : '';
const providerID = typeof rawModel.providerID === 'string' ? rawModel.providerID : '';
if (!providerID || !modelId) continue;
if (!isObject(rawModel.variants)) continue;
const variants = Object.keys(rawModel.variants).filter((key) => key.length > 0);
if (variants.length === 0) continue;
out[`${providerID}/${modelId}`] = variants;
}
}
return out;
}
/**
* Parse `ps` args output for live `opencode acp --port <n>` servers. Pure so
* the process-scan path is testable without a real process list.
*/
export function extractOpencodeAcpPorts(psArgsOutput: string): number[] {
return extractOpencodeAcpServers(psArgsOutput).map((server) => server.port);
}
/**
* Extract port + cwd from live `opencode acp --cwd <path> --port <n>` process
* args. The cwd lets callers skip servers whose project-level opencode config
* would produce a different provider catalog than the requesting directory.
*/
export function extractOpencodeAcpServers(psArgsOutput: string): Array<{ port: number; cwd: string | null }> {
const servers = new Map<number, string | null>();
for (const line of psArgsOutput.split('\n')) {
if (!/\bopencode acp\b/.test(line)) continue;
const portMatch = /--port (\d+)/.exec(line);
if (!portMatch) continue;
const port = Number(portMatch[1]);
if (!Number.isInteger(port) || port <= 0 || port > 65535) continue;
const cwdMatch = /--cwd (.+?)(?= --|$)/.exec(line);
servers.set(port, cwdMatch ? cwdMatch[1].trim() : null);
}
return [...servers.entries()].map(([port, cwd]) => ({ port, cwd }));
}
async function listRunningOpencodeServers(): Promise<Array<{ port: number; cwd: string | null }>> {
try {
const proc = Bun.spawn(['ps', '-eo', 'args='], { stdout: 'pipe', stderr: 'ignore' });
const output = await new Response(proc.stdout).text();
await proc.exited;
return extractOpencodeAcpServers(output);
} catch {
return [];
}
}
async function fetchVariantsFromServer(port: number): Promise<Record<string, string[]> | null> {
try {
const response = await fetch(`http://127.0.0.1:${port}/provider`, { signal: AbortSignal.timeout(1000) });
if (!response.ok) return null;
return parseOpencodeProviderVariants(await response.json());
} catch {
return null;
}
}
async function getEphemeralPort(): Promise<number> {
const net = await import('node:net');
return await new Promise((resolve, reject) => {
const server = net.createServer();
server.unref();
server.on('error', reject);
server.listen(0, '127.0.0.1', () => {
const address = server.address();
const port = typeof address === 'object' && address !== null ? address.port : null;
server.close(() => {
if (port !== null) {
resolve(port);
} else {
reject(new Error('Failed to acquire ephemeral port'));
}
});
});
});
}
/**
* Spawned-serve cache: the catalog only changes when the opencode binary or
* user config changes, so the natural cache unit is the server process
* lifetime, not an arbitrary TTL. A lazily spawned headless `opencode serve`
* stays resident and answers subsequent calls instantly; an idle reaper kills
* it after IDLE_REAP_MS without a request, and an `exit` hook kills it when
* the CLI exits gracefully. The reaper timer is unref'd so it never keeps the
* CLI process alive.
*/
type ResidentServe = { proc: ReturnType<typeof Bun.spawn>; port: number; cwd: string | null };
let resident: ResidentServe | null = null;
let idleReapTimer: ReturnType<typeof setTimeout> | null = null;
// In-flight coalescing is keyed by cwd: concurrent requests for different
// directories must not share a catalog (project-level opencode config differs).
const inFlightByCwd = new Map<string | null, Promise<ListOpencodeModelVariantsResponse>>();
const IDLE_REAP_MS = 10 * 60 * 1000;
let exitCleanupRegistered = false;
/**
* Kill the resident serve when the CLI exits gracefully (same pattern as
* autoStartServer's hub cleanup). Signal ownership stays with the runner so
* its asynchronous shutdown can finish before the process exits.
*/
function registerExitCleanup(): void {
if (exitCleanupRegistered) return;
exitCleanupRegistered = true;
const killResident = () => {
resident?.proc.kill();
resident = null;
};
process.on('exit', killResident);
}
function scheduleIdleReap(): void {
if (idleReapTimer) {
clearTimeout(idleReapTimer);
}
const target = resident;
idleReapTimer = setTimeout(() => {
// Only reap the serve this timer was scheduled for — a newer call may
// have replaced the resident between scheduling and firing.
if (resident === target && resident) {
resident.proc.kill();
resident = null;
}
idleReapTimer = null;
}, IDLE_REAP_MS);
idleReapTimer.unref?.();
}
export function listOpencodeModelVariants(request?: { cwd?: string | null }): Promise<ListOpencodeModelVariantsResponse> {
const cwd = request?.cwd ?? null;
const existing = inFlightByCwd.get(cwd);
if (existing) {
return existing;
}
const promise = listOpencodeModelVariantsUncached(cwd).finally(() => {
inFlightByCwd.delete(cwd);
});
inFlightByCwd.set(cwd, promise);
return promise;
}
async function listOpencodeModelVariantsUncached(cwd: string | null): Promise<ListOpencodeModelVariantsResponse> {
// Prefer a live OpenCode session's server — its /provider catalog is
// identical and answering from it skips any spawn entirely. Only servers
// running in the same cwd are used: project-level opencode config can
// override the provider catalog per directory.
for (const server of await listRunningOpencodeServers()) {
if (server.cwd !== cwd) continue;
const variants = await fetchVariantsFromServer(server.port);
if (variants) {
return { success: true, variants };
}
}
// Resident serve from a previous call — still the same opencode install
// and config, so the cached catalog is current by construction. A cwd
// mismatch means a different project config: kill and respawn targeted.
if (resident) {
if (resident.cwd !== cwd) {
resident.proc.kill();
resident = null;
} else {
const variants = await fetchVariantsFromServer(resident.port);
if (variants) {
scheduleIdleReap();
return { success: true, variants };
}
// Server died (e.g. reaped externally) — fall through and respawn.
resident.proc.kill();
resident = null;
}
}
const spawned = await spawnServeWithCatalog(cwd);
if (!spawned.success) {
return spawned;
}
// A concurrent different-cwd call may have installed its own resident in
// parallel — it is no longer referenced by anyone once we overwrite it.
// (Read through an explicit type: TS narrows the module singleton to null
// on this path, but a concurrent call may have assigned it.)
const previousResident = resident as ResidentServe | null;
if (previousResident) {
previousResident.proc.kill();
}
resident = { proc: spawned.proc, port: spawned.port, cwd };
registerExitCleanup();
scheduleIdleReap();
return { success: true, variants: spawned.variants };
}
async function spawnServeWithCatalog(cwd: string | null): Promise<
{ success: false; error: string } | { success: true; proc: ReturnType<typeof Bun.spawn>; port: number; variants: Record<string, string[]> }
> {
let port: number;
try {
port = await getEphemeralPort();
} catch {
return { success: false, error: 'Failed to acquire ephemeral port' };
}
let proc: ReturnType<typeof Bun.spawn> | null = null;
try {
proc = Bun.spawn(['opencode', 'serve', '--port', String(port)], {
stdout: 'ignore',
stderr: 'ignore',
...(cwd ? { cwd } : {}),
});
const deadline = Date.now() + PROBE_TIMEOUT_MS;
let payload: unknown = null;
while (Date.now() < deadline) {
await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
// Bail out early instead of burning the full deadline when serve
// died on bind (e.g. the ephemeral port was claimed in the gap).
if (proc.exitCode !== null) {
break;
}
try {
const response = await fetch(`http://127.0.0.1:${port}/provider`, { signal: AbortSignal.timeout(2000) });
if (response.ok) {
payload = await response.json();
break;
}
} catch {
// Server not ready yet — keep polling until the deadline.
}
}
if (!payload || proc.exitCode !== null) {
proc.kill();
return { success: false, error: 'OpenCode provider catalog did not become available in time' };
}
return { success: true, proc, port, variants: parseOpencodeProviderVariants(payload) };
} catch (error) {
proc?.kill();
return {
success: false,
error: error instanceof Error ? error.message : 'Failed to list OpenCode model variants'
};
}
}
@@ -4,6 +4,7 @@ import { registerBashHandlers } from './handlers/bash'
import { registerCodexModelHandlers } from './handlers/codexModels'
import { registerCursorModelHandlers } from './handlers/cursorModels'
import { registerOpencodeModelHandlers } from './handlers/opencodeModels'
import { registerOpencodeModelVariantsHandlers } from './handlers/opencodeModelVariants'
import { registerPiModelHandlers } from './handlers/piModels'
import { registerGrokModelHandlers } from './handlers/grokModels'
import { registerCopilotModelHandlers } from './handlers/copilotModels'
@@ -22,6 +23,7 @@ export function registerCommonHandlers(rpcHandlerManager: RpcHandlerManager, wor
registerCodexModelHandlers(rpcHandlerManager)
registerCursorModelHandlers(rpcHandlerManager)
registerOpencodeModelHandlers(rpcHandlerManager)
registerOpencodeModelVariantsHandlers(rpcHandlerManager)
registerPiModelHandlers(rpcHandlerManager)
registerGrokModelHandlers(rpcHandlerManager)
registerCopilotModelHandlers(rpcHandlerManager)