@vellumai/assistant 0.9.0-dev.202606181324.0804a69 → 0.9.0-dev.202606181513.fd39213

package/node_modules/@vellumai/gateway-client/src/admission-policy-contract.ts

@@ -53,20 +53,15 @@ export const ADMISSION_FLOOR: Record<AdmissionPolicy, number> = {
  *
  * `platform` / `a2a` are peer/internal channels with no human-trust model.
  *
- * NOTE: `phone` is exempt because the Twilio voice-webhook path
- * (twilio-voice-webhook → relay-setup-router) does not yet read
- * AdmissionPolicyStore / sourceMetadata.admissionPolicy. Storing a policy for
- * `phone` would have no runtime effect, so we exclude it from the API surface
- * until voice ingress is wired in a follow-up PR. Remove `"phone"` from this
- * set once the voice path enforces admission.
+ * `phone` is NOT exempt — voice ingress enforces the admission floor.
  *
- * `vellum` is NOT exempt — its floor is still enforced at runtime — but it is
- * hidden from the configurable UI; see {@link ADMISSION_POLICY_HIDDEN_CHANNELS}.
+ * `vellum` / `whatsapp` are NOT exempt — their floors are still enforced at
+ * runtime — but they are hidden from the configurable UI; see
+ * {@link ADMISSION_POLICY_HIDDEN_CHANNELS}.
  */
 export const ADMISSION_POLICY_EXEMPT_CHANNELS: ReadonlySet<string> = new Set([
   "platform",
   "a2a",
-  "phone",
 ]);
 
 export function isAdmissionPolicyExemptChannel(channelType: string): boolean {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.9.0-dev.202606181324.0804a69",
+  "version": "0.9.0-dev.202606181513.fd39213",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/cancel-clears-processing.test.ts

@@ -1,10 +1,14 @@
 /**
- * Regression test for the stuck "Thinking…" bug: a user cancel must drive the
- * conversation's processing flag to false even when the in-flight turn never
- * observes the AbortController signal (a wedged agent loop that never reaches
- * its `finally`). The processing flag is the authoritative source for the
- * client thinking indicator, so a latched-true flag pins every client on
- * "Thinking…" indefinitely.
+ * Cancel contract: a user cancel raises the conversation's AbortController and
+ * defers clearing the `processing` flag to the in-flight turn's `finally`.
+ *
+ * `cancelGeneration` no longer force-clears `processing` itself. Abort now
+ * propagates into the provider call and tool execution — and is backed by the
+ * agent loop's abort watchdog — so a cancelled turn always reaches its
+ * `finally` within a bounded time and tears down its own state there. The
+ * watchdog-driven path (turn reaches `finally`, processing clears) is covered
+ * by `conversation-agent-loop.test.ts`; this file pins the handler-side
+ * contract: cancel signals abort and leaves the flag to the turn.
  */
 import { afterEach, describe, expect, test } from "bun:test";
 
@@ -15,18 +19,18 @@ import {
 } from "../daemon/conversation-registry.js";
 import { cancelGeneration } from "../daemon/handlers/conversations.js";
 
-interface WedgedTurnConversation {
+interface CancelledConversation {
   isProcessing: () => boolean;
   setProcessingCalls: () => boolean[];
   abortCount: () => number;
 }
 
 /**
- * Register a conversation whose in-flight turn is wedged: it accepts the abort
- * signal but never unwinds, so it leaves the processing flag untouched. This
- * is the exact condition that latches `processing` true in production.
+ * Register a conversation whose in-flight turn is processing. The fake records
+ * abort calls and any `setProcessing` writes so the test can assert that
+ * `cancelGeneration` signals abort without flipping the flag itself.
  */
-function registerWedgedTurn(id: string): WedgedTurnConversation {
+function registerProcessingTurn(id: string): CancelledConversation {
   let processing = true;
   let abortCount = 0;
   const setProcessingCalls: boolean[] = [];
@@ -55,10 +59,9 @@ describe("cancelGeneration", () => {
     deleteConversation(conversationId);
   });
 
-  test("clears the processing flag when the in-flight turn ignores the abort signal", () => {
+  test("raises abort and defers clearing processing to the turn's finally", () => {
     // GIVEN a registered conversation that is processing
-    // AND whose in-flight turn ignores the abort signal (never clears processing)
-    const fake = registerWedgedTurn(conversationId);
+    const fake = registerProcessingTurn(conversationId);
     expect(fake.isProcessing()).toBe(true);
 
     // WHEN the user cancels generation
@@ -66,12 +69,12 @@ describe("cancelGeneration", () => {
 
     // THEN the cancel is acknowledged
     expect(cancelled).toBe(true);
-    // AND the abort signal is still raised on the conversation
+    // AND the abort signal is raised on the conversation
     expect(fake.abortCount()).toBe(1);
-    // AND the processing flag is cleared through setProcessing(false), which
-    // publishes the metadata sync invalidation that unblocks every client
-    expect(fake.setProcessingCalls()).toContain(false);
-    expect(fake.isProcessing()).toBe(false);
+    // AND cancelGeneration does NOT force-clear the flag itself — the in-flight
+    // turn's `finally` owns that teardown once abort drives it there.
+    expect(fake.setProcessingCalls()).not.toContain(false);
+    expect(fake.isProcessing()).toBe(true);
   });
 
   test("returns false for a conversation that is not registered", () => {

package/src/__tests__/conversation-agent-loop.test.ts

@@ -1749,55 +1749,62 @@ describe("session-agent-loop", () => {
       expect(drainReason).toBe("loop_complete");
     });
 
-    test("leaves a newer turn's state intact when superseded during unwind", async () => {
-      // GIVEN a fresh AbortController and request id that a newer turn installs
-      // (as persistUserMessage would once a user cancel released `processing`)
-      const newerTurnController = new AbortController();
-      let drained = false;
-
-      // AND a provider that, on this turn's single model call, simulates that
-      // newer turn taking ownership of the conversation before this turn
-      // reaches its finally
-      const ctxHolder: { conversation?: Conversation } = {};
+    test("abort watchdog drives a wedged turn to its finally", async () => {
+      // GIVEN a provider whose call wedges: it acknowledges the user cancel
+      // (aborts the signal) but its promise never settles and never observes
+      // the signal — the exact condition that latched `processing` true.
+      const events: ServerMessage[] = [];
+      const abortController = new AbortController();
+      let drainReason: string | undefined;
+      // The provider's call wedges on this promise. It settles only on test
+      // teardown so the abandoned `run()` can unwind cleanly instead of leaking
+      // background work (e.g. partial-persist debounce timers) into later tests.
+      let releaseHang: (reason: unknown) => void = () => {};
+      const hang = new Promise<never>((_, reject) => {
+        releaseHang = reject;
+      });
       const provider: Provider = {
         name: "mock-provider",
-        async sendMessage(_messages, options) {
-          const conversation = ctxHolder.conversation;
-          if (conversation) {
-            conversation.abortController = newerTurnController;
-            conversation.setProcessing(true);
-            conversation.currentRequestId = "newer-turn-req";
-          }
-          options?.onEvent?.({ type: "text_delta", text: "done" });
-          return {
-            content: [{ type: "text", text: "done" }],
-            model: "mock-model",
-            usage: { inputTokens: 0, outputTokens: 0 },
-            stopReason: "end_turn",
-          };
+        sendMessage(_messages, _options) {
+          abortController.abort();
+          // Never observes the signal — the exact condition that latched
+          // `processing` true before the watchdog existed.
+          return hang;
         },
       };
       const ctx = makeCtx({
         loopProvider: provider,
-        drainQueue: async () => {
-          drained = true;
+        abortController,
+        // Fire the watchdog quickly instead of the ~45s production default.
+        abortWatchdogMs: 30,
+        drainQueue: (reason: string) => {
+          drainReason = reason;
         },
-      });
-      ctxHolder.conversation = ctx;
-
-      // WHEN the superseded turn runs to completion
-      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+      } as unknown as Partial<Conversation>);
 
-      // THEN the finally leaves the newer turn's per-turn state intact so it
-      // stays cancellable and visible
-      expect(ctx.abortController).toBe(newerTurnController);
-      expect(ctx.isProcessing()).toBe(true);
-      expect(ctx.currentRequestId).toBe("newer-turn-req");
-      // AND it does not drain the newer turn's queue out from under it
-      expect(drained).toBe(false);
-      // AND this turn's own finalization that does not touch shared state still
-      // runs (the turn is still counted)
-      expect(ctx.turnCount).toBe(1);
+      try {
+        // WHEN the orchestrator runs the turn
+        await runAgentLoopImpl(ctx, "hi", "msg-1", (msg) => events.push(msg));
+
+        // THEN the watchdog forces the turn to its finally: processing clears,
+        // the abort controller is torn down, the queue drains, and the user
+        // sees a cancellation (not an error).
+        expect(ctx.isProcessing()).toBe(false);
+        expect(ctx.abortController).toBeNull();
+        expect(drainReason).toBe("loop_complete");
+        expect(
+          events.find((e) => e.type === "generation_cancelled"),
+        ).toBeDefined();
+        expect(
+          events.find((e) => e.type === "conversation_error"),
+        ).toBeUndefined();
+      } finally {
+        // Let the abandoned run() reject and unwind, then flush microtasks.
+        releaseHang(
+          new DOMException("The operation was aborted", "AbortError"),
+        );
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
     });
   });