pcp-mcp 0.1.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

pcp_mcp/tools/system.py

@@ -3,13 +3,24 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Annotated, Literal
+from typing import TYPE_CHECKING, Annotated, Literal, Optional
 
 from fastmcp import Context
+from mcp.types import ToolAnnotations
 from pydantic import Field
 
-from pcp_mcp.context import get_client
-from pcp_mcp.models import ProcessTopResult, SystemSnapshot
+from pcp_mcp.context import get_client_for_host
+from pcp_mcp.icons import (
+    ICON_DIAGNOSE,
+    ICON_HEALTH,
+    ICON_PROCESS,
+    ICON_SYSTEM,
+    TAGS_DIAGNOSE,
+    TAGS_HEALTH,
+    TAGS_PROCESS,
+    TAGS_SYSTEM,
+)
+from pcp_mcp.models import DiagnosisResult, ProcessTopResult, SystemSnapshot
 from pcp_mcp.utils.builders import (
     assess_processes,
     build_cpu_metrics,
@@ -25,6 +36,8 @@ from pcp_mcp.utils.extractors import get_scalar_value
 if TYPE_CHECKING:
     from fastmcp import FastMCP
 
+TOOL_ANNOTATIONS = ToolAnnotations(readOnlyHint=True, openWorldHint=True)
+
 SNAPSHOT_METRICS = {
     "cpu": [
         "kernel.all.cpu.user",
@@ -86,17 +99,75 @@ PROCESS_METRICS = {
 }
 
 
+async def _fetch_system_snapshot(
+    ctx: Context,
+    categories: list[str],
+    sample_interval: float,
+    host: str | None,
+) -> SystemSnapshot:
+    """Core logic for fetching a system snapshot."""
+    from pcp_mcp.errors import handle_pcp_error
+
+    all_metrics: list[str] = []
+    for cat in categories:
+        if cat in SNAPSHOT_METRICS:
+            all_metrics.extend(SNAPSHOT_METRICS[cat])
+
+    async def report_progress(current: float, total: float, message: str) -> None:
+        await ctx.report_progress(current, total, message)
+
+    async with get_client_for_host(ctx, host) as client:
+        try:
+            data = await client.fetch_with_rates(
+                all_metrics,
+                COUNTER_METRICS,
+                sample_interval,
+                progress_callback=report_progress,
+            )
+        except Exception as e:
+            raise handle_pcp_error(e, "fetching system snapshot") from e
+
+        await ctx.report_progress(95, 100, "Building snapshot...")
+
+        snapshot = SystemSnapshot(
+            timestamp=datetime.now(timezone.utc).isoformat(),
+            hostname=client.target_host,
+        )
+
+        if "cpu" in categories:
+            snapshot.cpu = build_cpu_metrics(data)
+        if "memory" in categories:
+            snapshot.memory = build_memory_metrics(data)
+        if "load" in categories:
+            snapshot.load = build_load_metrics(data)
+        if "disk" in categories:
+            snapshot.disk = build_disk_metrics(data)
+        if "network" in categories:
+            snapshot.network = build_network_metrics(data)
+
+        await ctx.report_progress(100, 100, "Complete")
+        return snapshot
+
+
 def register_system_tools(mcp: FastMCP) -> None:
     """Register system health tools with the MCP server."""
 
-    @mcp.tool()
+    @mcp.tool(
+        annotations=TOOL_ANNOTATIONS,
+        output_schema=SystemSnapshot.model_json_schema(),
+        icons=[ICON_SYSTEM],
+        tags=TAGS_SYSTEM,
+    )
     async def get_system_snapshot(
         ctx: Context,
         categories: Annotated[
-            list[str] | None,
+            Optional[list[str]],
             Field(
                 default=None,
-                description="Categories to include: cpu, memory, disk, network, load",
+                description=(
+                    "Categories to include: cpu, memory, disk, network, load. "
+                    "Defaults to all five if not specified."
+                ),
             ),
         ] = None,
         sample_interval: Annotated[
@@ -108,53 +179,62 @@ def register_system_tools(mcp: FastMCP) -> None:
                 description="Seconds between samples for rate calculation",
             ),
         ] = 1.0,
+        host: Annotated[
+            Optional[str],
+            Field(description="Target pmcd host to query (default: server's configured target)"),
+        ] = None,
     ) -> SystemSnapshot:
         """Get a point-in-time system health overview.
 
         Returns CPU, memory, disk I/O, network I/O, and load metrics in a single
         call. For rate metrics (CPU %, disk I/O, network throughput), takes two
         samples to calculate per-second rates.
-        """
-        from pcp_mcp.errors import handle_pcp_error
 
-        client = get_client(ctx)
+        Use this tool FIRST for system troubleshooting. It automatically handles
+        counter-to-rate conversion. Do NOT use query_metrics() for CPU, disk, or
+        network counters - those return raw cumulative values since boot.
 
+        Examples:
+            get_system_snapshot() - Quick health check (all categories)
+            get_system_snapshot(categories=["cpu", "memory"]) - CPU and memory only
+            get_system_snapshot(categories=["cpu", "load"]) - CPU and load averages
+            get_system_snapshot(categories=["disk", "network"]) - I/O analysis
+            get_system_snapshot(host="web1.example.com") - Query remote host
+        """
         if categories is None:
             categories = ["cpu", "memory", "disk", "network", "load"]
+        return await _fetch_system_snapshot(ctx, categories, sample_interval, host)
 
-        all_metrics: list[str] = []
-        for cat in categories:
-            if cat in SNAPSHOT_METRICS:
-                all_metrics.extend(SNAPSHOT_METRICS[cat])
-
-        try:
-            data = await client.fetch_with_rates(
-                all_metrics,
-                COUNTER_METRICS,
-                sample_interval,
-            )
-        except Exception as e:
-            raise handle_pcp_error(e, "fetching system snapshot") from e
-
-        snapshot = SystemSnapshot(
-            timestamp=datetime.now(timezone.utc).isoformat(),
-            hostname=client.target_host,
-        )
+    @mcp.tool(
+        annotations=TOOL_ANNOTATIONS,
+        output_schema=SystemSnapshot.model_json_schema(),
+        icons=[ICON_HEALTH],
+        tags=TAGS_HEALTH,
+    )
+    async def quick_health(
+        ctx: Context,
+        host: Annotated[
+            Optional[str],
+            Field(description="Target pmcd host to query (default: server's configured target)"),
+        ] = None,
+    ) -> SystemSnapshot:
+        """Fast system health check returning only CPU and memory metrics.
 
-        if "cpu" in categories:
-            snapshot.cpu = build_cpu_metrics(data)
-        if "memory" in categories:
-            snapshot.memory = build_memory_metrics(data)
-        if "load" in categories:
-            snapshot.load = build_load_metrics(data)
-        if "disk" in categories:
-            snapshot.disk = build_disk_metrics(data)
-        if "network" in categories:
-            snapshot.network = build_network_metrics(data)
+        Use this for rapid status checks when you don't need disk/network/load
+        details. Uses a shorter sample interval (0.5s) for faster results.
 
-        return snapshot
+        Examples:
+            quick_health() - Fast health check on default host
+            quick_health(host="web1.example.com") - Fast check on remote host
+        """
+        return await _fetch_system_snapshot(ctx, ["cpu", "memory"], 0.5, host)
 
-    @mcp.tool()
+    @mcp.tool(
+        annotations=TOOL_ANNOTATIONS,
+        output_schema=ProcessTopResult.model_json_schema(),
+        icons=[ICON_PROCESS],
+        tags=TAGS_PROCESS,
+    )
     async def get_process_top(
         ctx: Context,
         sort_by: Annotated[
@@ -174,14 +254,22 @@ def register_system_tools(mcp: FastMCP) -> None:
                 description="Seconds to sample for CPU/IO rates",
             ),
         ] = 1.0,
+        host: Annotated[
+            Optional[str],
+            Field(description="Target pmcd host to query (default: server's configured target)"),
+        ] = None,
     ) -> ProcessTopResult:
         """Get top processes by resource consumption.
 
         For CPU and I/O, takes two samples to calculate rates. Memory is instantaneous.
         Returns the top N processes sorted by the requested resource.
-        """
-        client = get_client(ctx)
 
+        Examples:
+            get_process_top() - Top 10 by CPU (default)
+            get_process_top(sort_by="memory", limit=20) - Top 20 memory consumers
+            get_process_top(sort_by="io", sample_interval=2.0) - Top I/O with longer sample
+            get_process_top(host="db1.example.com") - Query remote host
+        """
         all_metrics = (
             PROCESS_METRICS["info"] + PROCESS_METRICS["memory"] + PROCESS_METRICS.get(sort_by, [])
         )
@@ -202,28 +290,192 @@ def register_system_tools(mcp: FastMCP) -> None:
 
         from pcp_mcp.errors import handle_pcp_error
 
+        async def report_progress(current: float, total: float, message: str) -> None:
+            await ctx.report_progress(current, total, message)
+
+        async with get_client_for_host(ctx, host) as client:
+            try:
+                proc_data = await client.fetch_with_rates(
+                    all_metrics, counter_metrics, sample_interval, progress_callback=report_progress
+                )
+                sys_data = await client.fetch(system_metrics)
+            except Exception as e:
+                raise handle_pcp_error(e, "fetching process data") from e
+
+            await ctx.report_progress(92, 100, "Processing results...")
+
+            ncpu = get_scalar_value(sys_data, "hinv.ncpu", 1)
+            total_mem = get_scalar_value(sys_data, "mem.physmem", 1) * 1024
+
+            processes = build_process_list(proc_data, sort_by, total_mem, ncpu)
+            processes.sort(key=lambda p: get_sort_key(p, sort_by), reverse=True)
+            processes = processes[:limit]
+
+            assessment = assess_processes(processes, sort_by, ncpu)
+
+            await ctx.report_progress(100, 100, "Complete")
+            return ProcessTopResult(
+                timestamp=datetime.now(timezone.utc).isoformat(),
+                hostname=client.target_host,
+                sort_by=sort_by,
+                sample_interval=sample_interval,
+                processes=processes,
+                total_memory_bytes=int(total_mem),
+                ncpu=ncpu,
+                assessment=assessment,
+            )
+
+    @mcp.tool(
+        annotations=TOOL_ANNOTATIONS,
+        output_schema=DiagnosisResult.model_json_schema(),
+        icons=[ICON_DIAGNOSE],
+        tags=TAGS_DIAGNOSE,
+    )
+    async def smart_diagnose(
+        ctx: Context,
+        host: Annotated[
+            Optional[str],
+            Field(description="Target pmcd host to query (default: server's configured target)"),
+        ] = None,
+    ) -> DiagnosisResult:
+        """Use LLM to analyze system metrics and provide diagnosis.
+
+        Collects a quick system snapshot (CPU, memory, load) and asks the
+        connected LLM to analyze the metrics and provide actionable insights.
+
+        This tool demonstrates FastMCP's LLM sampling capability, where the
+        MCP server can request LLM assistance for complex analysis tasks.
+
+        Examples:
+            smart_diagnose() - Analyze default host
+            smart_diagnose(host="db1.example.com") - Analyze remote host
+        """
+        from pcp_mcp.errors import handle_pcp_error
+
         try:
-            proc_data = await client.fetch_with_rates(all_metrics, counter_metrics, sample_interval)
-            sys_data = await client.fetch(system_metrics)
+            snapshot = await _fetch_system_snapshot(ctx, ["cpu", "memory", "load"], 0.5, host)
         except Exception as e:
-            raise handle_pcp_error(e, "fetching process data") from e
+            raise handle_pcp_error(e, "fetching metrics for diagnosis") from e
 
-        ncpu = get_scalar_value(sys_data, "hinv.ncpu", 1)
-        total_mem = get_scalar_value(sys_data, "mem.physmem", 1) * 1024
+        metrics_summary = _format_snapshot_for_llm(snapshot)
 
-        processes = build_process_list(proc_data, sort_by, total_mem, ncpu)
-        processes.sort(key=lambda p: get_sort_key(p, sort_by), reverse=True)
-        processes = processes[:limit]
+        system_prompt = (
+            "You are a system performance analyst. Analyze the metrics and provide:\n"
+            "1. A brief diagnosis (2-3 sentences)\n"
+            "2. A severity level: 'healthy', 'warning', or 'critical'\n"
+            "3. Up to 3 actionable recommendations\n\n"
+            "Be concise and focus on actionable insights."
+        )
 
-        assessment = assess_processes(processes, sort_by, ncpu)
+        try:
+            sampling_result = await ctx.sample(
+                messages=f"Analyze these system metrics:\n\n{metrics_summary}",
+                system_prompt=system_prompt,
+                max_tokens=500,
+                result_type=DiagnosisResult,
+            )
+            result = sampling_result.result
+            result.timestamp = snapshot.timestamp
+            result.hostname = snapshot.hostname
+            return result
+        except Exception:
+            return _build_fallback_diagnosis(snapshot)
 
-        return ProcessTopResult(
-            timestamp=datetime.now(timezone.utc).isoformat(),
-            hostname=client.target_host,
-            sort_by=sort_by,
-            sample_interval=sample_interval,
-            processes=processes,
-            total_memory_bytes=int(total_mem),
-            ncpu=ncpu,
-            assessment=assessment,
+
+def _format_snapshot_for_llm(snapshot: SystemSnapshot) -> str:
+    """Format a system snapshot as text for LLM analysis."""
+    lines = [f"Host: {snapshot.hostname}", f"Time: {snapshot.timestamp}", ""]
+
+    if snapshot.cpu:
+        lines.extend(
+            [
+                "CPU:",
+                f"  User: {snapshot.cpu.user_percent:.1f}%",
+                f"  System: {snapshot.cpu.system_percent:.1f}%",
+                f"  Idle: {snapshot.cpu.idle_percent:.1f}%",
+                f"  I/O Wait: {snapshot.cpu.iowait_percent:.1f}%",
+                f"  CPUs: {snapshot.cpu.ncpu}",
+                "",
+            ]
+        )
+
+    if snapshot.memory:
+        total_gb = snapshot.memory.total_bytes / (1024**3)
+        avail_gb = snapshot.memory.available_bytes / (1024**3)
+        lines.extend(
+            [
+                "Memory:",
+                f"  Total: {total_gb:.1f} GB",
+                f"  Available: {avail_gb:.1f} GB",
+                f"  Used: {snapshot.memory.used_percent:.1f}%",
+                f"  Swap Used: {snapshot.memory.swap_used_bytes / (1024**3):.1f} GB",
+                "",
+            ]
+        )
+
+    if snapshot.load:
+        lines.extend(
+            [
+                "Load:",
+                f"  1m/5m/15m: {snapshot.load.load_1m:.2f} / "
+                f"{snapshot.load.load_5m:.2f} / {snapshot.load.load_15m:.2f}",
+                f"  Runnable: {snapshot.load.runnable}",
+                f"  Total procs: {snapshot.load.nprocs}",
+            ]
         )
+
+    return "\n".join(lines)
+
+
+def _build_fallback_diagnosis(snapshot: SystemSnapshot) -> DiagnosisResult:
+    """Build a basic diagnosis when LLM sampling isn't available."""
+    issues: list[str] = []
+    recommendations: list[str] = []
+    severity = "healthy"
+
+    if snapshot.cpu:
+        cpu_busy = 100 - snapshot.cpu.idle_percent
+        if cpu_busy > 90:
+            issues.append(f"CPU is heavily loaded ({cpu_busy:.0f}% busy)")
+            recommendations.append("Identify high-CPU processes with get_process_top")
+            severity = "critical"
+        elif cpu_busy > 70:
+            issues.append(f"CPU moderately busy ({cpu_busy:.0f}%)")
+            severity = "warning" if severity == "healthy" else severity
+
+    if snapshot.memory:
+        if snapshot.memory.used_percent > 90:
+            issues.append(f"Memory pressure high ({snapshot.memory.used_percent:.0f}% used)")
+            recommendations.append("Check for memory leaks or increase RAM")
+            severity = "critical"
+        elif snapshot.memory.used_percent > 75:
+            issues.append(f"Memory usage elevated ({snapshot.memory.used_percent:.0f}%)")
+            severity = "warning" if severity == "healthy" else severity
+
+    if snapshot.load and snapshot.cpu:
+        load_per_cpu = snapshot.load.load_1m / snapshot.cpu.ncpu
+        if load_per_cpu > 2.0:
+            issues.append(
+                f"Load very high ({snapshot.load.load_1m:.1f} for {snapshot.cpu.ncpu} CPUs)"
+            )
+            recommendations.append("Reduce concurrent workload or add capacity")
+            severity = "critical"
+        elif load_per_cpu > 1.0:
+            issues.append(f"Load elevated ({snapshot.load.load_1m:.1f})")
+            severity = "warning" if severity == "healthy" else severity
+
+    if not issues:
+        diagnosis = "System is operating normally. No issues detected."
+    else:
+        diagnosis = " ".join(issues)
+
+    if not recommendations:
+        recommendations = ["Continue monitoring"]
+
+    return DiagnosisResult(
+        timestamp=snapshot.timestamp,
+        hostname=snapshot.hostname,
+        diagnosis=diagnosis,
+        severity=severity,
+        recommendations=recommendations,
+    )

pcp_mcp/utils/__init__.py

@@ -2,7 +2,6 @@
 
 This package contains reusable utilities extracted to follow DRY principles:
 - extractors: Metric data extraction helpers
-- decorators: Error handling and other decorators
 - builders: Metric transformation and builder functions
 """
 
@@ -14,7 +13,6 @@ from pcp_mcp.utils.builders import (
     build_network_metrics,
     build_process_list,
 )
-from pcp_mcp.utils.decorators import handle_pcp_errors
 from pcp_mcp.utils.extractors import (
     extract_help_text,
     extract_timestamp,
@@ -30,8 +28,6 @@ __all__ = [
     "sum_instances",
     "extract_help_text",
     "extract_timestamp",
-    # Decorators
-    "handle_pcp_errors",
     # Builders
     "build_cpu_metrics",
     "build_memory_metrics",

pcp_mcp/utils/extractors.py

@@ -51,10 +51,28 @@ def extract_timestamp(response: dict) -> float:
     return float(ts)
 
 
+def format_units(info: dict) -> str:
+    """Format PCP units into a human-readable string."""
+    units = info.get("units", "")
+    if units:
+        return units
+
+    parts = []
+    if info.get("units-space"):
+        parts.append(info["units-space"])
+    if info.get("units-time"):
+        parts.append(info["units-time"])
+    if info.get("units-count"):
+        parts.append(info["units-count"])
+
+    return " / ".join(parts) if parts else "none"
+
+
 __all__ = [
     "get_first_value",
     "get_scalar_value",
     "sum_instances",
     "extract_help_text",
     "extract_timestamp",
+    "format_units",
 ]

{pcp_mcp-0.1.0.dist-info → pcp_mcp-1.0.1.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: pcp-mcp
-Version: 0.1.0
+Version: 1.0.1
 Summary: MCP server for Performance Co-Pilot
 Keywords: mcp,pcp,performance-co-pilot,monitoring,model-context-protocol
 Author: Major Hayden
 Author-email: Major Hayden <major@mhtx.net>
 License-Expression: MIT
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: License :: OSI Approved :: MIT License
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: System :: Monitoring
 Classifier: Typing :: Typed
+Requires-Dist: cachetools>=5.0
 Requires-Dist: fastmcp>=2.0.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: pydantic-settings>=2.0.0
@@ -32,6 +33,14 @@ MCP server for [Performance Co-Pilot (PCP)](https://pcp.io/) metrics.
 
 Query system performance metrics via the Model Context Protocol - CPU, memory, disk I/O, network, processes, and more.
 
+📖 **[Full Documentation](https://major.github.io/pcp-mcp)** | 🚀 **[Getting Started](https://major.github.io/pcp-mcp/getting-started/)**
+
+[![CI](https://github.com/major/pcp-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/major/pcp-mcp/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/major/pcp-mcp/branch/main/graph/badge.svg)](https://codecov.io/gh/major/pcp-mcp)
+[![PyPI version](https://badge.fury.io/py/pcp-mcp.svg)](https://pypi.org/project/pcp-mcp/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 ## 🚀 Installation
 
 ```bash
@@ -47,15 +56,15 @@ uv add pcp-mcp
 ## 📋 Requirements
 
 - **Python**: 3.10+
-- **PCP**: Performance Co-Pilot with `pmproxy` running
+- **PCP**: Performance Co-Pilot with `pmcd` and `pmproxy` running
   ```bash
   # Fedora/RHEL/CentOS
   sudo dnf install pcp
-  sudo systemctl enable --now pmproxy
+  sudo systemctl enable --now pmcd pmproxy
   
   # Ubuntu/Debian
   sudo apt install pcp
-  sudo systemctl enable --now pmproxy
+  sudo systemctl enable --now pmcd pmproxy
   ```
 
 ## ⚙️ Configuration
@@ -68,9 +77,12 @@ Configure via environment variables:
 | `PCP_PORT` | pmproxy port | `44322` |
 | `PCP_TARGET_HOST` | Target pmcd host to monitor | `localhost` |
 | `PCP_USE_TLS` | Use HTTPS for pmproxy | `false` |
+| `PCP_TLS_VERIFY` | Verify TLS certificates | `true` |
+| `PCP_TLS_CA_BUNDLE` | Path to custom CA bundle | (optional) |
 | `PCP_TIMEOUT` | Request timeout (seconds) | `30` |
 | `PCP_USERNAME` | HTTP basic auth user | (optional) |
 | `PCP_PASSWORD` | HTTP basic auth password | (optional) |
+| `PCP_ALLOWED_HOSTS` | Hostspecs allowed via host param | (optional) |
 
 ## 🎯 Usage
 
@@ -163,9 +175,9 @@ For remote monitoring:
 
 Browse metrics via MCP resources:
 
-- `pcp://metrics` - List all available metrics (grouped by prefix)
-- `pcp://system/snapshot` - Latest system snapshot
-- `pcp://processes/top` - Top processes
+- `pcp://health` - Quick system health summary
+- `pcp://metrics/common` - Catalog of commonly used metrics
+- `pcp://namespaces` - Live-discovered metric namespaces
 
 ## 💡 Use Cases
 
@@ -191,9 +203,9 @@ Ask Claude to:
 ## 🏗️ Architecture
 
 ```
-┌─────────┐         ┌─────────┐         ┌─────────┐         ┌─────────┐
+┌─────────┐         ┌─────────┐          ┌─────────┐         ┌─────────┐
 │   LLM   │ ◄─MCP─► │ pcp-mcp │ ◄─HTTP─► │ pmproxy │ ◄─────► │  pmcd   │
-└─────────┘         └─────────┘         └─────────┘         └─────────┘
+└─────────┘         └─────────┘          └─────────┘         └─────────┘
                                          (REST API)          (metrics)
 ```
 

pcp_mcp-1.0.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+pcp_mcp/AGENTS.md,sha256=1jIoPBgrOKEX4kQiUN7SR0rD6Gsu4ZdNKOxJq9Su7FA,2473
+pcp_mcp/__init__.py,sha256=5SKlrOQTqKxcWRvmBwmeXJapTqKggal8L89UxxwHTaQ,1949
+pcp_mcp/client.py,sha256=ZGWGXYn77_hbZ81O0vxjXubY9eRpOZWs2cLxqLO3pf8,9188
+pcp_mcp/config.py,sha256=gm-Sp1y-f3ZGZQk_ercMuKCojG145Fu6UjrvjRQUnpg,3526
+pcp_mcp/context.py,sha256=5M6l72phsijPr96PXpZDm1rd_Uvo7mY_LuiLdeiW2SE,2801
+pcp_mcp/errors.py,sha256=sIes9OSNdYQeOmwjFknhfXXjBjOOzXmc94bbB-4b_tg,1598
+pcp_mcp/icons.py,sha256=ZTMU4iDR0369NPOsaAyDhu-MngtdkbDY_QZbA6BjwN0,1497
+pcp_mcp/middleware.py,sha256=oUSdaCHSy1gVkKyeC2J8ASfhJep-3KvY8GFYRFWUvJ0,2387
+pcp_mcp/models.py,sha256=ugU3a-4PY5cVstxt6XAHGqBqXUt95HVYLq7z7sQDkTA,6835
+pcp_mcp/prompts/__init__.py,sha256=x3QDidJFt2CeLmFZWGLs673m9L9NUi2IC4Me5A9nxw4,12586
+pcp_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pcp_mcp/resources/__init__.py,sha256=55Mm2ZCuyyQWWql9N8cLk6ld1pNj3Ezc416jgFX35dU,541
+pcp_mcp/resources/catalog.py,sha256=si1frqawgrxl2ENhFE9cMEzYmTk7VCzShbO5foUU5Ug,12560
+pcp_mcp/resources/health.py,sha256=cHnH2aRF4gdeo0AVUDi_qWqHocDSULhlsGpnkS-qobE,3925
+pcp_mcp/server.py,sha256=N_XknbUCoURd7JQsNO8Tl7i9sdQZetTTE5LFsRjZozs,5030
+pcp_mcp/tools/AGENTS.md,sha256=1yt_W-TYlGA0aWJYCM7D0i2D4899E6_kIhyoqP1np-g,1963
+pcp_mcp/tools/__init__.py,sha256=sXhOqqnUwzSf16QU6eS79LMvXJcv7jqSXQlrpQG4UV0,505
+pcp_mcp/tools/metrics.py,sha256=r-kiAAFaIZue1FEqQuSHdvxHrXnSYhY73oru2HlSOGI,6834
+pcp_mcp/tools/system.py,sha256=g1f5j1qztUNW_4SL1pwFufZ5ZxphAn2sC6Zt98MApLk,16845
+pcp_mcp/utils/__init__.py,sha256=tTbcqrCV9pBBm7N3MwEI37Lc0JM1CVbw_etw36ejRWc,884
+pcp_mcp/utils/builders.py,sha256=n13Ou6cb1-YToG-M31J8_jWajq8ioJx6tJTKnqaQiio,10293
+pcp_mcp/utils/extractors.py,sha256=fy6aCI23JuGt73oIDxwPW_K4B0fJkFCF1VxYkBst0Y4,2279
+pcp_mcp-1.0.1.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+pcp_mcp-1.0.1.dist-info/entry_points.txt,sha256=PhVo92EGoS05yEpHVRyKEsxKya_bWlPLodp-g4tr2Rg,42
+pcp_mcp-1.0.1.dist-info/METADATA,sha256=1b5nl2lT2GjZJRBJH8bkAAV6H8RPo26-F_uSdF8iyJo,6671
+pcp_mcp-1.0.1.dist-info/RECORD,,

pcp_mcp/utils/decorators.py

@@ -1,38 +0,0 @@
-"""Error handling decorators for MCP tools."""
-
-from __future__ import annotations
-
-from functools import wraps
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from typing import Any
-
-
-def handle_pcp_errors(operation: str) -> Callable:
-    """Decorator to convert PCP exceptions to ToolError.
-
-    Args:
-        operation: Description of the operation (e.g., "fetching metrics").
-
-    Returns:
-        Decorated async function that handles PCP errors.
-    """
-
-    def decorator(func: Callable) -> Callable:
-        @wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> Any:
-            from pcp_mcp.errors import handle_pcp_error
-
-            try:
-                return await func(*args, **kwargs)
-            except Exception as e:
-                raise handle_pcp_error(e, operation) from e
-
-        return wrapper
-
-    return decorator
-
-
-__all__ = ["handle_pcp_errors"]