@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/anthropic-provider.test.ts

@@ -807,7 +807,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
 
   test("orphaned server_tool_use gets synthetic web_search_tool_result injected", async () => {
     // When stream is interrupted, server_tool_use may be stored without its
-    // paired web_search_tool_result. repairOrphanedServerToolUse should inject
+    // paired web_search_tool_result. repairOrphanedServerToolBlocks should inject
     // a synthetic error web_search_tool_result after the orphan so the model
     // knows the search failed (rather than silently returning zero results).
     const messages: Message[] = [
@@ -1133,7 +1133,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
 
   test("paired server_tool_use is not modified by repair", async () => {
     // When server_tool_use has its matching web_search_tool_result,
-    // repairOrphanedServerToolUse should not inject anything.
+    // repairOrphanedServerToolBlocks should not inject anything.
     const messages: Message[] = [
       userMsg("search"),
       {
@@ -1178,6 +1178,96 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(wsResults[0].tool_use_id).toBe("srvtoolu_paired");
   });
 
+  test("orphaned web_search_tool_result with no preceding server_tool_use gets downgraded to text", async () => {
+    // The inverse of the orphan server_tool_use case. A
+    // web_search_tool_result whose tool_use_id has no matching server_tool_use
+    // in the same assistant message would trip Anthropic's
+    // "messages.N.content.M: unexpected tool_use_id" error. Downgrading the
+    // orphan to a text block preserves the titles/URLs for the model and
+    // keeps the request valid.
+    const messages: Message[] = [
+      userMsg("Tell me more"),
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Let me check." },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_orphaned",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://example.com",
+                title: "Example",
+                encrypted_content: "enc_abc",
+              },
+            ],
+          },
+        ],
+      },
+      userMsg("Thanks"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; text?: string; tool_use_id?: string }>;
+    }>;
+
+    // No web_search_tool_result block survives anywhere in the dispatched
+    // request — the orphan must be downgraded so Anthropic doesn't 400.
+    const allBlocks = sent.flatMap((m) => m.content);
+    expect(allBlocks.every((b) => b.type !== "web_search_tool_result")).toBe(
+      true,
+    );
+
+    // The downgrade text references the orphan id and the result's URL so
+    // the model retains context.
+    const assistantMsg = sent[1];
+    expect(assistantMsg.role).toBe("assistant");
+    const downgraded = assistantMsg.content.find(
+      (b) => b.type === "text" && b.text?.includes("srvtoolu_orphaned"),
+    );
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("https://example.com");
+  });
+
+  test("orphaned web_search_tool_result with no content array still downgrades cleanly", async () => {
+    const messages: Message[] = [
+      userMsg("status?"),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_empty",
+            content: {
+              type: "web_search_tool_result_error",
+              error_code: "unavailable",
+            },
+          },
+        ],
+      },
+      userMsg("ok"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; text?: string }>;
+    }>;
+
+    const allBlocks = sent.flatMap((m) => m.content);
+    expect(allBlocks.every((b) => b.type !== "web_search_tool_result")).toBe(
+      true,
+    );
+    const downgraded = sent[1].content.find(
+      (b) => b.type === "text" && b.text?.includes("srvtoolu_empty"),
+    );
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("results unavailable");
+  });
+
   test("assistant message with only unknown blocks gets placeholder text", async () => {
     const messages: Message[] = [
       userMsg("Start"),

package/src/__tests__/app-control-flow.test.ts

@@ -65,6 +65,13 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       cap === "host_app_control" && mockHasClient
         ? { id: "mock-client" }
         : null,
+    // Stubbed for the surfaceProxyResolver's target_client_id resolution
+    // path. The flow tests do not exercise multiple-client scenarios; they
+    // only need the resolver to fall through to proxy.request without
+    // throwing on undefined methods.
+    listClientsByCapability: () => [],
+    getClientById: () => undefined,
+    getActorPrincipalIdForClient: () => undefined,
   },
 }));
 

