@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/__tests__/watch-retro-tool-availability.test.ts

@@ -1,10 +1,13 @@
 /**
  * The gate that decides whether a watch retrospective can report at all.
  *
- * A retrospective runs as a `clientless` wake, but its report continues to
- * use the post-turn renderer so the report lands after its tool call has been
- * persisted. The core UI tools remain available on that turn for other
- * background work, so this file pins both contracts against the real registry.
+ * A retrospective runs as a `clientless` wake, which pins the turn
+ * non-interactive. `conversation-tool-setup` gates the whole `ui_surface`
+ * family on a client being present, so in that turn `ui_show` is not denied,
+ * it is absent: a retrospective told to call it can only tell the user it
+ * cannot. Nothing about the card's schema, its renderer, or the prompt's
+ * wording reveals that, which is why it is asserted here against the real
+ * registry rather than assumed anywhere else.
  */
 
 import { afterAll, describe, expect, test } from "bun:test";
@@ -51,14 +54,20 @@ describe("watch retrospective tool availability", () => {
     ).toBe(true);
   });
 
-  test("core UI tools stay available on a clientless turn", async () => {
+  test("ui_show is absent from a clientless turn", async () => {
     await initializeTools();
     const ctx = clientlessContext();
 
-    for (const name of ["ui_show", "ui_update", "ui_dismiss"]) {
-      expect(isToolActiveForContext(name, ctx)).toBe(true);
-    }
+    // The reason the report does not go through `ui_show`. If this ever flips
+    // to true, the extra tool above can be reconsidered; while it is false,
+    // routing the retrospective's card through `ui_show` produces a turn that
+    // cannot report at all.
+    expect(isToolActiveForContext("ui_show", ctx)).toBe(false);
+    expect(isToolActiveForContext("ui_update", ctx)).toBe(false);
+    expect(isToolActiveForContext("ui_dismiss", ctx)).toBe(false);
 
+    // And the gate really is about the client, not about the tools being
+    // unregistered: with one attached, the same names are active.
     const withClient = clientfulContext();
     expect(isToolActiveForContext("ui_show", withClient)).toBe(true);
   });

package/src/__tests__/workspace-git-service.test.ts

@@ -4,7 +4,6 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
-  renameSync,
   rmSync,
   statSync,
   symlinkSync,
@@ -524,31 +523,6 @@ describe("WorkspaceGitService", () => {
       expect(trackedFiles()).not.toContain("gone-b.txt");
       expect(trackedFiles()).not.toContain("gone-c.txt");
     });
-
-    test("batched rename stages origin and destination even when they split", async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, "old-name.txt"), "moved");
-      await service.commitChanges("Seed rename source");
-
-      renameSync(join(testDir, "old-name.txt"), join(testDir, "new-name.txt"));
-      for (const name of ["x0.txt", "x1.txt", "x2.txt", "x3.txt"]) {
-        writeFileSync(join(testDir, name), name);
-      }
-
-      await withStageBatchSize(2, async () => {
-        await service.commitChanges("Rename across batches");
-      });
-
-      expect(trackedFiles()).toContain("new-name.txt");
-      expect(trackedFiles()).not.toContain("old-name.txt");
-      const status = execFileSync("git", ["status", "--porcelain"], {
-        cwd: testDir,
-        encoding: "utf-8",
-      }).trim();
-      expect(status).toBe("");
-    });
   });
 
   describe("getStatus", () => {

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

@@ -8,16 +8,9 @@
 
 import { describe, expect, mock, test } from "bun:test";
 
-import type {
-  AuthMethod,
-  InitializeResponse,
-  SessionConfigOption,
-} from "@agentclientprotocol/sdk";
-import * as acp from "@agentclientprotocol/sdk";
+import type { AuthMethod, InitializeResponse } 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(
@@ -167,139 +160,6 @@ 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
@@ -336,19 +196,17 @@ 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: options.command ?? "echo", args: [], env: options.env },
+      { command: "echo", args: [], env: options.env },
       () => {
         throw new Error("client factory should not be called in this test");
       },
@@ -376,10 +234,6 @@ describe("AcpAgentProcess auth_required retry", () => {
       options.resumeSessionRejections ?? [],
       {},
     );
-    const setSessionConfigOption = failThenSucceed(
-      options.setConfigOptionRejections ?? [],
-      { configOptions: [] },
-    );
     const prompt = failThenSucceed(options.promptRejections ?? [], {
       stopReason: "end_turn",
     });
@@ -398,7 +252,6 @@ describe("AcpAgentProcess auth_required retry", () => {
       newSession,
       loadSession,
       resumeSession,
-      setSessionConfigOption,
       prompt,
       authenticate,
     };
@@ -411,112 +264,18 @@ 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);
@@ -529,7 +288,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);
@@ -628,19 +387,6 @@ 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,8 +6,6 @@
 
 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 {
@@ -17,7 +15,6 @@ import {
   CLAUDE_ACP_COMMAND,
   isAcpAuthRequired,
   isClaudeAuthFailureMessage,
-  requestErrorReason,
 } from "../auth-required.js";
 
 describe("isAcpAuthRequired", () => {
@@ -92,99 +89,6 @@ 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,13 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import type {
-  SessionConfigOption,
-  SessionNotification,
-} from "@agentclientprotocol/sdk";
+import type { 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";
@@ -15,21 +11,16 @@ 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, configOptionUpdates };
+  return { handler, sent };
 }
 
 describe("VellumAcpClientHandler.sessionUpdate", () => {
@@ -791,82 +782,3 @@ 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__/session-manager-persistence.test.ts

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