@vellumai/assistant 0.12.1-staging.1 → 0.12.1

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

@@ -194,10 +194,7 @@ describe("AcpAgentProcess.createSession auth_required handling", () => {
       },
     });
 
-    await expect(proc.createSession("/tmp")).resolves.toEqual({
-      sessionId: "session-1",
-      configOptions: [],
-    });
+    await expect(proc.createSession("/tmp")).resolves.toBe("session-1");
     expect(authenticateCalls()).toBe(1);
   });
 

package/src/acp/agent-process.ts

@@ -6,7 +6,6 @@
  */
 
 import { type ChildProcess, spawn } from "node:child_process";
-import { basename } from "node:path";
 import { Readable, Writable } from "node:stream";
 
 import type {
@@ -15,24 +14,14 @@ import type {
   AuthMethodEnvVar,
   Client,
   InitializeResponse,
-  LoadSessionResponse,
   NewSessionResponse,
   PromptResponse,
-  ResumeSessionResponse,
-  SessionConfigOption,
-  SetSessionConfigOptionRequest,
 } from "@agentclientprotocol/sdk";
 import * as acp from "@agentclientprotocol/sdk";
 
 import { getLogger } from "../util/logger.js";
-import {
-  AcpAuthRequiredError,
-  CLAUDE_ACP_COMMAND,
-  isAcpAuthRequired,
-  isClaudeAuthFailureMessage,
-  requestErrorReason,
-} from "./auth-required.js";
-import { type AcpAgentConfig, AcpConfigOptionRefusedError } from "./types.js";
+import { AcpAuthRequiredError, isAcpAuthRequired } from "./auth-required.js";
+import type { AcpAgentConfig } from "./types.js";
 
 const log = getLogger("acp");
 
@@ -43,16 +32,6 @@ const log = getLogger("acp");
  */
 const STDERR_RETENTION_BYTES = 4096;
 
-/**
- * Normalizes the SDK's optional-and-nullable config-option field to an array,
- * so every session call hands its caller the same shape.
- */
-function normalizeConfigOptions(
-  configOptions: SessionConfigOption[] | null | undefined,
-): SessionConfigOption[] {
-  return configOptions ?? [];
-}
-
 function isEnvVarMethod(
   method: AuthMethod,
 ): method is AuthMethodEnvVar & { type: "env_var" } {
@@ -376,21 +355,16 @@ export class AcpAgentProcess {
 
   /**
    * Creates a new ACP session in the specified working directory.
-   * Returns the session ID and the config options the agent reported.
+   * Returns the session ID.
    */
-  async createSession(
-    cwd: string,
-  ): Promise<{ sessionId: string; configOptions: SessionConfigOption[] }> {
+  async createSession(cwd: string): Promise<string> {
     log.info({ agentId: this.agentId, cwd }, "Creating ACP session");
 
     const result: NewSessionResponse = await this.withAuthRetry(() =>
       this.requireConnection().newSession({ cwd, mcpServers: [] }),
     );
 
-    return {
-      sessionId: result.sessionId,
-      configOptions: normalizeConfigOptions(result.configOptions),
-    };
+    return result.sessionId;
   }
 
   /**
@@ -401,17 +375,12 @@ export class AcpAgentProcess {
    * callers should suppress forwarding of those replayed updates (see
    * VellumAcpClientHandler.beginReplaySuppression).
    */
-  async loadSession(
-    sessionId: string,
-    cwd: string,
-  ): Promise<{ configOptions: SessionConfigOption[] }> {
+  async loadSession(sessionId: string, cwd: string): Promise<void> {
     log.info({ agentId: this.agentId, sessionId, cwd }, "Loading ACP session");
 
-    const result: LoadSessionResponse = await this.withAuthRetry(() =>
+    await this.withAuthRetry(() =>
       this.requireConnection().loadSession({ sessionId, cwd, mcpServers: [] }),
     );
-
-    return { configOptions: normalizeConfigOptions(result.configOptions) };
   }
 
   /**
@@ -421,70 +390,16 @@ export class AcpAgentProcess {
    * preferred when the agent advertises the capability
    * (see supportsSessionResume).
    */
-  async resumeSession(
-    sessionId: string,
-    cwd: string,
-  ): Promise<{ configOptions: SessionConfigOption[] }> {
+  async resumeSession(sessionId: string, cwd: string): Promise<void> {
     log.info({ agentId: this.agentId, sessionId, cwd }, "Resuming ACP session");
 
-    const result: ResumeSessionResponse = await this.withAuthRetry(() =>
+    await this.withAuthRetry(() =>
       this.requireConnection().resumeSession({
         sessionId,
         cwd,
         mcpServers: [],
       }),
     );
-
-    return { configOptions: normalizeConfigOptions(result.configOptions) };
-  }
-
-  /**
-   * Sets one session config option (e.g. the model selector) via
-   * `session/set_config_option`. The agent answers with the full refreshed
-   * option set, which is returned to the caller.
-   *
-   * A boolean value sends the `type: "boolean"` request variant; a string
-   * sends the value-id variant.
-   */
-  async setConfigOption(
-    sessionId: string,
-    configId: string,
-    value: string | boolean,
-  ): Promise<SessionConfigOption[]> {
-    log.info(
-      { agentId: this.agentId, sessionId, configId, value },
-      "Setting ACP session config option",
-    );
-
-    const request: SetSessionConfigOptionRequest =
-      typeof value === "boolean"
-        ? { sessionId, configId, type: "boolean", value }
-        : { sessionId, configId, value };
-
-    const response = await this.withAuthRetry(async () => {
-      try {
-        return await this.requireConnection().setSessionConfigOption(request);
-      } catch (err) {
-        // Wrapped here, at the request itself, so `withAuthRetry` still sees
-        // an auth_required answer and a caller cannot confuse the adapter's
-        // refusal with a transport or authentication failure. Claude's
-        // expired-token failure travels as a generic error whose reason is
-        // the only signal, so under the Claude adapter it is left for the
-        // caller to classify.
-        if (err instanceof acp.RequestError && !isAcpAuthRequired(err)) {
-          const reason = requestErrorReason(err);
-          const claudeAuthFailure =
-            basename(this.config.command) === CLAUDE_ACP_COMMAND &&
-            isClaudeAuthFailureMessage(reason);
-          if (!claudeAuthFailure) {
-            throw new AcpConfigOptionRefusedError(reason);
-          }
-        }
-        throw err;
-      }
-    });
-
-    return normalizeConfigOptions(response.configOptions);
   }
 
   /**

package/src/acp/auth-required.ts

@@ -8,8 +8,7 @@
  * 2. Credentials present but rejected (the expired/revoked case): the CLI
  *    surfaces the API 401 as an error message it authors, and the adapter
  *    relays it as a generic -32603 internal error, NOT as `auth_required`.
- *    {@link isClaudeAuthFailureMessage}, over the text
- *    {@link requestErrorReason} decodes out of the rejection.
+ *    {@link isClaudeAuthFailureMessage}.
  *
  * A positive detection becomes {@link ACP_CLAUDE_AUTH_REQUIRED_CODE} on the
  * `acp_auth_required` event, which the client turns into the inline
@@ -82,54 +81,6 @@ export function isClaudeAuthFailureMessage(
   );
 }
 
-/** Messages the SDK's `RequestError` factories build when given no text. */
-const GENERIC_RPC_MESSAGES: ReadonlySet<string> = new Set([
-  "Parse error",
-  "Invalid request",
-  "Invalid params",
-  "Internal error",
-  "Request cancelled",
-  "Authentication required",
-  "Resource not found",
-]);
-
-/**
- * The sentence behind a JSON-RPC rejection. An adapter that throws a plain
- * Error reaches the client as a bare "Internal error" whose real text the
- * agent-side SDK moved into `data.details`. An adapter that raises
- * `RequestError.internalError(data, text)` keeps its words in the message and
- * only supplemental context in `data`, so a specific message wins. Behind a
- * generic message such as "Invalid params", `data.details` or the serialized
- * payload supplies the reason instead. Duck-typed like
- * {@link isAcpAuthRequired}:
- * `message` is read as a property, so a rejection that arrives as a plain
- * object off the wire decodes the same as an `Error` instance.
- */
-export function requestErrorReason(err: unknown): string {
-  if (typeof err !== "object" || err === null) {
-    return String(err);
-  }
-  const { data, message } = err as { data?: unknown; message?: unknown };
-  const own = typeof message === "string" ? message : String(err);
-  if (data == null) {
-    return own;
-  }
-  if (
-    typeof message === "string" &&
-    message.length > 0 &&
-    !GENERIC_RPC_MESSAGES.has(message)
-  ) {
-    return message;
-  }
-  const details = (data as { details?: unknown }).details;
-  if (typeof details === "string" && details.length > 0) {
-    return details;
-  }
-  // JSON.stringify answers undefined for a value it cannot represent.
-  const serialized: string | undefined = JSON.stringify(data);
-  return serialized ?? own;
-}
-
 /** The adapter whose auth failures the Connect Claude flow can repair. */
 export const CLAUDE_ACP_COMMAND = "claude-agent-acp";
 

package/src/acp/auto-install.test.ts

@@ -78,7 +78,7 @@ describe("ensureAdapterInstalled", () => {
     expect(args).toEqual([
       "add",
       "--global",
-      "@agentclientprotocol/claude-agent-acp@0.75.1",
+      "@agentclientprotocol/claude-agent-acp",
     ]);
   });
 
@@ -198,8 +198,8 @@ describe("ensureAdapterInstalled", () => {
       (call) => (call[1] as string[])[2],
     );
     expect(installedPackages.sort()).toEqual([
-      "@agentclientprotocol/claude-agent-acp@0.75.1",
-      "@agentclientprotocol/codex-acp@1.10.0",
+      "@agentclientprotocol/claude-agent-acp",
+      "@agentclientprotocol/codex-acp",
     ]);
   });
 });
@@ -232,7 +232,7 @@ describe("resolveAgentWithAutoInstall - resolution order", () => {
     // The resolved command is the REAL binary, not a `bun x` wrapper.
     expect(result.resolved.agent.command).toBe("claude-agent-acp");
     expect(result.autoInstalledPackage).toBe(
-      "@agentclientprotocol/claude-agent-acp@0.75.1",
+      "@agentclientprotocol/claude-agent-acp",
     );
     expect(result.failureMessage).toBeUndefined();
     expect(execFileMock).toHaveBeenCalledTimes(1);
@@ -264,14 +264,12 @@ describe("resolveAgentWithAutoInstall - resolution order", () => {
       return;
     }
     expect(result.resolved.agent.command).toBe("codex-acp");
-    expect(result.autoInstalledPackage).toBe(
-      "@agentclientprotocol/codex-acp@1.10.0",
-    );
+    expect(result.autoInstalledPackage).toBe("@agentclientprotocol/codex-acp");
     expect(execFileMock).toHaveBeenCalledTimes(1);
     expect(execFileMock.mock.calls[0][1]).toEqual([
       "add",
       "--global",
-      "@agentclientprotocol/codex-acp@1.10.0",
+      "@agentclientprotocol/codex-acp",
     ]);
   });
 
@@ -297,7 +295,7 @@ describe("resolveAgentWithAutoInstall - resolution order", () => {
     expect(result.resolved.ok).toBe(false);
     expect(result.failureMessage).toContain("claude-agent-acp is not on PATH");
     expect(result.failureMessage).toContain(
-      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
     expect(result.failureMessage).toContain("network is down");
     for (const call of execFileMock.mock.calls) {

package/src/acp/client-handler.ts

@@ -21,7 +21,6 @@ import type {
   ReleaseTerminalResponse,
   RequestPermissionRequest,
   RequestPermissionResponse,
-  SessionConfigOption,
   SessionNotification,
   TerminalOutputRequest,
   TerminalOutputResponse,
@@ -104,9 +103,6 @@ export class VellumAcpClientHandler implements Client {
     private readonly acpSessionId: string,
     private readonly sendToVellum: (msg: AssistantEvent) => void,
     private readonly parentConversationId: string,
-    private readonly onConfigOptions?: (
-      configOptions: SessionConfigOption[],
-    ) => void,
   ) {}
 
   /** Forwards an update to Vellum, stamping a contiguous per-session `seq`. */
@@ -186,12 +182,7 @@ export class VellumAcpClientHandler implements Client {
   async sessionUpdate(params: SessionNotification): Promise<void> {
     const update = params.update;
 
-    // Config options are current state rather than transcript history, so they
-    // are applied even while a replay is being suppressed.
-    if (
-      this.suppressForwarding &&
-      update.sessionUpdate !== "config_option_update"
-    ) {
+    if (this.suppressForwarding) {
       log.debug(
         { acpSessionId: this.acpSessionId, updateType: update.sessionUpdate },
         "Dropping replayed session update during suppression",
@@ -295,14 +286,10 @@ export class VellumAcpClientHandler implements Client {
         break;
       }
 
-      case "config_option_update": {
-        this.onConfigOptions?.(update.configOptions);
-        break;
-      }
-
       default: {
         // Other update types (available_commands_update, current_mode_update,
-        // session_info_update) are not forwarded to Vellum.
+        // config_option_update, session_info_update) are not forwarded to
+        // Vellum.
         log.debug(
           {
             acpSessionId: this.acpSessionId,

package/src/acp/resolve-agent.test.ts

@@ -56,9 +56,7 @@ describe("resolveAcpAgent", () => {
       return;
     }
     expect(result.agent.command).toBe("codex-acp");
-    expect(result.agent.description).toContain(
-      "@agentclientprotocol/codex-acp",
-    );
+    expect(result.agent.description).toContain("@agentclientprotocol/codex-acp");
   });
 
   test("falls back to default profile for claude when no user entry", () => {
@@ -193,7 +191,7 @@ describe("resolveAcpAgent", () => {
       return;
     }
     expect(result.hint).toBe(
-      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
     expect(result.command).toBe("claude-agent-acp");
   });
@@ -242,9 +240,7 @@ describe("resolveAcpAgent", () => {
     if (result.reason !== "binary_not_found") {
       return;
     }
-    expect(result.hint).toBe(
-      "bun add -g @agentclientprotocol/codex-acp@1.10.0",
-    );
+    expect(result.hint).toBe("bun add -g @agentclientprotocol/codex-acp");
   });
 
   test("binary preflight honors agent.env.PATH override (matches spawn env)", () => {
@@ -289,178 +285,6 @@ describe("resolveAcpAgent", () => {
     expect(result.agent.args).toEqual(["--verbose"]);
   });
 
-  test("the bundled claude profile carries its model", () => {
-    config.setConfig({ agents: {} });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.model).toBe("opus");
-  });
-
-  test("a user entry that names a model overrides the bundled one", () => {
-    config.setConfig({
-      agents: {
-        claude: { command: "claude-agent-acp", args: [], model: "sonnet" },
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.model).toBe("sonnet");
-  });
-
-  test("a user entry keeping the profile command and omitting model inherits it", () => {
-    config.setConfig({
-      agents: {
-        claude: { command: "claude-agent-acp", args: ["--my-flag"] },
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.args).toEqual(["--my-flag"]);
-    expect(result.agent.model).toBe("opus");
-  });
-
-  test("a user entry that omits command entirely still inherits the model", () => {
-    // The schema admits a command-less entry for a bundled id; the profile's
-    // command is inherited with the rest.
-    config.setConfig({
-      agents: {
-        claude: JSON.parse('{"args": ["--my-flag"]}'),
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.command).toBe("claude-agent-acp");
-    expect(result.agent.model).toBe("opus");
-  });
-
-  test("a user entry running the profile adapter by full path still inherits the model", () => {
-    config.setConfig({
-      agents: {
-        claude: { command: "/opt/bin/claude-agent-acp", args: [] },
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.command).toBe("/opt/bin/claude-agent-acp");
-    expect(result.agent.model).toBe("opus");
-  });
-
-  test("a user entry pointing the id at another adapter inherits no model", () => {
-    // The bundled aliases are Claude's own vocabulary, so an unrelated
-    // adapter under the `claude` id must not be handed `opus`.
-    config.setConfig({
-      agents: {
-        claude: { command: "my-custom-claude", args: ["--my-flag"] },
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.command).toBe("my-custom-claude");
-    expect(result.agent.model).toBeUndefined();
-  });
-
-  test("a user entry naming its own model keeps it across a replaced command", () => {
-    config.setConfig({
-      agents: {
-        claude: {
-          command: "my-custom-claude",
-          args: [],
-          model: "my-fork-large",
-        },
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.command).toBe("my-custom-claude");
-    expect(result.agent.model).toBe("my-fork-large");
-  });
-
-  test("a user entry pointing the id at another adapter inherits no description", () => {
-    config.setConfig({
-      agents: {
-        claude: { command: "my-custom-claude", args: [] },
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.description).toBeUndefined();
-    const listed = listAcpAgents().agents.find(
-      (entry) => entry.id === "claude",
-    );
-    expect(listed?.command).toBe("my-custom-claude");
-    expect(listed?.description).toBeUndefined();
-  });
-
-  test("a user entry running the profile adapter by full path inherits its description", () => {
-    config.setConfig({
-      agents: {
-        claude: { command: "/opt/bin/claude-agent-acp", args: [] },
-      },
-    });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.description).toContain(
-      "@agentclientprotocol/claude-agent-acp",
-    );
-  });
-
-  test("a bundled profile with no model leaves the resolved agent without one", () => {
-    config.setConfig({ agents: {} });
-
-    const result = resolveAcpAgent("codex");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.agent.model).toBeUndefined();
-  });
-
   test("resolves a full-path command directly without rewriting it", () => {
     config.setConfig({
       agents: {
@@ -508,7 +332,7 @@ describe("resolveAcpAgent - missing binary", () => {
     }
     expect(result.command).toBe("claude-agent-acp");
     expect(result.hint).toBe(
-      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
   });
 
@@ -527,7 +351,7 @@ describe("resolveAcpAgent - missing binary", () => {
       return;
     }
     expect(result.hint).toBe(
-      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
   });
 });
@@ -606,9 +430,7 @@ describe("listAcpAgents", () => {
     const codex = result.agents.find((a) => a.id === "codex");
     expect(codex?.available).toBe(false);
     expect(codex?.unavailableReason).toBe("'codex-acp' is not on PATH");
-    expect(codex?.setupHint).toBe(
-      "bun add -g @agentclientprotocol/codex-acp@1.10.0",
-    );
+    expect(codex?.setupHint).toBe("bun add -g @agentclientprotocol/codex-acp");
   });
 
   test("aliases are resolution sugar, not catalog entries", () => {
@@ -667,39 +489,3 @@ describe("listAcpAgents", () => {
     );
   });
 });
-
-describe("agent ids that name Object.prototype members", () => {
-  // An id read off the prototype chain would resolve as a configured agent
-  // that does not exist, and a spawn would start a process for a config
-  // nobody wrote.
-  for (const id of ["__proto__", "constructor", "prototype"]) {
-    test(`"${id}" resolves to nothing`, () => {
-      config.setConfig({ agents: {} });
-
-      const resolved = resolveAcpAgent(id);
-      expect(resolved.ok).toBe(false);
-      if (resolved.ok) {
-        return;
-      }
-      expect(resolved.reason).toBe("unknown_agent");
-      if (resolved.reason !== "unknown_agent") {
-        return;
-      }
-      expect(resolved.available).toEqual(["claude", "codex"]);
-    });
-  }
-
-  test("the catalog never lists one, even when config carries the key", () => {
-    config.setConfig({
-      agents: {
-        ...JSON.parse('{"__proto__": {"command": "evil", "args": []}}'),
-        claude: { command: "claude-agent-acp", args: [] },
-      },
-    });
-
-    expect(listAcpAgents().agents.map((a) => a.id)).toEqual([
-      "claude",
-      "codex",
-    ]);
-  });
-});