@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/credential-execution/process-manager.test.ts

@@ -125,3 +125,102 @@ describe("CesProcessManager.onTransportClose", () => {
     await pm.stop();
   });
 });
+
+// ---------------------------------------------------------------------------
+// Transport-death logging: WARN only for genuinely-unexpected death
+// ---------------------------------------------------------------------------
+
+type LogCall = { level: string; msg: string };
+
+function makeRecordingLogger(): {
+  calls: LogCall[];
+  logger: NonNullable<Parameters<typeof createCesProcessManager>[0]["logger"]>;
+} {
+  const calls: LogCall[] = [];
+  const rec =
+    (level: string) =>
+    (...args: unknown[]) => {
+      const msg = typeof args[0] === "string" ? args[0] : args[1];
+      calls.push({ level, msg: typeof msg === "string" ? msg : "" });
+    };
+  const logger = {
+    info: rec("info"),
+    warn: rec("warn"),
+    debug: rec("debug"),
+    error: rec("error"),
+  } as unknown as NonNullable<
+    Parameters<typeof createCesProcessManager>[0]["logger"]
+  >;
+  return { calls, logger };
+}
+
+describe("CesProcessManager transport-death logging", () => {
+  let tempDir: string;
+  let server: Server;
+  let connections: Array<import("node:net").Socket>;
+
+  beforeEach(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), "ces-pm-log-test-"));
+    mockSocketPath = join(tempDir, "ces.sock");
+    connections = [];
+    server = createServer((socket) => {
+      connections.push(socket);
+      socket.on("error", () => {});
+    });
+    await new Promise<void>((resolve) =>
+      server.listen(mockSocketPath, resolve),
+    );
+  });
+
+  afterEach(async () => {
+    for (const sock of connections) {
+      sock.destroy();
+    }
+    connections = [];
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("logs WARN when the transport dies unexpectedly (remote close)", async () => {
+    const { calls, logger } = makeRecordingLogger();
+    const pm = createCesProcessManager({ logger });
+    const transport = await pm.start();
+
+    // The remote (server) closes the connection: genuinely-unexpected death.
+    for (const sock of connections) {
+      sock.destroy();
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(transport.isAlive()).toBe(false);
+
+    expect(
+      calls.some(
+        (c) => c.level === "warn" && c.msg.includes("died unexpectedly"),
+      ),
+    ).toBe(true);
+
+    await pm.stop();
+  });
+
+  test("does not log WARN on an intentional stop()", async () => {
+    const { calls, logger } = makeRecordingLogger();
+    const pm = createCesProcessManager({ logger });
+    await pm.start();
+
+    await pm.stop();
+    // Let the socket close event propagate after destroy().
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(
+      calls.some(
+        (c) => c.level === "warn" && c.msg.includes("died unexpectedly"),
+      ),
+    ).toBe(false);
+    expect(
+      calls.some(
+        (c) =>
+          c.level === "debug" && c.msg.includes("CES socket transport closed"),
+      ),
+    ).toBe(true);
+  });
+});

package/src/credential-execution/process-manager.ts

@@ -29,6 +29,8 @@ import {
 
 const log = getLogger("ces-process-manager");
 
+type PmLogger = ReturnType<typeof getLogger>;
+
 const SOCKET_CONNECT_TIMEOUT_MS = 5_000;
 
 // ---------------------------------------------------------------------------
@@ -57,6 +59,9 @@ export interface CesProcessManagerConfig {
    * Reserved for future feature-flag checks or config-driven behavior.
    */
   assistantConfig?: AssistantConfig;
+
+  /** Logger override. Defaults to the module logger; injected in tests. */
+  logger?: PmLogger;
 }
 
 // ---------------------------------------------------------------------------
@@ -99,12 +104,13 @@ export interface CesProcessManager {
 // ---------------------------------------------------------------------------
 
 export function createCesProcessManager(
-  _config: CesProcessManagerConfig,
+  config: CesProcessManagerConfig,
 ): CesProcessManager {
+  const pmLog = config.logger ?? log;
   let managedSocket: Socket | null = null;
   let discoveryResult: DiscoveryResult | null = null;
   let running = false;
-  let currentTransport: CesTransport | null = null;
+  let currentTransport: SocketTransport | null = null;
   const transportCloseHandlers: Array<() => void> = [];
 
   return {
@@ -136,24 +142,28 @@ export function createCesProcessManager(
       }
 
       if (managedSocket) {
+        // Mark the close as intentional so the transport-death log is debug,
+        // not a misleading WARN, on routine shutdown/reconnect.
+        currentTransport?.markClosing();
         managedSocket.destroy();
         managedSocket = null;
       }
 
       currentTransport = null;
       running = false;
-      log.info("CES process manager stopped");
+      pmLog.info("CES process manager stopped");
     },
 
     async forceStop(): Promise<void> {
       if (managedSocket) {
+        currentTransport?.markClosing();
         managedSocket.destroy();
         managedSocket = null;
       }
 
       currentTransport = null;
       running = false;
-      log.info("CES process manager force-stopped");
+      pmLog.info("CES process manager force-stopped");
     },
 
     getDiscoveryResult(): DiscoveryResult | null {
@@ -195,8 +205,8 @@ export function createCesProcessManager(
 
   async function connectManagedSocket(
     discovery: ManagedDiscoverySuccess | SiblingDiscoverySuccess,
-  ): Promise<CesTransport> {
-    log.info(
+  ): Promise<SocketTransport> {
+    pmLog.info(
       { socketPath: discovery.socketPath, mode: discovery.mode },
       "Connecting to CES over socket",
     );
@@ -207,9 +217,14 @@ export function createCesProcessManager(
     );
     managedSocket = socket;
 
-    log.info("Connected to CES over socket");
+    pmLog.info("Connected to CES over socket");
 
-    return createSocketTransport(socket);
+    // Assign currentTransport synchronously here (no await between socket
+    // assignment and this line) so stop()/forceStop() can always mark an
+    // intentional close, even if they race the connect.
+    const transport = createSocketTransport(socket, pmLog);
+    currentTransport = transport;
+    return transport;
   }
 }
 
@@ -221,23 +236,43 @@ export function createCesProcessManager(
  * Tracks the transport `alive` state and notifies registered handlers exactly
  * once when the transport dies, so the RPC client can fail-fast any in-flight
  * calls instead of waiting out their timeouts.
+ *
+ * `markClosing()` records that an imminent close was initiated by us (shutdown,
+ * reconnect, handshake rejection). A close so marked logs at debug; an
+ * unmarked death (remote socket close, socket error) logs at WARN.
  */
-function createCloseNotifier(): {
+function createCloseNotifier(log: PmLogger): {
   isAlive: () => boolean;
-  markDead: () => void;
+  markClosing: () => void;
+  markDead: (reason?: string) => void;
   onClose: (handler: () => void) => void;
 } {
   let alive = true;
   let notified = false;
+  let intentional = false;
   const handlers: Array<() => void> = [];
   return {
     isAlive: () => alive,
-    markDead() {
+    markClosing() {
+      intentional = true;
+    },
+    markDead(reason?: string) {
       alive = false;
       if (notified) {
         return;
       }
       notified = true;
+      if (intentional) {
+        log.debug(
+          { reason: reason ?? "intentional" },
+          "CES socket transport closed",
+        );
+      } else {
+        log.warn(
+          { reason: reason ?? "unknown" },
+          "CES socket transport died unexpectedly; credential ops will fail over or reconnect",
+        );
+      }
       for (const handler of handlers) {
         try {
           handler();
@@ -256,10 +291,18 @@ function createCloseNotifier(): {
 // Socket transport (managed mode)
 // ---------------------------------------------------------------------------
 
-function createSocketTransport(socket: Socket): CesTransport {
+/**
+ * A CesTransport plus `markClosing()`, which the process manager calls before
+ * an intentional socket destroy so the ensuing close logs at debug, not WARN.
+ */
+interface SocketTransport extends CesTransport {
+  markClosing(): void;
+}
+
+function createSocketTransport(socket: Socket, log: PmLogger): SocketTransport {
   const messageHandlers: Array<(message: string) => void> = [];
   let buffer = "";
-  const death = createCloseNotifier();
+  const death = createCloseNotifier(log);
 
   const decoder = new StringDecoder("utf8");
 
@@ -278,12 +321,12 @@ function createSocketTransport(socket: Socket): CesTransport {
   });
 
   socket.on("close", () => {
-    death.markDead();
+    death.markDead("socket closed");
   });
 
   socket.on("error", (err) => {
     log.warn({ err }, "CES socket transport error");
-    death.markDead();
+    death.markDead("socket error");
   });
 
   return {
@@ -304,8 +347,11 @@ function createSocketTransport(socket: Socket): CesTransport {
 
     onClose: death.onClose,
 
+    markClosing: death.markClosing,
+
     close(): void {
-      death.markDead();
+      death.markClosing();
+      death.markDead("transport.close() called");
       socket.destroy();
     },
   };

package/src/daemon/__tests__/abort-null-controller.test.ts

@@ -37,25 +37,41 @@ mock.module("../../messaging/providers/telegram-bot/render.js", () => ({
 }));
 
 const { abortConversation } = await import("../conversation-lifecycle.js");
+import { createAbortReason } from "../../util/abort-reasons.js";
 import type { AbortContext } from "../conversation-lifecycle.js";
 
+interface QueuedEvent {
+  type: string;
+  requestId?: string;
+}
+
 interface Harness {
   ctx: AbortContext;
   setProcessingCalls: boolean[];
   prompterDisposed: () => boolean;
   secretPrompterDisposed: () => boolean;
   queueClearedCount: () => number;
+  queuedEvents: QueuedEvent[];
+  drainKicks: string[];
 }
 
 function makeContext(opts: {
   processing: boolean;
   controller: AbortController | null;
+  /** requestIds of messages sitting in the queue behind the aborted turn. */
+  queued?: string[];
 }): Harness {
   let processing = opts.processing;
   const setProcessingCalls: boolean[] = [];
   let prompterDisposed = false;
   let secretPrompterDisposed = false;
   let queueCleared = 0;
+  const queuedEvents: QueuedEvent[] = [];
+  const drainKicks: string[] = [];
+  let queuedItems = (opts.queued ?? []).map((requestId) => ({
+    requestId,
+    onEvent: (event: QueuedEvent) => queuedEvents.push(event),
+  }));
 
   const ctx = {
     conversationId: "abort-null-controller-test",
@@ -82,10 +98,19 @@ function makeContext(opts: {
     queue: {
       clear: () => {
         queueCleared += 1;
+        queuedItems = [];
+      },
+      get isEmpty() {
+        return queuedItems.length === 0;
       },
-      [Symbol.iterator]: function* () {
-        // no queued messages
+      get length() {
+        return queuedItems.length;
       },
+      [Symbol.iterator]: () => queuedItems[Symbol.iterator](),
+    },
+    pendingInterruptRepair: false,
+    kickDrainQueue: async (_reason?: string, origin?: string) => {
+      drainKicks.push(origin ?? "");
     },
   } as unknown as AbortContext;
 
@@ -95,6 +120,8 @@ function makeContext(opts: {
     prompterDisposed: () => prompterDisposed,
     secretPrompterDisposed: () => secretPrompterDisposed,
     queueClearedCount: () => queueCleared,
+    queuedEvents,
+    drainKicks,
   };
 }
 
@@ -152,6 +179,114 @@ describe("abortConversation", () => {
     );
   });
 
+  test("a user interrupt leaves queued messages for the stopped turn's drain", () => {
+    // GIVEN a live turn with two messages queued behind it
+    const controller = new AbortController();
+    const h = makeContext({
+      processing: true,
+      controller,
+      queued: ["req-a", "req-b"],
+    });
+
+    // WHEN the user stops the turn
+    abortConversation(
+      h.ctx,
+      createAbortReason("user_cancel", "test", "abort-null-controller-test"),
+    );
+
+    // THEN the queue is untouched, so the agent loop's `finally` drains it and
+    // the queued messages are sent rather than silently dropped
+    expect(h.queueClearedCount()).toBe(0);
+    expect(h.ctx.queue.length).toBe(2);
+    expect(h.queuedEvents).toEqual([]);
+    // AND the drain is left to that `finally`, not kicked from here
+    expect(h.drainKicks).toEqual([]);
+    // AND the drain is told to repair tool_use blocks the killed turn abandoned
+    expect(h.ctx.pendingInterruptRepair).toBe(true);
+  });
+
+  test("a user interrupt with no live turn kicks the drain itself", () => {
+    // GIVEN a conversation flagged processing with no controller left to
+    // signal, so no agent-loop `finally` is coming to drain the preserved queue
+    const h = makeContext({
+      processing: true,
+      controller: null,
+      queued: ["req-a"],
+    });
+
+    // WHEN the user stops it
+    abortConversation(
+      h.ctx,
+      createAbortReason("user_cancel", "test", "abort-null-controller-test"),
+    );
+
+    // THEN the queued message is still sent, because the abort kicks the drain
+    expect(h.ctx.queue.length).toBe(1);
+    expect(h.drainKicks).toEqual(["abortConversation:no_live_turn"]);
+  });
+
+  test("a non-interrupt abort discards the queue and closes out each row", () => {
+    // GIVEN a live turn with a queued message, torn down by a dispose
+    const controller = new AbortController();
+    const h = makeContext({
+      processing: true,
+      controller,
+      queued: ["req-a"],
+    });
+
+    // WHEN the conversation is disposed rather than interrupted
+    abortConversation(
+      h.ctx,
+      createAbortReason(
+        "conversation_disposed",
+        "test",
+        "abort-null-controller-test",
+      ),
+    );
+
+    // THEN the queue is dropped, since no turn is left for it to run on, and
+    // the sender gets the terminal event that closes the queued row, so no
+    // client is left holding a pending indicator nothing will ever settle
+    expect(h.queueClearedCount()).toBe(1);
+    expect(h.queuedEvents.map((e) => e.type)).toEqual([
+      "generation_cancelled",
+      "message_queued_deleted",
+    ]);
+    expect(h.queuedEvents[1].requestId).toBe("req-a");
+    expect(h.ctx.pendingInterruptRepair).toBe(false);
+  });
+
+  test("a teardown abort discards the queue even when the flag reads idle", () => {
+    // GIVEN a conversation whose turn already cleared the processing flag but
+    // is still unwinding: the agent-loop `finally` clears the flag, then awaits
+    // the turn-boundary commit before its `kickDrainQueue`. A dispose landing
+    // in that window sees an idle conversation with a populated queue.
+    const h = makeContext({
+      processing: false,
+      controller: null,
+      queued: ["req-a"],
+    });
+
+    // WHEN the conversation is disposed
+    abortConversation(
+      h.ctx,
+      createAbortReason(
+        "conversation_disposed",
+        "test",
+        "abort-null-controller-test",
+      ),
+    );
+
+    // THEN the queue goes with it, so the pending `kickDrainQueue` finds
+    // nothing to run against the disposed conversation, and the queued row
+    // still gets its terminal event
+    expect(h.ctx.queue.length).toBe(0);
+    expect(h.queuedEvents.map((e) => e.type)).toEqual([
+      "generation_cancelled",
+      "message_queued_deleted",
+    ]);
+  });
+
   test("clears the persisted flag when in-memory reads idle (cancel with no live abort)", () => {
     // GIVEN a conversation whose in-memory flag reads idle — e.g. reloaded
     // after its owning turn was interrupted out-of-process, so a persisted
@@ -166,9 +301,10 @@ describe("abortConversation", () => {
     // persisted column, so the row is unwedged for cold readers and the next
     // reload — cancel is not a silent no-op.
     expect(h.setProcessingCalls).toEqual([false]);
-    // AND the live-turn teardown (prompters, queue) is left alone: there was no
-    // live turn holding them.
+    // AND the live-turn teardown (prompters, surfaces) is left alone: there was
+    // no live turn holding them. The queue is the exception, discarded on any
+    // non-interrupt abort regardless of the flag.
     expect(h.prompterDisposed()).toBe(false);
-    expect(h.queueClearedCount()).toBe(0);
+    expect(h.ctx.queue.length).toBe(0);
   });
 });

package/src/daemon/__tests__/conversation-surfaces-launch.test.ts

@@ -23,6 +23,8 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { asConversation } from "../../__tests__/helpers/mock-conversation.js";
+
 // ── Module-level mocks ─────────────────────────────────────────────
 
 // Hub publish capture — used by the single-emit assertions. We spread
@@ -123,8 +125,7 @@ mock.module("../process-message.js", () => ({
 // before the modules under test are loaded.
 const { createSurfaceMutex, handleSurfaceAction } =
   await import("../conversation-surfaces.js");
-type SurfaceConversationContext =
-  import("../conversation-surfaces.js").SurfaceConversationContext;
+type Conversation = import("../../daemon/conversation.js").Conversation;
 type TrustContext = import("../trust-context-types.js").TrustContext;
 type AssistantEvent = import("../../api/index.js").AssistantEvent;
 type SurfaceType = import("../message-protocol.js").SurfaceType;
@@ -144,20 +145,18 @@ function resetProcessHarness(): void {
 
 // ── Surface-context harness ────────────────────────────────────────
 
-interface HarnessContext extends SurfaceConversationContext {
+interface HarnessContext extends Conversation {
   sent: AssistantEvent[];
   enqueueCalls: Array<{ content: string }>;
   processCalls: Array<{ content: string }>;
 }
 
-function makeContext(
-  overrides?: Partial<SurfaceConversationContext>,
-): HarnessContext {
+function makeContext(overrides?: Partial<Conversation>): HarnessContext {
   const sent: AssistantEvent[] = [];
   const enqueueCalls: Array<{ content: string }> = [];
   const processCalls: Array<{ content: string }> = [];
 
-  const base: SurfaceConversationContext = {
+  const base = asConversation({
     conversationId: "origin-conv-id",
     sendToClient: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -182,7 +181,7 @@ function makeContext(
     },
     withSurface: createSurfaceMutex(),
     ...overrides,
-  };
+  });
 
   return Object.assign(base, {
     sent,
@@ -196,10 +195,7 @@ function makeContext(
  * surfaces (no `pendingSurfaceActions` entry) — matching how the card
  * actually reaches `handleSurfaceAction` after reconstruction.
  */
-function registerCardSurface(
-  ctx: SurfaceConversationContext,
-  surfaceId: string,
-): void {
+function registerCardSurface(ctx: Conversation, surfaceId: string): void {
   ctx.surfaceState.set(surfaceId, {
     surfaceType: "card",
     data: { title: "Launch" },