@vellumai/assistant 0.5.16 → 0.6.1

package/src/tools/shared/filesystem/image-read.ts

@@ -1,8 +1,6 @@
-import { execFileSync } from "node:child_process";
-import { readFileSync, statSync, unlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { readFileSync, statSync } from "node:fs";
 
+import { optimizeImageForTransport } from "../../../agent/image-optimize.js";
 import type { ImageContent } from "../../../providers/types.js";
 import type { ToolExecutionResult } from "../../types.js";
 
@@ -17,12 +15,6 @@ export const IMAGE_EXTENSIONS = new Set([
 const MAX_SIZE_BYTES = 20 * 1024 * 1024; // 20 MB — LLM API transport limit (post-optimization)
 const MAX_SOURCE_SIZE_BYTES = 100 * 1024 * 1024; // 100 MB — pre-optimization guard
 
-// Images above this threshold get auto-optimized via sips (macOS) to avoid
-// sending multi-MB base64 payloads to the LLM API.
-const OPTIMIZE_THRESHOLD_BYTES = 1 * 1024 * 1024; // 1 MB
-const OPTIMIZE_MAX_DIMENSION = 1568; // Anthropic's recommended max
-const OPTIMIZE_JPEG_QUALITY = 80;
-
 /**
  * Detect the actual image format from the first bytes of the buffer.
  * Returns the MIME type, or null if unrecognised.
@@ -69,36 +61,6 @@ function detectMediaType(buf: Buffer): string | null {
   return null;
 }
 
-/**
- * Use macOS `sips` to resize and convert an image to JPEG.
- * Returns the path to the optimized temp file, or null if sips is unavailable.
- */
-function optimizeWithSips(srcPath: string): string | null {
-  const tmpPath = join(tmpdir(), `vellum-view-image-${Date.now()}.jpg`);
-  try {
-    execFileSync(
-      "sips",
-      [
-        "--resampleHeightWidthMax",
-        String(OPTIMIZE_MAX_DIMENSION),
-        "-s",
-        "format",
-        "jpeg",
-        "-s",
-        "formatOptions",
-        String(OPTIMIZE_JPEG_QUALITY),
-        srcPath,
-        "--out",
-        tmpPath,
-      ],
-      { stdio: "pipe", timeout: 15_000 },
-    );
-    return tmpPath;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Read an image file from disk, optionally optimize it, and return a
  * ToolExecutionResult with base64-encoded image content blocks.
@@ -130,51 +92,11 @@ export function readImageFile(resolvedPath: string): ToolExecutionResult {
   }
 
   let buffer: Buffer;
-  let optimized = false;
-  let tmpPath: string | null = null;
-
   try {
-    if (stat.size > OPTIMIZE_THRESHOLD_BYTES) {
-      tmpPath = optimizeWithSips(resolvedPath);
-      if (tmpPath) {
-        buffer = readFileSync(tmpPath) as Buffer;
-        optimized = true;
-      } else {
-        // sips unavailable — fast-fail if original file exceeds the transport limit
-        if (stat.size > MAX_SIZE_BYTES) {
-          const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
-          return {
-            content: `Error: image too large (${sizeMB} MB). Maximum is 20 MB. Image optimization (sips) is unavailable on this platform.`,
-            isError: true,
-          };
-        }
-        buffer = readFileSync(resolvedPath) as Buffer;
-      }
-    } else {
-      buffer = readFileSync(resolvedPath) as Buffer;
-    }
+    buffer = readFileSync(resolvedPath) as Buffer;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { content: `Error reading file: ${msg}`, isError: true };
-  } finally {
-    if (tmpPath) {
-      try {
-        unlinkSync(tmpPath);
-      } catch {
-        /* ignore cleanup errors */
-      }
-    }
-  }
-
-  if (buffer.length > MAX_SIZE_BYTES) {
-    const sizeMB = (buffer.length / (1024 * 1024)).toFixed(1);
-    const msg = optimized
-      ? `Error: image too large after optimization (${sizeMB} MB). Maximum is 20 MB.`
-      : `Error: image too large (${sizeMB} MB). Maximum is 20 MB.`;
-    return {
-      content: msg,
-      isError: true,
-    };
   }
 
   // Detect actual format from magic bytes - never trust the file extension
@@ -187,25 +109,40 @@ export function readImageFile(resolvedPath: string): ToolExecutionResult {
     };
   }
 
-  const base64Data = buffer.toString("base64");
+  // Optimize before size-checking — oversized images may compress under the limit.
+  const rawBase64 = buffer.toString("base64");
+  const { data: base64Data, mediaType: finalType } =
+    optimizeImageForTransport(rawBase64, detectedType);
+  const optimized = base64Data !== rawBase64;
+
+  const optimizedBytes = optimized
+    ? Math.ceil((base64Data.length * 3) / 4)
+    : buffer.length;
+  if (optimizedBytes > MAX_SIZE_BYTES) {
+    const sizeMB = (optimizedBytes / (1024 * 1024)).toFixed(1);
+    return {
+      content: `Error: image too large (${sizeMB} MB). Maximum is 20 MB even after optimization.`,
+      isError: true,
+    };
+  }
 
   const imageBlock: ImageContent = {
     type: "image" as const,
     source: {
       type: "base64" as const,
-      media_type: detectedType,
+      media_type: finalType,
       data: base64Data,
     },
   };
 
   const sizeSuffix = optimized
     ? ` (optimized from ${(stat.size / 1024).toFixed(0)} KB to ${(
-        buffer.length / 1024
+        optimizedBytes / 1024
       ).toFixed(0)} KB)`
     : "";
 
   return {
-    content: `Image loaded: ${resolvedPath} (${buffer.length} bytes, ${detectedType})${sizeSuffix}`,
+    content: `Image loaded: ${resolvedPath} (${optimizedBytes} bytes, ${finalType})${sizeSuffix}`,
     isError: false,
     contentBlocks: [imageBlock],
   };

package/src/tools/shared/filesystem/types.ts

@@ -78,3 +78,20 @@ export interface EditOutput {
 export type EditResult =
   | { ok: true; value: EditOutput }
   | { ok: false; error: FsError };
+
+// ---------------------------------------------------------------------------
+// List
+// ---------------------------------------------------------------------------
+
+export interface ListInput {
+  path: string;
+  glob?: string;
+}
+
+export interface ListOutput {
+  listing: string;
+}
+
+export type ListResult =
+  | { ok: true; value: ListOutput }
+  | { ok: false; error: FsError };

package/src/tools/shared/shell-output.ts

@@ -1,4 +1,24 @@
-export const MAX_OUTPUT_LENGTH = 50_000;
+import { randomUUID } from "node:crypto";
+import { unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export const MAX_OUTPUT_LENGTH = 20_000;
+
+/** Tracks temp files created for truncated shell output so they can be cleaned up on shutdown. */
+const trackedTempFiles = new Set<string>();
+
+/** Remove all tracked truncated-output temp files. Safe to call multiple times. */
+export function cleanupShellOutputTempFiles(): void {
+  for (const filePath of trackedTempFiles) {
+    try {
+      unlinkSync(filePath);
+    } catch {
+      // File may already be gone — ignore.
+    }
+  }
+  trackedTempFiles.clear();
+}
 
 export interface ShellOutputResult {
   content: string;
@@ -33,7 +53,16 @@ export function formatShellOutput(
   }
 
   if (output.length > MAX_OUTPUT_LENGTH) {
-    const msg = '<output_truncated limit="50K" />';
+    let fullOutputPath: string | undefined;
+    try {
+      fullOutputPath = join(tmpdir(), `vellum-shell-output-${randomUUID()}.txt`);
+      writeFileSync(fullOutputPath, output, { encoding: "utf-8", mode: 0o600 });
+      trackedTempFiles.add(fullOutputPath);
+    } catch {
+      fullOutputPath = undefined;
+    }
+    const fileAttr = fullOutputPath ? ` file="${fullOutputPath}"` : "";
+    const msg = `<output_truncated limit="20K"${fileAttr} />`;
     output = output.slice(0, MAX_OUTPUT_LENGTH) + `\n${msg}`;
     statusParts.push(msg);
   }

package/src/tools/subagent/abort.ts

@@ -1,13 +1,23 @@
 import { getSubagentManager } from "../../subagent/index.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
+import { resolveSubagentId } from "./resolve.js";
 
 export async function executeSubagentAbort(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const subagentId = input.subagent_id as string;
+  const subagentId = resolveSubagentId(input, context);
+  if (!subagentId && input.label) {
+    return {
+      content: `No subagent found with label "${input.label as string}".`,
+      isError: true,
+    };
+  }
   if (!subagentId) {
-    return { content: '"subagent_id" is required.', isError: true };
+    return {
+      content: '"subagent_id" or "label" is required.',
+      isError: true,
+    };
   }
 
   const manager = getSubagentManager();

package/src/tools/subagent/message.ts

@@ -1,16 +1,23 @@
 import { getSubagentManager } from "../../subagent/index.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
+import { resolveSubagentId } from "./resolve.js";
 
 export async function executeSubagentMessage(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const subagentId = input.subagent_id as string;
+  const subagentId = resolveSubagentId(input, context);
   const content = input.content as string;
 
+  if (!subagentId && input.label) {
+    return {
+      content: `No subagent found with label "${input.label as string}".`,
+      isError: true,
+    };
+  }
   if (!subagentId || !content) {
     return {
-      content: 'Both "subagent_id" and "content" are required.',
+      content: '"subagent_id" or "label", and "content" are required.',
       isError: true,
     };
   }

package/src/tools/subagent/notify-parent.ts

@@ -0,0 +1,79 @@
+import { RiskLevel } from "../../permissions/types.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import { getSubagentManager } from "../../subagent/index.js";
+import { registerTool } from "../registry.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+
+export async function executeSubagentNotifyParent(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const message = input.message as string;
+  const urgency = (input.urgency as string) || "info";
+
+  if (!message) {
+    return { content: '"message" is required.', isError: true };
+  }
+
+  const manager = getSubagentManager();
+  const sent = manager.notifyParent(context.conversationId, message, urgency);
+
+  if (!sent) {
+    return {
+      content:
+        "Could not notify parent. This tool is only available to subagents.",
+      isError: true,
+    };
+  }
+
+  return {
+    content: JSON.stringify({ sent: true, urgency }),
+    isError: false,
+  };
+}
+
+class NotifyParentTool implements Tool {
+  name = "notify_parent";
+  description =
+    "Send a notification to the parent conversation. Use this for important findings, when you're blocked, or when you have preliminary results the parent should know about. Do not overuse — notify for significant findings, not after every tool call.";
+  category = "orchestration";
+  defaultRiskLevel = RiskLevel.Low;
+
+  getDefinition(): ToolDefinition {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: {
+        type: "object",
+        properties: {
+          message: {
+            type: "string",
+            description: "The notification content for the parent.",
+          },
+          urgency: {
+            type: "string",
+            enum: ["info", "important", "blocked"],
+            description:
+              "'info' for progress updates, 'important' for key findings, 'blocked' when you need guidance.",
+          },
+          activity: {
+            type: "string",
+            description:
+              "Brief non-technical explanation of what you are doing and why, shown to the user as a status update.",
+          },
+        },
+        required: ["message", "activity"],
+      },
+    };
+  }
+
+  async execute(
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    return executeSubagentNotifyParent(input, context);
+  }
+}
+
+export const notifyParentTool = new NotifyParentTool();
+registerTool(notifyParentTool);

package/src/tools/subagent/read.ts

@@ -1,14 +1,24 @@
 import { getMessages } from "../../memory/conversation-crud.js";
 import { getSubagentManager, TERMINAL_STATUSES } from "../../subagent/index.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
+import { resolveSubagentId } from "./resolve.js";
 
 export async function executeSubagentRead(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const subagentId = input.subagent_id as string;
+  const subagentId = resolveSubagentId(input, context);
+  if (!subagentId && input.label) {
+    return {
+      content: `No subagent found with label "${input.label as string}".`,
+      isError: true,
+    };
+  }
   if (!subagentId) {
-    return { content: '"subagent_id" is required.', isError: true };
+    return {
+      content: '"subagent_id" or "label" is required.',
+      isError: true,
+    };
   }
 
   const manager = getSubagentManager();
@@ -45,32 +55,43 @@ export async function executeSubagentRead(
   }
 
   // Extract assistant messages only - that's the subagent's output.
-  const output: string[] = [];
+  // Group text blocks by message so last_n slices messages, not blocks.
+  const messageTexts: string[] = [];
   for (const msg of dbMessages) {
     if (msg.role !== "assistant") continue;
+    const blocks: string[] = [];
     try {
       const content = JSON.parse(msg.content);
       if (Array.isArray(content)) {
         for (const block of content) {
           if (block.type === "text" && typeof block.text === "string") {
-            output.push(block.text);
+            blocks.push(block.text);
           }
         }
       } else if (typeof content === "string") {
-        output.push(content);
+        blocks.push(content);
       }
     } catch {
       // Content might be plain text.
-      output.push(msg.content);
+      blocks.push(msg.content);
+    }
+    if (blocks.length > 0) {
+      messageTexts.push(blocks.join("\n\n"));
     }
   }
 
-  if (output.length === 0) {
+  if (messageTexts.length === 0) {
     return { content: "Subagent produced no text output.", isError: false };
   }
 
+  const lastN =
+    typeof input.last_n === "number" && input.last_n > 0
+      ? input.last_n
+      : undefined;
+  const sliced = lastN ? messageTexts.slice(-lastN) : messageTexts;
+
   return {
-    content: output.join("\n\n"),
+    content: sliced.join("\n\n"),
     isError: false,
   };
 }

package/src/tools/subagent/resolve.ts

@@ -0,0 +1,21 @@
+import { getSubagentManager } from "../../subagent/index.js";
+import type { ToolContext } from "../types.js";
+
+/**
+ * Resolve a subagent ID from tool input.
+ * Accepts either `subagent_id` (direct UUID) or `label` (case-insensitive lookup).
+ */
+export function resolveSubagentId(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): string | undefined {
+  if (input.subagent_id) return input.subagent_id as string;
+  if (input.label) {
+    const state = getSubagentManager().getByLabel(
+      input.label as string,
+      context.conversationId,
+    );
+    return state?.config.id;
+  }
+  return undefined;
+}

package/src/tools/subagent/spawn.ts

@@ -9,6 +9,7 @@ export async function executeSubagentSpawn(
   const objective = input.objective as string;
   const extraContext = input.context as string | undefined;
   const sendResultToUser = input.send_result_to_user !== false;
+  const role = (input.role as string | undefined) ?? undefined;
 
   if (!label || !objective) {
     return {
@@ -36,6 +37,7 @@ export async function executeSubagentSpawn(
         objective,
         context: extraContext,
         sendResultToUser,
+        ...(role ? { role: role as import("../../subagent/types.js").SubagentRole } : {}),
       },
       sendToClient as (msg: unknown) => void,
     );

package/src/tools/subagent/status.ts

@@ -1,13 +1,23 @@
 import { getSubagentManager } from "../../subagent/index.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
+import { resolveSubagentId } from "./resolve.js";
 
 export async function executeSubagentStatus(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const subagentId = input.subagent_id as string | undefined;
+  const subagentId = resolveSubagentId(input, context);
   const manager = getSubagentManager();
 
+  // If a label was provided but didn't resolve, that's an error — don't fall
+  // through to the "list all" path.
+  if (!subagentId && input.label) {
+    return {
+      content: `No subagent found with label "${input.label as string}".`,
+      isError: true,
+    };
+  }
+
   if (subagentId) {
     const state = manager.getState(subagentId);
     if (

package/src/tools/system/avatar-generator.ts

@@ -1,17 +1,17 @@
 import { randomUUID } from "node:crypto";
 import { mkdirSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 
 import { generateAvatar } from "../../media/avatar-router.js";
 import { mapGeminiError } from "../../media/gemini-image-service.js";
 import { getLogger } from "../../util/logger.js";
-import { getWorkspaceDir } from "../../util/platform.js";
+import { getAvatarImagePath } from "../../util/platform.js";
 
 const log = getLogger("avatar-generator");
 
 /** Canonical path where the custom avatar PNG is stored. */
 function getAvatarPath(): string {
-  return join(getWorkspaceDir(), "data", "avatar", "avatar-image.png");
+  return getAvatarImagePath();
 }
 
 export interface AvatarGenerationResult {

package/src/tools/system/register.ts

@@ -0,0 +1,23 @@
+/**
+ * Registers feature-flag-gated system tools with the daemon's tool registry.
+ *
+ * Called once at daemon startup via initializeTools(). Tools that are always
+ * registered (e.g. request_system_permission) are handled via the tool
+ * manifest's explicit tools list; this module handles conditional registration.
+ */
+
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import { getConfig } from "../../config/loader.js";
+import { registerTool } from "../registry.js";
+import { setPermissionModeTool } from "./set-permission-mode.js";
+
+export function registerSystemTools(): void {
+  try {
+    const config = getConfig();
+    if (isAssistantFeatureFlagEnabled("permission-controls-v2", config)) {
+      registerTool(setPermissionModeTool);
+    }
+  } catch {
+    // Config not yet loaded (e.g. during test setup) — permission mode tool stays off.
+  }
+}

package/src/tools/system/set-permission-mode.ts

@@ -0,0 +1,103 @@
+/**
+ * System tool: set_permission_mode
+ *
+ * Allows the LLM to deterministically switch permission mode axes via the
+ * PermissionModeStore rather than relying on model-generated text.
+ *
+ * This tool is always available (no permission check required) when the
+ * `permission-controls-v2` feature flag is enabled — it IS the permission
+ * mechanism.
+ */
+
+import {
+  getMode,
+  setAskBeforeActing,
+  setHostAccess,
+} from "../../permissions/permission-mode-store.js";
+import { RiskLevel } from "../../permissions/types.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+
+class SetPermissionModeTool implements Tool {
+  name = "set_permission_mode";
+  description =
+    "Change the assistant's permission mode. Supports partial updates — " +
+    "only the provided fields are changed. Use this to toggle whether the " +
+    "assistant asks before acting or whether host access is enabled.";
+  category = "system";
+  defaultRiskLevel = RiskLevel.Low;
+
+  getDefinition(): ToolDefinition {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: {
+        type: "object",
+        properties: {
+          askBeforeActing: {
+            type: "boolean",
+            description:
+              "When true, the assistant checks in with the user before taking actions.",
+          },
+          hostAccess: {
+            type: "boolean",
+            description:
+              "When true, the assistant can execute commands on the host machine without prompting.",
+          },
+        },
+      },
+    };
+  }
+
+  async execute(
+    input: Record<string, unknown>,
+    _context: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    const { askBeforeActing, hostAccess } = input;
+
+    // Validate that at least one field is provided
+    if (askBeforeActing === undefined && hostAccess === undefined) {
+      return {
+        content:
+          "Error: at least one of askBeforeActing or hostAccess must be provided.",
+        isError: true,
+      };
+    }
+
+    // Validate types of provided fields
+    if (askBeforeActing !== undefined && typeof askBeforeActing !== "boolean") {
+      return {
+        content: `Error: askBeforeActing must be a boolean, got ${typeof askBeforeActing}.`,
+        isError: true,
+      };
+    }
+    if (hostAccess !== undefined && typeof hostAccess !== "boolean") {
+      return {
+        content: `Error: hostAccess must be a boolean, got ${typeof hostAccess}.`,
+        isError: true,
+      };
+    }
+
+    // Apply changes for provided fields
+    if (typeof askBeforeActing === "boolean") {
+      setAskBeforeActing(askBeforeActing);
+    }
+
+    if (typeof hostAccess === "boolean") {
+      setHostAccess(hostAccess);
+    }
+
+    // Return confirmation with the new state
+    const mode = getMode();
+    return {
+      content: [
+        "Permission mode updated.",
+        `  askBeforeActing: ${mode.askBeforeActing}`,
+        `  hostAccess: ${mode.hostAccess}`,
+      ].join("\n"),
+      isError: false,
+    };
+  }
+}
+
+export const setPermissionModeTool = new SetPermissionModeTool();