@vellumai/assistant 0.4.44 → 0.4.45

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

@@ -1,73 +1,36 @@
-import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { deleteManagedSkill } from "../../skills/managed-store.js";
-import { registerTool } from "../registry.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
-
-export class DeleteManagedSkillTool implements Tool {
-  name = "delete_managed_skill";
-  description =
-    "Delete a managed skill from ~/.vellum/workspace/skills and remove it from the SKILLS.md index.";
-  category = "skills";
-  defaultRiskLevel = RiskLevel.High;
-
-  getDefinition(): ToolDefinition {
+import type { ToolContext, ToolExecutionResult } from "../types.js";
+
+/**
+ * Core execution logic for delete_managed_skill.
+ * Exported so bundled-skill executors and tests can call it directly.
+ */
+export async function executeDeleteManagedSkill(
+  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: "The ID of the managed skill to delete.",
-          },
-          remove_from_index: {
-            type: "boolean",
-            description:
-              "Whether to remove the skill from SKILLS.md index (default: true).",
-          },
-          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: ["skill_id"],
-      },
+      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 removeFromIndex = input.remove_from_index !== false;
-
-    const result = deleteManagedSkill(skillId.trim(), removeFromIndex);
+  const removeFromIndex = input.remove_from_index !== false;
 
-    if (!result.deleted) {
-      return { content: `Error: ${result.error}`, isError: true };
-    }
+  const result = deleteManagedSkill(skillId.trim(), removeFromIndex);
 
-    return {
-      content: JSON.stringify({
-        deleted: true,
-        skill_id: skillId.trim(),
-        index_updated: result.indexUpdated,
-      }),
-      isError: false,
-    };
+  if (!result.deleted) {
+    return { content: `Error: ${result.error}`, isError: true };
   }
-}
 
-export const deleteManagedSkillTool: Tool = new DeleteManagedSkillTool();
-registerTool(deleteManagedSkillTool);
+  return {
+    content: JSON.stringify({
+      deleted: true,
+      skill_id: skillId.trim(),
+      index_updated: result.indexUpdated,
+    }),
+    isError: false,
+  };
+}

package/src/tools/skills/execute.ts

@@ -0,0 +1,54 @@
+import { RiskLevel } from "../../permissions/types.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import { registerTool } from "../registry.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+
+export class SkillExecuteTool implements Tool {
+  name = "skill_execute";
+  description =
+    "Execute a tool provided by a loaded skill. Use this instead of calling skill tools directly. The skill's instructions (from skill_load) describe available tools and their parameters.";
+  category = "skills";
+  defaultRiskLevel = RiskLevel.Low;
+
+  getDefinition(): ToolDefinition {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: {
+        type: "object",
+        properties: {
+          tool: {
+            type: "string",
+            description:
+              "The skill tool name to execute (e.g. 'browser_navigate', 'task_create')",
+          },
+          input: {
+            type: "object",
+            description:
+              "Tool-specific parameters as documented in the skill's instructions",
+          },
+          reason: {
+            type: "string",
+            description:
+              "Brief non-technical explanation of what you are doing and why, shown to the user as a status update.",
+          },
+        },
+        required: ["tool", "input"],
+      },
+    };
+  }
+
+  async execute(
+    _input: Record<string, unknown>,
+    _context: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    return {
+      content:
+        "skill_execute should be intercepted at session level. If you see this error, the session dispatch is not configured.",
+      isError: true,
+    };
+  }
+}
+
+export const skillExecuteTool = new SkillExecuteTool();
+registerTool(skillExecuteTool);

package/src/tools/skills/load.ts

@@ -1,7 +1,10 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { skillFlagKey } from "../../config/skill-state.js";
-import type { SkillSummary } from "../../config/skills.js";
+import type { SkillSummary, SkillToolManifest } from "../../config/skills.js";
 import { loadSkillBySelector, loadSkillCatalog } from "../../config/skills.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
@@ -9,6 +12,7 @@ import {
   indexCatalogById,
   validateIncludes,
 } from "../../skills/include-graph.js";
+import { parseToolManifestFile } from "../../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../../skills/version-hash.js";
 import { getLogger } from "../../util/logger.js";
 import { registerTool } from "../registry.js";
@@ -16,6 +20,87 @@ import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 const log = getLogger("skill-load");
 
+/**
+ * Attempt to load and parse TOOLS.json from a skill directory.
+ * Returns undefined if the file doesn't exist or fails to parse.
+ */
+function loadToolManifest(
+  directoryPath: string,
+): SkillToolManifest | undefined {
+  const manifestPath = join(directoryPath, "TOOLS.json");
+  if (!existsSync(manifestPath)) {
+    return undefined;
+  }
+  try {
+    return parseToolManifestFile(manifestPath);
+  } catch (err) {
+    log.warn(
+      { err, manifestPath },
+      "Failed to parse TOOLS.json for tool schema output",
+    );
+    return undefined;
+  }
+}
+
+/**
+ * Format a skill tool manifest into a human-readable "Available Tools" section
+ * that instructs the LLM to use `skill_execute` to invoke the tools.
+ *
+ * When `childSkillName` is provided, a lighter sub-heading is used instead of
+ * the full `## Available Tools` header + preamble, avoiding duplicate headers
+ * when parent and child skills both have TOOLS.json.
+ */
+function formatToolSchemas(
+  manifest: SkillToolManifest,
+  childSkillName?: string,
+): string {
+  const lines: string[] = childSkillName
+    ? [`### Tools from ${childSkillName}`, ""]
+    : [
+        "## Available Tools",
+        "",
+        "Use `skill_execute` to call these tools.",
+        "",
+      ];
+
+  const toolHeadingLevel = childSkillName ? "####" : "###";
+
+  for (const tool of manifest.tools) {
+    lines.push(`${toolHeadingLevel} ${tool.name}`);
+    lines.push(tool.description);
+
+    const schema = tool.input_schema;
+    const properties = schema.properties as
+      | Record<string, Record<string, unknown>>
+      | undefined;
+    if (properties && Object.keys(properties).length > 0) {
+      const requiredSet = new Set<string>(
+        Array.isArray(schema.required) ? (schema.required as string[]) : [],
+      );
+
+      lines.push("Parameters:");
+      for (const [paramName, paramDef] of Object.entries(properties)) {
+        const paramType =
+          typeof paramDef.type === "string" ? paramDef.type : "any";
+        const requiredLabel = requiredSet.has(paramName)
+          ? "required"
+          : "optional";
+        const descPart =
+          typeof paramDef.description === "string"
+            ? `: ${paramDef.description}`
+            : "";
+        lines.push(
+          `- ${paramName} (${paramType}, ${requiredLabel})${descPart}`,
+        );
+      }
+    }
+
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd();
+}
+
 export class SkillLoadTool implements Tool {
   name = "skill_load";
   description =
@@ -69,7 +154,8 @@ export class SkillLoadTool implements Tool {
 
     // Assistant feature flag gate: reject loading if the skill's flag is OFF
     const config = getConfig();
-    if (!isAssistantFeatureFlagEnabled(skillFlagKey(skill.id), config)) {
+    const flagKey = skillFlagKey(skill);
+    if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config)) {
       return {
         content: `Error: skill "${skill.id}" is currently unavailable (disabled by feature flag)`,
         isError: true,
@@ -114,15 +200,26 @@ export class SkillLoadTool implements Tool {
 
     const body = skill.body.length > 0 ? skill.body : "(No body content)";
 
+    // Load tool schemas for the main skill
+    const mainManifest = loadToolManifest(skill.directoryPath);
+    const toolSchemasSection = mainManifest
+      ? formatToolSchemas(mainManifest)
+      : undefined;
+
     // Build immediate children metadata section and load included skill bodies
     let immediateChildrenSection: string;
     const includedBodies: string[] = [];
+    let anyChildHasTools = false;
     if (skill.includes && skill.includes.length > 0 && catalogIndex) {
       const childLines: string[] = [];
       for (const childId of skill.includes) {
         const child = catalogIndex.get(childId);
         if (!child) continue;
-        if (!isAssistantFeatureFlagEnabled(skillFlagKey(childId), config))
+        const childFlagKey = skillFlagKey(child);
+        if (
+          childFlagKey &&
+          !isAssistantFeatureFlagEnabled(childFlagKey, config)
+        )
           continue;
 
         childLines.push(
@@ -135,6 +232,17 @@ export class SkillLoadTool implements Tool {
           includedBodies.push(
             `--- Included Skill: ${childLoaded.skill.displayName} (${childId}) ---\n${childLoaded.skill.body}`,
           );
+
+          // Load tool schemas for the included skill (lighter sub-heading)
+          const childManifest = loadToolManifest(
+            childLoaded.skill.directoryPath,
+          );
+          if (childManifest) {
+            anyChildHasTools = true;
+            includedBodies.push(
+              formatToolSchemas(childManifest, childLoaded.skill.displayName),
+            );
+          }
         }
       }
       immediateChildrenSection = `Included Skills (immediate):\n${childLines.join(
@@ -162,7 +270,11 @@ export class SkillLoadTool implements Tool {
       for (const childId of skill.includes) {
         const child = catalogIndex.get(childId);
         if (!child) continue;
-        if (!isAssistantFeatureFlagEnabled(skillFlagKey(childId), config))
+        const childFlagKey2 = skillFlagKey(child);
+        if (
+          childFlagKey2 &&
+          !isAssistantFeatureFlagEnabled(childFlagKey2, config)
+        )
           continue;
         let childHash: string | undefined;
         try {
@@ -189,6 +301,15 @@ export class SkillLoadTool implements Tool {
         "",
         body,
         "",
+        ...(toolSchemasSection ? [toolSchemasSection, ""] : []),
+        ...(!toolSchemasSection && anyChildHasTools
+          ? [
+              "## Available Tools",
+              "",
+              "Use `skill_execute` to call these tools.",
+              "",
+            ]
+          : []),
         ...includedBodies.flatMap((b) => [b, ""]),
         immediateChildrenSection,
         "",
@@ -200,4 +321,5 @@ export class SkillLoadTool implements Tool {
   }
 }
 
-registerTool(new SkillLoadTool());
+export const skillLoadTool = new SkillLoadTool();
+registerTool(skillLoadTool);

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,
     };
   }