@vellumai/assistant 0.4.49 → 0.4.51

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

@@ -1,324 +1,9 @@
-import {
-  getAttachmentsForMessage,
-  getFilePathForAttachment,
-  setAttachmentThumbnail,
-} from "../../memory/attachments-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 {
-  ConversationSearchRequest,
-  HistoryRequest,
-  MessageContentRequest,
-  UserMessageAttachment,
-} from "../message-protocol.js";
-import { generateVideoThumbnail } from "../video-thumbnail.js";
-import {
-  type HandlerContext,
-  type HistorySurface,
-  type HistoryToolCall,
-  log,
-  type ParsedHistoryMessage,
-  renderHistoryContent,
-} from "./shared.js";
-
-/**
- * In light mode, strip heavy payloads (e.g. full HTML) from surface data
- * but preserve the fields the client needs to parse and render the surface.
- */
-function lightModeSurfaceData(s: HistorySurface): Record<string, unknown> {
-  switch (s.surfaceType) {
-    case "dynamic_page":
-      return {
-        ...(s.data.preview ? { preview: s.data.preview } : {}),
-        ...(s.data.appId ? { appId: s.data.appId } : {}),
-      };
-    case "card":
-      return {
-        ...(typeof s.data.title === "string" ? { title: s.data.title } : {}),
-        ...(typeof s.data.body === "string" ? { body: s.data.body } : {}),
-        ...(typeof s.data.template === "string"
-          ? { template: s.data.template }
-          : {}),
-        ...(s.data.templateData ? { templateData: s.data.templateData } : {}),
-      };
-    case "document_preview":
-      return {
-        ...(typeof s.data.surfaceId === "string"
-          ? { surfaceId: s.data.surfaceId }
-          : {}),
-        ...(typeof s.data.title === "string" ? { title: s.data.title } : {}),
-        ...(typeof s.data.content === "string"
-          ? { content: s.data.content }
-          : {}),
-      };
-    default:
-      // For other types (list, table, form, confirmation, etc.),
-      // preserve the full data — these are generally small.
-      return s.data;
-  }
-}
-
-export function handleHistoryRequest(
-  msg: HistoryRequest,
-  ctx: HandlerContext,
-): void {
-  // No limit means return all messages.
-  const limit = msg.limit;
-
-  // Resolve include flags: explicit flags override mode, mode provides defaults.
-  // Default mode is 'light' when no mode and no include flags are specified.
-  const isFullMode = msg.mode === "full";
-  const includeAttachments = msg.includeAttachments ?? isFullMode;
-  const includeToolImages = msg.includeToolImages ?? isFullMode;
-  const includeSurfaceData = msg.includeSurfaceData ?? isFullMode;
-
-  const { messages: dbMessages, hasMore } = getMessagesPaginated(
-    msg.sessionId,
-    limit,
-    msg.beforeTimestamp,
-    msg.beforeMessageId,
-  );
-
-  const parsed: ParsedHistoryMessage[] = dbMessages.map((m) => {
-    let text = "";
-    let toolCalls: HistoryToolCall[] = [];
-    let toolCallsBeforeText = false;
-    let textSegments: string[] = [];
-    let contentOrder: string[] = [];
-    let surfaces: HistorySurface[] = [];
-    try {
-      const content = JSON.parse(m.content);
-      const rendered = renderHistoryContent(content);
-      text = rendered.text;
-      toolCalls = rendered.toolCalls;
-      toolCallsBeforeText = rendered.toolCallsBeforeText;
-      textSegments = rendered.textSegments;
-      contentOrder = rendered.contentOrder;
-      surfaces = rendered.surfaces;
-      if (m.role === "assistant" && toolCalls.length > 0) {
-        log.info(
-          {
-            messageId: m.id,
-            toolCallCount: toolCalls.length,
-            text: truncate(text, 100, ""),
-          },
-          "History message with tool calls",
-        );
-      }
-    } catch (err) {
-      log.debug(
-        { err, messageId: m.id },
-        "Failed to parse message content as JSON, using raw text",
-      );
-      text = m.content;
-      textSegments = text ? [text] : [];
-      contentOrder = text ? ["text:0"] : [];
-      surfaces = [];
-    }
-    let subagentNotification: ParsedHistoryMessage["subagentNotification"];
-    if (m.metadata) {
-      try {
-        subagentNotification = (
-          JSON.parse(m.metadata) as {
-            subagentNotification?: ParsedHistoryMessage["subagentNotification"];
-          }
-        ).subagentNotification;
-      } catch (err) {
-        log.debug(
-          { err, messageId: m.id },
-          "Failed to parse message metadata as JSON, ignoring",
-        );
-      }
-    }
-    return {
-      id: m.id,
-      role: m.role,
-      text,
-      timestamp: m.createdAt,
-      toolCalls,
-      toolCallsBeforeText,
-      textSegments,
-      contentOrder,
-      surfaces,
-      ...(subagentNotification ? { subagentNotification } : {}),
-    };
-  });
-
-  const historyMessages = parsed.map((m) => {
-    let attachments: UserMessageAttachment[] | undefined;
-    if (m.role === "assistant" && m.id) {
-      const linked = getAttachmentsForMessage(m.id);
-      if (linked.length > 0) {
-        if (includeAttachments) {
-          // Full attachment data: same behavior as before
-          const MAX_INLINE_B64_SIZE = 512 * 1024;
-          attachments = linked.map((a) => {
-            const isFileBacked = !a.dataBase64;
-            const omit =
-              isFileBacked ||
-              (a.mimeType.startsWith("video/") &&
-                a.dataBase64.length > MAX_INLINE_B64_SIZE);
-
-            if (
-              a.mimeType.startsWith("video/") &&
-              !a.thumbnailBase64 &&
-              a.dataBase64
-            ) {
-              const attachmentId = a.id;
-              const base64 = a.dataBase64;
-              silentlyWithLog(
-                generateVideoThumbnail(base64).then((thumb) => {
-                  if (thumb) setAttachmentThumbnail(attachmentId, thumb);
-                }),
-                "video thumbnail generation",
-              );
-            }
-
-            const fp = getFilePathForAttachment(a.id);
-            return {
-              id: a.id,
-              filename: a.originalFilename,
-              mimeType: a.mimeType,
-              data: omit ? "" : a.dataBase64,
-              ...(omit ? { sizeBytes: a.sizeBytes } : {}),
-              ...(a.thumbnailBase64
-                ? { thumbnailData: a.thumbnailBase64 }
-                : {}),
-              ...(fp ? { filePath: fp } : {}),
-            };
-          });
-        } else {
-          // Light mode: metadata only, strip base64 data
-          attachments = linked.map((a) => {
-            const fp = getFilePathForAttachment(a.id);
-            return {
-              id: a.id,
-              filename: a.originalFilename,
-              mimeType: a.mimeType,
-              data: "",
-              sizeBytes: a.sizeBytes,
-              ...(a.thumbnailBase64
-                ? { thumbnailData: a.thumbnailBase64 }
-                : {}),
-              ...(fp ? { filePath: fp } : {}),
-            };
-          });
-        }
-      }
-    }
-
-    // In light mode, strip imageData from tool calls
-    const filteredToolCalls =
-      m.toolCalls.length > 0
-        ? includeToolImages
-          ? m.toolCalls
-          : m.toolCalls.map((tc) => {
-              if (tc.imageData) {
-                const { imageData: _, ...rest } = tc;
-                return rest;
-              }
-              return tc;
-            })
-        : m.toolCalls;
-
-    // In light mode, strip heavy payloads but keep essential fields so
-    // the client can still parse and render surfaces (e.g. card title/body,
-    // dynamic_page preview, document_preview metadata).
-    const filteredSurfaces =
-      m.surfaces.length > 0
-        ? includeSurfaceData
-          ? m.surfaces
-          : m.surfaces.map((s) => ({
-              surfaceId: s.surfaceId,
-              surfaceType: s.surfaceType,
-              title: s.title,
-              data: lightModeSurfaceData(s),
-              ...(s.actions ? { actions: s.actions } : {}),
-              ...(s.display ? { display: s.display } : {}),
-            }))
-        : m.surfaces;
-
-    // Apply text truncation when maxTextChars is set
-    let wasTruncated = false;
-    let textWasTruncated = false;
-    let text = m.text;
-    if (msg.maxTextChars !== undefined && text.length > msg.maxTextChars) {
-      text = text.slice(0, msg.maxTextChars) + " \u2026 [truncated]";
-      wasTruncated = true;
-      textWasTruncated = true;
-    }
-
-    // Apply tool result truncation when maxToolResultChars is set
-    const truncatedToolCalls =
-      msg.maxToolResultChars !== undefined && filteredToolCalls.length > 0
-        ? filteredToolCalls.map((tc) => {
-            if (
-              tc.result !== undefined &&
-              tc.result.length > msg.maxToolResultChars!
-            ) {
-              wasTruncated = true;
-              return {
-                ...tc,
-                result:
-                  tc.result.slice(0, msg.maxToolResultChars!) +
-                  " \u2026 [truncated]",
-              };
-            }
-            return tc;
-          })
-        : filteredToolCalls;
-
-    return {
-      ...(m.id ? { id: m.id } : {}),
-      role: m.role,
-      text,
-      timestamp: m.timestamp,
-      ...(truncatedToolCalls.length > 0
-        ? {
-            toolCalls: truncatedToolCalls,
-            toolCallsBeforeText: m.toolCallsBeforeText,
-          }
-        : {}),
-      ...(attachments ? { attachments } : {}),
-      ...(!textWasTruncated && m.textSegments.length > 0
-        ? { textSegments: m.textSegments }
-        : {}),
-      ...(!textWasTruncated && m.contentOrder.length > 0
-        ? { contentOrder: m.contentOrder }
-        : {}),
-      ...(filteredSurfaces.length > 0 ? { surfaces: filteredSurfaces } : {}),
-      ...(m.subagentNotification
-        ? { subagentNotification: m.subagentNotification }
-        : {}),
-      ...(wasTruncated ? { wasTruncated: true } : {}),
-    };
-  });
-
-  const oldestTimestamp =
-    historyMessages.length > 0 ? historyMessages[0].timestamp : undefined;
-  // Provide the oldest message ID as a tie-breaker cursor so clients can
-  // paginate without skipping same-millisecond messages at page boundaries.
-  const oldestMessageId =
-    historyMessages.length > 0 ? historyMessages[0].id : undefined;
-
-  ctx.send({
-    type: "history_response",
-    sessionId: msg.sessionId,
-    messages: historyMessages,
-    hasMore,
-    ...(oldestTimestamp !== undefined ? { oldestTimestamp } : {}),
-    ...(oldestMessageId ? { oldestMessageId } : {}),
-  });
-
-  // Surfaces are now included directly in the history_response message (in the surfaces array),
-  // so we no longer emit separate ui_surface_show messages during history loading.
-}
+import { renderHistoryContent } from "./shared.js";
 
 // ---------------------------------------------------------------------------
 // Shared business logic (transport-agnostic)
