@vellumai/assistant 0.3.20 → 0.3.21

package/src/tools/mcp/mcp-tool-factory.ts

@@ -0,0 +1,100 @@
+import type { McpServerConfig } from '../../config/mcp-schema.js';
+import type { McpServerManager } from '../../mcp/manager.js';
+import { RiskLevel } from '../../permissions/types.js';
+import type { ToolDefinition } from '../../providers/types.js';
+import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
+
+const riskMap: Record<string, RiskLevel> = {
+  low: RiskLevel.Low,
+  medium: RiskLevel.Medium,
+  high: RiskLevel.High,
+};
+
+/**
+ * Create a namespaced tool name to prevent collisions across MCP servers
+ * and with core/skill tools.
+ */
+export function mcpToolName(serverId: string, toolName: string): string {
+  return `mcp__${serverId}__${toolName}`;
+}
+
+/**
+ * Parse a namespaced MCP tool name back into serverId and original tool name.
+ * Returns null if the name doesn't match the MCP naming convention.
+ */
+export function parseMcpToolName(name: string): { serverId: string; toolName: string } | null {
+  if (!name.startsWith('mcp__')) return null;
+  const prefixRemoved = name.slice(5); // remove 'mcp__'
+  const firstSep = prefixRemoved.indexOf('__');
+  if (firstSep === -1) return null;
+  return {
+    serverId: prefixRemoved.slice(0, firstSep),
+    toolName: prefixRemoved.slice(firstSep + 2),
+  };
+}
+
+export interface McpToolMetadata {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+/**
+ * Create a Tool object from MCP tool metadata.
+ * The tool delegates execution to the McpServerManager.
+ */
+export function createMcpTool(
+  metadata: McpToolMetadata,
+  serverId: string,
+  serverConfig: McpServerConfig,
+  manager: McpServerManager,
+): Tool {
+  const namespacedName = mcpToolName(serverId, metadata.name);
+  const riskLevel = riskMap[serverConfig.defaultRiskLevel] ?? RiskLevel.High;
+
+  return {
+    name: namespacedName,
+    description: metadata.description,
+    category: 'mcp',
+    defaultRiskLevel: riskLevel,
+    origin: 'mcp',
+    ownerMcpServerId: serverId,
+    executionTarget: 'host',
+
+    getDefinition(): ToolDefinition {
+      return {
+        name: namespacedName,
+        description: metadata.description,
+        input_schema: metadata.inputSchema as ToolDefinition['input_schema'],
+      };
+    },
+
+    async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+      try {
+        const result = await manager.callTool(serverId, metadata.name, input);
+        return {
+          content: result.content,
+          isError: result.isError,
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: `MCP tool execution failed: ${message}`,
+          isError: true,
+        };
+      }
+    },
+  };
+}
+
+/**
+ * Create Tool objects from all tools provided by an MCP server.
+ */
+export function createMcpToolsFromServer(
+  tools: McpToolMetadata[],
+  serverId: string,
+  serverConfig: McpServerConfig,
+  manager: McpServerManager,
+): Tool[] {
+  return tools.map((tool) => createMcpTool(tool, serverId, serverConfig, manager));
+}

package/src/tools/registry.ts

@@ -121,7 +121,7 @@ export function registerSkillTools(newTools: Tool[]): Tool[] {
   for (const tool of newTools) {
     const existing = tools.get(tool.name);
     if (existing) {
-      const existingIsCore = existing.origin !== 'skill';
+      const existingIsCore = existing.origin === 'core' || !existing.origin;
       if (existingIsCore) {
         log.warn(
           { toolName: tool.name, skillId: tool.ownerSkillId },
@@ -176,6 +176,69 @@ export function unregisterSkillTools(skillId: string): void {
   }
 }
 
+/**
+ * Register multiple MCP-origin tools at once.
+ * Skips any tool whose name collides with a core tool (logs a warning).
+ * Throws if a tool name collides with a tool owned by a different MCP server.
+ */
+export function registerMcpTools(newTools: Tool[]): Tool[] {
+  const accepted: Tool[] = [];
+  for (const tool of newTools) {
+    const existing = tools.get(tool.name);
+    if (existing) {
+      const existingIsCore = existing.origin === 'core' || !existing.origin;
+      if (existingIsCore) {
+        log.warn(
+          { toolName: tool.name, serverId: tool.ownerMcpServerId },
+          `MCP server "${tool.ownerMcpServerId}" tried to register tool "${tool.name}" which conflicts with a core tool. Skipping.`,
+        );
+        continue;
+      }
+      if (existing.origin === 'skill') {
+        log.warn(
+          { toolName: tool.name, serverId: tool.ownerMcpServerId, skillId: existing.ownerSkillId },
+          `MCP server "${tool.ownerMcpServerId}" tried to register tool "${tool.name}" which conflicts with skill tool from "${existing.ownerSkillId}". Skipping.`,
+        );
+        continue;
+      }
+      if (existing.origin === 'mcp' && existing.ownerMcpServerId !== tool.ownerMcpServerId) {
+        throw new Error(
+          `MCP tool "${tool.name}" is already registered by MCP server "${existing.ownerMcpServerId}"`,
+        );
+      }
+    }
+    accepted.push(tool);
+  }
+
+  for (const tool of accepted) {
+    tools.set(tool.name, tool);
+    log.info({ name: tool.name, ownerMcpServerId: tool.ownerMcpServerId }, 'MCP tool registered');
+  }
+
+  return accepted;
+}
+
+/**
+ * Unregister all tools belonging to a specific MCP server.
+ */
+export function unregisterMcpTools(serverId: string): void {
+  for (const [name, tool] of tools) {
+    if (tool.origin === 'mcp' && tool.ownerMcpServerId === serverId) {
+      tools.delete(name);
+      log.info({ name, serverId }, 'MCP tool unregistered');
+    }
+  }
+}
+
+/**
+ * Return the names of all currently registered MCP-origin tools.
+ */
+export function getMcpToolNames(): string[] {
+  return Array.from(tools.values())
+    .filter((t) => t.origin === 'mcp')
+    .map((t) => t.name);
+}
+
 /**
  * Return the names of all currently registered skill-origin tools.
  */

package/src/tools/types.ts

@@ -170,10 +170,12 @@ export interface Tool {
   defaultRiskLevel: RiskLevel;
   /** When set to 'proxy', the tool is forwarded to a connected client rather than executed locally. */
   executionMode?: 'local' | 'proxy';
-  /** Whether this tool is a core built-in or provided by a skill. */
-  origin?: 'core' | 'skill';
+  /** Whether this tool is a core built-in, provided by a skill, or from an MCP server. */
+  origin?: 'core' | 'skill' | 'mcp';
   /** If origin is 'skill', the ID of the owning skill. */
   ownerSkillId?: string;
+  /** If origin is 'mcp', the ID of the owning MCP server. */
+  ownerMcpServerId?: string;
   /** Content-hash of the owning skill's source at registration time. */
   ownerSkillVersionHash?: string;
   /** Whether the owning skill is bundled with the daemon (trusted first-party). */