@vellumai/assistant 0.7.3 → 0.8.1

package/src/config/bundled-skills/messaging/tools/__tests__/messaging-feed-events.test.ts

@@ -1,207 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { EmitFeedEventParams } from "../../../../../home/emit-feed-event.js";
-
-// Capture all emitFeedEvent calls
-const emittedEvents: EmitFeedEventParams[] = [];
-
-mock.module("../../../../../home/emit-feed-event.js", () => ({
-  emitFeedEvent: async (params: EmitFeedEventParams) => {
-    emittedEvents.push(params);
-    return {
-      id: `emit:${params.source}:${params.dedupKey ?? "random"}`,
-      type: "action",
-      source: params.source,
-      title: params.title,
-      summary: params.summary,
-      priority: 50,
-      status: "new",
-      author: "assistant",
-      timestamp: new Date().toISOString(),
-      createdAt: new Date().toISOString(),
-    };
-  },
-}));
-
-// Stub messaging provider dependencies
-const mockCreateDraft = mock(async () => ({ id: "draft-123" }));
-const mockCreateDraftRaw = mock(async () => ({ id: "draft-raw-456" }));
-const mockGetThread = mock(async () => ({
-  messages: [
-    {
-      payload: {
-        headers: [
-          { name: "From", value: "sender@example.com" },
-          { name: "To", value: "user@example.com" },
-          { name: "Subject", value: "Test Subject" },
-          { name: "Message-ID", value: "<msg-1@example.com>" },
-        ],
-      },
-    },
-  ],
-}));
-const mockGetProfile = mock(async () => ({
-  emailAddress: "user@example.com",
-}));
-
-mock.module("../../../../../messaging/providers/gmail/client.js", () => ({
-  createDraft: mockCreateDraft,
-  createDraftRaw: mockCreateDraftRaw,
-  getThread: mockGetThread,
-  getProfile: mockGetProfile,
-}));
-
-mock.module("../../../../../messaging/providers/gmail/mime-builder.js", () => ({
-  buildMultipartMime: () => "mock-raw-mime",
-}));
-
-const mockSendMessage = mock(async () => ({
-  id: "msg-sent-789",
-  threadId: "thread-1",
-}));
-const mockArchiveByQuery = mock(async () => ({
-  archived: 3,
-  truncated: false,
-}));
-
-mock.module("../shared.js", () => ({
-  resolveProvider: async (platform?: string) => ({
-    id: platform === "slack" ? "slack" : "gmail",
-    displayName: platform === "slack" ? "Slack" : "Gmail",
-    sendMessage: mockSendMessage,
-    archiveByQuery: mockArchiveByQuery,
-  }),
-  getProviderConnection: async () => ({ token: "mock-token" }),
-  ok: (msg: string) => ({ status: "ok", output: msg }),
-  err: (msg: string) => ({ status: "error", output: msg }),
-  extractEmail: (addr: string) => addr.replace(/.*<(.+)>/, "$1").toLowerCase(),
-  extractHeader: (
-    headers: Array<{ name: string; value: string }>,
-    name: string,
-  ) => headers.find((h: { name: string }) => h.name === name)?.value ?? null,
-  parseAddressList: (addrs: string | null) =>
-    addrs ? addrs.split(",").map((a: string) => a.trim()) : [],
-}));
-
-// Stub gmail-mime-helpers
-mock.module("../gmail-mime-helpers.js", () => ({
-  guessMimeType: () => "application/octet-stream",
-}));
-
-// Stub conversation dependencies used by messaging-send cross-post
-mock.module("../../../../../memory/conversation-crud.js", () => ({
-  addMessage: async () => ({ id: "msg-1" }),
-  getConversation: () => null,
-}));
-mock.module("../../../../../memory/conversation-disk-view.js", () => ({
-  syncMessageToDisk: () => {},
-}));
-mock.module("../../../../../memory/external-conversation-store.js", () => ({
-  getBindingByChannelChat: () => null,
-}));
-
-const { run: runSend } = await import("../messaging-send.js");
-const { run: runArchive } = await import("../messaging-archive-by-sender.js");
-
-const baseContext = {
-  workingDir: "/tmp/test",
-  conversationId: "conv-xyz",
-  assistantId: "assistant-1",
-  triggeredBySurfaceAction: true,
-  batchAuthorizedByTask: false,
-  approvedViaPrompt: false,
-  trustClass: "guardian" as const,
-};
-
-beforeEach(() => {
-  emittedEvents.length = 0;
-  mockCreateDraft.mockClear();
-  mockCreateDraftRaw.mockClear();
-  mockSendMessage.mockClear();
-  mockArchiveByQuery.mockClear();
-});
-
-afterEach(() => {
-  emittedEvents.length = 0;
-});
-
-describe("messaging-send feed events", () => {
-  test("Gmail draft creation emits with source 'gmail' and dedup by draft ID", async () => {
-    await runSend(
-      {
-        platform: "gmail",
-        conversation_id: "recipient@example.com",
-        text: "Hello there",
-        subject: "Test",
-      },
-      baseContext,
-    );
-
-    expect(emittedEvents).toHaveLength(1);
-    expect(emittedEvents[0].source).toBe("gmail");
-    expect(emittedEvents[0].title).toBe("Email Draft Created");
-    expect(emittedEvents[0].dedupKey).toBe("email-draft:draft-123");
-  });
-
-  test("Slack sends emit with source 'slack'", async () => {
-    await runSend(
-      {
-        platform: "slack",
-        conversation_id: "#general",
-        text: "Hello Slack",
-      },
-      baseContext,
-    );
-
-    expect(emittedEvents).toHaveLength(1);
-    expect(emittedEvents[0].source).toBe("slack");
-    expect(emittedEvents[0].title).toBe("Slack Message Sent");
-    expect(emittedEvents[0].dedupKey).toBe("message-sent:msg-sent-789");
-  });
-
-  test("Non-Gmail, non-Slack sends emit with source 'gmail' as fallback", async () => {
-    await runSend(
-      {
-        platform: "other-email",
-        conversation_id: "user@example.com",
-        text: "Hello",
-      },
-      baseContext,
-    );
-
-    expect(emittedEvents).toHaveLength(1);
-    expect(emittedEvents[0].source).toBe("gmail");
-    // Mock resolveProvider returns id:"gmail" for non-slack platforms,
-    // so this goes through the Gmail draft path
-    expect(emittedEvents[0].title).toBe("Email Draft Created");
-    expect(emittedEvents[0].summary).toBe("Created an email draft.");
-  });
-});
-
-describe("messaging-archive feed events", () => {
-  test("Archive emits only when result.archived > 0", async () => {
-    await runArchive(
-      { platform: "gmail", query: "from:sender@example.com" },
-      baseContext,
-    );
-
-    expect(emittedEvents).toHaveLength(1);
-    expect(emittedEvents[0].source).toBe("gmail");
-    expect(emittedEvents[0].title).toBe("Messages Archived");
-    expect(emittedEvents[0].summary).toContain("Archived 3 message(s)");
-  });
-
-  test("Zero-match archives do NOT emit", async () => {
-    mockArchiveByQuery.mockResolvedValueOnce({
-      archived: 0,
-      truncated: false,
-    });
-
-    await runArchive(
-      { platform: "gmail", query: "from:nobody@example.com" },
-      baseContext,
-    );
-
-    expect(emittedEvents).toHaveLength(0);
-  });
-});

package/src/daemon/__tests__/conversation-feed-event.test.ts

@@ -1,304 +0,0 @@
-/**
- * Tests for the background conversation feed event emission logic in
- * conversation-agent-loop.ts.
- *
- * Rather than running the full agent loop, these tests exercise the
- * extraction logic in isolation by simulating the conditions under which
- * emitFeedEvent is called: conversation type, message content, and title.
- */
-
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Module-level mocks — must be in place before importing the module under test
-// ---------------------------------------------------------------------------
-
-const emitFeedEventSpy = mock<
-  (params: {
-    source: string;
-    title: string;
-    summary: string;
-    dedupKey?: string;
-  }) => Promise<unknown>
->(async () => ({}));
-
-mock.module("../../home/emit-feed-event.js", () => ({
-  emitFeedEvent: emitFeedEventSpy,
-}));
-
-const getConversationSpy = mock<
-  (id: string) => {
-    conversationType: string;
-    title: string | null;
-  } | null
->(() => null);
-
-const getMessageByIdSpy = mock<
-  (
-    messageId: string,
-    conversationId?: string,
-  ) => { id: string; content: string } | null
->(() => null);
-
-// We need to stub enough of conversation-crud to avoid DB initialization.
-// The actual agent loop imports getConversation and getMessageById from
-// conversation-crud — we intercept those here for test assertions.
-mock.module("../../memory/conversation-crud.js", () => ({
-  getConversation: getConversationSpy,
-  getMessageById: getMessageByIdSpy,
-  // Stubs for other exports that may be transitively referenced:
-  addMessage: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
-  deleteMessageById: () => {},
-  getConversationOriginChannel: () => null,
-  getConversationOriginInterface: () => null,
-  getLastUserTimestampBefore: () => null,
-  provenanceFromTrustContext: () => ({}),
-  updateConversationContextWindow: () => {},
-  updateConversationTitle: () => {},
-  updateMessageMetadata: () => {},
-}));
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Simulates the feed-event emission logic from conversation-agent-loop.ts.
- *
- * This mirrors the block inserted after `message_complete` so we can test it
- * in isolation without spinning up the full agent loop infrastructure.
- */
-/**
- * Tracks the last warning logged by simulateFeedEventEmission, so tests can
- * assert that malformed content is swallowed gracefully.
- */
-let lastFeedEventWarning: unknown = undefined;
-
-function simulateFeedEventEmission(
-  conversationId: string,
-  lastAssistantMessageId: string | undefined,
-): void {
-  lastFeedEventWarning = undefined;
-  try {
-    const conv = getConversationSpy(conversationId);
-    if (
-      conv &&
-      (conv.conversationType === "background" ||
-        conv.conversationType === "scheduled")
-    ) {
-      const lastMsg = lastAssistantMessageId
-        ? getMessageByIdSpy(lastAssistantMessageId, conversationId)
-        : undefined;
-      let summary: string;
-      if (lastMsg) {
-        const parsed: unknown = JSON.parse(lastMsg.content);
-        if (typeof parsed === "string") {
-          summary = parsed.slice(0, 200);
-        } else if (Array.isArray(parsed)) {
-          const textBlock = (
-            parsed as Array<{ type?: string; text?: string }>
-          ).find((b) => b.type === "text");
-          summary =
-            typeof textBlock?.text === "string"
-              ? textBlock.text.slice(0, 200)
-              : (conv.title ?? "Background task completed.");
-        } else {
-          summary = conv.title ?? "Background task completed.";
-        }
-      } else {
-        summary = conv.title ?? "Background task completed.";
-      }
-      void emitFeedEventSpy({
-        source: "assistant",
-        title: conv.title ?? "Background Task",
-        summary,
-        dedupKey: `bg-conv:${conversationId}`,
-      });
-    }
-  } catch (feedErr) {
-    lastFeedEventWarning = feedErr;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("background conversation feed event", () => {
-  beforeEach(() => {
-    emitFeedEventSpy.mockClear();
-    getConversationSpy.mockClear();
-    getMessageByIdSpy.mockClear();
-  });
-
-  afterEach(() => {
-    emitFeedEventSpy.mockReset();
-    getConversationSpy.mockReset();
-    getMessageByIdSpy.mockReset();
-  });
-
-  test("emits feed event for background conversation with text content", () => {
-    const convId = "conv-bg-123";
-    const msgId = "msg-456";
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "background",
-      title: "Nightly Cleanup",
-    });
-    getMessageByIdSpy.mockReturnValue({
-      id: msgId,
-      content: JSON.stringify([
-        { type: "text", text: "Cleaned up 42 files successfully." },
-      ]),
-    });
-
-    simulateFeedEventEmission(convId, msgId);
-
-    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
-    expect(emitFeedEventSpy).toHaveBeenCalledWith({
-      source: "assistant",
-      title: "Nightly Cleanup",
-      summary: "Cleaned up 42 files successfully.",
-      dedupKey: `bg-conv:${convId}`,
-    });
-  });
-
-  test("emits feed event for scheduled conversation", () => {
-    const convId = "conv-sched-789";
-    const msgId = "msg-101";
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "scheduled",
-      title: "Weekly Report",
-    });
-    getMessageByIdSpy.mockReturnValue({
-      id: msgId,
-      content: JSON.stringify([{ type: "text", text: "Report generated." }]),
-    });
-
-    simulateFeedEventEmission(convId, msgId);
-
-    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
-    expect(emitFeedEventSpy).toHaveBeenCalledWith({
-      source: "assistant",
-      title: "Weekly Report",
-      summary: "Report generated.",
-      dedupKey: `bg-conv:${convId}`,
-    });
-  });
-
-  test("truncates summary to 200 characters", () => {
-    const convId = "conv-bg-long";
-    const msgId = "msg-long";
-    const longText = "A".repeat(300);
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "background",
-      title: "Long Task",
-    });
-    getMessageByIdSpy.mockReturnValue({
-      id: msgId,
-      content: JSON.stringify([{ type: "text", text: longText }]),
-    });
-
-    simulateFeedEventEmission(convId, msgId);
-
-    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
-    const call = emitFeedEventSpy.mock.calls[0]![0];
-    expect(call.summary).toHaveLength(200);
-    expect(call.summary).toBe(longText.slice(0, 200));
-  });
-
-  test("falls back to conversation title when no text block in content", () => {
-    const convId = "conv-bg-notext";
-    const msgId = "msg-notext";
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "background",
-      title: "Image Task",
-    });
-    getMessageByIdSpy.mockReturnValue({
-      id: msgId,
-      content: JSON.stringify([{ type: "image", source: { data: "..." } }]),
-    });
-
-    simulateFeedEventEmission(convId, msgId);
-
-    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
-    expect(emitFeedEventSpy.mock.calls[0]![0].summary).toBe("Image Task");
-  });
-
-  test("falls back to default summary when no message and no title", () => {
-    const convId = "conv-bg-notitle";
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "background",
-      title: null,
-    });
-
-    simulateFeedEventEmission(convId, undefined);
-
-    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
-    const call = emitFeedEventSpy.mock.calls[0]![0];
-    expect(call.title).toBe("Background Task");
-    expect(call.summary).toBe("Background task completed.");
-  });
-
-  test("does NOT emit feed event for standard (foreground) conversations", () => {
-    const convId = "conv-standard-1";
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "standard",
-      title: "Regular Chat",
-    });
-
-    simulateFeedEventEmission(convId, undefined);
-
-    expect(emitFeedEventSpy).not.toHaveBeenCalled();
-  });
-
-  test("uses dedupKey per conversation for in-place updates", () => {
-    const convId = "conv-bg-dedup";
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "background",
-      title: "Recurring Job",
-    });
-
-    // First run
-    simulateFeedEventEmission(convId, undefined);
-    // Second run (re-run of same conversation)
-    simulateFeedEventEmission(convId, undefined);
-
-    expect(emitFeedEventSpy).toHaveBeenCalledTimes(2);
-    // Both calls use the same dedupKey
-    expect(emitFeedEventSpy.mock.calls[0]![0].dedupKey).toBe(
-      `bg-conv:${convId}`,
-    );
-    expect(emitFeedEventSpy.mock.calls[1]![0].dedupKey).toBe(
-      `bg-conv:${convId}`,
-    );
-  });
-
-  test("swallows malformed JSON content without throwing", () => {
-    const convId = "conv-bg-badjson";
-    const msgId = "msg-badjson";
-
-    getConversationSpy.mockReturnValue({
-      conversationType: "background",
-      title: "Bad JSON Task",
-    });
-    getMessageByIdSpy.mockReturnValue({
-      id: msgId,
-      content: "this is not valid JSON {{{",
-    });
-
-    // Should not throw
-    expect(() => simulateFeedEventEmission(convId, msgId)).not.toThrow();
-    // The error was caught and logged as a warning
-    expect(lastFeedEventWarning).toBeInstanceOf(SyntaxError);
-    // emitFeedEvent should NOT have been called
-    expect(emitFeedEventSpy).not.toHaveBeenCalled();
-  });
-});