@vellumai/assistant 0.8.2 → 0.8.3

package/src/__tests__/date-context.test.ts

@@ -4,6 +4,7 @@ import { UiConfigSchema } from "../config/schemas/platform.js";
 import {
   canonicalizeTimeZone,
   extractUserTimeZoneFromRecall,
+  formatLocalTimestamp,
   formatTurnTimestamp,
   resolveTurnTimezoneContext,
 } from "../daemon/date-context.js";
@@ -321,3 +322,47 @@ describe("formatTurnTimestamp", () => {
     expect(result).not.toContain("24:");
   });
 });
+
+// ---------------------------------------------------------------------------
+// formatLocalTimestamp
+// ---------------------------------------------------------------------------
+
+describe("formatLocalTimestamp", () => {
+  // 2026-05-11T17:30:00Z is 10:30 PDT (UTC-7, DST in effect).
+  const utcMidday = Date.parse("2026-05-11T17:30:00Z");
+
+  test("defaults to UTC when no timeZone is provided", () => {
+    expect(formatLocalTimestamp(utcMidday)).toBe("2026-05-11 17:30:00");
+  });
+
+  test("explicit UTC matches the no-timezone default", () => {
+    expect(formatLocalTimestamp(utcMidday, "UTC")).toBe("2026-05-11 17:30:00");
+  });
+
+  test("renders in America/Los_Angeles when configured", () => {
+    expect(formatLocalTimestamp(utcMidday, "America/Los_Angeles")).toBe(
+      "2026-05-11 10:30:00",
+    );
+  });
+
+  test("renders in Asia/Tokyo when configured", () => {
+    // UTC+9 — 17:30 UTC is 02:30 next-day local.
+    expect(formatLocalTimestamp(utcMidday, "Asia/Tokyo")).toBe(
+      "2026-05-12 02:30:00",
+    );
+  });
+
+  test("handles a DST spring-forward boundary correctly", () => {
+    // 2026-03-08 06:30:00Z is 01:30 EST. The 02:00 → 03:00 spring-forward
+    // in America/New_York happens at 07:00 UTC. 07:30 UTC is 03:30 EDT.
+    const beforeJump = Date.parse("2026-03-08T06:30:00Z");
+    const afterJump = Date.parse("2026-03-08T07:30:00Z");
+
+    expect(formatLocalTimestamp(beforeJump, "America/New_York")).toBe(
+      "2026-03-08 01:30:00",
+    );
+    expect(formatLocalTimestamp(afterJump, "America/New_York")).toBe(
+      "2026-03-08 03:30:00",
+    );
+  });
+});

package/src/__tests__/external-plugin-loader.test.ts

@@ -223,9 +223,9 @@ describe("loadExternalPlugin — hooks", () => {
     );
     expect(typeof registered?.hooks?.init).toBe("function");
     await registered?.hooks?.init?.({} as never);
-    expect(
-      (globalThis as Record<string, unknown>).__externalInitCalled,
-    ).toBe(true);
+    expect((globalThis as Record<string, unknown>).__externalInitCalled).toBe(
+      true,
+    );
     delete (globalThis as Record<string, unknown>).__externalInitCalled;
   });
 
@@ -290,9 +290,9 @@ describe("loadExternalPlugin — hooks", () => {
     expect(Object.keys(registered?.hooks ?? {})).toEqual(["init"]);
     expect(typeof registered?.hooks?.init).toBe("function");
     await registered?.hooks?.init?.({} as never);
-    expect((globalThis as Record<string, unknown>).__externalDtsInitCalled).toBe(
-      true,
-    );
+    expect(
+      (globalThis as Record<string, unknown>).__externalDtsInitCalled,
+    ).toBe(true);
     delete (globalThis as Record<string, unknown>).__externalDtsInitCalled;
   });
 
