@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for the default `user-prompt-submit-temp` hook (memory retrieval +
+ * Tests for the default `user-prompt-submit` hook (memory retrieval +
  * runtime injection).
  *
  * Covers the retrieval behavior, the side effects the hook owns (injected-block
@@ -37,6 +37,7 @@ const applyRuntimeInjectionsMock = mock(async (messages: unknown) => ({
 mock.module("../daemon/conversation-runtime-assembly.js", () => ({
   applyRuntimeInjections: applyRuntimeInjectionsMock,
   resolveTurnInboundActorContext: () => null,
+  resolveTurnModelProfileLabel: () => null,
 }));
 
 // The hook self-resolves the live conversation and its trust class; both are
@@ -56,14 +57,22 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => ({}) as AssistantConfig,
 }));
 
+// The hook publishes `memory_recalled` (and forwards the sink into
+// `prepareMemory` for `memory_status`) through the shared `broadcastMessage`
+// hub. Stub it so tests can assert what the hook emits.
+const broadcastMessageMock = mock((_msg: unknown) => {});
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: broadcastMessageMock,
+}));
+
+import type { UserPromptSubmitContext } from "@vellumai/plugin-api";
+
 import type { AssistantConfig } from "../config/schema.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
-import userPromptSubmitMemoryRetrieval, {
-  type MemoryRetrievalHookContext,
-} from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit-temp.js";
+import userPromptSubmitMemoryRetrieval from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit.js";
 import type { Message } from "../providers/types.js";
 
 /** Canonical metrics payload the graph retriever attaches to a real hit. */
@@ -136,19 +145,20 @@ function makeFakeGraphMemory(overrides?: {
 }
 
 function makeHookCtx(
-  overrides: Partial<MemoryRetrievalHookContext> = {},
-): MemoryRetrievalHookContext {
+  overrides: Partial<UserPromptSubmitContext> = {},
+): UserPromptSubmitContext {
   return {
-    onEvent: () => {},
     conversationId: "conv-test",
     userMessageId: "msg-test",
     logger: {
       warn: () => {},
-    } as unknown as MemoryRetrievalHookContext["logger"],
+    } as unknown as UserPromptSubmitContext["logger"],
     latestMessages: [],
     requestId: "req-test",
     isNonInteractive: false,
-    modelProfile: null,
+    modelProfileKey: null,
+    prompt: "",
+    originalMessages: [],
     ...overrides,
   };
 }
