Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

fix(coding-agent): expose ACP model and effort pickers (#2455)

Kennethb09e37d840aa
diff --git a/packages/coding-agent/.changes/acp-model-effort-pickers.md b/packages/coding-agent/.changes/acp-model-effort-pickers.md
new file mode 100644
index 0000000000..dc1271d139
--- /dev/null
+++ b/packages/coding-agent/.changes/acp-model-effort-pickers.md
@@ -0,0 +1 @@
+- Added model and reasoning effort pickers for ACP clients such as Zed, with model-specific effort options.
diff --git a/packages/coding-agent/docs/acp.md b/packages/coding-agent/docs/acp.md
index 4f1db9679b..e95bf2f932 100644
--- a/packages/coding-agent/docs/acp.md
+++ b/packages/coding-agent/docs/acp.md
@@ -20,6 +20,7 @@ Use ACP mode when something external needs to *drive* a session interactively: p
|---|---|
| `initialize` | Returns protocol version, capabilities, and agent info. |
| `session/new` | Creates the session. One session per connection. |
+| `session/set_config_option` | Changes the model or reasoning effort and returns all current options. |
| `session/prompt` | Runs one turn and resolves with a stop reason. |
| `session/cancel` | Notification; aborts the addressed session's turn. |
| `session/close` | Releases the session and frees the connection for a new one. |
@@ -28,6 +29,14 @@ One session per connection is a deliberate limit: Prime Agent's underlying sessi
Likewise `session/prompt` refuses a concurrent turn while one is running, and the working directory cannot be changed after startup — a client-supplied `cwd` that differs from the agent's real one is reported back in `_meta` rather than silently ignored.
+## Model and reasoning effort pickers
+
+`session/new` returns standard ACP `configOptions`, allowing clients such as Zed to display a model picker and a reasoning effort picker. Models come from providers configured in Prime Agent. Model values are opaque IDs encoding the provider and model ID as a JSON pair; clients should send the advertised value unchanged. The current model is included and can be reselected even if model discovery is unavailable.
+
+The effort picker uses the `thought_level` category and contains only levels supported by the selected model. It is omitted for models without reasoning support. Changing models returns updated effort options and the effective level after Prime Agent applies its model-specific limits. Changes use the same session and saved preferences as Prime Agent's own model and effort controls.
+
+Clients change selections with `session/set_config_option`, using `configId: "model"` or `configId: "thought_level"`. Unsupported values are rejected. `config_option_update` notifications keep the client synchronized with observed session configuration changes.
+
## MCP servers
Prime Agent accepts standard stdio and HTTP servers in `session/new.mcpServers`. The servers are
diff --git a/packages/coding-agent/src/modes/acp/acp-mode.ts b/packages/coding-agent/src/modes/acp/acp-mode.ts
index db1087f76c..5b6d4dc6db 100644
--- a/packages/coding-agent/src/modes/acp/acp-mode.ts
+++ b/packages/coding-agent/src/modes/acp/acp-mode.ts
@@ -12,9 +12,11 @@ import { takeOverStdout, writeRawStdout } from "../../core/output-guard.js";
import { InProcessAgentConnection } from "../agent-connection/in-process-agent-connection.js";
import type {
AgentConnection,
+ AgentConnectionModel,
AgentConnectionRlmChildAgentSnapshot,
AgentConnectionSessionEvent,
AgentConnectionSessionInputPause,
+ AgentConnectionState,
} from "../agent-connection/types.js";
import { latestAutonomousGateAttempt } from "../headless-completion.js";
import { type AcpEventMappingState, acpUpdatesForSessionEvent } from "./acp-events.js";
@@ -119,6 +121,8 @@ interface AcpInputPauseRelease {
interface AcpSessionEntry {
id: string;
+ configOptions: acp.SessionConfigOption[];
+ models: AgentConnectionModel[];
abort: AbortController | undefined;
cancelling: boolean;
cancelTask: Promise<void> | undefined;
@@ -133,6 +137,43 @@ interface AcpSessionEntry {
producer: AcpUpdateProducer;
}
+function modelValue(model: AgentConnectionModel): string {
+ return JSON.stringify([model.provider, model.id]);
+}
+
+function sessionConfigOptions(
+ state: AgentConnectionState,
+ models: readonly AgentConnectionModel[],
+): acp.SessionConfigOption[] {
+ if (!state.model) return [];
+ const available = new Map(models.map((model) => [modelValue(model), model]));
+ available.set(modelValue(state.model), state.model);
+ const configOptions: acp.SessionConfigOption[] = [
+ {
+ id: "model",
+ name: "Model",
+ category: "model",
+ type: "select",
+ currentValue: modelValue(state.model),
+ options: [...available.values()].map((model) => ({
+ value: modelValue(model),
+ name: `${model.name} (${model.provider})`,
+ })),
+ },
+ ];
+ if (state.model.reasoning && state.availableThinkingLevels.length > 0) {
+ configOptions.push({
+ id: "thought_level",
+ name: "Reasoning effort",
+ category: "thought_level",
+ type: "select",
+ currentValue: state.thinkingLevel,
+ options: state.availableThinkingLevels.map((level) => ({ value: level, name: level })),
+ });
+ }
+ return configOptions;
+}
+
/**
* The sole producer of ACP session updates for one ACP session.
*
@@ -514,6 +555,20 @@ export async function runAcpModeWithConnection(
let sessionCloseInFlight = false;
let sessionCloseTask: Promise<void> | undefined;
let bound = false;
+ let configTask: Promise<unknown> = Promise.resolve();
+ const enqueueConfig = <T>(operation: () => Promise<T>): Promise<T> => {
+ const task = configTask.then(operation);
+ configTask = task.catch(() => undefined);
+ return task;
+ };
+ const refreshConfig = async (entry: AcpSessionEntry): Promise<acp.SessionConfigOption[]> => {
+ const configOptions = sessionConfigOptions(await connection.getState(), entry.models);
+ if (session === entry && JSON.stringify(configOptions) !== JSON.stringify(entry.configOptions)) {
+ entry.configOptions = configOptions;
+ await entry.producer.publish({ sessionUpdate: "config_option_update", configOptions }, 0, "event");
+ }
+ return configOptions;
+ };
const baseStream =
options.stream ?? acp.ndJsonStream(rawStdoutSink(), Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>);
@@ -756,6 +811,8 @@ export async function runAcpModeWithConnection(
}
const entry: AcpSessionEntry = {
id: sessionId,
+ configOptions: [],
+ models: [],
abort: undefined,
cancelling: false,
cancelTask: undefined,
@@ -777,6 +834,16 @@ export async function runAcpModeWithConnection(
const mappingState: AcpEventMappingState = {};
const observedChildren = new Map<string, unknown>();
const unsubscribe = connection.subscribe((event) => {
+ if (
+ event.type === "session_replaced" ||
+ event.type === "session_resynced" ||
+ (event.type === "session_event" &&
+ ["thinking_level_changed", "auto_retry_start", "auto_retry_end", "agent_end"].includes(
+ event.event.type,
+ ))
+ ) {
+ void enqueueConfig(() => refreshConfig(entry)).catch(() => undefined);
+ }
// Heartbeats are connection-scoped, including if one races a prompt.
// They therefore intentionally use origin turn 0.
if (event.type === "heartbeats_changed") {
@@ -800,6 +867,16 @@ export async function runAcpModeWithConnection(
// Reconcile after subscribing so updates cannot be lost while the snapshot
// request is in flight. Do not turn a failed read into an empty roster.
const initialSnapshot = await connection.getInitialSnapshot();
+ // Optional picker discovery must not prevent session attachment.
+ try {
+ entry.models = await connection.getAvailableModels();
+ } catch {
+ entry.models = [];
+ }
+ entry.configOptions = sessionConfigOptions(
+ await connection.getState().catch(() => initialSnapshot.state),
+ entry.models,
+ );
for (const child of initialSnapshot.children ?? []) {
if (observedChildren.has(child.id)) continue;
observedChildren.set(child.id, child);
@@ -821,6 +898,7 @@ export async function runAcpModeWithConnection(
session = entry;
const response = {
sessionId,
+ configOptions: entry.configOptions,
...(cwdMismatch ? { _meta: primeAgentMeta({ cwd: cwdMismatch }) } : {}),
};
// The stream wrapper commits this gate after this exact response has
@@ -836,6 +914,42 @@ export async function runAcpModeWithConnection(
sessionNewInFlight = false;
}
})
+ .onRequest("session/set_config_option", async (ctx) => {
+ const { sessionId, configId, value } = ctx.params;
+ const entry = session?.id === sessionId ? session : undefined;
+ if (!entry) throw acp.RequestError.invalidParams({ reason: `Unknown ACP session: ${sessionId}` });
+ return enqueueConfig(async () => {
+ if (session !== entry || sessionCloseInFlight) {
+ throw acp.RequestError.invalidParams({ reason: "ACP session is closed or closing" });
+ }
+ if (configId === "model" && typeof value === "string") {
+ const current = (await connection.getState()).model;
+ if (current && modelValue(current) === value) {
+ return { configOptions: await refreshConfig(entry) };
+ }
+ let models: AgentConnectionModel[];
+ try {
+ models = await connection.getAvailableModels();
+ } catch {
+ throw acp.RequestError.invalidParams({ reason: "Model discovery is unavailable; try again later" });
+ }
+ const model = models.find((candidate) => modelValue(candidate) === value);
+ if (!model) throw acp.RequestError.invalidParams({ reason: `Unavailable model: ${value}` });
+ await connection.setModel(model.provider, model.id);
+ entry.models = models;
+ } else if (configId === "thought_level" && typeof value === "string") {
+ const state = await connection.getState();
+ const level = state.availableThinkingLevels.find((candidate) => candidate === value);
+ if (!state.model?.reasoning || !level) {
+ throw acp.RequestError.invalidParams({ reason: `Unsupported reasoning effort: ${value}` });
+ }
+ await connection.setThinkingLevel(level);
+ } else {
+ throw acp.RequestError.invalidParams({ reason: `Invalid configuration option: ${configId}` });
+ }
+ return { configOptions: await refreshConfig(entry) };
+ });
+ })
.onRequest("session/prompt", async (ctx: any) => {
const params = ctx.params as { sessionId: string; prompt: readonly unknown[] };
const entry = session?.id === params.sessionId ? session : undefined;
@@ -1013,6 +1127,7 @@ export async function runAcpModeWithConnection(
const inputPauseKey = closing.inputPauseKey;
if (!inputPauseKey) throw new Error("Missing ACP close input-pause key");
await stopSessionWork(pending, promptTask);
+ await configTask;
closing.unsubscribe?.();
// Keep the backing session fenced until a replacement ACP session is admitted.
await closing.producer.close();
diff --git a/packages/coding-agent/test/suite/acp-mode.test.ts b/packages/coding-agent/test/suite/acp-mode.test.ts
index 7f386305b7..7a61722daf 100644
--- a/packages/coding-agent/test/suite/acp-mode.test.ts
+++ b/packages/coding-agent/test/suite/acp-mode.test.ts
@@ -199,6 +199,92 @@ function connectAcpClient(connection: any, options: ClientHarnessOptions = {}):
}
describe("ACP mode end to end", () => {
+ it("advertises model and effort pickers and applies unambiguous ACP selections (#2455)", async () => {
+ const harness = await createHarness({
+ models: [
+ { id: "reasoner", reasoning: true },
+ { id: "plain/model", reasoning: false },
+ ],
+ });
+ const connection = new InProcessAgentConnection(runtimeHostFor(harness.session));
+ const otherProvider = `${harness.models[0].provider}/plain`;
+ harness.session.modelRegistry.registerProvider(otherProvider, {
+ api: harness.faux.api,
+ apiKey: "faux-key",
+ baseUrl: harness.models[0].baseUrl,
+ models: [{ ...harness.models[1], id: "model" }],
+ });
+ const { client, updates, close } = connectAcpClient(connection);
+ try {
+ await client.request("initialize", { protocolVersion: acp.PROTOCOL_VERSION, clientCapabilities: {} });
+ const params = { cwd: harness.tempDir, mcpServers: [] };
+ const session = (await client.request("session/new", params)) as acp.NewSessionResponse;
+ const model = JSON.stringify([harness.models[0].provider, "plain/model"]);
+ expect(session.configOptions).toMatchObject([
+ {
+ id: "model",
+ category: "model",
+ type: "select",
+ currentValue: JSON.stringify([harness.models[0].provider, "reasoner"]),
+ options: expect.arrayContaining([expect.objectContaining({ value: model })]),
+ },
+ {
+ id: "thought_level",
+ category: "thought_level",
+ currentValue: harness.session.thinkingLevel,
+ },
+ ]);
+ const select = (configId: string, value: string, sessionId = session.sessionId) =>
+ client.request("session/set_config_option", { sessionId, configId, value });
+ const effort = await select("thought_level", "high");
+ expect(harness.session.thinkingLevel).toBe("high");
+ expect(effort.configOptions).toContainEqual(
+ expect.objectContaining({ id: "thought_level", currentValue: "high" }),
+ );
+ const configurations = () => updates.filter((item) => item.update.sessionUpdate === "config_option_update");
+ expect(configurations().map((item) => item.update.configOptions)).toContainEqual(effort.configOptions);
+ for (const [configId, value, sessionId] of [
+ ["model", "missing", session.sessionId],
+ ["thought_level", "invalid", session.sessionId],
+ ["unknown", "high", session.sessionId],
+ ["thought_level", "low", "missing-session"],
+ ]) {
+ await expect(select(configId, value, sessionId)).rejects.toMatchObject({ code: -32602 });
+ }
+ expect(harness.session.thinkingLevel).toBe("high");
+ harness.session.setThinkingLevel("low");
+ const changed = await select("model", model);
+ expect(configurations().flatMap((item) => item.update.configOptions)).toContainEqual(
+ expect.objectContaining({ id: "thought_level", currentValue: "low" }),
+ );
+ expect(changed.configOptions).toEqual([expect.objectContaining({ id: "model", currentValue: model })]);
+ expect(harness.session.model?.id).toBe("plain/model");
+ expect(harness.session.thinkingLevel).toBe("off");
+ await expect(select("thought_level", "high")).rejects.toMatchObject({ code: -32602 });
+ const restored = await select("model", JSON.stringify([harness.models[0].provider, "reasoner"]));
+ expect(restored.configOptions).toContainEqual(
+ expect.objectContaining({ id: "thought_level", currentValue: "low" }),
+ );
+ await select("model", JSON.stringify([otherProvider, "model"]));
+ expect(harness.session.model).toMatchObject({ provider: otherProvider, id: "model" });
+ const discovery = vi.spyOn(connection, "getAvailableModels").mockRejectedValue(new Error("offline"));
+ try {
+ const retained = await select("model", JSON.stringify([otherProvider, "model"]));
+ expect(retained.configOptions).toEqual([
+ expect.objectContaining({ currentValue: JSON.stringify([otherProvider, "model"]) }),
+ ]);
+ await expect(select("model", model)).rejects.toMatchObject({ code: -32602 });
+ discovery.mockResolvedValue([]);
+ await expect(select("model", JSON.stringify([otherProvider, "model"]))).resolves.toEqual(retained);
+ } finally {
+ discovery.mockRestore();
+ }
+ } finally {
+ close();
+ harness.cleanup();
+ }
+ });
+
it("completes a prompt turn and streams assistant text", async () => {
const harness = await createHarness();
harness.setResponses([fauxAssistantMessage("Hello from prime-agent.")]);
diff --git a/packages/coding-agent/test/suite/harness.ts b/packages/coding-agent/test/suite/harness.ts
index 98cd048580..e37f9d3425 100644
--- a/packages/coding-agent/test/suite/harness.ts
+++ b/packages/coding-agent/test/suite/harness.ts
@@ -8,7 +8,7 @@ import { join } from "node:path";
import type { AgentMessage, AgentTool } from "@earendil-works/pi-agent-core";
import { Agent } from "@earendil-works/pi-agent-core";
import type { FauxModelDefinition, FauxProviderRegistration, FauxResponseStep, Model } from "@earendil-works/pi-ai";
-import { registerFauxProvider } from "@earendil-works/pi-ai";
+import { getApiProvider, registerFauxProvider, unregisterApiProviders } from "@earendil-works/pi-ai";
import type { AgentSessionMessageController } from "../../src/core/agent-messages.js";
import type { AgentObserveController } from "../../src/core/agent-observe.js";
import { AgentSession, type AgentSessionEvent, type AutoRefineReviewer } from "../../src/core/agent-session.js";
@@ -122,6 +122,8 @@ export async function createHarness(options: HarnessOptions = {}): Promise<Harne
models: options.models,
});
fauxProvider.setResponses([]);
+ const fauxApi = getApiProvider(fauxProvider.api);
+ if (!fauxApi) throw new Error("Faux API registration is missing");
const model = fauxProvider.getModel();
const toolMap = options.tools ? Object.fromEntries(options.tools.map((tool) => [tool.name, tool])) : undefined;
const withConfiguredAuth = options.withConfiguredAuth ?? true;
@@ -144,6 +146,7 @@ export async function createHarness(options: HarnessOptions = {}): Promise<Harne
baseUrl: model.baseUrl,
apiKey: "faux-key",
api: fauxProvider.api,
+ streamSimple: fauxApi.streamSimple,
models: fauxProvider.models.map((registeredModel) => ({
id: registeredModel.id,
name: registeredModel.name,
@@ -243,6 +246,7 @@ export async function createHarness(options: HarnessOptions = {}): Promise<Harne
cleanup() {
session.dispose();
fauxProvider.unregister();
+ unregisterApiProviders(`provider:${model.provider}`);
if (existsSync(tempDir)) {
// Spawned fixture processes may still be flushing their final registry
// writes; retry briefly instead of failing the suite on ENOTEMPTY.