ecp-runtime 0.2.9b0__tar.gz → 0.3.0__tar.gz

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/.gitignore

@@ -31,7 +31,7 @@ MANIFEST
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 *.manifest
 *.spec
-
+/specs/
 # Installer logs
 pip-log.txt
 pip-delete-this-directory.txt
@@ -50,7 +50,10 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 cover/
-
+node_modules/
+.github/agents
+.github/prompts/
+.specify/
 # Translations
 *.mo
 *.pot

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecp-runtime
-Version: 0.2.9b0
+Version: 0.3.0
 Summary: The reference runtime for the Evaluation Context Protocol (ECP).
 Project-URL: Homepage, https://github.com/evaluation-context-protocol/ecp
 Project-URL: Documentation, https://evaluationcontextprotocol.io/
@@ -24,9 +24,11 @@ It includes the CLI tool `ecp` for running agent evaluations.
 ## Install
 
 ```bash
-pip install ecp-runtime
+pip install "ecp-runtime==0.2.9"
 ```
 
+The latest stable PyPI release is now `0.2.9` and matches the current GitHub release line.
+
 ## Usage
 
 Run an evaluation manifest:
@@ -41,6 +43,13 @@ You can also run via module entrypoint:
 python -m ecp_runtime.cli run --manifest .\examples\langchain_demo\manifest.yaml
 ```
 
+Manifest `target` values may be either a command for the default stdio transport
+or an ECP Streamable HTTP endpoint:
+
+```yaml
+target: "http://127.0.0.1:8765/ecp"
+```
+
 If your manifest includes `llm_judge`, set an API key and optional judge model:
 
 ```bash

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/README.md

@@ -6,9 +6,11 @@ It includes the CLI tool `ecp` for running agent evaluations.
 ## Install
 
 ```bash
-pip install ecp-runtime
+pip install "ecp-runtime==0.2.9"
 ```
 
+The latest stable PyPI release is now `0.2.9` and matches the current GitHub release line.
+
 ## Usage
 
 Run an evaluation manifest:
@@ -23,6 +25,13 @@ You can also run via module entrypoint:
 python -m ecp_runtime.cli run --manifest .\examples\langchain_demo\manifest.yaml
 ```
 
+Manifest `target` values may be either a command for the default stdio transport
+or an ECP Streamable HTTP endpoint:
+
+```yaml
+target: "http://127.0.0.1:8765/ecp"
+```
+
 If your manifest includes `llm_judge`, set an API key and optional judge model:
 
 ```bash

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ecp-runtime"
-version = "0.2.9b0"
+version = "0.3.0"
 description = "The reference runtime for the Evaluation Context Protocol (ECP)."
 authors = [
   { name = "ECP Maintainers", email = "hello@ecp.org" },
@@ -29,4 +29,3 @@ Issues = "https://github.com/evaluation-context-protocol/ecp/issues"
 [project.scripts]
 ecp = "ecp_runtime.cli:app" 
 
-

ecp_runtime-0.3.0/src/ecp_runtime/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.9"

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/src/ecp_runtime/cli.py

@@ -1,12 +1,15 @@
-import logging
-import typer
-import sys
-import os
+import glob
 import json
+import logging
+import os
+import sys
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Any, Dict, List, Optional
+
+import typer
 
 from .reporter import HTMLReporter
+from .trend import RunTrendAnalyzer
 
 # Import local modules (Using relative imports)
 try:
@@ -137,5 +140,66 @@ def run(
         sys.exit(1)
 
 
+@app.command()
+def trend(
+    pattern: str = typer.Argument(
+        ...,
+        help="Glob pattern matching saved JSON report files (e.g. 'results/run-*.json')",
+    ),
+    window: int = typer.Option(
+        20,
+        "--window",
+        "-w",
+        help="Maximum number of recent runs to include in the analysis",
+        min=1,
+    ),
+    exit_on_regression: bool = typer.Option(
+        False,
+        "--exit-on-regression",
+        help="Exit with code 2 when a degrading trend is detected (for CI gates)",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Enable verbose output",
+    ),
+):
+    """
+    Analyse pass-rate trends across a sequence of saved JSON report files.
+    """
+    _configure_logging(verbose)
+
+    matched: List[Path] = sorted(Path(path) for path in glob.glob(pattern, recursive=True))
+
+    if not matched:
+        typer.echo(f"No files matched the pattern: {pattern}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Found {len(matched)} report(s). Analysing last {window}...")
+
+    analyzer = RunTrendAnalyzer(matched, window=window)
+    report = analyzer.analyze()
+
+    typer.echo("")
+    typer.echo(f"{'Run':<5}  {'Manifest':<45}  {'Passed':>6}  {'Total':>6}  {'Rate':>6}")
+    typer.echo("-" * 74)
+    for index, run in enumerate(report.runs, start=1):
+        manifest_label = Path(run.manifest).name if len(run.manifest) > 45 else run.manifest
+        rate_pct = f"{run.pass_rate * 100:.1f}%"
+        typer.echo(f"{index:<5}  {manifest_label:<45}  {run.passed:>6}  {run.total:>6}  {rate_pct:>6}")
+
+    typer.echo("")
+    typer.echo(f"Trend Direction : {report.direction.upper()}")
+    typer.echo(f"Slope (per run) : {report.pass_rate_slope:+.6f}")
+    typer.echo(f"Window          : {len(report.runs)} run(s) analysed (max {report.window})")
+    typer.echo(f"Regression flag : {'YES' if report.any_regression else 'No'}")
+    typer.echo("")
+
+    if report.any_regression and exit_on_regression:
+        typer.echo("Regression detected. Exiting with code 2 (--exit-on-regression).", err=True)
+        raise typer.Exit(code=2)
+
+
 if __name__ == "__main__":
     app()

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/src/ecp_runtime/graders.py

@@ -1,6 +1,7 @@
-import re
 import os
+import re
 from typing import Any, Dict, List, Tuple
+
 from .manifest import GraderConfig, StepConfig
 
 # Try importing OpenAI, but don't crash if it's missing (unless used)

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/src/ecp_runtime/manifest.py

@@ -1,6 +1,8 @@
 from typing import Any, Dict, List, Literal, Optional
-from pydantic import BaseModel, Field, model_validator
+
 import yaml
+from pydantic import BaseModel, Field, model_validator
+
 
 # --- The Grader (Assertion) Schema ---
 class GraderConfig(BaseModel):

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/src/ecp_runtime/runner.py

@@ -5,15 +5,18 @@ Simplified Version. V0.1
 AsyncIO Pending
 """
 
-import subprocess
 import json
-import os
-import time
 import logging
-import threading
+import os
 import queue
-from typing import Dict, Any, Optional, List
+import subprocess
+import threading
+import time
 from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from urllib import error, request
+from urllib.parse import urlparse
+
 from .graders import evaluate_step
 
 logger = logging.getLogger(__name__)
@@ -147,6 +150,75 @@ class AgentProcess:
             return ""
 
 
+class HTTPAgentClient:
+    """JSON-RPC client for ECP Streamable HTTP endpoints."""
+
+    def __init__(self, endpoint: str, rpc_timeout: float = 30.0):
+        self.endpoint = endpoint
+        self.rpc_timeout = rpc_timeout
+
+    def start(self):
+        return None
+
+    def stop(self):
+        return None
+
+    def send_rpc(self, method: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        if not params:
+            params = {}
+
+        payload = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+            "id": int(time.time() * 1000),
+        }
+        body = json.dumps(payload).encode("utf-8")
+        req = request.Request(
+            self.endpoint,
+            data=body,
+            method="POST",
+            headers={
+                "Accept": "application/json, text/event-stream",
+                "Content-Type": "application/json",
+            },
+        )
+
+        try:
+            with request.urlopen(req, timeout=self.rpc_timeout) as resp:
+                content_type = resp.headers.get("Content-Type", "")
+                raw = resp.read().decode("utf-8")
+        except error.HTTPError as exc:
+            raw = exc.read().decode("utf-8", errors="replace")
+            raise RuntimeError(
+                f"HTTP RPC failed: status={exc.code}, body={raw or exc.reason}"
+            ) from exc
+        except error.URLError as exc:
+            raise RuntimeError(f"HTTP RPC failed: {exc.reason}") from exc
+
+        if "text/event-stream" in content_type:
+            return self._parse_sse_response(raw)
+        if not raw:
+            raise RuntimeError("HTTP RPC response was empty")
+        payload = json.loads(raw)
+        if not isinstance(payload, dict):
+            raise RuntimeError("HTTP RPC response must be a JSON object")
+        return payload
+
+    def _parse_sse_response(self, raw: str) -> Dict[str, Any]:
+        for event in raw.split("\n\n"):
+            data_lines = []
+            for line in event.splitlines():
+                if line.startswith("data:"):
+                    data_lines.append(line[5:].lstrip())
+            if not data_lines:
+                continue
+            payload = json.loads("\n".join(data_lines))
+            if isinstance(payload, dict) and ("result" in payload or "error" in payload):
+                return payload
+        raise RuntimeError("SSE stream ended without a JSON-RPC response")
+
+
 class ECPRunner:
     """The Orchestrator."""
 
@@ -162,7 +234,7 @@ class ECPRunner:
             logger.info("Scenario: %s", scenario.name)
 
             rpc_timeout = float(os.environ.get("ECP_RPC_TIMEOUT", "30"))
-            agent = AgentProcess(self.manifest.target, rpc_timeout=rpc_timeout)
+            agent = self._create_agent(self.manifest.target, rpc_timeout=rpc_timeout)
             agent.start()
 
             try:
@@ -224,6 +296,11 @@ class ECPRunner:
             "scenarios": report_data
         }
 
+    def _create_agent(self, target: str, rpc_timeout: float):
+        if _is_http_url(target):
+            return HTTPAgentClient(target, rpc_timeout=rpc_timeout)
+        return AgentProcess(target, rpc_timeout=rpc_timeout)
+
     def _ensure_rpc_success(
         self,
         rpc_resp: Dict[str, Any],
@@ -243,3 +320,8 @@ class ECPRunner:
         raise RuntimeError(
             f"RPC call failed ({method}) at {where}: code={code}, message={message}"
         )
+
+
+def _is_http_url(target: str) -> bool:
+    parsed = urlparse(target)
+    return parsed.scheme in {"http", "https"} and bool(parsed.netloc)

ecp_runtime-0.3.0/src/ecp_runtime/trend.py

@@ -0,0 +1,113 @@
+"""
+ecp_runtime.trend
+=================
+RunTrendAnalyzer - reads a sequence of saved JSON report files produced by
+``ecp run --json-out`` and computes cross-run pass-rate regression signals.
+"""
+
+from __future__ import annotations
+
+import json
+import statistics
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Literal
+
+
+@dataclass
+class RunPoint:
+    """Represents a single evaluation run extracted from one JSON report."""
+
+    manifest: str
+    passed: int
+    total: int
+    pass_rate: float
+
+
+@dataclass
+class RunTrendReport:
+    """Aggregated analysis over a window of sequential runs."""
+
+    window: int
+    runs: List[RunPoint] = field(default_factory=list)
+    pass_rate_slope: float = 0.0
+    direction: Literal["improving", "degrading", "stable"] = "stable"
+    any_regression: bool = False
+
+
+class RunTrendAnalyzer:
+    """
+    Analyse cross-run pass-rate trends across a collection of JSON reports.
+
+    The analyzer sorts report paths lexicographically and keeps only the most
+    recent ``window`` reports.
+    """
+
+    _IMPROVING_THRESHOLD: float = 0.001
+    _DEGRADING_THRESHOLD: float = -0.001
+
+    def __init__(self, report_paths: List[Path], window: int = 20) -> None:
+        if window < 1:
+            raise ValueError(f"window must be >= 1, got {window}")
+        self.report_paths: List[Path] = sorted(report_paths)[-window:]
+        self.window = window
+
+    def analyze(self) -> RunTrendReport:
+        runs: List[RunPoint] = []
+
+        for path in self.report_paths:
+            point = self._load_run_point(path)
+            if point is not None:
+                runs.append(point)
+
+        if len(runs) < 2:
+            return RunTrendReport(
+                window=self.window,
+                runs=runs,
+                pass_rate_slope=0.0,
+                direction="stable",
+                any_regression=False,
+            )
+
+        slope = self._compute_slope([run.pass_rate for run in runs])
+        direction = self._classify(slope)
+
+        return RunTrendReport(
+            window=self.window,
+            runs=runs,
+            pass_rate_slope=round(slope, 6),
+            direction=direction,
+            any_regression=(direction == "degrading"),
+        )
+
+    @staticmethod
+    def _load_run_point(path: Path) -> RunPoint | None:
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return None
+
+        total = int(data.get("total", 0) or 0)
+        passed = int(data.get("passed", 0) or 0)
+        passed = max(0, min(passed, total))
+        pass_rate = passed / total if total > 0 else 0.0
+
+        return RunPoint(
+            manifest=data.get("manifest", str(path)),
+            passed=passed,
+            total=total,
+            pass_rate=pass_rate,
+        )
+
+    @staticmethod
+    def _compute_slope(pass_rates: List[float]) -> float:
+        x = list(range(len(pass_rates)))
+        slope, _intercept = statistics.linear_regression(x, pass_rates)
+        return slope
+
+    def _classify(self, slope: float) -> Literal["improving", "degrading", "stable"]:
+        if slope > self._IMPROVING_THRESHOLD:
+            return "improving"
+        if slope < self._DEGRADING_THRESHOLD:
+            return "degrading"
+        return "stable"

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/tests/test_cli.py

@@ -1,7 +1,7 @@
 import json
+import sys
 import tempfile
 import unittest
-import sys
 from pathlib import Path
 from unittest import mock
 
@@ -9,9 +9,8 @@ RUNTIME_SRC = Path(__file__).resolve().parents[1] / "src"
 if str(RUNTIME_SRC) not in sys.path:
     sys.path.insert(0, str(RUNTIME_SRC))
 
-from typer.testing import CliRunner
-
 from ecp_runtime.cli import app
+from typer.testing import CliRunner
 
 
 class CLISmokeTests(unittest.TestCase):

ecp_runtime-0.3.0/tests/test_example_integrations.py

@@ -0,0 +1,135 @@
+import os
+import socket
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+RUNTIME_SRC = Path(__file__).resolve().parents[1] / "src"
+
+
+class ExampleIntegrationTests(unittest.TestCase):
+    def _run_manifest(self, manifest_path: Path) -> subprocess.CompletedProcess[str]:
+        env = dict(os.environ)
+        existing = env.get("PYTHONPATH", "")
+        extra_paths = [str(RUNTIME_SRC)]
+        if existing:
+            extra_paths.append(existing)
+        env["PYTHONPATH"] = os.pathsep.join(extra_paths)
+
+        return subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "ecp_runtime.cli",
+                "run",
+                "--manifest",
+                str(manifest_path),
+                "--json",
+            ],
+            cwd=REPO_ROOT,
+            text=True,
+            capture_output=True,
+            env=env,
+            check=False,
+        )
+
+    def test_plain_python_demo_manifest_passes(self) -> None:
+        manifest = REPO_ROOT / "examples" / "plain_python_demo" / "manifest.yaml"
+        result = self._run_manifest(manifest)
+        self.assertEqual(result.returncode, 0, msg=result.stdout + result.stderr)
+        self.assertIn('"failed": 0', result.stdout)
+
+    def test_two_agent_demo_manifest_passes(self) -> None:
+        manifest = REPO_ROOT / "examples" / "two_agent_demo" / "manifest.yaml"
+        result = self._run_manifest(manifest)
+        self.assertEqual(result.returncode, 0, msg=result.stdout + result.stderr)
+        self.assertIn('"failed": 0', result.stdout)
+
+    def test_streamable_http_demo_manifest_passes(self) -> None:
+        port = self._free_port()
+        server_env = dict(os.environ)
+        sdk_src = REPO_ROOT / "sdk" / "python" / "src"
+        existing = server_env.get("PYTHONPATH", "")
+        extra_paths = [str(sdk_src)]
+        if existing:
+            extra_paths.append(existing)
+        server_env["PYTHONPATH"] = os.pathsep.join(extra_paths)
+        server_env["ECP_HTTP_PORT"] = str(port)
+
+        server = subprocess.Popen(
+            [sys.executable, str(REPO_ROOT / "examples" / "streamable_http_demo" / "agent.py")],
+            cwd=REPO_ROOT,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=server_env,
+        )
+
+        try:
+            self._wait_for_port("127.0.0.1", port)
+            with tempfile.TemporaryDirectory() as tmpdir:
+                manifest_path = Path(tmpdir) / "streamable-http-manifest.yaml"
+                manifest_path.write_text(
+                    textwrap.dedent(
+                        f"""
+                        manifest_version: "v1"
+                        name: "Streamable HTTP Transport Validation"
+                        target: "http://127.0.0.1:{port}/ecp"
+
+                        scenarios:
+                          - name: "HTTP Echo"
+                            steps:
+                              - input: "echo: transport is online"
+                                graders:
+                                  - type: text_match
+                                    field: public_output
+                                    condition: contains
+                                    value: "transport is online"
+                                  - type: tool_usage
+                                    tool_name: "http_echo"
+                                    arguments:
+                                      message: "transport is online"
+                        """
+                    ).strip(),
+                    encoding="utf-8",
+                )
+                result = self._run_manifest(manifest_path)
+
+            self.assertEqual(result.returncode, 0, msg=result.stdout + result.stderr)
+            self.assertIn('"failed": 0', result.stdout)
+        finally:
+            server.terminate()
+            try:
+                server.communicate(timeout=2)
+            except subprocess.TimeoutExpired:
+                server.kill()
+                server.communicate()
+
+    def _free_port(self) -> int:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.bind(("127.0.0.1", 0))
+            return int(sock.getsockname()[1])
+
+    def _wait_for_port(self, host: str, port: int) -> None:
+        deadline = time.time() + 5
+        while time.time() < deadline:
+            if self._port_is_open(host, port):
+                return
+            time.sleep(0.05)
+        raise AssertionError(f"Timed out waiting for {host}:{port}")
+
+    def _port_is_open(self, host: str, port: int) -> bool:
+        try:
+            with socket.create_connection((host, port), timeout=0.2):
+                return True
+        except OSError:
+            return False
+
+
+if __name__ == "__main__":
+    unittest.main()

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/tests/test_runner.py

@@ -1,5 +1,5 @@
-import unittest
 import sys
+import unittest
 from pathlib import Path
 from types import SimpleNamespace
 from unittest import mock
@@ -9,7 +9,7 @@ if str(RUNTIME_SRC) not in sys.path:
     sys.path.insert(0, str(RUNTIME_SRC))
 
 from ecp_runtime.manifest import StepConfig
-from ecp_runtime.runner import ECPRunner
+from ecp_runtime.runner import ECPRunner, HTTPAgentClient
 
 
 class RunnerTests(unittest.TestCase):
@@ -68,6 +68,50 @@ class RunnerTests(unittest.TestCase):
         self.assertIn("step=1", msg)
         self.assertIn("boom", msg)
 
+    def test_runner_uses_http_client_for_url_target(self) -> None:
+        runner = ECPRunner(SimpleNamespace(target="http://127.0.0.1:8765/ecp", scenarios=[]))
+
+        agent = runner._create_agent(runner.manifest.target, rpc_timeout=12.0)
+
+        self.assertIsInstance(agent, HTTPAgentClient)
+        self.assertEqual(agent.endpoint, "http://127.0.0.1:8765/ecp")
+        self.assertEqual(agent.rpc_timeout, 12.0)
+
+    def test_http_agent_client_posts_json_rpc(self) -> None:
+        class FakeResponse:
+            headers = {"Content-Type": "application/json; charset=utf-8"}
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, *_args):
+                return None
+
+            def read(self):
+                return b'{"jsonrpc":"2.0","id":1,"result":{"ok":true}}'
+
+        captured = {}
+
+        def fake_urlopen(req, timeout):
+            captured["url"] = req.full_url
+            captured["timeout"] = timeout
+            captured["body"] = req.data
+            captured["accept"] = req.headers.get("Accept")
+            return FakeResponse()
+
+        with mock.patch("ecp_runtime.runner.request.urlopen", fake_urlopen):
+            response = HTTPAgentClient("http://agent.test/ecp", rpc_timeout=3).send_rpc(
+                "agent/step", {"input": "hi"}
+            )
+
+        self.assertEqual(response["result"]["ok"], True)
+        self.assertEqual(captured["url"], "http://agent.test/ecp")
+        self.assertEqual(captured["timeout"], 3)
+        self.assertIn("application/json", captured["accept"])
+        body = captured["body"].decode("utf-8")
+        self.assertIn('"method": "agent/step"', body)
+        self.assertIn('"input": "hi"', body)
+
 
 if __name__ == "__main__":
     unittest.main()

ecp_runtime-0.3.0/tests/test_trend.py

@@ -0,0 +1,87 @@
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+# Ensure srd is in path for imports
+RUNTIME_SRC = Path(__file__).resolve().parents[1] / "src"
+if str(RUNTIME_SRC) not in sys.path:
+    sys.path.insert(0, str(RUNTIME_SRC))
+
+from ecp_runtime.trend import RunPoint, RunTrendAnalyzer
+
+
+class RunTrendAnalyzerTests(unittest.TestCase):
+    def test_analyzer_handles_improving_trend(self) -> None:
+        rates = [0.1, 0.5, 0.9]
+        runs = [RunPoint(manifest=f"r{i}", passed=int(r*10), total=10, pass_rate=r) for i, r in enumerate(rates)]
+        
+        # We mock _load_run_point to avoid file IO for the core logic test
+        with mock.patch.object(RunTrendAnalyzer, "_load_run_point", side_effect=runs):
+            analyzer = RunTrendAnalyzer([Path("r0"), Path("r1"), Path("r2")])
+            report = analyzer.analyze()
+            
+        self.assertEqual(report.direction, "improving")
+        self.assertGreater(report.pass_rate_slope, 0.3)
+        self.assertFalse(report.any_regression)
+
+    def test_analyzer_handles_degrading_trend(self) -> None:
+        rates = [0.9, 0.5, 0.1]
+        runs = [RunPoint(manifest=f"r{i}", passed=int(r*10), total=10, pass_rate=r) for i, r in enumerate(rates)]
+        
+        with mock.patch.object(RunTrendAnalyzer, "_load_run_point", side_effect=runs):
+            analyzer = RunTrendAnalyzer([Path("r0"), Path("r1"), Path("r2")])
+            report = analyzer.analyze()
+            
+        self.assertEqual(report.direction, "degrading")
+        self.assertLess(report.pass_rate_slope, -0.3)
+        self.assertTrue(report.any_regression)
+
+    def test_analyzer_handles_stable_trend(self) -> None:
+        rates = [0.5, 0.50001, 0.49999]
+        runs = [RunPoint(manifest=f"r{i}", passed=int(r*100), total=100, pass_rate=r) for i, r in enumerate(rates)]
+        
+        with mock.patch.object(RunTrendAnalyzer, "_load_run_point", side_effect=runs):
+            analyzer = RunTrendAnalyzer([Path("r0"), Path("r1"), Path("r2")])
+            report = analyzer.analyze()
+            
+        self.assertEqual(report.direction, "stable")
+        self.assertAlmostEqual(report.pass_rate_slope, 0.0, places=4)
+        self.assertFalse(report.any_regression)
+
+    def test_analyzer_window_trimming(self) -> None:
+        paths = [Path(f"r{i}") for i in range(10)]
+        analyzer = RunTrendAnalyzer(paths, window=3)
+        self.assertEqual(len(analyzer.report_paths), 3)
+        self.assertEqual(analyzer.report_paths[-1].name, "r9")
+
+    def test_single_run_returns_stable(self) -> None:
+        runs = [RunPoint(manifest="r0", passed=5, total=10, pass_rate=0.5)]
+        with mock.patch.object(RunTrendAnalyzer, "_load_run_point", side_effect=runs):
+            analyzer = RunTrendAnalyzer([Path("r0")])
+            report = analyzer.analyze()
+        self.assertEqual(report.direction, "stable")
+        self.assertEqual(report.pass_rate_slope, 0.0)
+
+
+class RunTrendAnalyzerFileTests(unittest.TestCase):
+    def test_load_run_point_from_file(self) -> None:
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as tmp:
+            data = {"passed": 8, "total": 10, "manifest": "test.yaml"}
+            json.dump(data, tmp)
+            tmp_path = Path(tmp.name)
+        
+        try:
+            point = RunTrendAnalyzer._load_run_point(tmp_path)
+            self.assertIsNotNone(point)
+            self.assertEqual(point.passed, 8)
+            self.assertEqual(point.pass_rate, 0.8)
+            self.assertEqual(point.manifest, "test.yaml")
+        finally:
+            tmp_path.unlink()
+
+
+if __name__ == "__main__":
+    unittest.main()

ecp_runtime-0.2.9b0/src/ecp_runtime/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/tests/test_graders.py

@@ -1,6 +1,6 @@
 import os
-import unittest
 import sys
+import unittest
 from pathlib import Path
 from types import SimpleNamespace
 from unittest import mock

{ecp_runtime-0.2.9b0 → ecp_runtime-0.3.0}/tests/test_manifest.py

@@ -1,6 +1,6 @@
+import sys
 import tempfile
 import unittest
-import sys
 from pathlib import Path
 
 from pydantic import ValidationError