비동기 처리 오퍼레이션 응답 결과 강화 및 create_* 도구명 set_*으로 변경

Author: call518

README.md

@@ -18,7 +18,8 @@
 
 - ✅ **Single Project Scope**: Operates within the configured `OS_PROJECT_NAME` project scope for complete tenant isolation. All operations are restricted to resources within the specified project, ensuring data privacy and security in multi-tenant environments.
 - ✅ **OpenStack SDK Integration**: Direct integration with OpenStack SDK for real-time project operations.
-- ✅ **Production-Safe Operations**: Built-in safety controls with `ALLOW_MODIFY_OPERATIONS` environment variable to prevent modification operations in production environments.
+- ✅ **Enhanced Operation Safety**: Built-in safety controls with `ALLOW_MODIFY_OPERATIONS` environment variable and comprehensive error handling that prevents false success claims and provides clear guidance for asynchronous operations.
+- ✅ **Smart Async Operation Handling**: Intelligent detection and guidance for OpenStack asynchronous operations (instance management, volume operations, network changes) with tool-specific timing expectations and verification commands.
 - ✅ **Enhanced Project Monitoring**: Comprehensive project status reports with health scoring system, resource utilization analysis, instance state tracking, and detailed health breakdown by service categories.
 - ✅ **Complete Service Coverage**: 93+ comprehensive tools covering Identity, Compute, Network, Storage, Image, Orchestration, Load Balancer, and Monitoring services within project scope.
 - ✅ **Advanced Instance Management**: Enhanced server lifecycle operations with backup, migration, rescue, and administrative functions including state analysis.
@@ -65,7 +66,7 @@
 | `openstack server create` | `set_instance` (action="create") | ✅ | Instance creation |
 | `openstack server start/stop/reboot` | `set_instance` | ✅ | Full lifecycle management |
 | `openstack server delete` | `set_instance` (action="delete") | ✅ | Instance deletion |
-| `openstack server backup create` | `create_server_backup` | ✅ | Backup creation with rotation |
+| `openstack server backup create` | `set_server_backup` | ✅ | Backup creation with rotation |
 | `openstack server image create` | `set_instance` (action="snapshot") | ✅ | Image/snapshot creation |
 | `openstack server shelve/unshelve` | `set_instance` | ✅ | Instance shelving |
 | `openstack server lock/unlock` | `set_instance` | ✅ | Instance locking |
@@ -97,7 +98,7 @@
 | `openstack server remove volume` | `set_server_volume` (action="detach") | ✅ | Volume detachment |
 | `openstack server set` | `set_server_properties` (action="set") | ✅ | Server property setting |
 | `openstack server unset` | `set_server_properties` (action="unset") | ✅ | Server property unsetting |
-| `openstack server dump create` | `create_server_dump` | ✅ | Server dump creation |
+| `openstack server dump create` | `set_server_dump` | ✅ | Server dump creation |
 | `openstack server event list` | `get_server_events` | ✅ | Server event tracking |
 | `openstack server group list` | `get_server_groups` | ✅ | Server group listing |
 | `openstack server group create/delete` | `set_server_group` | ✅ | Server group management |

src/mcp_openstack_ops/mcp_main.py

