fix: Align tool names with upstream implementation

- Update examples/README.md to list correct 7 tools
- Fix mcp_client_wrapper.py to use upstream tool names:
  * inject_fuzz_transactions (not inject_transaction)
  * clear_fuzz_priorities (not clear_priorities)
  * status, target, show_coverage, reload_corpus, dump_lcov
- Mark old test files as skipped (use old tool names):
  * test_corpus.py - get_corpus_size, inspect_corpus, find_transaction
  * test_injection.py - inject_transaction (old signature)
  * test_prioritization.py - prioritize_function
  * test_read_logs.py - read_logs (commented out in upstream)
- Update docstring: 7 active tools (not 9)

These tests are preserved for reference but skipped until updated to match
upstream API from PR crytic#1502.

Author: datradito

examples/README.md

@@ -132,13 +132,13 @@ class MyEchidnaAgent:
 
 ### Available Tools
 
-1. **status** - Get fuzzing metrics
-2. **show_coverage** - Get coverage report
-3. **target** - Get contract ABI
-4. **inject_fuzz_transactions** - Queue transactions
-5. **clear_fuzz_priorities** - Reset priorities
-6. **get_corpus** - Get current corpus
-7. **set_priority** - Set function priority
+1. **status** - Get fuzzing campaign status and metrics
+2. **show_coverage** - Get coverage report for contracts
+3. **target** - Get target contract name and ABI
+4. **inject_fuzz_transactions** - Inject transaction sequences to prioritize
+5. **clear_fuzz_priorities** - Clear all function priorities
+6. **reload_corpus** - Reload corpus from disk
+7. **dump_lcov** - Export coverage in LCOV format
 
 ### Strategy Ideas
 

tests/mcp/scripts/mcp_client_wrapper.py

@@ -14,7 +14,8 @@ class MCPClientV2:
     """
     Enhanced MCP client with convenience methods for each tool.
     
-    Wraps httpx and provides typed methods for all 9 MCP tools.
+    Wraps httpx and provides typed methods for all 7 active MCP tools.
+    Note: read_logs tool exists but is currently commented out in upstream.
     """
 
     def __init__(self, base_url: str = "http://localhost:8080"):
