@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/acp/__tests__/agent-process.test.ts

@@ -8,9 +8,16 @@
 
 import { describe, expect, mock, test } from "bun:test";
 
-import type { AuthMethod, InitializeResponse } from "@agentclientprotocol/sdk";
+import type {
+  AuthMethod,
+  InitializeResponse,
+  SessionConfigOption,
+} from "@agentclientprotocol/sdk";
+import * as acp from "@agentclientprotocol/sdk";
 
 import { AcpAgentProcess } from "../agent-process.js";
+import { AcpConfigOptionRefusedError } from "../types.js";
+import { modelOption } from "./helpers/acp-model-option.js";
 
 function makeProcess(): AcpAgentProcess {
   return new AcpAgentProcess(
@@ -160,6 +167,139 @@ describe("AcpAgentProcess loadSession/resumeSession", () => {
   });
 });
 
+describe("AcpAgentProcess config options", () => {
+  /** Injects a connection whose session calls report `configOptions`. */
+  function stubSessionResponses(
+    proc: AcpAgentProcess,
+    configOptions: SessionConfigOption[] | null | undefined,
+  ): void {
+    (proc as unknown as { connection: unknown }).connection = {
+      newSession: () =>
+        Promise.resolve({ sessionId: "session-1", configOptions }),
+      loadSession: () => Promise.resolve({ configOptions }),
+      resumeSession: () => Promise.resolve({ configOptions }),
+    };
+  }
+
+  test("createSession returns the reported options", async () => {
+    const proc = makeProcess();
+    const options = [modelOption("sonnet")];
+    stubSessionResponses(proc, options);
+
+    await expect(proc.createSession("/tmp/project")).resolves.toEqual({
+      sessionId: "session-1",
+      configOptions: options,
+    });
+  });
+
+  test("loadSession returns the reported options", async () => {
+    const proc = makeProcess();
+    const options = [modelOption("sonnet")];
+    stubSessionResponses(proc, options);
+
+    await expect(
+      proc.loadSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: options });
+  });
+
+  test("resumeSession returns the reported options", async () => {
+    const proc = makeProcess();
+    const options = [modelOption("opus")];
+    stubSessionResponses(proc, options);
+
+    await expect(
+      proc.resumeSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: options });
+  });
+
+  test("a null or absent configOptions normalizes to an empty array", async () => {
+    const created = makeProcess();
+    stubSessionResponses(created, null);
+    await expect(created.createSession("/tmp/project")).resolves.toEqual({
+      sessionId: "session-1",
+      configOptions: [],
+    });
+
+    const loaded = makeProcess();
+    stubSessionResponses(loaded, null);
+    await expect(
+      loaded.loadSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: [] });
+
+    const resumed = makeProcess();
+    stubSessionResponses(resumed, undefined);
+    await expect(
+      resumed.resumeSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: [] });
+  });
+
+  test("setConfigOption forwards the value and returns the refreshed set", async () => {
+    const proc = makeProcess();
+    const calls: unknown[] = [];
+    const refreshed = [modelOption("opus")];
+    (proc as unknown as { connection: unknown }).connection = {
+      setSessionConfigOption: (params: unknown) => {
+        calls.push(params);
+        return Promise.resolve({ configOptions: refreshed });
+      },
+    };
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "opus"),
+    ).resolves.toEqual(refreshed);
+
+    expect(calls).toEqual([
+      { sessionId: "session-1", configId: "model", value: "opus" },
+    ]);
+  });
+
+  test("setConfigOption sends the boolean request variant", async () => {
+    const proc = makeProcess();
+    const calls: unknown[] = [];
+    const refreshed = [modelOption("opus")];
+    (proc as unknown as { connection: unknown }).connection = {
+      setSessionConfigOption: (params: unknown) => {
+        calls.push(params);
+        return Promise.resolve({ configOptions: refreshed });
+      },
+    };
+
+    await proc.setConfigOption("session-1", "thinking", true);
+
+    expect(calls).toEqual([
+      {
+        sessionId: "session-1",
+        configId: "thinking",
+        type: "boolean",
+        value: true,
+      },
+    ]);
+  });
+
+  test("setConfigOption omits the discriminator for string values", async () => {
+    const proc = makeProcess();
+    const calls: unknown[] = [];
+    (proc as unknown as { connection: unknown }).connection = {
+      setSessionConfigOption: (params: unknown) => {
+        calls.push(params);
+        return Promise.resolve({ configOptions: [modelOption("opus")] });
+      },
+    };
+
+    await proc.setConfigOption("session-1", "model", "opus");
+
+    expect(calls[0]).not.toHaveProperty("type");
+  });
+
+  test("setConfigOption throws when the process is not spawned", async () => {
+    const proc = makeProcess();
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "opus"),
+    ).rejects.toThrow('ACP agent "test-agent" is not spawned');
+  });
+});
+
 describe("AcpAgentProcess auth_required retry", () => {
   // spawnedEnv is injected the way spawn() builds it ({ ...process.env,
   // ...config.env }), so the advertised var names use a VELLUM_TEST_ prefix
@@ -196,17 +336,19 @@ describe("AcpAgentProcess auth_required retry", () => {
    * initialize() so the advertised authMethods are captured.
    */
   async function setupAuthProcess(options: {
+    command?: string;
     env?: Record<string, string>;
     authMethods?: AuthMethod[];
     /** Rejections to throw from successive newSession calls before succeeding. */
     newSessionRejections?: unknown[];
     loadSessionRejections?: unknown[];
     resumeSessionRejections?: unknown[];
+    setConfigOptionRejections?: unknown[];
     promptRejections?: unknown[];
   }) {
     const proc = new AcpAgentProcess(
       "codex",
-      { command: "echo", args: [], env: options.env },
+      { command: options.command ?? "echo", args: [], env: options.env },
       () => {
         throw new Error("client factory should not be called in this test");
       },
@@ -234,6 +376,10 @@ describe("AcpAgentProcess auth_required retry", () => {
       options.resumeSessionRejections ?? [],
       {},
     );
+    const setSessionConfigOption = failThenSucceed(
+      options.setConfigOptionRejections ?? [],
+      { configOptions: [] },
+    );
     const prompt = failThenSucceed(options.promptRejections ?? [], {
       stopReason: "end_turn",
     });
@@ -252,6 +398,7 @@ describe("AcpAgentProcess auth_required retry", () => {
       newSession,
       loadSession,
       resumeSession,
+      setSessionConfigOption,
       prompt,
       authenticate,
     };
@@ -264,18 +411,112 @@ describe("AcpAgentProcess auth_required retry", () => {
       newSession,
       loadSession,
       resumeSession,
+      setSessionConfigOption,
       prompt,
       authenticate,
       internals,
     };
   }
 
+  // An adapter that throws a plain Error reaches the client as a generic
+  // "Internal error" carrying the real sentence in `data.details`, which is
+  // the shape these fixtures reproduce.
+  test("setConfigOption surfaces the adapter's error answer as a refusal", async () => {
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Internal error", {
+          details: "Invalid value for config option model: nope",
+        }),
+      ],
+    });
+
+    const refusal = await proc
+      .setConfigOption("session-1", "model", "nope")
+      .catch((err: unknown) => err);
+
+    expect(refusal).toBeInstanceOf(AcpConfigOptionRefusedError);
+    // The adapter's sentence, not the message the SDK framed it in.
+    expect((refusal as Error).message).toBe(
+      "Invalid value for config option model: nope",
+    );
+  });
+
+  test("setConfigOption serializes a payload that names no reason", async () => {
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Internal error", { code: 7 }),
+      ],
+    });
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "nope"),
+    ).rejects.toThrow('{"code":7}');
+  });
+
+  test("setConfigOption falls back to the message when there is no payload", async () => {
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Session not found"),
+      ],
+    });
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "nope"),
+    ).rejects.toThrow("Session not found");
+  });
+
+  test.each(["claude-agent-acp", "/usr/local/bin/claude-agent-acp"])(
+    "setConfigOption leaves Claude's message-shaped auth failure untyped (%s)",
+    async (command) => {
+      const expired = new acp.RequestError(-32603, "Internal error", {
+        details: "Not logged in",
+      });
+      const { proc } = await setupAuthProcess({
+        command,
+        setConfigOptionRejections: [expired],
+      });
+
+      await expect(
+        proc.setConfigOption("session-1", "model", "opus"),
+      ).rejects.toBe(expired);
+    },
+  );
+
+  test("setConfigOption reads Claude's login wording from another adapter as a refusal", async () => {
+    const { proc } = await setupAuthProcess({
+      command: "codex-acp",
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Internal error", {
+          details: "Not logged in",
+        }),
+      ],
+    });
+
+    const refusal = await proc
+      .setConfigOption("session-1", "model", "gpt-5")
+      .catch((err: unknown) => err);
+
+    expect(refusal).toBeInstanceOf(AcpConfigOptionRefusedError);
+    expect((refusal as Error).message).toBe("Not logged in");
+  });
+
+  test("setConfigOption leaves a transport failure untyped", async () => {
+    const closed = new Error("ACP connection closed");
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [closed],
+    });
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "opus"),
+    ).rejects.toBe(closed);
+  });
+
   test("createSession does not authenticate when newSession succeeds", async () => {
     const { proc, newSession, authenticate } = await setupAuthProcess({
       env: { [OPENAI_VAR]: "sk-test" },
     });
 
-    const sessionId = await proc.createSession("/tmp/project");
+    const { sessionId } = await proc.createSession("/tmp/project");
 
     expect(sessionId).toBe("session-1");
     expect(newSession).toHaveBeenCalledTimes(1);
@@ -288,7 +529,7 @@ describe("AcpAgentProcess auth_required retry", () => {
       newSessionRejections: [authRequiredError],
     });
 
-    const sessionId = await proc.createSession("/tmp/project");
+    const { sessionId } = await proc.createSession("/tmp/project");
 
     expect(sessionId).toBe("session-1");
     expect(authenticate).toHaveBeenCalledTimes(1);
@@ -387,6 +628,19 @@ describe("AcpAgentProcess auth_required retry", () => {
     expect(resumeSession).toHaveBeenCalledTimes(2);
   });
 
+  test("setConfigOption authenticates and retries on auth_required", async () => {
+    const { proc, setSessionConfigOption, authenticate } =
+      await setupAuthProcess({
+        env: { [OPENAI_VAR]: "sk-test" },
+        setConfigOptionRejections: [authRequiredError],
+      });
+
+    await proc.setConfigOption("session-1", "model", "opus");
+
+    expect(authenticate).toHaveBeenCalledWith({ methodId: "openai-api-key" });
+    expect(setSessionConfigOption).toHaveBeenCalledTimes(2);
+  });
+
   test("prompt authenticates and retries on auth_required, returning the response", async () => {
     const { proc, prompt, authenticate } = await setupAuthProcess({
       env: { [OPENAI_VAR]: "sk-test" },

package/src/acp/__tests__/auth-required.test.ts

@@ -6,6 +6,8 @@
 
 import { describe, expect, test } from "bun:test";
 
+import { RequestError } from "@agentclientprotocol/sdk";
+
 import { AcpAuthRequiredEventSchema } from "../../api/events/acp-auth-required.js";
 import { AcpSessionErrorEventSchema } from "../../api/events/acp-session-error.js";
 import {
@@ -15,6 +17,7 @@ import {
   CLAUDE_ACP_COMMAND,
   isAcpAuthRequired,
   isClaudeAuthFailureMessage,
+  requestErrorReason,
 } from "../auth-required.js";
 
 describe("isAcpAuthRequired", () => {
@@ -89,6 +92,99 @@ describe("isClaudeAuthFailureMessage", () => {
   });
 });
 
+describe("requestErrorReason", () => {
+  test("decodes the sentence the SDK moved into the payload", () => {
+    const rejection = new RequestError(-32603, "Internal error", {
+      details: "Failed to authenticate. Please run /login",
+    });
+
+    expect(requestErrorReason(rejection)).toBe(
+      "Failed to authenticate. Please run /login",
+    );
+    // The point of decoding: the generic message never matches.
+    expect(isClaudeAuthFailureMessage(rejection.message)).toBe(false);
+    expect(isClaudeAuthFailureMessage(requestErrorReason(rejection))).toBe(
+      true,
+    );
+  });
+
+  test("reads the message off a rejection that carries no payload", () => {
+    // Straight off the wire: a plain object, not an instance of any class we
+    // control, and with the auth text where the SDK leaves a framed one.
+    const rejection = {
+      code: -32603,
+      message: "Failed to authenticate. Please run /login",
+    };
+
+    expect(requestErrorReason(rejection)).toBe(
+      "Failed to authenticate. Please run /login",
+    );
+    expect(isClaudeAuthFailureMessage(requestErrorReason(rejection))).toBe(
+      true,
+    );
+  });
+
+  test("keeps the rejection's own message when the payload names no reason", () => {
+    expect(requestErrorReason(new RequestError(-32603, "boom", { c: 7 }))).toBe(
+      "boom",
+    );
+    expect(
+      requestErrorReason(
+        RequestError.methodNotFound("session/set_config_option"),
+      ),
+    ).toBe('"Method not found": session/set_config_option');
+    expect(requestErrorReason(new Error("Not logged in"))).toBe(
+      "Not logged in",
+    );
+  });
+
+  test("keeps a specific rejection message ahead of supplemental details", () => {
+    expect(
+      requestErrorReason(
+        new RequestError(-32603, "Model unavailable", {
+          details: "The selected deployment is temporarily unavailable",
+        }),
+      ),
+    ).toBe("Model unavailable");
+  });
+
+  test("serializes the payload behind a bare Internal error that names no reason", () => {
+    expect(
+      requestErrorReason(new RequestError(-32603, "Internal error", { c: 7 })),
+    ).toBe('{"c":7}');
+  });
+
+  test("serializes the payload behind a generic Invalid params", () => {
+    // How the agent-side SDK answers a request its schema rejects.
+    expect(
+      requestErrorReason(
+        RequestError.invalidParams({ _errors: ["model: Invalid option"] }),
+      ),
+    ).toBe('{"_errors":["model: Invalid option"]}');
+  });
+
+  test("decodes claude-agent-acp's prompt-time 401 from its message", () => {
+    // RequestError.internalError({ errorKind }, cliText) as the adapter raises
+    // it: the CLI's text rides the message and the payload only names a kind.
+    const rejection = new RequestError(
+      -32603,
+      "Internal error: Failed to authenticate. API Error: 401 OAuth access token has expired.",
+      { errorKind: "authentication_failed" },
+    );
+
+    expect(requestErrorReason(rejection)).toBe(rejection.message);
+    expect(isClaudeAuthFailureMessage(requestErrorReason(rejection))).toBe(
+      true,
+    );
+  });
+
+  test("stringifies a rejection that is not an object at all", () => {
+    expect(requestErrorReason("plain string")).toBe("plain string");
+    expect(requestErrorReason(-32603)).toBe("-32603");
+    expect(requestErrorReason(null)).toBe("null");
+  });
+});
+
 describe("AcpAuthRequiredError", () => {
   test("is an Error that carries the agent id and its message", () => {
     const err = new AcpAuthRequiredError("claude", "needs a reconnect");

package/src/acp/__tests__/client-handler.test.ts

@@ -1,9 +1,13 @@
 import { describe, expect, test } from "bun:test";
 
-import type { SessionNotification } from "@agentclientprotocol/sdk";
+import type {
+  SessionConfigOption,
+  SessionNotification,
+} from "@agentclientprotocol/sdk";
 
 import type { AssistantEvent } from "../../api/index.js";
 import { VellumAcpClientHandler } from "../client-handler.js";
+import { modelOption } from "./helpers/acp-model-option.js";
 
 const ACP_SESSION_ID = "acp-session-abc";
 const PARENT_CONVERSATION_ID = "conv-xyz";
@@ -11,16 +15,21 @@ const PARENT_CONVERSATION_ID = "conv-xyz";
 function makeHandler(): {
   handler: VellumAcpClientHandler;
   sent: AssistantEvent[];
+  configOptionUpdates: SessionConfigOption[][];
 } {
   const sent: AssistantEvent[] = [];
+  const configOptionUpdates: SessionConfigOption[][] = [];
   const handler = new VellumAcpClientHandler(
     ACP_SESSION_ID,
     (msg) => {
       sent.push(msg);
     },
     PARENT_CONVERSATION_ID,
+    (configOptions) => {
+      configOptionUpdates.push(configOptions);
+    },
   );
-  return { handler, sent };
+  return { handler, sent, configOptionUpdates };
 }
 
 describe("VellumAcpClientHandler.sessionUpdate", () => {
@@ -782,3 +791,82 @@ describe("VellumAcpClientHandler seq + enriched fields", () => {
     expect(msg.toolTitle).toContain("<redacted");
   });
 });
+
+describe("VellumAcpClientHandler config_option_update", () => {
+  const MODEL_OPTION = modelOption("sonnet");
+
+  const THOUGHT_OPTION: SessionConfigOption = {
+    type: "boolean",
+    id: "thinking",
+    name: "Extended thinking",
+    currentValue: true,
+  };
+
+  function configOptionUpdate(
+    configOptions: SessionConfigOption[],
+  ): SessionNotification {
+    return {
+      sessionId: ACP_SESSION_ID,
+      update: { sessionUpdate: "config_option_update", configOptions },
+    };
+  }
+
+  test("invokes the callback with the full option array", async () => {
+    const { handler, sent, configOptionUpdates } = makeHandler();
+
+    await handler.sessionUpdate(
+      configOptionUpdate([MODEL_OPTION, THOUGHT_OPTION]),
+    );
+
+    expect(configOptionUpdates).toEqual([[MODEL_OPTION, THOUGHT_OPTION]]);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("callback fires during replay suppression", async () => {
+    const { handler, sent, configOptionUpdates } = makeHandler();
+
+    handler.beginReplaySuppression();
+    await handler.sessionUpdate(configOptionUpdate([MODEL_OPTION]));
+
+    expect(configOptionUpdates).toEqual([[MODEL_OPTION]]);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("a handler without the callback tolerates the update", async () => {
+    const sent: AssistantEvent[] = [];
+    const handler = new VellumAcpClientHandler(
+      ACP_SESSION_ID,
+      (msg) => {
+        sent.push(msg);
+      },
+      PARENT_CONVERSATION_ID,
+    );
+
+    await handler.sessionUpdate(configOptionUpdate([MODEL_OPTION]));
+
+    expect(sent).toHaveLength(0);
+  });
+
+  test("the remaining unhandled update types stay unforwarded", async () => {
+    const { handler, sent, configOptionUpdates } = makeHandler();
+
+    await handler.sessionUpdate({
+      sessionId: ACP_SESSION_ID,
+      update: {
+        sessionUpdate: "available_commands_update",
+        availableCommands: [{ name: "create_plan", description: "Plan work" }],
+      },
+    });
+    await handler.sessionUpdate({
+      sessionId: ACP_SESSION_ID,
+      update: { sessionUpdate: "current_mode_update", currentModeId: "ask" },
+    });
+    await handler.sessionUpdate({
+      sessionId: ACP_SESSION_ID,
+      update: { sessionUpdate: "session_info_update", title: "Refactor" },
+    });
+
+    expect(sent).toHaveLength(0);
+    expect(configOptionUpdates).toHaveLength(0);
+  });
+});

package/src/acp/__tests__/helpers/acp-model-option.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared test fixture: the `SessionConfigOption` an adapter advertises for
+ * model selection, shaped the way claude-agent-acp reports one (a `select`
+ * with id and category `model`).
+ */
+
+import type { SessionConfigOption } from "@agentclientprotocol/sdk";
+
+/** A model selector currently sitting on `currentValue`. */
+export function modelOption(currentValue: string): SessionConfigOption {
+  return {
+    type: "select",
+    id: "model",
+    name: "Model",
+    category: "model",
+    currentValue,
+    options: [
+      { value: "sonnet", name: "Sonnet" },
+      { value: "opus", name: "Opus", description: "Most capable" },
+    ],
+  };
+}
+
+/**
+ * A model selector sitting on nothing. `deriveModelInfo` reads an empty
+ * `currentValue` as "no model reported", which is the only shape that leaves a
+ * resumed session with a selector to pin through.
+ */
+export function modelOptionWithoutCurrent(): SessionConfigOption {
+  return modelOption("");
+}
+
+/**
+ * A selector that is not the model one, so a set carrying only this reads as
+ * an adapter that advertises no model selection.
+ */
+export function nonModelOption(): SessionConfigOption {
+  return {
+    type: "select",
+    id: "mode",
+    name: "Mode",
+    currentValue: "default",
+    options: [{ value: "default", name: "Default" }],
+  };
+}
+
+/** `modelOption`'s options as `deriveModelInfo` flattens them. */
+export const MODEL_OPTION_MODELS = [
+  { value: "sonnet", label: "Sonnet" },
+  { value: "opus", label: "Opus", description: "Most capable" },
+];

package/src/acp/__tests__/session-manager-persistence.test.ts

@@ -66,7 +66,11 @@ function buildSessionWithFakeProcess(opts: {
     kill: () => {},
     spawn: () => {},
     initialize: () => Promise.resolve(),
-    createSession: () => Promise.resolve(opts.protocolSessionId),
+    createSession: () =>
+      Promise.resolve({
+        sessionId: opts.protocolSessionId,
+        configOptions: [],
+      }),
     cancel: () => Promise.resolve(),
     markStderr: () => 0,
     stderrSince: () => "",