@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -26,17 +26,11 @@ import { dirname, sep } from "node:path";
 
 import { z } from "zod";
 
-import { readBackupKey } from "../../backup/backup-key.js";
-import {
-  type BackupRunResult,
-  createSnapshotNow,
-} from "../../backup/backup-worker.js";
 import {
   listSnapshotsInDir,
   type SnapshotEntry,
 } from "../../backup/list-snapshots.js";
 import {
-  getBackupKeyPath,
   getLocalBackupsDir,
   resolveOffsiteDestinations,
 } from "../../backup/paths.js";
@@ -47,7 +41,7 @@ import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir, getWorkspaceHooksDir } from "../../util/platform.js";
 import { DefaultPathResolver } from "../migrations/vbundle-import-analyzer.js";
-import { BadRequestError, ConflictError, RouteError } from "./errors.js";
+import { BadRequestError, RouteError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("backup-routes");
@@ -115,23 +109,16 @@ async function validateSnapshotPath(rawPath: unknown): Promise<string> {
 }
 
 /**
- * Load the backup decryption key iff the target snapshot is encrypted.
- * Returns null for plaintext bundles. Throws BadRequestError when an
- * encrypted bundle is supplied but no key file exists.
+ * Reject encrypted snapshots — decryption has moved to the gateway (ATL-397).
+ * The assistant daemon no longer has access to the backup key.
  */
-async function loadKeyIfEncrypted(
-  snapshotPath: string,
-): Promise<Buffer | null> {
-  if (!snapshotPath.endsWith(".vbundle.enc")) {
-    return null;
-  }
-  const key = await readBackupKey(getBackupKeyPath());
-  if (key == null) {
+function rejectIfEncrypted(snapshotPath: string): void {
+  if (snapshotPath.endsWith(".vbundle.enc")) {
     throw new BadRequestError(
-      "Encrypted snapshot requires a backup key, but backup.key is missing",
+      "Encrypted snapshot restore/verify must go through the gateway, " +
+        "which owns the backup key. Use the gateway's backup endpoints instead.",
     );
   }
-  return key;
 }
 
 // ---------------------------------------------------------------------------
@@ -189,24 +176,17 @@ export async function handleBackupList(): Promise<BackupListResponse> {
   return { local, offsite, offsiteEnabled, nextRunAt };
 }
 
-export async function handleBackupCreate(): Promise<BackupRunResult> {
-  try {
-    const config = getConfig();
-    return await createSnapshotNow(config.backup, new Date());
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.startsWith("snapshot in progress")) {
-      throw new ConflictError("A snapshot is already in progress");
-    }
-    log.error({ err }, "Manual backup snapshot failed");
-    throw new RouteError(message, "INTERNAL_ERROR", 500);
-  }
+export async function handleBackupCreate(): Promise<never> {
+  throw new BadRequestError(
+    "Backup snapshot creation has moved to the gateway. " +
+      "Use the gateway's POST /v1/backups/create endpoint instead.",
+  );
 }
 
 export async function handleBackupRestore({ body }: RouteHandlerArgs) {
   const path = body?.path;
   const snapshotPath = await validateSnapshotPath(path);
-  const key = await loadKeyIfEncrypted(snapshotPath);
+  rejectIfEncrypted(snapshotPath);
 
   try {
     const pathResolver = new DefaultPathResolver(
@@ -215,7 +195,6 @@ export async function handleBackupRestore({ body }: RouteHandlerArgs) {
     );
 
     const result = await restoreFromSnapshot(snapshotPath, {
-      key: key ?? undefined,
       pathResolver,
       workspaceDir: getWorkspaceDir(),
     });
@@ -239,12 +218,10 @@ export async function handleBackupRestore({ body }: RouteHandlerArgs) {
 export async function handleBackupVerify({ body }: RouteHandlerArgs) {
   const path = body?.path;
   const snapshotPath = await validateSnapshotPath(path);
-  const key = await loadKeyIfEncrypted(snapshotPath);
+  rejectIfEncrypted(snapshotPath);
 
   try {
-    return await verifySnapshot(snapshotPath, {
-      key: key ?? undefined,
-    });
+    return await verifySnapshot(snapshotPath);
   } catch (err) {
     log.error({ err, snapshotPath }, "Snapshot verification failed");
     throw new RouteError(

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

@@ -18,6 +18,8 @@ import { z } from "zod";
 
 import { readNowScratchpad } from "../../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
+import { buildToolDefinitions } from "../../daemon/conversation-tool-setup.js";
+import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
 import { resolvePersonaContext } from "../../prompts/persona-resolver.js";
 import { getLogger } from "../../util/logger.js";
@@ -35,33 +37,6 @@ const IDENTITY_INTRO_KEY = "identity-intro";
 /** Conversation key used by the client for empty-state greeting generation. */
 const GREETING_KEY = "greeting";
 
-/**
- * Parse the `## Identity Intro` section from SOUL.md.
- * Returns the first non-empty line under that heading, or null.
- */
-function readSoulIdentityIntro(): string | null {
-  try {
-    const soulPath = getWorkspacePromptPath("SOUL.md");
-    if (!existsSync(soulPath)) return null;
-    const content = readFileSync(soulPath, "utf-8");
-
-    let inSection = false;
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (/^#+\s/.test(trimmed)) {
-        inSection = trimmed.toLowerCase().includes("identity intro");
-        continue;
-      }
-      if (inSection && trimmed.length > 0) {
-        return trimmed;
-      }
-    }
-  } catch {
-    // Fall through — no SOUL.md intro available
-  }
-  return null;
-}
-
 // ---------------------------------------------------------------------------
 // SSE helpers
 // ---------------------------------------------------------------------------
@@ -94,14 +69,17 @@ async function handleBtw({
 
   // ----- Identity intro fast-path -----
   if (conversationKey === IDENTITY_INTRO_KEY) {
-    const soulIntro = readSoulIdentityIntro();
-    const fastText = soulIntro ?? getCachedIntro()?.text;
+    let fastText: string | undefined;
+    const identityPath = getWorkspacePromptPath("IDENTITY.md");
+    if (existsSync(identityPath)) {
+      const fields = parseIdentityFields(readFileSync(identityPath, "utf-8"));
+      if (fields.name) {
+        fastText = `Hi, I'm ${fields.name}!`;
+      }
+    }
+    fastText ??= getCachedIntro()?.text;
     if (fastText) {
-      log.debug(
-        soulIntro
-          ? "Returning SOUL.md identity intro"
-          : "Returning cached identity intro",
-      );
+      log.debug("Returning identity intro fast-path");
       return new ReadableStream({
         start(controller) {
           controller.enqueue(sseEvent("btw_text_delta", { text: fastText }));
@@ -129,9 +107,7 @@ async function handleBtw({
   try {
     conversation = await getOrCreateConversation(conversationId);
   } catch {
-    throw new ServiceUnavailableError(
-      "Message processing is not available",
-    );
+    throw new ServiceUnavailableError("Message processing is not available");
   }
 
   return new ReadableStream({
@@ -145,6 +121,7 @@ async function handleBtw({
           const result = await runBtwSidechain({
             content: effectiveContent,
             conversation,
+            tools: buildToolDefinitions(),
             signal: abortSignal,
             userPersona,
             channelPersona,

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

@@ -8,6 +8,7 @@
 import { z } from "zod";
 
 import type { HostProxyCapability } from "../../channels/types.js";
+import { isHttpAuthDisabled } from "../../config/env.js";
 import { datesToISO } from "../../util/json.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
 import { NotFoundError } from "./errors.js";
@@ -33,7 +34,7 @@ export const ROUTES: RouteDefinition[] = [
     responseBody: z.object({
       clients: z.array(z.object({}).passthrough()),
     }),
-    handler: ({ queryParams }) => {
+    handler: ({ queryParams, headers }) => {
       const capability = queryParams?.capability as
         | HostProxyCapability
         | undefined;
@@ -42,12 +43,30 @@ export const ROUTES: RouteDefinition[] = [
         ? assistantEventHub.listClientsByCapability(capability)
         : assistantEventHub.listClients();
 
+      // Defense-in-depth: filter the listing to clients owned by the calling
+      // actor so users cannot enumerate other users' connected client IDs.
+      // Clients with no stored `actorPrincipalId` (legacy SSE subscribers from
+      // before host-proxy-same-user, service-gateway tokens) are filtered out
+      // — fail-closed is the right default for this security boundary.
+      // Dev-bypass mode (DISABLE_HTTP_AUTH=true, mirroring
+      // require-bound-guardian.ts) preserves the previous "return all" behavior
+      // for platform-managed deployments where the platform handles auth.
+      const callerPrincipalId = headers?.["x-vellum-actor-principal-id"];
+      const filtered = isHttpAuthDisabled()
+        ? clients
+        : clients.filter(
+            (c) =>
+              c.actorPrincipalId !== undefined &&
+              c.actorPrincipalId === callerPrincipalId,
+          );
+
       return {
-        clients: clients.map((c) =>
+        clients: filtered.map((c) =>
           datesToISO({
             clientId: c.clientId,
             interfaceId: c.interfaceId,
             capabilities: c.capabilities,
+            machineName: c.machineName,
             connectedAt: c.connectedAt,
             lastActiveAt: c.lastActiveAt,
           }),

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/contact-routes.ts

@@ -11,7 +11,6 @@
 import { z } from "zod";
 
 import {
-  deleteContact,
   getAssistantContactMetadata,
   getChannelById,
   getContact,
@@ -42,7 +41,6 @@ import {
 import {
   BadRequestError,
   ConflictError,
-  ForbiddenError,
   NotFoundError,
 } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -154,17 +152,6 @@ function handleGetContact(contactId: string) {
   };
 }
 
-function handleDeleteContact(contactId: string) {
-  const result = deleteContact(contactId);
-  if (result === "not_found") {
-    throw new NotFoundError(`Contact "${contactId}" not found`);
-  }
-  if (result === "is_guardian") {
-    throw new ForbiddenError("Cannot delete a guardian contact");
-  }
-  return null;
-}
-
 // ---------------------------------------------------------------------------
 // Invite handlers (transport-agnostic)
 // ---------------------------------------------------------------------------
@@ -502,18 +489,6 @@ export const ROUTES: RouteDefinition[] = [
     handler: ({ pathParams }: RouteHandlerArgs) =>
       handleGetContact(pathParams!.id),
   },
-  {
-    operationId: "deleteContact",
-    endpoint: "contacts/:id",
-    method: "DELETE",
-    policyKey: "contacts",
-    summary: "Delete a contact",
-    description: "Delete a contact by ID.",
-    tags: ["contacts"],
-    responseStatus: "204",
-    handler: ({ pathParams }: RouteHandlerArgs) =>
-      handleDeleteContact(pathParams!.id),
-  },
   {
     operationId: "upsert_contact",
     endpoint: "contacts",

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

@@ -50,7 +50,11 @@ import {
   CONFIG_RELOAD_DEBOUNCE_MS,
   log,
 } from "../../daemon/handlers/shared.js";
-import { getAssistantMessageIdsInTurn } from "../../memory/conversation-crud.js";
+import {
+  getAssistantMessageIdsInTurn,
+  getConversation,
+  getMessageById,
+} from "../../memory/conversation-crud.js";
 import { clearEmbeddingBackendCache } from "../../memory/embedding-backend.js";
 import {
   getRequestLogById,
@@ -58,6 +62,7 @@ import {
 } from "../../memory/llm-request-log-store.js";
 import { getMemoryRecallLogByMessageIds } from "../../memory/memory-recall-log-store.js";
 import { getMemoryV2ActivationLogByMessageIds } from "../../memory/memory-v2-activation-log-store.js";
+import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../memory/v2/constants.js";
 import { initializeProviders } from "../../providers/registry.js";
 import { resolvePricingForUsage } from "../../util/pricing.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
@@ -459,6 +464,26 @@ function handleGetMessageContent({
   return result;
 }
 
+const CONVERSATION_KINDS = [
+  "user",
+  "background",
+  "background_memory_consolidation",
+  "scheduled",
+] as const;
+type ConversationKind = (typeof CONVERSATION_KINDS)[number];
+
+function resolveConversationKind(
+  source: string,
+  conversationType: string,
+): ConversationKind {
+  if (source === MEMORY_V2_CONSOLIDATION_SOURCE) {
+    return "background_memory_consolidation";
+  }
+  if (conversationType === "background") return "background";
+  if (conversationType === "scheduled") return "scheduled";
+  return "user";
+}
+
 function handleGetLlmContext({ pathParams = {} }: RouteHandlerArgs) {
   const messageId = pathParams.id;
   if (!messageId) {
@@ -469,8 +494,17 @@ function handleGetLlmContext({ pathParams = {} }: RouteHandlerArgs) {
   const memoryRecallLog = getMemoryRecallLogByMessageIds(turnMessageIds);
   const memoryV2Activation =
     getMemoryV2ActivationLogByMessageIds(turnMessageIds);
+  const message = getMessageById(messageId);
+  const conversation = message ? getConversation(message.conversationId) : null;
+  const conversationKind: ConversationKind = conversation
+    ? resolveConversationKind(
+        conversation.source,
+        conversation.conversationType,
+      )
+    : "user";
   return {
     messageId,
+    conversationKind,
     logs: logs.map((log) => {
       let requestPayload: unknown;
       try {
@@ -709,6 +743,7 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["messages"],
     responseBody: z.object({
       messageId: z.string(),
+      conversationKind: z.enum(CONVERSATION_KINDS),
       logs: z.array(z.unknown()),
       memoryRecall: z.object({}).passthrough().nullable(),
       memoryV2Activation: z.object({}).passthrough().nullable(),