@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/invite-service-ipc.test.ts

@@ -1,350 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-// Prevent ensureTelegramBotUsernameResolved() from reading real credentials
-// and calling the Telegram API.
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async () => undefined,
-  setSecureKeyAsync: async () => {},
-  deleteSecureKeyAsync: async () => {},
-}));
-
-// The redemption service now claims the gateway-canonical row over IPC before
-// mutating. Default the claim to consumed (updated:true) so these assistant-side
-// handler tests exercise the happy redemption path.
-mock.module("../ipc/gateway-client.js", () => ({
-  ipcCallPersistent: async (
-    method: string,
-    params?: Record<string, unknown>,
-  ) => {
-    if (method === "contacts_get_rich") {
-      return richContactForId(params?.contactId as string);
-    }
-    if (method === "record_invite_redemption") {
-      return { ok: true, updated: true, mirrored: true };
-    }
-    if (method === "upsert_verified_channel") {
-      // Gateway-as-SoT activation: return a verified channel so the gateway-first
-      // relay lands its write before mirroring identity locally.
-      return {
-        ok: true,
-        verified: true,
-        channel: {
-          id: "gw-channel-1",
-          contactId: (params?.contactId as string) ?? "gw-contact-1",
-          type: (params?.type as string) ?? "telegram",
-          address: (params?.address as string) ?? "",
-          status: "active",
-          verifiedAt: Date.now(),
-          verifiedVia: (params?.verifiedVia as string) ?? "invite",
-        },
-      };
-    }
-    return undefined;
-  },
-}));
-
-// Serves contacts_get_rich (the gateway ACL read backing the gate-status
-// fallback) from the seeded local contact identity. Channel ACL state is
-// gateway-owned, so a contact with a mirrored channel reports "active" here —
-// the local status column is drained and never consulted.
-function richContactForId(contactId: string | undefined) {
-  if (!contactId) return undefined;
-  const contact = getContact(contactId);
-  if (!contact) return undefined;
-  // ACL columns are gateway-owned; the projection reports "active" and no longer
-  // mirrors the drained local ACL fields off the typed contact/channel.
-  return {
-    ok: true,
-    contact: {
-      id: contact.id,
-      displayName: contact.displayName,
-      role: "contact",
-      interactionCount: contact.interactionCount,
-      createdAt: contact.createdAt,
-      updatedAt: contact.updatedAt,
-      channels: contact.channels.map((c) => ({
-        id: c.id,
-        contactId: c.contactId,
-        type: c.type,
-        address: c.address,
-        isPrimary: c.isPrimary,
-        externalUserId: c.externalChatId,
-        status: "active",
-        policy: "allow",
-        verifiedAt: null,
-        verifiedVia: null,
-        lastSeenAt: null,
-        interactionCount: 0,
-        lastInteraction: null,
-        revokedReason: null,
-        blockedReason: null,
-      })),
-    },
-  };
-}
-
-import { getContact, upsertContact } from "../contacts/contact-store.js";
-import { handleMintInvite } from "../ipc/routes/invite-ipc-routes.js";
-import { getSqlite } from "../persistence/db-connection.js";
-import { initializeDb } from "../persistence/db-init.js";
-import {
-  createInvite,
-  findById,
-  hashToken,
-} from "../persistence/invite-store.js";
-import {
-  handleRedeemTokenInvite,
-  handleRedeemVoiceInvite,
-} from "../runtime/routes/contact-routes.js";
-import { generateVoiceCode, hashVoiceCode } from "../util/voice-code.js";
-
-await initializeDb();
-
-function resetTables() {
-  getSqlite().run("DELETE FROM assistant_ingress_invites");
-  getSqlite().run("DELETE FROM contact_channels");
-  getSqlite().run("DELETE FROM contacts");
-}
-
-/** Create a throwaway contact and return its ID, for use as the invite's contactId. */
-function createTargetContact(displayName = "Target Contact"): string {
-  return upsertContact({ displayName, role: "contact" }).id;
-}
-
-describe("handleMintInvite (invites_mint)", () => {
-  beforeEach(resetTables);
-
-  test("returns rawToken + gateway projection and persists the assistant row", async () => {
-    const contactId = createTargetContact();
-
-    const result = (await handleMintInvite({
-      body: { sourceChannel: "telegram", contactId, maxUses: 3 },
-    })) as {
-      ok: boolean;
-      invite: { id: string; token?: string };
-      rawToken?: string;
-      gateway: {
-        id: string;
-        inviteCodeHash: string;
-        sourceChannel: string;
-        contactId: string;
-        note: string | null;
-        maxUses: number;
-        expiresAt: number;
-      };
-    };
-
-    expect(result.ok).toBe(true);
-    expect(result.rawToken).toBeDefined();
-    expect(typeof result.rawToken).toBe("string");
-
-    // Gateway projection carries exactly the mirrored fields.
-    expect(result.gateway).toEqual({
-      id: result.invite.id,
-      inviteCodeHash: expect.any(String),
-      sourceChannel: "telegram",
-      contactId,
-      note: null,
-      maxUses: 3,
-      expiresAt: expect.any(Number),
-    });
-
-    // The assistant row is persisted and only the token hash is stored.
-    const row = findById(result.invite.id);
-    expect(row).not.toBeNull();
-    expect(row!.contactId).toBe(contactId);
-    expect(row!.tokenHash).toBe(hashToken(result.rawToken!));
-    expect(row!.inviteCodeHash).toBe(result.gateway.inviteCodeHash);
-  });
-
-  test("voice mint does not expose a raw token but persists voice fields", async () => {
-    const contactId = createTargetContact();
-
-    const result = (await handleMintInvite({
-      body: {
-        sourceChannel: "phone",
-        contactId,
-        expectedExternalUserId: "+12025550100",
-      },
-    })) as {
-      ok: boolean;
-      invite: { id: string; voiceCode?: string };
-      rawToken?: string;
-      gateway: { sourceChannel: string; inviteCodeHash: string };
-    };
-
-    expect(result.ok).toBe(true);
-    // Voice invites never expose the generic redemption token.
-    expect(result.rawToken).toBeUndefined();
-    expect(result.gateway.sourceChannel).toBe("phone");
-
-    const row = findById(result.invite.id);
-    expect(row).not.toBeNull();
-    expect(row!.expectedExternalUserId).toBe("+12025550100");
-    expect(row!.voiceCodeHash).toBeTruthy();
-    // Voice invites have no non-voice inviteCodeHash; the gateway projection
-    // mirrors the voice code hash instead so the NOT NULL mirror constraint holds.
-    expect(row!.inviteCodeHash).toBeNull();
-    expect(row!.voiceCodeHash).toBe(result.gateway.inviteCodeHash);
-  });
-
-  test("returns a 400 when required params are missing", async () => {
-    await expect(
-      handleMintInvite({ body: { contactId: createTargetContact() } }),
-    ).rejects.toThrow();
-  });
-});
-
-describe("handleRedeemTokenInvite (invites_redeem_token)", () => {
-  beforeEach(resetTables);
-
-  test("redeems a valid token and returns the invite shape", async () => {
-    const contactId = createTargetContact();
-    const { rawToken, invite } = createInvite({
-      sourceChannel: "telegram",
-      contactId,
-      maxUses: 1,
-    });
-
-    const result = (await handleRedeemTokenInvite({
-      body: {
-        token: rawToken,
-        sourceChannel: "telegram",
-        externalUserId: "user-1",
-      },
-    })) as { ok: boolean; invite: { id: string }; type: string };
-
-    expect(result.ok).toBe(true);
-    expect(result.invite.id).toBe(invite.id);
-    expect(result.type).toBe("redeemed");
-  });
-
-  test("surfaces type 'already_member' when an existing contact reopens the link", async () => {
-    const contactId = createTargetContact();
-    const { rawToken } = createInvite({
-      sourceChannel: "telegram",
-      contactId,
-      maxUses: 2,
-    });
-
-    // First redeem makes the caller an active contact.
-    await handleRedeemTokenInvite({
-      body: {
-        token: rawToken,
-        sourceChannel: "telegram",
-        externalUserId: "user-1",
-      },
-    });
-
-    // Second redeem by the SAME caller is a no-op membership-wise: it must
-    // surface type "already_member" so the gateway skips consuming a use.
-    const again = (await handleRedeemTokenInvite({
-      body: {
-        token: rawToken,
-        sourceChannel: "telegram",
-        externalUserId: "user-1",
-      },
-    })) as { ok: boolean; type: string };
-
-    expect(again.ok).toBe(true);
-    expect(again.type).toBe("already_member");
-  });
-
-  test("rejects a bogus token with a 400", async () => {
-    await expect(
-      handleRedeemTokenInvite({
-        body: {
-          token: "totally-bogus-token",
-          sourceChannel: "telegram",
-          externalUserId: "user-1",
-        },
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("rejects redemption on the wrong channel", async () => {
-    const contactId = createTargetContact();
-    const { rawToken } = createInvite({
-      sourceChannel: "telegram",
-      contactId,
-      maxUses: 1,
-    });
-
-    await expect(
-      handleRedeemTokenInvite({
-        body: {
-          token: rawToken,
-          sourceChannel: "phone",
-          externalUserId: "user-1",
-        },
-      }),
-    ).rejects.toThrow();
-  });
-});
-
-describe("handleRedeemVoiceInvite (invites_redeem_voice)", () => {
-  beforeEach(resetTables);
-
-  /** Create a voice invite with a known code; return the invite + plaintext code. */
-  function createVoiceInvite(callerPhone = "+12025550100") {
-    const code = generateVoiceCode(6);
-    const { invite } = createInvite({
-      sourceChannel: "phone",
-      contactId: createTargetContact(),
-      maxUses: 1,
-      expectedExternalUserId: callerPhone,
-      voiceCodeHash: hashVoiceCode(code),
-      voiceCodeDigits: 6,
-    });
-    return { invite, code };
-  }
-
-  test("redeems a valid voice code and returns the documented shape", async () => {
-    const phone = "+12025550100";
-    const { invite, code } = createVoiceInvite(phone);
-
-    const result = (await handleRedeemVoiceInvite({
-      body: { callerExternalUserId: phone, code },
-    })) as {
-      ok: boolean;
-      type: string;
-      memberId: string;
-      inviteId?: string;
-    };
-
-    expect(result).toEqual({
-      ok: true,
-      type: "redeemed",
-      memberId: expect.any(String),
-      inviteId: invite.id,
-    });
-  });
-
-  test("wrong caller identity is rejected with a 400", async () => {
-    const { code } = createVoiceInvite("+12025550100");
-
-    await expect(
-      handleRedeemVoiceInvite({
-        body: { callerExternalUserId: "+12025550101", code },
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("missing callerExternalUserId or code is rejected with a 400", async () => {
-    await expect(
-      handleRedeemVoiceInvite({ body: { code: "123456" } }),
-    ).rejects.toThrow();
-    await expect(
-      handleRedeemVoiceInvite({
-        body: { callerExternalUserId: "+12025550100" },
-      }),
-    ).rejects.toThrow();
-  });
-});

package/src/__tests__/job-handler-registry-guard.test.ts

@@ -1,125 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
-
-import { registerMemoryJobHandlers } from "../jobs/register-job-handlers.js";
-import * as jobsWorker from "../persistence/jobs-worker.js";
-import {
-  getMemoryPersistenceHooks,
-  resetMemoryPersistenceHooksForTests,
-} from "../persistence/memory-lifecycle-hooks.js";
-import { registerDefaultPluginJobHandlers } from "../plugins/defaults/index.js";
-import {
-  clearJobHandlerRegistry,
-  getRegisteredJobHandlers,
-  registerPluginJobHandlers,
-} from "../plugins/job-handler-registry.js";
-
-/**
- * The exact job types the `default-memory` plugin contributes via its
- * `jobHandlers` field. Locks the contribution against an accidental add/drop —
- * the job-handler analog of the injector order guard.
- */
-const MEMORY_JOB_TYPES = [
-  "embed_segment",
-  "embed_summary",
-  "backfill",
-  "rebuild_index",
-  "delete_qdrant_vectors",
-  "embed_media",
-  "embed_attachment",
-  "embed_graph_node",
-  "embed_pkb_file",
-  "graph_trigger_embed",
-  "graph_extract",
-  "graph_decay",
-  "graph_consolidate",
-  "graph_pattern_scan",
-  "graph_narrative_refine",
-  "graph_bootstrap",
-  "embed_concept_page",
-  "memory_v2_sweep",
-  "memory_v2_consolidate",
-  "memory_v2_migrate",
-  "memory_v2_reembed",
-  "memory_v2_activation_recompute",
-  "memory_v3_maintain",
-  "memory_retrospective",
-].sort();
-
-/**
- * Job types wired directly by `registerMemoryJobHandlers` for domains that are
- * not plugins (persistence cleanup, conversations, media, home, runtime).
- */
-const NON_PLUGIN_JOB_TYPES = [
-  "prune_old_conversations",
-  "prune_old_llm_request_logs",
-  "prune_old_trace_events",
-  "build_conversation_summary",
-  "media_processing",
-  "conversation_analyze",
-  "generate_conversation_starters",
-].sort();
-
-describe("job-handler registry — memory plugin contribution", () => {
-  beforeEach(() => {
-    clearJobHandlerRegistry();
-  });
-  afterEach(() => {
-    clearJobHandlerRegistry();
-    resetMemoryPersistenceHooksForTests();
-  });
-
-  it("default-memory contributes exactly the memory job types", () => {
-    registerDefaultPluginJobHandlers();
-    const types = getRegisteredJobHandlers()
-      .map((e) => e.type)
-      .sort();
-    expect(types).toEqual(MEMORY_JOB_TYPES);
-    // Globally unique types (the registry would have thrown on a dupe).
-    expect(new Set(types).size).toBe(types.length);
-  });
-
-  it("registerMemoryJobHandlers wires the full job-type set into the worker", () => {
-    const captured: string[] = [];
-    const spy = spyOn(jobsWorker, "registerJobHandler").mockImplementation(
-      (type: string) => {
-        captured.push(type);
-      },
-    );
-    try {
-      registerMemoryJobHandlers();
-    } finally {
-      spy.mockRestore();
-    }
-    const expected = [...MEMORY_JOB_TYPES, ...NON_PLUGIN_JOB_TYPES].sort();
-    expect(captured.slice().sort()).toEqual(expected);
-    // Each type registered exactly once — no plugin/non-plugin overlap, no drop.
-    expect(new Set(captured).size).toBe(captured.length);
-  });
-
-  it("registerMemoryJobHandlers also wires the persistence-lifecycle seam (the standalone worker has no bootstrap)", () => {
-    resetMemoryPersistenceHooksForTests();
-    const before = getMemoryPersistenceHooks();
-    const spy = spyOn(jobsWorker, "registerJobHandler").mockImplementation(
-      () => {},
-    );
-    try {
-      registerMemoryJobHandlers();
-    } finally {
-      spy.mockRestore();
-    }
-    // The seam must move off the no-op default — otherwise the standalone
-    // worker's fork-based retrospectives silently drop carried memory state.
-    expect(getMemoryPersistenceHooks()).not.toBe(before);
-  });
-
-  it("rejects a duplicate job-handler type across plugins", () => {
-    registerPluginJobHandlers("plugin-a", [
-      { type: "graph_extract", handler: () => undefined },
-    ]);
-    expect(() =>
-      registerPluginJobHandlers("plugin-b", [
-        { type: "graph_extract", handler: () => undefined },
-      ]),
-    ).toThrow(/already registered by plugin "plugin-a"/);
-  });
-});

package/src/__tests__/regenerate-fire-and-forget-trace.test.ts

@@ -1,203 +0,0 @@
-/**
- * Guards the observability contract for the fire-and-forget regenerate path.
- *
- * /regenerate does not await runAgentLoop — any error that escapes the
- * agent loop (e.g. a throw from its `finally` block) would otherwise be
- * swallowed by the `.catch()` without the structured `request_error` trace
- * event needed for observability.
- */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
-let dbMessages: Array<{
-  id: string;
-  conversationId: string;
-  role: string;
-  content: string;
-  createdAt: number;
-  metadata: string | null;
-}> = [];
-
-mock.module("../persistence/conversation-crud.js", () => ({
-  setConversationProcessingStartedAt: () => {},
-  isConversationProcessing: () => false,
-  getMessages: (conversationId: string) =>
-    dbMessages.filter((m) => m.conversationId === conversationId),
-  deleteMessageById: (messageId: string) => {
-    dbMessages = dbMessages.filter((m) => m.id !== messageId);
-    return { segmentIds: [], deletedSummaryIds: [] };
-  },
-  updateMessageContent: () => {},
-  relinkAttachments: () => 0,
-  deleteLastExchange: () => 0,
-  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
-}));
-
-mock.module("../persistence/conversation-queries.js", () => ({
-  isLastUserMessageToolResult: () => false,
-}));
-
-mock.module("../persistence/jobs-store.js", () => ({
-  enqueueMemoryJob: () => {},
-}));
-
-mock.module("../persistence/llm-request-log-store.js", () => ({
-  relinkLlmRequestLogs: () => {},
-}));
-
-mock.module("../persistence/embeddings/qdrant-circuit-breaker.js", () => ({
-  withQdrantBreaker: async (fn: () => Promise<unknown>) => fn(),
-}));
-
-mock.module("../persistence/embeddings/qdrant-client.js", () => ({
-  getQdrantClient: () => {
-    throw new Error("Qdrant not initialized");
-  },
-  resolveQdrantUrl: () => "http://127.0.0.1:6333",
-}));
-
-import {
-  type HistoryConversationContext,
-  regenerate,
-} from "../daemon/conversation-history.js";
-import type { Message } from "../providers/types.js";
-
-type TraceEvent = {
-  event: string;
-  body: string;
-  options: { requestId?: string; attributes?: Record<string, unknown> };
-};
-
-function buildContext(
-  overrides: Partial<{
-    runAgentLoop: HistoryConversationContext["runAgentLoop"];
-    messages: Message[];
-    traceEvents: TraceEvent[];
-  }> = {},
-): HistoryConversationContext {
-  const conversationId = "conv-regen-trace";
-
-  const messages: Message[] = overrides.messages ?? [
-    { role: "user", content: [{ type: "text", text: "hello" }] },
-    { role: "assistant", content: [{ type: "text", text: "hi" }] },
-  ];
-
-  dbMessages = [
-    {
-      id: "msg-u1",
-      conversationId,
-      role: "user",
-      content: JSON.stringify([{ type: "text", text: "hello" }]),
-      createdAt: 1000,
-      metadata: null,
-    },
-    {
-      id: "msg-a1",
-      conversationId,
-      role: "assistant",
-      content: JSON.stringify([{ type: "text", text: "hi" }]),
-      createdAt: 2000,
-      metadata: null,
-    },
-  ];
-
-  const traceEvents = overrides.traceEvents ?? [];
-  let processing = false;
-
-  const runAgentLoop: HistoryConversationContext["runAgentLoop"] =
-    overrides.runAgentLoop ??
-    (async () => {
-      throw new Error("boom");
-    });
-
-  return {
-    conversationId,
-    traceEmitter: {
-      emit: (event: string, body: string, options: TraceEvent["options"]) => {
-        traceEvents.push({ event, body, options });
-      },
-    } as unknown as HistoryConversationContext["traceEmitter"],
-    sendToClient: () => {},
-    messages,
-    isProcessing: () => processing,
-    setProcessing: (value: boolean) => {
-      processing = value;
-    },
-    abortController: null,
-    runAgentLoop,
-  };
-}
-
-describe("regenerate fire-and-forget error path", () => {
-  beforeEach(() => {
-    dbMessages = [];
-  });
-
-  test("emits request_error trace when runAgentLoop rejects asynchronously", async () => {
-    const traceEvents: TraceEvent[] = [];
-
-    const session = buildContext({
-      traceEvents,
-      runAgentLoop: async () => {
-        throw new Error("agent loop blew up in finally");
-      },
-    });
-
-    await regenerate(session, "req-123");
-
-    // Give the fire-and-forget .catch() a tick to run.
-    await new Promise((resolve) => setImmediate(resolve));
-
-    const errorEvents = traceEvents.filter((e) => e.event === "request_error");
-    expect(errorEvents).toHaveLength(1);
-    expect(errorEvents[0].body).toBe("agent loop blew up in finally");
-    expect(errorEvents[0].options.requestId).toBe("req-123");
-    expect(errorEvents[0].options.attributes?.errorClass).toBe("Error");
-    expect(errorEvents[0].options.attributes?.source).toBe(
-      "regenerate_fire_and_forget",
-    );
-    expect(errorEvents[0].options.attributes?.message).toBe(
-      "agent loop blew up in finally",
-    );
-  });
-
-  test("uses generated requestId when caller did not pass one", async () => {
-    const traceEvents: TraceEvent[] = [];
-
-    const session = buildContext({
-      traceEvents,
-      runAgentLoop: async () => {
-        throw new Error("boom");
-      },
-    });
-
-    await regenerate(session);
-
-    await new Promise((resolve) => setImmediate(resolve));
-
-    const errorEvents = traceEvents.filter((e) => e.event === "request_error");
-    expect(errorEvents).toHaveLength(1);
-    expect(typeof errorEvents[0].options.requestId).toBe("string");
-    expect((errorEvents[0].options.requestId ?? "").length).toBeGreaterThan(0);
-  });
-
-  test("does not emit request_error when runAgentLoop succeeds", async () => {
-    const traceEvents: TraceEvent[] = [];
-
-    const session = buildContext({
-      traceEvents,
-      runAgentLoop: async () => {},
-    });
-
-    await regenerate(session, "req-ok");
-
-    await new Promise((resolve) => setImmediate(resolve));
-
-    const errorEvents = traceEvents.filter((e) => e.event === "request_error");
-    expect(errorEvents).toHaveLength(0);
-  });
-});