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

package/src/ipc/routes/contacts-mirror-ipc-routes.ts

@@ -0,0 +1,202 @@
+/**
+ * IPC-only contact identity-mirror methods called by the gateway over the
+ * assistant IPC socket (`ipcCallAssistant`).
+ *
+ * The gateway DB owns the ACL verdict; these handlers write only the local
+ * identity/info mirror (contact + channel display fields), running on top of
+ * the `contact-store` upsert/delete primitives, which write info-only columns
+ * and never touch the gateway-owned ACL columns.
+ *
+ * No HTTP surface: registered directly on the IPC server (see
+ * `assistant-server.ts`), never in the shared `ROUTES` array.
+ */
+
+import { z } from "zod";
+
+import { deleteContact, upsertContact } from "../../contacts/contact-store.js";
+import { upsertContactChannel } from "../../contacts/contacts-write.js";
+import { getDb } from "../../persistence/db-connection.js";
+import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
+
+const ContactTypeSchema = z.enum(["human", "assistant"]);
+
+const UpsertChannelParamsSchema = z.object({
+  contactId: z.string().min(1).optional(),
+  // Gateway-minted channel id for a NEW channel: reused verbatim so the mirror
+  // row and the gateway row share an id (id-keyed gateway read-backs match).
+  channelId: z.string().min(1).optional(),
+  type: z.string().min(1),
+  address: z.string().min(1),
+  // Omit to preserve an existing channel's external_chat_id; an explicit value
+  // overwrites; a new channel defaults to null.
+  externalChatId: z.string().min(1).optional(),
+  displayName: z.string().optional(),
+  contactType: ContactTypeSchema.optional(),
+  notes: z.string().optional(),
+  // Inbound identity-seed callers set this so a changed platform profile name
+  // refreshes the mirror; invite-binding callers omit it to preserve a curated
+  // name.
+  refreshDisplayName: z.boolean().optional(),
+  // Reparent a conflicting (type,address) channel owned by another contact to
+  // this one. Invite/verified binding sets true; the inbound identity-seed
+  // mirror sets false to match the gateway insert's onConflictDoNothing (a
+  // first-seen race must not steal the channel from the contact the gateway
+  // kept). Omitted → the primitive defaults to `!!contactId`.
+  reassignConflictingChannels: z.boolean().optional(),
+  // Mark the channel primary. The guardian-bootstrap mirror sets true so its
+  // sole channel keeps the primary flag the gateway binding assigns; omitted
+  // callers leave the flag untouched (existing) or default false (new).
+  isPrimary: z.boolean().optional(),
+});
+
+/**
+ * Upsert a contact + channel identity row, faithfully replicating gateway
+ * identity: it reuses the gateway-minted channel id for a new channel,
+ * optionally re-parents a channel whose (type,address) belongs to another
+ * contact (`reassignConflictingChannels`; invite/verified binding only —
+ * inbound seeds pass false to match the gateway insert's onConflictDoNothing),
+ * refreshes external_chat_id, and — for a mirror-created contact — leaves
+ * user_file NULL (never a generated persona-file stub). The display name is
+ * refreshed for inbound seeds (`refreshDisplayName`) and preserved for the
+ * invite-binding path.
+ */
+export function handleContactsMirrorUpsertChannel({
+  body = {},
+}: RouteHandlerArgs) {
+  applyUpsertChannel(UpsertChannelParamsSchema.parse(body));
+  return { ok: true };
+}
+
+/** Run the channel upsert primitive for an already-parsed op payload. */
+function applyUpsertChannel(
+  params: z.infer<typeof UpsertChannelParamsSchema>,
+): void {
+  upsertContactChannel({
+    sourceChannel: params.type,
+    externalUserId: params.address,
+    externalChatId: params.externalChatId,
+    displayName: params.displayName,
+    contactId: params.contactId,
+    channelId: params.channelId,
+    contactType: params.contactType,
+    notes: params.notes,
+    refreshDisplayName: params.refreshDisplayName,
+    reassignConflictingChannels: params.reassignConflictingChannels,
+    isPrimary: params.isPrimary,
+    // The mirror never seeds a persona file: a mirror-created contact keeps
+    // user_file NULL.
+    userFileOnCreate: null,
+  });
+}
+
+const UpsertContactParamsSchema = z.object({
+  contactId: z.string().min(1),
+  displayName: z.string().min(1),
+  contactType: ContactTypeSchema.optional(),
+  notes: z.string().optional(),
+});
+
+/**
+ * Upsert an identity/display contact row (no channel). Used where the gateway
+ * creates a contact whose channel is bound separately (e.g. the guardian
+ * contact-prompt bootstrap). `userFile` is left null — the mirror never seeds
+ * a persona file.
+ */
+export function handleContactsMirrorUpsertContact({
+  body = {},
+}: RouteHandlerArgs) {
+  applyUpsertContact(UpsertContactParamsSchema.parse(body));
+  return { ok: true };
+}
+
+/** Run the contact upsert primitive for an already-parsed op payload. */
+function applyUpsertContact(
+  params: z.infer<typeof UpsertContactParamsSchema>,
+): void {
+  upsertContact({
+    id: params.contactId,
+    displayName: params.displayName,
+    contactType: params.contactType,
+    notes: params.notes,
+    userFile: null,
+  });
+}
+
+const DeleteContactParamsSchema = z.object({
+  contactId: z.string().min(1),
+});
+
+/**
+ * Delete a contact identity row from the mirror (channels cascade). Replaces
+ * the gateway's orphan-GC / rollback / delete raw mirror writes.
+ */
+export function handleContactsMirrorDeleteContact({
+  body = {},
+}: RouteHandlerArgs) {
+  applyDeleteContact(DeleteContactParamsSchema.parse(body));
+  return { ok: true };
+}
+
+/** Run the contact delete primitive for an already-parsed op payload. */
+function applyDeleteContact(
+  params: z.infer<typeof DeleteContactParamsSchema>,
+): void {
+  deleteContact(params.contactId);
+}
+
+/**
+ * A single identity-mirror operation, tagged by `op`. Each variant reuses the
+ * exact zod schema (and applier) of the corresponding single-row method, so the
+ * per-op semantics are identical — the only added guarantee is atomicity across
+ * ops.
+ */
+const MirrorOpSchema = z.discriminatedUnion("op", [
+  UpsertChannelParamsSchema.extend({ op: z.literal("upsert_channel") }),
+  UpsertContactParamsSchema.extend({ op: z.literal("upsert_contact") }),
+  DeleteContactParamsSchema.extend({ op: z.literal("delete_contact") }),
+]);
+
+const ApplyParamsSchema = z.object({
+  ops: z.array(MirrorOpSchema).min(1),
+});
+
+/**
+ * Apply an ordered batch of identity-mirror ops in ONE daemon-side transaction.
+ * Every op runs against the same connection between BEGIN and COMMIT, so a
+ * mid-batch failure rolls back the entire batch — the mirror is never left
+ * partially applied. Used by the gateway's transactional mirror sites
+ * (guardian bootstrap) whose several writes must land atomically.
+ */
+export function handleContactsMirrorApply({ body = {} }: RouteHandlerArgs) {
+  const { ops } = ApplyParamsSchema.parse(body);
+  getDb().transaction(() => {
+    for (const op of ops) {
+      switch (op.op) {
+        case "upsert_channel":
+          applyUpsertChannel(op);
+          break;
+        case "upsert_contact":
+          applyUpsertContact(op);
+          break;
+        case "delete_contact":
+          applyDeleteContact(op);
+          break;
+      }
+    }
+  });
+  return { ok: true };
+}
+
+/**
+ * IPC-only contact identity-mirror methods, keyed by IPC operationId.
+ * Registered directly on the assistant IPC server (see `assistant-server.ts`).
+ */
+export const CONTACTS_MIRROR_IPC_METHODS: Record<
+  string,
+  (args: RouteHandlerArgs) => unknown
+> = {
+  contacts_mirror_upsert_channel: handleContactsMirrorUpsertChannel,
+  contacts_mirror_upsert_contact: handleContactsMirrorUpsertContact,
+  contacts_mirror_delete_contact: handleContactsMirrorDeleteContact,
+  contacts_mirror_apply: handleContactsMirrorApply,
+};

