@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/heartbeat-service.test.ts

@@ -43,6 +43,7 @@ let mockConfig = {
     timezone: null as string | null,
     activeHoursStart: undefined as number | undefined,
     activeHoursEnd: undefined as number | undefined,
+    disposition: "Default disposition text mentioning notifications skill.",
   },
 };
 
@@ -386,6 +387,7 @@ describe("HeartbeatService", () => {
         timezone: null,
         activeHoursStart: undefined,
         activeHoursEnd: undefined,
+        disposition: "Default disposition text mentioning notifications skill.",
       },
     };
   });
@@ -418,8 +420,7 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls[0].conversationId).toBe("conv-1");
     expect(processMessageCalls[0].content).toContain("<heartbeat-checklist>");
     expect(processMessageCalls[0].content).toContain("<heartbeat-disposition>");
-    expect(processMessageCalls[0].content).toContain("HEARTBEAT_OK");
-    expect(processMessageCalls[0].content).toContain("HEARTBEAT_ALERT");
+    expect(processMessageCalls[0].content).toContain("notifications skill");
   });
 
   test("HEARTBEAT.md content is embedded in prompt when file exists", async () => {
@@ -750,30 +751,13 @@ describe("HeartbeatService", () => {
     });
   });
 
-  test("HEARTBEAT_ALERT emits a notification signal and surfaces the conversation", async () => {
+  test("conversation surfaces to the sidebar on every successful run", async () => {
     const conversationCreatedCalls: Array<{
       conversationId: string;
       title: string;
     }> = [];
     const service = createService({
       onConversationCreated: (info) => conversationCreatedCalls.push(info),
-      processMessage: async (...args: unknown[]) => {
-        const conversationId = args[0] as string;
-        mockStoredMessages.push({
-          id: "assistant-alert-1",
-          conversationId,
-          role: "assistant",
-          content: JSON.stringify([
-            {
-              type: "text",
-              text: "The first heartbeat found a concrete follow-up for the guardian.\nHEARTBEAT_ALERT",
-            },
-          ]),
-          createdAt: Date.now(),
-          metadata: null,
-        });
-        return { messageId: "user-heartbeat-1" };
-      },
     });
 
     await service.runOnce();
@@ -782,113 +766,6 @@ describe("HeartbeatService", () => {
     expect(conversationCreatedCalls).toEqual([
       { conversationId: "conv-1", title: "Heartbeat" },
     ]);
-    expect(emittedNotificationSignals).toHaveLength(1);
-    expect(emittedNotificationSignals[0]).toMatchObject({
-      sourceEventName: "heartbeat.alert",
-      sourceChannel: "watcher",
-      sourceContextId: "mock-run-id",
-      dedupeKey: "heartbeat:alert:mock-run-id",
-      attentionHints: {
-        requiresAction: true,
-        urgency: "medium",
-        isAsyncBackground: true,
-        visibleInSourceNow: false,
-      },
-      conversationAffinityHint: { vellum: "conv-1" },
-      conversationMetadata: {
-        source: "heartbeat",
-        groupId: "system:background",
-      },
-    });
-    expect(emittedNotificationSignals[0].contextPayload.summary).toBe(
-      "The first heartbeat found a concrete follow-up for the guardian.",
-    );
-    expect(emittedNotificationSignals[0].contextPayload.messageId).toBe(
-      "assistant-alert-1",
-    );
-    expect(
-      emittedNotificationSignals[0].contextPayload.sourceInterface,
-    ).toBeUndefined();
-  });
-
-  test("HEARTBEAT_OK stays silent", async () => {
-    const conversationCreatedCalls: Array<{
-      conversationId: string;
-      title: string;
-    }> = [];
-    const service = createService({
-      onConversationCreated: (info) => conversationCreatedCalls.push(info),
-      processMessage: async (...args: unknown[]) => {
-        const conversationId = args[0] as string;
-        mockStoredMessages.push({
-          id: "assistant-ok-1",
-          conversationId,
-          role: "assistant",
-          content: JSON.stringify([
-            {
-              type: "text",
-              text: "Everything looks good.\nHEARTBEAT_OK",
-            },
-          ]),
-          createdAt: Date.now(),
-          metadata: null,
-        });
-        return { messageId: "user-heartbeat-1" };
-      },
-    });
-
-    await service.runOnce();
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    // The conversation surfaces to the sidebar via the runner's bootstrap
-    // callback for *every* heartbeat — "silent OK" means no notification
-    // signal is emitted, not that the conversation is hidden.
-    expect(conversationCreatedCalls).toHaveLength(1);
-    expect(emittedNotificationSignals).toHaveLength(0);
-  });
-
-  test("HEARTBEAT_OK stays silent when earlier content mentions HEARTBEAT_ALERT", async () => {
-    const conversationCreatedCalls: Array<{
-      conversationId: string;
-      title: string;
-    }> = [];
-    const service = createService({
-      onConversationCreated: (info) => conversationCreatedCalls.push(info),
-      processMessage: async (...args: unknown[]) => {
-        const conversationId = args[0] as string;
-        mockStoredMessages.push({
-          id: "assistant-ok-2",
-          conversationId,
-          role: "assistant",
-          content: JSON.stringify([
-            {
-              type: "thinking",
-              thinking:
-                "I should decide between HEARTBEAT_ALERT and HEARTBEAT_OK.",
-            },
-            {
-              type: "tool_result",
-              content: "Tool output mentions HEARTBEAT_ALERT.",
-            },
-            {
-              type: "text",
-              text: "I considered HEARTBEAT_ALERT, but there is nothing useful to surface.\nHEARTBEAT_OK",
-            },
-          ]),
-          createdAt: Date.now(),
-          metadata: null,
-        });
-        return { messageId: "user-heartbeat-1" };
-      },
-    });
-
-    await service.runOnce();
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    // Conversation surfaces via the runner bootstrap, but no notification
-    // is emitted since the disposition is OK.
-    expect(conversationCreatedCalls).toHaveLength(1);
-    expect(emittedNotificationSignals).toHaveLength(0);
   });
 
   test("end-to-end: llm.callSites.heartbeatAgent.speed resolves to 'fast'", async () => {
@@ -1524,43 +1401,6 @@ describe("HeartbeatService", () => {
       });
     });
 
-    test("CAS false suppresses success surfacing", async () => {
-      mockCompleteHeartbeatRun.mockImplementation(() => false);
-
-      const conversationCreatedCalls: Array<{
-        conversationId: string;
-        title: string;
-      }> = [];
-      const service = createService({
-        onConversationCreated: (info) => conversationCreatedCalls.push(info),
-        processMessage: async (...args: unknown[]) => {
-          const conversationId = args[0] as string;
-          mockStoredMessages.push({
-            id: "assistant-alert-1",
-            conversationId,
-            role: "assistant",
-            content: JSON.stringify([
-              {
-                type: "text",
-                text: "Something worth surfacing.\nHEARTBEAT_ALERT",
-              },
-            ]),
-            createdAt: Date.now(),
-            metadata: null,
-          });
-          return { messageId: "msg-1" };
-        },
-      });
-      await service.runOnce();
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      // The bootstrap-time surface fires regardless of CAS (it happens
-      // before completeHeartbeatRun). CAS-false suppresses the alert
-      // notification emit but not the sidebar entry.
-      expect(conversationCreatedCalls).toHaveLength(1);
-      expect(emittedNotificationSignals).toHaveLength(0);
-    });
-
     test("CAS false suppresses failure alerter and feed event", async () => {
       mockCompleteHeartbeatRun.mockImplementation(() => false);
 
@@ -1836,4 +1676,24 @@ describe("HeartbeatService", () => {
       expect(processMessageCalls[0].content).not.toContain("<early-heartbeat>");
     });
   });
+
+  describe("configurable disposition", () => {
+    test("injects the configured disposition inside <heartbeat-disposition>", () => {
+      mockConfig.heartbeat.disposition = "Marker text from config.";
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 10);
+
+      expect(prompt).toContain(
+        "<heartbeat-disposition>\nMarker text from config.\n</heartbeat-disposition>",
+      );
+    });
+
+    test("omits the block when disposition is empty", () => {
+      mockConfig.heartbeat.disposition = "";
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 10);
+
+      expect(prompt).not.toContain("<heartbeat-disposition>");
+    });
+  });
 });

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -65,7 +65,6 @@ import type {
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
   GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
   MessageProcessor,
 } from "../../runtime/http-types.js";
 import {
@@ -113,7 +112,6 @@ export async function handleChannelInbound(
   _approvalCopyGenerator?: ApprovalCopyGenerator,
   _approvalConversationGenerator?: ApprovalConversationGenerator,
   _guardianActionCopyGenerator?: GuardianActionCopyGenerator,
-  _guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator,
 ): Promise<Response> {
   const body = await req.json();
   return wrapHandler(() => _handleChannelInbound({ body }));

package/src/__tests__/helpers/tar-fixtures.ts

@@ -0,0 +1,39 @@
+export function makeTarEntry(name: string, content: string): Buffer {
+  const header = Buffer.alloc(512, 0);
+  const nameBuffer = Buffer.from(name, "utf-8");
+  nameBuffer.copy(header, 0, 0, Math.min(nameBuffer.length, 100));
+
+  Buffer.from("0000644\0", "ascii").copy(header, 100);
+  Buffer.from("0000000\0", "ascii").copy(header, 108);
+  Buffer.from("0000000\0", "ascii").copy(header, 116);
+  Buffer.from(
+    `${content.length.toString(8).padStart(11, "0")}\0`,
+    "ascii",
+  ).copy(header, 124);
+  Buffer.from("00000000000\0", "ascii").copy(header, 136);
+  Buffer.from("        ", "ascii").copy(header, 148);
+  header[156] = "0".charCodeAt(0);
+  Buffer.from("ustar\0", "ascii").copy(header, 257);
+  Buffer.from("00", "ascii").copy(header, 263);
+
+  let sum = 0;
+  for (let i = 0; i < 512; i += 1) sum += header[i] ?? 0;
+  Buffer.from(`${sum.toString(8).padStart(6, "0")}\0 `, "ascii").copy(
+    header,
+    148,
+  );
+
+  const data = Buffer.from(content, "utf-8");
+  const padded = Buffer.alloc(Math.ceil(data.length / 512) * 512, 0);
+  data.copy(padded);
+  return Buffer.concat([header, padded]);
+}
+
+export function makeTar(
+  entries: Array<{ name: string; content: string }>,
+): Buffer {
+  return Buffer.concat([
+    ...entries.map((entry) => makeTarEntry(entry.name, entry.content)),
+    Buffer.alloc(1024, 0),
+  ]);
+}

package/src/__tests__/helpers/wait-for.ts

@@ -0,0 +1,21 @@
+export async function waitFor(
+  predicate: () => boolean | Promise<boolean>,
+  options: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    message?: string;
+  } = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 500;
+  const intervalMs = options.intervalMs ?? 5;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+
+  throw new Error(options.message ?? "Timed out waiting for test condition");
+}

package/src/__tests__/history-repair-pipeline.test.ts

@@ -248,7 +248,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "observer-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: observer },
     });
