@rishibhushan/jenkins-mcp-server 1.0.7 → 1.1.1

package/src/jenkins_mcp_server/server.py

@@ -7,9 +7,11 @@ Provides MCP protocol handlers for Jenkins operations including:
 - Tools (Jenkins operations)
 """
 
+import asyncio
 import json
 import logging
 import sys
+import time
 from typing import Optional
 
 import mcp.server.stdio
@@ -18,8 +20,10 @@ from mcp.server import NotificationOptions, Server
 from mcp.server.models import InitializationOptions
 from pydantic import AnyUrl
 
+from .cache import get_cache_manager
 from .config import JenkinsSettings, get_default_settings
-from .jenkins_client import get_jenkins_client, JenkinsConnectionError
+from .jenkins_client import get_jenkins_client
+from .metrics import get_metrics_collector, record_tool_execution
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -30,11 +34,17 @@ server = Server("jenkins-mcp-server")
 # Settings storage (injected by main)
 _jenkins_settings: Optional[JenkinsSettings] = None
 
+# Client connection cache (Quick Win #3)
+_jenkins_client_cache = None
+_client_cache_lock = asyncio.Lock()
+
 
 def set_jenkins_settings(settings: JenkinsSettings) -> None:
     """Set Jenkins settings for the server (called from __init__.py)"""
-    global _jenkins_settings
+    global _jenkins_settings, _jenkins_client_cache
     _jenkins_settings = settings
+    # Clear cache when settings change
+    _jenkins_client_cache = None
 
 
 def get_settings() -> JenkinsSettings:
@@ -45,6 +55,64 @@ def get_settings() -> JenkinsSettings:
     return _jenkins_settings
 
 
+async def get_cached_jenkins_client(settings: JenkinsSettings):
+    """
+    Get or create cached Jenkins client (Quick Win #3: Client Caching)
+    Reuses the same client connection across tool calls for better performance.
+    """
+    global _jenkins_client_cache
+
+    async with _client_cache_lock:
+        if _jenkins_client_cache is None:
+            logger.info("Creating new Jenkins client connection")
+            _jenkins_client_cache = get_jenkins_client(settings)
+        return _jenkins_client_cache
+
+
+# Input Validation Helpers (Quick Win #4)
+
+def validate_job_name(job_name: any) -> str:
+    """Validate job name parameter"""
+    if not job_name:
+        raise ValueError("Missing required argument: job_name")
+    if not isinstance(job_name, str):
+        raise ValueError(f"job_name must be a string, got {type(job_name).__name__}")
+    if not job_name.strip():
+        raise ValueError("job_name cannot be empty or whitespace")
+    return job_name.strip()
+
+
+def validate_build_number(build_number: any) -> int:
+    """Validate build number parameter"""
+    if build_number is None:
+        raise ValueError("Missing required argument: build_number")
+
+    try:
+        num = int(build_number)
+    except (ValueError, TypeError):
+        raise ValueError(f"build_number must be an integer, got: {build_number}")
+
+    if num < 0:
+        raise ValueError(f"build_number must be non-negative, got: {num}")
+
+    return num
+
+
+def validate_config_xml(config_xml: any) -> str:
+    """Validate XML configuration parameter"""
+    if not config_xml:
+        raise ValueError("Missing required argument: config_xml")
+    if not isinstance(config_xml, str):
+        raise ValueError(f"config_xml must be a string, got {type(config_xml).__name__}")
+
+    # Basic XML validation
+    xml_str = config_xml.strip()
+    if not xml_str.startswith('<'):
+        raise ValueError("config_xml must be valid XML (should start with '<')")
+
+    return xml_str
+
+
 # ==================== Resources ====================
 
 @server.list_resources()
@@ -314,6 +382,91 @@ async def _prompt_analyze_build_logs(arguments: dict[str, str]) -> types.GetProm
         )
 
 
+async def _tool_trigger_multiple_builds(client, args):
+    """Trigger builds for multiple jobs at once"""
+    job_names = args.get("job_names", [])
+    parameters = args.get("parameters", {})
+    wait_for_start = args.get("wait_for_start", False)
+
+    # Validation
+    if not job_names:
+        raise ValueError("No job names provided")
+
+    if not isinstance(job_names, list):
+        raise ValueError("job_names must be an array")
+
+    if len(job_names) > 20:
+        raise ValueError("Maximum 20 jobs can be triggered at once")
+
+    # Validate each job name
+    validated_jobs = []
+    for job_name in job_names:
+        try:
+            validated = validate_job_name(job_name)
+            validated_jobs.append(validated)
+        except ValueError as e:
+            return [types.TextContent(
+                type="text",
+                text=f"❌ Invalid job name '{job_name}': {str(e)}"
+            )]
+
+    # Validate parameters if provided
+    if parameters and not isinstance(parameters, dict):
+        raise ValueError(f"parameters must be a dictionary, got {type(parameters).__name__}")
+
+    # Trigger all builds
+    results = []
+    for job_name in validated_jobs:
+        try:
+            result = client.build_job(
+                job_name,
+                parameters,
+                wait_for_start=wait_for_start,
+                timeout=10  # Shorter timeout for batch
+            )
+
+            results.append({
+                "job": job_name,
+                "status": "triggered",
+                "queue_id": result.get('queue_id'),
+                "build_number": result.get('build_number') if wait_for_start else None
+            })
+
+            logger.info(f"Triggered build for {job_name}")
+
+        except Exception as e:
+            results.append({
+                "job": job_name,
+                "status": "failed",
+                "error": str(e)
+            })
+            logger.error(f"Failed to trigger {job_name}: {e}")
+
+    # Build summary
+    successful = [r for r in results if r["status"] == "triggered"]
+    failed = [r for r in results if r["status"] == "failed"]
+
+    summary = {
+        "total": len(job_names),
+        "successful": len(successful),
+        "failed": len(failed),
+        "results": results
+    }
+
+    # Invalidate cache since jobs were triggered
+    cache_manager = get_cache_manager()
+    await cache_manager.invalidate_pattern("jobs_list:")
+
+    emoji = "✅" if len(failed) == 0 else "⚠️"
+    message = f"{emoji} Batch Build Trigger Complete\n\n"
+    message += f"Total Jobs: {len(job_names)}\n"
+    message += f"Successful: {len(successful)}\n"
+    message += f"Failed: {len(failed)}\n\n"
+    message += f"Details:\n{json.dumps(results, indent=2)}"
+
+    return [types.TextContent(type="text", text=message)]
+
+
 # ==================== Tools ====================
 
 @server.list_tools()
@@ -343,8 +496,14 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "job_name": {"type": "string"},
-                    "build_number": {"type": "integer"},
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job"
+                    },
+                    "build_number": {
+                        "type": "integer",
+                        "description": "Build number to stop"
+                    },
                 },
                 "required": ["job_name", "build_number"],
             },
@@ -353,13 +512,18 @@ async def handle_list_tools() -> list[types.Tool]:
         # Job Information
         types.Tool(
             name="list-jobs",
-            description="List all Jenkins jobs with optional filtering",
+            description="List all Jenkins jobs with optional filtering and caching",
             inputSchema={
                 "type": "object",
                 "properties": {
                     "filter": {
                         "type": "string",
                         "description": "Filter jobs by name (case-insensitive partial match)"
+                    },
+                    "use_cache": {
+                        "type": "boolean",
+                        "description": "Use cached results if available (default: true)",
+                        "default": True
                     }
                 }
             },
@@ -369,7 +533,19 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Get detailed information about a Jenkins job",
             inputSchema={
                 "type": "object",
-                "properties": {"job_name": {"type": "string"}},
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job"
+                    },
+                    "max_recent_builds": {
+                        "type": "integer",
+                        "description": "Maximum number of recent builds to fetch (0-10, default: 3). Set to 0 to skip build history.",
+                        "default": 3,
+                        "minimum": 0,
+                        "maximum": 10
+                    }
+                },
                 "required": ["job_name"],
             },
         ),
@@ -381,8 +557,14 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "job_name": {"type": "string"},
-                    "build_number": {"type": "integer"},
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job"
+                    },
+                    "build_number": {
+                        "type": "integer",
+                        "description": "Build number to get information about"
+                    },
                 },
                 "required": ["job_name", "build_number"],
             },
@@ -393,8 +575,26 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "job_name": {"type": "string"},
-                    "build_number": {"type": "integer"},
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job"
+                    },
+                    "build_number": {
+                        "type": "integer",
+                        "description": "Build number to get console output from"
+                    },
+                    "max_lines": {
+                        "type": "integer",
+                        "description": "Maximum number of lines to return (default: 1000, max: 10000)",
+                        "default": 1000,
+                        "minimum": 10,
+                        "maximum": 10000
+                    },
+                    "tail_only": {
+                        "type": "boolean",
+                        "description": "If true, return last N lines instead of first N lines (default: false)",
+                        "default": False
+                    },
                 },
                 "required": ["job_name", "build_number"],
             },
@@ -404,7 +604,12 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Get the last build number for a job",
             inputSchema={
                 "type": "object",
-                "properties": {"job_name": {"type": "string"}},
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job"
+                    }
+                },
                 "required": ["job_name"],
             },
         ),
@@ -413,7 +618,12 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Get the timestamp of the last build",
             inputSchema={
                 "type": "object",
-                "properties": {"job_name": {"type": "string"}},
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job"
+                    }
+                },
                 "required": ["job_name"],
             },
         ),
@@ -425,8 +635,14 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "job_name": {"type": "string"},
-                    "config_xml": {"type": "string", "description": "Job configuration XML"},
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name for the new Jenkins job"
+                    },
+                    "config_xml": {
+                        "type": "string",
+                        "description": "Job configuration in XML format"
+                    },
                 },
                 "required": ["job_name", "config_xml"],
             },
@@ -437,8 +653,14 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "new_job_name": {"type": "string"},
-                    "source_job_name": {"type": "string"},
+                    "new_job_name": {
+                        "type": "string",
+                        "description": "Name for the new job to be created"
+                    },
+                    "source_job_name": {
+                        "type": "string",
+                        "description": "Name of the existing job to copy from"
+                    },
                 },
                 "required": ["new_job_name", "source_job_name"],
             },
@@ -449,9 +671,19 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "job_name": {"type": "string"},
-                    "config_data": {"type": "object"},
-                    "root_tag": {"type": "string", "default": "project"},
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name for the new Jenkins job"
+                    },
+                    "config_data": {
+                        "type": "object",
+                        "description": "Job configuration as structured data (will be converted to XML)"
+                    },
+                    "root_tag": {
+                        "type": "string",
+                        "default": "project",
+                        "description": "Root XML tag for the configuration (default: 'project')"
+                    },
                 },
                 "required": ["job_name", "config_data"],
             },
@@ -461,7 +693,12 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Delete an existing Jenkins job",
             inputSchema={
                 "type": "object",
-                "properties": {"job_name": {"type": "string"}},
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job to delete"
+                    }
+                },
                 "required": ["job_name"],
             },
         ),
@@ -470,7 +707,12 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Enable a disabled Jenkins job",
             inputSchema={
                 "type": "object",
-                "properties": {"job_name": {"type": "string"}},
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job to enable"
+                    }
+                },
                 "required": ["job_name"],
             },
         ),
@@ -479,7 +721,12 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Disable a Jenkins job",
             inputSchema={
                 "type": "object",
-                "properties": {"job_name": {"type": "string"}},
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job to disable"
+                    }
+                },
                 "required": ["job_name"],
             },
         ),
@@ -489,8 +736,14 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "job_name": {"type": "string"},
-                    "new_name": {"type": "string"},
+                    "job_name": {
+                        "type": "string",
+                        "description": "Current name of the Jenkins job"
+                    },
+                    "new_name": {
+                        "type": "string",
+                        "description": "New name for the Jenkins job"
+                    },
                 },
                 "required": ["job_name", "new_name"],
             },
@@ -502,7 +755,12 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Get the configuration XML for a job",
             inputSchema={
                 "type": "object",
-                "properties": {"job_name": {"type": "string"}},
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job"
+                    }
+                },
                 "required": ["job_name"],
             },
         ),
@@ -512,8 +770,14 @@ async def handle_list_tools() -> list[types.Tool]:
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "job_name": {"type": "string"},
-                    "config_xml": {"type": "string"},
+                    "job_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins job to update"
+                    },
+                    "config_xml": {
+                        "type": "string",
+                        "description": "New configuration in XML format"
+                    },
                 },
                 "required": ["job_name", "config_xml"],
             },
@@ -535,10 +799,102 @@ async def handle_list_tools() -> list[types.Tool]:
             description="Get information about a specific Jenkins node",
             inputSchema={
                 "type": "object",
-                "properties": {"node_name": {"type": "string"}},
+                "properties": {
+                    "node_name": {
+                        "type": "string",
+                        "description": "Name of the Jenkins node/agent"
+                    }
+                },
                 "required": ["node_name"],
             },
         ),
+        types.Tool(
+            name="trigger-multiple-builds",
+            description="Trigger builds for multiple jobs at once",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "job_names": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of job names to trigger",
+                        "minItems": 1,
+                        "maxItems": 20
+                    },
+                    "parameters": {
+                        "type": "object",
+                        "description": "Common parameters for all builds (optional)",
+                        "additionalProperties": {"type": ["string", "number", "boolean"]},
+                    },
+                    "wait_for_start": {
+                        "type": "boolean",
+                        "description": "Wait for all builds to start (default: false)",
+                        "default": False
+                    }
+                },
+                "required": ["job_names"],
+            },
+        ),
+
+        # Cache tools
+        types.Tool(
+            name="get-cache-stats",
+            description="Get cache statistics and information",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        types.Tool(
+            name="clear-cache",
+            description="Clear all cached data",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+
+        # Health Check (Quick Win #1)
+        types.Tool(
+            name="health-check",
+            description="Check Jenkins server health and connection status. Useful for troubleshooting connectivity issues.",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+
+        # Get metrics
+        types.Tool(
+            name="get-metrics",
+            description="Get usage metrics and performance statistics",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "tool_name": {
+                        "type": "string",
+                        "description": "Specific tool name (optional, returns all if not specified)"
+                    }
+                }
+            },
+        ),
+
+        types.Tool(
+            name="configure-webhook",
+            description="Configure webhook notifications for Jenkins events (requires Jenkins plugin)",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "job_name": {
+                        "type": "string",
+                        "description": "Job to configure webhook for"
+                    },
+                    "webhook_url": {
+                        "type": "string",
+                        "description": "URL to receive webhook notifications"
+                    },
+                    "events": {
+                        "type": "array",
+                        "items": {
+                            "enum": ["build_started", "build_completed", "build_failed", "build_success"]
+                        },
+                        "description": "Events to trigger webhook"
+                    }
+                },
+                "required": ["job_name", "webhook_url", "events"]
+            },
+        ),
     ]
 
     logger.info(f"Registered {len(tools)} Jenkins tools")
@@ -550,11 +906,15 @@ async def handle_call_tool(
         name: str,
         arguments: dict | None
 ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
-    """Handle tool execution requests"""
+    """Handle tool execution requests with improved error handling and metrics tracking"""
     arguments = arguments or {}
+    start_time = time.time()
+    success = False
+    error_message = None
 
     try:
-        client = get_jenkins_client(get_settings())
+        # Use cached client for better performance
+        client = await get_cached_jenkins_client(get_settings())
 
         # Route to appropriate handler
         handlers = {
@@ -589,22 +949,163 @@ async def handle_call_tool(
             "get-queue-info": _tool_get_queue_info,
             "list-nodes": _tool_list_nodes,
             "get-node-info": _tool_get_node_info,
+
+            # Health check (Quick Win #1)
+            "health-check": _tool_health_check,
+
+            # NEW: Medium Priority
+            "trigger-multiple-builds": _tool_trigger_multiple_builds,
+            "get-cache-stats": _tool_get_cache_stats,
+            "clear-cache": _tool_clear_cache,
+
+            # NEW: Low Priority
+            "get-metrics": _tool_get_metrics,
+            "configure-webhook": _tool_configure_webhook,
         }
 
         handler = handlers.get(name)
         if not handler:
             raise ValueError(f"Unknown tool: {name}")
 
-        return await handler(client, arguments)
+        result = await handler(client, arguments)
+        success = True
+        return result
 
-    except Exception as e:
-        logger.error(f"Tool execution failed for {name}: {e}", exc_info=True)
+    # Better error messages with troubleshooting steps (Quick Win #2)
+    except ValueError as e:
+        # Validation errors - user's fault
+        logger.warning(f"Validation error in {name}: {e}")
         return [
             types.TextContent(
                 type="text",
-                text=f"Error executing {name}: {str(e)}"
+                text=f"❌ Invalid input for {name}: {str(e)}\n\n"
+                     f"💡 Please check the parameter values and try again."
             )
         ]
+    except ImportError:
+        # Missing requests library
+        import_error = (
+            f"⚠️ Missing required library 'requests'.\n\n"
+            f"To fix this, run:\n"
+            f"pip install requests"
+        )
+        logger.error(f"Import error in {name}: requests library not found")
+        return [types.TextContent(type="text", text=import_error)]
+    except Exception as e:
+        # Check for common requests exceptions
+        error_type = type(e).__name__
+        error_message = str(e)
+
+        # Timeout errors
+        if 'timeout' in error_message.lower() or error_type == 'Timeout':
+            logger.error(f"Timeout error in {name}: {e}")
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"⏱️ Timeout connecting to Jenkins.\n\n"
+                         f"Troubleshooting steps:\n"
+                         f"1. Check Jenkins server is running\n"
+                         f"2. Verify URL is correct: {get_settings().url}\n"
+                         f"3. Ensure network/VPN connection is active\n"
+                         f"4. Check firewall settings\n\n"
+                         f"Error: {str(e)}"
+                )
+            ]
+
+        # Connection errors
+        elif 'connection' in error_message.lower() or error_type in ['ConnectionError', 'ConnectionRefusedError']:
+            logger.error(f"Connection error in {name}: {e}")
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"🔌 Cannot connect to Jenkins at {get_settings().url}\n\n"
+                         f"Troubleshooting steps:\n"
+                         f"1. Verify Jenkins server is accessible\n"
+                         f"2. Check port is correct (usually 8080)\n"
+                         f"3. Ensure firewall allows connection\n"
+                         f"4. Test with: curl {get_settings().url}/api/json\n\n"
+                         f"Error: {str(e)}"
+                )
+            ]
+
+        # Authentication errors (401)
+        elif '401' in error_message or 'unauthorized' in error_message.lower():
+            logger.error(f"Authentication error in {name}: {e}")
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"🔐 Authentication failed.\n\n"
+                         f"Troubleshooting steps:\n"
+                         f"1. Verify username is correct: {get_settings().username}\n"
+                         f"2. Check API token is valid (not expired)\n"
+                         f"3. Generate new token in Jenkins:\n"
+                         f"   - Go to Jenkins → Your Name → Configure\n"
+                         f"   - Click 'Add new Token' under API Token section\n"
+                         f"4. Update .env file with new token\n\n"
+                         f"Error: {str(e)}"
+                )
+            ]
+
+        # Permission errors (403)
+        elif '403' in error_message or 'forbidden' in error_message.lower():
+            logger.error(f"Permission error in {name}: {e}")
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"🚫 Permission denied.\n\n"
+                         f"Troubleshooting steps:\n"
+                         f"1. Check user has permission to access Jenkins\n"
+                         f"2. Verify user has permission for this operation\n"
+                         f"3. Contact Jenkins admin to grant necessary permissions\n\n"
+                         f"User: {get_settings().username}\n"
+                         f"Operation: {name}\n"
+                         f"Error: {str(e)}"
+                )
+            ]
+
+        # Not found errors (404)
+        elif '404' in error_message or 'not found' in error_message.lower():
+            logger.error(f"Not found error in {name}: {e}")
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"❌ Resource not found.\n\n"
+                         f"Troubleshooting steps:\n"
+                         f"1. Check job/resource name is correct (case-sensitive)\n"
+                         f"2. Verify resource exists in Jenkins\n"
+                         f"3. Ensure user has permission to view the resource\n"
+                         f"4. Try listing all jobs with 'list-jobs' tool\n\n"
+                         f"Error: {str(e)}"
+                )
+            ]
+
+        # Generic error with some context
+        else:
+            logger.error(f"Tool execution failed for {name}: {e}", exc_info=True)
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"❌ Error executing {name}\n\n"
+                         f"Error type: {error_type}\n"
+                         f"Error message: {str(e)}\n\n"
+                         f"💡 Troubleshooting tips:\n"
+                         f"1. Run 'health-check' tool to verify connection\n"
+                         f"2. Check Jenkins logs for more details\n"
+                         f"3. Verify all parameters are correct\n"
+                         f"4. Try the operation manually in Jenkins UI"
+                )
+            ]
+
+    finally:
+        # Record metrics
+        execution_time_ms = (time.time() - start_time) * 1000
+        await record_tool_execution(
+            tool_name=name,
+            execution_time_ms=execution_time_ms,
+            success=success,
+            error_message=error_message,
+            args={"tool": name}  # Don't log full args for privacy
+        )
 
 
 # ==================== Tool Handlers ====================
@@ -613,11 +1114,12 @@ async def handle_call_tool(
 
 async def _tool_trigger_build(client, args):
     """Trigger a Jenkins build"""
-    job_name = args.get("job_name")
+    # Input validation (Quick Win #4)
+    job_name = validate_job_name(args.get("job_name"))
     parameters = args.get("parameters", {})
 
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    if parameters and not isinstance(parameters, dict):
+        raise ValueError(f"parameters must be a dictionary, got {type(parameters).__name__}")
 
     result = client.build_job(job_name, parameters)
 
@@ -634,11 +1136,9 @@ async def _tool_trigger_build(client, args):
 
 async def _tool_stop_build(client, args):
     """Stop a running build"""
-    job_name = args.get("job_name")
-    build_number = args.get("build_number")
-
-    if not job_name or build_number is None:
-        raise ValueError("Missing required arguments: job_name and build_number")
+    # Input validation (Quick Win #4)
+    job_name = validate_job_name(args.get("job_name"))
+    build_number = validate_build_number(args.get("build_number"))
 
     client.stop_build(job_name, build_number)
 
@@ -653,9 +1153,26 @@ async def _tool_stop_build(client, args):
 # Job Information
 
 async def _tool_list_jobs(client, args):
-    """List all Jenkins jobs with optional filtering"""
-    jobs = client.get_jobs()
+    """List all Jenkins jobs with optional filtering and caching"""
     filter_text = args.get("filter", "").strip()
+    use_cache = args.get("use_cache", True)  # cache control
+
+    # Try cache first (if enabled)
+    cache_key = f"jobs_list:{filter_text or 'all'}"
+    if use_cache:
+        cache_manager = get_cache_manager()
+        cached_jobs = await cache_manager.get(cache_key)
+        if cached_jobs is not None:
+            logger.debug(f"Using cached job list ({len(cached_jobs)} jobs)")
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"Jenkins Jobs (cached) ({len(cached_jobs)} total):\n\n{json.dumps(cached_jobs, indent=2)}"
+                )
+            ]
+
+    # Fetch from Jenkins
+    jobs = client.get_jobs()
 
     # Apply filter if provided
     if filter_text:
@@ -674,6 +1191,10 @@ async def _tool_list_jobs(client, args):
         for job in jobs
     ]
 
+    # Cache the result
+    if use_cache:
+        await cache_manager.set(cache_key, jobs_info, ttl_seconds=30)
+
     # Build response message
     if filter_text:
         message = f"Jenkins Jobs matching '{filter_text}' ({len(jobs_info)} found):\n\n{json.dumps(jobs_info, indent=2)}"
@@ -690,10 +1211,19 @@ async def _tool_list_jobs(client, args):
 
 async def _tool_get_job_details(client, args):
     """Get detailed job information"""
-    job_name = args.get("job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
 
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    # Configurable number of recent builds to fetch (Critical Issue #3)
+    max_recent_builds = args.get("max_recent_builds", 3)
+    try:
+        max_recent_builds = int(max_recent_builds)
+        if max_recent_builds < 0:
+            max_recent_builds = 0
+        elif max_recent_builds > 10:
+            max_recent_builds = 10  # Cap at 10 to prevent excessive API calls
+    except (ValueError, TypeError):
+        max_recent_builds = 3  # Default to 3
 
     job_info = client.get_job_info(job_name)
 
@@ -707,10 +1237,14 @@ async def _tool_get_job_details(client, args):
         "lastFailedBuild": job_info.get("lastFailedBuild", {}),
     }
 
-    # Add recent builds
-    if "builds" in job_info:
+    # Add recent builds (optimized to reduce API calls)
+    if max_recent_builds > 0 and "builds" in job_info:
         recent_builds = []
-        for build in job_info["builds"][:5]:
+        builds_to_fetch = job_info["builds"][:max_recent_builds]
+
+        logger.info(f"Fetching {len(builds_to_fetch)} recent builds for '{job_name}'")
+
+        for build in builds_to_fetch:
             try:
                 build_info = client.get_build_info(job_name, build["number"])
                 recent_builds.append({
@@ -723,6 +1257,7 @@ async def _tool_get_job_details(client, args):
                 logger.warning(f"Could not fetch build {build['number']}: {e}")
 
         details["recentBuilds"] = recent_builds
+        details["recentBuildsCount"] = len(recent_builds)
 
     # Notify of resource changes
     try:
@@ -742,11 +1277,9 @@ async def _tool_get_job_details(client, args):
 
 async def _tool_get_build_info(client, args):
     """Get build information"""
-    job_name = args.get("job_name")
-    build_number = args.get("build_number")
-
-    if not job_name or build_number is None:
-        raise ValueError("Missing required arguments: job_name and build_number")
+    # Input validation (Quick Win #4)
+    job_name = validate_job_name(args.get("job_name"))
+    build_number = validate_build_number(args.get("build_number"))
 
     build_info = client.get_build_info(job_name, build_number)
 
@@ -779,33 +1312,78 @@ async def _tool_get_build_info(client, args):
 
 
 async def _tool_get_build_console(client, args):
-    """Get build console output"""
-    job_name = args.get("job_name")
-    build_number = args.get("build_number")
+    """Get build console output with improved truncation (High Priority Issue #5)"""
+    # Input validation (Quick Win #4)
+    job_name = validate_job_name(args.get("job_name"))
+    build_number = validate_build_number(args.get("build_number"))
 
-    if not job_name or build_number is None:
-        raise ValueError("Missing required arguments: job_name and build_number")
+    # Get configurable parameters with defaults from settings
+    settings = get_settings()
+    max_lines = args.get("max_lines", settings.console_max_lines)
+    tail_only = args.get("tail_only", False)
 
+    # Validate max_lines
+    try:
+        max_lines = int(max_lines)
+        if max_lines < 10:
+            max_lines = 10
+        elif max_lines > 10000:
+            max_lines = 10000
+    except (ValueError, TypeError):
+        max_lines = settings.console_max_lines
+
+    # Validate tail_only
+    if not isinstance(tail_only, bool):
+        tail_only = str(tail_only).lower() in ('true', '1', 'yes')
+
+    # Get console output
     console_output = client.get_build_console_output(job_name, build_number)
 
-    # Limit output size
-    max_length = 10000
-    if len(console_output) > max_length:
-        console_output = console_output[:max_length] + "\n... (output truncated)"
+    # Split into lines for better handling
+    all_lines = console_output.split('\n')
+    total_lines = len(all_lines)
+
+    # Determine what to show
+    prefix = ""
+    if total_lines <= max_lines:
+        # No truncation needed
+        output_lines = all_lines
+        prefix = f"[Complete output: {total_lines} lines]\n\n"
+    elif tail_only:
+        # Show last N lines
+        output_lines = all_lines[-max_lines:]
+        truncated_lines = total_lines - max_lines
+        prefix = f"[Showing last {max_lines} of {total_lines} lines - {truncated_lines} earlier lines omitted]\n\n"
+    else:
+        # Show first N lines
+        output_lines = all_lines[:max_lines]
+        truncated_lines = total_lines - max_lines
+        prefix = f"[Showing first {max_lines} of {total_lines} lines - {truncated_lines} later lines truncated]\n\n"
+
+    # Reconstruct output
+    final_output = '\n'.join(output_lines)
+
+    # Add helpful note if truncated
+    if total_lines > max_lines:
+        if tail_only:
+            suffix = f"\n\n💡 Tip: Use max_lines parameter to see more lines (current: {max_lines}, max: 10000)"
+        else:
+            suffix = f"\n\n💡 Tip: Set tail_only=true to see last {max_lines} lines, or increase max_lines (current: {max_lines}, max: 10000)"
+    else:
+        suffix = ""
 
     return [
         types.TextContent(
             type="text",
-            text=f"Console output for {job_name} #{build_number}:\n\n```\n{console_output}\n```"
+            text=f"{prefix}Console output for {job_name} #{build_number}:\n\n```\n{final_output}\n```{suffix}"
         )
     ]
 
 
 async def _tool_get_last_build_number(client, args):
     """Get last build number"""
-    job_name = args.get("job_name")
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
 
     num = client.get_last_build_number(job_name)
     return [types.TextContent(type="text", text=f"Last build number for '{job_name}': {num}")]
@@ -813,9 +1391,8 @@ async def _tool_get_last_build_number(client, args):
 
 async def _tool_get_last_build_timestamp(client, args):
     """Get last build timestamp"""
-    job_name = args.get("job_name")
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
 
     ts = client.get_last_build_timestamp(job_name)
     return [types.TextContent(type="text", text=f"Last build timestamp for '{job_name}': {ts}")]
@@ -825,11 +1402,9 @@ async def _tool_get_last_build_timestamp(client, args):
 
 async def _tool_create_job(client, args):
     """Create a new job"""
-    job_name = args.get("job_name")
-    config_xml = args.get("config_xml")
-
-    if not job_name or not config_xml:
-        raise ValueError("Missing required arguments: job_name and config_xml")
+    # Input validation (Quick Win #4)
+    job_name = validate_job_name(args.get("job_name"))
+    config_xml = validate_config_xml(args.get("config_xml"))
 
     client.create_job(job_name, config_xml)
     return [types.TextContent(type="text", text=f"Successfully created job '{job_name}'")]
@@ -837,11 +1412,9 @@ async def _tool_create_job(client, args):
 
 async def _tool_create_job_from_copy(client, args):
     """Create job from copy"""
-    new_job_name = args.get("new_job_name")
-    source_job_name = args.get("source_job_name")
-
-    if not new_job_name or not source_job_name:
-        raise ValueError("Missing required arguments: new_job_name and source_job_name")
+    # Input validation
+    new_job_name = validate_job_name(args.get("new_job_name"))
+    source_job_name = validate_job_name(args.get("source_job_name"))
 
     client.create_job_from_copy(new_job_name, source_job_name)
     return [types.TextContent(type="text", text=f"Successfully created job '{new_job_name}' from '{source_job_name}'")]
@@ -849,12 +1422,15 @@ async def _tool_create_job_from_copy(client, args):
 
 async def _tool_create_job_from_data(client, args):
     """Create job from data"""
-    job_name = args.get("job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
     config_data = args.get("config_data")
     root_tag = args.get("root_tag", "project")
 
-    if not job_name or config_data is None:
-        raise ValueError("Missing required arguments: job_name and config_data")
+    if config_data is None:
+        raise ValueError("Missing required argument: config_data")
+    if not isinstance(config_data, dict):
+        raise ValueError(f"config_data must be a dictionary, got {type(config_data).__name__}")
 
     client.create_job_from_dict(job_name, config_data, root_tag)
     return [types.TextContent(type="text", text=f"Successfully created job '{job_name}' from data")]
@@ -862,9 +1438,8 @@ async def _tool_create_job_from_data(client, args):
 
 async def _tool_delete_job(client, args):
     """Delete a job"""
-    job_name = args.get("job_name")
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
 
     client.delete_job(job_name)
     return [types.TextContent(type="text", text=f"Successfully deleted job '{job_name}'")]
@@ -872,9 +1447,8 @@ async def _tool_delete_job(client, args):
 
 async def _tool_enable_job(client, args):
     """Enable a job"""
-    job_name = args.get("job_name")
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
 
     client.enable_job(job_name)
     return [types.TextContent(type="text", text=f"Successfully enabled job '{job_name}'")]
@@ -882,9 +1456,8 @@ async def _tool_enable_job(client, args):
 
 async def _tool_disable_job(client, args):
     """Disable a job"""
-    job_name = args.get("job_name")
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
 
     client.disable_job(job_name)
     return [types.TextContent(type="text", text=f"Successfully disabled job '{job_name}'")]
@@ -892,11 +1465,9 @@ async def _tool_disable_job(client, args):
 
 async def _tool_rename_job(client, args):
     """Rename a job"""
-    job_name = args.get("job_name")
-    new_name = args.get("new_name")
-
-    if not job_name or not new_name:
-        raise ValueError("Missing required arguments: job_name and new_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
+    new_name = validate_job_name(args.get("new_name"))
 
     client.rename_job(job_name, new_name)
     return [types.TextContent(type="text", text=f"Successfully renamed job '{job_name}' to '{new_name}'")]
@@ -906,9 +1477,8 @@ async def _tool_rename_job(client, args):
 
 async def _tool_get_job_config(client, args):
     """Get job configuration"""
-    job_name = args.get("job_name")
-    if not job_name:
-        raise ValueError("Missing required argument: job_name")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
 
     config = client.get_job_config(job_name)
     return [types.TextContent(type="text", text=config)]
@@ -916,11 +1486,9 @@ async def _tool_get_job_config(client, args):
 
 async def _tool_update_job_config(client, args):
     """Update job configuration"""
-    job_name = args.get("job_name")
-    config_xml = args.get("config_xml")
-
-    if not job_name or not config_xml:
-        raise ValueError("Missing required arguments: job_name and config_xml")
+    # Input validation
+    job_name = validate_job_name(args.get("job_name"))
+    config_xml = validate_config_xml(args.get("config_xml"))
 
     client.update_job_config(job_name, config_xml)
     return [types.TextContent(type="text", text=f"Successfully updated config for job '{job_name}'")]
@@ -978,10 +1546,13 @@ async def _tool_list_nodes(client, args):
 
 async def _tool_get_node_info(client, args):
     """Get node information"""
+    # Input validation
     node_name = args.get("node_name")
-
     if not node_name:
         raise ValueError("Missing required argument: node_name")
+    if not isinstance(node_name, str):
+        raise ValueError(f"node_name must be a string, got {type(node_name).__name__}")
+    node_name = node_name.strip()
 
     node_info = client.get_node_info(node_name)
 
@@ -1002,6 +1573,342 @@ async def _tool_get_node_info(client, args):
     ]
 
 
+async def _tool_get_cache_stats(client, args):
+    """Get cache statistics"""
+    cache_manager = get_cache_manager()
+    stats = cache_manager.get_stats()
+    cache_info = await cache_manager.get_cache_info()
+
+    report = f"""
+📊 Cache Statistics
+
+═══════════════════════════════════════
+OVERVIEW
+═══════════════════════════════════════
+Cache Size:      {stats['size']} entries
+Total Requests:  {stats['total_requests']}
+Cache Hits:      {stats['hits']}
+Cache Misses:    {stats['misses']}
+Hit Rate:        {stats['hit_rate_percent']}%
+Evictions:       {stats['evictions']}
+
+═══════════════════════════════════════
+CACHED ENTRIES
+═══════════════════════════════════════
+"""
+
+    for entry in cache_info['entries']:
+        status = "✅ Valid" if not entry['is_expired'] else "❌ Expired"
+        report += f"\n{entry['key']}\n"
+        report += f"  Status: {status}\n"
+        report += f"  Age: {entry['age_seconds']}s\n"
+        report += f"  TTL: {entry['ttl_seconds']}s\n"
+        report += f"  Expires in: {entry['expires_in_seconds']}s\n"
+
+    return [types.TextContent(type="text", text=report.strip())]
+
+
+async def _tool_clear_cache(client, args):
+    """Clear all cached data"""
+    cache_manager = get_cache_manager()
+    cleared = await cache_manager.clear()
+
+    return [types.TextContent(
+        type="text",
+        text=f"✅ Cache cleared: {cleared} entries removed"
+    )]
+
+
+# Health Check Tool (Quick Win #1)
+
+async def _tool_health_check(client, args):
+    """
+    Check Jenkins server health and connection status.
+    Provides detailed diagnostics for troubleshooting.
+    """
+    checks = {
+        "server_reachable": False,
+        "authentication_valid": False,
+        "api_responsive": False,
+        "server_version": None,
+        "server_url": get_settings().url,
+        "username": get_settings().username,
+        "response_time_ms": None,
+        "timestamp": None
+    }
+
+    status_emoji = "❌"
+    status_text = "Unhealthy"
+    error_details = None
+
+    try:
+        import datetime
+        start_time = time.time()
+        checks["timestamp"] = datetime.datetime.now().isoformat()
+
+        # Test 1: Basic connectivity
+        try:
+            # Try to get user info (tests auth + connectivity)
+            user_info = client.get_whoami()
+            checks["server_reachable"] = True
+            checks["authentication_valid"] = True
+
+            # Get version info
+            try:
+                version = client.get_version()
+                checks["server_version"] = version
+                checks["api_responsive"] = True
+            except Exception as ve:
+                logger.warning(f"Could not get version: {ve}")
+                checks["api_responsive"] = False
+
+            # Calculate response time
+            elapsed_ms = (time.time() - start_time) * 1000
+            checks["response_time_ms"] = round(elapsed_ms, 2)
+
+            # Determine overall status
+            if checks["api_responsive"]:
+                status_emoji = "✅"
+                status_text = "Healthy"
+                if elapsed_ms > 2000:
+                    status_text = "Healthy (Slow)"
+                    status_emoji = "⚠️"
+            elif checks["authentication_valid"]:
+                status_emoji = "⚠️"
+                status_text = "Partially Healthy (API issues)"
+
+        except Exception as conn_error:
+            error_details = str(conn_error)
+            error_type = type(conn_error).__name__
+
+            # Classify the error
+            if 'timeout' in error_details.lower():
+                status_text = "Timeout - Server not responding"
+                checks["server_reachable"] = False
+            elif '401' in error_details or 'unauthorized' in error_details.lower():
+                status_text = "Authentication Failed"
+                checks["server_reachable"] = True
+                checks["authentication_valid"] = False
+            elif 'connection' in error_details.lower():
+                status_text = "Connection Failed - Server unreachable"
+                checks["server_reachable"] = False
+            else:
+                status_text = f"Error: {error_type}"
+
+    except Exception as e:
+        error_details = str(e)
+        status_text = f"Health check failed: {type(e).__name__}"
+        logger.error(f"Health check error: {e}", exc_info=True)
+
+    # Build detailed report
+    report = f"""
+{status_emoji} Jenkins Health Check: {status_text}
+
+═══════════════════════════════════════
+CONNECTION STATUS
+═══════════════════════════════════════
+Server URL:          {checks['server_url']}
+Username:            {checks['username']}
+Server Reachable:    {'✅ Yes' if checks['server_reachable'] else '❌ No'}
+Authentication:      {'✅ Valid' if checks['authentication_valid'] else '❌ Failed'}
+API Responsive:      {'✅ Yes' if checks['api_responsive'] else '❌ No'}
+
+═══════════════════════════════════════
+SERVER DETAILS
+═══════════════════════════════════════
+Jenkins Version:     {checks['server_version'] or 'Unknown'}
+Response Time:       {checks['response_time_ms']}ms
+Checked At:          {checks['timestamp']}
+"""
+
+    if error_details:
+        report += f"""
+═══════════════════════════════════════
+ERROR DETAILS
+═══════════════════════════════════════
+{error_details}
+"""
+
+    # Add troubleshooting tips if unhealthy
+    if status_emoji == "❌":
+        report += """
+═══════════════════════════════════════
+TROUBLESHOOTING STEPS
+═══════════════════════════════════════
+"""
+        if not checks['server_reachable']:
+            report += """
+🔌 Server Not Reachable:
+  1. Verify Jenkins is running
+  2. Check the URL is correct
+  3. Test with: curl {url}/api/json
+  4. Check firewall/VPN settings
+  5. Verify network connectivity
+""".format(url=checks['server_url'])
+
+        if checks['server_reachable'] and not checks['authentication_valid']:
+            report += """
+🔐 Authentication Failed:
+  1. Verify username is correct
+  2. Check API token is valid
+  3. Generate new token:
+     - Jenkins → Your Name → Configure
+     - API Token section → Add new Token
+  4. Update .env file with new token
+"""
+
+        if checks['server_reachable'] and checks['authentication_valid'] and not checks['api_responsive']:
+            report += """
+⚠️ API Not Responsive:
+  1. Check Jenkins server logs
+  2. Verify Jenkins is not overloaded
+  3. Check for Jenkins plugin issues
+  4. Restart Jenkins if needed
+"""
+
+    report += "\n💡 Tip: Run this health-check regularly to monitor your Jenkins connection."
+
+    return [types.TextContent(type="text", text=report.strip())]
+
+
+async def _tool_get_metrics(client, args):
+    """Get usage metrics"""
+    tool_name = args.get("tool_name")
+
+    metrics_collector = get_metrics_collector()
+
+    if tool_name:
+        # Get specific tool metrics
+        stats = await metrics_collector.get_tool_stats(tool_name)
+
+        report = f"""
+📊 Metrics for '{tool_name}'
+
+{json.dumps(stats, indent=2)}
+"""
+    else:
+        # Get overall summary
+        summary = await metrics_collector.get_summary()
+        tool_stats = await metrics_collector.get_tool_stats()
+
+        report = f"""
+📊 Jenkins MCP Server Metrics
+
+═══════════════════════════════════════
+SUMMARY
+═══════════════════════════════════════
+Uptime:              {summary['uptime_human']}
+Total Executions:    {summary['total_executions']}
+Successful:          {summary['successful_executions']}
+Failed:              {summary['failed_executions']}
+Success Rate:        {summary['success_rate_percent']}%
+Avg Execution Time:  {summary['avg_execution_time_ms']}ms
+Unique Tools Used:   {summary['unique_tools_used']}
+Most Used Tool:      {summary['most_used_tool']}
+Slowest Tool:        {summary['slowest_tool']}
+
+═══════════════════════════════════════
+PER-TOOL STATISTICS
+═══════════════════════════════════════
+{json.dumps(tool_stats, indent=2)}
+"""
+
+    return [types.TextContent(type="text", text=report.strip())]
+
+
+async def _tool_configure_webhook(client, args):
+    """Configure webhook for Jenkins job"""
+    job_name = validate_job_name(args.get("job_name"))
+    webhook_url = args.get("webhook_url")
+    events = args.get("events", [])
+
+    if not webhook_url:
+        raise ValueError("webhook_url is required")
+
+    if not events:
+        raise ValueError("At least one event must be specified")
+
+    # Get current job config
+    config_xml = client.get_job_config(job_name)
+
+    # Add webhook notification (this is simplified - actual implementation
+    # depends on Jenkins plugin configuration)
+    import xml.etree.ElementTree as ET
+
+    try:
+        root = ET.fromstring(config_xml)
+
+        # Add or update properties section
+        properties = root.find('properties')
+        if properties is None:
+            properties = ET.SubElement(root, 'properties')
+
+        # Add webhook trigger configuration
+        # (Actual XML structure depends on the webhook plugin used)
+        webhook_config = f"""
+        <!-- Webhook Configuration -->
+        <!-- Events: {', '.join(events)} -->
+        <!-- URL: {webhook_url} -->
+        """
+
+        # Note: This is a placeholder. Real implementation would need
+        # to configure the actual webhook plugin XML structure
+
+        updated_xml = ET.tostring(root, encoding='unicode')
+
+        # Update job
+        client.update_job_config(job_name, updated_xml)
+
+        return [types.TextContent(
+            type="text",
+            text=f"✅ Webhook configured for '{job_name}'\n\n"
+                 f"URL: {webhook_url}\n"
+                 f"Events: {', '.join(events)}\n\n"
+                 f"⚠️ Note: Requires Generic Webhook Trigger plugin in Jenkins"
+        )]
+
+    except Exception as e:
+        return [types.TextContent(
+            type="text",
+            text=f"❌ Failed to configure webhook: {str(e)}\n\n"
+                 f"Make sure the Generic Webhook Trigger plugin is installed in Jenkins."
+        )]
+
+
+# Note: MCP protocol may not support streaming yet. This is prepared for future use.
+# Example: For trigger-multiple-builds
+async def _tool_trigger_multiple_builds_with_progress(client, args):
+    """Trigger builds with progress updates"""
+    job_names = args.get("job_names", [])
+
+    # Initial message
+    yield types.TextContent(
+        type="text",
+        text=f"🚀 Starting batch build trigger for {len(job_names)} jobs..."
+    )
+
+    results = []
+    for i, job_name in enumerate(job_names, 1):
+        # Progress update
+        yield types.TextContent(
+            type="text",
+            text=f"⏳ [{i}/{len(job_names)}] Triggering {job_name}..."
+        )
+
+        try:
+            result = client.build_job(job_name)
+            results.append({"job": job_name, "status": "success"})
+        except Exception as e:
+            results.append({"job": job_name, "status": "failed", "error": str(e)})
+
+    # Final summary
+    successful = len([r for r in results if r["status"] == "success"])
+    yield types.TextContent(
+        type="text",
+        text=f"✅ Complete: {successful}/{len(job_names)} builds triggered successfully"
+    )
+
+
 # ==================== Main Server Entry Point ====================
 
 async def main():
@@ -1034,4 +1941,4 @@ async def main():
         logger.info("Server stopped by user")
     except Exception as e:
         logger.error(f"Server error: {e}", exc_info=True)
-        sys.exit(1)
+        sys.exit(1)