package/src/__tests__/assistant-events-sse-shed.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Tests for SSE subscriber shed-on-backpressure observability.
+ *
+ * Verifies that when `controller.desiredSize <= 0`, the SSE route invokes
+ * the injected shed reporter with the correct reason and per-subscriber
+ * context. Both shed sites are covered: the event-callback path (slow
+ * subscriber + publishes filling the queue) and the heartbeat-timer path
+ * (slow subscriber with no published events). The healthy path asserts
+ * no shed report fires.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  buildSseShedSentryContext,
+  handleSubscribeAssistantEvents,
+  type SseShedReason,
+  type SseSubscriberInstrumentation,
+} from "../runtime/routes/events-routes.js";
+
+initializeDb();
+
+function clearTables() {
+  const db = getDb();
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+interface ShedReport {
+  reason: SseShedReason;
+  events_delivered: number;
+  heartbeats_sent: number;
+  client_id: string | null;
+  interface_id: string | null;
+  conversation_key: string | null;
+  subscription_age_ms: number;
+}
+
+function makeReporterCaptor(): {
+  reports: ShedReport[];
+  reporter: (reason: SseShedReason, inst: SseSubscriberInstrumentation) => void;
+} {
+  const reports: ShedReport[] = [];
+  return {
+    reports,
+    reporter: (reason, inst) => {
+      reports.push({
+        reason,
+        events_delivered: inst.eventsDelivered,
+        heartbeats_sent: inst.heartbeatsSent,
+        client_id: inst.clientId,
+        interface_id: inst.interfaceId,
+        conversation_key: inst.conversationKey,
+        subscription_age_ms: Date.now() - inst.subscribedAtMs,
+      });
+    },
+  };
+}
+
+const SSE_HIGH_WATER_MARK = 16;
+
+describe("SSE route — backpressure shed observability", () => {
+  beforeEach(clearTables);
+
+  test("invokes shedReporter with reason=callback_backpressure when publishes saturate the queue", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-cb-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, shedReporter: reporter },
+    );
+    expect(hub.subscriberCount()).toBe(1);
+
+    // Saturate the stream's bounded queue without reading from it.
+    // start() already enqueued the immediate heartbeat (queue=1), so
+    // publishing `SSE_HIGH_WATER_MARK` events triggers the shed on the
+    // final publish when desiredSize hits 0.
+    for (let i = 0; i < SSE_HIGH_WATER_MARK; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+
+    expect(hub.subscriberCount()).toBe(0);
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.reason).toBe("callback_backpressure");
+    expect(reports[0]?.events_delivered).toBe(SSE_HIGH_WATER_MARK - 1);
+    // The initial heartbeat enqueued by start() must be counted so the
+    // reported queue depth matches what was actually pushed.
+    expect(reports[0]?.heartbeats_sent).toBe(1);
+    expect(reports[0]?.conversation_key).toBe("shed-cb-test");
+    expect(typeof reports[0]?.subscription_age_ms).toBe("number");
+
+    ac.abort();
+  });
+
+  test("invokes shedReporter with reason=heartbeat_backpressure when the heartbeat tick finds desiredSize<=0", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-hb-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, heartbeatIntervalMs: 20, shedReporter: reporter },
+    );
+    expect(hub.subscriberCount()).toBe(1);
+
+    // Fill the queue up to its limit without sending the publish that
+    // would shed via the callback path.
+    for (let i = 0; i < SSE_HIGH_WATER_MARK - 1; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+    expect(reports.length).toBe(0);
+
+    await new Promise((r) => setTimeout(r, 60));
+
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.reason).toBe("heartbeat_backpressure");
+    expect(reports[0]?.conversation_key).toBe("shed-hb-test");
+
+    ac.abort();
+  });
+
+  test("does not invoke shedReporter when a reader drains the stream", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-healthy-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, heartbeatIntervalMs: 1_000, shedReporter: reporter },
+    );
+
+    const reader = stream.getReader();
+    void reader.read();
+
+    for (let i = 0; i < 32; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+      void reader.read();
+    }
+
+    expect(reports.length).toBe(0);
+
+    ac.abort();
+    void reader.cancel();
+  });
+
+  test("captures client identity in the shed instrumentation context", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-client-test" },
+        headers: {
+          "x-vellum-client-id": "client-abc",
+          "x-vellum-interface-id": "macos",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub, shedReporter: reporter },
+    );
+
+    for (let i = 0; i < SSE_HIGH_WATER_MARK; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.client_id).toBe("client-abc");
+    expect(reports[0]?.interface_id).toBe("macos");
+
+    ac.abort();
+  });
+});
+
+describe("buildSseShedSentryContext", () => {
+  const inst: SseSubscriberInstrumentation = {
+    subscribedAtMs: 1_000,
+    eventsDelivered: 7,
+    heartbeatsSent: 3,
+    clientId: "client-xyz",
+    interfaceId: "macos",
+    // Channel-backed conversation key embedding a phone number.
+    conversationKey: "asst:self:whatsapp:447123456789",
+  };
+  const elDelay = { mean_ms: 1.2, p99_ms: 3.4, max_ms: 5.6 };
+
+  test("omits conversation_key so Sentry contexts do not leak PII", () => {
+    const ctx = buildSseShedSentryContext(
+      "callback_backpressure",
+      inst,
+      elDelay,
+      2_500,
+    );
+    expect(ctx).not.toHaveProperty("conversation_key");
+    expect(ctx).not.toHaveProperty("conversationKey");
+    expect(JSON.stringify(ctx)).not.toContain("447123456789");
+  });
+
+  test("preserves non-PII per-subscriber and runtime fields", () => {
+    const ctx = buildSseShedSentryContext(
+      "heartbeat_backpressure",
+      inst,
+      elDelay,
+      2_500,
+    );
+    expect(ctx).toMatchObject({
+      reason: "heartbeat_backpressure",
+      subscription_age_ms: 1_500,
+      events_delivered: 7,
+      heartbeats_sent: 3,
+      client_id: "client-xyz",
+      interface_id: "macos",
+      event_loop_delay_mean_ms: 1.2,
+      event_loop_delay_p99_ms: 3.4,
+      event_loop_delay_max_ms: 5.6,
+    });
+  });
+});

