@vellumai/assistant 0.9.0-dev.202606171417.d2192ab → 0.9.0-dev.202606171903.06eea08

package/openapi.yaml

@@ -17692,6 +17692,7 @@ paths:
               properties:
                 deliveryId:
                   type: string
+                  minLength: 1
                   description: Notification delivery ID
                 success:
                   type: boolean
@@ -17769,9 +17770,100 @@ paths:
                     type: boolean
                   feedItem:
                     type: object
-                    propertyNames:
-                      type: string
-                    additionalProperties: {}
+                    properties:
+                      id:
+                        type: string
+                      type:
+                        type: string
+                        const: notification
+                      priority:
+                        type: integer
+                        minimum: 0
+                        maximum: 100
+                      title:
+                        type: string
+                      summary:
+                        type: string
+                      timestamp:
+                        type: string
+                      status:
+                        default: new
+                        type: string
+                        enum:
+                          - new
+                          - seen
+                          - acted_on
+                          - dismissed
+                      expiresAt:
+                        type: string
+                      actions:
+                        type: array
+                        items:
+                          type: object
+                          properties:
+                            id:
+                              type: string
+                            label:
+                              type: string
+                            prompt:
+                              type: string
+                          required:
+                            - id
+                            - label
+                            - prompt
+                          additionalProperties: false
+                      urgency:
+                        type: string
+                        enum:
+                          - low
+                          - medium
+                          - high
+                          - critical
+                      conversationId:
+                        type: string
+                      detailPanel:
+                        type: object
+                        properties:
+                          kind:
+                            type: string
+                            enum:
+                              - emailDraft
+                              - documentPreview
+                              - permissionChat
+                              - paymentAuth
+                              - toolPermission
+                              - updatesList
+                        required:
+                          - kind
+                        additionalProperties: false
+                      category:
+                        type: string
+                        enum:
+                          - security
+                          - scheduling
+                          - background
+                          - email
+                          - system
+                      noteworthy:
+                        type: boolean
+                      fromAssistant:
+                        type: boolean
+                      metadata:
+                        type: object
+                        propertyNames:
+                          type: string
+                        additionalProperties: {}
+                      createdAt:
+                        type: string
+                    required:
+                      - id
+                      - type
+                      - priority
+                      - summary
+                      - timestamp
+                      - status
+                      - createdAt
+                    additionalProperties: false
                   channels:
                     type: array
                     items:
@@ -17826,7 +17918,11 @@ paths:
                     - vellum
                     - phone
                     - telegram
+                    - whatsapp
                     - slack
+                    - email
+                    - platform
+                    - a2a
                     - scheduler
                     - watcher
                 sourceContextId:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.9.0-dev.202606171417.d2192ab",
+  "version": "0.9.0-dev.202606171903.06eea08",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-compaction-strip.test.ts

