v2.1.0: p_value field, MCP timeseries tool, version bump

- Add p_value: float to SampleResult dataclass
- Parse p_value from API response in _parse_scan()
- Add waveguard_scan_timeseries tool to client MCP server
- Bump version to 2.1.0 (pyproject.toml + client.py + MCP server)

Author: gpartin

mcp_server/server.py

@@ -149,6 +149,55 @@ def _api_get(path: str) -> Any:
             "required": ["training", "test"],
         },
     },
+    {
+        "name": "waveguard_scan_timeseries",
+        "description": (
+            "Detect anomalies in time-series data using GPU-accelerated wave "
+            "physics simulation. Send a flat array of numeric values and a "
+            "window size. The tool automatically creates overlapping windows, "
+            "uses the first N as training (normal baseline), and scores the "
+            "remaining windows as test samples. Returns per-window anomaly "
+            "scores, confidence, and p-values.\n\n"
+            "Example: send 100 CPU-usage readings with window_size=10. "
+            "The first 5 windows become training, the rest are tested."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": (
+                        "Flat array of numeric time-series values in "
+                        "chronological order."
+                    ),
+                    "minItems": 4,
+                },
+                "window_size": {
+                    "type": "integer",
+                    "description": (
+                        "Number of data points per window (default: 10). "
+                        "Smaller windows = finer resolution."
+                    ),
+                },
+                "test_windows": {
+                    "type": "integer",
+                    "description": (
+                        "Number of trailing windows to test (default: auto, "
+                        "uses last ~40%% of windows)."
+                    ),
+                },
+                "sensitivity": {
+                    "type": "number",
+                    "description": (
+                        "Anomaly threshold multiplier (default: 2.0). Lower = "
+                        "more sensitive. Range: 0.5 to 5.0."
+                    ),
+                },
+            },
+            "required": ["data"],
+        },
+    },
     {
         "name": "waveguard_health",
         "description": (
@@ -169,6 +218,71 @@ def _api_get(path: str) -> Any:
 # ═══════════════════════════════════════════════════════════════════════════
 
 
+def _execute_timeseries(arguments: dict) -> dict:
+    """Sliding-window timeseries scan via the /v1/scan endpoint."""
+    data = arguments["data"]
+    window = int(arguments.get("window_size", 10))
+    sensitivity = arguments.get("sensitivity", 2.0)
+
+    # Build windows
+    windows = [data[i : i + window] for i in range(0, len(data) - window + 1)]
+    if len(windows) < 3:
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": (
+                        f"Not enough data: {len(data)} points with "
+                        f"window_size={window} gives {len(windows)} windows "
+                        f"(need at least 3)."
+                    ),
+                }
+            ],
+            "isError": True,
+        }
+
+    # Split into training / test
+    test_count = arguments.get("test_windows")
+    if test_count is None:
+        test_count = max(1, len(windows) * 2 // 5)
+    test_count = min(test_count, len(windows) - 2)
+
+    training = windows[: len(windows) - test_count]
+    test = windows[len(windows) - test_count :]
+
+    body: dict = {
+        "training": training,
+        "test": test,
+        "encoder_type": "timeseries",
+        "sensitivity": sensitivity,
+    }
+    result = _api_post("/v1/scan", body)
+
+    # Summarise
+    lines = [
+        f"Time-series scan: {len(windows)} windows "
+        f"(window_size={window}, {len(training)} train, {len(test)} test)",
+        "",
+    ]
+    for i, r in enumerate(result.get("results", [])):
+        idx = len(training) + i
+        is_anom = r.get("is_anomaly", False)
+        conf = r.get("confidence", 0)
+        pval = r.get("p_value", 1.0)
+        marker = "ANOMALY" if is_anom else "Normal"
+        lines.append(
+            f"  Window {idx}: {marker} (confidence: {conf:.0%}, "
+            f"p-value: {pval:.4f})"
+        )
+    summary = "\n".join(lines)
+    return {
+        "content": [
+            {"type": "text", "text": summary},
+            {"type": "text", "text": json.dumps(result, indent=2)},
+        ]
+    }
+
+
 def execute_tool(name: str, arguments: dict) -> dict:
     """Execute an MCP tool and return the result."""
     try:
@@ -221,6 +335,9 @@ def execute_tool(name: str, arguments: dict) -> dict:
                 ]
             }
 
