@vellumai/assistant 0.7.0 → 0.7.2

package/src/runtime/routes/consolidation-routes.ts

@@ -0,0 +1,115 @@
+/**
+ * Route handlers for the memory v2 consolidation job.
+ *
+ * Consolidation is the v2 counterpart to filing: an interval-based background
+ * pass that routes accumulated `memory/buffer.md` entries into concept pages.
+ * The job itself is enqueued by the memory jobs worker (see
+ * `maybeEnqueueGraphMaintenanceJobs` in `memory/jobs-worker.ts`); these routes
+ * only surface its config and provide an on-demand trigger for the Settings UI.
+ *
+ * `available` mirrors the filing route's `available` field: it reflects which
+ * background memory job is active for this instance. When `memory-v2-enabled`
+ * is off, consolidation returns `available: false` and the UI hides the row.
+ */
+
+import { z } from "zod";
+
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import { getConfig } from "../../config/loader.js";
+import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
+import {
+  enqueueMemoryJob,
+  hasActiveJobOfType,
+} from "../../memory/jobs-store.js";
+import { GRAPH_MAINTENANCE_CHECKPOINTS } from "../../memory/jobs-worker.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+function isConsolidationAvailable(): boolean {
+  return isAssistantFeatureFlagEnabled("memory-v2-enabled", getConfig());
+}
+
+function consolidationIntervalMs(): number {
+  return getConfig().memory.v2.consolidation_interval_hours * 60 * 60 * 1000;
+}
+
+function readLastRunAt(): number | null {
+  const raw = getMemoryCheckpoint(
+    GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
+  );
+  if (!raw) return null;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+// ---------------------------------------------------------------------------
+// Shared ROUTES
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "getConsolidationConfig",
+    endpoint: "consolidation/config",
+    method: "GET",
+    policyKey: "consolidation",
+    requirePolicyEnforcement: true,
+    summary: "Get consolidation config",
+    description:
+      "Return the current memory v2 consolidation schedule configuration.",
+    tags: ["consolidation"],
+    responseBody: z.object({
+      available: z.boolean(),
+      enabled: z.boolean(),
+      intervalMs: z.number(),
+      nextRunAt: z.number().nullable(),
+      lastRunAt: z.number().nullable(),
+      success: z.boolean(),
+    }),
+    handler: async (_args: RouteHandlerArgs) => {
+      const available = isConsolidationAvailable();
+      const v2Config = getConfig().memory.v2;
+      const intervalMs = consolidationIntervalMs();
+      const lastRunAt = readLastRunAt();
+      const nextRunAt = lastRunAt != null ? lastRunAt + intervalMs : null;
+      return {
+        available,
+        enabled: available && v2Config.enabled,
+        intervalMs,
+        nextRunAt,
+        lastRunAt,
+        success: true,
+      };
+    },
+  },
+  {
+    operationId: "runConsolidationNow",
+    endpoint: "consolidation/run-now",
+    method: "POST",
+    policyKey: "consolidation",
+    requirePolicyEnforcement: true,
+    summary: "Run consolidation now",
+    description:
+      "Enqueue an immediate memory v2 consolidation job. Returns once the job is queued; the job itself runs through the memory jobs worker.",
+    tags: ["consolidation"],
+    responseBody: z.object({
+      success: z.boolean(),
+      ran: z.boolean().describe("Whether a job was enqueued"),
+      jobId: z.string().nullable(),
+    }),
+    handler: async (_args: RouteHandlerArgs) => {
+      if (!isConsolidationAvailable()) {
+        throw new BadRequestError(
+          "Consolidation is not available (memory-v2-enabled is off)",
+        );
+      }
+      // Coalesce: don't pile up duplicate jobs if the worker hasn't picked up
+      // the previous one yet. The consolidation job's own lock catches the
+      // overlapping-window case but does not prevent queue depth from growing.
+      if (hasActiveJobOfType("memory_v2_consolidate")) {
+        return { success: true, ran: false, jobId: null };
+      }
+      const jobId = enqueueMemoryJob("memory_v2_consolidate", {});
+      return { success: true, ran: true, jobId };
+    },
+  },
+];

