devrev-Python-SDK 2.6.0__tar.gz → 2.7.0__tar.gz

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/Dockerfile

@@ -39,11 +39,11 @@ FROM python:3.11-slim AS runtime
 # Metadata labels
 LABEL maintainer="Matthew G. Monteleone <matthewm@augmentcode.com>" \
       description="DevRev MCP Server - A Model Context Protocol server for the DevRev platform" \
-      version="2.4.1" \
+      version="2.6.0" \
       org.opencontainers.image.source="https://github.com/mgmonteleone/py-dev-rev" \
       org.opencontainers.image.title="DevRev MCP Server" \
       org.opencontainers.image.description="Production-ready MCP server for DevRev API integration" \
-      org.opencontainers.image.version="2.4.1" \
+      org.opencontainers.image.version="2.6.0" \
       org.opencontainers.image.licenses="MIT"
 
 # Set environment variables for Python

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devrev-Python-SDK
-Version: 2.6.0
+Version: 2.7.0
 Summary: A modern, type-safe Python SDK for the DevRev API
 Project-URL: Homepage, https://github.com/mgmonteleone/py-dev-rev
 Project-URL: Documentation, https://github.com/mgmonteleone/py-dev-rev

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/docs/changelog.md

@@ -5,6 +5,20 @@ All notable changes to the DevRev Python SDK will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.7.0] - 2026-02-28
+
+### Added
+
+- **Server Version Discoverability**: AI agents can now discover the server's version, capabilities, and update status dynamically
+  - **Server Instructions**: `FastMCP` constructor includes `instructions` parameter with version info, delivered to agents on connection
+  - **`devrev_server_info` Tool**: Returns server version, uptime, Python version, platform, enabled capabilities, and checks PyPI for the latest published version
+  - **`devrev://server/info` Resource**: Static server metadata resource for agents preferring resource-based discovery
+  - **PyPI Version Check**: Runtime check against PyPI to determine if the server is running the latest version, with graceful degradation on network failure
+
+### Fixed
+
+- **Version Comparison**: `_compare_versions` now catches `InvalidVersion` from the `packaging` library for graceful degradation with malformed version strings
+
 ## [2.6.0] - 2026-02-28
 
 ### Added
@@ -474,6 +488,7 @@ This release marks the completion of all four development phases, providing a pr
 
 | Version | Date | Highlights |
 |---------|------|------------|
+| 2.7.0 | 2026-02-28 | 🔍 Server version discoverability for AI agents |
 | 2.6.0 | 2026-02-28 | 🔐 Compliance-grade audit logging, MCP documentation |
 | 2.4.1 | 2026-02-27 | 🐛 CI: mypy strict-mode type errors, test collection |
 | 2.4.0 | 2026-02-25 | 🔑 MCP Server: Per-user DevRev PAT authentication |

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/docs/hooks/copy_llms.py

@@ -10,16 +10,16 @@ import shutil
 from pathlib import Path
 
 
-def on_post_build(config, **kwargs):
+def on_post_build(config, **_kwargs):
     """Copy llms*.txt files from repo root to site output directory.
-    
+
     This hook runs after MkDocs builds the site and copies all llms*.txt files
     from the repository root to the site output directory, making them accessible
     at the root URL of the documentation site.
-    
+
     Args:
         config: MkDocs configuration dictionary.
-        **kwargs: Additional keyword arguments (unused).
+        **_kwargs: Additional keyword arguments (unused).
     """
     # Get paths from config
     repo_root = Path(config["config_file_path"]).parent
@@ -27,10 +27,10 @@ def on_post_build(config, **kwargs):
 
     # List of llms.txt files to copy
     llms_files = [
-        "llms.txt",           # Main llms.txt file
-        "llms-ctx.txt",       # Context-focused version
+        "llms.txt",  # Main llms.txt file
+        "llms-ctx.txt",  # Context-focused version
         "llms-ctx-full.txt",  # Full context version
-        "llms-mcp.txt",       # MCP-specific version
+        "llms-mcp.txt",  # MCP-specific version
     ]
 
     # Copy each file if it exists
@@ -42,4 +42,3 @@ def on_post_build(config, **kwargs):
             print(f"[OK] Copied {filename} to site root")
         else:
             print(f"[WARNING] {filename} not found in repo root")