+        elif name == "waveguard_scan_timeseries":
+            return _execute_timeseries(arguments)
+
         elif name == "waveguard_health":
             result = _api_get("/v1/health")
             status = (
@@ -254,7 +371,7 @@ class MCPStdioServer:
     def __init__(self) -> None:
         self.server_info = {
             "name": "waveguard",
-            "version": "2.0.0",
+            "version": "2.1.0",
         }
 
     def handle_message(self, msg: dict) -> Optional[dict]:
@@ -318,7 +435,7 @@ def handle_message(self, msg: dict) -> Optional[dict]:
     def run_stdio(self) -> None:
         """Run the MCP server on stdin/stdout."""
         sys.stderr.write(
-            f"WaveGuard MCP server v2.0.0 started (API: {API_URL})\n"
+            f"WaveGuard MCP server v2.1.0 started (API: {API_URL})\n"
         )
         sys.stderr.flush()
 
@@ -353,7 +470,7 @@ def run_http_server(port: int = 3001) -> None:
         print("HTTP transport requires: pip install fastapi uvicorn")
         sys.exit(1)
 
-    mcp_app = FA(title="WaveGuard MCP Server", version="2.0.0")
+    mcp_app = FA(title="WaveGuard MCP Server", version="2.1.0")
     server = MCPStdioServer()
 
     @mcp_app.post("/mcp")
@@ -364,7 +481,7 @@ async def mcp_endpoint(request: dict) -> dict:  # type: ignore[type-arg]
     async def mcp_tools() -> dict:  # type: ignore[type-arg]
         return {"tools": TOOLS}
 
-    print(f"WaveGuard MCP HTTP server v2.0.0 on port {port}")
+    print(f"WaveGuard MCP HTTP server v2.1.0 on port {port}")
     uvicorn.run(mcp_app, host="0.0.0.0", port=port)
 
 
@@ -374,7 +491,7 @@ async def mcp_tools() -> dict:  # type: ignore[type-arg]
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
-        description="WaveGuard MCP Server v2.0.0"
+        description="WaveGuard MCP Server v2.1.0"
     )
     parser.add_argument(
         "--http",

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "WaveGuardClient"
-version = "2.0.0"
+version = "2.1.0"
 description = "Python SDK for WaveGuard — physics-based anomaly detection API"
 readme = "README.md"
 license = "MIT"

test_api.py

@@ -0,0 +1,44 @@
+"""Quick test: SDK direct API + p_value + grid 64."""
+from waveguard import WaveGuard
+
+wg = WaveGuard()
+
+sr = wg.scan(
+    training=[
+        {"cpu": 45, "mem": 60, "disk": 30, "net": 100, "io": 20},
+        {"cpu": 50, "mem": 65, "disk": 32, "net": 110, "io": 22},
+        {"cpu": 48, "mem": 62, "disk": 31, "net": 105, "io": 21},
+        {"cpu": 47, "mem": 63, "disk": 29, "net": 102, "io": 19},
+        {"cpu": 46, "mem": 61, "disk": 30, "net": 108, "io": 23},
+    ],
+    test=[
+        {"cpu": 46, "mem": 61, "disk": 30, "net": 103, "io": 20},
+        {"cpu": 99, "mem": 95, "disk": 90, "net": 900, "io": 85},
+    ],
+)
+
+print("=== SDK DIRECT API TEST ===")
+print(f"Results: {len(sr.results)} samples")
+for i, r in enumerate(sr.results):
+    print(
+        f"  Sample {i+1}: anomaly={r.is_anomaly}, score={r.score:.2f}, "
+        f"confidence={r.confidence:.2%}, p_value={r.p_value:.6f}, "
+        f"grid={r.engine.grid_size}"
+    )
+    feats = [(f.label, round(f.z_score, 2)) for f in r.top_features[:3]]
+    print(f"           top features: {feats}")
+
+print()
+print(f"p_value field present: {hasattr(sr.results[0], 'p_value')}")
+print(f"Grid size (should be 64): {sr.results[0].engine.grid_size}")
+print()
+print("=== ALL CHECKS ===")
+checks = [
+    ("p_value field exists", hasattr(sr.results[0], 'p_value')),
+    ("Grid = 64", sr.results[0].engine.grid_size == 64),
+    ("p_value is float", isinstance(sr.results[0].p_value, float)),
+    ("2 results returned", len(sr.results) == 2),
+]
+for name, ok in checks:
+    print(f"  {'PASS' if ok else 'FAIL'}: {name}")
+print(f"\nAll checks passed: {all(ok for _, ok in checks)}")

test_mcp.py

@@ -0,0 +1,73 @@
+"""Test MCP endpoint: tools/list (verify 3 tools) + waveguard_scan_timeseries."""
+import requests
+import json
+
+URL = "https://gpartin--waveguard-api-fastapi-app.modal.run/mcp"
+HDR = {"Content-Type": "application/json"}
+
+
+def mcp(method, params=None, msg_id=1):
+    body = {"jsonrpc": "2.0", "method": method, "id": msg_id}
+    if params:
+        body["params"] = params
+    r = requests.post(URL, json=body, headers=HDR, timeout=90)
+    r.raise_for_status()
+    return r.json()
+
+
+# 1) Initialize
+init = mcp("initialize", {"protocolVersion": "2024-11-05",
+                           "capabilities": {},
+                           "clientInfo": {"name": "test", "version": "1.0"}})
+print("=== MCP INITIALIZE ===")
+print(f"Server: {init['result']['serverInfo']}")
+
+# 2) tools/list
+tools = mcp("tools/list", msg_id=2)
+names = [t["name"] for t in tools["result"]["tools"]]
+print(f"\n=== MCP TOOLS/LIST ({len(names)} tools) ===")
+for n in names:
+    print(f"  - {n}")
+
+assert "waveguard_scan_timeseries" in names, "timeseries tool missing!"
+print("\nPASS: waveguard_scan_timeseries present")
+
+# 3) Call waveguard_scan_timeseries
+import math
+# Generate sine wave with a spike anomaly
+data = [math.sin(i * 0.3) * 10 + 50 for i in range(40)]
+data[35] = 200  # anomaly spike
+
+ts_result = mcp("tools/call", {
+    "name": "waveguard_scan_timeseries",
+    "arguments": {
+        "data": data,
+        "window_size": 5,
+        "sensitivity": 2.0,
+    }
+}, msg_id=3)
+
+print("\n=== MCP TIMESERIES SCAN ===")
+content = ts_result["result"]["content"]
+print(content[0]["text"])
+
+# Parse JSON results
+full = json.loads(content[1]["text"])
+results = full.get("results", [])
+print(f"\nReturned {len(results)} test windows")
+any_anomaly = any(r.get("is_anomaly") for r in results)
+any_pvalue = any("p_value" in r for r in results)
+print(f"Any anomaly detected: {any_anomaly}")
+print(f"p_value in results: {any_pvalue}")
+
+# 4) Summary
+print("\n=== ALL MCP CHECKS ===")
+checks = [
+    ("3 tools listed", len(names) == 3),
+    ("timeseries tool present", "waveguard_scan_timeseries" in names),
+    ("timeseries returns results", len(results) > 0),
+    ("p_value in results", any_pvalue),
+]
+for name, ok in checks:
+    print(f"  {'PASS' if ok else 'FAIL'}: {name}")
+print(f"\nAll MCP checks passed: {all(ok for _, ok in checks)}")

waveguard/client.py

@@ -38,7 +38,7 @@
     ServerError,
 )
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"
 
 
 # ─────────────────────────────── Data Classes ─────────────────────────────
@@ -71,6 +71,7 @@ class SampleResult:
     threshold: float
     mahalanobis_distance: float
     confidence: float
+    p_value: float
     top_features: List[FeatureInfo]
     latency_ms: float
     engine: EngineInfo
@@ -272,6 +273,7 @@ def _parse_scan(
                     threshold=r.get("threshold", 0.0),
                     mahalanobis_distance=r.get("mahalanobis_distance", 0.0),
                     confidence=r.get("confidence", 0.0),
+                    p_value=r.get("p_value", 1.0),
                     top_features=features,
                     latency_ms=r.get("latency_ms", 0.0),
                     engine=EngineInfo(