@@ -160,7 +170,10 @@ function makeHookCtx(
  */
 function installConversation(
   graphMemory: ConversationGraphMemory,
-  opts?: { trusted?: boolean; signal?: AbortSignal },
+  opts?: {
+    trusted?: boolean;
+    signal?: AbortSignal;
+  },
 ): void {
   currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
   currentConversation = {
@@ -175,11 +188,12 @@ beforeEach(() => {
   recordMemoryRecallLogMock.mockReset();
   applyRuntimeInjectionsMock.mockClear();
   findConversationOrSubagentMock.mockClear();
+  broadcastMessageMock.mockReset();
   currentConversation = undefined;
   currentTrustClass = "guardian";
 });
 
-describe("user-prompt-submit-temp hook (memory retrieval)", () => {
+describe("user-prompt-submit hook (memory retrieval)", () => {
   test("adopts the injected run messages when the actor is trusted", async () => {
     const injected: Message[] = [
       { role: "user", content: [{ type: "text", text: "injected" }] },
@@ -299,14 +313,12 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
   });
 
   test("persists injected block, recall log, and emits memory_recalled", async () => {
-    const received: ServerMessage[] = [];
     const { memory } = makeFakeGraphMemory({
       injectedBlockText: "injected-block",
       metrics: makeMetrics(),
     });
     installConversation(memory, { trusted: true });
     const ctx = makeHookCtx({
-      onEvent: (msg) => received.push(msg),
       userMessageId: "msg-42",
       conversationId: "conv-42",
     });
@@ -323,8 +335,98 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     };
     expect(logEntry.conversationId).toBe("conv-42");
     expect(logEntry.reason).toBe("graph:none");
-    expect(received).toHaveLength(1);
-    expect(received[0]?.type).toBe("memory_recalled");
+    // The `memory_recalled` summary publishes through the shared broadcast hub.
+    expect(broadcastMessageMock).toHaveBeenCalledTimes(1);
+    const emitted = broadcastMessageMock.mock.calls[0]?.[0] as ServerMessage;
+    expect(emitted.type).toBe("memory_recalled");
+  });
+
+  test("memory-v3 active → v2 persists immediately, then the combined update removes it and persists the v3 card block", async () => {
+    // The v2 block is persisted RIGHT AFTER retrieval (no loss window: a
+    // crash between retrieval and assembly must not leave v2's activation
+    // store claiming pages whose block never reached metadata). Assembly then
+    // reports memoryV3Active (v3 superseded/stripped v2's tail block), so the
+    // post-assembly combined update REMOVES the v2 key — persisting it would
+    // rehydrate a block that is not in the live history.
+    const { memory } = makeFakeGraphMemory({
+      injectedBlockText: "v2-block-superseded",
+      metrics: makeMetrics(),
+    });
+    installConversation(memory, { trusted: true });
+    applyRuntimeInjectionsMock.mockImplementationOnce(
+      async (messages: unknown) => ({
+        messages,
+        blocks: {
+          memoryV3Active: true,
+          memoryV3InjectedBlock: "header\n\n# memory/concepts/page-a.md\nhead",
+        },
+      }),
+    );
+    const ctx = makeHookCtx({ userMessageId: "msg-43" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(updateMessageMetadataMock.mock.calls).toEqual([
+      ["msg-43", { memoryInjectedBlock: "v2-block-superseded" }],
+      [
+        "msg-43",
+        {
+          // `undefined` deletes the key (JSON.stringify drops it) — the turn
+          // ends with the two memory layers mutually exclusive per row.
+          memoryInjectedBlock: undefined,
+          memoryV3InjectedBlock: "header\n\n# memory/concepts/page-a.md\nhead",
+        },
+      ],
+    ]);
+  });
+
+  test("memory-v3 active with EMPTY net-new → the immediate v2 persist is removed again", async () => {
+    // All-repeat turn: v2 was stripped (superseded) and v3 attached nothing
+    // new — the row must rehydrate with no memory block, matching live state.
+    const { memory } = makeFakeGraphMemory({
+      injectedBlockText: "v2-block-superseded",
+      metrics: makeMetrics(),
+    });
+    installConversation(memory, { trusted: true });
+    applyRuntimeInjectionsMock.mockImplementationOnce(
+      async (messages: unknown) => ({
+        messages,
+        blocks: { memoryV3Active: true },
+      }),
+    );
+    const ctx = makeHookCtx({ userMessageId: "msg-44" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(updateMessageMetadataMock.mock.calls).toEqual([
+      ["msg-44", { memoryInjectedBlock: "v2-block-superseded" }],
+      ["msg-44", { memoryInjectedBlock: undefined }],
+    ]);
+  });
+
+  test("v2 block is already persisted when runtime assembly throws (no loss window)", async () => {
+    // Regression guard for the v2 path: with the v3 shadow flag on, assembly
+    // includes a seconds-long selector LLM call. If the process dies or the
+    // turn aborts in that window, the v2 block must already be in metadata —
+    // v2's activation store claimed its pages during retrieval, and a
+    // claimed-but-never-persisted block is absent from history on reload AND
+    // suppressed until compaction.
+    const { memory } = makeFakeGraphMemory({
+      injectedBlockText: "v2-block",
+      metrics: makeMetrics(),
+    });
+    installConversation(memory, { trusted: true });
+    applyRuntimeInjectionsMock.mockImplementationOnce(async () => {
+      throw new Error("assembly failed");
+    });
+    const ctx = makeHookCtx({ userMessageId: "msg-45" });
+
+    await expect(userPromptSubmitMemoryRetrieval(ctx)).rejects.toThrow(
+      "assembly failed",
+    );
+    expect(updateMessageMetadataMock).toHaveBeenCalledWith("msg-45", {
+      memoryInjectedBlock: "v2-block",
+    });
   });
 
   test("skips metadata persist when no block text is injected", async () => {

package/src/__tests__/notification-decision-strategy.test.ts

@@ -9,17 +9,17 @@
 
 import { describe, expect, test } from "bun:test";
 
-import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
 import {
   buildAccessRequestContractText,
   buildAccessRequestIdentityLine,
-  composeFallbackCopy,
   hasAccessRequestInstructions,
   hasInviteFlowDirective,
   normalizeForDirectiveMatching,
   sanitizeIdentityField,
   sanitizeMessagePreview,
-} from "../notifications/copy-composer.js";
+} from "../notifications/access-request-copy.js";
+import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
+import { composeFallbackCopy } from "../notifications/copy-composer.js";
 import {
   enforceGuardianCallConversationAffinity,
   validateConversationActions,

package/src/__tests__/oauth-store.test.ts

@@ -58,7 +58,6 @@ import {
   getAppByProviderAndClientId,
   getConnection,
   getConnectionByProvider,
-  getConnectionByProviderAndAccount,
   getProvider,
   isProviderConnected,
   listActiveConnectionsByProvider,
@@ -1689,90 +1688,6 @@ describe("connection operations", () => {
     });
   });
 
-  describe("getConnectionByProviderAndAccount", () => {
-    test("returns the connection matching the given account", async () => {
-      const app = await createTestApp("github", "client-1");
-
-      const conn1 = createConnection({
-        oauthAppId: app.id,
-        provider: "github",
-        accountInfo: "user1@example.com",
-        grantedScopes: ["repo"],
-        hasRefreshToken: false,
-        createdAt: 1000,
-      });
-
-      createConnection({
-        oauthAppId: app.id,
-        provider: "github",
-        accountInfo: "user2@example.com",
-        grantedScopes: ["repo"],
-        hasRefreshToken: false,
-        createdAt: 2000,
-      });
-
-      const result = getConnectionByProviderAndAccount(
-        "github",
-        "user1@example.com",
-      );
-      expect(result).toBeDefined();
-      expect(result!.id).toBe(conn1.id);
-    });
-
-    test("falls back to getConnectionByProvider when accountInfo is undefined", async () => {
-      const app = await createTestApp("github", "client-1");
-
-      const conn = createConnection({
-        oauthAppId: app.id,
-        provider: "github",
-        accountInfo: "user@example.com",
-        grantedScopes: ["repo"],
-        hasRefreshToken: false,
-      });
-
-      const result = getConnectionByProviderAndAccount("github", undefined);
-      expect(result).toBeDefined();
-      expect(result!.id).toBe(conn.id);
-    });
-
-    test("returns undefined when no connection matches the account", async () => {
-      const app = await createTestApp("github", "client-1");
-
-      createConnection({
-        oauthAppId: app.id,
-        provider: "github",
-        accountInfo: "user@example.com",
-        grantedScopes: ["repo"],
-        hasRefreshToken: false,
-      });
-
-      const result = getConnectionByProviderAndAccount(
-        "github",
-        "other@example.com",
-      );
-      expect(result).toBeUndefined();
-    });
-
-    test("skips revoked connections", async () => {
-      const app = await createTestApp("github", "client-1");
-
-      const conn = createConnection({
-        oauthAppId: app.id,
-        provider: "github",
-        accountInfo: "user@example.com",
-        grantedScopes: ["repo"],
-        hasRefreshToken: false,
-      });
-      updateConnection(conn.id, { status: "revoked" });
-
-      const result = getConnectionByProviderAndAccount(
-        "github",
-        "user@example.com",
-      );
-      expect(result).toBeUndefined();
-    });
-  });
-
   describe("listActiveConnectionsByProvider", () => {
     test("returns all active connections for a provider", async () => {
       const app = await createTestApp("github", "client-1");

package/src/__tests__/{context-overflow-policy.test.ts → overflow-policy.test.ts}

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import type { ContextOverflowRecoveryConfig } from "../config/schemas/inference.js";
 import { ContextOverflowRecoveryConfigSchema } from "../config/schemas/inference.js";
-import { resolveOverflowAction } from "../daemon/context-overflow-policy.js";
+import { resolveOverflowAction } from "../plugins/defaults/compaction/overflow-policy.js";
 
 /** Parse an empty object to get all defaults. */
 const DEFAULTS: ContextOverflowRecoveryConfig =

package/src/__tests__/parallel-tool.benchmark.test.ts

@@ -137,6 +137,7 @@ describe("Parallel tool execution benchmarks", () => {
     });
     const start = Date.now();
     await loop.run({
+      requestId: "test-request",
       messages: [userMessage],
       onEvent: () => {},
       trust: { sourceChannel: "vellum", trustClass: "unknown" },
@@ -185,6 +186,7 @@ describe("Parallel tool execution benchmarks", () => {
     });
     const start = Date.now();
     await loop.run({
+      requestId: "test-request",
       messages: [userMessage],
       onEvent: () => {},
       trust: { sourceChannel: "vellum", trustClass: "unknown" },
@@ -246,6 +248,7 @@ describe("Parallel tool execution benchmarks", () => {
     const events: AgentEvent[] = [];
     const start = Date.now();
     await loop.run({
+      requestId: "test-request",
       messages: [userMessage],
       onEvent: collectEvents(events),
       trust: { sourceChannel: "vellum", trustClass: "unknown" },
@@ -319,6 +322,7 @@ describe("Parallel tool execution benchmarks", () => {
       });
       const start = Date.now();
       const { history } = await loop.run({
+        requestId: "test-request",
         messages: [userMessage],
         onEvent: () => {},
         trust: { sourceChannel: "vellum", trustClass: "unknown" },

package/src/__tests__/persist-unsendable-image-downscale.test.ts

@@ -30,7 +30,6 @@ mock.module("../agent/image-optimize.js", () => ({
   }),
 }));
 
-import { persistUnsendableImageDowngrades } from "../daemon/persist-unsendable-image.js";
 import {
   addMessage,
   createConversation,
@@ -38,6 +37,7 @@ import {
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import { persistUnsendableImageDowngrades } from "../plugins/defaults/image-recovery/recover.js";
 import type { ContentBlock } from "../providers/types.js";
 
 initializeDb();
@@ -58,9 +58,22 @@ function oversizedPngBase64(): string {
   const height = 9000;
   return Buffer.from(
     Uint8Array.from([
-      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, // PNG signature
-      0x00, 0x00, 0x00, 0x0d, // IHDR length (13)
-      0x49, 0x48, 0x44, 0x52, // "IHDR"
+      0x89,
+      0x50,
+      0x4e,
+      0x47,
+      0x0d,
+      0x0a,
+      0x1a,
+      0x0a, // PNG signature
+      0x00,
+      0x00,
+      0x00,
+      0x0d, // IHDR length (13)
+      0x49,
+      0x48,
+      0x44,
+      0x52, // "IHDR"
       (width >>> 24) & 0xff,
       (width >>> 16) & 0xff,
       (width >>> 8) & 0xff,
@@ -69,7 +82,11 @@ function oversizedPngBase64(): string {
       (height >>> 16) & 0xff,
       (height >>> 8) & 0xff,
       height & 0xff,
-      0x08, 0x06, 0x00, 0x00, 0x00,
+      0x08,
+      0x06,
+      0x00,
+      0x00,
+      0x00,
     ]),
   ).toString("base64");
 }
@@ -80,7 +97,10 @@ function toolResultWithImage(data: string): ContentBlock {
     tool_use_id: "toolu_123",
     content: "Screenshot captured",
     contentBlocks: [
-      { type: "image", source: { type: "base64", media_type: "image/png", data } },
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data },
+      },
     ],
   };
 }
@@ -119,9 +139,9 @@ describe("persistUnsendableImageDowngrades (downscalable host)", () => {
     };
     const nested = toolResult.contentBlocks?.[0];
     expect(nested?.type).toBe("image");
-    expect((nested as Extract<ContentBlock, { type: "image" }>).source.data).toBe(
-      SHRUNK_DATA,
-    );
+    expect(
+      (nested as Extract<ContentBlock, { type: "image" }>).source.data,
+    ).toBe(SHRUNK_DATA);
   });
 
   /** Re-running is a no-op: the downscaled payload is within limits. */

package/src/__tests__/persist-unsendable-image.test.ts

@@ -14,10 +14,6 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  oversizedImageReplacement,
-  persistUnsendableImageDowngrades,
-} from "../daemon/persist-unsendable-image.js";
 import {
   addMessage,
   createConversation,
@@ -25,6 +21,10 @@ import {
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import {
+  oversizedImageReplacement,
+  persistUnsendableImageDowngrades,
+} from "../plugins/defaults/image-recovery/recover.js";
 import type { ContentBlock } from "../providers/types.js";
 
 initializeDb();

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -370,3 +370,81 @@ describe("persistence-layer secret redaction", () => {
     expect(textBlock?.text).toBe(text);
   });
 });
+
+describe("thinking timing persistence", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+    state = createEventHandlerState();
+    state.turnStartedAt = 1_700_000_000_000;
+  });
+
+  afterEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  function makeThinkingCompleteEvent(): Extract<
+    AgentEvent,
+    { type: "message_complete" }
+  > {
+    return {
+      type: "message_complete",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "let me reason", signature: "sig" },
+          { type: "text", text: "the answer" },
+        ],
+      },
+    };
+  }
+
+  test("stamps per-block thinking timing onto the persisted thinking block", async () => {
+    // GIVEN a turn whose row was reserved at llm_call_started
+    await handleLlmCallStarted(state, makeDeps());
+
+    // AND streaming then captured timing for one thinking block (startedAt when
+    // it opened, completedAt at its last reasoning delta). The reserve resets
+    // the accumulator, so deltas — and thus the timing — land after it.
+    state.currentThinkingTimestamps = [{ startedAt: 1000, completedAt: 1750 }];
+
+    // WHEN the message completes and content is persisted
+    await handleMessageComplete(state, makeDeps(), makeThinkingCompleteEvent());
+
+    // THEN the persisted thinking block carries the internal `_`-prefixed
+    // timing so a history reload can surface the duration + "Started at" hover
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      _startedAt?: number;
+      _completedAt?: number;
+    }>;
+    const thinkingBlock = blocks.find((b) => b.type === "thinking");
+    expect(thinkingBlock?._startedAt).toBe(1000);
+    expect(thinkingBlock?._completedAt).toBe(1750);
+  });
+
+  test("persists no thinking timing when none was captured this turn", async () => {
+    // GIVEN a turn that produced a thinking block but captured no timing
+    // (thinking streaming disabled, so the timing list stays empty)
+    expect(state.currentThinkingTimestamps).toEqual([]);
+
+    // WHEN the message completes and content is persisted
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(state, makeDeps(), makeThinkingCompleteEvent());
+
+    // THEN the thinking block is persisted without timing, so the client hides
+    // the duration exactly as a tool call with no timing
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      _startedAt?: number;
+      _completedAt?: number;
+    }>;
+    const thinkingBlock = blocks.find((b) => b.type === "thinking");
+    expect(thinkingBlock).toBeDefined();
+    expect(thinkingBlock?._startedAt).toBeUndefined();
+    expect(thinkingBlock?._completedAt).toBeUndefined();
+  });
+});