@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/channel-availability-routes.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Tests for `assistant/src/runtime/routes/channel-availability-routes.ts`.
+ *
+ * The handler returns a fixed base list (`slack`, `telegram`, `phone`) and
+ * appends `email` when the platform reports at least one registered email
+ * address for this assistant. Platform failures fall back to base-only.
+ *
+ * Each entry is hydrated with display metadata from `CHANNEL_METADATA`
+ * (label, subtitle, icon, supportsVerification, setupMessages) so clients
+ * never need to carry per-channel switches.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { CHANNEL_METADATA } from "../channels/types.js";
+
+// ---------------------------------------------------------------------------
+// Mock state — flipped per-test
+// ---------------------------------------------------------------------------
+
+let mockPlatformAssistantId: string | null = "assistant-test-id";
+let mockEmailAddressesResponse: {
+  ok: boolean;
+  status: number;
+  body: unknown;
+} = {
+  ok: true,
+  status: 200,
+  body: { count: 0, results: [] },
+};
+let mockFetchThrows = false;
+
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () => ({
+      platformAssistantId: mockPlatformAssistantId,
+      fetch: async (_path: string) => {
+        if (mockFetchThrows) {
+          throw new Error("platform unreachable");
+        }
+        return {
+          ok: mockEmailAddressesResponse.ok,
+          status: mockEmailAddressesResponse.status,
+          json: async () => mockEmailAddressesResponse.body,
+        };
+      },
+    }),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { ROUTES } from "../runtime/routes/channel-availability-routes.js";
+
+const handler = ROUTES[0]!.handler;
+
+interface ChannelEntry {
+  id: string;
+  label: string;
+  subtitle: string;
+  icon: string;
+  supportsVerification: boolean;
+  setupMessages: { guardian: string; contact: string };
+}
+interface HandlerResult {
+  channels: ChannelEntry[];
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("channels/available", () => {
+  beforeEach(() => {
+    mockPlatformAssistantId = "assistant-test-id";
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 0, results: [] },
+    };
+    mockFetchThrows = false;
+  });
+
+  test("base list only when no email address registered", async () => {
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("appends email when at least one address registered (count field)", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 1, results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+      "email",
+    ]);
+  });
+
+  test("appends email when results non-empty even without count field", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toContain("email");
+  });
+
+  test("base list only when platform returns non-ok", async () => {
+    mockEmailAddressesResponse = {
+      ok: false,
+      status: 500,
+      body: { detail: "boom" },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("base list only when platform fetch throws (best-effort)", async () => {
+    mockFetchThrows = true;
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("base list only when no platformAssistantId on client", async () => {
+    mockPlatformAssistantId = null;
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("each channel entry carries display metadata from CHANNEL_METADATA", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 1, results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    for (const channel of result.channels) {
+      const expected = (CHANNEL_METADATA as any)[channel.id];
+      expect(expected).toBeDefined();
+      expect(channel).toEqual(expected);
+    }
+  });
+
+  test("email metadata: not verification-capable, mail icon", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 1, results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+    const email = result.channels.find((c) => c.id === "email");
+
+    expect(email).toBeDefined();
+    expect(email!.icon).toBe("mail");
+    expect(email!.label).toBe("Email");
+    expect(email!.supportsVerification).toBe(false);
+  });
+
+  test("slack/telegram/phone are all verification-capable", async () => {
+    const result = (await handler({})) as HandlerResult;
+    for (const id of ["slack", "telegram", "phone"]) {
+      const ch = result.channels.find((c) => c.id === id);
+      expect(ch).toBeDefined();
+      expect(ch!.supportsVerification).toBe(true);
+      expect(ch!.setupMessages.guardian.length).toBeGreaterThan(0);
+      expect(ch!.setupMessages.contact.length).toBeGreaterThan(0);
+    }
+  });
+});

package/src/__tests__/channel-delivery-store.test.ts

@@ -30,6 +30,11 @@ import {
   recordProcessingFailure,
   replayDeadLetters,
 } from "../memory/delivery-status.js";
+import {
+  getBindingByChannelChat,
+  getBindingByChannelChatThread,
+  upsertBinding,
+} from "../memory/external-conversation-store.js";
 import { RETRY_MAX_ATTEMPTS } from "../memory/job-utils.js";
 import {
   channelInboundEvents,
@@ -37,6 +42,7 @@ import {
   externalConversationBindings,
   messages,
 } from "../memory/schema.js";
+import { buildConversationDetailResponse } from "../runtime/services/conversation-serializer.js";
 import { handleDeleteConversation } from "./helpers/channel-test-adapter.js";
 
 initializeDb();
@@ -50,7 +56,11 @@ function resetTables() {
 }
 
 /** Insert a message row so FK constraints on channel_inbound_events.message_id pass. */
-function insertMessage(id: string, conversationId: string): void {
+function insertMessage(
+  id: string,
+  conversationId: string,
+  metadata?: Record<string, unknown>,
+): void {
   const db = getDb();
   db.insert(messages)
     .values({
@@ -59,6 +69,7 @@ function insertMessage(id: string, conversationId: string): void {
       role: "user",
       content: "test message",
       createdAt: Date.now(),
+      metadata: metadata ? JSON.stringify(metadata) : null,
     })
     .run();
 }
@@ -116,6 +127,226 @@ describe("channel-delivery-store", () => {
     expect(r1.conversationId).toBe(r2.conversationId);
   });
 
+  test("same Slack channel and thread reuses the same conversation", () => {
+    const r1 = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+    const r2 = recordInbound("slack", "C0123ABCDEF", "msg-2", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    expect(r1.conversationId).toBe(r2.conversationId);
+  });
+
+  test("different Slack threads in one channel get different conversations", () => {
+    const r1 = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+    const r2 = recordInbound("slack", "C0123ABCDEF", "msg-2", {
+      sourceThreadId: "1710000000.000200",
+    });
+
+    expect(r1.conversationId).not.toBe(r2.conversationId);
+  });
+
+  test("legacy Slack channel key with matching inbound root ts gets aliased to the threaded key", () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000100";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: threadTs,
+    });
+
+    const threaded = recordInbound("slack", channelId, "thread-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000001.000100",
+    });
+
+    expect(threaded.conversationId).toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(legacy.conversationId);
+  });
+
+  test("legacy Slack channel key with matching slackMeta.threadTs evidence gets aliased to the threaded key", () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000200";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: "1710000000.999999",
+    });
+    insertMessage("legacy-thread-message", legacy.conversationId, {
+      slackMeta: JSON.stringify({
+        source: "slack",
+        channelId,
+        channelTs: "1710000001.000200",
+        threadTs,
+        eventKind: "message",
+      }),
+    });
+
+    const threaded = recordInbound("slack", channelId, "thread-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000002.000200",
+    });
+
+    expect(threaded.conversationId).toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(legacy.conversationId);
+  });
+
+  test("legacy Slack thread evidence scan is bounded when metadata does not prove the thread", () => {
+    const channelId = "C0123ABCDEF";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: "1710000000.000100",
+    });
+    for (let i = 0; i < 550; i++) {
+      insertMessage(`legacy-thread-message-${i}`, legacy.conversationId, {
+        slackMeta: JSON.stringify({
+          source: "slack",
+          channelId,
+          channelTs: `1710000001.${String(i).padStart(6, "0")}`,
+          threadTs: "1710000000.000100",
+          eventKind: "message",
+        }),
+      });
+    }
+    insertMessage("legacy-thread-message-target", legacy.conversationId, {
+      slackMeta: JSON.stringify({
+        source: "slack",
+        channelId,
+        channelTs: "1710000002.000600",
+        threadTs: "1710000000.000600",
+        eventKind: "message",
+      }),
+    });
+
+    const threaded = recordInbound("slack", channelId, "thread-reply", {
+      sourceThreadId: "1710000000.000600",
+      sourceMessageId: "1710000003.000600",
+    });
+
+    expect(threaded.conversationId).not.toBe(legacy.conversationId);
+  });
+
+  test("legacy Slack channel key without evidence for the requested thread is not reused", () => {
+    const channelId = "C0123ABCDEF";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: "1710000000.000100",
+    });
+    insertMessage("legacy-other-thread-message", legacy.conversationId, {
+      slackMeta: JSON.stringify({
+        source: "slack",
+        channelId,
+        channelTs: "1710000001.000100",
+        threadTs: "1710000000.000100",
+        eventKind: "message",
+      }),
+    });
+
+    const threaded = recordInbound("slack", channelId, "new-thread-reply", {
+      sourceThreadId: "1710000000.000300",
+      sourceMessageId: "1710000001.000300",
+    });
+
+    expect(threaded.conversationId).not.toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(
+        `asst:self:slack:${channelId}:thread:1710000000.000300`,
+      )?.conversationId,
+    ).toBe(threaded.conversationId);
+  });
+
+  test("aliasing a proven legacy Slack thread does not collapse different thread IDs", () => {
+    const channelId = "C0123ABCDEF";
+    const legacyThreadTs = "1710000000.000100";
+    const newThreadTs = "1710000000.000200";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: legacyThreadTs,
+    });
+
+    const aliased = recordInbound("slack", channelId, "legacy-thread-reply", {
+      sourceThreadId: legacyThreadTs,
+      sourceMessageId: "1710000001.000100",
+    });
+    const separate = recordInbound("slack", channelId, "new-thread-reply", {
+      sourceThreadId: newThreadTs,
+      sourceMessageId: "1710000001.000200",
+    });
+
+    expect(aliased.conversationId).toBe(legacy.conversationId);
+    expect(separate.conversationId).not.toBe(legacy.conversationId);
+    expect(separate.conversationId).not.toBe(aliased.conversationId);
+  });
+
+  test("reset legacy-aliased Slack thread does not reattach to old legacy conversation", async () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000100";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: threadTs,
+    });
+    const aliased = recordInbound("slack", channelId, "legacy-thread-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000001.000100",
+    });
+    expect(aliased.conversationId).toBe(legacy.conversationId);
+
+    const req = new Request("http://localhost/channels/conversation", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sourceChannel: "slack",
+        conversationExternalId: channelId,
+        sourceThreadId: threadTs,
+      }),
+    });
+    const res = await handleDeleteConversation(req);
+    expect(res.status).toBe(200);
+
+    const afterReset = recordInbound("slack", channelId, "after-reset-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000002.000100",
+    });
+
+    expect(afterReset.conversationId).not.toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(afterReset.conversationId);
+  });
+
+  test("reset legacy Slack thread before alias exists does not reattach to old legacy conversation", async () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000100";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: threadTs,
+    });
+
+    const req = new Request("http://localhost/channels/conversation", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sourceChannel: "slack",
+        conversationExternalId: channelId,
+        sourceThreadId: threadTs,
+      }),
+    });
+    const res = await handleDeleteConversation(req);
+    expect(res.status).toBe(200);
+
+    const afterReset = recordInbound("slack", channelId, "after-reset-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000002.000100",
+    });
+
+    expect(afterReset.conversationId).not.toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(afterReset.conversationId);
+  });
+
   test("different chats get different conversations", () => {
     const r1 = recordInbound("telegram", "chat-1", "msg-1");
     const r2 = recordInbound("telegram", "chat-2", "msg-1");
@@ -149,6 +380,63 @@ describe("channel-delivery-store", () => {
     expect(r1.conversationId).toBe(r2.conversationId);
   });
 
+  test("external bindings allow multiple Slack thread anchors per channel", () => {
+    const r1 = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+    const r2 = recordInbound("slack", "C0123ABCDEF", "msg-2", {
+      sourceThreadId: "1710000000.000200",
+    });
+
+    upsertBinding({
+      conversationId: r1.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+    upsertBinding({
+      conversationId: r2.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000200",
+    });
+
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000100")
+        ?.conversationId,
+    ).toBe(r1.conversationId);
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000200")
+        ?.conversationId,
+    ).toBe(r2.conversationId);
+    expect(getBindingByChannelChat("slack", "C0123ABCDEF")).toBeNull();
+  });
+
+  test("conversation detail exposes Slack thread anchor from binding", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+
+    const detail = buildConversationDetailResponse(result.conversationId);
+
+    expect(detail?.conversation.channelBinding).toMatchObject({
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+      slackThread: {
+        channelId: "C0123ABCDEF",
+        threadTs: "1710000000.000100",
+      },
+    });
+  });
+
   // ── Deduplication ─────────────────────────────────────────────────
 
   test("duplicate inbound returns duplicate: true with same eventId", () => {

package/src/__tests__/channel-policy.test.ts

@@ -71,6 +71,7 @@ describe("channel policy registry", () => {
       "start_new_conversation",
       "continue_existing_conversation",
       "not_deliverable",
+      "push_only",
     ]);
 
     for (const channelId of CHANNEL_IDS) {
@@ -101,6 +102,7 @@ describe("channel policy registry", () => {
       ["telegram", "continue_existing_conversation"],
       ["slack", "continue_existing_conversation"],
       ["phone", "not_deliverable"],
+      ["platform", "push_only"],
     ];
 
     for (const [channelId, expected] of expectedStrategies) {
@@ -113,6 +115,7 @@ describe("channel policy registry", () => {
       "start_new_conversation",
       "continue_existing_conversation",
       "not_deliverable",
+      "push_only",
     ]);
 
     for (const channelId of CHANNEL_IDS) {
@@ -148,4 +151,13 @@ describe("channel policy registry", () => {
       }
     }
   });
+
+  test("channels with push_only strategy have deliveryEnabled: true", () => {
+    for (const channelId of CHANNEL_IDS) {
+      const policy = getChannelPolicy(channelId);
+      if (policy.notification.conversationStrategy === "push_only") {
+        expect(policy.notification.deliveryEnabled).toBe(true);
+      }
+    }
+  });
 });

package/src/__tests__/checker.test.ts

@@ -1597,6 +1597,95 @@ describe("bash network_mode=proxied — risk capped at medium", () => {
   });
 });
 
+describe("credentialed proxied bash — high risk escalation", () => {
+  beforeEach(() => {
+    mockRisk("low");
+    mockIpcResponse("get_global_thresholds", DEFAULT_GATEWAY_THRESHOLDS);
+    _clearGlobalCacheForTesting();
+    clearRiskCache();
+    testConfig.skills = { load: { extraDirs: [] } };
+  });
+
+  test("proxied bash with credential_ids sends credentialRefCount in IPC params", async () => {
+    mockRisk("high", {
+      reason:
+        "Proxied credential session — shell has access to injected credentials",
+    });
+    const result = await check(
+      "bash",
+      {
+        command: "curl https://api.example.com",
+        network_mode: "proxied",
+        credential_ids: ["cred-abc-123"],
+      },
+      "/tmp",
+    );
+    expect(result.decision).toBe("prompt");
+    expect(result.reason).toContain("credential");
+  });
+
+  test("proxied bash with multiple credential_ids prompts with high risk", async () => {
+    mockRisk("high", {
+      reason:
+        "Proxied credential session — shell has access to injected credentials",
+    });
+    const result = await check(
+      "bash",
+      {
+        command: "ls",
+        network_mode: "proxied",
+        credential_ids: ["cred-1", "cred-2"],
+      },
+      "/tmp",
+    );
+    expect(result.decision).toBe("prompt");
+  });
+
+  test("proxied bash with empty credential_ids array does not escalate risk", async () => {
+    mockRisk("low");
+    const result = await check(
+      "bash",
+      {
+        command: "ls",
+        network_mode: "proxied",
+        credential_ids: [],
+      },
+      "/tmp",
+    );
+    // Empty array means no credential refs — follows normal proxied behavior
+    expect(result.decision).toBe("allow");
+  });
+
+  test("proxied bash with credential_ids containing empty strings does not escalate", async () => {
+    mockRisk("low");
+    const result = await check(
+      "bash",
+      {
+        command: "ls",
+        network_mode: "proxied",
+        credential_ids: ["", ""],
+      },
+      "/tmp",
+    );
+    // Empty strings are filtered out, so no credential refs
+    expect(result.decision).toBe("allow");
+  });
+
+  test("non-proxied bash with credential_ids follows normal flow", async () => {
+    mockRisk("low");
+    const result = await check(
+      "bash",
+      {
+        command: "ls",
+        credential_ids: ["cred-abc-123"],
+      },
+      "/tmp",
+    );
+    // Without proxied mode, credential refs don't affect IPC classification
+    expect(result.decision).toBe("allow");
+  });
+});
+
 describe("workspace mode — auto-allow workspace-scoped operations", () => {
   const workspaceDir = "/home/user/my-project";
 

package/src/__tests__/circuit-breaker-pipeline.test.ts

@@ -377,7 +377,6 @@ describe("circuit-breaker pipeline", () => {
       manifest: {
         name: "observer",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", circuitBreakerApi: "v1" },
       },
       middleware: {
         circuitBreaker: async (args, next) => {