@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/conversation-surfaces-table-action.test.ts

@@ -0,0 +1,360 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createSurfaceMutex,
+  handleSurfaceAction,
+  type SurfaceConversationContext,
+} from "../daemon/conversation-surfaces.js";
+import type {
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+} from "../daemon/message-protocol.js";
+
+/**
+ * Build a minimal SurfaceConversationContext for testing table surface actions.
+ * Tracks calls to enqueueMessage and processMessage so tests can assert
+ * whether an LLM turn was triggered with the correct content.
+ */
+function makeContext(): SurfaceConversationContext & {
+  enqueueCalls: Array<{
+    content: string;
+    requestId: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }>;
+  processCalls: Array<{
+    content: string;
+    requestId?: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }>;
+  sentMessages: ServerMessage[];
+} {
+  const enqueueCalls: Array<{
+    content: string;
+    requestId: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }> = [];
+  const processCalls: Array<{
+    content: string;
+    requestId?: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }> = [];
+  const sentMessages: ServerMessage[] = [];
+
+  return {
+    conversationId: "test-convo",
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg) => sentMessages.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map(),
+    surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: (
+      content,
+      attachments,
+      _onEvent,
+      requestId,
+      surfaceId,
+      _currentPage,
+      _metadata,
+      _options,
+      displayContent,
+    ) => {
+      enqueueCalls.push({
+        content,
+        requestId: requestId ?? "enq-req",
+        attachments,
+        surfaceId,
+        displayContent,
+      });
+      return { queued: false, requestId: requestId ?? "enq-req" };
+    },
+    getQueueDepth: () => 0,
+    processMessage: async (
+      content,
+      attachments,
+      _onEvent,
+      requestId,
+      surfaceId,
+      _currentPage,
+      _options,
+      displayContent,
+    ) => {
+      processCalls.push({
+        content,
+        requestId,
+        attachments,
+        surfaceId,
+        displayContent,
+      });
+      return "ok";
+    },
+    withSurface: createSurfaceMutex(),
+    enqueueCalls,
+    processCalls,
+    sentMessages,
+  };
+}
+
+/**
+ * Register a table surface with selectionMode and action buttons,
+ * mimicking what surfaceProxyResolver does for ui_show with await_action.
+ */
+function registerTableSurface(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+  opts?: {
+    selectionMode?: "single" | "multiple" | "none";
+    rows?: Array<{
+      id: string;
+      cells: Record<string, string>;
+      selectable?: boolean;
+    }>;
+    actions?: Array<{
+      id: string;
+      label: string;
+      style?: string;
+      data?: Record<string, unknown>;
+    }>;
+  },
+): void {
+  const rows = opts?.rows ?? [
+    {
+      id: "r1",
+      cells: { from: "alice@example.com", subject: "Meeting" },
+      selectable: true,
+    },
+    {
+      id: "r2",
+      cells: { from: "bob@example.com", subject: "Update" },
+      selectable: true,
+    },
+    {
+      id: "r3",
+      cells: { from: "carol@example.com", subject: "Invoice" },
+      selectable: true,
+    },
+  ];
+  const actions = opts?.actions ?? [
+    { id: "archive", label: "Archive Selected", style: "primary" },
+    { id: "delete", label: "Delete Selected", style: "destructive" },
+  ];
+
+  const data = {
+    columns: [
+      { id: "from", label: "From" },
+      { id: "subject", label: "Subject" },
+    ],
+    rows,
+    selectionMode: opts?.selectionMode ?? "multiple",
+  };
+
+  ctx.surfaceState.set(surfaceId, {
+    surfaceType: "table",
+    data: data as unknown as SurfaceData,
+    title: "Test Table",
+    actions,
+  });
+
+  ctx.pendingSurfaceActions.set(surfaceId, { surfaceType: "table" });
+}
+
+describe("table surface action with selectedIds", () => {
+  test("action button click with selectedIds triggers LLM message", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-1");
+
+    await handleSurfaceAction(ctx, "table-1", "archive", {
+      selectedIds: ["r1", "r3"],
+    });
+
+    // Should trigger processMessage (not enqueued since not processing)
+    expect(ctx.processCalls).toHaveLength(1);
+    const msg = ctx.processCalls[0];
+
+    // Content should include action summary
+    expect(msg.content).toContain("[User action on table surface:");
+
+    // Content should include selectedIds in action data
+    expect(msg.content).toContain("selectedIds");
+    expect(msg.content).toContain("r1");
+    expect(msg.content).toContain("r3");
+
+    // Content should include deselection description (r2 was not selected)
+    expect(msg.content).toContain("Deselected items");
+    expect(msg.content).toContain("bob@example.com");
+
+    // Should NOT contain alice or carol in deselection (they were selected)
+    expect(msg.content).not.toContain("alice@example.com");
+    expect(msg.content).not.toContain("carol@example.com");
+  });
+
+  test("action button click without selectedIds still triggers LLM message", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-2");
+
+    await handleSurfaceAction(ctx, "table-2", "archive", undefined);
+
+    expect(ctx.processCalls).toHaveLength(1);
+    expect(ctx.processCalls[0].content).toContain(
+      "[User action on table surface:",
+    );
+  });
+
+  test("selectedIds are included via action data merge", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-3");
+
+    await handleSurfaceAction(ctx, "table-3", "archive", {
+      selectedIds: ["r2"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // Action data should contain selectedIds
+    expect(content).toContain('"selectedIds":["r2"]');
+
+    // Deselection should show r1 and r3 (not selected)
+    expect(content).toContain("Deselected items");
+    expect(content).toContain("alice@example.com");
+    expect(content).toContain("carol@example.com");
+  });
+
+  test("pending surface action is cleared after processing", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-4");
+
+    expect(ctx.pendingSurfaceActions.has("table-4")).toBe(true);
+
+    await handleSurfaceAction(ctx, "table-4", "archive", {
+      selectedIds: ["r1"],
+    });
+
+    // Non-dynamic_page pending entries are cleared after action
+    expect(ctx.pendingSurfaceActions.has("table-4")).toBe(false);
+  });
+
+  test("action with stored action data merges with client data", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-5", {
+      actions: [
+        {
+          id: "archive",
+          label: "Archive",
+          style: "primary",
+          data: { destination: "archive-folder" },
+        },
+      ],
+    });
+
+    await handleSurfaceAction(ctx, "table-5", "archive", {
+      selectedIds: ["r1", "r2"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // Both stored action data and client data should be present
+    expect(content).toContain("destination");
+    expect(content).toContain("archive-folder");
+    expect(content).toContain("selectedIds");
+  });
+
+  test("relay_prompt action on table includes selectedIds context", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-6", {
+      actions: [
+        {
+          id: "relay_prompt",
+          label: "Archive",
+          style: "primary",
+          data: { prompt: "Archive these selected items" },
+        },
+      ],
+    });
+
+    await handleSurfaceAction(ctx, "table-6", "relay_prompt", {
+      selectedIds: ["r1"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // relay_prompt should use the prompt as content
+    expect(content).toContain("Archive these selected items");
+
+    // Should also include deselection context
+    expect(content).toContain("Deselected items");
+  });
+
+  test("selection_changed action is non-terminal and does not trigger LLM", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-7");
+
+    await handleSurfaceAction(ctx, "table-7", "selection_changed", {
+      selectedIds: ["r1", "r2"],
+    });
+
+    expect(ctx.enqueueCalls).toHaveLength(0);
+    expect(ctx.processCalls).toHaveLength(0);
+
+    // Pending surface should still be present (not consumed)
+    expect(ctx.pendingSurfaceActions.has("table-7")).toBe(true);
+  });
+
+  test("all rows selected produces no deselection description", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-8");
+
+    await handleSurfaceAction(ctx, "table-8", "archive", {
+      selectedIds: ["r1", "r2", "r3"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // No deselection when all are selected
+    expect(content).not.toContain("Deselected items");
+  });
+
+  test("displayContent is set for non-relay actions", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-9");
+
+    await handleSurfaceAction(ctx, "table-9", "archive", {
+      selectedIds: ["r1"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    // displayContent should be set for non-relay actions
+    expect(ctx.processCalls[0].displayContent).toBeDefined();
+  });
+
+  test("surfaceId is forwarded to processMessage", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-10");
+
+    await handleSurfaceAction(ctx, "table-10", "archive", {
+      selectedIds: ["r1"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    expect(ctx.processCalls[0].surfaceId).toBe("table-10");
+  });
+});

package/src/__tests__/conversation-sync-tags.test.ts

@@ -0,0 +1,235 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
+import {
+  projectAssistantMessage,
+  recordConversationSeenSignal,
+} from "../memory/conversation-attention-store.js";
+import { createConversation } from "../memory/conversation-crud.js";
+import { getDb, resetDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { ROUTES as CONVERSATION_LIST_ROUTES } from "../runtime/routes/conversation-list-routes.js";
+import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../runtime/routes/conversation-management-routes.js";
+import type { RouteDefinition } from "../runtime/routes/types.js";
+import { waitFor } from "./helpers/wait-for.js";
+
+initializeDb();
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function findRoute(
+  routes: RouteDefinition[],
+  operationId: string,
+): RouteDefinition {
+  const route = routes.find(
+    (candidate) => candidate.operationId === operationId,
+  );
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
+  return route;
+}
+
+async function captureEvents(
+  action: () => void | Promise<unknown>,
+  expectedCount: number,
+): Promise<AssistantEvent[]> {
+  const received: AssistantEvent[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    callback: (event) => {
+      received.push(event);
+    },
+  });
+  try {
+    await action();
+    await waitFor(() => received.length >= expectedCount, {
+      message: "Timed out waiting for conversation sync tag event",
+    });
+    return received;
+  } finally {
+    subscription.dispose();
+  }
+}
+
+describe("conversation sync tags", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  afterAll(() => {
+    resetDb();
+  });
+
+  test("rename emits legacy title/list events and conversation metadata sync tags", async () => {
+    const conversation = createConversation("Old title");
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "renameConversation",
+    );
+
+    const received = await captureEvents(() => {
+      route.handler({
+        pathParams: { id: conversation.id },
+        body: { name: "New title" },
+      });
+    }, 3);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_title_updated",
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[2]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+
+  test("create emits legacy list invalidation and list/metadata sync tags", async () => {
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "createConversation",
+    );
+    let conversationId: string | undefined;
+
+    const received = await captureEvents(async () => {
+      const result = (await route.handler({
+        body: { conversationKey: "sync-create-test" },
+      })) as { id: string };
+      conversationId = result.id;
+    }, 2);
+
+    expect(conversationId).toBeDefined();
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversationId!),
+      ],
+    });
+  });
+
+  test("reorder emits list invalidation and metadata sync tags for touched conversations", async () => {
+    const first = createConversation("First");
+    const second = createConversation("Second");
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "reorderConversations",
+    );
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          updates: [
+            { conversationId: first.id, displayOrder: 1, isPinned: true },
+            { conversationId: second.id, displayOrder: 2, isPinned: false },
+          ],
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(first.id),
+        conversationMetadataSyncTag(second.id),
+      ],
+    });
+  });
+
+  test("record seen emits list invalidation and metadata sync tags for the touched conversation", async () => {
+    const conversation = createConversation("Attention");
+    projectAssistantMessage({
+      conversationId: conversation.id,
+      messageId: "assistant-message-1",
+      messageAt: 1_700_000_000_000,
+    });
+    const route = findRoute(CONVERSATION_LIST_ROUTES, "recordConversationSeen");
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          conversationId: conversation.id,
+          sourceChannel: "vellum",
+          signalType: "macos_conversation_opened",
+          confidence: "explicit",
+          source: "test",
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+
+  test("mark unread emits list invalidation and metadata sync tags for the touched conversation", async () => {
+    const conversation = createConversation("Attention");
+    projectAssistantMessage({
+      conversationId: conversation.id,
+      messageId: "assistant-message-1",
+      messageAt: 1_700_000_000_000,
+    });
+    recordConversationSeenSignal({
+      conversationId: conversation.id,
+      sourceChannel: "vellum",
+      signalType: "macos_conversation_opened",
+      confidence: "explicit",
+      source: "test",
+    });
+    const route = findRoute(CONVERSATION_LIST_ROUTES, "markConversationUnread");
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          conversationId: conversation.id,
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+});

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -63,7 +63,11 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { enabled: false, v2: { enabled: false } },
+    memory: {
+      enabled: false,
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -61,7 +61,11 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { enabled: false, v2: { enabled: false } },
+    memory: {
+      enabled: false,
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/credential-security-invariants.test.ts

@@ -189,10 +189,10 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "messaging/providers/slack/adapter.ts", // Slack bot token lookup for Socket Mode connectivity check
       "credential-health/credential-health-service.ts", // proactive credential health monitoring
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
-      "providers/managed-proxy/context.ts", // managed proxy API key lookup for provider initialization
+      "providers/platform-proxy/context.ts", // managed proxy API key lookup for provider initialization
       "platform/client.ts", // platform client credential store fallback for standalone CLI auth
       "mcp/mcp-oauth-provider.ts", // MCP OAuth token/client/discovery persistence
-      "runtime/routes/integrations/slack/share.ts", // Slack share routes credential lookup
+      "runtime/routes/integrations/slack/token.ts", // shared Slack token resolver (bot/user token lookup for CLI use routes)
       "mcp/client.ts", // MCP client cached-token lookup
       "oauth/token-persistence.ts", // OAuth token persistence (set/delete tokens)
       "oauth/credential-token-resolver.ts", // centralized access-token key resolution for OAuth and manual-token providers
@@ -208,9 +208,11 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "config/bundled-skills/image-studio/tools/media-generate-image.ts", // image generation tool API key lookup
       "config/bundled-skills/media-processing/tools/analyze-keyframes.ts", // keyframe analysis tool API key lookup
       "providers/registry.ts", // provider registry API key lookup for initialization
+      "providers/inference/resolve-auth.ts", // provider_connection auth resolver (api_key path reads vault, mirrors registry.ts)
       "providers/provider-availability.ts", // provider availability API key check
       "media/image-credentials.ts", // shared image-gen credential resolver (provider API key lookup)
       "memory/embedding-backend.ts", // embedding backend API key lookup
+      "memory/llm-request-log-source-clickhouse.ts", // ClickHouse read source — lazy lookup of clickhouse:url + clickhouse:password + vellum:platform_assistant_id for self-scoped mirror reads
       "daemon/providers-setup.ts", // provider initialization API key lookup
       "workspace/migrations/006-services-config.ts", // services config migration reads provider API keys
       "workspace/migrations/018-rekey-compound-credential-keys.ts", // re-key compound credential storage keys
@@ -220,22 +222,20 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/lifecycle.ts", // CES client injection into secure-keys at startup
       "daemon/daemon-skill-host.ts", // SkillHost secureKeys facet adapter (delegates to getProviderKeyAsync)
       "runtime/routes/credential-prompt-routes.ts", // Route for secure credential prompt (stores secret via setSecureKeyAsync)
+      "runtime/routes/credential-routes.ts", // CLI credential management routes (CLI-migrated to IPC)
+      "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
+      "plugins/external-api.ts", // globalThis runtime bridge that exposes getSecureKeyAsync to dynamically-imported workspace plugins (compiled-binary plugin loading)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup
       "tts/providers/xai-provider.ts", // xAI TTS API key lookup
-      "meet/session-manager.ts", // Meet bot container provisioning (provider API key lookup for Deepgram/TTS)
       "credential-health/credential-health-service.ts", // credential health check reads access tokens for liveness pings
       "ipc/skill-routes/providers.ts", // skill IPC route exposes provider key lookup to hosted skills
-      "cli/commands/avatar.ts", // CLI avatar command credential lookup
-      "cli/commands/credentials.ts", // CLI credential management commands
+      "runtime/routes/avatar-routes.ts", // avatar generate route reads platform_base_url from credential store
       "cli/commands/keys.ts", // CLI provider key management
       "cli/commands/oauth/connect.ts", // CLI OAuth connect stored-secret verification
-      "cli/commands/platform/connect.ts", // CLI platform connect credential check
-      "cli/commands/platform/disconnect.ts", // CLI platform disconnect credential lookup
-      "cli/commands/platform/index.ts", // CLI platform status credential check
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));