@@ -297,7 +296,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "override-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: shortCircuit },
     });
@@ -342,7 +340,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "late-user-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: userMiddleware },
     });

package/src/__tests__/history-repair.test.ts

@@ -766,6 +766,79 @@ describe("repairHistory", () => {
         (b as { text: string }).text.includes("srvtoolu_orphan"),
     );
     expect(downgraded).toBeDefined();
+    // Titles/URLs from the original results must survive the downgrade so
+    // the model can still reason about what was searched.
+    const text = (downgraded as { text: string }).text;
+    expect(text).toContain("Example");
+    expect(text).toContain("https://example.com");
+  });
+
+  test("preserves all titles/URLs when downgrading multi-result orphan", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_multi",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://alpha.test",
+                title: "Alpha",
+                encrypted_content: "enc_a",
+              },
+              {
+                type: "web_search_result",
+                url: "https://beta.test",
+                title: "Beta",
+                encrypted_content: "enc_b",
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired } = repairHistory(messages);
+    const downgraded = repaired[1].content.find((b) => b.type === "text") as
+      | { text: string }
+      | undefined;
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("Alpha");
+    expect(downgraded!.text).toContain("https://alpha.test");
+    expect(downgraded!.text).toContain("Beta");
+    expect(downgraded!.text).toContain("https://beta.test");
+    // Must NOT emit the legacy fixed placeholder.
+    expect(downgraded!.text).not.toContain("[web search result]");
+  });
+
+  test("downgrades error-envelope web_search orphan to a stable marker", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_err",
+            content: {
+              type: "web_search_tool_result_error",
+              error_code: "unavailable",
+            },
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired } = repairHistory(messages);
+    const downgraded = repaired[1].content.find((b) => b.type === "text") as
+      | { text: string }
+      | undefined;
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("srvtoolu_err");
+    expect(downgraded!.text).toContain("results unavailable");
   });
 
   test("repairs both orphan directions within the same assistant message", () => {