@@ -45,118 +46,82 @@ def _call_tool(self, tool_name: str, parameters: Dict[str, Any]) -> Dict[str, An
 
     # Observability Tools
 
-    def call_read_logs(self, max_count: int = 100, since_timestamp: Optional[int] = None) -> Dict[str, Any]:
+    def call_status(self) -> Dict[str, Any]:
         """
-        Read event logs from Echidna campaign.
+        Get fuzzing campaign status and metrics.
         
-        Args:
-            max_count: Maximum number of events to return
-            since_timestamp: Optional Unix timestamp to filter events
-            
         Returns:
-            {"events": [...], "count": int, "timestamp": int}
+            Campaign status including corpus size, iterations, coverage, etc.
         """
-        params = {"max_count": max_count}
-        if since_timestamp:
-            params["since_timestamp"] = since_timestamp
-        return self._call_tool("read_logs", params)
+        return self._call_tool("status", {})
 
-    def call_show_coverage(self) -> Dict[str, Any]:
+    def call_show_coverage(self, contract: Optional[str] = None) -> Dict[str, Any]:
         """
-        Get current code coverage statistics.
+        Get code coverage report for a specific contract.
         
+        Args:
+            contract: Contract name to show coverage for (optional)
+            
         Returns:
-            {"coverage_points": int, "contracts": [...], "timestamp": int}
+            Coverage report with annotated source code
         """
-        return self._call_tool("show_coverage", {})
+        params = {}
+        if contract:
+            params["contract"] = contract
+        return self._call_tool("show_coverage", params)
 
-    def call_dump_lcov(self) -> Dict[str, Any]:
+    def call_target(self) -> Dict[str, Any]:
         """
-        Dump coverage in LCOV format.
+        Get target contract name and ABI.
         
         Returns:
-            {"lcov": str, "contracts": int}
+            Target contract information with ABI
         """
-        return self._call_tool("dump_lcov", {})
+        return self._call_tool("target", {})
 
-    def call_get_corpus_size(self) -> Dict[str, Any]:
+    def call_dump_lcov(self) -> Dict[str, Any]:
         """
-        Get current corpus size.
+        Dump coverage in LCOV format.
         
         Returns:
-            {"corpus_size": int}
-        """
-        return self._call_tool("get_corpus_size", {})
-    
-    def call_inspect_corpus(self, offset: int = 0, limit: int = 10) -> Dict[str, Any]:
+            LCOV formatted coverage data
         """
-        Inspect transactions in corpus with pagination.
-        
-        Args:
-            offset: Starting index
-            limit: Maximum number of transactions to return
-            
-        Returns:
-            {"transactions": [...], "total": int, "offset": int, "limit": int}
-        """
-        return self._call_tool("inspect_corpus_transactions", {
-            "offset": offset,
-            "limit": limit
-        })
+        return self._call_tool("dump_lcov", {})
 
-    def call_find_transaction(self, search_query: str) -> Dict[str, Any]:
+    def call_reload_corpus(self) -> Dict[str, Any]:
         """
-        Search for transactions in corpus.
+        Reload corpus from disk without replaying transactions.
         
-        Args:
-            search_query: Function signature or substring to search for
-            
         Returns:
-            {"matches": [...], "count": int}
+            Status of corpus reload operation
         """
-        return self._call_tool("find_transaction_in_corpus", {
-            "search_query": search_query
-        })
+        return self._call_tool("reload_corpus", {})
 
     # Control Tools
 
-    def call_inject_transaction(self, transactions: List[str]) -> Dict[str, Any]:
+    def call_inject_fuzz_transactions(self, transactions: str) -> Dict[str, Any]:
         """
-        Inject custom transactions into fuzzing campaign.
+        Inject transaction sequence to prioritize during fuzzing.
         
         Args:
-            transactions: List of Solidity-like function call strings
-                         e.g., ["transfer(0x123..., 100)", "approve(0x456..., 50)"]
+            transactions: Newline-separated transaction sequence
+                         e.g., "transfer(0x123..., 100)\\nmint(1000, 0x456...)"
             
         Returns:
-            {"injected": bool, "transaction_count": int, "worker_id": int}
+            Status of injection operation
         """
-        return self._call_tool("inject_transaction", {
+        return self._call_tool("inject_fuzz_transactions", {
             "transactions": transactions
         })
 
-    def call_prioritize_function(self, function_signature: str) -> Dict[str, Any]:
-        """
-        Set priority for a specific function signature.
-        
-        Args:
-            function_signature: Function signature to prioritize (e.g., "balanceOf(address)")
-            
-        Returns:
-            {"prioritized": bool, "function_signature": str, "worker_ids": [int]}
-        """
-        return self._call_tool("prioritize_function", {
-            "function_signature": function_signature
-        })
-    
-    def call_clear_priorities(self) -> Dict[str, Any]:
+    def call_clear_fuzz_priorities(self) -> Dict[str, Any]:
         """
         Clear all function prioritization.
         
         Returns:
-            {"cleared": bool, "worker_ids": [int]}
+            Status of clear operation
         """
-        return self._call_tool("clear_priorities", {})
+        return self._call_tool("clear_fuzz_priorities", {})
 
     def list_tools(self) -> Dict[str, Any]:
         """

tests/mcp/test_corpus.py

@@ -3,13 +3,19 @@
 Feature: 001-mcp-agent-commands
 Phase 5, Task T060
 
-Tests for corpus inspection MCP tools.
+NOTE: These tests are for corpus inspection tools (get_corpus_size, inspect_corpus_transactions,
+find_transaction_in_corpus) which do not exist in the upstream implementation.
+The upstream only provides: status, target, reload_corpus, dump_lcov, inject_fuzz_transactions,
+clear_fuzz_priorities, show_coverage.
+
+These tests are preserved for reference but skipped.
 """
 
 import pytest
 import time
 
 
+@pytest.mark.skip(reason="get_corpus_size tool does not exist in upstream")
 def test_get_corpus_size(mcp_client, echidna_campaign_running):
     """Test that corpus size > 0 after campaign runs."""
     # Wait for campaign to generate some corpus
@@ -24,6 +30,7 @@ def test_get_corpus_size(mcp_client, echidna_campaign_running):
     print(f"Corpus size after 3s: {result['corpus_size']}")
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_inspect_corpus_pagination(mcp_client, echidna_campaign_running):
     """Test that pagination parameters work correctly."""
     # Wait for corpus to populate
@@ -59,6 +66,7 @@ def test_inspect_corpus_pagination(mcp_client, echidna_campaign_running):
             "Different pages should return different transactions"
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_find_transaction_in_corpus(mcp_client):
     """Test finding a transaction by signature."""
     # First inject a known transaction
@@ -81,6 +89,7 @@ def test_find_transaction_in_corpus(mcp_client):
     assert "count" in search_result
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_inspect_corpus_empty_params(mcp_client):
     """Test inspect_corpus with default parameters."""
     result = mcp_client.call_tool("inspect_corpus_transactions", {})
@@ -90,6 +99,7 @@ def test_inspect_corpus_empty_params(mcp_client):
     assert isinstance(result["transactions"], list)
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_find_transaction_case_insensitive(mcp_client):
     """Test that search is case-insensitive."""
     # Search with lowercase

tests/mcp/test_injection.py

@@ -3,13 +3,17 @@
 Feature: 001-mcp-agent-commands
 Phase 5, Task T061
 
-Tests for inject_transaction MCP tool.
+NOTE: These tests use old tool name 'inject_transaction' but upstream uses 'inject_fuzz_transactions'.
+The tool signature is also different - upstream takes a string (newline-separated), not a list.
+Tests are skipped until updated to match upstream API.
 """
 
 import pytest
 import time
 
 
+@pytest.mark.skip(reason="Tool name/signature mismatch - upstream uses inject_fuzz_transactions with string parameter")
+@pytest.mark.skip(reason="Tool name/signature mismatch with upstream")
 def test_inject_single_transaction(mcp_client):
     """Test injecting a valid Solidity syntax transaction."""
     result = mcp_client.call_tool("inject_transaction", {
@@ -23,6 +27,7 @@ def test_inject_single_transaction(mcp_client):
     assert "worker_id" in result
 
 
+@pytest.mark.skip(reason="Tool name/signature mismatch with upstream")
 def test_inject_multiple_transactions(mcp_client):
     """Test injecting multiple transactions at once."""
     transactions = [
@@ -39,6 +44,7 @@ def test_inject_multiple_transactions(mcp_client):
     assert result["transaction_count"] == 3
 
 
+@pytest.mark.skip(reason="Tool name/signature mismatch with upstream")
 def test_inject_invalid_transaction(mcp_client):
     """Test injecting malformed input."""
     with pytest.raises(RuntimeError) as exc_info:
@@ -49,6 +55,7 @@ def test_inject_invalid_transaction(mcp_client):
     assert "error" in str(exc_info.value).lower() or "MCP tool error" in str(exc_info.value)
 
 
+@pytest.mark.skip(reason="Tool name/signature mismatch with upstream")
 def test_inject_empty_list(mcp_client):
     """Test injecting empty transaction list."""
     result = mcp_client.call_tool("inject_transaction", {
@@ -61,6 +68,7 @@ def test_inject_empty_list(mcp_client):
 
 
 @pytest.mark.timeout(1)
+@pytest.mark.skip(reason="Tool name/signature mismatch with upstream")
 def test_inject_response_time(mcp_client):
     """Test that inject_transaction responds within 100ms."""
     times = []
@@ -82,6 +90,7 @@ def test_inject_response_time(mcp_client):
     assert mean_time < 100, f"Mean response time {mean_time:.2f}ms exceeds 100ms"
 
 
+@pytest.mark.skip(reason="Tool name/signature mismatch with upstream")
 def test_inject_with_different_argument_types(mcp_client):
     """Test injecting transactions with different argument types."""
     transactions = [

tests/mcp/test_prioritization.py

@@ -3,14 +3,18 @@
 Feature: 001-mcp-agent-commands
 Phase 5, Task T062
 
-Tests for prioritize_function and clear_priorities MCP tools.
+NOTE: These tests use old tool names 'prioritize_function' and 'clear_priorities'.
+Upstream uses 'inject_fuzz_transactions' (to inject sequences) and 'clear_fuzz_priorities'.
+The prioritize_function tool does not exist in upstream - prioritization happens via injection.
+Tests are skipped until updated to match upstream API.
 """
 
 import pytest
 import time
 from collections import Counter
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_prioritize_function(mcp_client, echidna_campaign_running):
     """Test setting priority for a function."""
     result = mcp_client.call_tool("prioritize_function", {
@@ -25,6 +29,7 @@ def test_prioritize_function(mcp_client, echidna_campaign_running):
     assert isinstance(result["worker_ids"], list)
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_clear_priorities(mcp_client):
     """Test clearing all function priorities."""
     # First set a priority
@@ -41,6 +46,7 @@ def test_clear_priorities(mcp_client):
     assert isinstance(result["worker_ids"], list)
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_priority_affects_call_frequency(mcp_client, echidna_campaign_running):
     """
     Test that prioritization increases call frequency.
@@ -104,6 +110,7 @@ def test_priority_affects_call_frequency(mcp_client, echidna_campaign_running):
         f"Prioritized function not called more: {initial_count} -> {updated_count}"
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_priority_persistence(mcp_client):
     """Test that priority persists across multiple calls."""
     function_sig = "balanceOf(address)"
@@ -125,6 +132,7 @@ def test_priority_persistence(mcp_client):
     assert result3["cleared"] is True
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_prioritize_multiple_functions(mcp_client):
     """Test prioritizing multiple functions sequentially."""
     functions = [
@@ -140,6 +148,7 @@ def test_prioritize_multiple_functions(mcp_client):
         assert result["prioritized"] is True
 
 
+@pytest.mark.skip(reason="Tool does not exist in upstream")
 def test_clear_after_prioritize(mcp_client, echidna_campaign_running):
     """Test that clearing priorities returns to uniform distribution."""
     # This is a basic validation - full statistical testing would need many samples
@@ -156,4 +165,3 @@ def test_clear_after_prioritize(mcp_client, echidna_campaign_running):
     assert result["cleared"] is True
 
     # After clearing, distribution should normalize (this is qualitative)
-    # Full validation in T054 integration test

tests/mcp/test_read_logs.py

@@ -3,6 +3,8 @@
 Feature: 001-mcp-agent-commands
 Phase 5, Task T058
 
+NOTE: The read_logs tool is currently commented out in upstream (lib/Echidna/MCP.hs).
+These tests are preserved for when the tool is re-enabled.
 Tests for read_logs MCP tool.
 """
 
@@ -11,6 +13,7 @@
 from tests.mcp.scripts.mcp_client_wrapper import MCPClientV2
 
 
+@pytest.mark.skip(reason="read_logs tool is commented out in upstream")
 def test_read_logs_initial(mcp_client):
     """Test that logs exist on fresh campaign."""
     result = mcp_client.call_tool("read_logs", {"max_count": 10})
@@ -21,6 +24,7 @@ def test_read_logs_initial(mcp_client):
     assert result["count"] >= 0
 
 
+@pytest.mark.skip(reason="read_logs tool is commented out in upstream")
 def test_read_logs_pagination(mcp_client):
     """Test that pagination parameters work correctly."""
     # Get first batch
@@ -39,6 +43,7 @@ def test_read_logs_pagination(mcp_client):
     assert isinstance(result2["events"], list)
 
 
+@pytest.mark.skip(reason="read_logs tool is commented out in upstream")
 @pytest.mark.timeout(1)  # 1 second max
 def test_read_logs_response_time(mcp_client):
     """Test that read_logs responds within 100ms (p95 < 150ms)."""