@vellumai/assistant 0.4.43 → 0.4.45

package/src/tools/skills/scaffold-managed.ts

@@ -1,200 +1,121 @@
-import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { createManagedSkill } from "../../skills/managed-store.js";
-import { registerTool } from "../registry.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+import type { ToolContext, ToolExecutionResult } from "../types.js";
 
 /** Strip embedded newlines/carriage returns to prevent YAML frontmatter injection. */
 function sanitizeFrontmatterValue(value: string): string {
   return value.replace(/[\r\n]+/g, " ").trim();
 }
 
-export class ScaffoldManagedSkillTool implements Tool {
-  name = "scaffold_managed_skill";
-  description =
-    "Create or update a managed skill in ~/.vellum/workspace/skills. The skill becomes available for skill_load immediately.";
-  category = "skills";
-  defaultRiskLevel = RiskLevel.High;
-
-  getDefinition(): ToolDefinition {
+/**
+ * Core execution logic for scaffold_managed_skill.
+ * Exported so bundled-skill executors and tests can call it directly.
+ */
+export async function executeScaffoldManagedSkill(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const skillId = input.skill_id;
+  if (typeof skillId !== "string" || !skillId.trim()) {
     return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          skill_id: {
-            type: "string",
-            description:
-              'Unique identifier for the skill (lowercase slug, e.g. "my-skill").',
-          },
-          name: {
-            type: "string",
-            description: "Human-readable name for the skill.",
-          },
-          description: {
-            type: "string",
-            description: "Short description of what the skill does.",
-          },
-          body_markdown: {
-            type: "string",
-            description:
-              "The full skill body in markdown — instructions, prompts, templates, etc.",
-          },
-          emoji: {
-            type: "string",
-            description: "Optional emoji icon for the skill.",
-          },
-          user_invocable: {
-            type: "boolean",
-            description:
-              "Whether users can invoke this skill directly (default: true).",
-          },
-          disable_model_invocation: {
-            type: "boolean",
-            description:
-              "Whether to prevent the model from auto-invoking this skill (default: false).",
-          },
-          overwrite: {
-            type: "boolean",
-            description:
-              "Whether to overwrite an existing skill with the same ID (default: false).",
-          },
-          add_to_index: {
-            type: "boolean",
-            description:
-              "Whether to add the skill to SKILLS.md index (default: true).",
-          },
-          includes: {
-            type: "array",
-            items: { type: "string" },
-            description:
-              "Optional list of child skill IDs that this skill includes (metadata only, no auto-activation).",
-          },
-          reason: {
-            type: "string",
-            description:
-              "Brief non-technical explanation of what you are creating and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-          },
-        },
-        required: ["skill_id", "name", "description", "body_markdown"],
-      },
+      content: "Error: skill_id is required and must be a non-empty string",
+      isError: true,
     };
   }
 
-  async execute(
-    input: Record<string, unknown>,
-    _context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const skillId = input.skill_id;
-    if (typeof skillId !== "string" || !skillId.trim()) {
-      return {
-        content: "Error: skill_id is required and must be a non-empty string",
-        isError: true,
-      };
-    }
+  const name = input.name;
+  if (typeof name !== "string" || !name.trim()) {
+    return {
+      content: "Error: name is required and must be a non-empty string",
+      isError: true,
+    };
+  }
 
-    const name = input.name;
-    if (typeof name !== "string" || !name.trim()) {
-      return {
-        content: "Error: name is required and must be a non-empty string",
-        isError: true,
-      };
-    }
+  const description = input.description;
+  if (typeof description !== "string" || !description.trim()) {
+    return {
+      content: "Error: description is required and must be a non-empty string",
+      isError: true,
+    };
+  }
 
-    const description = input.description;
-    if (typeof description !== "string" || !description.trim()) {
-      return {
-        content:
-          "Error: description is required and must be a non-empty string",
-        isError: true,
-      };
-    }
+  const bodyMarkdown = input.body_markdown;
+  if (typeof bodyMarkdown !== "string" || !bodyMarkdown.trim()) {
+    return {
+      content:
+        "Error: body_markdown is required and must be a non-empty string",
+      isError: true,
+    };
+  }
 
-    const bodyMarkdown = input.body_markdown;
-    if (typeof bodyMarkdown !== "string" || !bodyMarkdown.trim()) {
+  // Validate and normalize includes
+  let includes: string[] | undefined;
+  if (input.includes !== undefined) {
+    if (!Array.isArray(input.includes)) {
       return {
-        content:
-          "Error: body_markdown is required and must be a non-empty string",
+        content: "Error: includes must be an array of strings",
         isError: true,
       };
     }
-
-    // Validate and normalize includes
-    let includes: string[] | undefined;
-    if (input.includes !== undefined) {
-      if (!Array.isArray(input.includes)) {
+    for (const item of input.includes) {
+      if (typeof item !== "string") {
         return {
-          content: "Error: includes must be an array of strings",
+          content: "Error: each element in includes must be a non-empty string",
           isError: true,
         };
       }
-      for (const item of input.includes) {
-        if (typeof item !== "string") {
-          return {
-            content:
-              "Error: each element in includes must be a non-empty string",
-            isError: true,
-          };
-        }
-        if (!item.trim()) {
-          return {
-            content:
-              "Error: each element in includes must be a non-empty string",
-            isError: true,
-          };
-        }
-      }
-      const normalized: string[] = [];
-      const seen = new Set<string>();
-      for (const item of input.includes as string[]) {
-        const trimmed = item.trim();
-        if (seen.has(trimmed)) continue;
-        seen.add(trimmed);
-        normalized.push(trimmed);
-      }
-      if (normalized.length > 0) {
-        includes = normalized;
+      if (!item.trim()) {
+        return {
+          content: "Error: each element in includes must be a non-empty string",
+          isError: true,
+        };
       }
     }
-
-    const result = createManagedSkill({
-      id: skillId.trim(),
-      name: sanitizeFrontmatterValue(name),
-      description: sanitizeFrontmatterValue(description),
-      bodyMarkdown: bodyMarkdown,
-      emoji:
-        typeof input.emoji === "string"
-          ? sanitizeFrontmatterValue(input.emoji)
-          : undefined,
-      userInvocable:
-        typeof input.user_invocable === "boolean"
-          ? input.user_invocable
-          : undefined,
-      disableModelInvocation:
-        typeof input.disable_model_invocation === "boolean"
-          ? input.disable_model_invocation
-          : undefined,
-      overwrite: input.overwrite === true,
-      addToIndex: input.add_to_index !== false,
-      includes,
-    });
-
-    if (!result.created) {
-      return { content: `Error: ${result.error}`, isError: true };
+    const normalized: string[] = [];
+    const seen = new Set<string>();
+    for (const item of input.includes as string[]) {
+      const trimmed = item.trim();
+      if (seen.has(trimmed)) continue;
+      seen.add(trimmed);
+      normalized.push(trimmed);
+    }
+    if (normalized.length > 0) {
+      includes = normalized;
     }
+  }
 
-    return {
-      content: JSON.stringify({
-        created: true,
-        skill_id: skillId.trim(),
-        path: result.path,
-        index_updated: result.indexUpdated,
-      }),
-      isError: false,
-    };
+  const result = createManagedSkill({
+    id: skillId.trim(),
+    name: sanitizeFrontmatterValue(name),
+    description: sanitizeFrontmatterValue(description),
+    bodyMarkdown: bodyMarkdown,
+    emoji:
+      typeof input.emoji === "string"
+        ? sanitizeFrontmatterValue(input.emoji)
+        : undefined,
+    userInvocable:
+      typeof input.user_invocable === "boolean"
+        ? input.user_invocable
+        : undefined,
+    disableModelInvocation:
+      typeof input.disable_model_invocation === "boolean"
+        ? input.disable_model_invocation
+        : undefined,
+    overwrite: input.overwrite === true,
+    addToIndex: input.add_to_index !== false,
+    includes,
+  });
+
+  if (!result.created) {
+    return { content: `Error: ${result.error}`, isError: true };
   }
-}
 
-export const scaffoldManagedSkillTool: Tool = new ScaffoldManagedSkillTool();
-registerTool(scaffoldManagedSkillTool);
+  return {
+    content: JSON.stringify({
+      created: true,
+      skill_id: skillId.trim(),
+      path: result.path,
+      index_updated: result.indexUpdated,
+    }),
+    isError: false,
+  };
+}

package/src/tools/subagent/message.ts

@@ -28,13 +28,6 @@ export async function executeSubagentMessage(
 
   const result = await manager.sendMessage(subagentId, content);
 
-  if (result === "queue_full") {
-    return {
-      content: `Subagent "${subagentId}" message queue is full. Please wait for current messages to be processed.`,
-      isError: true,
-    };
-  }
-
   if (result === "empty") {
     return {
       content: "Message content is empty or whitespace-only.",

package/src/tools/subagent/spawn.ts

@@ -23,7 +23,7 @@ export async function executeSubagentSpawn(
     | undefined;
   if (!sendToClient) {
     return {
-      content: "No IPC client connected — cannot spawn subagent.",
+      content: "No client connected — cannot spawn subagent.",
       isError: true,
     };
   }

package/src/tools/swarm/delegate.ts

@@ -8,7 +8,6 @@ import { executeSwarm } from "../../swarm/orchestrator.js";
 import { generatePlan } from "../../swarm/router-planner.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
-import { registerTool } from "../registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 const log = getLogger("swarm-delegate");
@@ -205,8 +204,6 @@ export const swarmDelegateTool: Tool = {
   },
 };
 
-registerTool(swarmDelegateTool);
-
 /** Clear all active sessions — only for testing. */
 export function _resetSwarmActive(): void {
   activeSessions.clear();

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

@@ -109,39 +109,33 @@ export const setAvatarTool: Tool = {
       };
     } catch (error) {
       if (error instanceof ManagedAvatarError) {
+        log.error(
+          {
+            error: error.message,
+            statusCode: error.statusCode,
+            code: error.code,
+          },
+          "Avatar generation failed (managed)",
+        );
         if (error.statusCode === 429) {
-          log.warn(
-            { correlationId: error.correlationId },
-            "Avatar generation rate limited",
-          );
           return {
             content:
-              "Avatar generation is rate limited. Please wait and try again.",
+              "Avatar generation is currently rate limited. Please try again in a moment.",
             isError: true,
           };
         }
-        if (error.statusCode === 503) {
-          log.warn(
-            { correlationId: error.correlationId },
-            "Avatar generation service unavailable",
-          );
+        if (error.statusCode >= 500) {
           return {
-            content: "Avatar generation service is temporarily unavailable.",
+            content:
+              "Avatar generation is temporarily unavailable. Please try again later.",
             isError: true,
           };
         }
-        const detail =
-          error.message || "Avatar generation failed. Please try again.";
-        log.error(
-          { error: detail, correlationId: error.correlationId },
-          "Managed avatar generation failed",
-        );
         return {
-          content: `Avatar generation failed: ${detail}`,
+          content: `Avatar generation failed: ${error.message}`,
           isError: true,
         };
       }
-
       const message = mapGeminiError(error);
       log.error({ error: message }, "Avatar generation failed");
       return {

package/src/tools/system/request-permission.ts

@@ -110,4 +110,5 @@ class RequestSystemPermissionTool implements Tool {
   }
 }
 
-registerTool(new RequestSystemPermissionTool());
+export const requestSystemPermissionTool = new RequestSystemPermissionTool();
+registerTool(requestSystemPermissionTool);

package/src/tools/terminal/safe-env.ts

@@ -27,6 +27,7 @@ const SAFE_ENV_VARS = [
   "SSH_AGENT_PID",
   "GPG_TTY",
   "GNUPGHOME",
+  "VELLUM_DEV",
 ] as const;
 
 export function buildSanitizedEnv(): Record<string, string> {

package/src/tools/tool-manifest.ts

@@ -6,24 +6,28 @@
  * so adding/removing tools only requires editing this manifest.
  */
 
-import { accountManageTool } from "./credentials/account-registry.js";
+import { assetMaterializeTool } from "./assets/materialize.js";
+import { assetSearchTool } from "./assets/search.js";
 import { credentialStoreTool } from "./credentials/vault.js";
-import {
-  memoryDeleteTool,
-  memoryRecallTool,
-  memorySaveTool,
-  memoryUpdateTool,
-} from "./memory/register.js";
+import { fileEditTool } from "./filesystem/edit.js";
+import { fileReadTool } from "./filesystem/read.js";
+import { fileWriteTool } from "./filesystem/write.js";
+import { memoryManageTool, memoryRecallTool } from "./memory/register.js";
+import { webFetchTool } from "./network/web-fetch.js";
+import { webSearchTool } from "./network/web-search.js";
 import type { LazyToolDescriptor } from "./registry.js";
-import { setAvatarTool } from "./system/avatar-generator.js";
-import { navigateSettingsTabTool } from "./system/navigate-settings.js";
-import { openSystemSettingsTool } from "./system/open-system-settings.js";
-import { voiceConfigUpdateTool } from "./system/voice-config.js";
+import { skillExecuteTool } from "./skills/execute.js";
+import { skillLoadTool } from "./skills/load.js";
+import { requestSystemPermissionTool } from "./system/request-permission.js";
+import { shellTool } from "./terminal/shell.js";
 import type { Tool } from "./types.js";
-import { screenWatchTool } from "./watch/screen-watch.js";
 
 // ── Eager side-effect modules ───────────────────────────────────────
-// These static imports trigger top-level `registerTool()` side effects.
+// These static imports trigger top-level `registerTool()` side effects on
+// first evaluation. The named imports above serve double duty: they give us
+// module-level references to each tool instance so that initializeTools()
+// can explicitly re-register them after a test registry reset (ESM caching
+// prevents side effects from re-running on subsequent imports).
 //
 // IMPORTANT: These MUST be static imports (not dynamic `await import()`).
 // When the daemon is compiled with `bun --compile`, dynamic imports with
@@ -31,21 +35,6 @@ import { screenWatchTool } from "./watch/screen-watch.js";
 // filesystem root rather than the module's own directory, causing
 // "Cannot find module './filesystem/read.js'" crashes in production builds.
 // Static imports are resolved at bundle time and are always safe.
-import "./assets/materialize.js";
-import "./assets/search.js";
-import "./filesystem/edit.js";
-import "./filesystem/read.js";
-import "./filesystem/view-image.js";
-import "./filesystem/write.js";
-import "./network/web-fetch.js";
-import "./network/web-search.js";
-import "./skills/delete-managed.js";
-import "./skills/load.js";
-import "./skills/scaffold-managed.js";
-import "./swarm/delegate.js";
-import "./system/request-permission.js";
-import "./system/version.js";
-import "./terminal/shell.js";
 
 // loadEagerModules is a no-op now that all eager registrations happen via
 // static imports above. Kept for API compatibility with registry.ts callers.
@@ -64,39 +53,44 @@ export const eagerModuleToolNames: string[] = [
   "file_edit",
   "web_search",
   "web_fetch",
+  "skill_execute",
   "skill_load",
-  "scaffold_managed_skill",
-  "delete_managed_skill",
   "request_system_permission",
   "asset_search",
   "asset_materialize",
-  "swarm_delegate",
-  "view_image",
-  "version",
 ];
 
 // ── Explicit tool instances ─────────────────────────────────────────
-// Tools exported as instances — registered by initializeTools() without
-// relying on import side effects.
+// Tools registered by initializeTools() via explicit instance references.
+// This includes both previously-eager tools (referenced here so they survive
+// a test registry reset) and tools that have always been explicit.
 
 export const explicitTools: Tool[] = [
-  memorySaveTool,
-  memoryUpdateTool,
-  memoryDeleteTool,
+  // Previously-eager tools — kept here so initializeTools() can re-register
+  // them after __resetRegistryForTesting() clears the registry (ESM caching
+  // prevents their side-effect registrations from re-running).
+  shellTool,
+  fileReadTool,
+  fileWriteTool,
+  fileEditTool,
+  webFetchTool,
+  webSearchTool,
+  skillExecuteTool,
+  skillLoadTool,
+  requestSystemPermissionTool,
+  assetSearchTool,
+  assetMaterializeTool,
+  // Always-explicit tools
+  memoryManageTool,
   memoryRecallTool,
   credentialStoreTool,
-  accountManageTool,
-  screenWatchTool,
-  voiceConfigUpdateTool,
-  setAvatarTool,
-  openSystemSettingsTool,
-  navigateSettingsTabTool,
 ];
 
 // ── Lazy tool descriptors ───────────────────────────────────────────
 // Tools that defer module loading until first invocation.
-// bash and swarm_delegate were previously lazy but are now eagerly registered
-// via side-effect imports above, preserving their full definitions (including
-// the `reason` field on bash) and fixing bun --compile module-not-found crashes.
+// bash was previously lazy but is now eagerly registered via side-effect
+// imports above, preserving its full definition (including the `reason` field)
+// and fixing bun --compile module-not-found crashes.
+// swarm_delegate has been moved to the orchestration bundled skill.
 
 export const lazyTools: LazyToolDescriptor[] = [];

package/src/tools/types.ts

@@ -136,9 +136,9 @@ export interface ToolContext {
     allowedTools?: string[];
     allowedDomains?: string[];
   }) => Promise<SecretPromptResult>;
-  /** Optional callback to send a message to the connected IPC client (e.g. open_url). */
+  /** Optional callback to send a message to the connected client (e.g. open_url). */
   sendToClient?: (msg: { type: string; [key: string]: unknown }) => void;
-  /** True when an interactive IPC client is connected (not just a no-op callback). */
+  /** True when an interactive client is connected (not just a no-op callback). */
   isInteractive?: boolean;
   /** Memory scope ID from the session's memory policy, so memory tools can target the correct scope. */
   memoryScopeId?: string;
@@ -169,6 +169,10 @@ export interface ToolContext {
   channelPermissionChannelId?: string;
   /** The tool_use block ID from the LLM response, used to correlate confirmation prompts with specific tool invocations. */
   toolUseId?: string;
+  /** Optional proxy for delegating host_bash execution to a connected client (managed/cloud-hosted mode). */
+  hostBashProxy?: import("../daemon/host-bash-proxy.js").HostBashProxy;
+  /** Optional proxy for delegating host_file_read/write/edit execution to a connected client (managed/cloud-hosted mode). */
+  hostFileProxy?: import("../daemon/host-file-proxy.js").HostFileProxy;
 }
 
 export interface DiffInfo {

package/src/tools/ui-surface/definitions.ts

@@ -218,63 +218,8 @@ export const uiDismissTool: Tool = {
   execute: proxyExecute,
 };
 
-// ---------------------------------------------------------------------------
-// request_file
-// ---------------------------------------------------------------------------
-
-export const requestFileTool: Tool = {
-  name: "request_file",
-  description:
-    "Request a file or image from the user. Shows a file upload dialog where the user can drag-and-drop or browse for files. " +
-    "Use this when you need the user to share a file (image, document, PDF, etc.) to continue the conversation. " +
-    "The result contains the uploaded file data including base64 content and MIME type.",
-  category: "ui-surface",
-  defaultRiskLevel: RiskLevel.Low,
-  executionMode: "proxy",
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          prompt: {
-            type: "string",
-            description:
-              'What to ask the user for, e.g. "Please share the design file you\'d like me to review"',
-          },
-          accepted_types: {
-            type: "array",
-            items: { type: "string" },
-            description:
-              'MIME type filters, e.g. ["image/*", "application/pdf"]. If omitted, all supported file types are accepted.',
-          },
-          max_files: {
-            type: "number",
-            description: "Maximum number of files to accept. Defaults to 1.",
-          },
-          reason: {
-            type: "string",
-            description:
-              "Brief non-technical explanation of what you are requesting and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-          },
-        },
-        required: ["prompt"],
-      },
-    };
-  },
-
-  execute: proxyExecute,
-};
-
-// ---------------------------------------------------------------------------
-// All tools exported as array for convenience
-// ---------------------------------------------------------------------------
-
 export const allUiSurfaceTools: Tool[] = [
   uiShowTool,
   uiUpdateTool,
   uiDismissTool,
-  requestFileTool,
 ];

package/src/util/errors.ts

@@ -14,9 +14,6 @@ export enum ErrorCode {
   // Daemon errors
   DAEMON_ERROR = "DAEMON_ERROR",
 
-  // IPC/socket errors
-  IPC_ERROR = "IPC_ERROR",
-
   // Platform-specific errors (clipboard, unsupported OS features)
   PLATFORM_ERROR = "PLATFORM_ERROR",
 
@@ -151,17 +148,22 @@ export class ConfigError extends AssistantError {
   }
 }
 
-export class DaemonError extends AssistantError {
-  constructor(message: string, options?: { cause?: unknown }) {
-    super(message, ErrorCode.DAEMON_ERROR, options);
-    this.name = "DaemonError";
+export class ProviderNotConfiguredError extends ConfigError {
+  constructor(
+    public readonly requestedProvider: string,
+    public readonly registeredProviders: string[],
+  ) {
+    super(
+      `No providers available. Requested: "${requestedProvider}". Registered: ${registeredProviders.join(", ") || "none"}`,
+    );
+    this.name = "ProviderNotConfiguredError";
   }
 }
 
-export class IpcError extends AssistantError {
+export class DaemonError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
-    super(message, ErrorCode.IPC_ERROR, options);
-    this.name = "IpcError";
+    super(message, ErrorCode.DAEMON_ERROR, options);
+    this.name = "DaemonError";
   }
 }