@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/acp/resolve-agent.ts

@@ -4,7 +4,7 @@
  * `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", "Gemini CLI") resolve via `AGENT_ID_ALIASES` when the
+ * 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,
@@ -132,8 +132,6 @@ const AGENT_ID_ALIASES: Record<string, string> = {
   claudecode: "claude",
   codexcli: "codex",
   openaicodex: "codex",
-  geminicli: "gemini",
-  googlegemini: "gemini",
 };
 
 /**
@@ -151,7 +149,7 @@ function normalizeAgentId(id: string): string {
  * vs bundled default" without re-deriving it.
  *
  * When the raw id misses both maps, fall back to `AGENT_ID_ALIASES` so
- * natural names like "claude code" or "Gemini CLI" resolve to the canonical
+ * natural names like "claude code" or "OpenAI Codex" resolve to the canonical
  * id. The alias is consulted ONLY after both direct lookups miss, so a user
  * config entry literally keyed "claude code" always wins over the alias.
  */

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

@@ -0,0 +1,312 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { VellumAcpClientHandler } from "./client-handler.js";
+import { AcpSessionManager } from "./session-manager.js";
+
+// Parent conversations registered per test; torn down in afterEach so the
+// shared registry does not leak state between cases.
+const registered: string[] = [];
+
+afterEach(() => {
+  for (const id of registered.splice(0)) {
+    deleteConversation(id);
+  }
+});
+
+/**
+ * A duck-typed parent conversation exposing only the three methods
+ * `notifyParent` touches. `enqueueMessage` returns not-queued by default so the
+ * persist + runAgentLoop branch runs and the metadata can be asserted; pass
+ * `enqueueQueued: true` to exercise the enqueue branch instead.
+ */
+function mockConversation(opts?: { enqueueQueued?: boolean }) {
+  const enqueueMessage = mock(() => ({
+    queued: opts?.enqueueQueued ?? false,
+    requestId: "req-1",
+    rejected: false,
+  }));
+  const persistUserMessage = mock(async () => ({
+    id: "msg-1",
+    deduplicated: false,
+  }));
+  let resolveLoop!: () => void;
+  const loopRan = new Promise<void>((r) => {
+    resolveLoop = r;
+  });
+  const runAgentLoop = mock(async () => {
+    resolveLoop();
+  });
+  const conversation = {
+    enqueueMessage,
+    persistUserMessage,
+    runAgentLoop,
+  } as unknown as Conversation;
+  return {
+    conversation,
+    enqueueMessage,
+    persistUserMessage,
+    runAgentLoop,
+    loopRan,
+  };
+}
+
+/** Fake AcpAgentProcess covering only the calls firePromptInBackground makes. */
+function fakeProcess(prompt: () => Promise<unknown>) {
+  return {
+    markStderr: () => 0,
+    stderrSince: () => "",
+    prompt,
+    kill: mock(() => {}),
+  };
+}
+
+/** Injects a running session directly into the manager (no child process). */
+function injectSession(
+  manager: AcpSessionManager,
+  acpSessionId: string,
+  parentConversationId: string,
+  process: ReturnType<typeof fakeProcess>,
+) {
+  const sendToVellum = mock(() => {});
+  const clientHandler = new VellumAcpClientHandler(
+    acpSessionId,
+    sendToVellum,
+    parentConversationId,
+  );
+  const entry = {
+    process,
+    state: {
+      id: acpSessionId,
+      agentId: "claude",
+      acpSessionId: "proto-1",
+      parentConversationId,
+      status: "running" as string,
+      startedAt: Date.now(),
+    },
+    clientHandler,
+    sendToVellum,
+    currentPrompt: null as unknown,
+    parentConversationId,
+    cwd: "/tmp",
+    command: "noop",
+  };
+  (manager as any).sessions.set(acpSessionId, entry);
+  return entry;
+}
+
+function fire(
+  manager: AcpSessionManager,
+  acpSessionId: string,
+  entry: ReturnType<typeof injectSession>,
+): Promise<unknown> {
+  const bg = (manager as any).firePromptInBackground(
+    acpSessionId,
+    entry,
+    "proto-1",
+    "do it",
+  );
+  entry.currentPrompt = bg;
+  return bg;
+}
+
+describe("AcpSessionManager parent notification", () => {
+  test("prompt failure notifies the parent once with the failed message + acpNotification metadata", async () => {
+    const manager = new AcpSessionManager(1);
+    const {
+      conversation,
+      enqueueMessage,
+      persistUserMessage,
+      runAgentLoop,
+      loopRan,
+    } = mockConversation();
+    setConversation("parent-fail", conversation);
+    registered.push("parent-fail");
+
+    const proc = fakeProcess(() => Promise.reject(new Error("boom")));
+    const entry = injectSession(manager, "sess-fail", "parent-fail", proc);
+
+    await fire(manager, "sess-fail", entry);
+    await loopRan;
+
+    // Exactly one notification (enqueue returned not-queued, so persist+loop).
+    expect(enqueueMessage).toHaveBeenCalledTimes(1);
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+
+    const persistArg = (
+      persistUserMessage.mock.calls as unknown as Array<
+        [{ content: string; metadata: unknown }]
+      >
+    )[0][0];
+    expect(persistArg.content).toBe('[ACP agent "claude" failed]\n\nboom');
+    expect(persistArg.metadata).toEqual({
+      acpNotification: { acpSessionId: "proto-1", agent: "claude" },
+    });
+
+    // Session was torn down on failure.
+    expect((manager.getStatus() as unknown[]).length).toBe(0);
+    expect(proc.kill).toHaveBeenCalled();
+  });
+
+  test("prompt success still notifies the parent exactly once", async () => {
+    const manager = new AcpSessionManager(1);
+    const {
+      conversation,
+      enqueueMessage,
+      persistUserMessage,
+      runAgentLoop,
+      loopRan,
+    } = mockConversation();
+    setConversation("parent-ok", conversation);
+    registered.push("parent-ok");
+
+    const proc = fakeProcess(() => Promise.resolve({ stopReason: "end_turn" }));
+    const entry = injectSession(manager, "sess-ok", "parent-ok", proc);
+
+    await fire(manager, "sess-ok", entry);
+    await loopRan;
+
+    expect(enqueueMessage).toHaveBeenCalledTimes(1);
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+
+    const persistArg = (
+      persistUserMessage.mock.calls as unknown as Array<
+        [{ content: string; metadata: unknown }]
+      >
+    )[0][0];
+    expect(
+      persistArg.content.startsWith('[ACP agent "claude" completed]'),
+    ).toBe(true);
+    expect(persistArg.metadata).toEqual({
+      acpNotification: { acpSessionId: "proto-1", agent: "claude" },
+    });
+  });
+
+  test("a cancelled session does not notify the parent on failure", async () => {
+    const manager = new AcpSessionManager(1);
+    const { conversation, enqueueMessage } = mockConversation();
+    setConversation("parent-cancel", conversation);
+    registered.push("parent-cancel");
+
+    const proc = fakeProcess(() => Promise.reject(new Error("boom")));
+    const entry = injectSession(manager, "sess-cancel", "parent-cancel", proc);
+    // Simulate a user cancel landing before the rejection settles.
+    entry.state.status = "cancelled";
+
+    await fire(manager, "sess-cancel", entry);
+    // Any notification would have called enqueue synchronously inside the catch.
+    expect(enqueueMessage).not.toHaveBeenCalled();
+  });
+
+  test("a cancelled session does not notify the parent on success", async () => {
+    // A prompt can win the cancel race by resolving normally; a user stop must
+    // still not wake the parent with a completion.
+    const manager = new AcpSessionManager(1);
+    const { conversation, enqueueMessage } = mockConversation();
+    setConversation("parent-cancel-ok", conversation);
+    registered.push("parent-cancel-ok");
+
+    const proc = fakeProcess(() => Promise.resolve({ stopReason: "end_turn" }));
+    const entry = injectSession(
+      manager,
+      "sess-cancel-ok",
+      "parent-cancel-ok",
+      proc,
+    );
+    entry.state.status = "cancelled";
+
+    await fire(manager, "sess-cancel-ok", entry);
+    expect(enqueueMessage).not.toHaveBeenCalled();
+  });
+
+  test("cancel marks the session cancelled before the protocol cancel resolves", async () => {
+    // Guards the cancel race: if the in-flight prompt rejects while
+    // process.cancel is still pending, the failure gate must already see
+    // "cancelled" so it does not wake the parent after a user stop.
+    const manager = new AcpSessionManager(1);
+    let resolveCancel!: () => void;
+    const cancelPending = new Promise<void>((r) => {
+      resolveCancel = r;
+    });
+    const proc = {
+      markStderr: () => 0,
+      stderrSince: () => "",
+      prompt: () => new Promise(() => {}),
+      kill: mock(() => {}),
+      cancel: mock(() => cancelPending),
+    };
+    const entry = injectSession(
+      manager,
+      "sess-race",
+      "parent-race",
+      proc as unknown as ReturnType<typeof fakeProcess>,
+    );
+
+    const cancelPromise = (manager as any).cancel("sess-race");
+    // Synchronously after kicking off cancel — before the protocol cancel
+    // resolves — the status is already "cancelled".
+    expect(entry.state.status).toBe("cancelled");
+    expect(proc.cancel).toHaveBeenCalled();
+
+    resolveCancel();
+    await cancelPromise;
+  });
+
+  test("cancel restores the previous status when the protocol cancel throws", async () => {
+    // If process.cancel rejects, the session was not actually cancelled, so the
+    // status must roll back to running (else the live prompt's eventual settle
+    // is wrongly suppressed) and the error must propagate to the caller.
+    const manager = new AcpSessionManager(1);
+    const proc = {
+      markStderr: () => 0,
+      stderrSince: () => "",
+      prompt: () => new Promise(() => {}),
+      kill: mock(() => {}),
+      cancel: mock(() => Promise.reject(new Error("adapter down"))),
+    };
+    const entry = injectSession(
+      manager,
+      "sess-cancel-throw",
+      "parent-cancel-throw",
+      proc as unknown as ReturnType<typeof fakeProcess>,
+    );
+    // A prompt is still in flight; cancel must not tear it down on failure.
+    entry.currentPrompt = new Promise(() => {});
+
+    await expect((manager as any).cancel("sess-cancel-throw")).rejects.toThrow(
+      "adapter down",
+    );
+    expect(entry.state.status).toBe("running");
+  });
+
+  test("a superseded prompt does not notify the parent", async () => {
+    const manager = new AcpSessionManager(1);
+    const { conversation, enqueueMessage } = mockConversation();
+    setConversation("parent-stale", conversation);
+    registered.push("parent-stale");
+
+    const proc = fakeProcess(() => Promise.reject(new Error("boom")));
+    const entry = injectSession(manager, "sess-stale", "parent-stale", proc);
+
+    const bg = (manager as any).firePromptInBackground(
+      entry.state.id,
+      entry,
+      "proto-1",
+      "do it",
+    );
+    // A concurrent steer superseded this prompt: currentPrompt no longer
+    // points at it, so the whole catch body (including notify) is skipped.
+    entry.currentPrompt = null;
+    await bg;
+
+    expect(enqueueMessage).not.toHaveBeenCalled();
+    // The stale catch left the session in place (no teardown).
+    expect((manager.getStatus() as unknown[]).length).toBe(1);
+  });
+});

package/src/acp/session-manager.ts

@@ -18,6 +18,7 @@ import { getLogger } from "../util/logger.js";
 import { AcpAgentProcess } from "./agent-process.js";
 import { resolveAgentWithAutoInstall } from "./auto-install.js";
 import { VellumAcpClientHandler } from "./client-handler.js";
+import { deriveFailureError } from "./failure-error.js";
 import { prepareAgentEnv } from "./prepare-agent-env.js";
 import { formatResolveFailure } from "./resolve-agent.js";
 import { claudeResumeHint } from "./resume-hint.js";
@@ -739,9 +740,28 @@ export class AcpSessionManager {
     if (!entry) {
       throw new AcpSessionNotFoundError(acpSessionId);
     }
-    await entry.process.cancel(entry.state.acpSessionId);
+    // Mark cancelled BEFORE awaiting the protocol cancel. If the in-flight
+    // prompt rejects during this window, its catch handler must already see
+    // "cancelled" so it neither overwrites the status with "failed" nor wakes
+    // the parent — no model activity may follow a user stop.
+    const prevStatus = entry.state.status;
+    const prevCompletedAt = entry.state.completedAt;
     entry.state.status = "cancelled";
     entry.state.completedAt = Date.now();
+    try {
+      await entry.process.cancel(entry.state.acpSessionId);
+    } catch (err) {
+      // The protocol cancel failed (e.g. the adapter connection is already
+      // down): the session was NOT actually cancelled, so restore the prior
+      // status. Otherwise the still-running prompt's eventual completion would
+      // be wrongly suppressed and persisted as cancelled. Rethrow so the caller
+      // reports failure and the client rolls back its optimistic cancel.
+      if (this.sessions.get(acpSessionId) === entry) {
+        entry.state.status = prevStatus;
+        entry.state.completedAt = prevCompletedAt;
+      }
+      throw err;
+    }
     // Re-check the map after the await: the in-flight prompt's handler may
     // have already torn the session down while process.cancel was pending.
     if (!entry.currentPrompt && this.sessions.get(acpSessionId) === entry) {
@@ -963,6 +983,10 @@ export class AcpSessionManager {
     message: string,
   ): Promise<unknown> {
     log.info({ acpSessionId, messageLen: message.length }, "ACP firing prompt");
+    // Checkpoint stderr before the prompt so a failure derives only from stderr
+    // this prompt produced — not lines retained from startup, resume, or an
+    // earlier (possibly cancelled) prompt.
+    const stderrMark = entry.process.markStderr();
     const promptPromise = entry.process
       .prompt(acpProtocolSessionId, message)
       .then((response) => {
@@ -1023,55 +1047,22 @@ export class AcpSessionManager {
           // kill the agent process.
           this.teardownSession(acpSessionId, current);
 
-          // Notify parent session so the LLM sees the agent's output
+          // Notify parent session so the LLM sees the agent's output.
           const agentLabel = current.state.agentId;
           const responseText = current.clientHandler.responseText;
-          const sessionId = current.state.acpSessionId;
           const hint = claudeResumeHint(
             current.command,
             current.cwd,
-            sessionId,
+            current.state.acpSessionId,
           );
           const resumeHint = hint ? `\n\n${hint}` : "";
-          const notifyMessage = `[ACP agent "${agentLabel}" completed]\n\n${responseText}${resumeHint}`;
-          // Tag the injected message so the daemon skips its user_message_echo
-          // and the client filters it from the rendered transcript — the user
-          // sees the run through its inline card, not a chat turn.
-          const acpNotification = {
-            acpSessionId: sessionId,
-            agent: agentLabel,
-          };
-          const parentConversation = findConversation(
-            current.parentConversationId,
-          );
-          if (parentConversation) {
-            const enqueueResult = parentConversation.enqueueMessage({
-              content: notifyMessage,
-              metadata: { acpNotification },
-            });
-            if (!enqueueResult.queued && !enqueueResult.rejected) {
-              parentConversation
-                .persistUserMessage({
-                  content: notifyMessage,
-                  metadata: { acpNotification },
-                })
-                .then(({ id: messageId }) =>
-                  parentConversation.runAgentLoop(notifyMessage, messageId),
-                )
-                .catch((err) => {
-                  log.error(
-                    {
-                      parentConversationId: current.parentConversationId,
-                      err,
-                    },
-                    "Failed to process ACP notification in parent",
-                  );
-                });
-            }
-          } else {
-            log.warn(
-              { parentConversationId: current.parentConversationId },
-              "ACP agent finished but parent conversation not found",
+          // Skip when cancelled: a prompt can win the cancel race by resolving
+          // normally, but a user stop must not enqueue a completion and wake the
+          // parent (mirrors the failure-path gate below).
+          if (current.state.status !== "cancelled") {
+            this.notifyParent(
+              current,
+              `[ACP agent "${agentLabel}" completed]\n\n${responseText}${resumeHint}`,
             );
           }
         }
@@ -1081,17 +1072,26 @@ export class AcpSessionManager {
         // Same guards: entry must exist, prompt must be current, and status
         // must not have been set to "cancelled".
         if (current && current.currentPrompt === promptPromise) {
+          // The ack message is often a generic "Internal error"; recover the
+          // real cause from the adapter's retained stderr.
+          const failureMessage = deriveFailureError(
+            err.message,
+            current.process.stderrSince(stderrMark),
+          );
           if (current.state.status !== "cancelled") {
             current.state.status = "failed";
             current.state.completedAt = Date.now();
-            current.state.error = err.message;
+            current.state.error = failureMessage;
           }
           current.currentPrompt = null;
-          log.error({ acpSessionId, error: err.message }, "ACP prompt failed");
+          log.error(
+            { acpSessionId, error: err.message, failureMessage },
+            "ACP prompt failed",
+          );
           current.sendToVellum({
             type: "acp_session_error",
             acpSessionId,
-            error: err.message,
+            error: failureMessage,
           });
 
           // Persist the terminal row before teardown clears the buffer.
@@ -1099,12 +1099,68 @@ export class AcpSessionManager {
 
           // Free the session slot and deny any pending permissions.
           this.teardownSession(acpSessionId, current);
+
+          // Wake the parent with the failure (mirrors the success path) so
+          // the assistant reports it instead of silently re-spawning. Skip
+          // when cancelled: a user-cancelled run tears down silently and must
+          // not inject a turn. teardownSession leaves state intact, so the
+          // agentId read below is still valid.
+          if (current.state.status !== "cancelled") {
+            this.notifyParent(
+              current,
+              `[ACP agent "${current.state.agentId}" failed]\n\n${failureMessage}`,
+            );
+          }
         }
       });
 
     return promptPromise;
   }
 
+  /**
+   * Injects an ACP run's outcome into its parent conversation. Shared by the
+   * success and failure paths of firePromptInBackground so a hard failure
+   * reaches the parent (and its inline card) exactly like a completion does.
+   *
+   * The message carries `acpNotification` metadata so the daemon skips its
+   * user_message_echo and the client filters it from the rendered transcript —
+   * the user sees the run through its inline card, not a raw chat turn, while
+   * the LLM still receives the text.
+   *
+   * Reads `entry.state.acpSessionId`/`agentId`, which teardownSession leaves
+   * intact, so callers may invoke this after tearing the session down.
+   */
+  private notifyParent(entry: SessionEntry, message: string): void {
+    const acpNotification = {
+      acpSessionId: entry.state.acpSessionId,
+      agent: entry.state.agentId,
+    };
+    const parentConversation = findConversation(entry.parentConversationId);
+    if (!parentConversation) {
+      log.warn(
+        { parentConversationId: entry.parentConversationId },
+        "ACP agent finished but parent conversation not found",
+      );
+      return;
+    }
+    const enqueueResult = parentConversation.enqueueMessage({
+      content: message,
+      metadata: { acpNotification },
+    });
+    if (enqueueResult.queued || enqueueResult.rejected) return;
+    parentConversation
+      .persistUserMessage({ content: message, metadata: { acpNotification } })
+      .then(({ id: messageId }) =>
+        parentConversation.runAgentLoop(message, messageId),
+      )
+      .catch((err) => {
+        log.error(
+          { parentConversationId: entry.parentConversationId, err },
+          "Failed to process ACP notification in parent",
+        );
+      });
+  }
+
   /**
    * Kills all processes on shutdown. Also flags the manager as disposed so
    * resumes that are mid-await when shutdown happens abort before spawning

package/src/agent/ax-tree-compaction.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
+import {
+  compactAxTreeHistory,
+  escapeAxTreeContent,
+} from "../context/outbound-sanitize.js";
 import type { Message } from "../providers/types.js";
-import { compactAxTreeHistory, escapeAxTreeContent } from "./loop.js";
 
 // ---------------------------------------------------------------------------
 // Helpers