@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/acp/resolve-agent.ts

@@ -1,15 +1,15 @@
 /**
  * Shared resolver for ACP agent ids → agent config + binary preflight.
  *
- * `resolveAcpAgent(id)` layers user-provided `config.acp.agents[id]` over the
- * bundled `DEFAULT_ACP_AGENT_PROFILES` so common agents like `claude` and
- * `codex` Just Work with no per-user config required; `mergeWithProfile` says
- * what an entry inherits. Natural names ("claude code", "OpenAI Codex")
- * resolve via `AGENT_ID_ALIASES` when the raw id misses both maps. The result
- * is a discriminated union covering every reason a spawn might fail before we
- * even start the agent process: unknown agent id, or binary missing from
- * PATH. Callers (acp_spawn, acp_list_agents, and the `/v1/acp/spawn` HTTP
- * route) get a single source of truth and matching actionable hints.
+ * `resolveAcpAgent(id)` merges user-provided `config.acp.agents[id]` (wins on
+ * overlap) with the bundled `DEFAULT_ACP_AGENT_PROFILES` so common agents like
+ * `claude` and `codex` Just Work with no per-user config required. Natural
+ * names ("claude code", "OpenAI Codex") resolve via `AGENT_ID_ALIASES` when the
+ * raw id misses both maps. The result is a discriminated union covering every
+ * reason a spawn might fail before we even start the agent process: unknown
+ * agent id, or binary missing from PATH. Callers (acp_spawn, acp_list_agents,
+ * and the `/v1/acp/spawn` HTTP route) get a single source of truth and
+ * matching actionable hints.
  *
  * The resolver NEVER fetches or runs packages in the (untrusted) task cwd.
  * When the adapter binary is missing, resolution simply fails with
@@ -25,16 +25,12 @@
  * `available` / `setupHint` derived from the same binary resolution.
  */
 
-import { basename } from "node:path";
-
 import {
-  type AcpAgentProfile,
   DEFAULT_ACP_AGENT_PROFILES,
   DEFAULT_AGENT_NPM_PACKAGES,
 } from "../config/acp-defaults.js";
-import type { AcpAgentConfig as ConfiguredAcpAgent } from "../config/acp-schema.js";
+import type { AcpAgentConfig } from "../config/acp-schema.js";
 import { getConfig } from "../config/loader.js";