@@ -21,6 +21,17 @@ def handle_operation_result(result: Dict[str, Any], operation_name: str, details
     Returns:
         Success JSON or clear error message
     """
+    # Check if result is None or empty
+    if not result:
+        error_response = f"❌ **{operation_name} Failed**\n\n**Error**: No response received from OpenStack API. The operation may have failed or timed out."
+        
+        if details:
+            details_str = '\n'.join([f"**{k}**: {v}" for k, v in details.items()])
+            error_response += f"\n\n{details_str}"
+            error_response += "\n\n**Recommendation**: Please verify the operation status and try again if needed."
+            
+        return error_response
+    
     # Check if operation failed and return clear error message
     if isinstance(result, dict) and result.get('success') is False:
         error_message = result.get('message', 'Unknown error occurred')
@@ -33,16 +44,97 @@ def handle_operation_result(result: Dict[str, Any], operation_name: str, details
 
         return error_response
 
-    # Return success response
-    return result if isinstance(result, str) else json.dumps(result, indent=2, ensure_ascii=False)
+    # Enhanced handling for successful operations with tool-specific async guidance
+    if isinstance(result, dict) and result.get('success') is True:
+        # Extract operation details from various parameter structures
+        action = details.get('Action', 'operation') if details else 'operation'
+        resource_name = (details.get('Instance') or details.get('Volume') or 
+                        details.get('Network') or details.get('Stack') or 
+                        details.get('Image') or details.get('Keypair') or 'resource') if details else 'resource'
+        
+        # Tool-specific async handling and verification commands
+        async_operations = {
+            "Instance Management": {
+                "async_actions": ["start", "stop", "restart", "reboot", "create", "delete", "resize", "rebuild"],
+                "timing": "30-60 seconds",
+                "verify_cmd": f"Show instance status for {resource_name}"
+            },
+            "Volume Management": {
+                "async_actions": ["create", "delete", "extend", "attach", "detach"],
+                "timing": "10-30 seconds", 
+                "verify_cmd": "List all volumes"
+            },
+            "Network Management": {
+                "async_actions": ["create", "delete"],
+                "timing": "5-15 seconds",
+                "verify_cmd": "Show all networks"
+            },
+            "Heat Stack Management": {
+                "async_actions": ["create", "update", "delete"],
+                "timing": "2-10 minutes",
+                "verify_cmd": "List all Heat stacks"
+            },
+            "Image Management": {
+                "async_actions": ["create", "delete", "update"],
+                "timing": "1-5 minutes",
+                "verify_cmd": "List available images"
+            },
+            "Quota Management": {
+                "async_actions": [],  # Usually synchronous
+                "timing": "immediate",
+                "verify_cmd": "Show quota usage and limits"
+            },
+            "Keypair Management": {
+                "async_actions": [],  # Usually synchronous
+                "timing": "immediate", 
+                "verify_cmd": "List all keypairs"
+            }
+        }
+        
+        tool_config = async_operations.get(operation_name, {
+            "async_actions": ["create", "delete", "update"],
+            "timing": "variable",
+            "verify_cmd": f"Check {operation_name.lower()} status"
+        })
+        
+        # Only add async note for operations that are actually asynchronous
+        if action.lower() in tool_config.get("async_actions", []):
+            if "message" in result:
+                timing = tool_config.get("timing", "variable")
+                verify_cmd = tool_config.get("verify_cmd", f"Check {operation_name.lower()} status")
+                
+                result["message"] += f"\n\n📋 Note: This is an asynchronous operation. The {action} command has been initiated successfully (expected completion: {timing}). You can verify the status using '{verify_cmd}'."
+            
+            result["operation_type"] = "asynchronous"
+            result["verification_needed"] = True
+        else:
+            # For synchronous operations, just mark as completed
+            result["operation_type"] = "synchronous"
+            result["verification_needed"] = False
+    
+    # Return formatted JSON response
+    try:
+        return json.dumps(result, indent=2, ensure_ascii=False)
+    except Exception as e:
+        # Fallback for JSON serialization issues
+        return f"Operation completed but response formatting failed: {str(e)}"
+        
+        # Return formatted JSON for other successful dict results
+        try:
+            return json.dumps(result, indent=2, ensure_ascii=False)
+        except Exception as json_error:
+            return f"✅ **{operation_name} Successful**\n\nOperation completed but response formatting failed: {str(json_error)}"
+    
+    # Return string results as-is
+    return str(result) if result else "❌ **Operation Failed**: Empty response"
 
 from .connection import get_openstack_connection
+from .services.compute import search_instances as _search_instances
 from .functions import (
     get_service_status as _get_service_status, 
     get_instance_details as _get_instance_details, 
     get_instance_by_name as _get_instance_by_name,
     get_instance_by_id as _get_instance_by_id,
-    search_instances as _search_instances,
     get_instances_by_status as _get_instances_by_status,
     get_network_details as _get_network_details,
     set_instance as _set_instance,
@@ -66,8 +158,8 @@ def handle_operation_result(result: Dict[str, Any], operation_name: str, details
     set_server_security_group as _set_server_security_group,
     set_server_migration as _set_server_migration,
     set_server_properties as _set_server_properties,
-    create_server_backup as _create_server_backup,
-    create_server_dump as _create_server_dump,
+    create_server_backup as _set_server_backup,
+    create_server_dump as _set_server_dump,
     # Network (Neutron) enhanced functions
     get_floating_ips as _get_floating_ips,
     set_floating_ip as _set_floating_ip,
@@ -422,20 +514,13 @@ async def search_instances(
 
         search_result = _search_instances(
             search_term=search_term, 
-            search_in=search_in,
+            search_fields=search_in.split(',') if search_in else ['name', 'id'],
             limit=limit,
-            offset=offset,
-            case_sensitive=case_sensitive
+            include_inactive=True  # 모든 인스턴스를 검색하기 위해
         )
 
         # Handle both old return format (list) and new return format (dict)
-        if isinstance(search_result, dict):
-            instances = search_result.get('instances', [])
-            search_info = search_result.get('search_info', {})
-            pagination_info = search_result.get('pagination', {})
-            performance_info = search_result.get('performance', {})
-        else:
-            # Backward compatibility with old list return format
+        if isinstance(search_result, list):
             instances = search_result
             search_info = {
                 'search_term': search_term,
@@ -445,6 +530,17 @@ async def search_instances(
             }
             pagination_info = {'limit': limit, 'offset': offset, 'has_more': False}
             performance_info = {}
+        elif isinstance(search_result, dict):
+            instances = search_result.get('instances', [])
+            search_info = search_result.get('search_info', {})
+            pagination_info = search_result.get('pagination', {})
+            performance_info = search_result.get('performance', {})
+        else:
+            # Fallback for unexpected format
+            instances = []
+            search_info = {'search_term': search_term, 'matches_found': 0}
+            pagination_info = {'limit': limit, 'offset': offset, 'has_more': False}
+            performance_info = {}
 
         result = {
             "timestamp": datetime.now().isoformat(),
@@ -1046,7 +1142,7 @@ async def set_server_properties(
 
 
 @conditional_tool
-async def create_server_backup(
+async def set_server_backup(
     instance_name: str,
     backup_name: str,
     backup_type: str = "daily",
@@ -1087,7 +1183,7 @@ async def create_server_backup(
             'metadata': metadata
         }
 
-        result = _create_server_backup(instance_name.strip(), backup_name.strip(), **kwargs)
+        result = _set_server_backup(instance_name.strip(), backup_name.strip(), **kwargs)
 
         # Use centralized result handling
         return handle_operation_result(
@@ -1112,7 +1208,7 @@ async def create_server_backup(
 
 
 @conditional_tool
-async def create_server_dump(instance_name: str) -> str:
+async def set_server_dump(instance_name: str) -> str:
     """
     Create a dump file for a server (vendor-specific feature).
     
@@ -1135,7 +1231,7 @@ async def create_server_dump(instance_name: str) -> str:
     try:
         logger.info(f"Attempting to create server dump: {instance_name}")
 
-        result = _create_server_dump(instance_name.strip())
+        result = _set_server_dump(instance_name.strip())
 
         # Use centralized result handling
         return handle_operation_result(

src/mcp_openstack_ops/prompt_template.md

@@ -49,6 +49,65 @@
 - ❌ **WRONG**: "요청을 처리했습니다" (when required parameters missing)
 - ✅ **CORRECT**: Return the actual error message from the tool
 
+### **🔍 Empty Response Detection and Handling**
+
+**CRITICAL RULE**: If MCP tool returns empty, null, or "(응답 내용 없음)" response:
+
+1. **NEVER assume operation succeeded**
+2. **NEVER make up success messages**
+3. **ALWAYS report the empty response issue**
+4. **Recommend verification steps**
+
+**Proper Response Pattern for Empty Results**:
+```
+❌ The operation may not have completed successfully as no response was received from the OpenStack API.
+
+🔍 **Recommended Next Steps**:
+1. Please verify the current status: "Show instance status for [instance-name]"
+2. Check recent events: "Show instance events for [instance-name]" 
+3. Try the operation again if needed
+
+This ensures we don't provide false success confirmations when operations may have actually failed.
+```
+
+**Common Empty Response Scenarios**:
+- Instance start/stop/restart operations
+- Volume attach/detach operations  
+- Network configuration changes
+- Security group modifications
+- Any OpenStack asynchronous operations
+
+### **⚠️ Asynchronous Operation Awareness**
+
+**For OpenStack asynchronous operations** (start, stop, restart, create, delete):
+
+1. **Success message** = Command was **initiated**, not completed
+2. **Always inform user** about asynchronous nature
+3. **Provide status check guidance**
+
+### **🔄 Enhanced Response Handling for All Operations**
+
+**All `set_*` operations use enhanced response processing:**
+
+**Success Response Patterns**:
+- **Instance Operations**: `✅ Instance [action] initiated. Verify: "Show instance status"`
+- **Volume Operations**: `✅ Volume [action] initiated. Verify: "List all volumes"`
+- **Network Operations**: `✅ Network [action] initiated. Verify: "Show all networks"`
+- **Image Operations**: `✅ Image [action] initiated. Verify: "List available images"`
+- **Stack Operations**: `✅ Stack [action] initiated. Verify: "List all Heat stacks"`
+- **Other Operations**: `✅ [Resource] [action] initiated. Verify with appropriate status command.`
+
+**Universal Empty Response Pattern**:
+```
+❌ No response from OpenStack API - operation status unclear.
+Verify current state with appropriate status check command and retry if needed.
+```
+
+**Application Rules**:
+- **Enhanced responses**: All `set_*` tools (modify operations)
+- **Standard responses**: All `get_*`, `search_*`, `monitor_*` tools (read-only)
+- **Async operations**: Always include verification guidance and expected timing
+
 ### **📋 Required Parameters for Create Operations**
 
 **VM Creation (`set_instance` with action="create")**:
@@ -219,8 +278,8 @@ This approach provides **comprehensive 360-degree cluster visibility** with infr
 **Server Advanced Operations:**
 - `set_server_migration`: Live migrate/evacuate/confirm/abort (**Conditional Tool**)
 - `set_server_properties`: Set/unset metadata and properties (**Conditional Tool**)
-- `create_server_backup`: Create incremental backups (**Conditional Tool**)
-- `create_server_dump`: Trigger memory dumps (**Conditional Tool**)
+- `set_server_backup`: Create incremental backups (**Conditional Tool**)
+- `set_server_dump`: Trigger memory dumps (**Conditional Tool**)
 
 **Server Information & Resources:**
 - `get_server_groups`: Affinity/anti-affinity policy information (always available)