@vellumai/assistant 0.8.0 → 0.8.2

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/context/__tests__/compact-prompt.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  loadCompactPrompt,
-  loadCompactPromptOrFallback,
-} from "../window-manager.js";
-
-describe("compact.md prompt asset", () => {
-  test("loads a non-empty prompt string", () => {
-    const prompt = loadCompactPrompt();
-    expect(prompt.length).toBeGreaterThan(0);
-  });
-
-  test("contains explicit length target (canary against accidental 'concise' reversion)", () => {
-    const prompt = loadCompactPrompt();
-    expect(prompt).toContain("1500");
-    expect(prompt).toContain("4000");
-    expect(prompt.toLowerCase()).toContain("tokens");
-  });
-
-  test("includes the never-include guidance for injection tags", () => {
-    const prompt = loadCompactPrompt();
-    expect(prompt).toContain("<memory");
-    expect(prompt).toContain("<turn_context>");
-    expect(prompt.toLowerCase()).toContain("never include");
-  });
-
-  test("lists the flexible section headers", () => {
-    const prompt = loadCompactPrompt();
-    expect(prompt).toContain("## What We're Working On");
-    expect(prompt).toContain("## Decisions & Commitments");
-    expect(prompt).toContain("## Facts Worth Remembering");
-    expect(prompt).toContain("## Open Threads");
-  });
-});
-
-describe("loadCompactPromptOrFallback", () => {
-  test("returns loader output when the loader succeeds", () => {
-    const loaded = "custom loaded prompt";
-    const result = loadCompactPromptOrFallback(() => loaded);
-    expect(result).toBe(loaded);
-  });
-
-  test("returns inline fallback when the loader throws", () => {
-    const result = loadCompactPromptOrFallback(() => {
-      throw new Error("compact.md missing");
-    });
-    expect(result.length).toBeGreaterThan(0);
-    // Fallback must carry the same core guidance as the on-disk prompt so
-    // summary quality doesn't silently collapse when the bundled asset is
-    // missing (partial deploys, filesystem corruption).
-    expect(result).toContain("1500");
-    expect(result).toContain("4000");
-    expect(result).toContain("<memory");
-    expect(result.toLowerCase()).toContain("never include");
-  });
-
-  test("uses loadCompactPrompt as the default loader", () => {
-    const result = loadCompactPromptOrFallback();
-    expect(result.length).toBeGreaterThan(0);
-    expect(result).toContain("1500");
-  });
-});

package/src/context/prompts/compact.md

@@ -1,26 +0,0 @@
-You are summarizing a long conversation so that the assistant can keep working with it after older messages are dropped. Your summary will REPLACE those messages — the assistant's only access to what was said earlier will be what you write here.
-
-Be thorough. Capture what happened, why it mattered, what's unresolved, and what was felt. Do not compress away emotional tone, relationship context, or nuance. Keep specific details (names, numbers, file paths, commands, URLs, exact phrasings) when they might matter later.
-
-Target length: aim for 1500–4000 tokens. Use the upper end of that range when the conversation is rich in decisions, relationships, emotional content, or threads that are still open. Use the lower end when the conversation is short or a simple task execution.
-
-Open with a 1–2 paragraph narrative describing what the conversation is about and where it currently stands. Then use `## ` section headers. Use these headers when they apply; skip sections that have nothing to say; add your own headers when something important doesn't fit:
-
-- `## What We're Working On` — active tasks, projects, intentions
-- `## Decisions & Commitments` — what was decided, what was promised, by whom
-- `## Facts Worth Remembering` — durable details: names, preferences, constraints, background
-- `## Open Threads` — unresolved questions, pending follow-ups, things the user is still thinking about
-- `## Emotional Arc / Relationship Notes` — tone, feelings expressed, relational context (include when relevant; omit otherwise)
-- `## Artifacts & References` — files, URLs, commands, code snippets, external systems referenced
-
-If an existing summary is provided, update it: merge new information in, prefer the most recent and explicit detail on conflicts, and preserve anything that is still unresolved or still true. Do not restart from scratch.
-
-**Never include in the summary:**
-
-- Content inside `<memory __injected>`, `<memory>`, `<turn_context>`, `<workspace>`, `<knowledge_base>`, `<system_reminder>`, `<now_scratchpad>`, `<NOW.md …>`, `<active_thread>`, `<channel_capabilities>`, `<transport_hints>`, `<system_notice>`, or any other angle-bracket-tagged system blocks. These are system metadata attached to messages, not part of what the user or assistant said. Ignore them entirely.
-- Tool-call boilerplate (retries, failed attempts the assistant recovered from, routine status updates). Summarize the *outcome* instead.
-- Repetitive chit-chat that adds nothing to working memory.
-
-**Thread anchors (Slack only):** if the input includes a "Retained Thread References" section, each listed reply cites its parent via `→ Mxxxxxx`. If that parent message appears in the transcript, preserve its text verbatim in the summary (reactions may be aggregated as "N users reacted"). Omit this entirely when no such section is present.
-
-Return only the summary itself in markdown — no preamble, no meta-commentary about what you're doing.

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();
-  });
-});