@vellumai/assistant 0.5.1 → 0.5.3

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

@@ -4,6 +4,7 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 
+import { enrichMessageWithSourcePaths } from "../../agent/attachments.js";
 import {
   createAssistantMessage,
   createUserMessage,
@@ -21,10 +22,13 @@ import {
   isModelSlashCommand,
 } from "../../daemon/conversation-process.js";
 import {
-  isProviderShortcut,
   resolveSlash,
   type SlashContext,
 } from "../../daemon/conversation-slash.js";
+import {
+  getCannedFirstGreeting,
+  isWakeUpGreeting,
+} from "../../daemon/first-greeting.js";
 import { renderHistoryContent } from "../../daemon/handlers/shared.js";
 import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
 import { HostCuProxy } from "../../daemon/host-cu-proxy.js";
@@ -34,6 +38,7 @@ import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
   generateCanonicalRequestCode,
+  listCanonicalGuardianRequests,
   listPendingRequestsByConversationScope,
   resolveCanonicalGuardianRequest,
 } from "../../memory/canonical-guardian-store.js";
@@ -76,6 +81,9 @@ import {
 
 const log = getLogger("conversation-routes");
 
+/** Matches the `<no_response/>` sentinel used by channel delivery suppression. */
+const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/g;
+
 const SUGGESTION_CACHE_MAX = 100;
 
 function collectCanonicalGuardianRequestHintIds(
@@ -97,6 +105,43 @@ function collectCanonicalGuardianRequestHintIds(
     .map((req) => req.id);
 }
 
+/**
+ * Expire orphaned canonical guardian requests for a conversation.
+ *
+ * After the in-memory auto-deny loop runs, there may still be "pending"
+ * canonical requests in the DB that have no corresponding in-memory
+ * pending interaction (e.g. the prompter timed out and resolved the
+ * confirmation directly without syncing canonical status). This sweep
+ * catches those stragglers so they don't get falsely matched by the
+ * guardian reply router on subsequent messages.
+ *
+ * Only expires requests *sourced from* (not merely delivered to) this
+ * conversation. Delivered requests may still have live pending interactions
+ * in their source conversation. Additionally skips requests that still
+ * have a live in-memory pending interaction.
+ *
+ * Uses `listCanonicalGuardianRequests` (not `listPendingRequestsByConversationScope`)
+ * so that time-expired requests (past their `expiresAt`) are also caught
+ * instead of being silently filtered out.
+ */
+function expireOrphanedCanonicalRequests(conversationId: string): void {
+  const sourceScoped = listCanonicalGuardianRequests({
+    conversationId,
+    status: "pending",
+    kind: "tool_approval",
+  });
+
+  for (const req of sourceScoped) {
+    // Skip requests that still have a live in-memory pending interaction —
+    // they are not orphaned.
+    if (pendingInteractions.get(req.id)) continue;
+
+    resolveCanonicalGuardianRequest(req.id, "pending", {
+      status: "expired",
+    });
+  }
+}
+
 async function tryConsumeCanonicalGuardianReply(params: {
   conversationId: string;
   sourceChannel: string;
@@ -107,6 +152,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
     filename: string;
     mimeType: string;
     data: string;
+    filePath?: string;
   }>;
   conversation: import("../../daemon/conversation.js").Conversation;
   onEvent: (msg: ServerMessage) => void;
@@ -139,8 +185,12 @@ async function tryConsumeCanonicalGuardianReply(params: {
     sourceChannel,
     conversation,
   );
-  const pendingRequestIds =
-    pendingRequestHintIds.length > 0 ? pendingRequestHintIds : undefined;
+  // Always pass the hints array (even when empty) so
+  // findPendingCanonicalRequests respects the in-memory staleness filter
+  // applied by collectCanonicalGuardianRequestHintIds. Converting empty
+  // hints to `undefined` caused the router to fall through to raw DB
+  // queries that rediscovered stale canonical requests.
+  const pendingRequestIds = pendingRequestHintIds;
 
   const routerResult = await routeGuardianReply({
     messageText: trimmedContent,
@@ -183,19 +233,33 @@ async function tryConsumeCanonicalGuardianReply(params: {
   // is not re-processed as a new user turn.
   let messageId: string | undefined;
   try {
+    const guardianImageSourcePaths: Record<string, string> = {};
+    for (let i = 0; i < attachments.length; i++) {
+      const a = attachments[i];
+      if (a.filePath && a.mimeType.toLowerCase().startsWith("image/")) {
+        guardianImageSourcePaths[`${i}:${a.filename}`] = a.filePath;
+      }
+    }
     const channelMeta = {
       userMessageChannel: sourceChannel,
       assistantMessageChannel: sourceChannel,
       userMessageInterface: sourceInterface,
       assistantMessageInterface: sourceInterface,
       provenanceTrustClass: "guardian" as const,
+      ...(Object.keys(guardianImageSourcePaths).length > 0
+        ? { imageSourcePaths: guardianImageSourcePaths }
+        : {}),
     };
 
-    const userMessage = createUserMessage(content, attachments);
+    const cleanUserMessage = createUserMessage(content, attachments);
+    const llmUserMessage = enrichMessageWithSourcePaths(
+      cleanUserMessage,
+      attachments,
+    );
     const persistedUser = await addMessage(
       conversationId,
       "user",
-      JSON.stringify(userMessage.content),
+      JSON.stringify(cleanUserMessage.content),
       channelMeta,
     );
     messageId = persistedUser.id;
@@ -215,7 +279,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
 
     // Avoid mutating in-memory history / emitting stream deltas while a run is active.
     if (!conversation.isProcessing()) {
-      conversation.getMessages().push(userMessage, assistantMessage);
+      conversation.getMessages().push(llmUserMessage, assistantMessage);
       onEvent({
         type: "assistant_text_delta",
         text: replyText,
@@ -302,6 +366,48 @@ export function handleListMessages(
       content = msg.content;
     }
     const rendered = renderHistoryContent(content);
+
+    // Strip <no_response/> markers from assistant messages so web/API
+    // clients never see the raw sentinel. Only assistant messages produce
+    // this marker; user messages are left untouched.
+    if (msg.role === "assistant") {
+      const originalSegments = rendered.textSegments;
+      const keepIndices: number[] = [];
+      const filteredSegments: string[] = [];
+      for (let i = 0; i < originalSegments.length; i++) {
+        const cleaned = originalSegments[i]
+          .replace(NO_RESPONSE_INLINE_RE, "")
+          .trim();
+        if (cleaned.length > 0) {
+          keepIndices.push(i);
+          filteredSegments.push(cleaned);
+        }
+      }
+      // Remap contentOrder text:N indices to account for removed segments
+      const indexMap = new Map<number, number>();
+      keepIndices.forEach((oldIdx, newIdx) => indexMap.set(oldIdx, newIdx));
+      const filteredContentOrder = rendered.contentOrder
+        .map((entry) => {
+          const m = entry.match(/^text:(\d+)$/);
+          if (!m) return entry;
+          const newIdx = indexMap.get(Number(m[1]));
+          return newIdx !== undefined ? `text:${newIdx}` : undefined;
+        })
+        .filter((e): e is string => e !== undefined);
+
+      return {
+        role: msg.role,
+        text: rendered.text.replace(NO_RESPONSE_INLINE_RE, "").trim(),
+        timestamp: msg.createdAt,
+        toolCalls: rendered.toolCalls,
+        toolCallsBeforeText: rendered.toolCallsBeforeText,
+        textSegments: filteredSegments,
+        contentOrder: filteredContentOrder,
+        surfaces: rendered.surfaces,
+        id: msg.id,
+      };
+    }
+
     return {
       role: msg.role,
       text: rendered.text,
@@ -327,15 +433,11 @@ export function handleListMessages(
       // generate thumbnails for inline display on history restore.
       const linked = attachmentsStore.getAttachmentMetadataForMessage(m.id);
       if (linked.length > 0) {
-        // Batch-fetch file-backed status for all attachments in one query
-        // instead of issuing a separate query per attachment.
-        const fileBackedIds = attachmentsStore.getFileBackedAttachmentIds(
-          linked.map((a) => a.id),
-        );
         msgAttachments = linked.map((a) => {
-          const isFileBacked = fileBackedIds.has(a.id);
           if (a.mimeType.startsWith("image/")) {
-            const full = attachmentsStore.getAttachmentById(a.id);
+            const full = attachmentsStore.getAttachmentById(a.id, {
+              hydrateFileData: true,
+            });
             return {
               id: a.id,
               filename: a.originalFilename,
@@ -346,7 +448,7 @@ export function handleListMessages(
               ...(a.thumbnailBase64
                 ? { thumbnailData: a.thumbnailBase64 }
                 : {}),
-              ...(isFileBacked ? { fileBacked: true } : {}),
+              fileBacked: true,
             };
           }
           return {
@@ -356,7 +458,7 @@ export function handleListMessages(
             sizeBytes: a.sizeBytes,
             kind: a.kind,
             ...(a.thumbnailBase64 ? { thumbnailData: a.thumbnailBase64 } : {}),
-            ...(isFileBacked ? { fileBacked: true } : {}),
+            fileBacked: true,
           };
         });
       }
@@ -748,6 +850,92 @@ export async function handleSendMessage(
     skipProxySenderUpdate: preservingProxies,
   });
 
+  // ── Canned first-greeting fast path ──
+  // On a completely fresh workspace, skip LLM inference for the macOS
+  // wake-up greeting and return a pre-written response. This eliminates
+  // 10-30s of inference latency on first boot.
+  if (isWakeUpGreeting(trimmedContent, conversation.getMessages().length)) {
+    const cannedGreeting = getCannedFirstGreeting();
+    if (cannedGreeting) {
+      conversation.processing = true;
+      let cleanupDeferred = false;
+      try {
+        const provenance = provenanceFromTrustContext(
+          conversation.trustContext,
+        );
+        const channelMeta = {
+          ...provenance,
+          userMessageChannel: sourceChannel,
+          assistantMessageChannel: sourceChannel,
+          userMessageInterface: sourceInterface,
+          assistantMessageInterface: sourceInterface,
+        };
+
+        const rawContent = content ?? "";
+        const attachments = hasAttachments
+          ? smDeps.resolveAttachments(attachmentIds)
+          : [];
+        const userMsg = createUserMessage(rawContent, attachments);
+        const persisted = await addMessage(
+          mapping.conversationId,
+          "user",
+          JSON.stringify(userMsg.content),
+          channelMeta,
+        );
+        conversation.getMessages().push(userMsg);
+
+        setConversationOriginChannelIfUnset(
+          mapping.conversationId,
+          sourceChannel,
+        );
+        setConversationOriginInterfaceIfUnset(
+          mapping.conversationId,
+          sourceInterface,
+        );
+
+        const assistantMsg = createAssistantMessage(cannedGreeting);
+        await addMessage(
+          mapping.conversationId,
+          "assistant",
+          JSON.stringify(assistantMsg.content),
+          channelMeta,
+        );
+        conversation.getMessages().push(assistantMsg);
+
+        const conversationId = mapping.conversationId;
+        const response = Response.json(
+          { accepted: true, messageId: persisted.id, conversationId },
+          { status: 202 },
+        );
+
+        // Defer event publishing to next tick (same pattern as unknown-slash
+        // fast path) so the HTTP response reaches the client before SSE
+        // events arrive.
+        setTimeout(() => {
+          onEvent({ type: "assistant_text_delta", text: cannedGreeting });
+          onEvent({ type: "message_complete", conversationId });
+          conversation.processing = false;
+          silentlyWithLog(
+            conversation.drainQueue(),
+            "canned-greeting queue drain",
+          );
+        }, 0);
+
+        log.info(
+          { conversationId },
+          "Served canned first greeting — skipped LLM inference",
+        );
+        cleanupDeferred = true;
+        return response;
+      } finally {
+        if (!cleanupDeferred && conversation.processing) {
+          conversation.processing = false;
+          silentlyWithLog(conversation.drainQueue(), "error-path queue drain");
+        }
+      }
+    }
+  }
+
   const attachments = hasAttachments
     ? smDeps.resolveAttachments(attachmentIds)
     : [];
@@ -856,6 +1044,10 @@ export async function handleSendMessage(
       pendingInteractions.removeByConversation(conversation);
     }
 
+    // Expire any orphaned canonical requests that survived without a
+    // matching in-memory pending interaction (e.g. prompter timeouts).
+    expireOrphanedCanonicalRequests(mapping.conversationId);
+
     return Response.json(
       { accepted: true, queued: true, conversationId: mapping.conversationId },
       { status: 202 },
@@ -892,6 +1084,10 @@ export async function handleSendMessage(
     pendingInteractions.removeByConversation(conversation);
   }
 
+  // Expire any orphaned canonical requests that survived without a
+  // matching in-memory pending interaction (e.g. prompter timeouts).
+  expireOrphanedCanonicalRequests(mapping.conversationId);
+
   // Conversation is idle — persist and fire agent loop immediately
   conversation.setTurnChannelContext({
     userMessageChannel: sourceChannel,
@@ -915,6 +1111,7 @@ export async function handleSendMessage(
     model: config.services.inference.model,
     provider: config.services.inference.provider,
     estimatedCost: conversation.usageStats.estimatedCost,
+    userMessageInterface: sourceInterface,
   };
   const slashResult = await resolveSlash(rawContent, slashContext);
 
@@ -923,6 +1120,13 @@ export async function handleSendMessage(
     let cleanupDeferred = false;
     try {
       const provenance = provenanceFromTrustContext(conversation.trustContext);
+      const imageSourcePaths: Record<string, string> = {};
+      for (let i = 0; i < attachments.length; i++) {
+        const a = attachments[i];
+        if (a.filePath && a.mimeType.toLowerCase().startsWith("image/")) {
+          imageSourcePaths[`${i}:${a.filename}`] = a.filePath;
+        }
+      }
       const channelMeta = {
         ...provenance,
         userMessageChannel: sourceChannel,
@@ -930,15 +1134,19 @@ export async function handleSendMessage(
         userMessageInterface: sourceInterface,
         assistantMessageInterface: sourceInterface,
         ...(body.automated === true ? { automated: true } : {}),
+        ...(Object.keys(imageSourcePaths).length > 0
+          ? { imageSourcePaths }
+          : {}),
       };
-      const userMsg = createUserMessage(rawContent, attachments);
+      const cleanMsg = createUserMessage(rawContent, attachments);
+      const llmMsg = enrichMessageWithSourcePaths(cleanMsg, attachments);
       const persisted = await addMessage(
         mapping.conversationId,
         "user",
-        JSON.stringify(userMsg.content),
+        JSON.stringify(cleanMsg.content),
         channelMeta,
       );
-      conversation.getMessages().push(userMsg);
+      conversation.getMessages().push(llmMsg);
 
       const assistantMsg = createAssistantMessage(slashResult.message);
       await addMessage(
@@ -960,10 +1168,9 @@ export async function handleSendMessage(
 
       // Snapshot model info now so the deferred callback cannot observe
       // a config change from a concurrent request.
-      const modelInfoEvent =
-        isModelSlashCommand(rawContent) || isProviderShortcut(rawContent)
-          ? await buildModelInfoEvent()
-          : null;
+      const modelInfoEvent = isModelSlashCommand(rawContent)
+        ? await buildModelInfoEvent()
+        : null;
 
       const response = Response.json(
         {
@@ -1047,6 +1254,7 @@ async function generateLlmSuggestion(
   provider: Provider,
   assistantText: string,
 ): Promise<string | null> {
+  const log = (await import("../../util/logger.js")).getLogger("runtime-http");
   const truncated =
     assistantText.length > 2000 ? assistantText.slice(-2000) : assistantText;
 
@@ -1055,18 +1263,43 @@ async function generateLlmSuggestion(
     [{ role: "user", content: [{ type: "text", text: prompt }] }],
     [], // no tools
     undefined, // no system prompt
-    { config: { max_tokens: 30 } },
+    { config: { max_tokens: 40, modelIntent: "latency-optimized" } },
   );
 
   const textBlock = response.content.find((b) => b.type === "text");
   const raw = textBlock && "text" in textBlock ? textBlock.text.trim() : "";
+  const stripped = raw.replace(/^["']+|["']+$/g, "");
 
-  if (!raw) return null;
+  if (!stripped) {
+    log.debug("Suggestion rejected: empty LLM response");
+    return null;
+  }
 
   // Take first line only, then enforce the length cap
-  const firstLine = raw.split("\n")[0].trim();
-  if (!firstLine || firstLine.length > 50) return null;
-  return firstLine;
+  const firstLine = stripped.split("\n")[0].trim();
+  if (!firstLine) {
+    log.debug(
+      { rawLength: stripped.length },
+      "Suggestion rejected: empty after first-line extraction",
+    );
+    return null;
+  }
+  if (firstLine.length <= 50) return firstLine;
+  // Truncate at last word boundary within 50 chars.
+  // Only strip the trailing partial word if the slice actually cut mid-word;
+  // if the character right after the cut is whitespace, the slice is already clean.
+  const sliced = firstLine.slice(0, 50);
+  const wordTruncated = (
+    /\s/.test(firstLine[50]) ? sliced : sliced.replace(/\s+\S*$/, "")
+  ).trim();
+  if (wordTruncated.length < 15) {
+    log.debug(
+      { rawLength: firstLine.length, truncatedLength: wordTruncated.length },
+      "Suggestion rejected: too short after word-boundary truncation",
+    );
+    return null;
+  }
+  return wordTruncated;
 }
 
 export async function handleGetSuggestion(
@@ -1193,8 +1426,16 @@ export async function handleGetSuggestion(
         }
       } catch (err) {
         suggestionInFlight.delete(msg.id);
-        log.warn({ err }, "LLM suggestion failed");
+        log.warn(
+          { err, conversationKey, messageId: msg.id },
+          "LLM suggestion failed",
+        );
       }
+    } else {
+      log.debug(
+        { conversationKey, messageId: msg.id },
+        "Suggestion skipped: no provider available",
+      );
     }
 
     return Response.json({

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

@@ -123,8 +123,10 @@ function handleListConversationStarters(url: URL): Response {
 
   const db = getDb();
 
-  // Fetch chips (ranked by model, newest batch first)
-  const rawItems = db
+  // Fetch all chips (ranked by model, newest batch first), apply diversity
+  // reordering, then paginate. Reordering must happen before offset/limit so
+  // that paginated results are stable across pages.
+  const allItems = db
     .select({
       id: conversationStarters.id,
       label: conversationStarters.label,
@@ -143,20 +145,16 @@ function handleListConversationStarters(url: URL): Response {
       desc(conversationStarters.generationBatch),
       desc(conversationStarters.createdAt),
     )
-    .limit(limitParam)
-    .offset(offsetParam)
     .all();
 
-  const countRow = rawGet<{ c: number }>(
-    `SELECT COUNT(*) AS c FROM conversation_starters WHERE scope_id = ? AND card_type = 'chip'`,
-    scopeId,
-  );
-  const total = countRow?.c ?? 0;
+  const total = allItems.length;
 
-  // If starters exist, return them immediately.
+  // If starters exist, reorder for category diversity then paginate.
   if (total > 0) {
+    const ordered = orderStrongestFirst(allItems);
+    const page = ordered.slice(offsetParam, offsetParam + limitParam);
     return Response.json({
-      starters: orderStrongestFirst(rawItems),
+      starters: page,
       total,
       status: "ready",
     });

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

@@ -410,6 +410,7 @@ async function handleDiagnosticsExport(body: {
         return JSON.stringify({
           id: r.id,
           conversationId: r.conversationId,
+          provider: r.provider,
           request: redactDeep(request),
           response: redactDeep(response),
           createdAt: r.createdAt,

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

@@ -8,6 +8,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { getBaseDataDir } from "../../config/env-registry.js";
+import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getWorkspacePromptPath, readLockfile } from "../../util/platform.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
@@ -149,41 +150,7 @@ export function handleGetIdentity(): Response {
   }
 
   const content = readFileSync(identityPath, "utf-8");
-  const fields: Record<string, string> = {};
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    const lower = trimmed.toLowerCase();
-    const extract = (prefix: string): string | null => {
-      if (!lower.startsWith(prefix)) return null;
-      return trimmed.split(":**").pop()?.trim() ?? null;
-    };
-
-    const name = extract("- **name:**");
-    if (name) {
-      fields.name = name;
-      continue;
-    }
-    const role = extract("- **role:**");
-    if (role) {
-      fields.role = role;
-      continue;
-    }
-    const personality = extract("- **personality:**") ?? extract("- **vibe:**");
-    if (personality) {
-      fields.personality = personality;
-      continue;
-    }
-    const emoji = extract("- **emoji:**");
-    if (emoji) {
-      fields.emoji = emoji;
-      continue;
-    }
-    const home = extract("- **home:**");
-    if (home) {
-      fields.home = home;
-      continue;
-    }
-  }
+  const fields = parseIdentityFields(content);
 
   const version = getPackageVersion();
 

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -334,7 +334,7 @@ export async function enforceIngressAcl(
                   dmCallbackUrl,
                   {
                     chatId: senderUserId,
-                    text: "I've notified the owner that you'd like to chat with me. If they approve your request, they'll share a 6-digit verification code with you. You can reply with the code here.",
+                    text: "I don't recognize you yet! I've let my owner know you're trying to reach me. They'll need to share a 6-digit verification code with you — ask them directly if you know them. Once you have the code, reply here with it.",
                     assistantId,
                   },
                   mintBearerToken(),
@@ -588,7 +588,7 @@ export async function enforceIngressAcl(
                     dmCallbackUrl,
                     {
                       chatId: senderUserId,
-                      text: "I've notified the owner that you'd like to chat with me. If they approve your request, they'll share a 6-digit verification code with you. You can reply with the code here.",
+                      text: "I don't recognize you yet! I've let my owner know you're trying to reach me. They'll need to share a 6-digit verification code with you — ask them directly if you know them. Once you have the code, reply here with it.",
                       assistantId,
                     },
                     mintBearerToken(),