@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/conversation-inference-profile-route.test.ts

@@ -1,6 +1,11 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
 import { makeMockLogger } from "./helpers/mock-logger.js";
+import { waitFor } from "./helpers/wait-for.js";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
@@ -63,6 +68,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       type: string;
       conversationId?: string;
       profile?: string | null;
+      tags?: string[];
     }> = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
@@ -74,6 +80,10 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
             event.message.type === "conversation_inference_profile_updated"
               ? event.message.profile
               : undefined,
+          tags:
+            event.message.type === "sync_changed"
+              ? event.message.tags
+              : undefined,
         });
       },
     });
@@ -84,7 +94,9 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       headers: {},
     });
 
-    await Promise.resolve();
+    await waitFor(() => received.length === 2, {
+      message: "Timed out waiting for inference profile route event",
+    });
 
     expect(result).toMatchObject({
       conversationId: conversation.id,
@@ -98,6 +110,16 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
         type: "conversation_inference_profile_updated",
         conversationId: conversation.id,
         profile: "quality-optimized",
+        tags: undefined,
+      },
+      {
+        type: "sync_changed",
+        conversationId: undefined,
+        profile: undefined,
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMetadataSyncTag(conversation.id),
+        ],
       },
     ]);
 
@@ -125,14 +147,17 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       body: { profile: "balanced" },
       headers: {},
     });
+    await new Promise((resolve) => setTimeout(resolve, 0));
     expect(getConversation(conversation.id)?.inferenceProfile).toBe("balanced");
 
-    const received: Array<{ profile?: string | null }> = [];
+    const received: Array<{ profile?: string | null; tags?: string[] }> = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {
         if (event.message.type === "conversation_inference_profile_updated") {
           received.push({ profile: event.message.profile });
+        } else if (event.message.type === "sync_changed") {
+          received.push({ tags: event.message.tags });
         }
       },
     });
@@ -143,14 +168,24 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       headers: {},
     });
 
-    await Promise.resolve();
+    await waitFor(() => received.length === 2, {
+      message: "Timed out waiting for inference profile route event",
+    });
 
     expect(result).toMatchObject({
       conversationId: conversation.id,
       profile: null,
     });
     expect(getConversation(conversation.id)?.inferenceProfile).toBeNull();
-    expect(received).toEqual([{ profile: null }]);
+    expect(received).toEqual([
+      { profile: null },
+      {
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMetadataSyncTag(conversation.id),
+        ],
+      },
+    ]);
 
     subscription.dispose();
   });
@@ -163,6 +198,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       body: { profile: "balanced" },
       headers: {},
     });
+    await new Promise((resolve) => setTimeout(resolve, 0));
     const updatedAtAfterSet = getConversation(conversation.id)?.updatedAt;
 
     const received: Array<{ profile?: string | null }> = [];

package/src/__tests__/conversation-lifecycle.test.ts

@@ -450,6 +450,119 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[2].content).toEqual([{ type: "text", text: "Tail" }]);
   });
 