-

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/llms-ctx-full.txt

@@ -13,7 +13,7 @@ A modern, type-safe Python SDK and MCP Server for the DevRev API with:
 **Install**: `pip install devrev-python-sdk`
 **Install with MCP**: `pip install devrev-python-sdk[mcp]`
 **Docs**: https://mgmonteleone.github.io/py-dev-rev/
-**Version**: 2.5.0
+**Version**: 2.7.0
 
 ## Authentication
 

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/llms-ctx.txt

@@ -6,7 +6,7 @@ A modern, type-safe Python SDK and MCP Server for the DevRev API. Requires Pytho
 **Install SDK**: `pip install devrev-python-sdk`
 **Install with MCP**: `pip install devrev-python-sdk[mcp]`
 **Docs**: https://mgmonteleone.github.io/py-dev-rev/
-**Version**: 2.5.0
+**Version**: 2.7.0
 
 ## SDK Quick Start
 

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/llms-mcp.txt

@@ -5,7 +5,7 @@
 **Install**: `pip install devrev-python-sdk[mcp]`
 **Run**: `devrev-mcp-server`
 **Docs**: https://mgmonteleone.github.io/py-dev-rev/mcp/
-**Version**: 2.5.0
+**Version**: 2.7.0
 **Protocol**: MCP 2025-06-18
 
 ## Quick Setup

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/llms.txt

@@ -10,7 +10,7 @@ Key information:
 - Both sync and async clients available (DevRevClient, AsyncDevRevClient)
 - Uses Pydantic v2 for all request/response models
 - MCP Server command: `devrev-mcp-server`
-- Version 2.5.0 (current)
+- Version 2.7.0 (current)
 
 ## SDK Quick Start
 

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "devrev-Python-SDK"
-version = "2.6.0"
+version = "2.7.0"
 description = "A modern, type-safe Python SDK for the DevRev API"
 readme = "README.md"
 requires-python = ">=3.11"

devrev_python_sdk-2.7.0/src/devrev_mcp/resources/server_info.py

@@ -0,0 +1,42 @@
+"""MCP resource for DevRev server information."""
+
+from __future__ import annotations
+
+import json
+import logging
+import platform
+import sys
+
+from devrev_mcp import __version__
+from devrev_mcp.server import mcp
+
+logger = logging.getLogger(__name__)
+
+
+@mcp.resource("devrev://server/info")
+async def get_server_info_resource() -> str:
+    """Get DevRev MCP Server information as a resource.
+
+    Returns static server metadata including version, Python version,
+    and links. For dynamic information like uptime and latest PyPI version,
+    use the devrev_server_info tool instead.
+
+    Returns:
+        JSON string containing server metadata.
+    """
+    return json.dumps(
+        {
+            "uri": "devrev://server/info",
+            "type": "server_info",
+            "name": "DevRev MCP Server",
+            "version": __version__,
+            "python_version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            "platform": platform.system(),
+            "links": {
+                "github": "https://github.com/mgmonteleone/py-dev-rev",
+                "documentation": "https://mgmonteleone.github.io/py-dev-rev/",
+                "pypi": "https://pypi.org/project/devrev-Python-SDK/",
+            },
+            "note": "Use devrev_server_info tool for dynamic info (uptime, latest version check).",
+        }
+    )

{devrev_python_sdk-2.6.0 → devrev_python_sdk-2.7.0}/src/devrev_mcp/server.py

