@vellumai/assistant 0.6.4 → 0.6.5

package/src/runtime/routes/approval-strategies/guardian-callback-strategy.ts

@@ -102,6 +102,15 @@ export async function handleGuardianCallbackDecision(
     approvalMessageTs,
   } = params;
 
+  // Reactions have their own deterministic emoji-to-action mapping in
+  // `handleApprovalInterception`. Return null immediately so reaction
+  // callbackData never enters the conversational engine below, which would
+  // misclassify `reaction:white_check_mark` etc. as plain text and only
+  // ever produce `approve_once`/`reject`.
+  if (callbackData?.startsWith("reaction:")) {
+    return null;
+  }
+
   // Callback/button path: deterministic and takes priority.
   let callbackDecision: ApprovalDecisionResult | null = null;
   if (callbackData) {

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

@@ -10,7 +10,7 @@ import { getAvatarImagePath } from "../../util/platform.js";
 import { buildAssistantEvent } from "../assistant-event.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
-import { httpError } from "../http-errors.js";
+import { httpError, type HttpErrorCode } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
 
 const log = getLogger("avatar-routes");
@@ -78,9 +78,25 @@ export function avatarRouteDefinitions(): RouteDefinition[] {
         const result = writeTraitsAndRenderAvatar(body);
 
         if (!result.ok) {
-          const status = result.reason === "render_error" ? 500 : 400;
-          const code =
-            result.reason === "render_error" ? "INTERNAL_ERROR" : "BAD_REQUEST";
+          // Map each failure reason to an HTTP status that reflects its
+          // cause: invalid inputs → 400, missing native dependency → 503,
+          // everything else → 500.
+          let status: number;
+          let code: HttpErrorCode;
+          switch (result.reason) {
+            case "invalid_traits":
+              status = 400;
+              code = "BAD_REQUEST";
+              break;
+            case "native_unavailable":
+              status = 503;
+              code = "SERVICE_UNAVAILABLE";
+              break;
+            case "render_error":
+              status = 500;
+              code = "INTERNAL_ERROR";
+              break;
+          }
           return httpError(code, result.message, status);
         }
 

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

@@ -16,7 +16,6 @@ import { existsSync, readFileSync } from "node:fs";
 
 import { z } from "zod";
 
-import { getConfig } from "../../config/loader.js";
 import { readNowScratchpad } from "../../daemon/conversation-runtime-assembly.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
 import { resolvePersonaContext } from "../../prompts/persona-resolver.js";
@@ -178,9 +177,7 @@ async function handleBtw(
             userPersona,
             channelPersona,
             userSlug,
-            ...(isGreeting
-              ? { modelIntent: getConfig().ui.greetingModelIntent }
-              : {}),
+            ...(isGreeting ? { callSite: "emptyStateGreeting" as const } : {}),
             onEvent: (event) => {
               if (event.type === "text_delta") {
                 controller.enqueue(

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

@@ -386,8 +386,13 @@ export function conversationManagementRouteDefinitions(
           );
         }
 
-        // Broadcast conversation_title_updated so all connected clients
-        // (including the one that initiated the rename) update immediately.
+        // Broadcast conversation_title_updated so the client currently
+        // viewing this conversation can update the header in-place.
+        // Scoped to the conversation id so foreign conversationId values
+        // don't leak to other subscribers' speculative ID-resolution
+        // paths. Other clients learn about the rename via the unscoped
+        // `conversation_list_invalidated` published below, which triggers
+        // their sidebars to refetch and pick up the new title.
         assistantEventHub
           .publish(
             buildAssistantEvent(
@@ -752,6 +757,19 @@ export function conversationManagementRouteDefinitions(
             groupId: u.groupId,
           })),
         );
+        assistantEventHub
+          .publish(
+            buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+              type: "conversation_list_invalidated",
+              reason: "reordered",
+            }),
+          )
+          .catch((err) => {
+            log.warn(
+              { err },
+              "Failed to publish conversation_list_invalidated (reordered)",
+            );
+          });
         return Response.json({ ok: true });
       },
     },

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