@@ -345,7 +345,6 @@ describe("loadExternalPlugin — tools", () => {
       dir,
       "tools/alpha.ts",
       `export default {
-  name: "two_tools_alpha",
   description: "alpha",
   defaultRiskLevel: "low" as const,
   input_schema: { type: "object", properties: {}, required: [] },
@@ -357,7 +356,6 @@ describe("loadExternalPlugin — tools", () => {
       dir,
       "tools/beta.ts",
       `export default {
-  name: "two_tools_beta",
   description: "beta",
   defaultRiskLevel: "low" as const,
   input_schema: { type: "object", properties: {}, required: [] },
@@ -374,7 +372,7 @@ describe("loadExternalPlugin — tools", () => {
     const names = (registered?.tools ?? []).map(
       (t) => (t as { name: string }).name,
     );
-    expect(names).toEqual(["two_tools_alpha", "two_tools_beta"]);
+    expect(names).toEqual(["alpha", "beta"]);
   });
 
   test("plugin.tools is undefined when tools/ is absent", async () => {
@@ -403,18 +401,95 @@ describe("loadExternalPlugin — tools", () => {
     expect(registeredNames()).toHaveLength(0);
   });
 
-  test("a tool default export missing string name is logged and skipped", async () => {
-    const dir = freshPluginDir("tool-no-name");
-    writePackageJson(dir, { name: "tool-no-name", version: "0.1.0" });
+  test("a tool default export with missing fields loads with documented defaults", async () => {
+    const dir = freshPluginDir("tool-with-defaults");
+    writePackageJson(dir, { name: "tool-with-defaults", version: "0.1.0" });
+    // The default export is a bare empty object — no description,
+    // defaultRiskLevel, input_schema, or execute. The loader must fill
+    // each slot with its documented default and still register the plugin.
+    writeSurfaceFile(dir, "tools/empty.ts", `export default {};\n`);
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "tool-with-defaults",
+    );
+    expect(registered).toBeDefined();
+    const tools = (registered?.tools ?? []) as Array<{
+      name: string;
+      description: string;
+      defaultRiskLevel: string;
+      input_schema: Record<string, unknown>;
+      execute: (
+        input: Record<string, unknown>,
+        context: unknown,
+      ) => Promise<{ content: string; isError: boolean }>;
+    }>;
+    expect(tools).toHaveLength(1);
+    const empty = tools[0]!;
+    expect(empty.name).toBe("empty");
+    expect(empty.description).toBe("");
+    expect(empty.defaultRiskLevel).toBe("medium");
+    expect(empty.input_schema).toEqual({
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    });
+    expect(typeof empty.execute).toBe("function");
+
+    const result = await empty.execute({}, {} as unknown);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("empty");
+    expect(result.content).toContain("no execute implementation");
+  });
+
+  test("a partial tool default export merges author fields with defaults", async () => {
+    const dir = freshPluginDir("tool-partial-defaults");
+    writePackageJson(dir, {
+      name: "tool-partial-defaults",
+      version: "0.1.0",
+    });
+    // Author supplies only description + execute; the loader must default
+    // defaultRiskLevel and input_schema while keeping the author's fields.
     writeSurfaceFile(
       dir,
-      "tools/nameless.ts",
-      `export default { description: "missing name" };\n`,
+      "tools/partial.ts",
+      `export default {
+  description: "custom description",
+  async execute() {
+    return { content: "ran", isError: false };
+  },
+};
+`,
     );
 
     await loadExternalPlugin(dir);
 
-    expect(registeredNames()).toHaveLength(0);
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "tool-partial-defaults",
+    );
+    const tool = (registered?.tools ?? [])[0] as
+      | {
+          description: string;
+          defaultRiskLevel: string;
+          input_schema: object;
+          execute: (
+            input: Record<string, unknown>,
+            context: unknown,
+          ) => Promise<{ content: string; isError: boolean }>;
+        }
+      | undefined;
+    expect(tool).toBeDefined();
+    expect(tool?.description).toBe("custom description");
+    expect(tool?.defaultRiskLevel).toBe("medium");
+    expect(tool?.input_schema).toEqual({
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    });
+    const result = await tool!.execute({}, {} as unknown);
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("ran");
   });
 });
 
@@ -474,9 +549,6 @@ describe("loadExternalPlugin — end-to-end @vellumai/simple-memory", () => {
     const toolNames = (registered?.tools ?? [])
       .map((t) => (t as { name: string }).name)
       .sort();
-    expect(toolNames).toEqual([
-      "simple_memory_recall",
-      "simple_memory_remember",
-    ]);
+    expect(toolNames).toEqual(["recall", "remember"]);
   });
 });

package/src/__tests__/guardian-action-no-hardcoded-copy.test.ts

@@ -20,7 +20,6 @@ const SCANNED_FILES = [
   "calls/call-controller.ts",
   "calls/guardian-action-sweep.ts",
   "runtime/routes/inbound-message-handler.ts",
-  "runtime/guardian-action-conversation-turn.ts",
   "daemon/conversation-process.ts",
 ];
 

package/src/__tests__/guardian-dispatch.test.ts

@@ -295,6 +295,7 @@ describe("guardian-dispatch", () => {
       conversationId: "conv-from-thread-created",
       title: "Guardian alert",
       sourceEventName: "guardian.question",
+      silent: false,
     };
     mockEmitResult = {
       signalId: "sig-4",

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 }));