@@ -400,45 +85,3 @@ export function getMessageContent(
     ...(toolCalls ? { toolCalls } : {}),
   };
 }
-
-// ---------------------------------------------------------------------------
-// HTTP 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,
-    ...(result.text !== undefined ? { text: result.text } : {}),
-    ...(result.toolCalls ? { toolCalls: result.toolCalls } : {}),
-  });
-}

package/src/daemon/handlers/sessions.ts

@@ -421,8 +421,11 @@ export async function handleSessionCreate(
         pendingInteractions.resolve(requestId);
       });
       session.setHostFileProxy(fileProxy);
-      const cuProxy = new HostCuProxy(sendEvent);
+      const cuProxy = new HostCuProxy(sendEvent, (requestId) => {
+        pendingInteractions.resolve(requestId);
+      });
       session.setHostCuProxy(cuProxy);
+      session.addPreactivatedSkillId("computer-use");
     }
     session.updateClient(sendEvent, false);
     session
@@ -575,23 +578,24 @@ export function handleCancel(msg: CancelRequest, ctx: HandlerContext): void {
 }
 
 /**
- * Undo the last message in a session. Returns the removed count, or null if session not found.
+ * Undo the last message in a session. Returns the removed count, or null if
+ * the conversation does not exist. Restores evicted sessions from the database.
  */