package/src/runtime/routes/contact-prompt-routes.ts

@@ -0,0 +1,183 @@
+/**
+ * IPC route for the `contacts/prompt` CLI command.
+ *
+ * Flow:
+ *   1. CLI calls `contacts/prompt` IPC route with optional channel/role hints.
+ *   2. Daemon broadcasts a `contact_request` to all connected clients.
+ *   3. Client shows a contact address input form.
+ *   4. User enters an address; client POSTs to the gateway's
+ *      `POST /v1/contacts/prompt` HTTP route.
+ *   5. Gateway upserts the contact + channel (gateway owns all contact writes).
+ *   6. Gateway calls daemon IPC `resolve_contact_prompt` with the new contact info.
+ *   7. Daemon resolves the pending promise; `contacts/prompt` IPC returns to CLI.
+ *
+ * The daemon only broadcasts the prompt and waits. It never writes contacts.
+ * All writes go through the gateway.
+ */
+
+import { v4 as uuid } from "uuid";
+import { z } from "zod";
+
+import { getLogger } from "../../util/logger.js";
+import { broadcastMessage } from "../assistant-event-hub.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const log = getLogger("contact-prompt-routes");
+
+/** Timeout for waiting on the user to submit the contact form (5 min). */
+const CONTACT_PROMPT_TIMEOUT_MS = 300_000;
+
+// ---------------------------------------------------------------------------
+// Pending contact prompts
+// ---------------------------------------------------------------------------
+
+export interface ContactPromptResult {
+  ok: boolean;
+  error?: string;
+  contactId?: string;
+  channelId?: string;
+  channelType?: string;
+  address?: string;
+}
+
+interface PendingContactPrompt {
+  resolve: (result: ContactPromptResult) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+const pendingContactPrompts = new Map<string, PendingContactPrompt>();
+
+/**
+ * Called by the gateway after it writes the contact and channel.
+ * Resolves the pending promise so the CLI's `contacts/prompt` IPC call returns.
+ */
+function resolveContactPrompt({
+  body = {},
+}: RouteHandlerArgs): { resolved: boolean } {
+  const { requestId, contactId, channelId, channelType, address, error } =
+    body as {
+      requestId: string;
+      contactId?: string;
+      channelId?: string;
+      channelType?: string;
+      address?: string;
+      error?: string;
+    };
+  const pending = pendingContactPrompts.get(requestId);
+  if (!pending) {
+    log.warn({ requestId }, "resolve_contact_prompt: no pending prompt found");
+    return { resolved: false };
+  }
+
+  clearTimeout(pending.timer);
+  pendingContactPrompts.delete(requestId);
+
+  if (error) {
+    pending.resolve({ ok: false, error });
+  } else {
+    pending.resolve({
+      ok: true,
+      contactId,
+      channelId,
+      channelType,
+      address,
+    });
+  }
+
+  log.info({ requestId, contactId }, "Contact prompt resolved");
+  return { resolved: true };
+}
+
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+
+const ContactPromptParams = z.object({
+  channel: z
+    .string()
+    .optional()
+    .describe(
+      "Suggested channel type hint (e.g. phone, email, telegram). Free text — not enforced.",
+    ),
+  placeholder: z
+    .string()
+    .optional()
+    .describe("Placeholder text for the address input field."),
+  label: z.string().optional().describe("Display label shown in the prompt UI."),
+  description: z.string().optional().describe("Longer description for the prompt UI."),
+  role: z
+    .enum(["guardian", "trusted-contact", "unknown"])
+    .default("unknown")
+    .describe("Intended role of the contact being registered."),
+});
+
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+
+async function handleContactPrompt({
+  body = {},
+}: RouteHandlerArgs): Promise<ContactPromptResult> {
+  const { channel, placeholder, label, description, role } =
+    ContactPromptParams.parse(body);
+
+  const requestId = uuid();
+
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      pendingContactPrompts.delete(requestId);
+      log.warn({ requestId }, "Contact prompt timed out");
+      resolve({ ok: false, error: "Prompt timed out" });
+    }, CONTACT_PROMPT_TIMEOUT_MS);
+
+    pendingContactPrompts.set(requestId, { resolve, timer });
+
+    broadcastMessage({
+      type: "contact_request",
+      requestId,
+      channel,
+      placeholder,
+      label,
+      description,
+      role,
+    });
+
+    log.info({ requestId, channel, role }, "Contact prompt broadcast");
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+
+export const CONTACT_PROMPT_ROUTES: RouteDefinition[] = [
+  {
+    operationId: "contacts_prompt",
+    endpoint: "contacts/prompt",
+    method: "POST",
+    handler: handleContactPrompt,
+    summary: "Prompt user to register a contact channel",
+    description:
+      "Broadcasts a contact_request to connected clients, waits for the user to submit an address via the gateway. The gateway owns the contact write and notifies the daemon via resolve_contact_prompt IPC.",
+    tags: ["contacts"],
+    requestBody: ContactPromptParams,
+    responseBody: z.object({
+      ok: z.boolean(),
+      error: z.string().optional(),
+      contactId: z.string().optional(),
+      channelId: z.string().optional(),
+      channelType: z.string().optional(),
+      address: z.string().optional(),
+    }),
+  },
+  {
+    operationId: "resolve_contact_prompt",
+    endpoint: "resolve_contact_prompt",
+    method: "POST",
+    handler: resolveContactPrompt,
+    summary: "Gateway callback: resolve a pending contact prompt",
+    description:
+      "Called by the gateway after it writes the contact and channel. Unblocks the waiting contacts/prompt IPC call.",
+    tags: ["contacts"],
+  },
+];

