feat(satellite): unify tool path format to use serverSlug for namespacing

Author: Lasim

services/satellite/src/core/mcp-server-wrapper.ts

@@ -240,30 +240,27 @@ export class McpServerWrapper {
       throw new Error('Invalid tool_path parameter - must be a non-empty string in format "serverName:toolName"');
     }
 
-    // Parse tool_path from "serverName:toolName" format to "serverName-toolName" (internal namespaced format)
+    // Validate tool_path format (serverSlug:toolName)
     const colonIndex = toolPath.indexOf(':');
     if (colonIndex <= 0) {
-      throw new Error(`Invalid tool_path format: ${toolPath}. Expected format: "serverName:toolName" (e.g., "github:create_issue")`);
+      throw new Error(`Invalid tool_path format: ${toolPath}. Expected format: "serverSlug:toolName" (e.g., "github:create_issue")`);
     }
 
-    const serverSlug = toolPath.substring(0, colonIndex);
-    const toolName = toolPath.substring(colonIndex + 1);
-    const namespacedToolName = `${serverSlug}-${toolName}`;
+    // tool_path format matches internal namespaced format (unified to colon separator)
+    const namespacedToolName = toolPath;
 
     this.logger.info({
       operation: 'execute_mcp_tool',
-      tool_path: toolPath,
-      namespaced_tool_name: namespacedToolName
-    }, `Executing tool: ${toolPath} (internal: ${namespacedToolName})`);
+      tool_path: toolPath
+    }, `Executing tool: ${toolPath}`);
 
     this.logger.debug({
       operation: 'execute_mcp_tool_debug',
       tool_path: toolPath,
-      namespaced_tool_name: namespacedToolName,
       arguments: toolArguments
     }, `Tool arguments for ${toolPath}`);
 
-    // Route to existing executeToolCall with namespaced format
+    // Route to executeToolCall with namespaced format
     return await this.executeToolCall(namespacedToolName, toolArguments);
   }
 
@@ -326,10 +323,10 @@ export class McpServerWrapper {
       namespaced_tool_name: namespacedToolName
     }, `Calling namespaced tool: ${namespacedToolName}`);
 