@@ -140,6 +140,12 @@ _transport_security = _build_transport_security(_config)
 
 mcp = FastMCP(
     _config.server_name,
+    instructions=(
+        f"DevRev MCP Server v{__version__} — provides AI access to the DevRev platform "
+        f"for managing support tickets, customer accounts, knowledge bases, and workflows. "
+        f"Use the devrev_server_info tool to check version details, capabilities, and whether "
+        f"this is the latest version."
+    ),
     lifespan=app_lifespan,
     host=_config.host,
     port=_config.port,
@@ -237,6 +243,7 @@ from devrev_mcp.tools import groups as _groups_tools  # noqa: E402, F401
 from devrev_mcp.tools import incidents as _incidents_tools  # noqa: E402, F401
 from devrev_mcp.tools import links as _links_tools  # noqa: E402, F401
 from devrev_mcp.tools import parts as _parts_tools  # noqa: E402, F401
+from devrev_mcp.tools import server_info as _server_info_tools  # noqa: E402, F401
 from devrev_mcp.tools import slas as _slas_tools  # noqa: E402, F401
 from devrev_mcp.tools import tags as _tags_tools  # noqa: E402, F401
 from devrev_mcp.tools import timeline as _timeline_tools  # noqa: E402, F401
@@ -259,6 +266,7 @@ from devrev_mcp.resources import account as _account_resources  # noqa: E402, F4
 from devrev_mcp.resources import article as _article_resources  # noqa: E402, F401
 from devrev_mcp.resources import conversation as _conversation_resources  # noqa: E402, F401
 from devrev_mcp.resources import part as _part_resources  # noqa: E402, F401
+from devrev_mcp.resources import server_info as _server_info_resources  # noqa: E402, F401
 from devrev_mcp.resources import ticket as _ticket_resources  # noqa: E402, F401
 from devrev_mcp.resources import user as _user_resources  # noqa: E402, F401
 

devrev_python_sdk-2.7.0/src/devrev_mcp/tools/server_info.py

@@ -0,0 +1,108 @@
+"""MCP tool for DevRev server information and version checking."""
+
+from __future__ import annotations
+
+import logging
+import platform
+import sys
+import time
+from typing import Any
+
+import httpx
+from mcp.server.fastmcp import Context
+
+from devrev_mcp import __version__
+from devrev_mcp.server import mcp
+
+logger = logging.getLogger(__name__)
+
+# PyPI package name for version lookups
+_PYPI_PACKAGE_NAME = "devrev-Python-SDK"
+_PYPI_URL = f"https://pypi.org/pypi/{_PYPI_PACKAGE_NAME}/json"
+_PYPI_TIMEOUT = 5.0
+
+# Static metadata
+_GITHUB_URL = "https://github.com/mgmonteleone/py-dev-rev"
+_DOCS_URL = "https://mgmonteleone.github.io/py-dev-rev/"
+
+
+def _compare_versions(current: str, latest: str) -> bool | None:
+    """Compare two version strings. Returns True if current >= latest."""
+    try:
+        from packaging.version import Version
+
+        return Version(current) >= Version(latest)
+    except Exception:
+        # Catches ImportError (packaging not installed) and InvalidVersion (malformed version)
+        pass
+    # Fallback: simple tuple comparison
+    try:
+        current_parts = tuple(int(x) for x in current.split("."))
+        latest_parts = tuple(int(x) for x in latest.split("."))
+        return current_parts >= latest_parts
+    except (ValueError, AttributeError):
+        return None
+
+
+async def _fetch_latest_pypi_version() -> str | None:
+    """Fetch the latest version from PyPI. Returns None on failure."""
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(_PYPI_URL, timeout=_PYPI_TIMEOUT)
+            response.raise_for_status()
+            data = response.json()
+            version = data.get("info", {}).get("version")
+            return str(version) if version is not None else None
+    except Exception:
+        logger.debug("Failed to fetch latest version from PyPI", exc_info=True)
+        return None
+
+
+@mcp.tool()
+async def devrev_server_info(ctx: Context[Any, Any, Any]) -> dict[str, Any]:
+    """Get DevRev MCP Server information including version, capabilities, and update status.
+
+    Returns server version, enabled features, uptime, and checks PyPI for the
+    latest published version so you can tell the user whether they are up to date.
+
+    Use this tool when asked about the MCP server version, capabilities, or status.
+    """
+    from devrev_mcp.middleware.health import _start_time
+
+    app = ctx.request_context.lifespan_context
+
+    # Calculate uptime
+    uptime_seconds = int(time.monotonic() - _start_time) if _start_time is not None else 0
+
+    # Fetch latest version from PyPI
+    latest_version = await _fetch_latest_pypi_version()
+    is_latest = _compare_versions(__version__, latest_version) if latest_version else None
+
+    return {
+        "server": {
+            "name": app.config.server_name,
+            "version": __version__,
+            "uptime_seconds": uptime_seconds,
+            "python_version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            "platform": platform.system(),
+        },
+        "capabilities": {
+            "beta_tools_enabled": app.config.enable_beta_tools,
+            "destructive_tools_enabled": app.config.enable_destructive_tools,
+            "auth_mode": app.config.auth_mode,
+            "transport": app.config.transport,
+            "audit_logging": app.config.audit_log_enabled,
+            "rate_limit_rpm": app.config.rate_limit_rpm,
+        },
+        "update_status": {
+            "current_version": __version__,
+            "latest_version": latest_version or "unknown",
+            "is_latest": is_latest,
+            "pypi_package": _PYPI_PACKAGE_NAME,
+        },
+        "links": {
+            "github": _GITHUB_URL,
+            "documentation": _DOCS_URL,
+            "pypi": f"https://pypi.org/project/{_PYPI_PACKAGE_NAME}/",
+        },
+    }

devrev_python_sdk-2.7.0/tests/unit/mcp/test_server_info.py

@@ -0,0 +1,336 @@
+"""Tests for DevRev MCP server info tool and resource."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+
+class TestServerInfoResource:
+    """Tests for the devrev://server/info resource."""
+
+    @pytest.mark.asyncio
+    async def test_returns_valid_json(self):
+        """Test that the resource returns valid JSON."""
+        from devrev_mcp.resources.server_info import get_server_info_resource
+
+        result = await get_server_info_resource()
+        data = json.loads(result)
+        assert isinstance(data, dict)
+
+    @pytest.mark.asyncio
+    async def test_contains_required_fields(self):
+        """Test that the resource contains all required fields."""
+        from devrev_mcp.resources.server_info import get_server_info_resource
+
+        result = await get_server_info_resource()
+        data = json.loads(result)
+        assert data["uri"] == "devrev://server/info"
+        assert data["type"] == "server_info"
+        assert "version" in data
+        assert "python_version" in data
+        assert "platform" in data
+        assert "links" in data
+        assert "note" in data
+
+    @pytest.mark.asyncio
+    async def test_links_contain_urls(self):
+        """Test that links contain expected URLs."""
+        from devrev_mcp.resources.server_info import get_server_info_resource
+
+        result = await get_server_info_resource()
+        data = json.loads(result)
+        assert "github" in data["links"]
+        assert "documentation" in data["links"]
+        assert "pypi" in data["links"]
+        assert data["links"]["github"].startswith("https://")
+
+    @pytest.mark.asyncio
+    async def test_version_matches_package(self):
+        """Test that the version matches the package version."""
+        from devrev_mcp import __version__
+        from devrev_mcp.resources.server_info import get_server_info_resource
+
+        result = await get_server_info_resource()
+        data = json.loads(result)
+        assert data["version"] == __version__
+
+    @pytest.mark.asyncio
+    async def test_python_version_format(self):
+        """Test that python_version is in X.Y.Z format."""
+        from devrev_mcp.resources.server_info import get_server_info_resource
+
+        result = await get_server_info_resource()
+        data = json.loads(result)
+        parts = data["python_version"].split(".")
+        assert len(parts) == 3
+        assert all(p.isdigit() for p in parts)
+
+    @pytest.mark.asyncio
+    async def test_note_mentions_tool(self):
+        """Test that the note directs users to the tool for dynamic info."""
+        from devrev_mcp.resources.server_info import get_server_info_resource
+
+        result = await get_server_info_resource()
+        data = json.loads(result)
+        assert "devrev_server_info" in data["note"]
+
+
+class TestServerInfoTool:
+    """Tests for the devrev_server_info tool."""
+
+    @pytest.mark.asyncio
+    async def test_returns_server_section(self, mock_ctx):
+        """Test that the tool returns server information."""
+        from devrev_mcp.tools.server_info import devrev_server_info
+
+        with (
+            patch(
+                "devrev_mcp.tools.server_info._fetch_latest_pypi_version",
+                new_callable=AsyncMock,
+                return_value="2.6.0",
+            ),
+            patch("devrev_mcp.middleware.health._start_time", 0.0),
+        ):
+            result = await devrev_server_info(mock_ctx)
+
+        assert "server" in result
+        assert "version" in result["server"]
+        assert "name" in result["server"]
+        assert "uptime_seconds" in result["server"]
+        assert "python_version" in result["server"]
+        assert "platform" in result["server"]
+
+    @pytest.mark.asyncio
+    async def test_returns_capabilities_section(self, mock_ctx):
+        """Test that the tool returns capabilities information."""
+        from devrev_mcp.tools.server_info import devrev_server_info
+
+        with patch(
+            "devrev_mcp.tools.server_info._fetch_latest_pypi_version",
+            new_callable=AsyncMock,
+            return_value="2.6.0",
+        ):
+            result = await devrev_server_info(mock_ctx)
+
+        assert "capabilities" in result
+        caps = result["capabilities"]
+        assert "beta_tools_enabled" in caps
+        assert "destructive_tools_enabled" in caps
+        assert "auth_mode" in caps
+        assert "transport" in caps
+        assert "audit_logging" in caps
+        assert "rate_limit_rpm" in caps
+
+    @pytest.mark.asyncio
+    async def test_returns_update_status_section(self, mock_ctx):
+        """Test that the tool returns update status information."""
+        from devrev_mcp.tools.server_info import devrev_server_info
+
+        with patch(
+            "devrev_mcp.tools.server_info._fetch_latest_pypi_version",
+            new_callable=AsyncMock,
+            return_value="2.6.0",
+        ):
+            result = await devrev_server_info(mock_ctx)
+
+        assert "update_status" in result
+        status = result["update_status"]
+        assert "current_version" in status
+        assert "latest_version" in status
+        assert "is_latest" in status
+        assert "pypi_package" in status
+
+    @pytest.mark.asyncio
+    async def test_returns_links_section(self, mock_ctx):
+        """Test that the tool returns links."""
+        from devrev_mcp.tools.server_info import devrev_server_info
+
+        with patch(
+            "devrev_mcp.tools.server_info._fetch_latest_pypi_version",
+            new_callable=AsyncMock,
+            return_value="2.6.0",
+        ):
+            result = await devrev_server_info(mock_ctx)
+
+        assert "links" in result
+        assert "github" in result["links"]
+        assert "documentation" in result["links"]
+        assert "pypi" in result["links"]
+
+    @pytest.mark.asyncio
+    async def test_pypi_failure_returns_unknown(self, mock_ctx):
+        """Test graceful handling when PyPI is unreachable."""
+        from devrev_mcp.tools.server_info import devrev_server_info
+
+        with patch(
+            "devrev_mcp.tools.server_info._fetch_latest_pypi_version",
+            new_callable=AsyncMock,
+            return_value=None,
+        ):
+            result = await devrev_server_info(mock_ctx)
+
+        assert result["update_status"]["latest_version"] == "unknown"
+        assert result["update_status"]["is_latest"] is None
+
+    @pytest.mark.asyncio
+    async def test_is_latest_true_when_current_equals_latest(self, mock_ctx):
+        """Test is_latest is True when versions match."""
+        from devrev_mcp import __version__
+        from devrev_mcp.tools.server_info import devrev_server_info
+
+        with patch(
+            "devrev_mcp.tools.server_info._fetch_latest_pypi_version",
+            new_callable=AsyncMock,
+            return_value=__version__,
+        ):
+            result = await devrev_server_info(mock_ctx)
+
+        assert result["update_status"]["is_latest"] is True
+
+    @pytest.mark.asyncio
+    async def test_is_latest_false_when_behind(self, mock_ctx):
+        """Test is_latest is False when a newer version exists."""
+        from devrev_mcp.tools.server_info import devrev_server_info
+
+        with patch(
+            "devrev_mcp.tools.server_info._fetch_latest_pypi_version",
+            new_callable=AsyncMock,
+            return_value="99.99.99",
+        ):
+            result = await devrev_server_info(mock_ctx)
+
+        assert result["update_status"]["is_latest"] is False
+
+
+class TestVersionComparison:
+    """Tests for the _compare_versions helper."""
+
+    def test_equal_versions(self):
+        from devrev_mcp.tools.server_info import _compare_versions
+
+        assert _compare_versions("2.6.0", "2.6.0") is True
+
+    def test_current_newer(self):
+        from devrev_mcp.tools.server_info import _compare_versions
+
+        assert _compare_versions("2.7.0", "2.6.0") is True
+
+    def test_current_older(self):
+        from devrev_mcp.tools.server_info import _compare_versions
+
+        assert _compare_versions("2.5.0", "2.6.0") is False
+
+    def test_major_version_difference(self):
+        from devrev_mcp.tools.server_info import _compare_versions
+
+        assert _compare_versions("3.0.0", "2.99.99") is True
+        assert _compare_versions("1.99.99", "2.0.0") is False
+
+    def test_invalid_version_returns_none(self):
+        """Test that invalid versions return None when packaging is not available."""
+        import sys
+        from unittest.mock import patch
+
+        from devrev_mcp.tools.server_info import _compare_versions
+
+        # Mock ImportError to force fallback to simple comparison
+        # We need to patch the import at the point where it's used
+        with patch.dict(sys.modules, {"packaging.version": None}):
+            result = _compare_versions("invalid", "also-invalid")
+            assert result is None
+
+    def test_invalid_version_with_packaging_degrades_gracefully(self):
+        """Test that invalid versions degrade gracefully even when packaging is available."""
+        from devrev_mcp.tools.server_info import _compare_versions
+
+        # When packaging is available but version strings are invalid, should return None
+        result = _compare_versions("invalid", "also-invalid")
+        assert result is None
+
+
+class TestFetchLatestPyPIVersion:
+    """Tests for the _fetch_latest_pypi_version helper."""
+
+    @pytest.mark.asyncio
+    async def test_successful_fetch(self):
+        """Test successful PyPI version fetch."""
+        from devrev_mcp.tools.server_info import _fetch_latest_pypi_version
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"info": {"version": "2.6.0"}}
+        mock_response.raise_for_status = MagicMock()
+
+        with patch("devrev_mcp.tools.server_info.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(return_value=mock_response)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=None)
+            mock_client_cls.return_value = mock_client
+
+            result = await _fetch_latest_pypi_version()
+            assert result == "2.6.0"
+
+    @pytest.mark.asyncio
+    async def test_network_error_returns_none(self):
+        """Test that network errors return None."""
+        from devrev_mcp.tools.server_info import _fetch_latest_pypi_version
+
+        with patch("devrev_mcp.tools.server_info.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(side_effect=Exception("Network error"))
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=None)
+            mock_client_cls.return_value = mock_client
+
+            result = await _fetch_latest_pypi_version()
+            assert result is None
+
+    @pytest.mark.asyncio
+    async def test_malformed_response_returns_none(self):
+        """Test that malformed JSON responses return None gracefully."""
+        from devrev_mcp.tools.server_info import _fetch_latest_pypi_version
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {}  # Missing 'info' key
+        mock_response.raise_for_status = MagicMock()
+
+        with patch("devrev_mcp.tools.server_info.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(return_value=mock_response)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=None)
+            mock_client_cls.return_value = mock_client
+
+            result = await _fetch_latest_pypi_version()
+            assert result is None  # .get("info", {}).get("version") returns None
+
+
+class TestServerInstructions:
+    """Tests for the server instructions parameter."""
+
+    def test_mcp_server_has_instructions(self):
+        """Test that the MCP server instance has instructions set."""
+        import os
+        from unittest.mock import patch as mock_patch
+
+        with mock_patch.dict(os.environ, {"DEVREV_API_TOKEN": "test-token"}, clear=False):
+            from devrev_mcp.server import mcp
+
+            # FastMCP stores instructions - check it's set and contains version info
+            assert mcp.instructions is not None
+            assert "DevRev MCP Server" in mcp.instructions
+            assert "devrev_server_info" in mcp.instructions
+
+    def test_instructions_contain_version(self):
+        """Test that instructions include the version string."""
+        import os
+        from unittest.mock import patch as mock_patch
+
+        with mock_patch.dict(os.environ, {"DEVREV_API_TOKEN": "test-token"}, clear=False):
+            from devrev_mcp import __version__
+            from devrev_mcp.server import mcp
+
+            assert __version__ in mcp.instructions