package/src/runtime/routes/conversation-list-routes.ts

@@ -30,7 +30,6 @@ import { UserError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { buildAssistantEvent } from "../assistant-event.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import {
   buildConversationDetailResponse,
   serializeConversationSummary,
@@ -58,7 +57,7 @@ function resolveOrThrow(rawId: string): string {
 function publishListInvalidated(): void {
   assistantEventHub
     .publish(
-      buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+      buildAssistantEvent({
         type: "conversation_list_invalidated",
         reason: "seen_changed",
       }),
@@ -75,9 +74,7 @@ function publishListInvalidated(): void {
 // Handlers
 // ---------------------------------------------------------------------------
 
-function handleListConversations({
-  queryParams = {},
-}: RouteHandlerArgs) {
+function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
   const limit = Number(queryParams.limit ?? 50);
   const offset = Number(queryParams.offset ?? 0);
   const backgroundOnly = queryParams.conversationType === "background";
@@ -99,8 +96,7 @@ function handleListConversations({
   const conversationIds = rows.map((c) => c.id);
   const displayMeta = getDisplayMetaForConversations(conversationIds);
   const bindings = getBindingsForConversations(conversationIds);
-  const attentionStates =
-    getAttentionStateByConversationIds(conversationIds);
+  const attentionStates = getAttentionStateByConversationIds(conversationIds);
   const parentCache = new Map<string, ConversationRow | null>();
   const nextOffset = offset + limit;
 
@@ -140,9 +136,9 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
   const conversationId = resolveOrThrow(rawConversationId);
 
   try {
-    const priorState = getAttentionStateByConversationIds([
+    const priorState = getAttentionStateByConversationIds([conversationId]).get(
       conversationId,
-    ]).get(conversationId);
+    );
     const wasUnseen =
       priorState != null &&
       priorState.latestAssistantMessageAt != null &&
@@ -155,8 +151,7 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
       sourceChannel: (body.sourceChannel as string) ?? "vellum",
       signalType: ((body.signalType as string) ??
         "macos_conversation_opened") as SignalType,
-      confidence: ((body.confidence as string) ??
-        "explicit") as Confidence,
+      confidence: ((body.confidence as string) ?? "explicit") as Confidence,
       source: (body.source as string) ?? "http-api",
       evidenceText: body.evidenceText as string | undefined,
       metadata: body.metadata as Record<string, unknown> | undefined,
@@ -169,10 +164,7 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
 
     return { ok: true };
   } catch (err) {
-    log.error(
-      { err, conversationId },
-      "POST /v1/conversations/seen: failed",
-    );
+    log.error({ err, conversationId }, "POST /v1/conversations/seen: failed");
     throw new InternalError("Failed to record seen signal");
   }
 }
@@ -194,22 +186,15 @@ function handleMarkUnread({ body = {} }: RouteHandlerArgs) {
     if (err instanceof UserError) {
       throw new UnprocessableEntityError(err.message);
     }
-    log.error(
-      { err, conversationId },
-      "POST /v1/conversations/unread: failed",
-    );
+    log.error({ err, conversationId }, "POST /v1/conversations/unread: failed");
     throw new InternalError("Failed to mark conversation unread");
   }
 }
 
-function handleGetConversation({
-  pathParams = {},
-}: RouteHandlerArgs) {
+function handleGetConversation({ pathParams = {} }: RouteHandlerArgs) {
   const detail = buildConversationDetailResponse(pathParams.id!);
   if (!detail) {
-    throw new NotFoundError(
-      `Conversation ${pathParams.id} not found`,
-    );
+    throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }
   return detail;
 }
@@ -236,8 +221,7 @@ export const ROUTES: RouteDefinition[] = [
     method: "POST",
     policyKey: "conversations/seen",
     summary: "Record a seen signal",
-    description:
-      "Mark a conversation as seen, advancing the attention cursor.",
+    description: "Mark a conversation as seen, advancing the attention cursor.",
     tags: ["conversations"],
     handler: handleRecordSeen,
   },
@@ -247,8 +231,7 @@ export const ROUTES: RouteDefinition[] = [
     method: "POST",
     policyKey: "conversations/unread",
     summary: "Mark conversation unread",
-    description:
-      "Reset the seen cursor so the conversation appears unread.",
+    description: "Reset the seen cursor so the conversation appears unread.",
     tags: ["conversations"],
     handler: handleMarkUnread,
   },

package/src/runtime/routes/conversation-management-routes.ts

@@ -28,7 +28,6 @@ import {
   switchConversation,
   undoLastMessage,
 } from "../../daemon/handlers/conversations.js";
-import type { ServerMessage } from "../../daemon/message-protocol.js";
 import type { ConversationListInvalidatedReason } from "../../daemon/message-types/conversations.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
 import {
@@ -54,13 +53,8 @@ import { UserError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { buildAssistantEvent } from "../assistant-event.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { buildConversationDetailResponse } from "../services/conversation-serializer.js";
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-} from "./errors.js";
+import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("conversation-management-routes");
@@ -75,10 +69,12 @@ function resolveOrThrow(rawId: string): string {
   return id;
 }
 
-function publishListInvalidated(reason: ConversationListInvalidatedReason): void {
+function publishListInvalidated(
+  reason: ConversationListInvalidatedReason,
+): void {
   assistantEventHub
     .publish(
-      buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+      buildAssistantEvent({
         type: "conversation_list_invalidated",
         reason,
       }),
@@ -191,8 +187,7 @@ function handleSetInferenceProfile({
   pathParams = {},
   body = {},
 }: RouteHandlerArgs) {
-  const resolvedId =
-    resolveConversationId(pathParams.id!) ?? pathParams.id!;
+  const resolvedId = resolveConversationId(pathParams.id!) ?? pathParams.id!;
   const conversation = getConversation(resolvedId);
   if (!conversation) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
@@ -200,12 +195,9 @@ function handleSetInferenceProfile({
 
   if (
     body.profile !== null &&
-    (typeof body.profile !== "string" ||
-      (body.profile as string).length === 0)
+    (typeof body.profile !== "string" || (body.profile as string).length === 0)
   ) {
-    throw new BadRequestError(
-      "profile must be a non-empty string or null",
-    );
+    throw new BadRequestError("profile must be a non-empty string or null");
   }
 
   const profile = body.profile as string | null;
@@ -223,7 +215,6 @@ function handleSetInferenceProfile({
     assistantEventHub
       .publish(
         buildAssistantEvent(
-          DAEMON_INTERNAL_ASSISTANT_ID,
           {
             type: "conversation_inference_profile_updated",
             conversationId: resolvedId,
@@ -260,7 +251,6 @@ function handleRenameConversation({
   assistantEventHub
     .publish(
       buildAssistantEvent(
-        DAEMON_INTERNAL_ASSISTANT_ID,
         {
           type: "conversation_title_updated",
           conversationId: pathParams.id!,
@@ -381,9 +371,7 @@ function handleCancelGeneration({ pathParams = {} }: RouteHandlerArgs) {
 async function handleUndoLastMessage({ pathParams = {} }: RouteHandlerArgs) {
   const result = await undoLastMessage(pathParams.id!);
   if (!result) {
-    throw new NotFoundError(
-      `No active conversation for ${pathParams.id}`,
-    );
+    throw new NotFoundError(`No active conversation for ${pathParams.id}`);
   }
   return {
     removedCount: result.removedCount,
@@ -393,32 +381,10 @@ async function handleUndoLastMessage({ pathParams = {} }: RouteHandlerArgs) {
 
 async function handleRegenerateResponse({ pathParams = {} }: RouteHandlerArgs) {
   const conversationId = pathParams.id!;
-  const resolvedId = resolveConversationId(conversationId) ?? conversationId;
-  let hubChain: Promise<void> = Promise.resolve();
-  const sendEvent = (event: ServerMessage) => {
-    const ae = buildAssistantEvent(
-      DAEMON_INTERNAL_ASSISTANT_ID,
-      event,
-      resolvedId,
-    );
-    hubChain = (async () => {
-      await hubChain;
-      try {
-        await assistantEventHub.publish(ae);
-      } catch (err) {
-        log.warn(
-          { err },
-          "assistant-events hub subscriber threw during regenerate",
-        );
-      }
-    })();
-  };
   try {
-    const result = await regenerateResponse(conversationId, sendEvent);
+    const result = await regenerateResponse(conversationId);
     if (!result) {
-      throw new NotFoundError(
-        `No active conversation for ${pathParams.id}`,
-      );
+      throw new NotFoundError(`No active conversation for ${pathParams.id}`);
     }
     return undefined;
   } catch (err) {
@@ -566,8 +532,7 @@ export const ROUTES: RouteDefinition[] = [
     method: "DELETE",
     policyKey: "conversations/clear-all",
     summary: "Clear all conversations",
-    description:
-      "Permanently delete ALL conversations, messages, and memory.",
+    description: "Permanently delete ALL conversations, messages, and memory.",
     tags: ["conversations"],
     responseStatus: "204",
     handler: handleClearAllConversations,
@@ -631,8 +596,7 @@ export const ROUTES: RouteDefinition[] = [
     method: "POST",
     policyKey: "conversations/cancel",
     summary: "Cancel generation",
-    description:
-      "Abort the in-progress assistant response for a conversation.",
+    description: "Abort the in-progress assistant response for a conversation.",
     tags: ["conversations"],
     pathParams: [{ name: "id" }],
     responseStatus: "202",
@@ -673,8 +637,7 @@ export const ROUTES: RouteDefinition[] = [
     method: "POST",
     policyKey: "conversations/reorder",
     summary: "Reorder conversations",
-    description:
-      "Batch-update display order and pin state for conversations.",
+    description: "Batch-update display order and pin state for conversations.",
     tags: ["conversations"],
     requestBody: z.object({
       updates: z