package/src/__tests__/avatar-identity-sync.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { ROUTES as AVATAR_ROUTES } from "../runtime/routes/avatar-routes.js";
+import { publishIdentityChanged } from "../runtime/sync/resource-sync-events.js";
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for avatar/identity sync event");
+}
+
+describe("avatar and identity sync events", () => {
+  test("notify_avatar_updated emits legacy avatar event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const route = AVATAR_ROUTES.find(
+        (candidate) => candidate.operationId === "notify_avatar_updated",
+      );
+      expect(route).toBeDefined();
+
+      await route!.handler({});
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "avatar_updated",
+        "sync_changed",
+      ]);
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantAvatar],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("identity changes emit legacy identity event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishIdentityChanged({
+        name: "Sage",
+        role: "Assistant",
+        personality: "Calm",
+        emoji: ":sparkles:",
+        home: "San Francisco",
+      });
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "identity_changed",
+        "sync_changed",
+      ]);
+      expect(received[0].message).toMatchObject({
+        type: "identity_changed",
+        name: "Sage",
+      });
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantIdentity],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+});

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -1,5 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+// Default the warm-pool gate to OPEN — these tests probe background-job
+// disk-pressure behavior, not the pre-first-message guard.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -107,11 +114,13 @@ mock.module("../memory/conversation-crud.js", () => ({
     return { id: "conv-1", ...opts };
   },
   countConversationsByScheduleJobId: mock(() => 0),
+  countMessagesAfter: mock(() => 0),
   deleteMessageById: mock(() => {}),
   clearAll: mock(() => ({ conversations: 0, messages: 0 })),
   deleteConversation: mock(() => ({ memoryIds: [] })),
   deleteLastExchange: mock(() => 0),
   findAnalysisConversationFor: mock(() => null),
+  findMostRecentRetrospectiveFor: mock(() => null),
   forkConversation: mock(() => ({ id: "conv-fork" })),
   getConversationOverrideProfile: () => undefined,
   getConversationOverrideProfileFromRow: () => undefined,
@@ -126,6 +135,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => null,
   getMessageById: () => null,
   getMessages: () => [],
+  getMessagesAfter: () => [],
   getMessagesPaginated: () => ({ messages: [], hasMore: false }),
   getTurnTimeBounds: () => null,
   getConversation: () => null,
@@ -175,6 +185,7 @@ mock.module("../memory/jobs-store.js", () => ({
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),
   upsertDebouncedJob: mock(() => "job-debounced"),
+  upsertMemoryRetrospectiveJob: mock(() => "job-memory-retrospective"),
 }));
 
 const mockMaybeRunDbMaintenance = mock(() => {});
@@ -187,7 +198,6 @@ mock.module("../memory/cleanup-schedule-state.js", () => ({
   markScheduledCleanupEnqueued: mock(() => {}),
 }));
 
-const { startFeedScheduler } = await import("../home/feed-scheduler.js");
 const { runMemoryJobsOnce } = await import("../memory/jobs-worker.js");
 const { FilingService } = await import("../filing/filing-service.js");
 const { WorkspaceHeartbeatService } =
@@ -202,27 +212,6 @@ describe("background workers disk pressure gate", () => {
     mockMaybeRunDbMaintenance.mockClear();
   });
 
-  test("home feed scheduler skips producers while locked", async () => {
-    const gmailDigestRunner = mock(async () => null);
-    const rollupRunner = mock(async () => ({
-      wroteCount: 1,
-      skippedReason: "empty_items" as const,
-    }));
-    const handle = startFeedScheduler({
-      runOnStart: false,
-      gmailCountSource: async () => 0,
-      gmailDigestRunner,
-      rollupRunner,
-    });
-
-    const summary = await handle.runOnce(new Date("2026-05-05T12:00:00.000Z"));
-    handle.stop();
-
-    expect(summary).toEqual({ gmailDigestRan: false, rollupRan: false });
-    expect(gmailDigestRunner).not.toHaveBeenCalled();
-    expect(rollupRunner).not.toHaveBeenCalled();
-  });
-
   test("memory jobs worker skips before claiming or maintenance writes", async () => {
     const processed = await runMemoryJobsOnce({ enableScheduledCleanup: true });
 

package/src/__tests__/btw-routes.test.ts

@@ -320,6 +320,7 @@ describe("POST /v1/btw", () => {
     expect(mockBuildSystemPrompt).toHaveBeenCalledWith({
       channelPersona: null,
       excludeBootstrap: true,
+      excludeCustomPrefix: true,
       userPersona: null,
       userSlug: null,
     });