package/src/ipc/routes/db-proxy.ts

@@ -11,8 +11,11 @@
  * private implementation detail between the gateway and assistant IPC
  * servers and must not be discoverable by clients or the OpenAPI spec.
  *
- * Remove this once all contacts/guardian-binding logic is migrated off
- * the assistant daemon and into the gateway's own database.
+ * The gateway callers are pinned by an allowlist guard
+ * (gateway `__tests__/db-proxy-allowlist.test.ts`): verification-session +
+ * rate-limit state, the contact-merge identity-mirror cluster (pending a
+ * merge-shaped op), and one-time data migrations. Slated for removal with the
+ * verification-session source-of-truth move.
  *
  * Tracking: ATL-XXX (gateway security migration)
  */

package/src/ipc/routes/invite-ipc-routes.ts

@@ -1,66 +1,80 @@
 /**
- * IPC-only invite methods called by the gateway's native invite HTTP
- * handlers over the assistant IPC socket (`ipcCallAssistant`).
+ * IPC-only invite methods called by the gateway over the assistant IPC
+ * socket (`ipcCallAssistant`).
  *
- * Token secrecy + voice fields are assistant-owned, so the gateway mints
- * tokens / redeems codes here and mirrors the canonical lifecycle into its
- * own DB. These have no HTTP surface: they are registered directly on the
- * IPC server and never enter the shared `ROUTES` array, so they can never
+ * These have no HTTP surface: they are registered directly on the IPC
+ * server and never enter the shared `ROUTES` array, so they can never
  * reach the gateway's HTTP IPC proxy route schema (`get_route_schema`).
  *
  * Per `assistant/AGENTS.md`, IPC-only methods are registered here rather
  * than flagged inside `ROUTES`.
  */
 