-export function undoLastMessage(
+export async function undoLastMessage(
   sessionId: string,
   ctx: HandlerContext,
-): { removedCount: number } | null {
-  const session = ctx.sessions.get(sessionId);
-  if (!session) {
+): Promise<{ removedCount: number } | null> {
+  if (!getConversation(sessionId)) {
     return null;
   }
+  const session = await ctx.getOrCreateSession(sessionId);
   ctx.touchSession(sessionId);
   const removedCount = session.undo();
   return { removedCount };
 }
 
-export function handleUndo(msg: UndoRequest, ctx: HandlerContext): void {
-  const result = undoLastMessage(msg.sessionId, ctx);
+export async function handleUndo(msg: UndoRequest, ctx: HandlerContext): Promise<void> {
+  const result = await undoLastMessage(msg.sessionId, ctx);
   if (!result) {
     ctx.send({ type: "error", message: "No active session" });
     return;
@@ -606,17 +610,18 @@ export function handleUndo(msg: UndoRequest, ctx: HandlerContext): void {
 /**
  * Regenerate the last assistant response for a session. The caller provides
  * a `sendEvent` callback for delivering streaming events via HTTP/SSE.
- * Returns null if the session is not found. Throws on regeneration errors.
+ * Returns null if the conversation does not exist. Restores evicted sessions
+ * from the database when needed. Throws on regeneration errors.
  */
 export async function regenerateResponse(
   sessionId: string,
   ctx: HandlerContext,
   sendEvent: (event: ServerMessage) => void,
 ): Promise<{ requestId: string } | null> {
-  const session = ctx.sessions.get(sessionId);
-  if (!session) {
+  if (!getConversation(sessionId)) {
     return null;
   }
+  const session = await ctx.getOrCreateSession(sessionId);
   ctx.touchSession(sessionId);
   session.updateClient(sendEvent, false);
   const requestId = uuid();
@@ -647,11 +652,11 @@ export async function handleRegenerate(
   msg: RegenerateRequest,
   ctx: HandlerContext,
 ): Promise<void> {
-  const session = ctx.sessions.get(msg.sessionId);
-  if (!session) {
+  if (!getConversation(msg.sessionId)) {
     ctx.send({ type: "error", message: "No active session" });
     return;
   }
+  const session = await ctx.getOrCreateSession(msg.sessionId);
 
   const regenerateChannel =
     parseChannelId(session.getTurnChannelContext()?.assistantMessageChannel) ??

package/src/daemon/handlers/shared.ts

@@ -176,22 +176,6 @@ function clampAttachmentText(text: string): string {
   return `${text.slice(0, HISTORY_ATTACHMENT_TEXT_LIMIT)}<truncated />`;
 }
 
-function renderImageBlockForHistory(block: Record<string, unknown>): string {
-  const source = isRecord(block.source) ? block.source : null;
-  const mediaType =
-    source && typeof source.media_type === "string"
-      ? source.media_type
-      : "image/*";
-  const sizeBytes =
-    source && typeof source.data === "string"
-      ? estimateBase64Bytes(source.data)
-      : 0;
-  if (sizeBytes <= 0) {
-    return `[Image attachment] ${mediaType}`;
-  }
-  return `[Image attachment] ${mediaType}, ${formatBytes(sizeBytes)}`;
-}
-
 function renderFileBlockForHistory(block: Record<string, unknown>): string {
   const source = isRecord(block.source) ? block.source : null;
   const mediaType =
@@ -328,7 +312,9 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
       continue;
     }
     if (block.type === "image") {
-      attachmentParts.push(renderImageBlockForHistory(block));
+      // Image data is sent as a separate attachment — skip the placeholder
+      // text so the client doesn't render both "[Image attachment]" and the
+      // actual image thumbnail.
       continue;
     }
     if (block.type === "tool_use") {

package/src/daemon/handlers/skills.ts

@@ -250,12 +250,20 @@ export interface SkillListItem {
   provenance: SkillProvenance;
 }
 
+/** Sorting rank for provenance-based ordering: first-party first, local last. */
+function provenanceSortRank(p: SkillProvenance): number {
+  if (p.kind === "first-party") return 0;
+  if (p.kind === "third-party" && p.provider) return 1;
+  if (p.kind === "third-party") return 2;
+  return 3; // local
+}
+
 export function listSkills(_ctx: SkillOperationContext): SkillListItem[] {
   const config = getConfig();
   const catalog = loadSkillCatalog();
   const resolved = resolveSkillStates(catalog, config);
 
-  return resolved.map((r) => ({
+  const items = resolved.map((r) => ({
     id: r.summary.id,
     name: r.summary.displayName,
     description: r.summary.description,
@@ -272,6 +280,17 @@ export function listSkills(_ctx: SkillOperationContext): SkillListItem[] {
     userInvocable: r.summary.userInvocable,
     provenance: resolveProvenance(r.summary),
   }));
+
+  // Sort: first-party > third-party with provider > third-party without > local,
+  // alphabetical by name within each tier.
+  items.sort((a, b) => {
+    const rankDiff =
+      provenanceSortRank(a.provenance) - provenanceSortRank(b.provenance);
+    if (rankDiff !== 0) return rankDiff;
+    return a.name.localeCompare(b.name);
+  });
+
+  return items;
 }
 
 export function enableSkill(

package/src/daemon/history-repair.ts

@@ -1,6 +1,7 @@
 import type {
   ContentBlock,
   Message,
+  ServerToolUseContent,
   ToolResultContent,
   ToolUseContent,
 } from "../providers/types.js";
@@ -20,6 +21,11 @@ export interface RepairResult {
 const SYNTHETIC_RESULT =
   "<synthesized_result>tool result missing from history</synthesized_result>";
 
+const SYNTHETIC_WEB_SEARCH_ERROR = {
+  type: "web_search_tool_result_error",
+  error_code: "unavailable",
+};
+
 export function repairHistory(messages: Message[]): RepairResult {
   const stats: RepairStats = {
     assistantToolResultsMigrated: 0,
@@ -45,12 +51,15 @@ export function repairHistory(messages: Message[]): RepairResult {
         recoveredResults = new Map();
       }
 
-      // Strip tool_result blocks from assistant messages, preserving them
-      // so they can be migrated to the correct user message position
+      // Strip client-side tool_result blocks from assistant messages,
+      // preserving them so they can be migrated to the correct user message.
+      // Server-side tools (server_tool_use / web_search_tool_result) are
+      // self-paired within the assistant message and must NOT be separated.
       const cleanedContent: ContentBlock[] = [];
       const newRecovered = new Map<string, ToolResultContent>();
       for (const block of msg.content) {
         if (block.type === "tool_result") {
+          // guard:allow-tool-result-only — only client-side tool_result belongs in recovered; web_search_tool_result stays in the assistant message
           const tr = block as ToolResultContent;
           newRecovered.set(tr.tool_use_id, tr);
           stats.assistantToolResultsMigrated++;
@@ -59,9 +68,34 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
+      // Ensure every server_tool_use has a paired web_search_tool_result
+      // in the same assistant message (handles interrupted streams)
+      const serverToolIds = new Set(
+        cleanedContent
+          .filter(
+            (b): b is ServerToolUseContent => b.type === "server_tool_use",
+          )
+          .map((b) => b.id),
+      );
+      const matchedServerIds = new Set(
+        cleanedContent
+          .filter((b) => b.type === "web_search_tool_result")
+          .map((b) => (b as { tool_use_id: string }).tool_use_id),
+      );
+      for (const id of serverToolIds) {
+        if (!matchedServerIds.has(id)) {
+          cleanedContent.push({
+            type: "web_search_tool_result",
+            tool_use_id: id,
+            content: SYNTHETIC_WEB_SEARCH_ERROR,
+          });
+          stats.missingToolResultsInserted++;
+        }
+      }
+
       result.push({ role: "assistant", content: cleanedContent });
 
-      // Collect tool_use IDs from this assistant message
+      // Only track client-side tool_use IDs as pending (not server_tool_use)
       pendingToolUseIds = new Set(
         cleanedContent
           .filter((b): b is ToolUseContent => b.type === "tool_use")
@@ -76,14 +110,28 @@ export function repairHistory(messages: Message[]): RepairResult {
 
         for (const block of msg.content) {
           if (block.type === "tool_result") {
+            // guard:allow-tool-result-only — matches client-side tool_use; web_search_tool_result is handled separately below
             const tr = block as ToolResultContent;
             if (pendingToolUseIds.has(tr.tool_use_id)) {
               matchedIds.add(tr.tool_use_id);
               newContent.push(block);
             } else {
               stats.orphanToolResultsDowngraded++;
-              newContent.push(downgradeToolResult(tr));
+              newContent.push(downgradeResult(tr));
             }
+          } else if (block.type === "web_search_tool_result") {
+            // web_search_tool_result in a user message is orphaned — server-side
+            // results belong in the assistant message, not here
+            stats.orphanToolResultsDowngraded++;
+            newContent.push(
+              downgradeResult(
+                block as {
+                  type: "web_search_tool_result";
+                  tool_use_id: string;
+                  content: unknown;
+                },
+              ),
+            );
           } else {
             newContent.push(block);
           }
@@ -112,11 +160,21 @@ export function repairHistory(messages: Message[]): RepairResult {
         pendingToolUseIds = new Set();
         recoveredResults = new Map();
       } else {
-        // No pending tool_use — any tool_result here is orphaned
+        // No pending tool_use — any tool_result/web_search_tool_result here is orphaned
         const newContent: ContentBlock[] = msg.content.map((block) => {
           if (block.type === "tool_result") {
             stats.orphanToolResultsDowngraded++;
-            return downgradeToolResult(block as ToolResultContent);
+            return downgradeResult(block as ToolResultContent);
+          }
+          if (block.type === "web_search_tool_result") {
+            stats.orphanToolResultsDowngraded++;
+            return downgradeResult(
+              block as {
+                type: "web_search_tool_result";
+                tool_use_id: string;
+                content: unknown;
+              },
+            );
           }
           return block;
         });
@@ -207,9 +265,15 @@ export function deepRepairHistory(messages: Message[]): RepairResult {
   return repairHistory(merged);
 }
 
-function downgradeToolResult(tr: ToolResultContent): ContentBlock {
+function downgradeResult(tr: {
+  type: string;
+  tool_use_id: string;
+  content?: unknown;
+}): ContentBlock {
+  const content =
+    tr.type === "tool_result" ? tr.content : "[web search result]"; // guard:allow-tool-result-only — distinguishes content format between the two types
   return {
     type: "text",
-    text: `[orphaned tool_result for ${tr.tool_use_id}]: ${tr.content}`,
+    text: `[orphaned ${tr.type} for ${tr.tool_use_id}]: ${content}`,
   };
 }