+  test("internal-channel trusted_contact view still rehydrates memoryV2StaticBlock", async () => {
+    // Regression: the prior `!isUntrustedTrustClass(trustClass)` gate
+    // blocked any non-guardian view from rehydrating personal memory,
+    // including legitimate internal flows (e.g. trusted_contact actors
+    // arriving over the internal `"vellum"` channel). Injection time
+    // uses `shouldExposePersonalMemory`, which keys on `sourceChannel`
+    // rather than `trustClass` and exposes personal memory for
+    // `sourceChannel === "vellum"` regardless of actor trust class. The
+    // rehydrate gate must match so a daemon-restart reload of the same
+    // conversation produces an identical prefix.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First" }]),
+        metadata: JSON.stringify({
+          // Rows must carry `trusted_contact` / `unknown` provenance to
+          // survive the row-level filter for non-guardian views.
+          provenanceTrustClass: "trusted_contact",
+          memoryV2StaticBlock:
+            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+        metadata: JSON.stringify({ provenanceTrustClass: "trusted_contact" }),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail" }]),
+        metadata: JSON.stringify({ provenanceTrustClass: "trusted_contact" }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    conversation.setTrustContext({
+      trustClass: "trusted_contact",
+      sourceChannel: "vellum",
+    });
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(messages[0].content).toEqual([
+      {
+        type: "text",
+        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+      },
+      { type: "text", text: "First" },
+    ]);
+  });
+
+  test("rehydration order matches injection-time order for the full personal-memory set", async () => {
+    // Injection-time layout (per `applyRuntimeInjections` after-memory-
+    // prefix splicing in ascending injector order: pkb-context 30,
+    // pkb-reminder 35, memory-v2-static 38, now-md 40):
+    //   [<memory __injected>, <memory>v2static</memory>, <NOW.md>,
+    //    <system_reminder>, <knowledge_base>, ...original]
+    // Rehydration must reproduce this exactly so Anthropic's prefix cache
+    // matches msg[0] across daemon restarts.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryInjectedBlock: "mem payload",
+          memoryV2StaticBlock:
+            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+          nowScratchpadBlock: "<NOW.md>\nnow body\n</NOW.md>",
+          pkbSystemReminderBlock:
+            "<system_reminder>\npkb reminder body\n</system_reminder>",
+          pkbContextBlock: "<knowledge_base>\nkb body\n</knowledge_base>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(messages[0].content).toEqual([
+      { type: "text", text: "<memory>\nmem payload\n</memory>" },
+      {
+        type: "text",
+        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+      },
+      { type: "text", text: "<NOW.md>\nnow body\n</NOW.md>" },
+      {
+        type: "text",
+        text: "<system_reminder>\npkb reminder body\n</system_reminder>",
+      },
+      { type: "text", text: "<knowledge_base>\nkb body\n</knowledge_base>" },
+      { type: "text", text: "First turn" },
+    ]);
+  });
+
   test("untrusted-actor view does not rehydrate memoryV2StaticBlock", async () => {
     mockConversation = defaultConv();
     // Rows with `trusted_contact` / `unknown` provenance survive the
@@ -492,4 +605,64 @@ describe("loadFromDb metadata injection rehydration", () => {
     // suppresses the personal-memory block.
     expect(messages[0].content).toEqual([{ type: "text", text: "First" }]);
   });
+
+  test("ensureActorScopedHistory reloads when sourceChannel changes within the same trust class", async () => {
+    // Regression: cache invalidation previously keyed only on trust class.
+    // `loadFromDb` gates `memoryV2StaticBlock` rehydration on `sourceChannel`
+    // via `shouldExposePersonalMemory`, so a same-trust-class reuse from a
+    // different channel (e.g. internal `vellum` → remote channel) must
+    // re-run `loadFromDb` or stale personal-memory exposure persists.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First" }]),
+        metadata: JSON.stringify({
+          provenanceTrustClass: "trusted_contact",
+          memoryV2StaticBlock:
+            "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+        metadata: JSON.stringify({ provenanceTrustClass: "trusted_contact" }),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail" }]),
+        metadata: JSON.stringify({ provenanceTrustClass: "trusted_contact" }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    // First load: internal channel, trusted_contact actor → personal memory
+    // exposed via `shouldExposePersonalMemory({sourceChannel: "vellum", ...})`.
+    conversation.setTrustContext({
+      trustClass: "trusted_contact",
+      sourceChannel: "vellum",
+    });
+    await conversation.ensureActorScopedHistory();
+    expect(conversation.getMessages()[0].content).toEqual([
+      {
+        type: "text",
+        text: "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+      },
+      { type: "text", text: "First" },
+    ]);
+
+    // Reuse with the same trust class but a remote channel. The cache must
+    // invalidate and trigger a reload that strips the personal-memory block.
+    conversation.setTrustContext({
+      trustClass: "trusted_contact",
+      sourceChannel: "telegram",
+    });
+    await conversation.ensureActorScopedHistory();
+    expect(conversation.getMessages()[0].content).toEqual([
+      { type: "text", text: "First" },
+    ]);
+  });
 });

package/src/__tests__/conversation-media-retry.test.ts

@@ -23,7 +23,11 @@ function makeImageBlockWithSize(
 ): Extract<ContentBlock, { type: "image" }> {
   return {
     type: "image",
-    source: { type: "base64", media_type: "image/png", data: "A".repeat(dataLength) },
+    source: {
+      type: "base64",
+      media_type: "image/png",
+      data: "A".repeat(dataLength),
+    },
   };
 }
 
@@ -103,16 +107,19 @@ describe("stripMediaPayloadsForRetry", () => {
   // ---------------------------------------------------------------------------
 
   test("budget-aware: keeps images that fit within token budget", () => {
-    // Non-Anthropic estimation: estimateTextTokens(base64Data) + overhead (~19 tokens).
-    // Data length 4000 → 1000 data tokens + 19 overhead ≈ 1019 tokens/image.
-    // Budget of 3500 allows 3 images (3 * 1019 = 3057 <= 3500) but not 4.
-    const images = Array.from({ length: 5 }, () => makeImageBlockWithSize(4000));
+    // Dimension-based estimation: when the base64 data has no parseable image
+    // header, fall back to IMAGE_MAX_TOKENS (1600) + overhead (~19 tokens) ≈
+    // 1619 tokens/image. Budget of 5000 allows 3 images (3 * 1619 = 4857
+    // <= 5000) but not 4 (4 * 1619 = 6476 > 5000).
+    const images = Array.from({ length: 5 }, () =>
+      makeImageBlockWithSize(4000),
+    );
     const messages: Message[] = [
       makeUserMessage({ type: "text", text: "describe these" }, ...images),
     ];
 
     const result = stripMediaPayloadsForRetry(messages, {
-      mediaTokenBudget: 3500,
+      mediaTokenBudget: 5000,
       providerName: "mock",
     });
     expect(result.modified).toBe(true);
@@ -120,7 +127,9 @@ describe("stripMediaPayloadsForRetry", () => {
     const content = result.messages[0].content;
     const keptImages = content.filter((b) => b.type === "image");
     const stubs = content.filter(
-      (b) => b.type === "text" && (b as { text: string }).text.includes("Image omitted"),
+      (b) =>
+        b.type === "text" &&
+        (b as { text: string }).text.includes("Image omitted"),
     );
     expect(keptImages.length).toBe(3);
     expect(stubs.length).toBe(2);
@@ -174,7 +183,9 @@ describe("stripMediaPayloadsForRetry", () => {
     const content = result.messages[0].content;
     const keptImages = content.filter((b) => b.type === "image");
     const stubs = content.filter(
-      (b) => b.type === "text" && (b as { text: string }).text.includes("Image omitted"),
+      (b) =>
+        b.type === "text" &&
+        (b as { text: string }).text.includes("Image omitted"),
     );
     expect(keptImages.length).toBe(3);
     expect(stubs.length).toBe(2);

package/src/__tests__/conversation-message-sync-tags.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  conversationMessagesSyncTag,
+  type SyncChangedMessage,
+} from "../daemon/message-types/sync.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import {
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
+import { waitFor } from "./helpers/wait-for.js";
+
+async function captureEvents(
+  action: () => void | Promise<unknown>,
+  expectedCount: number,
+): Promise<AssistantEvent[]> {
+  const received: AssistantEvent[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    callback: (event) => {
+      received.push(event);
+    },
+  });
+  try {
+    await action();
+    await waitFor(() => received.length >= expectedCount, {
+      message: "Timed out waiting for conversation message sync tag event",
+    });
+    return received;
+  } finally {
+    subscription.dispose();
+  }
+}
+
+function syncMessages(events: AssistantEvent[]): SyncChangedMessage[] {
+  return events
+    .map((event) => event.message)
+    .filter(
+      (message): message is SyncChangedMessage =>
+        message.type === "sync_changed",
+    );
+}
+
+describe("conversation message sync tags", () => {
+  test("message-history publisher emits the conversation messages tag", async () => {
+    const received = await captureEvents(() => {
+      publishConversationMessagesChanged("conversation-123");
+    }, 1);
+
+    expect(syncMessages(received)).toEqual([
+      {
+        type: "sync_changed",
+        tags: [conversationMessagesSyncTag("conversation-123")],
+      },
+    ]);
+  });
+
+  test("callers can sequence user echo before the message-history tag", async () => {
+    const received = await captureEvents(() => {
+      broadcastMessage({
+        type: "user_message_echo",
+        conversationId: "conversation-123",
+        text: "Hello from another client",
+        messageId: "message-123",
+      });
+      publishConversationMessagesChanged("conversation-123");
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "user_message_echo",
+      "sync_changed",
+    ]);
+    expect(syncMessages(received)).toEqual([
+      {
+        type: "sync_changed",
+        tags: [conversationMessagesSyncTag("conversation-123")],
+      },
+    ]);
+  });
+
+  test("token deltas do not emit message-history sync tags", async () => {
+    const received = await captureEvents(() => {
+      broadcastMessage({
+        type: "assistant_text_delta",
+        conversationId: "conversation-123",
+        text: "partial",
+      });
+    }, 1);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "assistant_text_delta",
+    ]);
+    expect(syncMessages(received)).toEqual([]);
+  });
+});

package/src/__tests__/conversation-pairing.test.ts

@@ -815,6 +815,60 @@ describe("pairDeliveryWithConversation", () => {
     expect(getBindingByChannelChatMock).not.toHaveBeenCalled();
   });
 
+  // ── conversationMetadata.conversationType override ─────────────────
+
+  test("uses conversationMetadata.conversationType when set, overriding channel strategy", async () => {
+    const signal = makeSignal({
+      conversationMetadata: {
+        source: "heartbeat",
+        groupId: "system:background",
+        conversationType: "background",
+      },
+    });
+    const copy = makeCopy({ conversationTitle: "Heartbeat Alert" });
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      copy,
+    );
+
+    expect(result.conversationId).toBe("conv-001");
+    expect(result.strategy).toBe("start_new_conversation");
+    expect(createConversationMock).toHaveBeenCalledTimes(1);
+    const callArgs = createConversationMock.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+    // vellum channel normally yields "standard", but the metadata override wins
+    expect(callArgs.conversationType).toBe("background");
+  });
+
+  test("falls back to channel strategy when conversationMetadata.conversationType is not set", async () => {
+    const signal = makeSignal({
+      conversationMetadata: {
+        source: "scheduler",
+        groupId: "group-1",
+      },
+    });
+    const copy = makeCopy();
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      copy,
+    );
+
+    expect(result.conversationId).toBe("conv-001");
+    expect(createConversationMock).toHaveBeenCalledTimes(1);
+    const callArgs = createConversationMock.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+    // No override — vellum (start_new_conversation) defaults to "standard"
+    expect(callArgs.conversationType).toBe("standard");
+  });
+
   // ── not_deliverable (voice) ───────────────────────────────────────
 
   test("returns null conversationId and messageId for not_deliverable strategy", async () => {

package/src/__tests__/conversation-process-callsite.test.ts

@@ -97,7 +97,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -57,7 +57,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     services: {
       inference: {
         mode: "your-own",
@@ -71,6 +74,7 @@ mock.module("../config/loader.js", () => ({
       },
       "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
+    compaction: { enabled: true, autoThreshold: 0.7 },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},

package/src/__tests__/conversation-queue.test.ts

@@ -77,7 +77,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     conversations: { skipAutoRetitling: false },
     timeouts: { permissionTimeoutSec: 1 },
     skills: { entries: {}, allowBundled: true },