-import { mintIngressInvite } from "../../runtime/invite-service.js";
-import {
-  handleRedeemTokenInvite,
-  handleRedeemVoiceInvite,
-} from "../../runtime/routes/contact-routes.js";
-import { BadRequestError } from "../../runtime/routes/errors.js";
+import { InviteRedemptionOutcomeSchema } from "@vellumai/gateway-client";
+import { z } from "zod";
+
+import { upsertContactChannel } from "../../contacts/contacts-write.js";
+import { composeInvitePresentation } from "../../runtime/invite-service.js";
 import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
 
 /**
- * Mint an invite for the gateway (`invites_mint`).
+ * Best-effort local info mirror for a gateway-native invite redemption.
  *
- * Returns the raw token plus the minimal projection the gateway mirrors into
- * its own store. Token generation/hashing and voice fields stay
- * assistant-owned.
+ * The gateway owns the ACL outcome; this handler only upserts the local
+ * contact/channel identity row from the outcome's identity fields.
+ * `upsertContactChannel` is an idempotent upsert and fires
+ * `notifyContactsChanged()` internally, so repeated delivery of the same
+ * outcome is safe.
  */
-export async function handleMintInvite({ body = {} }: RouteHandlerArgs) {
-  const result = await mintIngressInvite({
-    sourceChannel: body.sourceChannel as string | undefined,
-    note: body.note as string | undefined,
-    maxUses: body.maxUses as number | undefined,
-    expiresInMs: body.expiresInMs as number | undefined,
-    expectedExternalUserId: body.expectedExternalUserId as string | undefined,
-    contactId: body.contactId as string,
+export function handleInviteRedeemed({ body = {} }: RouteHandlerArgs) {
+  const outcome = InviteRedemptionOutcomeSchema.parse(body);
+  upsertContactChannel({
+    sourceChannel: outcome.sourceChannel,
+    externalUserId: outcome.memberExternalUserId,
+    externalChatId: outcome.memberExternalChatId,
+    displayName: outcome.displayName,
+    username: outcome.username,
+    contactId: outcome.contactId,
   });
+  return { ok: true };
+}
+
+const ComposeInvitePresentationParamsSchema = z.object({
+  contactId: z.string().min(1).optional(),
+  invite: z.record(z.string(), z.unknown()),
+  rawToken: z.string().min(1).optional(),
+});
 
-  if (!result.ok) {
-    throw new BadRequestError(result.error);
-  }
-  return {
-    ok: true,
-    invite: result.data.invite,
-    rawToken: result.data.rawToken,
-    gateway: result.data.gateway,
-  };
+/**
+ * Compose the daemon-owned presentation fields (share link, guardian
+ * instruction, channel handle) for a gateway-minted invite payload.
+ *
+ * Called best-effort by the gateway HTTP create handler so direct gateway
+ * callers receive the same presentation the daemon create relay layers on
+ * in-process. The invite row and its secrets stay gateway-owned; this only
+ * derives display fields from the one-time create payload.
+ */
+export async function handleComposeInvitePresentation({
+  body = {},
+}: RouteHandlerArgs) {
+  const params = ComposeInvitePresentationParamsSchema.parse(body);
+  const invite = await composeInvitePresentation(params);
+  return { invite };
 }
 
 /**
  * IPC-only invite methods, keyed by IPC operationId. Registered directly on
  * the assistant IPC server (see `assistant-server.ts`).
  *
- * `invites_redeem_voice` / `invites_redeem_token` reuse the same split
- * handlers that back the shared HTTP `invites_redeem` route, so token/voice
- * redemption behaves identically across both transports.
+ * `invite_redeemed` is the gateway's post-redemption info-mirror
+ * notification; redemption itself is gateway-native.
+ * `invites_compose_presentation` is the gateway HTTP create handler's
+ * presentation callback; minting itself is gateway-native.
  */
 export const INVITE_IPC_METHODS: Record<
   string,
   (args: RouteHandlerArgs) => unknown
 > = {
-  invites_mint: handleMintInvite,
-  invites_redeem_voice: handleRedeemVoiceInvite,
-  invites_redeem_token: handleRedeemTokenInvite,
+  invite_redeemed: handleInviteRedeemed,
+  invites_compose_presentation: handleComposeInvitePresentation,
 };

package/src/jobs/worker.ts

@@ -14,9 +14,10 @@ import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 
 import { getConfig } from "../config/loader.js";
 import { startInProcessMemoryJobsWorker } from "../persistence/jobs-worker.js";
+import { registerDefaultPluginPersistenceHooks } from "../plugins/defaults/index.js";
+import { registerMemoryPluginJobHandlers } from "../plugins/defaults/memory/job-handler-registration.js";
 import { getLogger } from "../util/logger.js";
 import { getMemoryWorkerPidPath } from "../util/platform.js";
-import { registerMemoryJobHandlers } from "./register-job-handlers.js";
 
 const log = getLogger("memory-worker-process");
 
@@ -42,7 +43,13 @@ async function main(): Promise<void> {
   writeFileSync(pidPath, String(process.pid), { flag: "w" });
   log.info({ pid: process.pid, pidPath }, "Memory worker process started");
 
-  registerMemoryJobHandlers();
+  // This process does not run plugin bootstrap, so self-register everything the
+  // worker dispatches from before starting it: the job handlers (the memory
+  // plugin's own plus the host's non-plugin domain handlers) and the memory
+  // persistence-lifecycle hooks (without which the fork-based retrospectives
+  // silently drop carried memory state).
+  registerMemoryPluginJobHandlers();
+  registerDefaultPluginPersistenceHooks();
   const worker = startInProcessMemoryJobsWorker();
 
   // Keep-alive: the worker's setTimeout timers are unref'd, so without

package/src/live-voice/__tests__/live-voice-archive.test.ts

@@ -63,6 +63,7 @@ async function createMessage(role: "user" | "assistant" = "user") {
 
 function getMessageMetadata(messageId: string): Record<string, unknown> {
   const row = rawGet<{ metadata: string | null }>(
+    "test:getMessageMetadata",
     `SELECT metadata FROM messages WHERE id = ?`,
     messageId,
   );
@@ -80,6 +81,7 @@ function getLiveVoiceArtifacts(
 
 function countAttachmentsForMessage(messageId: string): number {
   const row = rawGet<{ count: number }>(
+    "test:countMessageAttachments",
     `SELECT COUNT(*) AS count FROM message_attachments WHERE message_id = ?`,
     messageId,
   );
@@ -88,6 +90,7 @@ function countAttachmentsForMessage(messageId: string): number {
 
 function countAllAttachments(): number {
   const row = rawGet<{ count: number }>(
+    "test:countAllAttachments",
     `SELECT COUNT(*) AS count FROM attachments`,
   );
   return row?.count ?? 0;
@@ -177,6 +180,7 @@ describe("live voice audio archive", () => {
       filePath: string | null;
       sourcePath: string | null;
     }>(
+      "test:fetchAudioArtifact",
       `SELECT
          data_base64 AS dataBase64,
          file_path AS filePath,
@@ -347,7 +351,11 @@ describe("live voice audio archive", () => {
     expect(first.type).toBe("archived");
     if (first.type !== "archived") throw new Error("expected archive result");
 
-    rawRun(`UPDATE messages SET metadata = NULL WHERE id = ?`, message.id);
+    rawRun(
+      "test:clearMessageMetadata",
+      `UPDATE messages SET metadata = NULL WHERE id = ?`,
+      message.id,
+    );
 
     const second = archiveLiveVoiceAssistantResponseAudio({
       messageId: message.id,
@@ -524,6 +532,7 @@ describe("live voice audio archive", () => {
       originalFilename: string;
       mimeType: string;
     }>(
+      "test:listAttachments",
       `SELECT original_filename AS originalFilename, mime_type AS mimeType
        FROM attachments`,
     );

package/src/live-voice/live-voice-archive.ts

@@ -237,6 +237,7 @@ function readMessageMetadata(
   messageId: string,
 ): MessageMetadataState | "not_found" | "invalid_metadata" {
   const row = rawGet<{ metadata: string | null }>(
+    "liveVoice:readMessageMetadata",
     `SELECT metadata FROM messages WHERE id = ?`,
     messageId,
   );
@@ -270,6 +271,7 @@ function messageAttachmentLinkExists(
   attachmentId: string,
 ): boolean {
   const row = rawGet<{ id: string }>(
+    "liveVoice:attachmentLinkExists",
     `SELECT id
      FROM message_attachments
      WHERE message_id = ? AND attachment_id = ?
@@ -299,6 +301,7 @@ function findExistingAttachmentByFilename(
   filenameStem: string,
 ): AttachmentLookupRow | null {
   const rows = rawAll<AttachmentLookupRow>(
+    "liveVoice:findAttachmentByFilename",
     `SELECT
        a.id AS id,
        a.original_filename AS originalFilename,
@@ -320,6 +323,7 @@ function findExistingAttachmentByFilename(
 
 function nextAttachmentPosition(messageId: string): number {
   const row = rawGet<{ nextPosition: number | null }>(
+    "liveVoice:nextAttachmentPosition",
     `SELECT COALESCE(MAX(position) + 1, 0) AS nextPosition
      FROM message_attachments
      WHERE message_id = ?`,
@@ -343,6 +347,7 @@ function persistArtifactMetadata(
   ];
 
   rawRun(
+    "liveVoice:persistArtifactMetadata",
     `UPDATE messages SET metadata = ? WHERE id = ?`,
     JSON.stringify({
       ...state.metadata,

package/src/messaging/providers/__tests__/transport-dispatch.test.ts

@@ -9,15 +9,15 @@ const slack = {
     Promise.resolve({ ts: "slack-ts" }),
   ),
   sendSlackReaction: mock((..._args: unknown[]) => Promise.resolve()),
-  sendSlackTypingIndicator: mock((..._args: unknown[]) =>
-    Promise.resolve("typing-ts"),
-  ),
   sendSlackAssistantThreadStatus: mock((..._args: unknown[]) =>
     Promise.resolve(),
   ),
   sendSlackAttachments: mock((..._args: unknown[]) =>
     Promise.resolve({ allFailed: false, failureCount: 0 }),
   ),
+  sendSlackStreamOp: mock((..._args: unknown[]) =>
+    Promise.resolve({ ok: true, ts: "stream-ts" }),
+  ),
 };
 const telegram = {
   sendTelegramReply: mock((..._args: unknown[]) => Promise.resolve()),
@@ -144,13 +144,29 @@ describe("Slack sub-operation selection", () => {
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
 
-  test("typing routes to sendSlackTypingIndicator", async () => {
+  test("a typing payload to Slack falls through to deliver (no typing capability)", async () => {
     await deliverDirect(
       `${BASE}/deliver/slack`,
-      payload({ chatAction: "typing" }),
+      payload({ chatAction: "typing", text: "hi" }),
+    );
+    expect(slack.sendSlackReply).toHaveBeenCalledTimes(1);
+  });
+
+  test("slackStream routes to sendSlackStreamOp ahead of the text path", async () => {
+    const result = await deliverDirect(
+      `${BASE}/deliver/slack?threadTs=1700.5`,
+      payload({
+        text: "ignored while streaming",
+        slackStream: { action: "start", threadTs: "1700.5" },
+      }),
     );
-    expect(slack.sendSlackTypingIndicator).toHaveBeenCalledTimes(1);
+    expect(slack.sendSlackStreamOp).toHaveBeenCalledTimes(1);
+    expect(slack.sendSlackStreamOp.mock.calls[0]).toEqual([
+      "C1",
+      { action: "start", threadTs: "1700.5" },
+    ]);
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
+    expect(result).toEqual({ ok: true, ts: "stream-ts" });
   });
 });
 

package/src/messaging/providers/channel-transport.ts

@@ -52,4 +52,10 @@ export interface ChannelTransport {
     ctx: CallbackContext,
     payload: ChannelReplyPayload,
   ): Promise<ChannelDeliveryResult>;
+
+  /** Perform one streaming operation. Routed when `payload.slackStream` is set. */
+  streamReply?(
+    ctx: CallbackContext,
+    payload: ChannelReplyPayload,
+  ): Promise<ChannelDeliveryResult>;
 }

package/src/messaging/providers/index.ts

@@ -88,6 +88,9 @@ export async function deliverDirect(
   }
 
   const ctx = callbackContext(callbackUrl);
+  if (payload.slackStream && transport.streamReply) {
+    return transport.streamReply(ctx, payload);
+  }
   if (payload.reaction && transport.sendReaction) {
     return transport.sendReaction(ctx, payload);
   }

package/src/messaging/providers/slack/api.test.ts

@@ -6,7 +6,7 @@ mock.module("../../../security/secure-keys.js", () => ({
   getSecureKeyAsync: async () => BOT_TOKEN,
 }));
 
-const { getSlackConversationInfo } = await import("./api.js");
+const { getSlackConversationInfo, startSlackStream } = await import("./api.js");
 
 const originalFetch = globalThis.fetch;
 
@@ -52,3 +52,51 @@ describe("getSlackConversationInfo", () => {
     });
   });
 });
+
+describe("startSlackStream", () => {
+  function mockStartStream(): () => Record<string, unknown> {
+    let capturedBody: Record<string, unknown> = {};
+    globalThis.fetch = mock(async (_input, init) => {
+      capturedBody = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      return new Response(JSON.stringify({ ok: true, ts: "1700.1" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+    return () => capturedBody;
+  }
+
+  test("sets recipient fields when streaming into a channel", async () => {
+    const body = mockStartStream();
+
+    await startSlackStream({
+      channel: "C123",
+      threadTs: "1700.0",
+      markdownText: "hi",
+      recipientUserId: "U123",
+      recipientTeamId: "T123",
+    });
+
+    expect(body()).toMatchObject({
+      channel: "C123",
+      thread_ts: "1700.0",
+      markdown_text: "hi",
+      recipient_user_id: "U123",
+      recipient_team_id: "T123",
+    });
+  });
+
+  test("omits recipient fields for a DM stream", async () => {
+    const body = mockStartStream();
+
+    await startSlackStream({
+      channel: "D123",
+      threadTs: "1700.0",
+      markdownText: "hi",
+    });
+
+    const sent = body();
+    expect(sent).not.toHaveProperty("recipient_user_id");
+    expect(sent).not.toHaveProperty("recipient_team_id");
+  });
+});