@vellumai/assistant 0.8.12 → 0.9.0-staging.1

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -50,7 +50,11 @@ describe("schedule_syntax column migration", () => {
         reuse_conversation INTEGER NOT NULL DEFAULT 0,
         script TEXT,
         wake_conversation_id TEXT,
+        workflow_name TEXT,
+        workflow_args_json TEXT,
         timeout_ms INTEGER,
+        inference_profile TEXT,
+        capabilities_json TEXT,
         description TEXT NOT NULL DEFAULT '',
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
@@ -138,6 +142,16 @@ describe("schedule_syntax column migration", () => {
     } catch {
       /* already exists */
     }
+    try {
+      raw.exec(`ALTER TABLE cron_jobs ADD COLUMN workflow_name TEXT`);
+    } catch {
+      /* already exists */
+    }
+    try {
+      raw.exec(`ALTER TABLE cron_jobs ADD COLUMN workflow_args_json TEXT`);
+    } catch {
+      /* already exists */
+    }
     migrateScheduleSourceConversation(db);
     migrateScheduleDescription(db);
 
@@ -203,6 +217,16 @@ describe("schedule_syntax column migration", () => {
     } catch {
       /* ok */
     }
+    try {
+      raw.exec(`ALTER TABLE cron_jobs ADD COLUMN workflow_name TEXT`);
+    } catch {
+      /* ok */
+    }
+    try {
+      raw.exec(`ALTER TABLE cron_jobs ADD COLUMN workflow_args_json TEXT`);
+    } catch {
+      /* ok */
+    }
     migrateScheduleSourceConversation(db);
     migrateScheduleSourceConversation(db);
     migrateScheduleDescription(db);

package/src/__tests__/dynamic-page-surface.test.ts

@@ -125,6 +125,56 @@ describe("ui_show dynamic_page app substitute guard", () => {
     expect(proxied).toBe(false);
   });
 
+  test("rejects dynamic_page with empty data and does not proxy", async () => {
+    let proxied = false;
+
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "dynamic_page",
+        title: "SKILL.md — elevenlabs-tts",
+        activity: "Reopening SKILL.md with rendered content",
+        data: {},
+      },
+      {
+        conversationId: "conversation-123",
+        workingDir: "/tmp",
+        trustClass: "guardian",
+        proxyToolResolver: async () => {
+          proxied = true;
+          return { content: "proxied", isError: false };
+        },
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("data.html");
+    expect(proxied).toBe(false);
+  });
+
+  test("rejects dynamic_page with whitespace-only html and does not proxy", async () => {
+    let proxied = false;
+
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "dynamic_page",
+        title: "Blank",
+        data: { html: "   \n  " },
+      },
+      {
+        conversationId: "conversation-123",
+        workingDir: "/tmp",
+        trustClass: "guardian",
+        proxyToolResolver: async () => {
+          proxied = true;
+          return { content: "proxied", isError: false };
+        },
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(proxied).toBe(false);
+  });
+
   test("allows transient non-app dynamic_page surfaces", async () => {
     let proxied = false;
 
@@ -156,6 +206,81 @@ describe("ui_show dynamic_page app substitute guard", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// task_progress ui_show appends the update hint to its return value
+// ---------------------------------------------------------------------------
+
+describe("ui_show task_progress update hint", () => {
+  const ctx = {
+    conversationId: "conversation-123",
+    workingDir: "/tmp",
+    trustClass: "guardian" as const,
+    proxyToolResolver: async () => ({
+      content: "Surface displayed (surface_id: surf-1).",
+      isError: false,
+    }),
+  };
+
+  test("appends the ui_update hint after a task_progress card is shown", async () => {
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "card",
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Surface displayed (surface_id: surf-1).");
+    expect(result.content).toContain("call ui_update with this surface_id");
+  });
+
+  test("recognizes task_progress nested under data", async () => {
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "card",
+        data: {
+          template: "task_progress",
+          templateData: { status: "in_progress" },
+        },
+      },
+      ctx,
+    );
+
+    expect(result.content).toContain("call ui_update with this surface_id");
+  });
+
+  test("does not append the hint for a non-task_progress card", async () => {
+    const result = await uiShowTool.execute(
+      { surface_type: "card", data: { title: "Plain", body: "hi" } },
+      ctx,
+    );
+
+    expect(result.content).toBe("Surface displayed (surface_id: surf-1).");
+  });
+
+  test("does not append the hint when the surface call errors", async () => {
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "card",
+        template: "task_progress",
+        templateData: { status: "in_progress" },
+      },
+      {
+        ...ctx,
+        proxyToolResolver: async () => ({
+          content: "blocked on this channel",
+          isError: true,
+        }),
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe("blocked on this channel");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // UiSurfaceShowDynamicPage structure
 // ---------------------------------------------------------------------------

package/src/__tests__/empty-state-greeting-cache.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Unit tests for the empty-state greeting cache
+ * (runtime/routes/empty-state-greeting-cache.ts).
+ *
+ * Validates TTL round-tripping, expiry, and the TTL=0 "always regenerate"
+ * behavior that disables caching entirely.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — defined before importing the module under test
+// ---------------------------------------------------------------------------
+
+const checkpointStore = new Map<string, string>();
+
+mock.module("../memory/checkpoints.js", () => ({
+  getMemoryCheckpoint: (key: string) => checkpointStore.get(key) ?? null,
+  setMemoryCheckpoint: (key: string, value: string) => {
+    checkpointStore.set(key, value);
+  },
+}));
+
+let cacheTtlMs = 4 * 60 * 60 * 1000;
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ ui: { emptyStateGreetingCacheTtlMs: cacheTtlMs } }),
+}));
+
+// ---------------------------------------------------------------------------
+// Imports (after mocks)
+// ---------------------------------------------------------------------------
+
+import {
+  getCachedEmptyStateGreeting,
+  setCachedEmptyStateGreeting,
+} from "../runtime/routes/empty-state-greeting-cache.js";
+
+const TIMESTAMP_KEY = "empty_state:greeting:cached_at";
+
+beforeEach(() => {
+  cacheTtlMs = 4 * 60 * 60 * 1000;
+});
+
+afterEach(() => {
+  checkpointStore.clear();
+});
+
+describe("empty-state greeting cache", () => {
+  test("returns null when the cache is empty", () => {
+    expect(getCachedEmptyStateGreeting()).toBeNull();
+  });
+
+  test("round-trips set then get within the TTL", () => {
+    setCachedEmptyStateGreeting("hey there");
+    expect(getCachedEmptyStateGreeting()).toBe("hey there");
+  });
+
+  test("returns null once the TTL is exceeded", () => {
+    setCachedEmptyStateGreeting("stale");
+    checkpointStore.set(
+      TIMESTAMP_KEY,
+      String(Date.now() - (4 * 60 + 1) * 60 * 1000),
+    );
+    expect(getCachedEmptyStateGreeting()).toBeNull();
+  });
+
+  test("returns the cached value just within the TTL", () => {
+    setCachedEmptyStateGreeting("fresh enough");
+    checkpointStore.set(
+      TIMESTAMP_KEY,
+      String(Date.now() - (3 * 60 + 59) * 60 * 1000),
+    );
+    expect(getCachedEmptyStateGreeting()).toBe("fresh enough");
+  });
+
+  test("TTL of 0 disables caching: writes are skipped and reads miss", () => {
+    cacheTtlMs = 0;
+    setCachedEmptyStateGreeting("should not persist");
+    expect(checkpointStore.size).toBe(0);
+    expect(getCachedEmptyStateGreeting()).toBeNull();
+  });
+
+  test("TTL of 0 ignores a value cached while caching was enabled", () => {
+    setCachedEmptyStateGreeting("cached while on");
+    cacheTtlMs = 0;
+    expect(getCachedEmptyStateGreeting()).toBeNull();
+  });
+
+  test("returns null when the timestamp checkpoint is missing", () => {
+    checkpointStore.set("empty_state:greeting:text", "orphaned");
+    expect(getCachedEmptyStateGreeting()).toBeNull();
+  });
+});

package/src/__tests__/gateway-flag-listener.test.ts

@@ -2,7 +2,7 @@ import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach,beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Isolated temp directory for the IPC socket
@@ -48,12 +48,23 @@ mock.module("../runtime/sync/sync-publisher.js", () => ({
   },
 }));
 
+// ---------------------------------------------------------------------------
+// Track calls to syncFlagGatedTools so we can assert the listener registers
+// newly-enabled flag-gated tools after a runtime refresh (not just the cache).
+// ---------------------------------------------------------------------------
+let syncToolsCallCount = 0;
+
+mock.module("../tools/registry.js", () => ({
+  syncFlagGatedTools: async () => {
+    syncToolsCallCount++;
+  },
+}));
+
 // ---------------------------------------------------------------------------
 // Dynamic imports (after mock.module)
 // ---------------------------------------------------------------------------
-const { startGatewayFlagListener, stopGatewayFlagListener } = await import(
-  "../ipc/gateway-flag-listener.js"
-);
+const { startGatewayFlagListener, stopGatewayFlagListener } =
+  await import("../ipc/gateway-flag-listener.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -104,6 +115,7 @@ describe("gateway-flag-listener", () => {
   beforeEach(() => {
     mkdirSync(testRoot, { recursive: true });
     refreshCallCount = 0;
+    syncToolsCallCount = 0;
     publishedTagSets = [];
     testServer = createTestServer();
   });
@@ -123,7 +135,7 @@ describe("gateway-flag-listener", () => {
     }
   });
 
-  test("refreshes flag cache on connect and on feature_flags_changed event", async () => {
+  test("refreshes flag cache AND syncs gated tools on connect and on feature_flags_changed event", async () => {
     await new Promise<void>((resolve) => {
       testServer.server.listen(socketPath, resolve);
     });
@@ -133,11 +145,17 @@ describe("gateway-flag-listener", () => {
     await new Promise((r) => setTimeout(r, 100));
 
     expect(refreshCallCount).toBe(1);
+    // Connect must also sync gated tools, so a flag flipped while disconnected
+    // registers its tools without waiting for a restart.
+    expect(syncToolsCallCount).toBe(1);
 
     testServer.emit("feature_flags_changed");
     await new Promise((r) => setTimeout(r, 100));
 
     expect(refreshCallCount).toBe(2);
+    // The runtime flag change must register newly-enabled tools too — not just
+    // refresh the cache (the bug: routes pass the gate but tools stay absent).
+    expect(syncToolsCallCount).toBe(2);
   });
 
   test("broadcasts feature-flags sync_changed when flags change", async () => {
@@ -207,8 +225,7 @@ describe("gateway-flag-listener", () => {
     const countAfterReconnect = refreshCallCount;
     expect(countAfterReconnect).toBeGreaterThan(0);
 
-    const payload =
-      JSON.stringify({ event: "feature_flags_changed" }) + "\n";
+    const payload = JSON.stringify({ event: "feature_flags_changed" }) + "\n";
     secondClient!.write(payload);
     await new Promise((r) => setTimeout(r, 200));
 

package/src/__tests__/guardian-action-sweep.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -18,27 +18,11 @@ mock.module("../runtime/gateway-client.js", () => ({
   },
 }));
 
-import {
-  createCallSession,
-  createPendingQuestion,
-  getPendingQuestion,
-} from "../calls/call-store.js";
-import {
-  startGuardianActionSweep,
-  stopGuardianActionSweep,
-  sweepExpiredGuardianActions,
-} from "../calls/guardian-action-sweep.js";
+import type { ExpiryDeliveryInfo } from "../calls/guardian-action-sweep.js";
+import { sendGuardianExpiryNotices } from "../calls/guardian-action-sweep.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
-import {
-  createGuardianActionDelivery,
-  createGuardianActionRequest,
-  getDeliveriesByRequestId,
-  getGuardianActionRequest,
-  updateDeliveryStatus,
-} from "../memory/guardian-action-store.js";
-import { conversations } from "../memory/schema.js";
-import { resetDbForTesting } from "./db-test-helpers.js";
+import { conversations, messages } from "../memory/schema.js";
 
 initializeDb();
 
@@ -55,218 +39,71 @@ function ensureConversation(id: string): void {
     .run();
 }
 
-function resetTables(): void {
-  const db = getDb();
-  db.run("DELETE FROM guardian_action_deliveries");
-  db.run("DELETE FROM guardian_action_requests");
-  db.run("DELETE FROM call_pending_questions");
-  db.run("DELETE FROM call_events");
-  db.run("DELETE FROM call_sessions");
-  db.run("DELETE FROM messages");
-  db.run("DELETE FROM conversations");
-  deliveredMessages.length = 0;
+function makeDelivery(
+  overrides: Partial<ExpiryDeliveryInfo> = {},
+): ExpiryDeliveryInfo {
+  return {
+    id: "delivery-1",
+    status: "sent",
+    destinationChannel: "telegram",
+    destinationConversationId: null,
+    destinationChatId: "chat-123",
+    ...overrides,
+  };
 }
 
-describe("guardian-action-sweep", () => {
+describe("sendGuardianExpiryNotices", () => {
   beforeEach(() => {
-    resetTables();
-  });
-
-  afterAll(() => {
-    stopGuardianActionSweep();
-    resetDbForTesting();
+    const db = getDb();
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+    deliveredMessages.length = 0;
   });
 
-  test("sweepExpiredGuardianActions expires requests past their expiresAt", async () => {
-    const convId = "conv-sweep-1";
-    ensureConversation(convId);
-
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "What is the code?");
-
-    // Create request that has already expired
-    const request = createGuardianActionRequest({
-      kind: "ask_guardian",
-      sourceChannel: "phone",
-      sourceConversationId: convId,
-      callSessionId: session.id,
-      pendingQuestionId: pq.id,
-      questionText: pq.questionText,
-      expiresAt: Date.now() - 10_000, // expired 10s ago
-    });
-
-    ensureConversation("conv-mac-1");
-    createGuardianActionDelivery({
-      requestId: request.id,
-      destinationChannel: "vellum",
-      destinationConversationId: "conv-mac-1",
-    });
-    updateDeliveryStatus(
-      getDeliveriesByRequestId(request.id).find(
-        (d) => d.destinationChannel === "vellum",
-      )!.id,
-      "sent",
+  test("sends external channel expiry notices for sent deliveries", async () => {
+    await sendGuardianExpiryNotices(
+      [makeDelivery({ status: "sent" }), makeDelivery({ id: "d2", status: "pending", destinationChatId: "chat-456" })],
+      "assistant-1",
     );
 
-    await sweepExpiredGuardianActions();
-
-    const updatedRequest = getGuardianActionRequest(request.id);
-    expect(updatedRequest).not.toBeNull();
-    expect(updatedRequest!.status).toBe("expired");
-
-    const deliveries = getDeliveriesByRequestId(request.id);
-    expect(deliveries).toHaveLength(1);
-    expect(deliveries[0].status).toBe("expired");
-  });
-
-  test("sweepExpiredGuardianActions expires pending questions", async () => {
-    const convId = "conv-sweep-2";
-    ensureConversation(convId);
-
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "What is the gate code?");
-
-    createGuardianActionRequest({
-      kind: "ask_guardian",
-      sourceChannel: "phone",
-      sourceConversationId: convId,
-      callSessionId: session.id,
-      pendingQuestionId: pq.id,
-      questionText: pq.questionText,
-      expiresAt: Date.now() - 5_000,
-    });
-
-    // Verify the question is still pending before sweep
-    expect(getPendingQuestion(session.id)).not.toBeNull();
-
-    await sweepExpiredGuardianActions();
-
-    // Pending question should be expired
-    expect(getPendingQuestion(session.id)).toBeNull();
+    expect(deliveredMessages).toHaveLength(2);
+    expect(deliveredMessages[0].url).toBe("/deliver/telegram");
+    expect(deliveredMessages[0].body.chatId).toBe("chat-123");
+    expect(deliveredMessages[0].body.assistantId).toBe("assistant-1");
+    expect(deliveredMessages[1].body.chatId).toBe("chat-456");
   });
 
-  test("sweepExpiredGuardianActions does nothing when no expired requests exist", async () => {
-    const convId = "conv-sweep-3";
-    ensureConversation(convId);
-
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "Still valid?");
-
-    // Request that expires in the future
-    const request = createGuardianActionRequest({
-      kind: "ask_guardian",
-      sourceChannel: "phone",
-      sourceConversationId: convId,
-      callSessionId: session.id,
-      pendingQuestionId: pq.id,
-      questionText: pq.questionText,
-      expiresAt: Date.now() + 60_000, // expires in 60s
-    });
-
-    await sweepExpiredGuardianActions();
-
-    const updatedRequest = getGuardianActionRequest(request.id);
-    expect(updatedRequest!.status).toBe("pending");
-    expect(getPendingQuestion(session.id)).not.toBeNull();
-  });
-
-  test("sweepExpiredGuardianActions sends external channel expiry notices for sent deliveries", async () => {
-    const convId = "conv-sweep-4";
-    ensureConversation(convId);
-
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "External question?");
-
-    const request = createGuardianActionRequest({
-      kind: "ask_guardian",
-      sourceChannel: "phone",
-      sourceConversationId: convId,
-      callSessionId: session.id,
-      pendingQuestionId: pq.id,
-      questionText: pq.questionText,
-      expiresAt: Date.now() - 5_000,
-    });
-
-    const delivery = createGuardianActionDelivery({
-      requestId: request.id,
-      destinationChannel: "telegram",
-      destinationChatId: "chat-123",
-    });
-    updateDeliveryStatus(delivery.id, "sent");
-
-    await sweepExpiredGuardianActions();
-
-    // Wait for the fire-and-forget async delivery to complete
-    await new Promise((resolve) => setTimeout(resolve, 50));
-
-    // The external delivery should trigger an HTTP POST to the gateway
-    expect(deliveredMessages.length).toBeGreaterThanOrEqual(1);
-  });
-
-  test("sweepExpiredGuardianActions skips failed deliveries", async () => {
-    const convId = "conv-sweep-5";
-    ensureConversation(convId);
-
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "Skip this?");
-
-    const request = createGuardianActionRequest({
-      kind: "ask_guardian",
-      sourceChannel: "phone",
-      sourceConversationId: convId,
-      callSessionId: session.id,
-      pendingQuestionId: pq.id,
-      questionText: pq.questionText,
-      expiresAt: Date.now() - 5_000,
-    });
-
-    const delivery = createGuardianActionDelivery({
-      requestId: request.id,
-      destinationChannel: "telegram",
-      destinationChatId: "chat-456",
-    });
-    updateDeliveryStatus(delivery.id, "failed", "Network error");
-
-    deliveredMessages.length = 0;
-
-    await sweepExpiredGuardianActions();
+  test("skips deliveries that are not sent or pending", async () => {
+    await sendGuardianExpiryNotices(
+      [
+        makeDelivery({ status: "failed" }),
+        makeDelivery({ id: "d2", status: "expired" }),
+      ],
+      "assistant-1",
+    );
 
-    // Should NOT have sent an expiry notice for a failed delivery
     expect(deliveredMessages).toHaveLength(0);
   });
 
-  test("startGuardianActionSweep and stopGuardianActionSweep manage timer", () => {
-    startGuardianActionSweep();
-    // Calling start again should be a no-op (idempotent)
-    startGuardianActionSweep();
+  test("adds an expiry message to vellum guardian conversations", async () => {
+    ensureConversation("guardian-conv");
+
+    await sendGuardianExpiryNotices(
+      [
+        makeDelivery({
+          destinationChannel: "vellum",
+          destinationConversationId: "guardian-conv",
+          destinationChatId: null,
+        }),
+      ],
+      "assistant-1",
+    );
 
-    stopGuardianActionSweep();
-    // Calling stop again should be safe
-    stopGuardianActionSweep();
+    expect(deliveredMessages).toHaveLength(0);
+    const db = getDb();
+    const rows = db.select().from(messages).all();
+    expect(rows).toHaveLength(1);
+    expect(rows[0].conversationId).toBe("guardian-conv");
+    expect(rows[0].content).toContain("expired");
   });
 });