@vellumai/assistant 0.6.4 → 0.6.5

package/src/__tests__/cross-provider-web-search.test.ts

@@ -312,6 +312,90 @@ describe("Cross-Provider Web Search — OpenAI (Responses API)", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// OpenAI Responses API — native web search tool mapping
+// ---------------------------------------------------------------------------
+
+describe("Cross-Provider Web Search — OpenAI (Responses API, native mode)", () => {
+  beforeEach(() => {
+    lastOpenAIResponsesParams = null;
+  });
+
+  test("maps web_search to native web_search_preview tool when useNativeWebSearch is enabled", async () => {
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o", {
+      useNativeWebSearch: true,
+    });
+
+    const tools = [
+      {
+        name: "file_read",
+        description: "Read a file",
+        input_schema: {
+          type: "object",
+          properties: { path: { type: "string" } },
+        },
+      },
+      {
+        name: "web_search",
+        description: "Search the web",
+        input_schema: {
+          type: "object",
+          properties: { query: { type: "string" } },
+        },
+      },
+    ];
+
+    await provider.sendMessage([userMsg("Search for something")], tools);
+
+    const sentTools = lastOpenAIResponsesParams!.tools as Array<
+      Record<string, unknown>
+    >;
+    expect(sentTools).toHaveLength(2);
+    // Non-web-search tools stay as function tools
+    expect(sentTools[0]).toMatchObject({ type: "function", name: "file_read" });
+    // web_search is replaced with native hosted tool
+    expect(sentTools[1]).toEqual({ type: "web_search_preview" });
+  });
+
+  test("still degrades web search history blocks in native mode", async () => {
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o", {
+      useNativeWebSearch: true,
+    });
+    await provider.sendMessage(webSearchConversation());
+
+    const input = lastOpenAIResponsesParams!.input as Array<{
+      type: string;
+      role?: string;
+      content?: Array<{ type: string; text?: string }>;
+    }>;
+
+    // server_tool_use in assistant history is still degraded to text placeholder
+    const assistantItems = input.filter(
+      (item) => item.type === "message" && item.role === "assistant",
+    );
+    const hasWebSearchPlaceholder = assistantItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "output_text" &&
+          part.text?.includes("[Web search: web_search]"),
+      ),
+    );
+    expect(hasWebSearchPlaceholder).toBe(true);
+
+    // web_search_tool_result in user history is still degraded to text placeholder
+    const userItems = input.filter(
+      (item) => item.type === "message" && item.role === "user",
+    );
+    const hasWebSearchResult = userItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "input_text" && part.text === "[Web search results]",
+      ),
+    );
+    expect(hasWebSearchResult).toBe(true);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // OpenAI Chat Completions compatibility provider tests
 // ---------------------------------------------------------------------------

package/src/__tests__/daemon-server-persist-and-process-callsite.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Regression guard for PR #26115 follow-up: verifies that
+ * `DaemonServer.persistAndProcessMessage` threads `options.callSite`
+ * through to `conversation.runAgentLoop`, mirroring the threading already
+ * done in `DaemonServer.processMessage`.
+ *
+ * The fix is a one-line spread on the `runAgentLoop` options object:
+ *
+ *   ...(options?.callSite ? { callSite: options.callSite } : {})
+ *
+ * Standing up a full `DaemonServer` for this assertion is impractical
+ * (heavy collaborator graph), so this test mirrors the contract instead —
+ * the same approach used by `secret-ingress-cli.test.ts`. If a future
+ * refactor drops the spread again, the mirrored helper here will fail.
+ *
+ * The complementary `conversation-process-callsite.test.ts` test exercises
+ * the threading end-to-end through `Conversation.processMessage`, so the
+ * `Conversation.runAgentLoop` half of the chain is already covered.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import type { LLMCallSite } from "../config/schemas/llm.js";
+
+interface RunAgentLoopOptions {
+  isInteractive?: boolean;
+  isUserMessage?: boolean;
+  callSite?: LLMCallSite;
+}
+
+/**
+ * Mirrors the `runAgentLoop` invocation in
+ * `DaemonServer.persistAndProcessMessage` (server.ts:1396-1400). Production
+ * callers pass `options?.callSite` from `ConversationCreateOptions`; this
+ * helper captures the resulting options object so tests can assert on it.
+ */
+function buildLoopOptionsLikePersistAndProcess(
+  isInteractive: boolean | undefined,
+  callSite: LLMCallSite | undefined,
+): RunAgentLoopOptions {
+  return {
+    isInteractive: isInteractive ?? false,
+    isUserMessage: true,
+    ...(callSite ? { callSite } : {}),
+  };
+}
+
+describe("DaemonServer.persistAndProcessMessage — callSite threading", () => {
+  test("includes callSite in runAgentLoop options when provided", () => {
+    const runAgentLoopMock = mock<(opts: RunAgentLoopOptions) => void>(
+      () => {},
+    );
+
+    const opts = buildLoopOptionsLikePersistAndProcess(true, "heartbeatAgent");
+    runAgentLoopMock(opts);
+
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(1);
+    expect(runAgentLoopMock.mock.calls[0][0]).toEqual({
+      isInteractive: true,
+      isUserMessage: true,
+      callSite: "heartbeatAgent",
+    });
+  });
+
+  test("omits callSite from runAgentLoop options when undefined", () => {
+    const runAgentLoopMock = mock<(opts: RunAgentLoopOptions) => void>(
+      () => {},
+    );
+
+    const opts = buildLoopOptionsLikePersistAndProcess(false, undefined);
+    runAgentLoopMock(opts);
+
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(1);
+    expect(runAgentLoopMock.mock.calls[0][0]).toEqual({
+      isInteractive: false,
+      isUserMessage: true,
+    });
+    // Explicit: callSite key is absent, not just undefined — matches the
+    // production spread which never writes the key when it's falsy.
+    expect("callSite" in runAgentLoopMock.mock.calls[0][0]).toBe(false);
+  });
+
+  test("threads non-default callSite values (e.g. 'filingAgent')", () => {
+    const runAgentLoopMock = mock<(opts: RunAgentLoopOptions) => void>(
+      () => {},
+    );
+
+    const opts = buildLoopOptionsLikePersistAndProcess(false, "filingAgent");
+    runAgentLoopMock(opts);
+
+    expect(runAgentLoopMock.mock.calls[0][0].callSite).toBe("filingAgent");
+  });
+});

