@vellumai/assistant 0.4.43 → 0.4.45

package/src/tools/claude-code/claude-code.ts

@@ -26,7 +26,7 @@ const AUTO_APPROVE_TOOLS = new Set([
   "Bash(find *)",
 ]);
 
-// Tools that always require user approval via confirmation IPC
+// Tools that always require user approval via confirmation prompt
 const APPROVAL_REQUIRED_TOOLS = new Set([
   "Bash",
   "Edit",

package/src/tools/computer-use/definitions.ts

@@ -27,67 +27,57 @@ const reasonProperty = {
     "Brief non-technical explanation of why this tool is being called",
 };
 
-function makeClickTool(name: string, verb: string): Tool {
-  return {
-    name,
-    description: `${verb} on a UI element by its [ID] from the accessibility tree, or at raw screen coordinates as fallback.`,
-    category: "computer-use",
-    defaultRiskLevel: RiskLevel.Low,
-    executionMode: "proxy",
-
-    getDefinition(): ToolDefinition {
-      return {
-        name: this.name,
-        description: this.description,
-        input_schema: {
-          type: "object",
-          properties: {
-            element_id: {
-              type: "integer",
-              description:
-                "The [ID] number of the element from the accessibility tree (preferred)",
-            },
-            x: {
-              type: "integer",
-              description:
-                "X coordinate on screen (fallback when no element_id)",
-            },
-            y: {
-              type: "integer",
-              description:
-                "Y coordinate on screen (fallback when no element_id)",
-            },
-            reasoning: {
-              type: "string",
-              description: `Explanation of what you see and why you are ${verb.toLowerCase()}ing here`,
-            },
-            reason: reasonProperty,
-          },
-          required: ["reasoning"],
-        },
-      };
-    },
-
-    execute: proxyExecute,
-  };
-}
-
 // ---------------------------------------------------------------------------
-// Click variants
+// click (unified — click_type selects single / double / right)
 // ---------------------------------------------------------------------------
 
-export const computerUseClickTool = makeClickTool(
-  "computer_use_click",
-  "Click",
-);
-export const computerUseDoubleClickTool = makeClickTool(
-  "computer_use_double_click",
-  "Double-click",
-);
-export const computerUseRightClickTool = makeClickTool(
-  "computer_use_right_click",
-  "Right-click",
-);
+export const computerUseClickTool: Tool = {
+  name: "computer_use_click",
+  description:
+    "Click on a UI element by its [ID] from the accessibility tree, or at raw screen coordinates as fallback. Supports single click, double-click, and right-click via the click_type parameter.",
+  category: "computer-use",
+  defaultRiskLevel: RiskLevel.Low,
+  executionMode: "proxy",
+
+  getDefinition(): ToolDefinition {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: {
+        type: "object",
+        properties: {
+          click_type: {
+            type: "string",
+            enum: ["single", "double", "right"],
+            description: 'Type of click to perform (default: "single")',
+          },
+          element_id: {
+            type: "integer",
+            description:
+              "The [ID] number of the element from the accessibility tree (preferred)",
+          },
+          x: {
+            type: "integer",
+            description: "X coordinate on screen (fallback when no element_id)",
+          },
+          y: {
+            type: "integer",
+            description: "Y coordinate on screen (fallback when no element_id)",
+          },
+          reasoning: {
+            type: "string",
+            description:
+              "Explanation of what you see and why you are clicking here",
+          },
+          reason: reasonProperty,
+        },
+        required: ["reasoning"],
+      },
+    };
+  },
+
+  execute: proxyExecute,
+};
 
 // ---------------------------------------------------------------------------
 // type_text
@@ -474,8 +464,6 @@ export const computerUseRespondTool: Tool = {
 
 export const allComputerUseTools: Tool[] = [
   computerUseClickTool,
-  computerUseDoubleClickTool,
-  computerUseRightClickTool,
   computerUseTypeTextTool,
   computerUseKeyTool,
   computerUseScrollTool,

package/src/tools/document/document-tool.ts

@@ -12,7 +12,7 @@ export function executeDocumentCreate(
   const initialContent = (input.initial_content as string | undefined) || "";
   const surfaceId = `doc-${randomUUID()}`;
 
-  // Send document_editor_show IPC message to open the built-in RTE
+  // Send document_editor_show message to open the built-in RTE
   if (context.sendToClient) {
     context.sendToClient({
       type: "document_editor_show",
@@ -47,13 +47,13 @@ export function executeDocumentCreate(
     };
   }
 
-  // Fallback if no IPC client is connected
+  // Fallback if no client is connected
   return {
     content: JSON.stringify({
       surface_id: surfaceId,
       title,
       opened: false,
-      error: "No IPC client connected to open document editor",
+      error: "No client connected to open document editor",
     }),
     isError: false,
   };
@@ -67,7 +67,7 @@ export function executeDocumentUpdate(
   const content = input.content as string;
   const mode = (input.mode as string | undefined) || "append";
 
-  // Send document_editor_update IPC message to update the built-in RTE
+  // Send document_editor_update message to update the built-in RTE
   if (context.sendToClient) {
     context.sendToClient({
       type: "document_editor_update",
@@ -88,11 +88,11 @@ export function executeDocumentUpdate(
     };
   }
 
-  // Fallback if no IPC client is connected
+  // Fallback if no client is connected
   return {
     content: JSON.stringify({
       success: false,
-      error: "No IPC client connected to update document",
+      error: "No client connected to update document",
     }),
     isError: true,
   };

package/src/tools/document/editor-template.ts

@@ -39,17 +39,19 @@ export function generateEditorHTML(
       --v-text: #1D1D1F;
       --v-text-secondary: #86868B;
       --v-text-muted: #AEAEB2;
-      --v-accent: #8A5BE0;
+      --v-accent: #657D5B;
+      --v-accent-hover: #516748;
     }
     @media (prefers-color-scheme: dark) {
       :root {
-        --v-bg: #070D19;
-        --v-surface: #1E293B;
-        --v-surface-border: #334155;
-        --v-text: #F8FAFC;
-        --v-text-secondary: #94A3B8;
-        --v-text-muted: #64748B;
-        --v-accent: #8A5BE0;
+        --v-bg: #20201E;
+        --v-surface: #3A3A37;
+        --v-surface-border: #4A4A46;
+        --v-text: #F5F3EB;
+        --v-text-secondary: #A1A096;
+        --v-text-muted: #6B6B65;
+        --v-accent: #657D5B;
+        --v-accent-hover: #516748;
       }
     }
 

package/src/tools/filesystem/edit.ts

@@ -161,4 +161,5 @@ class FileEditTool implements Tool {
   }
 }
 
-registerTool(new FileEditTool());
+export const fileEditTool = new FileEditTool();
+registerTool(fileEditTool);

package/src/tools/filesystem/read.ts

@@ -1,13 +1,20 @@
+import { extname } from "node:path";
+
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import { registerTool } from "../registry.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
+import {
+  IMAGE_EXTENSIONS,
+  readImageFile,
+} from "../shared/filesystem/image-read.js";
 import { sandboxPolicy } from "../shared/filesystem/path-policy.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 class FileReadTool implements Tool {
   name = "file_read";
-  description = "Read the contents of a file";
+  description =
+    "Read the contents of a file. For image files (JPEG, PNG, GIF, WebP), returns the image for visual analysis.";
   category = "filesystem";
   defaultRiskLevel = RiskLevel.Low;
 
@@ -54,6 +61,16 @@ class FileReadTool implements Tool {
       };
     }
 
+    // For image files, delegate to the shared image reader.
+    const ext = extname(rawPath).toLowerCase();
+    if (IMAGE_EXTENSIONS.has(ext)) {
+      const pathCheck = sandboxPolicy(rawPath, context.workingDir);
+      if (!pathCheck.ok) {
+        return { content: `Error: ${pathCheck.error}`, isError: true };
+      }
+      return readImageFile(pathCheck.resolved);
+    }
+
     const ops = new FileSystemOps((path, opts) =>
       sandboxPolicy(path, context.workingDir, opts),
     );
@@ -86,4 +103,5 @@ class FileReadTool implements Tool {
   }
 }
 
-registerTool(new FileReadTool());
+export const fileReadTool = new FileReadTool();
+registerTool(fileReadTool);

package/src/tools/filesystem/write.ts

@@ -97,4 +97,5 @@ class FileWriteTool implements Tool {
   }
 }
 
-registerTool(new FileWriteTool());
+export const fileWriteTool = new FileWriteTool();
+registerTool(fileWriteTool);

package/src/tools/host-filesystem/edit.ts

@@ -48,7 +48,7 @@ class HostFileEditTool implements Tool {
 
   async execute(
     input: Record<string, unknown>,
-    _context: ToolContext,
+    context: ToolContext,
   ): Promise<ToolExecutionResult> {
     const rawPath = input.path as string;
     if (!rawPath || typeof rawPath !== "string") {
@@ -87,6 +87,22 @@ class HostFileEditTool implements Tool {
 
     const replaceAll = input.replace_all === true;
 
+    // Proxy to connected client for execution on the user's machine
+    // when a capable client is available (managed/cloud-hosted mode).
+    if (context.hostFileProxy?.isAvailable()) {
+      return context.hostFileProxy.request(
+        {
+          operation: "edit",
+          path: rawPath,
+          old_string: oldString as string,
+          new_string: newString as string,
+          replace_all: replaceAll,
+        },
+        context.sessionId,
+        context.signal,
+      );
+    }
+
     const ops = new FileSystemOps(hostPolicy);
 
     const result = ops.editFileSafe({

package/src/tools/host-filesystem/read.ts

@@ -42,7 +42,7 @@ class HostFileReadTool implements Tool {
 
   async execute(
     input: Record<string, unknown>,
-    _context: ToolContext,
+    context: ToolContext,
   ): Promise<ToolExecutionResult> {
     const rawPath = input.path as string;
     if (!rawPath || typeof rawPath !== "string") {
@@ -52,6 +52,21 @@ class HostFileReadTool implements Tool {
       };
     }
 
+    // Proxy to connected client for execution on the user's machine
+    // when a capable client is available (managed/cloud-hosted mode).
+    if (context.hostFileProxy?.isAvailable()) {
+      return context.hostFileProxy.request(
+        {
+          operation: "read",
+          path: rawPath,
+          offset: typeof input.offset === "number" ? input.offset : undefined,
+          limit: typeof input.limit === "number" ? input.limit : undefined,
+        },
+        context.sessionId,
+        context.signal,
+      );
+    }
+
     const ops = new FileSystemOps(hostPolicy);
 
     const result = ops.readFileSafe({

package/src/tools/host-filesystem/write.ts

@@ -40,7 +40,7 @@ class HostFileWriteTool implements Tool {
 
   async execute(
     input: Record<string, unknown>,
-    _context: ToolContext,
+    context: ToolContext,
   ): Promise<ToolExecutionResult> {
     const rawPath = input.path as string;
     if (!rawPath || typeof rawPath !== "string") {
@@ -58,6 +58,20 @@ class HostFileWriteTool implements Tool {
       };
     }
 
+    // Proxy to connected client for execution on the user's machine
+    // when a capable client is available (managed/cloud-hosted mode).
+    if (context.hostFileProxy?.isAvailable()) {
+      return context.hostFileProxy.request(
+        {
+          operation: "write",
+          path: rawPath,
+          content: fileContent,
+        },
+        context.sessionId,
+        context.signal,
+      );
+    }
+
     const ops = new FileSystemOps(hostPolicy);
 
     const result = ops.writeFileSafe({ path: rawPath, content: fileContent });

package/src/tools/host-terminal/host-shell.ts

@@ -101,6 +101,30 @@ class HostShellTool implements Tool {
         isError: true,
       };
     }
+    // Proxy to connected client for execution on the user's machine
+    // when a capable client is available (managed/cloud-hosted mode).
+    if (context.hostBashProxy?.isAvailable()) {
+      const { shellDefaultTimeoutSec, shellMaxTimeoutSec } =
+        getConfig().timeouts;
+      const rawSec =
+        typeof input.timeout_seconds === "number"
+          ? input.timeout_seconds
+          : shellDefaultTimeoutSec;
+      const normalizedTimeout = Math.max(
+        1,
+        Math.min(rawSec, shellMaxTimeoutSec),
+      );
+      return context.hostBashProxy.request(
+        {
+          command,
+          working_dir: rawWorkingDir as string | undefined,
+          timeout_seconds: normalizedTimeout,
+        },
+        context.sessionId,
+        context.signal,
+      );
+    }
+
     const workingDir =
       typeof rawWorkingDir === "string" ? rawWorkingDir : homedir();
 

package/src/tools/memory/definitions.ts

@@ -3,7 +3,7 @@ import type { ToolDefinition } from "../../providers/types.js";
 export const memoryRecallDefinition: ToolDefinition = {
   name: "memory_recall",
   description:
-    "Deep search across all memory sources (semantic, lexical, entity graph, recency) for specific information. Use this when you need to recall details about past conversations, decisions, preferences, project context, or any prior knowledge. Returns formatted memory context with item IDs for use with memory_update/memory_delete.",
+    "Deep search across all memory sources (semantic, lexical, entity graph, recency) for specific information. Use this when you need to recall details about past conversations, decisions, preferences, project context, or any prior knowledge. Returns formatted memory context with item IDs for use with memory_manage.",
   input_schema: {
     type: "object",
     properties: {
@@ -26,92 +26,56 @@ export const memoryRecallDefinition: ToolDefinition = {
   },
 };
 
-export const memorySaveDefinition: ToolDefinition = {
-  name: "memory_save",
-  description:
-    "Save a fact, preference, decision, or other noteworthy information to memory for future recall. Use this when the user shares something worth remembering.",
-  input_schema: {
-    type: "object",
-    properties: {
-      statement: {
-        type: "string",
-        description: "The fact or preference to remember (1-2 sentences)",
-      },
-      kind: {
-        type: "string",
-        enum: [
-          "preference",
-          "fact",
-          "decision",
-          "profile",
-          "relationship",
-          "event",
-          "opinion",
-          "instruction",
-          "style",
-          "playbook",
-          "learning",
-        ],
-        description: "Category of the memory item",
-      },
-      subject: {
-        type: "string",
-        description: "Short subject/topic label (2-8 words)",
-      },
-      reason: {
-        type: "string",
-        description:
-          "Brief non-technical explanation of what you are saving and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-      },
-    },
-    required: ["statement", "kind"],
+const memoryManageProperties = {
+  op: {
+    type: "string" as const,
+    enum: ["save", "update", "delete"],
+    description: "The operation to perform",
   },
-};
-
-export const memoryUpdateDefinition: ToolDefinition = {
-  name: "memory_update",
-  description:
-    "Update or correct an existing memory item. Use this when previously saved information needs to be changed.",
-  input_schema: {
-    type: "object",
-    properties: {
-      memory_id: {
-        type: "string",
-        description:
-          "ID of the memory item to update (from memory_recall results)",
-      },
-      statement: {
-        type: "string",
-        description: "The updated statement to replace the existing one",
-      },
-      reason: {
-        type: "string",
-        description:
-          "Brief non-technical explanation of what you are updating and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-      },
-    },
-    required: ["memory_id", "statement"],
+  memory_id: {
+    type: "string" as const,
+    description: "ID of existing memory item (required for update/delete)",
+  },
+  statement: {
+    type: "string" as const,
+    description:
+      "The fact or preference to remember (required for save/update, 1-2 sentences)",
+  },
+  kind: {
+    type: "string" as const,
+    enum: [
+      "preference",
+      "fact",
+      "decision",
+      "profile",
+      "relationship",
+      "event",
+      "opinion",
+      "instruction",
+      "style",
+      "playbook",
+      "learning",
+    ],
+    description: "Category of the memory item (required for save)",
+  },
+  subject: {
+    type: "string" as const,
+    description: "Short subject/topic label, 2-8 words (optional, save only)",
+  },
+  reason: {
+    type: "string" as const,
+    description:
+      "Brief non-technical explanation shown to the user as a status update",
   },
 };
 
-export const memoryDeleteDefinition: ToolDefinition = {
-  name: "memory_delete",
+export const memoryManageDefinition: ToolDefinition = {
+  name: "memory_manage",
   description:
-    "Delete a previously saved memory item. Use this when information is no longer relevant, was saved in error, or the user asks to forget something.",
+    "Save, update, or delete memory items. Use 'save' for new information worth remembering, 'update' to correct existing items, 'delete' to remove outdated items.",
   input_schema: {
     type: "object",
-    properties: {
-      memory_id: {
-        type: "string",
-        description:
-          "ID of the memory item to delete (from memory_recall results)",
-      },
-      reason: {
-        type: "string",
-        description:
-          "Brief non-technical explanation of what you are deleting and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-      },
-    },
-    required: ["memory_id"],
+    properties: memoryManageProperties,
+    required: ["op"],
   },
 };

package/src/tools/memory/handlers.test.ts

@@ -26,7 +26,6 @@ mock.module("../../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/tools/memory/handlers.ts

@@ -468,7 +468,7 @@ function inferSubjectFromStatement(statement: string): string {
 
 /**
  * Strip a typed ID prefix (e.g. "item:abc-123" -> "abc-123") so that IDs
- * copied from memory_recall output work in memory_update.
+ * copied from memory_recall output work in memory_manage update/delete ops.
  */
 function stripTypedIdPrefix(id: string): string {
   const match = id.match(/^(?:item|segment|summary):(.+)$/);