@@ -65,6 +65,7 @@ import {
   getLastAssistantTimestampBefore,
   getMessages,
   getMessagesPaginated,
+  hasMessages,
   type MessageRow,
   provenanceFromTrustContext,
   setConversationOriginChannelIfUnset,
@@ -1066,7 +1067,20 @@ function makeHubPublisher(
       typeof (msg as { conversationId?: unknown }).conversationId === "string"
         ? (msg as { conversationId: string }).conversationId
         : undefined;
-    const resolvedConversationId = msgConversationId ?? conversationId;
+    // `conversation_list_invalidated` is a list-level system event: it
+    // describes no particular conversation and every connected client
+    // should refresh its sidebar. Publish it unscoped so the SSE hub does
+    // not filter it out by the subscriber's `filter.conversationId`.
+    // Other events (including `conversation_title_updated`) stay scoped to
+    // their conversation — unscoped scoped-events would leak foreign
+    // `conversationId` values to native clients' speculative ID-resolution
+    // path. For `conversation_title_updated` we instead enqueue a matching
+    // unscoped `conversation_list_invalidated` below so other clients'
+    // sidebars can refresh and pick up the new title.
+    const resolvedConversationId =
+      msg.type === "conversation_list_invalidated"
+        ? undefined
+        : (msgConversationId ?? conversationId);
     const event = buildAssistantEvent(
       DAEMON_INTERNAL_ASSISTANT_ID,
       msg,
@@ -1082,6 +1096,29 @@ function makeHubPublisher(
           "assistant-events hub subscriber threw during POST /messages",
         );
       }
+
+      // When the agent loop auto-generates a conversation title, also
+      // broadcast an unscoped `conversation_list_invalidated` so every
+      // connected client's sidebar can refresh and pick up the new title.
+      // Without this, clients viewing other conversations (or a draft)
+      // would never learn that the title for this conversation changed.
+      // The scoped `conversation_title_updated` above still handles the
+      // in-place update for the client currently viewing this conversation.
+      if (msg.type === "conversation_title_updated") {
+        try {
+          await deps.assistantEventHub.publish(
+            buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+              type: "conversation_list_invalidated",
+              reason: "renamed",
+            }),
+          );
+        } catch (err) {
+          log.warn(
+            { err },
+            "Failed to publish conversation_list_invalidated after title update",
+          );
+        }
+      }
     })();
   };
 }
@@ -1302,6 +1339,7 @@ export async function handleSendMessage(
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
+    clientMessageId?: string;
     onboarding?: {
       tools: string[];
       tasks: string[];
@@ -1312,6 +1350,8 @@ export async function handleSendMessage(
   };
 
   const { conversationKey, content, attachmentIds } = body;
+  const clientMessageId =
+    typeof body.clientMessageId === "string" ? body.clientMessageId : undefined;
   if (!body.sourceChannel || typeof body.sourceChannel !== "string") {
     return httpError("BAD_REQUEST", "sourceChannel is required", 400);
   }
@@ -1414,19 +1454,27 @@ export async function handleSendMessage(
 
   const smDeps = deps.sendMessageDeps;
 
-  // Notify all connected clients that the conversation list changed when a
-  // new standard conversation is created so sidebars can refresh.
-  if (mapping.created && mapping.conversationType === "standard") {
-    smDeps.assistantEventHub
-      .publish(
-        buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
-          type: "conversation_list_invalidated",
-          reason: "created",
-        }),
-      )
-      .catch((err) => {
-        log.warn({ err }, "Failed to publish conversation_list_invalidated");
-      });
+  // Notify all connected clients that the conversation list changed when
+  // this is the first message in a standard conversation, so sidebars on
+  // other devices can refresh. We check for first-message rather than
+  // first-create because the SSE subscribe handler (events-routes.ts) may
+  // have already materialised the conversation from a draft key before any
+  // message was sent — in that case `mapping.created` is `false` even
+  // though, from the user's perspective, this is a brand-new conversation
+  // that other clients don't yet know about.
+  if (mapping.conversationType === "standard") {
+    if (!hasMessages(mapping.conversationId)) {
+      smDeps.assistantEventHub
+        .publish(
+          buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+            type: "conversation_list_invalidated",
+            reason: "created",
+          }),
+        )
+        .catch((err) => {
+          log.warn({ err }, "Failed to publish conversation_list_invalidated");
+        });
+    }
   }
 
   // Build transport metadata from the request so the daemon can inject