-import type { AcpAgentConfig } from "./types.js";
 
 /**
  * Whether this agent's entry came from user config (wins over default) or
@@ -138,19 +134,6 @@ const AGENT_ID_ALIASES: Record<string, string> = {
   openaicodex: "codex",
 };
 
-/**
- * Ids that read back as inherited `Object.prototype` members instead of
- * configured agents. `directLookup` and `mergedAgentIds` refuse them so an id
- * from a tool call or an HTTP body can resolve to nothing but a real entry:
- * resolving one would report a configured agent that does not exist, and a
- * spawn would then start a process for a config nobody wrote.
- */
-const PROTOTYPE_SENSITIVE_AGENT_IDS: ReadonlySet<string> = new Set([
-  "__proto__",
-  "constructor",
-  "prototype",
-]);
-
 /**
  * Normalize a raw agent id for alias matching: lowercase and strip spaces,
  * underscores, and hyphens so "Claude Code", "claude-code", and
@@ -183,92 +166,45 @@ export function lookupAcpAgentConfig(id: string): AcpAgentConfig | undefined {
 }
 
 function lookupAgent(
-  userAgents: Record<string, ConfiguredAcpAgent>,
+  userAgents: Record<string, AcpAgentConfig>,
   id: string,
-): { agent: AcpAgentConfig; source: AcpAgentSource; id: string } | undefined {
+): { agent: AcpAgentConfig; source: AcpAgentSource } | undefined {
   const direct = directLookup(userAgents, id);
   if (direct) {
-    return { ...direct, id };
+    return direct;
   }
-  const normalized = normalizeAgentId(id);
-  const canonicalId = Object.hasOwn(AGENT_ID_ALIASES, normalized)
-    ? AGENT_ID_ALIASES[normalized]
+  const canonicalId = AGENT_ID_ALIASES[normalizeAgentId(id)];
+  return canonicalId !== undefined
+    ? directLookup(userAgents, canonicalId)
     : undefined;
-  if (canonicalId === undefined) {
-    return undefined;
-  }
-  const aliased = directLookup(userAgents, canonicalId);
-  return aliased ? { ...aliased, id: canonicalId } : undefined;
 }
 
 function directLookup(
-  userAgents: Record<string, ConfiguredAcpAgent>,
+  userAgents: Record<string, AcpAgentConfig>,
   id: string,
 ): { agent: AcpAgentConfig; source: AcpAgentSource } | undefined {
-  if (PROTOTYPE_SENSITIVE_AGENT_IDS.has(id)) {
-    return undefined;
-  }
-  const userAgent = Object.hasOwn(userAgents, id) ? userAgents[id] : undefined;
-  const defaultAgent = Object.hasOwn(DEFAULT_ACP_AGENT_PROFILES, id)
-    ? DEFAULT_ACP_AGENT_PROFILES[id]
-    : undefined;
+  const userAgent = userAgents[id];
   if (userAgent) {
-    const agent = mergeWithProfile(userAgent, defaultAgent);
-    return agent ? { agent, source: "config" } : undefined;
+    return { agent: userAgent, source: "config" };
   }
+  const defaultAgent = DEFAULT_ACP_AGENT_PROFILES[id];
   if (defaultAgent) {
     return { agent: defaultAgent, source: "default" };
   }
   return undefined;
 }
 
-/**
- * Fill a user config entry from the bundled profile for the same id. An entry
- * that runs the profile's adapter (it omits `command`, or names the same
- * binary, by full path or not) inherits the leaves it leaves out: `command`
- * itself, the description, and the `model` a session starts on. `args` is the
- * exception, because the schema defaults it to `[]`: a parsed entry always
- * carries its own, so the profile's never reaches it. An entry that points
- * the id at a different adapter stands alone, like any user-only entry,
- * so a config that reuses the `claude` id for something else never carries
- * Claude's description or has Claude's `opus` sent to it. Zod omits absent
- * optional keys, so an omission never spreads as an undefined override.
- *
- * `undefined` only for an entry with neither a command nor a profile to take
- * one from, a shape the config schema rejects before it gets here.
- */
-function mergeWithProfile(
-  userAgent: ConfiguredAcpAgent,
-  profile: AcpAgentProfile | undefined,
-): AcpAgentConfig | undefined {
-  const command = userAgent.command;
-  if (!profile) {
-    return command === undefined ? undefined : { ...userAgent, command };
-  }
-  // A full path to the bundled binary is still the bundled adapter; the
-  // basename is the adapter's identity everywhere else in this module.
-  if (
-    command !== undefined &&
-    basename(command) !== basename(profile.command)
-  ) {
-    return { ...userAgent, command };
-  }
-  return { ...profile, ...userAgent, command: command ?? profile.command };
-}
-
 /**
  * Defaults first (declaration order), then user-only ids. Deduplicated so a
  * user config that overrides a default doesn't list the id twice.
  */
-function mergedAgentIds(
-  userAgents: Record<string, ConfiguredAcpAgent>,
-): string[] {
+function mergedAgentIds(userAgents: Record<string, AcpAgentConfig>): string[] {
   return Array.from(
     new Set([
       ...Object.keys(DEFAULT_ACP_AGENT_PROFILES),
       ...Object.keys(userAgents),
     ]),
-  ).filter((id) => !PROTOTYPE_SENSITIVE_AGENT_IDS.has(id));
+  );
 }
 
 /**
@@ -320,8 +256,7 @@ export function listAcpAgents(): {
   const config = getConfig();
   const userAgents = config.acp.agents;
   const agents: AcpAgentEntry[] = mergedAgentIds(userAgents).map((id) => {
-    // Non-null: ids come from `mergedAgentIds`, and the schema admits a
-    // command-less entry only for a bundled id, so the lookup always resolves.
+    // Non-null: ids come from `mergedAgentIds` so the lookup always resolves.
     const { agent, source } = lookupAgent(userAgents, id)!;
     // Same binary preflight as `resolveAcpAgent`: available iff the command
     // is on PATH. A missing binary is auto-installed at spawn time, but the

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

@@ -1,7 +1,5 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
-import { RequestError } from "@agentclientprotocol/sdk";
-
 import type { Conversation } from "../daemon/conversation.js";
 import {
   deleteConversation,
@@ -41,7 +39,6 @@ mock.module("./prepare-agent-env.js", () => ({
 }));
 
 import { createAbortReason } from "../util/abort-reasons.js";
-import { modelOption } from "./__tests__/helpers/acp-model-option.js";
 import { VellumAcpClientHandler } from "./client-handler.js";
 import { AcpSessionManager } from "./session-manager.js";
 
@@ -93,10 +90,10 @@ function mockConversation(opts?: { enqueueQueued?: boolean }) {
 }
 
 /** Fake AcpAgentProcess covering only the calls firePromptInBackground makes. */