-    // Parse the server slug from the namespaced tool name
-    const dashIndex = namespacedToolName.indexOf('-');
-    if (dashIndex <= 0) {
-      throw new Error(`Invalid tool name format: ${namespacedToolName}. Expected format: serverSlug-toolName`);
+    // Validate namespaced tool name format (serverSlug:toolName)
+    const colonIndex = namespacedToolName.indexOf(':');
+    if (colonIndex <= 0) {
+      throw new Error(`Invalid tool name format: ${namespacedToolName}. Expected format: serverSlug:toolName`);
     }
 
     // Find the cached tool to get the original tool name and verify it exists

services/satellite/src/process/types.ts

@@ -7,6 +7,7 @@ export interface MCPServerConfig {
   installation_id: string;       // Database ID from backend
   installation_name: string;     // e.g., "context7-john-R36no6FGoMFEZO9nWJJLT"
   team_id: string;              // Team UUID
+  server_slug: string;          // Server slug (e.g., "sequential", "brightdata-mcp-1")
   command: string;              // "npx" for Node.js packages
   args: string[];               // ["-y", "@upstash/context7"]
   env: Record<string, string>;  // Environment variables from three-tier config

services/satellite/src/server.ts

@@ -344,6 +344,7 @@ export async function createServer() {
               installation_id: serverConfig.installation_id || serverName,
               installation_name: serverName,
               team_id: serverConfig.team_id || 'unknown',
+              server_slug: serverConfig.server_slug || serverName,
               command: serverConfig.command!,
               args: serverConfig.args!,
               env: serverConfig.env || {}

services/satellite/src/services/command-processor.ts

@@ -320,6 +320,7 @@ export class CommandProcessor {
       installation_id: payload.installation_id as string,
       installation_name: payload.installation_name as string,
       team_id: payload.team_id as string,
+      server_slug: (payload.server_slug as string) || (payload.installation_name as string),
       command: payload.command as string,
       args: payload.args as string[],
       env: (payload.env as Record<string, string>) || {}

services/satellite/src/services/remote-tool-discovery-manager.ts

@@ -13,10 +13,11 @@ import { OAuthTokenService } from './oauth-token-service';
  */
 export interface CachedTool {
   originalName: string;
-  namespacedName: string; // e.g., "context7-resolve_library_id"
+  namespacedName: string; // e.g., "context7:resolve_library_id"
   description: string;
   inputSchema: any;
   serverName: string;
+  serverSlug: string;     // Server slug for tool_path format (e.g., "brightdata-mcp-1")
   discoveredAt: Date;
 }
 
@@ -407,16 +408,17 @@ export class RemoteToolDiscoveryManager {
 
       // Convert to cached tools with namespacing using server_slug for friendly names
       const discoveredAt = new Date();
+      // Use server_slug from config for friendly namespacing, fallback to server_name
+      const serverSlug = config.server_slug || config.server_name || serverName;
+
       const cachedTools: CachedTool[] = response.tools.map((tool: any) => {
-        // Use server_slug from config for friendly namespacing, fallback to server_name
-        const friendlyServerName = config.server_slug || config.server_name || serverName;
-        
         return {
           originalName: tool.name,
-          namespacedName: `${friendlyServerName}-${tool.name}`,
-          description: `[${friendlyServerName}] ${tool.description || 'No description'}`,
+          namespacedName: `${serverSlug}:${tool.name}`,
+          description: `[${serverSlug}] ${tool.description || 'No description'}`,
           inputSchema: tool.inputSchema || {},
           serverName: serverName, // Keep original serverName for routing
+          serverSlug: serverSlug, // Store slug for tool_path format
           discoveredAt: discoveredAt
         };
       });

services/satellite/src/services/stdio-tool-discovery-manager.ts

@@ -9,10 +9,11 @@ import type { EventBus } from './event-bus';
 export interface CachedStdioTool {
   serverName: string;           // Installation name (e.g., "filesystem-john-abc123")
   originalName: string;         // Tool name from server (e.g., "read_file")
-  namespacedName: string;       // User-facing name (e.g., "filesystem-read_file")
+  namespacedName: string;       // Namespaced name (e.g., "filesystem:read_file")
   description: string;          // Tool description
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   inputSchema: any;            // JSON Schema for tool parameters
+  serverSlug: string;          // Server slug for tool_path format (e.g., "sequential")
 }
 
 /**
@@ -94,21 +95,22 @@ export class StdioToolDiscoveryManager {
         return [];
       }
 
-      // Extract server slug from installation name (e.g., "filesystem-john-abc123" -> "filesystem")
-      const serverSlug = this.extractServerSlug(installationName);
-      
+      // Get server slug from process config (e.g., "sequential", "brightdata-mcp-1")
+      const serverSlug = processInfo.config.server_slug;
+
       const cachedTools: CachedStdioTool[] = [];
       const toolSet = new Set<string>();
 
       for (const tool of response.tools) {
-        const namespacedName = `${serverSlug}-${tool.name}`;
-        
+        const namespacedName = `${serverSlug}:${tool.name}`;
+
         const cachedTool: CachedStdioTool = {
           serverName: installationName,
           originalName: tool.name,
           namespacedName: namespacedName,
           description: tool.description || '',
-          inputSchema: tool.inputSchema || {}
+          inputSchema: tool.inputSchema || {},
+          serverSlug: serverSlug
         };
 
         this.toolCache.set(namespacedName, cachedTool);
@@ -272,16 +274,4 @@ export class StdioToolDiscoveryManager {
     return stats;
   }
 
-  /**
-   * Extract server slug from installation name
-   * Examples:
-   *   "filesystem-john-R36no6FGoMFEZO9nWJJLT" -> "filesystem"
-   *   "context7-alice-S47mp8GHpNGFZP0oWKKMU" -> "context7"
-   */
-  private extractServerSlug(installationName: string): string {
-    // Installation name format: {server_slug}-{team_slug}-{installation_id}
-    // Take everything before the first hyphen
-    const parts = installationName.split('-');
-    return parts[0] || installationName;
-  }
 }

services/satellite/src/services/tool-search-service.ts

@@ -114,30 +114,14 @@ export class ToolSearchService {
    * Flatten unified tools into searchable format
    */
   private flattenTools(tools: UnifiedCachedTool[]): SearchableTool[] {
-    return tools.map(tool => {
-      const serverSlug = this.extractServerSlug(tool.namespacedName);
-      
-      return {
-        serverName: tool.serverName,
-        serverSlug: serverSlug,
-        toolName: tool.originalName,
-        namespacedName: tool.namespacedName,
-        description: tool.description,
-        transport: tool.transport
-      };
-    });
-  }
-
-  /**
-   * Extract server slug from namespaced name
-   * Example: "filesystem-read_file" -> "filesystem"
-   */
-  private extractServerSlug(namespacedName: string): string {
-    const dashIndex = namespacedName.indexOf('-');
-    if (dashIndex > 0) {
-      return namespacedName.substring(0, dashIndex);
-    }
-    return namespacedName;
+    return tools.map(tool => ({
+      serverName: tool.serverName,
+      serverSlug: tool.serverSlug, // Use stored serverSlug directly
+      toolName: tool.originalName,
+      namespacedName: tool.namespacedName,
+      description: tool.description,
+      transport: tool.transport
+    }));
   }
 
   /**

services/satellite/src/services/unified-tool-discovery-manager.ts

@@ -12,10 +12,11 @@ import { RuntimeState } from '../process/runtime-state';
 export interface UnifiedCachedTool {
   serverName: string;           // Installation name (e.g., "filesystem-john-abc123")
   originalName: string;         // Tool name from server (e.g., "read_file")
-  namespacedName: string;       // User-facing name (e.g., "filesystem-read_file")
+  namespacedName: string;       // Namespaced name (e.g., "filesystem:read_file")
   description: string;          // Tool description
   inputSchema: any;            // JSON Schema for tool parameters
   transport: 'stdio' | 'http' | 'sse'; // Transport type for routing
+  serverSlug: string;           // Server slug for tool_path format (e.g., "brightdata-mcp-1")
   discoveredAt?: Date;          // When the tool was discovered
 }
 
@@ -171,17 +172,19 @@ export class UnifiedToolDiscoveryManager {
         description: tool.description,
         inputSchema: tool.inputSchema,
         transport: 'http' as const,
+        serverSlug: tool.serverSlug,
         discoveredAt: tool.discoveredAt
       })),
-      
+
       // Map stdio tools
       ...stdioTools.map(tool => ({
         serverName: tool.serverName,
         originalName: tool.originalName,
         namespacedName: tool.namespacedName,
         description: tool.description,
         inputSchema: tool.inputSchema,
-        transport: 'stdio' as const
+        transport: 'stdio' as const,
+        serverSlug: tool.serverSlug
       }))
     ];
 
@@ -197,7 +200,8 @@ export class UnifiedToolDiscoveryManager {
     if (stdioTool) {
       return {
         ...stdioTool,
-        transport: 'stdio'
+        transport: 'stdio',
+        serverSlug: stdioTool.serverSlug
       };
     }
 
@@ -211,6 +215,7 @@ export class UnifiedToolDiscoveryManager {
         description: remoteTool.description,
         inputSchema: remoteTool.inputSchema,
         transport: 'http',
+        serverSlug: remoteTool.serverSlug,
         discoveredAt: remoteTool.discoveredAt
       };
     }