@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/browser-skill-endstate.test.ts

@@ -12,7 +12,6 @@ mock.module("../config/loader.js", () => ({
 
 import { BROWSER_OPERATION_META } from "../browser/operations.js";
 import { BROWSER_OPERATIONS } from "../browser/types.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   projectSkillTools,
   resetSkillToolProjection,
@@ -23,6 +22,7 @@ import {
   getAllTools,
   initializeTools,
 } from "../tools/registry.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 import {
   BROWSER_SKILL_ID,
   buildSkillLoadHistory,
@@ -30,13 +30,13 @@ import {
 
 afterAll(() => {
   __resetRegistryForTesting();
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 describe("browser CLI-only architecture end-state", () => {
   beforeAll(async () => {
     __resetRegistryForTesting();
-    _setOverridesForTesting({
+    setOverridesForTesting({
       browser: true,
     });
     await initializeTools();

package/src/__tests__/btw-routes.test.ts

@@ -38,6 +38,7 @@ const mockAddMessage = mock(() => {});
 
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: mockAddMessage,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const MOCK_TOOLS = [
@@ -48,8 +49,8 @@ const MOCK_TOOLS = [
   },
 ];
 
-mock.module("../daemon/conversation-tool-setup.js", () => ({
-  buildToolDefinitions: () => MOCK_TOOLS,
+mock.module("../tools/registry.js", () => ({
+  getAllToolDefinitions: () => MOCK_TOOLS,
 }));
 
 const MOCK_SYSTEM_PROMPT = "You are a helpful assistant.";
@@ -317,12 +318,11 @@ describe("POST /v1/btw", () => {
 
     expect(tools).toEqual(MOCK_TOOLS);
     expect(systemPrompt).toBe(MOCK_SYSTEM_PROMPT);
+    // Persona is resolved internally now; btw-routes no longer plumbs
+    // it through to buildSystemPrompt.
     expect(mockBuildSystemPrompt).toHaveBeenCalledWith({
-      channelPersona: null,
       excludeBootstrap: true,
       excludeCustomPrefix: true,
-      userPersona: null,
-      userSlug: null,
     });
     expect(options!.config!.tool_choice).toEqual({ type: "none" });
     expect(options!.config!.callSite).toBe("identityIntro");

package/src/__tests__/call-controller.test.ts

@@ -166,7 +166,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     reason: "mocked",
     deliveryResults: [],
   }),
-  registerBroadcastFn: () => {},
 }));
 
 mock.module("../calls/voice-session-bridge.js", () => {
@@ -253,16 +252,17 @@ import {
   getPendingCanonicalRequestByCallSessionId,
 } from "../memory/canonical-guardian-store.js";
 import { getMessages } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { resetTestTables } from "../memory/raw-query.js";
 import { conversations } from "../memory/schema.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 initializeDb();
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 // ── CallTransport mock factory ───────────────────────────────────────

package/src/__tests__/cancel-resolves-conversation-key.test.ts

@@ -49,7 +49,7 @@ mock.module("../daemon/handlers/conversations.js", () => ({
     return true;
   },
   switchConversation: async () => null,
-  clearAllConversations: () => 0,
+  clearAllConversations: async () => 0,
   undoLastMessage: async () => null,
   regenerateResponse: async () => null,
 }));

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

@@ -76,7 +76,7 @@ import {
   createCanonicalGuardianRequest,
   getCanonicalGuardianRequest,
 } from "../memory/canonical-guardian-store.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryChannels from "../memory/delivery-channels.js";
 import {
@@ -90,6 +90,7 @@ import * as gatewayClient from "../runtime/gateway-client.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { sweepExpiredGuardianApprovals } from "../runtime/routes/channel-guardian-routes.js";
 import { _setTestPollMaxWait } from "../runtime/routes/channel-route-shared.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
@@ -97,7 +98,7 @@ initializeDb();
 initAuthSigningKey(Buffer.from("test-signing-key-at-least-32-bytes-long"));
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 // ---------------------------------------------------------------------------

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

@@ -81,7 +81,7 @@ import {
   updateSessionDelivery as storeUpdateSessionDelivery,
   updateSessionStatus as _storeUpdateSessionStatus,
 } from "../memory/channel-verification-sessions.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { upsertBinding as upsertExternalBinding } from "../memory/external-conversation-store.js";
 import {
@@ -121,12 +121,13 @@ import {
   composeVerificationTelegram,
   GUARDIAN_VERIFY_TEMPLATE_KEYS,
 } from "../runtime/verification-templates.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 initializeDb();
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 function resetTables(): void {
@@ -2777,7 +2778,7 @@ describe("outbound voice verification", () => {
     }
   });
 
-  test("start_outbound rejects unsupported channels", async () => {
+  test("start_outbound succeeds for email channel", async () => {
     const { lastResponse } = createResponseReader();
     await handleChannelVerificationSession(
       {
@@ -2790,8 +2791,8 @@ describe("outbound voice verification", () => {
 
     const resp = lastResponse();
     expect(resp).not.toBeNull();
-    expect(resp!.success).toBe(false);
-    expect(resp!.error).toBe("unsupported_channel");
+    expect(resp!.success).toBe(true);
+    expect(resp!.channel).toBe("email");
   });
 
   test("create_session without destination falls through to inbound challenge", async () => {

package/src/__tests__/channel-readiness-slack-remote.test.ts

@@ -0,0 +1,175 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { credentialKey } from "../security/credential-key.js";
+
+let mockSecureKeys: Record<string, string>;
+let mockRawConfig: Record<string, unknown>;
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (key: string) => mockSecureKeys[key] ?? null,
+  setSecureKeyAsync: async (key: string, value: string) => {
+    mockSecureKeys[key] = value;
+    return true;
+  },
+  deleteSecureKeyAsync: async (key: string) => {
+    delete mockSecureKeys[key];
+    return true;
+  },
+}));
+
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => mockRawConfig,
+  getConfig: () => ({ email: { enabled: false } }),
+  getNestedValue: (obj: Record<string, unknown>, path: string) => {
+    const keys = path.split(".");
+    let current: unknown = obj;
+    for (const key of keys) {
+      if (current == null || typeof current !== "object") return undefined;
+      current = (current as Record<string, unknown>)[key];
+    }
+    return current;
+  },
+}));
+
+mock.module("../config/env-registry.js", () => ({
+  getIsPlatform: () => false,
+}));
+
+mock.module("../channels/config.js", () => ({
+  getChannelInvitePolicy: () => ({ codeRedemptionEnabled: false }),
+}));
+
+mock.module("../calls/twilio-rest.js", () => ({
+  hasTwilioCredentials: () => false,
+}));
+
+mock.module("../calls/twilio-config.js", () => ({
+  resolveTwilioPhoneNumber: () => undefined,
+}));
+
+mock.module("../email/feature-gate.js", () => ({
+  isEmailEnabled: () => false,
+}));
+
+mock.module("./channel-invite-transports/whatsapp.js", () => ({
+  resolveWhatsAppDisplayNumber: () => undefined,
+}));
+
+const originalFetch = globalThis.fetch;
+let fetchCalls: Array<{ url: string; init?: RequestInit }>;
+let fetchHandler: (
+  url: string,
+  init?: RequestInit,
+) => { ok: boolean; body: unknown };
+
+beforeEach(() => {
+  mockSecureKeys = {};
+  mockRawConfig = {};
+  fetchCalls = [];
+  fetchHandler = () => ({ ok: true, body: { ok: true } });
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input.toString();
+    fetchCalls.push({ url, init });
+    const { ok, body } = fetchHandler(url, init);
+    return new Response(JSON.stringify(body), {
+      status: ok ? 200 : 500,
+      headers: { "content-type": "application/json" },
+    });
+  }) as typeof globalThis.fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+async function runSlackRemoteProbe() {
+  const { createReadinessService } = await import(
+    "../runtime/channel-readiness-service.js"
+  );
+  const service = createReadinessService();
+  return service.getReadiness("slack", true);
+}
+
+describe("slack remote probe (auth.test)", () => {
+  test("reports skipped when no bot_token is stored", async () => {
+    const [snapshot] = await runSlackRemoteProbe();
+    const remote = snapshot.remoteChecks ?? [];
+    expect(remote.length).toBeGreaterThan(0);
+    expect(remote[0].name).toBe("auth_test");
+    expect(remote[0].passed).toBe(false);
+    expect(remote[0].message).toMatch(/no bot_token/i);
+    // fetch must not be called when there is no token
+    expect(fetchCalls.length).toBe(0);
+  });
+
+  test("passes when Slack auth.test returns ok and workspaces match", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    mockRawConfig = { slack: { teamId: "T123" } };
+    fetchHandler = () => ({
+      ok: true,
+      body: { ok: true, team_id: "T123", team: "acme", user: "apollobot" },
+    });
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const remote = snapshot.remoteChecks ?? [];
+    const authTest = remote.find((c) => c.name === "auth_test")!;
+    const wsMatch = remote.find((c) => c.name === "workspace_match")!;
+
+    expect(authTest.passed).toBe(true);
+    expect(authTest.message).toContain("acme");
+    expect(wsMatch.passed).toBe(true);
+
+    // The first slack fetch should hit auth.test
+    expect(fetchCalls[0].url).toBe("https://slack.com/api/auth.test");
+    expect(
+      (fetchCalls[0].init?.headers as Record<string, string>).Authorization,
+    ).toBe("Bearer xoxb-fake");
+  });
+
+  test("fails when Slack auth.test rejects the bot_token", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-stale";
+    fetchHandler = () => ({
+      ok: true,
+      body: { ok: false, error: "invalid_auth" },
+    });
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const authTest = snapshot.remoteChecks!.find(
+      (c) => c.name === "auth_test",
+    )!;
+    expect(authTest.passed).toBe(false);
+    expect(authTest.message).toMatch(/invalid_auth/);
+  });
+
+  test("flags workspace mismatch between stored config and live token", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    mockRawConfig = { slack: { teamId: "T_old" } };
+    fetchHandler = () => ({
+      ok: true,
+      body: { ok: true, team_id: "T_new", team: "newco", user: "apollobot" },
+    });
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const wsMatch = snapshot.remoteChecks!.find(
+      (c) => c.name === "workspace_match",
+    )!;
+    expect(wsMatch.passed).toBe(false);
+    expect(wsMatch.message).toContain("T_old");
+    expect(wsMatch.message).toContain("T_new");
+    expect(wsMatch.message).toContain("reconnect");
+  });
+
+  test("reports network failure as a failed check", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    globalThis.fetch = (async () => {
+      throw new Error("ECONNREFUSED");
+    }) as unknown as typeof globalThis.fetch;
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const authTest = snapshot.remoteChecks!.find(
+      (c) => c.name === "auth_test",
+    )!;
+    expect(authTest.passed).toBe(false);
+    expect(authTest.message).toMatch(/ECONNREFUSED/);
+  });
+});

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

@@ -128,6 +128,7 @@ mock.module("../memory/conversation-crud.js", () => ({
         : {};
     row.metadata = JSON.stringify({ ...existing, ...updates });
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/attachments-store.js", () => ({
@@ -577,6 +578,40 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls).toHaveLength(0);
   });
 
+  it("updates a live-delivered message when skipped text has attachments", async () => {
+    const seenTs: string[] = [];
+    const attachments: RuntimeAttachmentMetadata[] = [
+      {
+        id: "attachment-1",
+        filename: "report.txt",
+        mimeType: "text/plain",
+        sizeBytes: 12,
+        kind: "file",
+      },
+    ];
+
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/slack",
+      chatId: "chat-live",
+      textSegments: ["Already sent live."],
+      attachments,
+      startFromSegment: 1,
+      messageTs: "1700000000.000055",
+      onMessageTs: (ts) => seenTs.push(ts),
+    });
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload).toEqual({
+      chatId: "chat-live",
+      attachments,
+      assistantId: undefined,
+      ephemeral: undefined,
+      user: undefined,
+      messageTs: "1700000000.000055",
+    });
+    expect(seenTs).toEqual(["1700000000.000055"]);
+  });
+
   it("passes ephemeral and user through to each delivery call", async () => {
     await deliverRenderedReplyViaCallback({
       callbackUrl: "http://gateway/deliver/slack",