@@ -1,12 +1,13 @@
 /**
- * The compaction summarizer's input routing.
+ * The compaction summarizer's input.
  *
- * Budget-gate compaction summarizes the *injected* history so the summary
- * call's prompt prefix matches the agent's warm prefix cache (a cache read
- * rather than a fresh cache write). Overflow recovery summarizes the
- * injection-*stripped* history because its emergency split keeps an
- * un-stripped verbatim prefix that the post-compaction re-injection would
- * otherwise double-stack.
+ * Both the budget gate and overflow recovery summarize the *injected* history
+ * (the genuine conversation as the agent saw it) so the summary call's prompt
+ * prefix matches the agent's warm prefix cache — a cache read rather than a
+ * fresh cache write. The agent loop hands the full injected history to
+ * compaction unconditionally; the post-compaction re-injection hook owns
+ * injection idempotency by stripping the tail's per-turn blocks before
+ * re-applying them.
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
@@ -46,17 +47,17 @@ const testPostCompactPlugin = {
 const CONVERSATION_ID = "compaction-strip-conversation";
 
 /**
- * A runtime `<workspace>` injection block. `stripInjectionsForCompaction`
- * matches its full `{ prefix: "<workspace>\n", suffix: "\n</workspace>" }`
- * wrapper and drops it from user-message content.
+ * A runtime `<workspace>` injection block. Its presence in the summarizer's
+ * input proves compaction received the injected history rather than a stripped
+ * copy.
  */
 const WORKSPACE_INJECTION =
   "<workspace>\nActive workspace: project-x\n</workspace>";
 const TURN_BODY = "Hello there, this is the turn body.";
 
 /**
- * A user turn carrying a real text block plus a runtime injection block.
- * Stripping drops the injection block and keeps the real one.
+ * A user turn carrying a real text block plus a runtime injection block, both
+ * of which ride into compaction's input as-is.
  */
 const injectedUserMessage: Message = {
   role: "user",
@@ -184,7 +185,7 @@ describe("AgentLoop compaction summarizer input", () => {
     expect(events.some((e) => e.type === "history_stripped")).toBe(true);
   });
 
-  test("overflow-driven compaction summarizes the injection-stripped history", async () => {
+  test("overflow-driven compaction summarizes the injected history", async () => {
     // GIVEN a history whose user turn carries a runtime-injection block
     const capture: CompactionInputCapture = { budget: null, overflow: null };
 
@@ -229,10 +230,10 @@ describe("AgentLoop compaction summarizer input", () => {
       ...installCapturingManager(capture),
     });
 
-    // THEN overflow recovery received the history with the injection removed
+    // THEN overflow recovery received the injected history, injection intact
     expect(capture.overflow).not.toBeNull();
-    expect(serialize(capture.overflow)).not.toContain("<workspace>");
-    // AND the real turn body survives the strip
+    expect(serialize(capture.overflow)).toContain("<workspace>");
+    // AND the real turn body is present alongside the injection
     expect(serialize(capture.overflow)).toContain(TURN_BODY);
     // AND the budget summarizer was not invoked
     expect(capture.budget).toBeNull();

package/src/__tests__/app-compiler.test.ts

@@ -2,9 +2,17 @@ import { existsSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  expect,
+  setDefaultTimeout,
+  test,
+} from "bun:test";
 
 import { compileApp } from "../bundler/app-compiler.js";
+import { ensureCompilerTools } from "../bundler/compiler-tools.js";
 import {
   ALLOWED_PACKAGES,
   getCacheDir,
@@ -19,8 +27,14 @@ import {
 
 let tempDir: string;
 
+// Compiler-tool download (esbuild + preact from npm) can take 10s+ on a cold
+// CI cache. Raise the file-level default so beforeAll isn't killed mid-install.
+// Each test file runs in its own process, so this doesn't leak.
+setDefaultTimeout(30_000);
+
 beforeAll(async () => {
   tempDir = await mkdtemp(join(tmpdir(), "app-compiler-test-"));
+  await ensureCompilerTools();
 });
 
 afterAll(async () => {

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

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { cancelGeneration } from "../daemon/handlers/conversations.js";
+
+interface WedgedTurnConversation {
+  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.
+ */
+function registerWedgedTurn(id: string): WedgedTurnConversation {
+  let processing = true;
+  let abortCount = 0;
+  const setProcessingCalls: boolean[] = [];
+  const fake = {
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      setProcessingCalls.push(value);
+      processing = value;
+    },
+    abort: () => {
+      abortCount += 1;
+    },
+  };
+  setConversation(id, fake as unknown as Conversation);
+  return {
+    isProcessing: () => processing,
+    setProcessingCalls: () => setProcessingCalls,
+    abortCount: () => abortCount,
+  };
+}
+
+describe("cancelGeneration", () => {
+  const conversationId = "cancel-clears-processing-test-conversation";
+
+  afterEach(() => {
+    deleteConversation(conversationId);
+  });
+
+  test("clears the processing flag when the in-flight turn ignores the abort signal", () => {
+    // GIVEN a registered conversation that is processing
+    // AND whose in-flight turn ignores the abort signal (never clears processing)
+    const fake = registerWedgedTurn(conversationId);
+    expect(fake.isProcessing()).toBe(true);
+
+    // WHEN the user cancels generation
+    const cancelled = cancelGeneration(conversationId);
+
+    // THEN the cancel is acknowledged
+    expect(cancelled).toBe(true);
+    // AND the abort signal is still 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);
+  });
+
+  test("returns false for a conversation that is not registered", () => {
+    // GIVEN no conversation registered under the id
+
+    // WHEN the user cancels generation for the unknown id
+    const cancelled = cancelGeneration("cancel-clears-processing-unknown-id");
+
+    // THEN the cancel reports that nothing was found
+    expect(cancelled).toBe(false);
+  });
+});

package/src/__tests__/compactor-summary-call-truncation.test.ts

@@ -0,0 +1,223 @@
+/**
+ * The compaction summary call bounds its own input to the context window.
+ *
+ * With no tool pair to anchor an emergency split, an overflow recovery routes
+ * the full conversation straight into `runAssistantDrivenCompaction`. If that
+ * history exceeds the window, the summary call must front-truncate its own
+ * request or it overflows in turn and recovery stalls. Below the window the
+ * request is sent untouched so its prefix stays byte-aligned with the agent's
+ * warm cache (the budget-path cache reuse must not regress).
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getMessages: () => [],
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+}));
+
+import { runAssistantDrivenCompaction } from "../context/compactor.js";
+import { estimatePromptTokens } from "../context/token-estimator.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TRUNCATION_MARKER = "summary covers only the visible portion";
+
+function turnTimestamp(turn: number): string {
+  const hour = String(10 + Math.floor(turn / 60)).padStart(2, "0");
+  const minute = String(turn % 60).padStart(2, "0");
+  return `2026-05-21 (Thursday) ${hour}:${minute}:00 -05:00 (America/Chicago)`;
+}
+
+function userTurn(turn: number, body: string): Message {
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `<turn_context>\ncurrent_time: ${turnTimestamp(
+          turn,
+        )}\n</turn_context>\n[U${turn}] ${body}`,
+      },
+    ],
+  };
+}
+
+function assistantTurn(turn: number, body: string): Message {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text: `[A${turn}] ${body}` }],
+  };
+}
+
+const SUMMARY = "Earlier turns summarized in the assistant's own voice.";
+
+function compactionResponse(tailTurn: number, preview: string): string {
+  return `<compaction_result>
+<summary>
+${SUMMARY}
+</summary>
+<key_state>
+- Nothing critical pending.
+</key_state>
+<tail_start timestamp="${turnTimestamp(tailTurn)}" preview="${preview}" />
+</compaction_result>`;
+}
+
+function makeCapturingProvider(response: string): {
+  provider: Provider;
+  lastRequest: () => Message[] | null;
+} {
+  let captured: Message[] | null = null;
+  const provider: Provider = {
+    name: "mock-provider",
+    sendMessage: async (messages: Message[]) => {
+      captured = messages;
+      return {
+        content: [{ type: "text", text: response }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return { provider, lastRequest: () => captured };
+}
+
+function estimate(messages: Message[]): number {
+  return estimatePromptTokens(messages, "system", {
+    providerName: "mock-provider",
+  });
+}
+
+describe("runAssistantDrivenCompaction — summary call self-truncation", () => {
+  test("front-truncates the outbound request when the full history exceeds the context window", async () => {
+    // GIVEN a tool-pair-free history whose estimate exceeds the window, so an
+    // overflow recovery would route it straight into the summary call.
+    const messages: Message[] = [];
+    for (let i = 0; i < 40; i++) {
+      messages.push(
+        userTurn(
+          i,
+          "Heavy user turn body that carries real weight. ".repeat(8),
+        ),
+      );
+      messages.push(
+        assistantTurn(
+          i,
+          "Heavy assistant reply that also carries weight. ".repeat(8),
+        ),
+      );
+    }
+
+    const maxInputTokens = 10_000;
+    // Budget mirrors compactor.compactionPrefixBudget: window minus the
+    // instruction reserve (800) and the 15% output reserve.
+    const prefixBudget =
+      maxInputTokens - 800 - Math.floor(maxInputTokens * 0.15);
+    expect(estimate(messages)).toBeGreaterThan(prefixBudget);
+
+    const { provider, lastRequest } = makeCapturingProvider(
+      compactionResponse(38, "Heavy user turn body"),
+    );
+
+    // WHEN the summary call runs against that oversized history.
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-test",
+      messages,
+      provider,
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens,
+      force: true,
+      previousEstimatedInputTokens: 90_000,
+    });
+
+    expect(result.compacted).toBe(true);
+
+    // THEN the request actually sent fits within the context window.
+    const sent = lastRequest();
+    expect(sent).not.toBeNull();
+    expect(estimate(sent ?? [])).toBeLessThan(maxInputTokens);
+
+    // AND it opens with a marker noting the dropped leading messages so the
+    // model knows the summary covers only the visible portion.
+    const firstBlock = sent?.[0]?.content[0];
+    const firstText = firstBlock && "text" in firstBlock ? firstBlock.text : "";
+    expect(firstText).toContain(TRUNCATION_MARKER);
+  });
+
+  test("sends the full history untouched when it already fits below the budget", async () => {
+    // GIVEN a small history whose estimate is well under the window — the
+    // common budget-triggered compaction.
+    const messages: Message[] = [];
+    for (let i = 0; i < 8; i++) {
+      messages.push(userTurn(i, "short user turn body"));
+      messages.push(assistantTurn(i, "short assistant reply body"));
+    }
+
+    const maxInputTokens = 200_000;
+    const prefixBudget =
+      maxInputTokens - 800 - Math.floor(maxInputTokens * 0.15);
+    expect(estimate(messages)).toBeLessThan(prefixBudget);
+
+    const { provider, lastRequest } = makeCapturingProvider(
+      compactionResponse(6, "short user turn body"),
+    );
+
+    // WHEN the summary call runs against the below-budget history.
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-test",
+      messages,
+      provider,
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens,
+      force: true,
+      previousEstimatedInputTokens: 90_000,
+    });
+
+    expect(result.compacted).toBe(true);
+
+    // THEN no truncation marker is prepended and the request carries every
+    // history message plus the single instruction, with the leading message
+    // byte-identical to the original — keeping the prefix cache warm.
+    const sent = lastRequest();
+    expect(sent).not.toBeNull();
+    expect(sent?.length).toBe(messages.length + 1);
+    const firstBlock = sent?.[0]?.content[0];
+    const firstText = firstBlock && "text" in firstBlock ? firstBlock.text : "";
+    expect(firstText).not.toContain(TRUNCATION_MARKER);
+    const originalFirst = messages[0]?.content[0];
+    expect(firstText).toBe(
+      originalFirst && "text" in originalFirst ? originalFirst.text : "",
+    );
+  });
+});

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

@@ -1748,6 +1748,57 @@ describe("session-agent-loop", () => {
       // THEN the queue is drained with the loop-complete reason
       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 } = {};
+      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",
+          };
+        },
+      };
+      const ctx = makeCtx({
+        loopProvider: provider,
+        drainQueue: async () => {
+          drained = true;
+        },
+      });
+      ctxHolder.conversation = ctx;
+
+      // WHEN the superseded turn runs to completion
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // 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);
+    });
   });
 
   describe("stale pending surface cleanup", () => {