@vellumai/assistant 0.4.41 → 0.4.43

package/src/daemon/handlers/session-history.ts

@@ -1,37 +1,37 @@
-import * as net from "node:net";
-
 import {
   getAttachmentsForMessage,
   getFilePathForAttachment,
   setAttachmentThumbnail,
 } from "../../memory/attachments-store.js";
-import * as conversationStore from "../../memory/conversation-store.js";
+import { getMessageById } from "../../memory/conversation-crud.js";
+import {
+  getMessagesPaginated,
+  listConversations,
+  searchConversations,
+} from "../../memory/conversation-queries.js";
 import { silentlyWithLog } from "../../util/silently.js";
 import { truncate } from "../../util/truncate.js";
-import type { UserMessageAttachment } from "../ipc-contract.js";
 import type {
   ConversationSearchRequest,
   HistoryRequest,
   MessageContentRequest,
-} from "../ipc-protocol.js";
+  UserMessageAttachment,
+} from "../message-protocol.js";
 import { generateVideoThumbnail } from "../video-thumbnail.js";
 import {
   type HandlerContext,
   type HistorySurface,
   type HistoryToolCall,
   log,
-  mergeToolResults,
   type ParsedHistoryMessage,
   renderHistoryContent,
 } from "./shared.js";
 
 export function handleHistoryRequest(
   msg: HistoryRequest,
-  socket: net.Socket,
   ctx: HandlerContext,
 ): void {
-  // Default to unlimited when callers don't specify a limit, preserving
-  // backward-compatible behavior of returning full conversation history.
+  // No limit means return all messages.
   const limit = msg.limit;
 
   // Resolve include flags: explicit flags override mode, mode provides defaults.
@@ -41,13 +41,12 @@ export function handleHistoryRequest(
   const includeToolImages = msg.includeToolImages ?? isFullMode;
   const includeSurfaceData = msg.includeSurfaceData ?? isFullMode;
 
-  const { messages: dbMessages, hasMore } =
-    conversationStore.getMessagesPaginated(
-      msg.sessionId,
-      limit,
-      msg.beforeTimestamp,
-      msg.beforeMessageId,
-    );
+  const { messages: dbMessages, hasMore } = getMessagesPaginated(
+    msg.sessionId,
+    limit,
+    msg.beforeTimestamp,
+    msg.beforeMessageId,
+  );
 
   const parsed: ParsedHistoryMessage[] = dbMessages.map((m) => {
     let text = "";
@@ -114,12 +113,7 @@ export function handleHistoryRequest(
     };
   });
 
-  // Merge tool_result data from user messages into the preceding assistant
-  // message's toolCalls, and suppress user messages that only contain
-  // tool_result blocks (internal agent-loop turns).
-  const merged = mergeToolResults(parsed);
-
-  const historyMessages = merged.map((m) => {
+  const historyMessages = parsed.map((m) => {
     let attachments: UserMessageAttachment[] | undefined;
     if (m.role === "assistant" && m.id) {
       const linked = getAttachmentsForMessage(m.id);
@@ -281,7 +275,7 @@ export function handleHistoryRequest(
   const oldestMessageId =
     historyMessages.length > 0 ? historyMessages[0].id : undefined;
 
-  ctx.send(socket, {
+  ctx.send({
     type: "history_response",
     sessionId: msg.sessionId,
     messages: historyMessages,
@@ -294,38 +288,55 @@ export function handleHistoryRequest(
   // so we no longer emit separate ui_surface_show messages during history loading.
 }
 
-export function handleConversationSearch(
-  msg: ConversationSearchRequest,
-  socket: net.Socket,
-  ctx: HandlerContext,
-): void {
-  const results = conversationStore.searchConversations(msg.query, {
-    limit: msg.limit,
-    maxMessagesPerConversation: msg.maxMessagesPerConversation,
-  });
-  ctx.send(socket, {
-    type: "conversation_search_response",
-    query: msg.query,
-    results,
-  });
+// ---------------------------------------------------------------------------
+// Shared business logic (transport-agnostic)
+// ---------------------------------------------------------------------------
+
+export interface ConversationSearchParams {
+  query: string;
+  limit?: number;
+  maxMessagesPerConversation?: number;
 }
 
-export function handleMessageContentRequest(
-  msg: MessageContentRequest,
-  socket: net.Socket,
-  ctx: HandlerContext,
-): void {
-  const dbMessage = conversationStore.getMessageById(
-    msg.messageId,
-    msg.sessionId,
-  );
-  if (!dbMessage) {
-    ctx.send(socket, {
-      type: "error",
-      message: `Message ${msg.messageId} not found in session ${msg.sessionId}`,
-    });
-    return;
+/** Search conversations and return results (no transport dependency). */
+export function performConversationSearch(params: ConversationSearchParams) {
+  // Treat "*" as a list-all wildcard — FTS treats it as a literal character.
+  if (params.query.trim() === "*") {
+    const rows = listConversations(params.limit);
+    return rows.map((r) => ({
+      conversationId: r.id,
+      conversationTitle: r.title,
+      conversationUpdatedAt: r.updatedAt,
+      matchingMessages: [],
+    }));
   }
+  return searchConversations(params.query, {
+    limit: params.limit,
+    maxMessagesPerConversation: params.maxMessagesPerConversation,
+  });
+}
+
+export interface MessageContentResult {
+  sessionId?: string;
+  messageId: string;
+  text?: string;
+  toolCalls?: Array<{
+    name: string;
+    result?: string;
+    input?: Record<string, unknown>;
+  }>;
+}
+
+/**
+ * Get the full content of a single message by ID.
+ * Returns null if the message is not found.
+ */
+export function getMessageContent(
+  messageId: string,
+  sessionId?: string,
+): MessageContentResult | null {
+  const dbMessage = getMessageById(messageId, sessionId);
+  if (!dbMessage) return null;
 
   let text: string | undefined;
   let toolCalls:
@@ -336,48 +347,10 @@ export function handleMessageContentRequest(
     const content = JSON.parse(dbMessage.content);
     const rendered = renderHistoryContent(content);
     text = rendered.text || undefined;
-    const mergedToolCalls = rendered.toolCalls;
-
-    // Handle legacy conversations where tool_result blocks are stored in the
-    // following user message rather than inline with the assistant message.
-    // This mirrors the mergeToolResults logic used by handleHistoryRequest.
-    if (
-      dbMessage.role === "assistant" &&
-      mergedToolCalls.some((tc) => tc.result === undefined)
-    ) {
-      const nextMsg = conversationStore.getNextMessage(
-        msg.sessionId,
-        dbMessage.createdAt,
-        dbMessage.id,
-      );
-      if (nextMsg && nextMsg.role === "user") {
-        try {
-          const nextContent = JSON.parse(nextMsg.content);
-          const nextRendered = renderHistoryContent(nextContent);
-          if (
-            nextRendered.text.trim() === "" &&
-            nextRendered.toolCalls.length > 0
-          ) {
-            for (const resultEntry of nextRendered.toolCalls) {
-              const unresolved = mergedToolCalls.find(
-                (tc) => tc.result === undefined,
-              );
-              if (unresolved) {
-                unresolved.result = resultEntry.result;
-                unresolved.isError = resultEntry.isError;
-                if (resultEntry.imageData)
-                  unresolved.imageData = resultEntry.imageData;
-              }
-            }
-          }
-        } catch {
-          // Next message isn't valid JSON — skip merging
-        }
-      }
-    }
+    const parsedToolCalls = rendered.toolCalls;
 
-    if (mergedToolCalls.length > 0) {
-      toolCalls = mergedToolCalls.map((tc) => ({
+    if (parsedToolCalls.length > 0) {
+      toolCalls = parsedToolCalls.map((tc) => ({
         name: tc.name,
         input: tc.input,
         ...(tc.result !== undefined ? { result: tc.result } : {}),
@@ -388,11 +361,52 @@ export function handleMessageContentRequest(
     text = dbMessage.content || undefined;
   }
 
-  ctx.send(socket, {
+  return {
+    sessionId,
+    messageId,
+    ...(text !== undefined ? { text } : {}),
+    ...(toolCalls ? { toolCalls } : {}),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// IPC handlers (delegate to shared logic)
+// ---------------------------------------------------------------------------
+
+export function handleConversationSearch(
+  msg: ConversationSearchRequest,
+  ctx: HandlerContext,
+): void {
+  const results = performConversationSearch({
+    query: msg.query,
+    limit: msg.limit,
+    maxMessagesPerConversation: msg.maxMessagesPerConversation,
+  });
+  ctx.send({
+    type: "conversation_search_response",
+    query: msg.query,
+    results,
+  });
+}
+
+export function handleMessageContentRequest(
+  msg: MessageContentRequest,
+  ctx: HandlerContext,
+): void {
+  const result = getMessageContent(msg.messageId, msg.sessionId);
+  if (!result) {
+    ctx.send({
+      type: "error",
+      message: `Message ${msg.messageId} not found in session ${msg.sessionId}`,
+    });
+    return;
+  }
+
+  ctx.send({
     type: "message_content_response",
     sessionId: msg.sessionId,
     messageId: msg.messageId,
-    ...(text !== undefined ? { text } : {}),
-    ...(toolCalls ? { toolCalls } : {}),
+    ...(result.text !== undefined ? { text: result.text } : {}),
+    ...(result.toolCalls ? { toolCalls: result.toolCalls } : {}),
   });
 }

package/src/daemon/handlers/session-user-message.ts

@@ -1,5 +1,3 @@
-import * as net from "node:net";
-
 import { v4 as uuid } from "uuid";
 
 import {
@@ -17,7 +15,7 @@ import {
   listCanonicalGuardianRequests,
   listPendingCanonicalGuardianRequestsByDestinationConversation,
 } from "../../memory/canonical-guardian-store.js";
-import * as conversationStore from "../../memory/conversation-store.js";
+import { addMessage } from "../../memory/conversation-crud.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import { routeGuardianReply } from "../../runtime/guardian-reply-router.js";
 import {
@@ -32,8 +30,11 @@ import {
 } from "../../security/secret-scanner.js";
 import { createApprovalConversationGenerator } from "../approval-generators.js";
 import { getAssistantName } from "../identity-helpers.js";
-import type { UserMessageAttachment } from "../ipc-contract.js";
-import type { ServerMessage, UserMessage } from "../ipc-protocol.js";
+import type {
+  ServerMessage,
+  UserMessage,
+  UserMessageAttachment,
+} from "../message-protocol.js";
 import { executeRecordingIntent } from "../recording-executor.js";
 import { resolveRecordingIntent } from "../recording-intent.js";
 import {
@@ -71,24 +72,23 @@ async function persistRecordingExchange(
   messageText: string,
   responseText: string,
   session: Session,
-  socket: net.Socket,
   ctx: HandlerContext,
 ): Promise<void> {
-  ctx.send(socket, {
+  ctx.send({
     type: "assistant_text_delta",
     text: responseText,
     sessionId,
   });
-  ctx.send(socket, {
+  ctx.send({
     type: "message_complete",
     sessionId,
   });
-  await conversationStore.addMessage(
+  await addMessage(
     sessionId,
     "user",
     JSON.stringify([{ type: "text", text: messageText }]),
   );
-  await conversationStore.addMessage(
+  await addMessage(
     sessionId,
     "assistant",
     JSON.stringify([{ type: "text", text: responseText }]),
@@ -110,7 +110,6 @@ async function persistRecordingExchange(
 function handleSecretIngress(
   msg: UserMessage,
   messageText: string,
-  socket: net.Socket,
   ctx: HandlerContext,
   session: Session,
   rlog: typeof log,
@@ -125,7 +124,7 @@ function handleSecretIngress(
     { detectedTypes: ingressCheck.detectedTypes },
     "Blocked user message containing secrets",
   );
-  ctx.send(socket, {
+  ctx.send({
     type: "error",
     message: ingressCheck.userNotice!,
     category: "secret_blocked",
@@ -146,12 +145,12 @@ function handleSecretIngress(
 
   session.redirectToSecurePrompt(ingressCheck.detectedTypes, {
     onStored: (record) => {
-      ctx.send(socket, {
+      ctx.send({
         type: "assistant_text_delta",
         sessionId: msg.sessionId,
         text: "Saved your secret securely. Continuing with your request.",
       });
-      ctx.send(socket, {
+      ctx.send({
         type: "message_complete",
         sessionId: msg.sessionId,
       });
@@ -185,7 +184,6 @@ async function handleStructuredRecordingIntent(
   msg: UserMessage,
   messageText: string,
   session: Session,
-  socket: net.Socket,
   ctx: HandlerContext,
   rlog: typeof log,
 ): Promise<boolean> {
@@ -207,7 +205,6 @@ async function handleStructuredRecordingIntent(
     const recordingId = handleRecordingStart(
       msg.sessionId,
       { promptForSource: true },
-      socket,
       ctx,
     );
     const responseText = recordingId
@@ -218,7 +215,6 @@ async function handleStructuredRecordingIntent(
       messageText,
       responseText,
       session,
-      socket,
       ctx,
     );
     return true;
@@ -232,18 +228,16 @@ async function handleStructuredRecordingIntent(
       messageText,
       responseText,
       session,
-      socket,
       ctx,
     );
     return true;
   } else if (action === "restart") {
-    const restartResult = handleRecordingRestart(msg.sessionId, socket, ctx);
+    const restartResult = handleRecordingRestart(msg.sessionId, ctx);
     await persistRecordingExchange(
       msg.sessionId,
       messageText,
       restartResult.responseText,
       session,
-      socket,
       ctx,
     );
     return true;
@@ -257,7 +251,6 @@ async function handleStructuredRecordingIntent(
       messageText,
       responseText,
       session,
-      socket,
       ctx,
     );
     return true;
@@ -271,7 +264,6 @@ async function handleStructuredRecordingIntent(
       messageText,
       responseText,
       session,
-      socket,
       ctx,
     );
     return true;
@@ -293,7 +285,6 @@ async function handleStandaloneRecordingIntent(
   msg: UserMessage,
   messageText: string,
   session: Session,
-  socket: net.Socket,
   ctx: HandlerContext,
   rlog: typeof log,
 ): Promise<{
@@ -321,7 +312,6 @@ async function handleStandaloneRecordingIntent(
   ) {
     const execResult = executeRecordingIntent(intentResult, {
       conversationId: msg.sessionId,
-      socket,
       ctx,
     });
 
@@ -335,7 +325,6 @@ async function handleStandaloneRecordingIntent(
         messageText,
         execResult.responseText!,
         session,
-        socket,
         ctx,
       );
       return { handled: true, updatedMessageText: messageText };
@@ -351,7 +340,6 @@ async function handleStandaloneRecordingIntent(
   ) {
     const execResult = executeRecordingIntent(intentResult, {
       conversationId: msg.sessionId,
-      socket,
       ctx,
     });
 
@@ -366,7 +354,6 @@ async function handleStandaloneRecordingIntent(
       handleRecordingStart(
         msg.sessionId,
         { promptForSource: true },
-        socket,
         ctx,
       );
     }
@@ -374,7 +361,7 @@ async function handleStandaloneRecordingIntent(
       intentResult.kind === "restart_with_remainder" ||
       intentResult.kind === "start_and_stop_with_remainder"
     ) {
-      const restartResult = handleRecordingRestart(msg.sessionId, socket, ctx);
+      const restartResult = handleRecordingRestart(msg.sessionId, ctx);
       if (
         !restartResult.initiated &&
         restartResult.reason === "no_active_recording" &&
@@ -383,7 +370,6 @@ async function handleStandaloneRecordingIntent(
         handleRecordingStart(
           msg.sessionId,
           { promptForSource: true },
-          socket,
           ctx,
         );
       }
@@ -428,7 +414,6 @@ async function handleStandaloneRecordingIntent(
       if (mapped) {
         const execResult = executeRecordingIntent(mapped, {
           conversationId: msg.sessionId,
-          socket,
           ctx,
         });
 
@@ -442,7 +427,6 @@ async function handleStandaloneRecordingIntent(
             messageText,
             execResult.responseText!,
             session,
-            socket,
             ctx,
           );
           return { handled: true, updatedMessageText: messageText };
@@ -463,7 +447,6 @@ async function handlePendingConfirmationReply(
   session: Session,
   ipcChannel: ChannelId,
   ipcInterface: InterfaceId,
-  socket: net.Socket,
   ctx: HandlerContext,
   rlog: typeof log,
 ): Promise<boolean> {
@@ -558,7 +541,7 @@ async function handlePendingConfirmationReply(
         messageText,
         msg.attachments ?? [],
       );
-      await conversationStore.addMessage(
+      await addMessage(
         msg.sessionId,
         "user",
         JSON.stringify(consumedUserMessage.content),
@@ -571,7 +554,7 @@ async function handlePendingConfirmationReply(
           ? "Decision applied."
           : "Request already resolved.");
       const consumedAssistantMessage = createAssistantMessage(replyText);
-      await conversationStore.addMessage(
+      await addMessage(
         msg.sessionId,
         "assistant",
         JSON.stringify(consumedAssistantMessage.content),
@@ -581,26 +564,26 @@ async function handlePendingConfirmationReply(
         session.messages.push(consumedUserMessage, consumedAssistantMessage);
       }
 
-      ctx.send(socket, {
+      ctx.send({
         type: "message_queued",
         sessionId: msg.sessionId,
         requestId,
         position: 0,
       });
-      ctx.send(socket, {
+      ctx.send({
         type: "message_dequeued",
         sessionId: msg.sessionId,
         requestId,
       });
 
       if (!session.isProcessing()) {
-        ctx.send(socket, {
+        ctx.send({
           type: "assistant_text_delta",
           text: replyText,
           sessionId: msg.sessionId,
         });
       }
-      ctx.send(socket, {
+      ctx.send({
         type: "message_request_complete",
         sessionId: msg.sessionId,
         requestId,
@@ -692,7 +675,6 @@ function buildDispatchUserMessage(params: {
   sendEvent: (event: ServerMessage) => void;
   ipcChannel: ChannelId;
   ipcInterface: InterfaceId;
-  socket: net.Socket;
   ctx: HandlerContext;
   rlog: typeof log;
 }): DispatchUserMessageFn {
@@ -702,7 +684,6 @@ function buildDispatchUserMessage(params: {
     sendEvent,
     ipcChannel,
     ipcInterface,
-    socket,
     ctx,
     rlog,
   } = params;
@@ -765,7 +746,6 @@ function buildDispatchUserMessage(params: {
         },
       );
       ctx.send(
-        socket,
         buildSessionErrorMessage(msg.sessionId, {
           code: "QUEUE_FULL",
           userMessage:
@@ -788,7 +768,7 @@ function buildDispatchUserMessage(params: {
           attributes: { position, source },
         },
       );
-      ctx.send(socket, {
+      ctx.send({
         type: "message_queued",
         sessionId: msg.sessionId,
         requestId: dispatchRequestId,
@@ -833,37 +813,34 @@ function buildDispatchUserMessage(params: {
           { err, source },
           "Error processing user message (session or provider failure)",
         );
-        ctx.send(socket, {
+        ctx.send({
           type: "error",
           message: `Failed to process message: ${message}`,
         });
         const classified = classifySessionError(err, { phase: "agent_loop" });
-        ctx.send(socket, buildSessionErrorMessage(msg.sessionId, classified));
+        ctx.send( buildSessionErrorMessage(msg.sessionId, classified));
       });
   };
 }
 
 export async function handleUserMessage(
   msg: UserMessage,
-  socket: net.Socket,
   ctx: HandlerContext,
 ): Promise<void> {
   const requestId = uuid();
   const rlog = log.child({ sessionId: msg.sessionId, requestId });
   try {
-    ctx.socketToSession.set(socket, msg.sessionId);
-    const session = await ctx.getOrCreateSession(msg.sessionId, socket, true);
+    const session = await ctx.getOrCreateSession(msg.sessionId);
     // Only wire the escalation handler if one isn't already set — handleTaskSubmit
     // sets a handler with the client's actual screen dimensions, and overwriting it
     // here would replace those dimensions with the daemon's defaults.
     if (!session.hasEscalationHandler()) {
-      wireEscalationHandler(session, socket, ctx);
+      wireEscalationHandler(session, ctx);
     }
 
     const ipcChannel = parseChannelId(msg.channel) ?? "vellum";
     const sendEvent = makeIpcEventSender({
       ctx,
-      socket,
       session,
       conversationId: msg.sessionId,
       sourceChannel: ipcChannel,
@@ -874,7 +851,7 @@ export async function handleUserMessage(
     session.updateClient(sendEvent, false);
     const ipcInterface = parseInterfaceId(msg.interface);
     if (!ipcInterface) {
-      ctx.send(socket, {
+      ctx.send({
         type: "error",
         message:
           "Invalid user_message: interface is required and must be valid",
@@ -897,7 +874,6 @@ export async function handleUserMessage(
       sendEvent,
       ipcChannel,
       ipcInterface,
-      socket,
       ctx,
       rlog,
     });
@@ -909,7 +885,6 @@ export async function handleUserMessage(
       handleSecretIngress(
         msg,
         messageText,
-        socket,
         ctx,
         session,
         rlog,
@@ -925,7 +900,6 @@ export async function handleUserMessage(
         msg,
         messageText,
         session,
-        socket,
         ctx,
         rlog,
       )
@@ -938,7 +912,6 @@ export async function handleUserMessage(
       msg,
       messageText,
       session,
-      socket,
       ctx,
       rlog,
     );
@@ -956,7 +929,6 @@ export async function handleUserMessage(
         session,
         ipcChannel,
         ipcInterface,
-        socket,
         ctx,
         rlog,
       )
@@ -979,11 +951,11 @@ export async function handleUserMessage(
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     rlog.error({ err }, "Error setting up user message processing");
-    ctx.send(socket, {
+    ctx.send( {
       type: "error",
       message: `Failed to process message: ${message}`,
     });
     const classified = classifySessionError(err, { phase: "handler" });
-    ctx.send(socket, buildSessionErrorMessage(msg.sessionId, classified));
+    ctx.send( buildSessionErrorMessage(msg.sessionId, classified));
   }
 }