feat(mcp): Implement dynamic MCP tool discovery

**MAJOR IMPROVEMENT:** Replace hardcoded tool list with runtime discovery

Before:
- 34 hardcoded MCP tools in ovsm_handler.rs
- Tools would get out of sync with server capabilities
- Required code changes to add new tools

After:
- Dynamically discovers ALL tools from configured MCP servers
- Automatically registers tools at runtime via list_tools() API
- Tested: ✅ 75 tools discovered from osvm-mcp server
- Graceful degradation if server initialization fails

Implementation:
- Iterate through all configured MCP servers
- Call initialize_server() + list_tools() for each
- Register McpBridgeTool for every discovered tool
- Debug output shows discovered tool count per server

Additional fixes:
- Add getBlockHeight to RPC bridge registry
- Fix getBalance example to use direct parameters
- Handle async context properly with .await (not block_on)

Testing:
✅ getSlot, getBlockHeight, getVersion working
✅ 75 MCP tools auto-discovered
✅ Graceful error handling for unavailable servers

This resolves the hardcoded tool list antipattern and makes
OSVM truly dynamic with MCP server capabilities.

Author: 0xrinegade

examples/ovsm_scripts/mcp_basic_rpc.ovsm

@@ -24,7 +24,8 @@
 ;; 4. Get balance for a known wallet
 (log :message "\n4. Checking wallet balance...")
 (define wallet "GBBbhHigLDyfxV71A24vGM2JLFukdChaNDTXGED1mF5r")
-(define balance (getBalance :address wallet))
+(define balance-result (getBalance wallet))
+(define balance (. balance-result value))
 (log :message "Balance (lamports):" :value balance)
 (log :message "Balance (SOL):" :value (/ balance 1000000000.0))
 

src/commands/ovsm_handler.rs

@@ -19,47 +19,58 @@ pub async fn handle_ovsm_command(
             use crate::utils::rpc_bridge::create_rpc_registry;
 
             let mut registry = create_rpc_registry();
-            // Register MCP tools for OVSM script execution
+
+            // Dynamically register MCP tools from configured servers
             let mut mcp_service = McpService::new_with_debug(debug);
             let _ = mcp_service.load_config();
             let mcp_arc = Arc::new(tokio::sync::Mutex::new(mcp_service));
-            let mcp_tools = vec![
-                "get_account_transactions",
-                "get_transaction",
-                "batch_transactions",
-                "analyze_transaction",
-                "explain_transaction",
-                "get_account_stats",
-                "get_account_portfolio",
-                "get_solana_balance",
-                "get_account_token_stats",
-                "check_account_type",
-                "search_accounts",
-                "get_balance",
-                "get_block",
-                "get_recent_blocks",
-                "get_block_stats",
-                "get_token_info",
-                "get_token_metadata",
-                "get_nft_collections",
-                "get_trending_nfts",
-                "get_defi_overview",
-                "get_dex_analytics",
-                "get_defi_health",
-                "get_validator_analytics",
-                "universal_search",
-                "verify_wallet_signature",
-                "get_user_history",
-                "get_usage_stats",
-                "manage_api_keys",
-                "get_api_metrics",
-                "report_error",
-                "get_program_registry",
-                "get_program_info",
-                "solana_rpc_call",
-            ];
-            for tool in mcp_tools {
-                registry.register(McpBridgeTool::new(tool, Arc::clone(&mcp_arc)));
+
+            // Discover and register tools from all configured MCP servers
+            {
+                let mut svc = mcp_arc.lock().await;
+                let mut total_tools = 0;
+
+                // Get all configured servers
+                let servers: Vec<String> = svc.list_servers()
+                    .iter()
+                    .map(|(id, _)| (*id).clone())
+                    .collect();
+
+                for server_id in servers {
+                    // Initialize server
+                    if let Err(e) = svc.initialize_server(&server_id).await {
+                        if debug {
+                            eprintln!("⚠️  Failed to initialize MCP server '{}': {}", server_id, e);
+                        }
+                        continue;
+                    }
+
+                    // List tools from this server
+                    match svc.list_tools(&server_id).await {
+                        Ok(tools) => {
+                            if debug {
+                                println!("📦 Discovered {} tools from MCP server '{}'", tools.len(), server_id);
+                            }
+                            total_tools += tools.len();
+
+                            // Register each tool
+                            drop(svc); // Release lock before registering
+                            for tool in tools {
+                                registry.register(McpBridgeTool::new(&tool.name, Arc::clone(&mcp_arc)));
+                            }
+                            svc = mcp_arc.lock().await; // Re-acquire lock
+                        }
+                        Err(e) => {
+                            if debug {
+                                eprintln!("⚠️  Failed to list tools from '{}': {}", server_id, e);
+                            }
+                        }
+                    }
+                }
+
+                if debug && total_tools > 0 {
+                    println!("✅ Registered {} MCP tools total\n", total_tools);
+                }
             }
             let mut service = OvsmService::with_registry(registry, verbose, debug);
 

src/utils/rpc_bridge.rs

@@ -273,6 +273,7 @@ pub fn create_rpc_registry() -> ToolRegistry {
         "getParsedTransaction",
         "getSlot",
         "getBlock",
+        "getBlockHeight",
         "getTransaction",
         "getAccountInfo",
         "getBalance",