-function fakeProcess(prompt: () => Promise<unknown>, stderr = "") {
+function fakeProcess(prompt: () => Promise<unknown>) {
   return {
     markStderr: () => 0,
-    stderrSince: () => stderr,
+    stderrSince: () => "",
     prompt,
     kill: mock(() => {}),
   };
@@ -368,8 +365,6 @@ describe("AcpSessionManager auth-required recovery surface", () => {
     parentToolUseId?: string;
     cancelled?: boolean;
     credentialDigest?: string;
-    failure?: () => Promise<never>;
-    stderr?: string;
   }) {
     const manager = new AcpSessionManager(1);
     const parentId = `parent-${opts.id}`;
@@ -381,7 +376,7 @@ describe("AcpSessionManager auth-required recovery surface", () => {
       manager,
       opts.id,
       parentId,
-      fakeProcess(opts.failure ?? authFailure, opts.stderr),
+      fakeProcess(authFailure),
     );
     entry.command = opts.command;
     (entry as { parentToolUseId?: string }).parentToolUseId =
@@ -517,62 +512,6 @@ describe("AcpSessionManager auth-required recovery surface", () => {
     expect(r.persistedContent).toBeUndefined();
   });
 
-  test("claude's prompt-time 401 raises the surface when stderr names another failure", async () => {
-    // claude-agent-acp raises it as RequestError.internalError({ errorKind },
-    // cliText), and stderr supplies the failure message, so the auth text
-    // survives only on the rejection's own message.
-    refusedDigests.length = 0;
-    const digest = claudeTokenDigest("sk-ant-oat-prompt-401");
-    const r = await driveAuthFailure({
-      id: "sess-auth-prompt-401",
-      command: "claude-agent-acp",
-      parentToolUseId: "tool-anchor-prompt-401",
-      credentialDigest: digest,
-      failure: () =>
-        Promise.reject(
-          new RequestError(
-            -32603,
-            "Internal error: Failed to authenticate. API Error: 401 OAuth access token has expired.",
-            { errorKind: "authentication_failed" },
-          ),
-        ),
-      stderr: '{"error":{"message":"Something else happened"}}',
-    });
-
-    expect(r.authEvent).toMatchObject({
-      acpSessionId: "sess-auth-prompt-401",
-      authCode: "acp_claude_auth_required",
-      parentToolUseId: "tool-anchor-prompt-401",
-    });
-    expect(hasAcpConnectCardRaised(r.parentId)).toBe(true);
-    expect(refusedDigests).toContain(digest);
-  });
-
-  test("the rejection's own message is checked when its payload names a different reason", async () => {
-    refusedDigests.length = 0;
-    const digest = claudeTokenDigest("sk-ant-oat-own-message");
-    const r = await driveAuthFailure({
-      id: "sess-auth-own-message",
-      command: "claude-agent-acp",
-      parentToolUseId: "tool-anchor-own-message",
-      credentialDigest: digest,
-      failure: () =>
-        Promise.reject(
-          new RequestError(
-            -32603,
-            "Internal error: Failed to authenticate. API Error: 401",
-            { details: "Request failed" },
-          ),
-        ),
-      stderr: '{"error":{"message":"Something else happened"}}',
-    });
-
-    expect(r.authEvent).toMatchObject({
-      authCode: "acp_claude_auth_required",
-    });
-    expect(refusedDigests).toContain(digest);
-  });
-
   test("a non-claude adapter never raises the surface, even on an auth-shaped failure", async () => {
     const r = await driveAuthFailure({
       id: "sess-auth-codex",
@@ -777,136 +716,4 @@ describe("AcpSessionManager.spawn: a stopped turn leaves no agent running", () =
     expect(proc.kill).toHaveBeenCalled();
     expect(internals.sessions.size).toBe(0);
   });
-
-  /**
-   * The model pin is an await of its own, and it sits after the setup
-   * recheck. A stop landing inside it gets the same treatment: no spawned
-   * event, no model event, no prompt, and no session left behind.
-   */
-  test("a cancel during the model pin tears the process down and fires nothing", async () => {
-    const manager = new AcpSessionManager(1);
-    const controller = new AbortController();
-    const prompt = mock(() => Promise.resolve({}));
-    const setConfigOption = mock(async () => {
-      // The user stops the turn while the pin's round trip is open.
-      controller.abort(REASON);
-      return [modelOption("opus")];
-    });
-    const proc = {
-      ...fakeProcess(prompt),
-      spawn: () => {},
-      initialize: async () => {},
-      createSession: async () => ({
-        sessionId: "proto-1",
-        configOptions: [modelOption("sonnet")],
-      }),
-      setConfigOption,
-    };
-    let injected: ReturnType<typeof injectSession> | undefined;
-    const internals = manager as unknown as {
-      registerSession: (opts: {
-        acpSessionId: string;
-        parentConversationId: string;
-      }) => unknown;
-      sessions: Map<string, unknown>;
-    };
-    internals.registerSession = (opts) => {
-      injected = injectSession(
-        manager,
-        opts.acpSessionId,
-        opts.parentConversationId,
-        proc as unknown as ReturnType<typeof fakeProcess>,
-      );
-      return injected;
-    };
-
-    await expect(
-      manager.spawn(
-        "claude",
-        { command: "noop", args: [] } as never,
-        "do the task",
-        "/tmp",
-        "conv-1",
-        () => {},
-        { model: "opus" },
-        { signal: controller.signal },
-      ),
-    ).rejects.toThrow();
-
-    expect(setConfigOption).toHaveBeenCalled();
-    expect(injected?.sendToVellum).not.toHaveBeenCalled();
-    expect(prompt).not.toHaveBeenCalled();
-    expect(proc.kill).toHaveBeenCalled();
-    expect(internals.sessions.size).toBe(0);
-  });
-
-  /**
-   * A cancel that persists a resumable row frees the id, so a resume can
-   * register a fresh entry under it before the stopped spawn's pin settles.
-   * The teardown owes that spawn its own process, and owes the replacement
-   * its map slot.
-   */
-  test("a cancel during the model pin leaves a replacement session for the same id alone", async () => {
-    const manager = new AcpSessionManager(2);
-    const controller = new AbortController();
-    const prompt = mock(() => Promise.resolve({}));
-    let replacement: ReturnType<typeof injectSession> | undefined;
-    let spawnedId: string | undefined;
-    const setConfigOption = mock(async () => {
-      // The turn is stopped and the id is resumed by another request while
-      // the pin's round trip is still open.
-      controller.abort(REASON);
-      replacement = injectSession(
-        manager,
-        spawnedId!,
-        "conv-2",
-        fakeProcess(mock(() => Promise.resolve({}))),
-      );
-      return [modelOption("opus")];
-    });
-    const proc = {
-      ...fakeProcess(prompt),
-      spawn: () => {},
-      initialize: async () => {},
-      createSession: async () => ({
-        sessionId: "proto-1",
-        configOptions: [modelOption("sonnet")],
-      }),
-      setConfigOption,
-    };
-    const internals = manager as unknown as {
-      registerSession: (opts: {
-        acpSessionId: string;
-        parentConversationId: string;
-      }) => unknown;
-      sessions: Map<string, unknown>;
-    };
-    internals.registerSession = (opts) => {
-      spawnedId = opts.acpSessionId;
-      return injectSession(
-        manager,
-        opts.acpSessionId,
-        opts.parentConversationId,
-        proc as unknown as ReturnType<typeof fakeProcess>,
-      );
-    };
-
-    await expect(
-      manager.spawn(
-        "claude",
-        { command: "noop", args: [] } as never,
-        "do the task",
-        "/tmp",
-        "conv-1",
-        () => {},
-        { model: "opus" },
-        { signal: controller.signal },
-      ),
-    ).rejects.toThrow();
-
-    expect(prompt).not.toHaveBeenCalled();
-    expect(proc.kill).toHaveBeenCalled();
-    expect(replacement?.process.kill).not.toHaveBeenCalled();
-    expect(internals.sessions.get(spawnedId!)).toBe(replacement);
-  });
 });