@vellumai/assistant 0.8.5 → 0.8.6

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

@@ -252,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__/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 {

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",

package/src/__tests__/channel-retry-sweep.test.ts

@@ -16,10 +16,19 @@ const deliveryCalls: Array<{
   assistantId?: string;
   messageId?: string;
   startFromSegment?: number;
+  messageTs?: string;
+}> = [];
+const liveDeliveryCalls: Array<{
+  callbackUrl: string;
+  payload: Record<string, unknown>;
 }> = [];
 let deliverReplyViaCallbackImpl: (
   ...args: unknown[]
 ) => Promise<void> = async () => {};
+let deliverChannelReplyImpl: (
+  callbackUrl: string,
+  payload: Record<string, unknown>,
+) => Promise<Record<string, unknown>> = async () => ({ ok: true });
 
 mock.module("../runtime/channel-reply-delivery.js", () => ({
   deliverReplyViaCallback: async (
@@ -27,16 +36,24 @@ mock.module("../runtime/channel-reply-delivery.js", () => ({
     externalChatId: string,
     callbackUrl: string,
     assistantId?: string,
-    options?: { messageId?: string; startFromSegment?: number },
+    options?: {
+      messageId?: string;
+      startFromSegment?: number;
+      messageTs?: string;
+    },
   ) => {
-    deliveryCalls.push({
+    const call: (typeof deliveryCalls)[number] = {
       conversationId,
       externalChatId,
       callbackUrl,
       assistantId,
       messageId: options?.messageId,
       startFromSegment: options?.startFromSegment,
-    });
+    };
+    if (options?.messageTs !== undefined) {
+      call.messageTs = options.messageTs;
+    }
+    deliveryCalls.push(call);
     return deliverReplyViaCallbackImpl(
       conversationId,
       externalChatId,
@@ -69,6 +86,16 @@ mock.module("../runtime/channel-reply-delivery.js", () => ({
   },
 }));
 
+mock.module("../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async (
+    callbackUrl: string,
+    payload: Record<string, unknown>,
+  ) => {
+    liveDeliveryCalls.push({ callbackUrl, payload });
+    return deliverChannelReplyImpl(callbackUrl, payload);
+  },
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryCrud from "../memory/delivery-crud.js";
@@ -158,7 +185,9 @@ describe("channel-retry-sweep", () => {
   beforeEach(() => {
     resetTables();
     deliveryCalls.length = 0;
+    liveDeliveryCalls.length = 0;
     deliverReplyViaCallbackImpl = async () => {};
+    deliverChannelReplyImpl = async () => ({ ok: true });
   });
 
   test("replays canonical payloads with trustClass correctly", async () => {
@@ -427,6 +456,294 @@ describe("channel-retry-sweep", () => {
     ).toBe("assistant-delivery-fails");
   });
 
+  test("Slack DM processing retries skip previously delivered live text responses", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "slack",
+      "D-LIVE-RETRY",
+      "slack-msg-live-retry",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "slack",
+      interface: "slack",
+      externalChatId: "D-LIVE-RETRY",
+      replyCallbackUrl: "https://example.test/deliver/slack",
+      sourceMetadata: { chatType: "im" },
+      trustCtx: {
+        trustClass: "unknown",
+        sourceChannel: "slack",
+        requesterChatId: "D-LIVE-RETRY",
+      },
+      slackDmLiveDeliveredTextResponseIndexes: [1],
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "Already delivered live response.",
+        conversationId,
+      });
+      options?.onEvent?.({
+        type: "tool_use_start",
+        toolName: "web_search",
+        input: { query: "one" },
+        conversationId,
+        toolUseId: "toolu_1",
+      });
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "New live response.",
+        conversationId,
+      });
+      options?.onEvent?.({
+        type: "tool_use_start",
+        toolName: "web_search",
+        input: { query: "two" },
+        conversationId,
+        toolUseId: "toolu_2",
+      });
+      options?.onEvent?.({
+        type: "message_complete",
+        conversationId,
+        messageId: "assistant-live-retry-final",
+      });
+      db.insert(messages)
+        .values({
+          id: "user-live-retry",
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId: "user-live-retry" };
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    const rawPayload = row?.rawPayload
+      ? (JSON.parse(row.rawPayload) as Record<string, unknown>)
+      : {};
+
+    expect(
+      liveDeliveryCalls.map((entry) => entry.payload.text).filter(Boolean),
+    ).toEqual(["New live response."]);
+    expect(rawPayload.slackDmLiveDeliveredTextResponseIndexes).toEqual([1, 2]);
+    expect(rawPayload.replyMessageId).toBe("assistant-live-retry-final");
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "D-LIVE-RETRY",
+        callbackUrl: "https://example.test/deliver/slack",
+        assistantId: undefined,
+        messageId: "assistant-live-retry-final",
+        startFromSegment: 2,
+      },
+    ]);
+    expect(row?.processingStatus).toBe("processed");
+  });
+
+  test("Slack DM processing retries resume final delivery after live text", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "slack",
+      "D-LIVE-RETRY-SAME-REPLY",
+      "slack-msg-live-retry-same-reply",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "slack",
+      interface: "slack",
+      externalChatId: "D-LIVE-RETRY-SAME-REPLY",
+      replyCallbackUrl: "https://example.test/deliver/slack",
+      sourceMetadata: { chatType: "im" },
+      trustCtx: {
+        trustClass: "unknown",
+        sourceChannel: "slack",
+        requesterChatId: "D-LIVE-RETRY-SAME-REPLY",
+      },
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+    deliverChannelReplyImpl = async () => ({
+      ok: true,
+      ts: "1700000000.000044",
+    });
+
+    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "Live retry response.",
+        conversationId,
+      });
+      options?.onEvent?.({
+        type: "tool_use_start",
+        toolName: "web_search",
+        input: { query: "example" },
+        conversationId,
+        toolUseId: "toolu_1",
+      });
+      options?.onEvent?.({
+        type: "message_complete",
+        conversationId,
+        messageId: "assistant-live-retry-same-reply",
+      });
+      db.insert(messages)
+        .values({
+          id: "user-live-retry-same-reply",
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId: "user-live-retry-same-reply" };
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    const rawPayload = row?.rawPayload
+      ? (JSON.parse(row.rawPayload) as Record<string, unknown>)
+      : {};
+
+    expect(
+      liveDeliveryCalls.map((entry) => entry.payload.text).filter(Boolean),
+    ).toEqual(["Live retry response."]);
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "D-LIVE-RETRY-SAME-REPLY",
+        callbackUrl: "https://example.test/deliver/slack",
+        assistantId: undefined,
+        messageId: "assistant-live-retry-same-reply",
+        startFromSegment: 1,
+        messageTs: "1700000000.000044",
+      },
+    ]);
+    expect(rawPayload.slackDmLiveDeliveredTextResponseIndexes).toEqual([1]);
+    expect(rawPayload.replyMessageId).toBe("assistant-live-retry-same-reply");
+    expect(row?.processingStatus).toBe("processed");
+    expect(row?.deliveryStatus).toBe("delivered");
+  });
+
+  test("Slack DM processing retries persist live delivery progress before final delivery failures", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "slack",
+      "D-LIVE-RETRY-FINAL-FAILS",
+      "slack-msg-live-retry-final-fails",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "slack",
+      interface: "slack",
+      externalChatId: "D-LIVE-RETRY-FINAL-FAILS",
+      replyCallbackUrl: "https://example.test/deliver/slack",
+      sourceMetadata: { chatType: "im" },
+      trustCtx: {
+        trustClass: "unknown",
+        sourceChannel: "slack",
+        requesterChatId: "D-LIVE-RETRY-FINAL-FAILS",
+      },
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+    deliverChannelReplyImpl = async () => ({
+      ok: true,
+      ts: "1700000000.000055",
+    });
+    deliverReplyViaCallbackImpl = async () => {
+      throw new Error("fetch failed before progress callback");
+    };
+
+    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "Live retry response.",
+        conversationId,
+      });
+      options?.onEvent?.({
+        type: "tool_use_start",
+        toolName: "web_search",
+        input: { query: "example" },
+        conversationId,
+        toolUseId: "toolu_1",
+      });
+      options?.onEvent?.({
+        type: "message_complete",
+        conversationId,
+        messageId: "assistant-live-retry-final-fails",
+      });
+      db.insert(messages)
+        .values({
+          id: "user-live-retry-final-fails",
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId: "user-live-retry-final-fails" };
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    const rawPayload = row?.rawPayload
+      ? (JSON.parse(row.rawPayload) as Record<string, unknown>)
+      : {};
+
+    expect(
+      liveDeliveryCalls.map((entry) => entry.payload.text).filter(Boolean),
+    ).toEqual(["Live retry response."]);
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "D-LIVE-RETRY-FINAL-FAILS",
+        callbackUrl: "https://example.test/deliver/slack",
+        assistantId: undefined,
+        messageId: "assistant-live-retry-final-fails",
+        startFromSegment: 1,
+        messageTs: "1700000000.000055",
+      },
+    ]);
+    expect(rawPayload.slackDmLiveDeliveredTextResponseIndexes).toEqual([1]);
+    expect(row?.deliveredSegmentCount).toBe(1);
+    expect(row?.deliveryStatus).toBe("failed");
+  });
+
   test("delivery retry for processed events resumes delivery without processing", async () => {
     const inbound = deliveryCrud.recordInbound(
       "telegram",