package/src/__tests__/delete-propagation.test.ts

@@ -0,0 +1,437 @@
+/**
+ * Tests for Slack message_deleted propagation into stored messages.
+ *
+ * The gateway forwards delete events with `callbackData = "message_deleted"`
+ * and `sourceMetadata.messageId` set to the deleted message's ts. The daemon
+ * marks the corresponding stored row's `slackMeta.deletedAt` while leaving
+ * the `content` column untouched (audit retention; the renderer elides based
+ * on the deletedAt marker).
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+}));
+
+import { eq } from "drizzle-orm";
+
+import { upsertContactChannel } from "../contacts/contacts-write.js";
+import { getDb, initializeDb } from "../memory/db.js";
+import { linkMessage, recordInbound } from "../memory/delivery-crud.js";
+import { messages } from "../memory/schema.js";
+import {
+  readSlackMetadata,
+  writeSlackMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
+import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
+import { _setDeleteLookupConfigForTests } from "../runtime/routes/inbound-message-handler.js";
+
+initializeDb();
+
+const TEST_BEARER_TOKEN = "test-token";
+// Slack `message_deleted` events stamp the deleted message's original author
+// as the actor (gateway: `event.previous_message.user`). The author must be a
+// recognised member for the inbound ACL to admit the event — gating delete
+// behind ACL is the contract under test.
+const SLACK_DELETE_ACTOR_ID = "U_DELETE_ACTOR";
+const SLACK_DELETE_ACTOR_DISPLAY_NAME = "Delete Actor";
+
+function resetState(): void {
+  const db = getDb();
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
+}
+
+function seedActiveDeleteActor(externalChatId: string): void {
+  upsertContactChannel({
+    sourceChannel: "slack",
+    externalUserId: SLACK_DELETE_ACTOR_ID,
+    externalChatId,
+    status: "active",
+    policy: "allow",
+    displayName: SLACK_DELETE_ACTOR_DISPLAY_NAME,
+  });
+}
+
+interface SeededMessage {
+  conversationId: string;
+  messageId: string;
+  originalTs: string;
+  externalChatId: string;
+}
+
+function seedSlackMessage(opts: {
+  externalChatId: string;
+  originalTs: string;
+  content?: string;
+  withSlackMeta?: boolean;
+}): SeededMessage {
+  const db = getDb();
+  // Record the inbound event so channel_inbound_events has an entry
+  // (sourceMessageId = ts for the lookup join).
+  const inbound = recordInbound("slack", opts.externalChatId, opts.originalTs, {
+    sourceMessageId: opts.originalTs,
+  });
+
+  const messageId = `msg-${opts.originalTs}`;
+  const slackMeta = opts.withSlackMeta
+    ? writeSlackMetadata({
+        source: "slack",
+        channelId: opts.externalChatId,
+        channelTs: opts.originalTs,
+        eventKind: "message",
+        displayName: "Test User",
+      })
+    : undefined;
+  const metadata = slackMeta
+    ? JSON.stringify({
+        userMessageChannel: "slack",
+        userMessageInterface: "slack",
+        slackMeta,
+      })
+    : JSON.stringify({
+        userMessageChannel: "slack",
+        userMessageInterface: "slack",
+      });
+
+  db.insert(messages)
+    .values({
+      id: messageId,
+      conversationId: inbound.conversationId,
+      role: "user",
+      content: opts.content ?? "Original message text",
+      createdAt: Date.now(),
+      metadata,
+    })
+    .run();
+  linkMessage(inbound.eventId, messageId);
+
+  return {
+    conversationId: inbound.conversationId,
+    messageId,
+    originalTs: opts.originalTs,
+    externalChatId: opts.externalChatId,
+  };
+}
+
+function buildSlackDeleteRequest(opts: {
+  externalChatId: string;
+  deletedTs: string;
+  eventId?: string;
+  actorExternalId?: string;
+}): Request {
+  const eventId = opts.eventId ?? `evt-del-${opts.deletedTs}`;
+  return new Request("http://localhost:8080/channels/inbound", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Gateway-Origin": TEST_BEARER_TOKEN,
+    },
+    body: JSON.stringify({
+      sourceChannel: "slack",
+      interface: "slack",
+      conversationExternalId: opts.externalChatId,
+      // Delete events get a fresh externalMessageId per-event (PR 5).
+      externalMessageId: eventId,
+      content: "",
+      callbackData: "message_deleted",
+      actorExternalId: opts.actorExternalId ?? SLACK_DELETE_ACTOR_ID,
+      sourceMetadata: {
+        // The original (deleted) message's ts — the lookup key.
+        messageId: opts.deletedTs,
+      },
+    }),
+  });
+}
+
+describe("Slack delete propagation", () => {
+  beforeEach(() => {
+    resetState();
+    seedActiveDeleteActor("C0123CHANNEL");
+    // Keep the lookup retry-loop fast by default so the "no such message"
+    // paths don't pay the full production backoff. The race-test below
+    // overrides this to a longer delay so the first retry can observe
+    // the deferred linkMessage.
+    _setDeleteLookupConfigForTests(2, 20);
+  });
+
+  test("marks slackMeta.deletedAt and leaves content untouched", async () => {
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "1234.5678",
+      content: "Original audited text",
+      withSlackMeta: true,
+    });
+
+    const before = Date.now();
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: seeded.originalTs,
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+    const after = Date.now();
+
+    expect(resp.status).toBe(200);
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+    expect(json.messageId).toBe(seeded.messageId);
+
+    const db = getDb();
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+
+    expect(row).toBeDefined();
+    // Content column MUST be unchanged for audit.
+    expect(row!.content).toBe("Original audited text");
+
+    // Parent metadata still has its sibling keys intact.
+    const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    expect(parsed.userMessageChannel).toBe("slack");
+    expect(parsed.userMessageInterface).toBe("slack");
+    expect(typeof parsed.slackMeta).toBe("string");
+
+    // slackMeta.deletedAt is set to a recent timestamp.
+    const slackMeta = readSlackMetadata(parsed.slackMeta as string);
+    expect(slackMeta).not.toBeNull();
+    expect(slackMeta!.deletedAt).toBeDefined();
+    expect(slackMeta!.deletedAt!).toBeGreaterThanOrEqual(before);
+    expect(slackMeta!.deletedAt!).toBeLessThanOrEqual(after);
+    // Existing slackMeta fields are preserved.
+    expect(slackMeta!.channelId).toBe("C0123CHANNEL");
+    expect(slackMeta!.channelTs).toBe("1234.5678");
+    expect(slackMeta!.eventKind).toBe("message");
+    expect(slackMeta!.displayName).toBe("Test User");
+  });
+
+  test("delete for unknown ts is a no-op", async () => {
+    // Seed an unrelated message so the conversation exists but ts mismatches.
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "1111.1111",
+      content: "Should remain untouched",
+      withSlackMeta: true,
+    });
+
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: "9999.9999", // not seeded
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(resp.status).toBe(200);
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(false);
+
+    // Original message must not be modified.
+    const db = getDb();
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+
+    expect(row!.content).toBe("Should remain untouched");
+    const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const slackMeta = readSlackMetadata(parsed.slackMeta as string);
+    expect(slackMeta!.deletedAt).toBeUndefined();
+  });
+
+  test("delete for row without slackMeta is a no-op (legacy row)", async () => {
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "2222.2222",
+      content: "Legacy pre-upgrade text",
+      withSlackMeta: false,
+    });
+
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: seeded.originalTs,
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(false);
+
+    const db = getDb();
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+
+    expect(row!.content).toBe("Legacy pre-upgrade text");
+    const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    expect(parsed.slackMeta).toBeUndefined();
+  });
+
+  test("delete missing sourceMetadata.messageId is a no-op", async () => {
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "3333.3333",
+      content: "Untouched",
+      withSlackMeta: true,
+    });
+
+    const req = new Request("http://localhost:8080/channels/inbound", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Gateway-Origin": TEST_BEARER_TOKEN,
+      },
+      body: JSON.stringify({
+        sourceChannel: "slack",
+        interface: "slack",
+        conversationExternalId: seeded.externalChatId,
+        externalMessageId: "evt-del-no-source",
+        content: "",
+        callbackData: "message_deleted",
+        actorExternalId: SLACK_DELETE_ACTOR_ID,
+        // sourceMetadata intentionally omitted
+      }),
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(false);
+
+    const db = getDb();
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+    const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const slackMeta = readSlackMetadata(parsed.slackMeta as string);
+    expect(slackMeta!.deletedAt).toBeUndefined();
+  });
+
+  test("delete that races ahead of linkMessage is retried until the link lands", async () => {
+    // Simulates the race: a delete webhook arrives after `recordInbound`
+    // has inserted the original event row but before the agent-loop path
+    // has called `linkMessage` to bind it to a stored message. Without
+    // the retry loop the delete would silently no-op and the deletion
+    // signal would be lost.
+    const db = getDb();
+    const externalChatId = "C0123CHANNEL";
+    const originalTs = "5555.5555";
+    const inbound = recordInbound("slack", externalChatId, originalTs, {
+      sourceMessageId: originalTs,
+    });
+
+    const messageId = `msg-${originalTs}`;
+    const slackMeta = writeSlackMetadata({
+      source: "slack",
+      channelId: externalChatId,
+      channelTs: originalTs,
+      eventKind: "message",
+      displayName: "Test User",
+    });
+    db.insert(messages)
+      .values({
+        id: messageId,
+        conversationId: inbound.conversationId,
+        role: "user",
+        content: "Original text",
+        createdAt: Date.now(),
+        metadata: JSON.stringify({
+          userMessageChannel: "slack",
+          userMessageInterface: "slack",
+          slackMeta,
+        }),
+      })
+      .run();
+
+    // Shorten retries to a handful of small backoffs so the test is fast
+    // while still exercising the loop.
+    _setDeleteLookupConfigForTests(5, 50);
+
+    // Link the message after a short delay — this lands during one of the
+    // retry backoffs. Intentionally not awaited.
+    const LINK_DELAY_MS = 120;
+    setTimeout(() => {
+      linkMessage(inbound.eventId, messageId);
+    }, LINK_DELAY_MS);
+
+    const req = buildSlackDeleteRequest({
+      externalChatId,
+      deletedTs: originalTs,
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(resp.status).toBe(200);
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+    expect(json.messageId).toBe(messageId);
+
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .get();
+    const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const parsedSlackMeta = readSlackMetadata(parsed.slackMeta as string);
+    expect(parsedSlackMeta!.deletedAt).toBeDefined();
+  });
+
+  test("delete from non-member actor is rejected by ACL and does not apply", async () => {
+    // Use a channel where NO active member is seeded so the actor cannot
+    // resolve via the channel's externalChatId either. Verifies that ACL
+    // enforcement rejects delete events from non-members before the delete
+    // handler processes them — the delete must not apply and no row should
+    // be mutated when the actor is not an active member of the target
+    // channel. Also clear the C0123CHANNEL seed for the alt channel below
+    // since beforeEach wires the seed on C0123CHANNEL only.
+    const altChannel = "C0_NON_MEMBER_CHAN";
+    const seeded = seedSlackMessage({
+      externalChatId: altChannel,
+      originalTs: "7777.7777",
+      content: "Original audited text",
+      withSlackMeta: true,
+    });
+
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: seeded.originalTs,
+      actorExternalId: "U_NON_MEMBER",
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    // ACL denies the inbound — the response must not carry `deleted: true`.
+    expect(json.deleted).not.toBe(true);
+
+    // The original row remains unmodified — content untouched and no
+    // deletedAt marker stamped on slackMeta.
+    const db = getDb();
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+    expect(row!.content).toBe("Original audited text");
+    const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const slackMeta = readSlackMetadata(parsed.slackMeta as string);
+    expect(slackMeta!.deletedAt).toBeUndefined();
+  });
+});