@vellumai/assistant 0.8.12 → 0.9.0-staging.2

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,175 @@ describe("ui_show dynamic_page app substitute guard", () => {
   });
 });
 
+describe("ui_show empty card guard", () => {
+  function makeCtx(onProxy: () => void) {
+    return {
+      conversationId: "conversation-123",
+      workingDir: "/tmp",
+      trustClass: "guardian" as const,
+      proxyToolResolver: async () => {
+        onProxy();
+        return { content: "proxied", isError: false };
+      },
+    };
+  }
+
+  test("rejects a card carrying only a title and does not proxy", async () => {
+    let proxied = false;
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "card",
+        title: "Vellum Internal Usage app",
+        activity: "Showing progress",
+        data: {},
+      },
+      makeCtx(() => {
+        proxied = true;
+      }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("card requires content");
+    expect(proxied).toBe(false);
+  });
+
+  test("rejects a card with no content at all", async () => {
+    let proxied = false;
+    const result = await uiShowTool.execute(
+      { surface_type: "card", data: {} },
+      makeCtx(() => {
+        proxied = true;
+      }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(proxied).toBe(false);
+  });
+
+  test("allows a card with a body", async () => {
+    let proxied = false;
+    const result = await uiShowTool.execute(
+      { surface_type: "card", data: { title: "Plain", body: "hi" } },
+      makeCtx(() => {
+        proxied = true;
+      }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(proxied).toBe(true);
+  });
+
+  test("allows a task_progress card with empty data (template renders a shell)", async () => {
+    let proxied = false;
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "card",
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      },
+      makeCtx(() => {
+        proxied = true;
+      }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(proxied).toBe(true);
+  });
+
+  test("allows an action-only card", async () => {
+    let proxied = false;
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "card",
+        title: "Confirm",
+        actions: [{ id: "ok", label: "OK" }],
+        data: {},
+      },
+      makeCtx(() => {
+        proxied = true;
+      }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(proxied).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 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));