@@ -1720,6 +1768,7 @@ export async function handleSendMessage(
             text: rawContent,
             conversationId,
             messageId: persisted.id,
+            clientMessageId,
           });
           onEvent({ type: "assistant_text_delta", text: cannedGreeting });
           onEvent({ type: "message_complete", conversationId });
@@ -1817,6 +1866,7 @@ export async function handleSendMessage(
       { isInteractive },
       undefined, // displayContent
       transport,
+      clientMessageId,
     );
     if (enqueueResult.rejected) {
       return Response.json(
@@ -1929,9 +1979,9 @@ export async function handleSendMessage(
     messageCount: conversation.getMessages().length,
     inputTokens: conversation.usageStats.inputTokens,
     outputTokens: conversation.usageStats.outputTokens,
-    maxInputTokens: config.contextWindow.maxInputTokens,
-    model: config.services.inference.model,
-    provider: config.services.inference.provider,
+    maxInputTokens: config.llm.default.contextWindow.maxInputTokens,
+    model: config.llm.default.model,
+    provider: config.llm.default.provider,
     estimatedCost: conversation.usageStats.estimatedCost,
     userMessageInterface: sourceInterface,
   };
@@ -2019,6 +2069,7 @@ export async function handleSendMessage(
           text: rawContent,
           conversationId,
           messageId: persisted.id,
+          clientMessageId,
         });
         if (modelInfoEvent) {
           onEvent(modelInfoEvent);
@@ -2075,6 +2126,7 @@ export async function handleSendMessage(
           text: rawContent,
           conversationId,
           messageId: persisted.id,
+          clientMessageId,
         });
         conversation.emitActivityState(
           "thinking",
@@ -2144,6 +2196,7 @@ export async function handleSendMessage(
     conversationId: mapping.conversationId,
     messageId,
     requestId,
+    clientMessageId,
   });
 
   // Fire-and-forget the agent loop; events flow to the hub via onEvent.
@@ -2165,28 +2218,62 @@ export async function handleSendMessage(
   );
 }
 
