Update core_mcp.py

core_mcp.py

@@ -276,22 +276,6 @@ def execute_tool(tool_name: str, params: Dict[str, str]) -> Dict[str, any]:
     return result
 
 def execute_gradio_space(tool_name: str, tool_config: Dict, params: Dict[str, str], transaction_id: str, timestamp: str) -> Dict[str, any]:
-    try:
-        from gradio_client import Client
-    except ImportError:
-        return {
-            'transaction_id': transaction_id,
-            'timestamp': timestamp,
-            'tool_name': tool_name,
-            'tool_type': 'gradio_space',
-            'endpoint': tool_config['space_name'],
-            'request_payload': params,
-            'response_payload': None,
-            'status': 'FAILURE',
-            'latency': 0.0,
-            'error_message': 'gradio_client not installed',
-            'summary': '❌ gradio_client not installed'
-        }
     space_name = tool_config['space_name']
     if not space_name or 'PLACEHOLDER' in space_name:
         return {
@@ -307,14 +291,23 @@ def execute_gradio_space(tool_name: str, tool_config: Dict, params: Dict[str, st
             'error_message': 'Tool space name not configured',
             'summary': '❌ Space not configured'
         }
+    
+    api_endpoint = f"https://huggingface.co/spaces/{space_name}/api/predict"
+    
+    param_order = tool_config.get('param_order', tool_config['required_params'])
+    data_array = [params.get(param, '') for param in param_order]
+    
+    payload = {"data": data_array}
+    headers = {'Content-Type': 'application/json'}
+    
     try:
-        hf_token = tool_config.get('hf_token', None)
-        client = Client(space_name, hf_token=hf_token) if hf_token else Client(space_name)
-        param_order = tool_config.get('param_order', tool_config['required_params'])
-        param_values = [params.get(param, '') for param in param_order]
-        api_name = tool_config.get('api_name', '/predict')
-        result = client.predict(*param_values, api_name=api_name)
+        response = requests.post(api_endpoint, headers=headers, json=payload, timeout=120)
+        response.raise_for_status()
+        result_data = response.json()
+        
+        result = result_data.get('data', [{}])[0] if 'data' in result_data else result_data
         summary = result.get('message', f"✅ Executed {tool_name}") if isinstance(result, dict) else f"✅ Executed {tool_name}"
+        
         return {
             'transaction_id': transaction_id,
             'timestamp': timestamp,
@@ -328,7 +321,25 @@ def execute_gradio_space(tool_name: str, tool_config: Dict, params: Dict[str, st
             'error_message': None,
             'summary': summary
         }
+    except requests.exceptions.HTTPError as e:
+        error_msg = f"HTTP {e.response.status_code}: {e.response.reason}"
+        if e.response.status_code == 503:
+            error_msg = "Space unavailable (503) - may be cold-starting or overloaded"
+        return {
+            'transaction_id': transaction_id,
+            'timestamp': timestamp,
+            'tool_name': tool_name,
+            'tool_type': 'gradio_space',
+            'endpoint': space_name,
+            'request_payload': params,
+            'response_payload': None,
+            'status': 'FAILURE',
+            'latency': 0.0,
+            'error_message': error_msg,
+            'summary': f"❌ {error_msg}"
+        }
     except Exception as e:
+        sanitized_error = sanitize_error_message(str(e))
         return {
             'transaction_id': transaction_id,
             'timestamp': timestamp,
@@ -339,8 +350,8 @@ def execute_gradio_space(tool_name: str, tool_config: Dict, params: Dict[str, st
             'response_payload': None,
             'status': 'FAILURE',
             'latency': 0.0,
-            'error_message': str(e),
-            'summary': f"❌ Execution failed: {str(e)[:50]}..."
+            'error_message': sanitized_error,
+            'summary': f"❌ Execution failed: {sanitized_error[:50]}..."
         }
 
 def execute_http_tool(tool_name: str, tool_config: Dict, params: Dict[str, str], transaction_id: str, timestamp: str) -> Dict[str, any]:
@@ -419,7 +430,10 @@ def call_ai_api(full_url: str, api_key: str, messages: List[Dict[str, str]]) ->
         else:
             return f"ERROR: API malformed response: {data}"
     except Exception as e:
-        return f"ERROR: API call failed: {str(e)}"
+        # SANITIZE the error message to remove API keys
+        raw_error = str(e)
+        sanitized_error = sanitize_error_message(raw_error)
+        return f"ERROR: API call failed: {sanitized_error}"
 
 def resolve_model(selected_label: str, model_registry: Dict[str, Dict], fallback_label: str, agent_name: str) -> Tuple[str, str, str]:
     if selected_label and selected_label in model_registry: