@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/runtime/routes/__tests__/conversation-surface-routes.test.ts

@@ -0,0 +1,322 @@
+/**
+ * Tests for the conversation surface API — the explicit opt-in that promotes
+ * a background/scheduled conversation into the default ("standard")
+ * conversation listing so clients show it in the Recents sidebar grouping.
+ *
+ * Exercises:
+ *  - POST /v1/conversations/:id/surface (set + clear, validation, 404)
+ *  - GET  /v1/conversations default listing inclusion of surfaced rows
+ *  - GET  /v1/conversations?conversationType=background|scheduled unchanged
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Stub the event hub to avoid spinning up real SSE infrastructure.
+mock.module("../../assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => () => {},
+  },
+  broadcastMessage: () => {},
+}));
+
+// Spy on the sync publish so we can assert the invalidation fires after a
+// successful write without standing up the real broadcast machinery.
+const publishedListAndMetadata: Array<{
+  reason: string;
+  conversationIds: string | string[];
+}> = [];
+mock.module("../../sync/resource-sync-events.js", () => ({
+  publishConversationListChanged: () => {},
+  publishConversationTitleChanged: () => {},
+  publishConversationListAndMetadataChanged: (
+    reason: string,
+    conversationIds: string | string[],
+  ) => {
+    publishedListAndMetadata.push({ reason, conversationIds });
+  },
+}));
+
+import {
+  createConversation,
+  getConversation,
+} from "../../../memory/conversation-crud.js";
+import { getDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { conversations } from "../../../memory/schema.js";
+import { ROUTES as CONVERSATION_LIST_ROUTES } from "../conversation-list-routes.js";
+import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../conversation-management-routes.js";
+import { BadRequestError, NotFoundError } from "../errors.js";
+import type { RouteDefinition } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// DB bootstrap
+// ---------------------------------------------------------------------------
+
+initializeDb();
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findHandler(routes: RouteDefinition[], operationId: string) {
+  const route = routes.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+const surfaceHandler = findHandler(
+  CONVERSATION_MANAGEMENT_ROUTES,
+  "surfaceConversation",
+);
+const listHandler = findHandler(CONVERSATION_LIST_ROUTES, "listConversations");
+const reorderHandler = findHandler(
+  CONVERSATION_MANAGEMENT_ROUTES,
+  "reorderConversations",
+);
+
+interface SurfaceResponse {
+  ok: boolean;
+  conversationId: string;
+  surfacedAt: number | null;
+}
+
+interface ConversationSummary {
+  id: string;
+  title: string;
+  conversationType: string;
+  surfacedAt?: number;
+}
+
+interface ListResponse {
+  conversations: ConversationSummary[];
+  nextOffset: number;
+  hasMore: boolean;
+}
+
+function clearConversations(): void {
+  getDb().delete(conversations).run();
+}
+
+function seed(
+  title: string,
+  conversationType: "standard" | "background" | "scheduled",
+): string {
+  return createConversation({ title, conversationType, source: "test" }).id;
+}
+
+function listIds(queryParams: Record<string, string> = {}): string[] {
+  const response = listHandler({ queryParams }) as ListResponse;
+  return response.conversations.map((c) => c.id);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("POST /v1/conversations/:id/surface", () => {
+  beforeEach(() => {
+    clearConversations();
+    publishedListAndMetadata.length = 0;
+  });
+
+  test("surfaces a background conversation and returns the timestamp", () => {
+    const id = seed("Background run", "background");
+    const before = Date.now();
+    const response = surfaceHandler({
+      pathParams: { id },
+      body: { surfaced: true },
+    }) as SurfaceResponse;
+    expect(response.ok).toBe(true);
+    expect(response.conversationId).toBe(id);
+    expect(response.surfacedAt).toBeGreaterThanOrEqual(before);
+  });
+
+  test("publishes a shape-changing list invalidation after the write", () => {
+    const id = seed("Background run", "background");
+    surfaceHandler({ pathParams: { id }, body: { surfaced: true } });
+    expect(publishedListAndMetadata).toEqual([
+      { reason: "reordered", conversationIds: id },
+    ]);
+  });
+
+  test("clearing returns surfacedAt null", () => {
+    const id = seed("Background run", "background");
+    surfaceHandler({ pathParams: { id }, body: { surfaced: true } });
+    const response = surfaceHandler({
+      pathParams: { id },
+      body: { surfaced: false },
+    }) as SurfaceResponse;
+    expect(response.surfacedAt).toBeNull();
+  });
+
+  test("404s for an unknown conversation id", () => {
+    expect(() =>
+      surfaceHandler({
+        pathParams: { id: crypto.randomUUID() },
+        body: { surfaced: true },
+      }),
+    ).toThrow(NotFoundError);
+  });
+
+  test("400s when surfaced is missing or not a boolean", () => {
+    const id = seed("Background run", "background");
+    expect(() => surfaceHandler({ pathParams: { id }, body: {} })).toThrow(
+      BadRequestError,
+    );
+    expect(() =>
+      surfaceHandler({ pathParams: { id }, body: { surfaced: "yes" } }),
+    ).toThrow(BadRequestError);
+  });
+});
+
+describe("GET /v1/conversations — surfaced rows in the default listing", () => {
+  beforeEach(() => {
+    clearConversations();
+    publishedListAndMetadata.length = 0;
+  });
+
+  test("background/scheduled rows stay out of the default listing until surfaced", () => {
+    const standardId = seed("Standard chat", "standard");
+    seed("Background run", "background");
+    seed("Scheduled run", "scheduled");
+    expect(listIds()).toEqual([standardId]);
+  });
+
+  test("surfacing promotes a background conversation into the default listing", () => {
+    const standardId = seed("Standard chat", "standard");
+    const backgroundId = seed("Background run", "background");
+    surfaceHandler({
+      pathParams: { id: backgroundId },
+      body: { surfaced: true },
+    });
+
+    const response = listHandler({ queryParams: {} }) as ListResponse;
+    expect(response.conversations.map((c) => c.id).sort()).toEqual(
+      [standardId, backgroundId].sort(),
+    );
+    const surfaced = response.conversations.find((c) => c.id === backgroundId)!;
+    expect(surfaced.conversationType).toBe("background");
+    expect(surfaced.surfacedAt).toBeGreaterThan(0);
+    const standard = response.conversations.find((c) => c.id === standardId)!;
+    expect(standard.surfacedAt).toBeUndefined();
+  });
+
+  test("surfacing promotes a scheduled conversation into the default listing", () => {
+    const scheduledId = seed("Scheduled run", "scheduled");
+    surfaceHandler({
+      pathParams: { id: scheduledId },
+      body: { surfaced: true },
+    });
+    expect(listIds()).toEqual([scheduledId]);
+  });
+
+  test("clearing the promotion removes the row from the default listing again", () => {
+    const backgroundId = seed("Background run", "background");
+    surfaceHandler({
+      pathParams: { id: backgroundId },
+      body: { surfaced: true },
+    });
+    expect(listIds()).toEqual([backgroundId]);
+
+    surfaceHandler({
+      pathParams: { id: backgroundId },
+      body: { surfaced: false },
+    });
+    expect(listIds()).toEqual([]);
+  });
+
+  test("filtered background/scheduled listings keep returning surfaced rows", () => {
+    const backgroundId = seed("Background run", "background");
+    const scheduledId = seed("Scheduled run", "scheduled");
+    surfaceHandler({
+      pathParams: { id: backgroundId },
+      body: { surfaced: true },
+    });
+    surfaceHandler({
+      pathParams: { id: scheduledId },
+      body: { surfaced: true },
+    });
+
+    // "background" is the back-compat umbrella (background + scheduled).
+    expect(listIds({ conversationType: "background" }).sort()).toEqual(
+      [backgroundId, scheduledId].sort(),
+    );
+    expect(listIds({ conversationType: "scheduled" })).toEqual([scheduledId]);
+  });
+
+  test("moving a surfaced conversation to system:background clears the promotion", () => {
+    const backgroundId = seed("Background run", "background");
+    surfaceHandler({
+      pathParams: { id: backgroundId },
+      body: { surfaced: true },
+    });
+    expect(listIds()).toEqual([backgroundId]);
+
+    // Move-to-Group sends only groupId/isPinned through the reorder
+    // endpoint — the demotion out of Recents must happen in the same
+    // server-side write, with no second API call from the client.
+    reorderHandler({
+      body: {
+        updates: [
+          { conversationId: backgroundId, groupId: "system:background" },
+        ],
+      },
+    });
+
+    expect(getConversation(backgroundId)?.surfacedAt).toBeNull();
+    expect(listIds()).toEqual([]);
+    expect(listIds({ conversationType: "background" })).toEqual([backgroundId]);
+  });
+
+  test("moving a surfaced conversation to system:scheduled clears the promotion", () => {
+    const scheduledId = seed("Scheduled run", "scheduled");
+    surfaceHandler({
+      pathParams: { id: scheduledId },
+      body: { surfaced: true },
+    });
+    expect(listIds()).toEqual([scheduledId]);
+
+    reorderHandler({
+      body: {
+        updates: [{ conversationId: scheduledId, groupId: "system:scheduled" }],
+      },
+    });
+
+    expect(getConversation(scheduledId)?.surfacedAt).toBeNull();
+    expect(listIds()).toEqual([]);
+  });
+
+  test("moving a surfaced conversation to a non-demoting group keeps the promotion", () => {
+    const backgroundId = seed("Background run", "background");
+    surfaceHandler({
+      pathParams: { id: backgroundId },
+      body: { surfaced: true },
+    });
+
+    reorderHandler({
+      body: {
+        updates: [{ conversationId: backgroundId, groupId: "system:all" }],
+      },
+    });
+
+    expect(getConversation(backgroundId)?.surfacedAt).toBeGreaterThan(0);
+  });
+
+  test("archived surfaced rows stay out of the default (active) listing", () => {
+    const backgroundId = seed("Background run", "background");
+    surfaceHandler({
+      pathParams: { id: backgroundId },
+      body: { surfaced: true },
+    });
+    getDb().update(conversations).set({ archivedAt: Date.now() }).run();
+    expect(listIds()).toEqual([]);
+  });
+});

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -29,7 +29,6 @@ mock.module("../../../util/logger.js", () => ({
 
 // ── Real imports (after mocks) ────────────────────────────────────────────────
 
-import { setOverridesForTesting } from "../../../__tests__/feature-flag-test-helpers.js";
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import { providerConnections } from "../../../memory/schema/inference.js";
@@ -91,7 +90,6 @@ function seedConnection(opts: {
 beforeEach(() => {
   clearConnections();
   fakeConfig = {};
-  setOverridesForTesting({ "openai-compatible-endpoints": true });
 });
 
 // ── GET list ─────────────────────────────────────────────────────────────────
@@ -160,36 +158,6 @@ describe("GET inference/provider-connections (list)", () => {
     expect(result.connections).toEqual([]);
   });
 
-  test("hides openai-compatible rows when the feature flag is disabled", async () => {
-    setOverridesForTesting({ "openai-compatible-endpoints": false });
-    seedConnection({
-      name: "my-openai",
-      provider: "openai",
-      auth: { type: "platform" },
-    });
-    seedConnection({
-      name: "my-compatible",
-      provider: "openai-compatible",
-      auth: { type: "api_key", credential: "ref/k" },
-    });
-
-    const result = (await call(
-      findHandler("inference_provider_connections_list"),
-      {},
-    )) as { connections: Array<{ name: string }> };
-
-    expect(result.connections.map((c) => c.name)).toEqual(["my-openai"]);
-  });
-
-  test("rejects openai-compatible provider filter when the feature flag is disabled", async () => {
-    setOverridesForTesting({ "openai-compatible-endpoints": false });
-
-    await expect(
-      call(findHandler("inference_provider_connections_list"), {
-        queryParams: { provider: "openai-compatible" },
-      }),
-    ).rejects.toBeInstanceOf(BadRequestError);
-  });
 });
 
 // ── GET single ────────────────────────────────────────────────────────────────
@@ -219,20 +187,6 @@ describe("GET inference/provider-connections/:name (single)", () => {
     ).rejects.toBeInstanceOf(NotFoundError);
   });
 
-  test("throws 404 for openai-compatible row when the feature flag is disabled", async () => {
-    setOverridesForTesting({ "openai-compatible-endpoints": false });
-    seedConnection({
-      name: "my-compatible",
-      provider: "openai-compatible",
-      auth: { type: "api_key", credential: "ref/k" },
-    });
-
-    await expect(
-      call(findHandler("inference_provider_connections_get"), {
-        pathParams: { name: "my-compatible" },
-      }),
-    ).rejects.toBeInstanceOf(NotFoundError);
-  });
 });
 
 // ── POST create ───────────────────────────────────────────────────────────────
@@ -317,22 +271,6 @@ describe("POST inference/provider-connections (create)", () => {
     ).rejects.toBeInstanceOf(BadRequestError);
   });
 
-  test("rejects openai-compatible creation when the feature flag is disabled", async () => {
-    setOverridesForTesting({ "openai-compatible-endpoints": false });
-
-    await expect(
-      call(findHandler("inference_provider_connections_create"), {
-        body: {
-          name: "my-compatible",
-          provider: "openai-compatible",
-          auth: { type: "api_key", credential: "ref/k" },
-          base_url: "http://localhost:8080/v1",
-          models: [{ id: "local-model" }],
-        },
-      }),
-    ).rejects.toBeInstanceOf(BadRequestError);
-  });
-
   test("throws 400 when auth schema is invalid (api_key without credential)", async () => {
     await expect(
       call(findHandler("inference_provider_connections_create"), {

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -369,8 +369,12 @@ describe("GET /v1/plugins/search", () => {
       catalog(ref, [
         {
           name: "simple-memory",
-          path: "experimental/plugins/simple-memory",
-          source: { kind: "first-party" },
+          path: "github:vellum-ai/simple-memory@ed09a4c01bf18e4ac8859faee94cb65c7cbd1ca3",
+          source: {
+            kind: "github",
+            repo: "vellum-ai/simple-memory",
+            ref: "ed09a4c01bf18e4ac8859faee94cb65c7cbd1ca3",
+          },
         },
         {
           name: "caveman",
@@ -402,8 +406,12 @@ describe("GET /v1/plugins/search", () => {
       matches: [
         {
           name: "simple-memory",
-          path: "experimental/plugins/simple-memory",
-          source: { kind: "first-party" },
+          path: "github:vellum-ai/simple-memory@ed09a4c01bf18e4ac8859faee94cb65c7cbd1ca3",
+          source: {
+            kind: "github",
+            repo: "vellum-ai/simple-memory",
+            ref: "ed09a4c01bf18e4ac8859faee94cb65c7cbd1ca3",
+          },
         },
       ],
     });
@@ -458,7 +466,7 @@ describe("GET /v1/plugins/search", () => {
   test("PluginCatalogUnavailableError → ServiceUnavailableError (503)", async () => {
     getCatalogSpy.mockImplementation(async () => {
       throw new PluginCatalogUnavailableError(
-        "GitHub contents listing failed for experimental/plugins @ main: HTTP 403",
+        "GitHub contents listing failed for plugins @ main: HTTP 403",
         403,
       );
     });
@@ -489,8 +497,12 @@ describe("GET /v1/plugins/search", () => {
     const frozenMatches = Object.freeze([
       Object.freeze({
         name: "a",
-        path: "experimental/plugins/a",
-        source: { kind: "first-party" } as const,
+        path: "github:acme/a@bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+        source: {
+          kind: "github",
+          repo: "acme/a",
+          ref: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+        } as const,
       }),
     ]) as readonly PluginSearchMatch[];
     getCatalogSpy.mockImplementation(async (ref) =>
@@ -506,7 +518,11 @@ describe("GET /v1/plugins/search", () => {
       result.matches.push({
         name: "b",
         path: "x",
-        source: { kind: "first-party" },
+        source: {
+          kind: "github",
+          repo: "acme/b",
+          ref: "cccccccccccccccccccccccccccccccccccccccc",
+        },
       }),
     ).not.toThrow();
   });
@@ -620,7 +636,11 @@ function pluginDetails(overrides: Partial<PluginDetails> = {}): PluginDetails {
     homepage: overrides.homepage ?? null,
     license: overrides.license ?? null,
     version: overrides.version ?? null,
-    source: overrides.source ?? { kind: "first-party" },
+    source: overrides.source ?? {
+      kind: "github",
+      repo: "JuliusBrussee/caveman",
+      ref: "63a91ecadbf4c4719a4602a5abb00883f9966034",
+    },
     readme: overrides.readme ?? null,
     ref: overrides.ref ?? "main",
   };
@@ -766,8 +786,8 @@ describe("POST /v1/plugins/install", () => {
 
   test("ignores a caller-supplied ref and pins to the curated default", async () => {
     // Security boundary: installing from an unreviewed ref (a PR branch,
-    // fork ref, ...) could load attacker-controlled marketplace/first-party
-    // code, so the HTTP route never honors a body `ref` — it always resolves
+    // fork ref, ...) could load attacker-controlled marketplace code, so the
+    // HTTP route never honors a body `ref` — it always resolves
     // against the curated default ref.
     installSpy.mockImplementation(async (opts) => ({
       name: opts.name,

package/src/runtime/routes/acp-routes.test.ts

@@ -39,6 +39,7 @@ import {
 import { installAcpConfigStub } from "../../acp/__tests__/helpers/acp-config-stub.js";
 import { installWhichStub } from "../../acp/__tests__/helpers/which-stub.js";
 import type { AcpSessionState } from "../../acp/index.js";
+import * as pendingInteractions from "../pending-interactions.js";
 
 const config = await installAcpConfigStub();
 const which = installWhichStub();
@@ -170,6 +171,31 @@ mock.module("../../tools/credentials/broker.js", () => ({
   },
 }));
 
+// Drive the spawn route's high-risk approval gate (ATL-822). `spawnSession`
+// registers a `directResolve` confirmation in `pendingInteractions` and then
+// broadcasts a `confirmation_request`. Real broadcasting needs the event hub /
+// SSE wiring, so the mock auto-resolves the freshly registered interaction
+// the same way `POST /v1/confirm` would (resolve + directResolve). Tests flip
+// `approvalBehavior` to exercise allow / deny, and read `confirmationRequests`
+// to assert the prompt's risk shape. `interaction_resolved` and other event
+// types are ignored.
+type ApprovalBehavior = "allow" | "deny";
+let approvalBehavior: ApprovalBehavior = "allow";
+const confirmationRequests: Array<Record<string, unknown>> = [];
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: { type?: string; requestId?: string }) => {
+    if (msg?.type !== "confirmation_request") return;
+    confirmationRequests.push(msg as Record<string, unknown>);
+    const decision = approvalBehavior;
+    const interaction = pendingInteractions.resolve(
+      msg.requestId as string,
+      decision === "allow" ? "approved" : "rejected",
+    );
+    interaction?.directResolve?.(decision);
+  },
+}));
+
 import { eq } from "drizzle-orm";
 
 import { getDb, getSqlite } from "../../memory/db-connection.js";
@@ -193,6 +219,8 @@ beforeEach(() => {
   capturedSpawns.length = 0;
   vaultStore.clear();
   metadataStore.clear();
+  approvalBehavior = "allow";
+  confirmationRequests.length = 0;
 });
 
 // ---------------------------------------------------------------------------
@@ -224,6 +252,84 @@ describe("POST /v1/acp/spawn", () => {
     await expect(handler({ body: { agent: "claude" } })).rejects.toThrow(
       "agent, task, and conversationId are required",
     );
+    // Guard runs before the approval gate — no prompt is surfaced.
+    expect(confirmationRequests).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// POST /v1/acp/spawn — high-risk approval gate (ATL-822)
+//
+// Spawning an ACP agent is a host subprocess with auto-allowed
+// filesystem/terminal access. The skill-tool path gets the descriptor's
+// `risk: "high"` prompt via ToolExecutor; this route reaches the session
+// manager directly, so it surfaces the same confirmation itself and refuses
+// to spawn unless a guardian approves.
+// ---------------------------------------------------------------------------
+
+describe("POST /v1/acp/spawn — approval gate", () => {
+  test("surfaces a high-risk host confirmation before spawning", async () => {
+    seedVaultToken("test-token-abc123");
+
+    const handler = getSpawnHandler();
+    await handler({
+      body: {
+        agent: "claude",
+        task: "do a thing",
+        conversationId: "conv-1",
+        cwd: "/work/repo",
+      },
+    });
+
+    expect(confirmationRequests).toHaveLength(1);
+    const prompt = confirmationRequests[0];
+    expect(prompt.toolName).toBe("acp_spawn");
+    expect(prompt.riskLevel).toBe("high");
+    expect(prompt.executionTarget).toBe("host");
+    expect(prompt.conversationId).toBe("conv-1");
+    expect((prompt.input as { cwd?: string }).cwd).toBe("/work/repo");
+    // Prompt resolved "allow" → spawn proceeds.
+    expect(capturedSpawns).toHaveLength(1);
+  });
+
+  test("throws ForbiddenError and does not spawn when the guardian denies", async () => {
+    approvalBehavior = "deny";
+    seedVaultToken("test-token-abc123");
+
+    const handler = getSpawnHandler();
+    await expect(
+      handler({
+        body: {
+          agent: "claude",
+          task: "do a thing",
+          conversationId: "conv-1",
+        },
+      }),
+    ).rejects.toThrow(/guardian approval/i);
+
+    // Denied before any host side effects: no subprocess, no pending leak.
+    expect(capturedSpawns).toHaveLength(0);
+    expect(pendingInteractions.getAll()).toHaveLength(0);
+  });
+
+  test("denies (and does not spawn) when the client disconnects before approval", async () => {
+    seedVaultToken("test-token-abc123");
+    const controller = new AbortController();
+    controller.abort();
+
+    const handler = getSpawnHandler();
+    await expect(
+      handler({
+        body: {
+          agent: "claude",
+          task: "do a thing",
+          conversationId: "conv-1",
+        },
+        abortSignal: controller.signal,
+      }),
+    ).rejects.toThrow(/guardian approval/i);
+
+    expect(capturedSpawns).toHaveLength(0);
   });
 });