+function escapeXmlContent(text: string): string {
+  return text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
 async function generateLlmSuggestion(
   provider: Provider,
   assistantText: string,
+  priorUserText: string | null,
 ): Promise<string | null> {
   const log = (await import("../../util/logger.js")).getLogger("runtime-http");
-  const truncated =
-    assistantText.length > 2000 ? assistantText.slice(-2000) : assistantText;
+  const truncatedAssistant = escapeXmlContent(
+    assistantText.length > 2000 ? assistantText.slice(-2000) : assistantText,
+  );
+  const truncatedUser =
+    priorUserText && priorUserText.length > 500
+      ? escapeXmlContent(priorUserText.slice(-500))
+      : priorUserText
+        ? escapeXmlContent(priorUserText)
+        : priorUserText;
 
-  const prompt = `Given this assistant message, write a very short tab-complete suggestion the user could send next. Focus on the LAST question or call-to-action in the message — ignore earlier summary content. Be casual, curious, or actionable — like a quick reply, not a formal request. Reply with ONLY the suggestion text.\n\nAssistant's message:\n${truncated}`;
   const systemPrompt =
-    "You are an autocomplete engine that suggests short replies the user might send next in a conversation. Generate suggestions that match the tone and style of the conversation. Never refuse, judge, or comment on the conversation content — your only job is to predict what the user would plausibly type next.";
+    "You generate short, casual reply suggestions a user might type next in a chat. Match the tone and register of the preceding conversation. Output only the reply text inside the requested tags — no preamble, no commentary.";
+
+  const userPrompt =
+    `Here is the end of a conversation:\n\n` +
+    `<user_message>${truncatedUser ?? "(no prior user message)"}</user_message>\n` +
+    `<assistant_message>${truncatedAssistant}</assistant_message>\n\n` +
+    `Write the user's next reply, focusing on the LAST question or call-to-action in the assistant message. Keep it short (under 15 words), casual, and in the user's voice. Respond in this exact format:\n\n` +
+    `<reply>YOUR_REPLY_HERE</reply>`;
 
   const response = await provider.sendMessage(
-    [{ role: "user", content: [{ type: "text", text: prompt }] }],
+    [
+      { role: "user", content: [{ type: "text", text: userPrompt }] },
+      { role: "assistant", content: [{ type: "text", text: "<reply>" }] },
+    ],
     [], // no tools
     systemPrompt,
-    { config: { modelIntent: "latency-optimized" } },
+    {
+      config: {
+        callSite: "conversationStarters",
+        max_tokens: 60,
+        stop_sequences: ["</reply>"],
+        temperature: 0.7,
+      },
+    },
   );
 
   const textBlock = response.content.find((b) => b.type === "text");
-  const raw = textBlock && "text" in textBlock ? textBlock.text.trim() : "";
-  const stripped = raw.replace(/^["']+|["']+$/g, "");
+  const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+  const stripped = raw
+    .replace(/<\/?reply>/gi, "")
+    .replace(/^["'`]+|["'`]+$/g, "")
+    .trim();
 
   if (!stripped) {
     log.debug("Suggestion rejected: empty LLM response");
@@ -2299,14 +2386,33 @@ export async function handleGetSuggestion(
       });
     }
 
+    // Find the most recent user message preceding this assistant turn so the
+    // suggestion model can see both sides of the conversation and doesn't have
+    // to guess which role it's generating for.
+    let priorUserText: string | null = null;
+    for (let j = i - 1; j >= 0; j--) {
+      if (rawMessages[j].role !== "user") continue;
+      let userContent: unknown;
+      try {
+        userContent = JSON.parse(rawMessages[j].content);
+      } catch {
+        userContent = rawMessages[j].content;
+      }
+      const userText = renderHistoryContent(userContent).text.trim();
+      if (userText) {
+        priorUserText = userText;
+        break;
+      }
+    }
+
     // Try LLM suggestion using the configured provider
-    const provider = await getConfiguredProvider();
+    const provider = await getConfiguredProvider("conversationStarters");
     if (provider) {
       try {
         // Deduplicate concurrent requests
         let promise = suggestionInFlight.get(msg.id);
         if (!promise) {
-          promise = generateLlmSuggestion(provider, text);
+          promise = generateLlmSuggestion(provider, text, priorUserText);
           suggestionInFlight.set(msg.id, promise);
         }
 

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

@@ -65,7 +65,7 @@ function handleDebug(): Response {
       startedAt: new Date(startedAt).toISOString(),
     },
     provider: {
-      configuredProvider: config.services.inference.provider,
+      configuredProvider: config.llm.default.provider,
       registeredProviders,
       routingSources,
       inferenceMode: config.services.inference.mode,

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

@@ -222,7 +222,7 @@ async function handleDictation(body: DictationBody): Promise<Response> {
   const transcription = expandSnippets(body.transcription, profile.snippets);
 
   try {
-    const provider = await getConfiguredProvider();
+    const provider = await getConfiguredProvider("interactionClassifier");
     if (!provider) {
       log.warn(
         "Dictation: no provider available, using heuristic + raw transcription",
@@ -288,7 +288,7 @@ async function handleDictation(body: DictationBody): Promise<Response> {
         systemPrompt,
         {
           config: {
-            modelIntent: "latency-optimized",
+            callSite: "interactionClassifier",
             max_tokens: maxTokens,
             tool_choice: {
               type: "tool" as const,
@@ -381,7 +381,7 @@ async function handleCommandMode(
   const maxTokens = Math.max(1024, computeMaxTokens(inputLength));
 
   try {
-    const provider = await getConfiguredProvider();
+    const provider = await getConfiguredProvider("interactionClassifier");
     if (!provider) {
       log.warn("Command mode: no provider available, returning selected text");
       const normalizedText = applyDictionary(
@@ -399,7 +399,9 @@ async function handleCommandMode(
       [userMessage(body.transcription)],
       [],
       systemPrompt,
-      { config: { modelIntent: "latency-optimized", max_tokens: maxTokens } },
+      {
+        config: { callSite: "interactionClassifier", max_tokens: maxTokens },
+      },
     );
 
     const textBlock = response.content.find((b) => b.type === "text");

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

@@ -10,6 +10,16 @@
  * When `conversationKey` is provided, subscribers receive events scoped to
  * that conversation. When omitted, subscribers receive events from ALL
  * conversations for this assistant (unfiltered).
+ *
+ * If the conversationKey has no server-side mapping yet (e.g. a client-
+ * generated draft UUID that has not been sent a first message), this
+ * handler eagerly materialises the conversation so the subscriber's
+ * `filter.conversationId` matches the id under which the first turn's
+ * scoped events (text deltas, tool calls, message_complete) will be
+ * published by `handleSendMessage`. The `conversation_list_invalidated`
+ * notification for other clients is driven by `handleSendMessage`'s
+ * first-message check, so eager materialisation here is safe and does
+ * not hide the first-message notification from other clients.
  */
 
 import { getOrCreateConversation } from "../../memory/conversation-key-store.js";
@@ -75,6 +85,12 @@ export function handleSubscribeAssistantEvents(
     assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
   };
   if (conversationKey) {
+    // Eagerly resolve (and if necessary create) the conversation so the
+    // subscriber's filter matches the id under which first-turn scoped
+    // events will be published. The `conversation_list_invalidated`
+    // publish is driven by `handleSendMessage`'s first-message check,
+    // so eager materialisation here is safe and does not suppress the
+    // cross-client notification.
     const mapping = getOrCreateConversation(conversationKey);
     filter.conversationId = mapping.conversationId;
   }

package/src/runtime/routes/guardian-approval-interception.ts

@@ -31,6 +31,7 @@ import type {
   ApprovalCopyGenerator,
 } from "../http-types.js";
 import { parseApprovalIntent } from "../nl-approval-parser.js";
+import { isTrackedApprovalPromptTs } from "./approval-prompt-ts-tracker.js";
 import { handleGuardianCallbackDecision } from "./approval-strategies/guardian-callback-strategy.js";
 import { handleGuardianTextEngineDecision } from "./approval-strategies/guardian-text-engine-strategy.js";
 import {
@@ -139,7 +140,15 @@ export async function handleApprovalInterception(
   // so getChannelApprovalPrompt(conversationId) would return null.
   // Only guardians can approve via reaction — non-guardian reactions are
   // silently ignored to prevent self-approval.
-  if (callbackData?.startsWith("reaction:")) {
+  //
+  // `reaction_removed:` callbackData never expresses an approval intent, and
+  // `isSlackReactionEvent` short-circuits before reaching here for removals,
+  // but guard explicitly so a future refactor can't turn an un-react into an
+  // unintended approval.
+  if (
+    callbackData?.startsWith("reaction:") &&
+    !callbackData.startsWith("reaction_removed:")
+  ) {
     if (trustCtx.trustClass !== "guardian" || !actorExternalId) {
       return { handled: true, type: "stale_ignored" };
     }
@@ -149,6 +158,23 @@ export async function handleApprovalInterception(
       return { handled: true, type: "stale_ignored" };
     }
 
+    // Require the reacted-to message to be a tracked approval prompt. Without
+    // this check, any unrelated 👍 reaction from the guardian in a subscribed
+    // channel would approve the outstanding pending request (now that
+    // reactions are admitted from any subscribed channel, not just tracked
+    // bot threads). `approvalMessageTs` is `item.ts` of the reacted-to
+    // Slack message, propagated from `sourceMetadata.messageId`.
+    if (
+      !approvalMessageTs ||
+      !isTrackedApprovalPromptTs(
+        sourceChannel,
+        conversationExternalId,
+        approvalMessageTs,
+      )
+    ) {
+      return { handled: true, type: "stale_ignored" };
+    }
+
     const allPending = getAllPendingApprovalsByGuardianChat(
       sourceChannel,
       conversationExternalId,
@@ -493,8 +519,12 @@ export async function handleApprovalInterception(
   // ── Slack reaction path ──
   // Reactions produce `callbackData` of the form `reaction:<emoji_name>`.
   // Only guardians can approve via reaction — non-guardian reactions are
-  // silently ignored to prevent self-approval.
-  if (callbackData?.startsWith("reaction:")) {
+  // silently ignored to prevent self-approval. `reaction_removed:` never
+  // expresses an approval intent.
+  if (
+    callbackData?.startsWith("reaction:") &&
+    !callbackData.startsWith("reaction_removed:")
+  ) {
     if (trustCtx.trustClass !== "guardian") {
       return { handled: true, type: "stale_ignored" };
     }

package/src/runtime/routes/guardian-approval-prompt.ts

@@ -17,6 +17,7 @@ import {
 } from "../gateway-client.js";
 import { buildActionLegend } from "../guardian-decision-types.js";
 import type { ApprovalCopyGenerator } from "../http-types.js";
+import { trackApprovalPromptTs } from "./approval-prompt-ts-tracker.js";
 import { requiredDecisionKeywords } from "./channel-route-shared.js";
 
 const log = getLogger("runtime-http");
@@ -141,7 +142,7 @@ export async function deliverGeneratedApprovalPrompt(
     }
 
     try {
-      await deliverApprovalPrompt(
+      const deliveryResult = await deliverApprovalPrompt(
         replyCallbackUrl,
         chatId,
         enrichedText,
@@ -149,6 +150,9 @@ export async function deliverGeneratedApprovalPrompt(
         assistantId,
         bearerToken,
       );
+      if (deliveryResult.ts) {
+        trackApprovalPromptTs(sourceChannel, chatId, deliveryResult.ts);
+      }
       return true;
     } catch (err) {
       log.error(
@@ -168,7 +172,7 @@ export async function deliverGeneratedApprovalPrompt(
     const taggedFallback = `${plainTextFallback}\n[ref:${uiMetadata.requestId}]`;
 
     try {
-      await deliverChannelReply(
+      const fallbackResult = await deliverChannelReply(
         replyCallbackUrl,
         {
           chatId,
@@ -177,6 +181,9 @@ export async function deliverGeneratedApprovalPrompt(
         },
         bearerToken,
       );
+      if (fallbackResult.ts) {
+        trackApprovalPromptTs(sourceChannel, chatId, fallbackResult.ts);
+      }
       return true;
     } catch (err) {
       log.error(
@@ -197,7 +204,7 @@ export async function deliverGeneratedApprovalPrompt(
   const taggedPlainText = `${plainText}\n[ref:${uiMetadata.requestId}]`;
 
   try {
-    await deliverChannelReply(
+    const plainResult = await deliverChannelReply(
       replyCallbackUrl,
       {
         chatId,
@@ -206,6 +213,9 @@ export async function deliverGeneratedApprovalPrompt(
       },
       bearerToken,
     );
+    if (plainResult.ts) {
+      trackApprovalPromptTs(sourceChannel, chatId, plainResult.ts);
+    }
     return true;
   } catch (err) {
     log.error(