greenpick 0.1.4__tar.gz → 0.1.6__tar.gz

{greenpick-0.1.4/src/greenpick.egg-info → greenpick-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.1.4
+Version: 0.1.6
 Summary: Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs.
 Author-email: "Data Science Advisers, LLC" <info@datascienceadvisers.com>
 License-Expression: MIT
@@ -254,15 +254,39 @@ of the options below.)
 }
 ```
 
-**In a Jupyter notebook or Python script**, set them before you start (or import) the server:
+**In a Jupyter notebook or Python script**, connect with the MCP client library and pass the keys
+in `env`. The library starts GreenPick as a separate process and doesn't forward the notebook's own
+environment variables to it:
 
 ```python
-import os
-os.environ["GREENPICK_CARBON_SOURCE"] = "auto"
-os.environ["EIA_API_KEY"] = "your-eia-key"
-os.environ["ENTSOE_TOKEN"] = "your-entsoe-token"
+import sys
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+params = StdioServerParameters(
+    command=sys.executable,
+    args=["-m", "greenpick"],
+    env={
+        "GREENPICK_CARBON_SOURCE": "auto",
+        "EIA_API_KEY": "your-eia-key",
+        "ENTSOE_TOKEN": "your-entsoe-token",
+    },
+)
+
+# In Jupyter, errlog must be a real file (the notebook's stderr has no fileno()).
+with open("greenpick-server.log", "w") as errlog:
+    async with stdio_client(params, errlog=errlog) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            result = await session.call_tool(
+                "region_carbon_now", {"provider": "aws", "region": "us-west-2"}
+            )
+            print(result.content[0].text)
 ```
 
+Top-level `await` works in Jupyter. In a plain script, put the `with` block inside an `async def`
+and run it with `asyncio.run(...)`.
+
 Every carbon figure includes a `quality` field: `live` means real grid data, `mock` means a
 fallback value. Check it to confirm live data is on.
 

{greenpick-0.1.4 → greenpick-0.1.6}/README.md

@@ -224,15 +224,39 @@ of the options below.)
 }
 ```
 
-**In a Jupyter notebook or Python script**, set them before you start (or import) the server:
+**In a Jupyter notebook or Python script**, connect with the MCP client library and pass the keys
+in `env`. The library starts GreenPick as a separate process and doesn't forward the notebook's own
+environment variables to it:
 
 ```python
-import os
-os.environ["GREENPICK_CARBON_SOURCE"] = "auto"
-os.environ["EIA_API_KEY"] = "your-eia-key"
-os.environ["ENTSOE_TOKEN"] = "your-entsoe-token"
+import sys
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+params = StdioServerParameters(
+    command=sys.executable,
+    args=["-m", "greenpick"],
+    env={
+        "GREENPICK_CARBON_SOURCE": "auto",
+        "EIA_API_KEY": "your-eia-key",
+        "ENTSOE_TOKEN": "your-entsoe-token",
+    },
+)
+
+# In Jupyter, errlog must be a real file (the notebook's stderr has no fileno()).
+with open("greenpick-server.log", "w") as errlog:
+    async with stdio_client(params, errlog=errlog) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            result = await session.call_tool(
+                "region_carbon_now", {"provider": "aws", "region": "us-west-2"}
+            )
+            print(result.content[0].text)
 ```
 
+Top-level `await` works in Jupyter. In a plain script, put the `with` block inside an `async def`
+and run it with `asyncio.run(...)`.
+
 Every carbon figure includes a `quality` field: `live` means real grid data, `mock` means a
 fallback value. Check it to confirm live data is on.
 

{greenpick-0.1.4 → greenpick-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "greenpick"
-version = "0.1.4"
+version = "0.1.6"
 description = "Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs."
 readme = "README.md"
 requires-python = ">=3.11"

greenpick-0.1.6/src/greenpick/__init__.py

@@ -0,0 +1,15 @@
+"""GreenPick — design-time sustainability co-pilot (MCP server).
+
+Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
+delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
+"""
+
+__version__ = "0.1.6"
+
+# httpx logs every request URL at INFO, and our live sources pass their API key / token as a URL
+# query parameter — so at the default log level the secret would land in the MCP client's logs.
+# Keep the HTTP libraries at WARNING (no request lines) for every entry point that imports us.
+import logging as _logging
+
+for _name in ("httpx", "httpcore"):
+    _logging.getLogger(_name).setLevel(_logging.WARNING)

greenpick-0.1.6/src/greenpick/data/_net.py

@@ -0,0 +1,23 @@
+"""Shared networking helpers for the live carbon sources.
+
+Two jobs:
+- `describe_error`: a log-safe summary of a failed request. httpx exception messages embed the
+  full request URL, and our data sources pass their API key / token as a URL query parameter, so
+  logging the exception verbatim would write the secret into the MCP client's log files.
+- Shared timeouts, so one slow upstream can't freeze a tool call.
+"""
+from __future__ import annotations
+
+import httpx
+
+# Per-step limits for a single HTTP request (connect / read / write / pool).
+REQUEST_TIMEOUT = httpx.Timeout(8.0, connect=5.0)
+# Hard ceiling for ONE request end-to-end. httpx timeouts are per-step, so a server that trickles
+# bytes can stretch a request far past them; asyncio.wait_for enforces a true wall-clock limit.
+REQUEST_DEADLINE_S = 15.0
+
+
+def describe_error(e: BaseException) -> str:
+    """Error type plus HTTP status (if any) — never the URL, which carries the credential."""
+    status = getattr(getattr(e, "response", None), "status_code", None)
+    return f"{type(e).__name__}" + (f" (HTTP {status})" if status else "")

{greenpick-0.1.4 → greenpick-0.1.6}/src/greenpick/data/eia_repository.py

@@ -14,6 +14,7 @@ Carbon intensity = sum(gen_fuel * factor_fuel) / sum(gen_fuel).  Directional, no
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
 from datetime import datetime, timezone
@@ -23,6 +24,7 @@ import httpx
 from ..models import CarbonReading, Provider, HourlyCarbon
 from .mock_repository import MockCarbonRepository
 from .static_data import region_meta, emission_factors
+from ._net import REQUEST_TIMEOUT, REQUEST_DEADLINE_S, describe_error
 
 log = logging.getLogger("greenpick.eia")
 
@@ -78,8 +80,9 @@ class EIARepository:
                 "sort[0][direction]": "desc",
                 "length": "2000",   # ~5-7 days of hourly rows x fuels — enough for a daily pattern
             }
-            async with httpx.AsyncClient(timeout=12) as client:
-                resp = await client.get(_URL, params=params)
+            async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+                resp = await asyncio.wait_for(client.get(_URL, params=params),
+                                              timeout=REQUEST_DEADLINE_S)
             if resp.status_code in (401, 403):
                 log.warning("EIA rejected the key (HTTP %s) — using mock. Check EIA_API_KEY.",
                             resp.status_code)
@@ -87,7 +90,8 @@ class EIARepository:
             resp.raise_for_status()
             return resp.json().get("response", {}).get("data", [])
         except Exception as e:
-            log.debug("EIA call failed for BA %s (%s) — mock fallback", ba, e)
+            # describe_error, not e: the exception text embeds the URL, which carries the key.
+            log.debug("EIA call failed for BA %s (%s) — mock fallback", ba, describe_error(e))
             return None
 
     async def carbon_history(self, provider: Provider, region: str) -> list[HourlyCarbon]:

{greenpick-0.1.4 → greenpick-0.1.6}/src/greenpick/data/electricitymaps_repository.py

@@ -13,6 +13,7 @@ API: GET https://api.electricitymap.org/v3/carbon-intensity/latest?zone=XX
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
 from datetime import datetime, timezone
@@ -22,6 +23,7 @@ import httpx
 from ..models import CarbonReading, Provider, HourlyCarbon
 from .mock_repository import MockCarbonRepository
 from .static_data import region_meta
+from ._net import REQUEST_TIMEOUT, REQUEST_DEADLINE_S, describe_error
 
 log = logging.getLogger("greenpick.electricitymaps")
 
@@ -66,9 +68,11 @@ class ElectricityMapsRepository:
             })
 
         try:
-            async with httpx.AsyncClient(timeout=8) as client:
-                resp = await client.get(_BASE, params={"zone": zone},
-                                        headers={"auth-token": self._token})
+            async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+                resp = await asyncio.wait_for(
+                    client.get(_BASE, params={"zone": zone}, headers={"auth-token": self._token}),
+                    timeout=REQUEST_DEADLINE_S,
+                )
 
             if resp.status_code in (401, 403):
                 # Config problem, not a per-region issue. Warn once, then stop trying.
@@ -100,5 +104,6 @@ class ElectricityMapsRepository:
 
         except Exception as e:
             # Network/parse/rate-limit -> mock fallback rather than erroring the tool.
-            log.debug("Electricity Maps call failed for zone %s (%s) — mock fallback", zone, e)
+            log.debug("Electricity Maps call failed for zone %s (%s) — mock fallback",
+                      zone, describe_error(e))
             return await self._fallback.carbon_now(provider, region)

{greenpick-0.1.4 → greenpick-0.1.6}/src/greenpick/data/entsoe_repository.py

@@ -14,6 +14,7 @@ Response: XML with <TimeSeries> per production type:
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 import re
 import time
@@ -25,11 +26,17 @@ import httpx
 from ..models import CarbonReading, Provider, HourlyCarbon, ForecastHour
 from .mock_repository import MockCarbonRepository
 from .static_data import region_meta, emission_factors
+from ._net import REQUEST_TIMEOUT, REQUEST_DEADLINE_S, describe_error
 
 log = logging.getLogger("greenpick.entsoe")
 
 _URL = "https://web-api.tp.entsoe.eu/api"
 
+# Retry policy for a slow/flaky upstream, bounded so a tool call never hangs on it:
+_ATTEMPTS = 3
+_FETCH_BUDGET_S = 20.0        # total wall-clock for ALL attempts + backoff of one fetch
+_OUTAGE_COOLDOWN_S = 300.0    # after a failed fetch, skip that zone (labelled fallback) this long
+
 
 def _strip_ns(tag: str) -> str:
     """ENTSO-E XML is namespaced; strip '{ns}tag' -> 'tag' for simple matching."""
@@ -70,6 +77,7 @@ class ENTSOERepository:
         self._cache: dict[str, tuple[float, CarbonReading]] = {}  # EIC -> (fetched_at, reading)
         self._fallback = MockCarbonRepository()
         self._warned_no_token = False
+        self._down_until: dict[str, float] = {}   # EIC -> epoch secs; skip the zone until then
 
     async def carbon_now(self, provider: Provider, region: str) -> CarbonReading:
         meta = region_meta(provider, region) or {}
@@ -114,28 +122,57 @@ class ENTSOERepository:
             "periodEnd": now.strftime("%Y%m%d%H%M"),
         }
 
-        # ENTSO-E is occasionally slow / empty for a given zone (their docs warn about response
-        # times). Retry a couple of times before degrading to mock, since a transient miss would
-        # otherwise show a region as mock for the whole cache window.
-        import asyncio
-        attempts = 3
-        for attempt in range(1, attempts + 1):
+        return await self._get_bounded(eic, params, label="A75")
+
+    def _is_down(self, eic: str) -> bool:
+        return time.time() < self._down_until.get(eic, 0.0)
+
+    async def _get_bounded(self, eic: str, params: dict, label: str,
+                           no_match_is_final: bool = False) -> str | None:
+        """GET with retries inside ONE wall-clock budget, and outage memory.
+
+        ENTSO-E is occasionally slow or empty for a zone (their docs warn about response times), so
+        we retry — but every attempt and backoff shares a single _FETCH_BUDGET_S, so a struggling
+        upstream degrades this call to the labelled fallback in seconds rather than freezing the tool.
+        If the zone still fails, remember it for _OUTAGE_COOLDOWN_S: the next calls (e.g. the other
+        regions in a ranking, then the timing lookup) fall back immediately instead of each waiting
+        out their own retry cycle. Returns the body text, or None (callers fall back)."""
+        if self._is_down(eic):
+            return None
+        deadline = time.monotonic() + _FETCH_BUDGET_S
+        for attempt in range(1, _ATTEMPTS + 1):
+            remaining = deadline - time.monotonic()
+            if remaining <= 0.5:
+                break
             try:
-                async with httpx.AsyncClient(timeout=15) as client:
-                    resp = await client.get(_URL, params=params)
+                async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+                    resp = await asyncio.wait_for(client.get(_URL, params=params),
+                                                  timeout=min(remaining, REQUEST_DEADLINE_S))
                 if resp.status_code in (401, 403):
-                    log.warning("ENTSO-E rejected the token (HTTP %s) — using mock. Check ENTSOE_TOKEN.",
-                                resp.status_code)
+                    log.warning("ENTSO-E rejected the token (HTTP %s) on %s — using fallback. "
+                                "Check ENTSOE_TOKEN.", resp.status_code, label)
                     return None   # auth: don't retry
                 resp.raise_for_status()
                 if resp.text and "<TimeSeries" in resp.text:
                     return resp.text
-                # 200 but no usable generation (transient empty) -> retry
-                log.debug("ENTSO-E empty for %s (attempt %d/%d)", eic, attempt, attempts)
+                # 'No matching data' (common for A65 in some zones) means "not offered", not an
+                # outage: bail quietly without retrying or marking the zone down.
+                if no_match_is_final and "No matching data" in resp.text:
+                    log.debug("ENTSO-E %s: no matching data for %s", label, eic)
+                    return None
+                log.debug("ENTSO-E %s empty for %s (attempt %d/%d)", label, eic, attempt, _ATTEMPTS)
             except Exception as e:
-                log.debug("ENTSO-E call failed for %s (attempt %d/%d): %s", eic, attempt, attempts, e)
-            if attempt < attempts:
-                await asyncio.sleep(0.6 * attempt)   # brief backoff: 0.6s, 1.2s
+                # describe_error, not e: the exception text embeds the URL, which carries the token.
+                log.debug("ENTSO-E %s failed for %s (attempt %d/%d): %s",
+                          label, eic, attempt, _ATTEMPTS, describe_error(e))
+            if attempt < _ATTEMPTS:
+                pause = 0.6 * attempt   # brief backoff: 0.6s, 1.2s — inside the same budget
+                if deadline - time.monotonic() <= pause + 0.5:
+                    break
+                await asyncio.sleep(pause)
+        self._down_until[eic] = time.time() + _OUTAGE_COOLDOWN_S
+        log.info("ENTSO-E unavailable for %s — using the labelled fallback for the next %ds.",
+                 eic, int(_OUTAGE_COOLDOWN_S))
         return None
 
     async def _fetch_forecast_xml(self, eic: str, document_type: str, hours_ahead: int,
@@ -153,31 +190,7 @@ class ENTSOERepository:
             "periodEnd": end.strftime("%Y%m%d%H%M"),
         }
         params["outBiddingZone_Domain" if load else "in_Domain"] = eic
-
-        import asyncio
-        attempts = 3
-        for attempt in range(1, attempts + 1):
-            try:
-                async with httpx.AsyncClient(timeout=15) as client:
-                    resp = await client.get(_URL, params=params)
-                if resp.status_code in (401, 403):
-                    log.warning("ENTSO-E rejected the token (HTTP %s) on forecast — using fallback.",
-                                resp.status_code)
-                    return None
-                resp.raise_for_status()
-                if resp.text and "<TimeSeries" in resp.text:
-                    return resp.text
-                # 'No matching data' (common for A65 in some zones) is not retryable — bail quietly.
-                if "No matching data" in resp.text:
-                    log.debug("ENTSO-E %s: no matching data for %s", document_type, eic)
-                    return None
-                log.debug("ENTSO-E %s empty for %s (attempt %d/%d)", document_type, eic, attempt, attempts)
-            except Exception as e:
-                log.debug("ENTSO-E %s failed for %s (attempt %d/%d): %s",
-                          document_type, eic, attempt, attempts, e)
-            if attempt < attempts:
-                await asyncio.sleep(0.6 * attempt)
-        return None
+        return await self._get_bounded(eic, params, label=document_type, no_match_is_final=True)
 
     async def renewable_forecast(self, provider: Provider, region: str, hours_ahead: int = 24
                                  ) -> list[ForecastHour]:

{greenpick-0.1.4 → greenpick-0.1.6}/src/greenpick/server.py

@@ -18,7 +18,29 @@ from .services import (
 )
 from .models import ServingHub
 
-mcp = FastMCP("greenpick")
+# Sent to every MCP client at connect. Agents learn a server from its tool list, not its README, and
+# the tool list starts with region-picking — so without this they lead with the rarest decision and
+# skip the most valuable one. This names the strongest uses first and the reporting rules that matter.
+INSTRUCTIONS = """\
+GreenPick advises on cloud infrastructure decisions BEFORE you deploy, weighing carbon, cost and \
+latency together. Strongest uses, in order:
+1. Right-sizing (rightsizing_check): an over-provisioned instance cut to a standard, buyable size \
+saves money and carbon in the same move. Lead with the monthly dollar saving.
+2. Scheduling deferrable jobs: cleanest_hours_to_run (one-off), cleanest_time_of_day (recurring), \
+carbon_forecast (EU day-ahead).
+3. GPU training and LLM inference footprints: estimate_training_carbon (gpu_hours is the TOTAL across \
+all GPUs; report wall_clock_hours as the run length), estimate_inference_carbon.
+4. Efficiency and placement: greener_instance_family, compare_regions_tri_axis, greener_alternative_to, \
+serving_pattern_advice; carbon_metric_scaffold for an app to track its own estimated carbon.
+Before recommending a region move, run data_locality_egress_check: egress can erase the win. Mention \
+any residency_note.
+Every carbon figure carries source and quality fields. Report 'mock', 'cached' or 'historical' values \
+as such, never as live readings. If a call fails or output is missing, say so rather than describing \
+what the tool would return. GreenPick estimates; it does not measure running systems or report model \
+accuracy. Use explain_methodology_and_limits when asked how a number was produced.\
+"""
+
+mcp = FastMCP("greenpick", instructions=INSTRUCTIONS)
 _repo = get_repository()
 
 

{greenpick-0.1.4 → greenpick-0.1.6/src/greenpick.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.1.4
+Version: 0.1.6
 Summary: Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs.
 Author-email: "Data Science Advisers, LLC" <info@datascienceadvisers.com>
 License-Expression: MIT
@@ -254,15 +254,39 @@ of the options below.)
 }
 ```
 
-**In a Jupyter notebook or Python script**, set them before you start (or import) the server:
+**In a Jupyter notebook or Python script**, connect with the MCP client library and pass the keys
+in `env`. The library starts GreenPick as a separate process and doesn't forward the notebook's own
+environment variables to it:
 
 ```python
-import os
-os.environ["GREENPICK_CARBON_SOURCE"] = "auto"
-os.environ["EIA_API_KEY"] = "your-eia-key"
-os.environ["ENTSOE_TOKEN"] = "your-entsoe-token"
+import sys
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+params = StdioServerParameters(
+    command=sys.executable,
+    args=["-m", "greenpick"],
+    env={
+        "GREENPICK_CARBON_SOURCE": "auto",
+        "EIA_API_KEY": "your-eia-key",
+        "ENTSOE_TOKEN": "your-entsoe-token",
+    },
+)
+
+# In Jupyter, errlog must be a real file (the notebook's stderr has no fileno()).
+with open("greenpick-server.log", "w") as errlog:
+    async with stdio_client(params, errlog=errlog) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            result = await session.call_tool(
+                "region_carbon_now", {"provider": "aws", "region": "us-west-2"}
+            )
+            print(result.content[0].text)
 ```
 
+Top-level `await` works in Jupyter. In a plain script, put the `with` block inside an `async def`
+and run it with `asyncio.run(...)`.
+
 Every carbon figure includes a `quality` field: `live` means real grid data, `mock` means a
 fallback value. Check it to confirm live data is on.
 

{greenpick-0.1.4 → greenpick-0.1.6}/src/greenpick.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/greenpick.egg-info/entry_points.txt
 src/greenpick.egg-info/requires.txt
 src/greenpick.egg-info/top_level.txt
 src/greenpick/data/__init__.py
+src/greenpick/data/_net.py
 src/greenpick/data/auto_repository.py
 src/greenpick/data/eia_repository.py
 src/greenpick/data/electricitymaps_repository.py

{greenpick-0.1.4 → greenpick-0.1.6}/tests/test_services.py

@@ -1143,3 +1143,111 @@ async def test_serving_echoes_resolved_hub_coordinates():
 def test_catalog_has_no_invented_aws_new_york_region():
     from greenpick.data.static_data import regions
     assert "us-east-nyc" not in regions()["aws"]
+
+
+# --- 0.1.5: secrets never reach logs; a slow upstream can't freeze a tool call ---
+
+import logging
+
+
+def test_http_libraries_do_not_log_request_urls():
+    import greenpick  # noqa: F401  (import side effect sets the levels)
+    # httpx logs full request URLs (which carry our API keys) at INFO; we keep it at WARNING.
+    assert logging.getLogger("httpx").getEffectiveLevel() >= logging.WARNING
+    assert logging.getLogger("httpcore").getEffectiveLevel() >= logging.WARNING
+
+
+@pytest.mark.asyncio
+async def test_eia_key_never_appears_in_logs(monkeypatch, caplog):
+    caplog.set_level(logging.DEBUG)
+    secret = "EIA-SECRET-123"
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(500, text="boom")   # raise_for_status -> exception text embeds URL
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    r = await EIARepository(api_key=secret).carbon_now("aws", "us-east-1")
+    assert r.quality == "mock"
+    assert secret not in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_entsoe_token_never_appears_in_logs(monkeypatch, caplog):
+    caplog.set_level(logging.DEBUG)
+    secret = "ENTSOE-SECRET-456"
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(503, text="unavailable")
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    monkeypatch.setattr("greenpick.data.entsoe_repository.asyncio.sleep", _no_sleep)
+    r = await ENTSOERepository(token=secret).carbon_now("aws", "eu-north-1")
+    assert r.quality == "mock"
+    assert secret not in caplog.text
+
+
+async def _no_sleep(_seconds):
+    return None
+
+
+@pytest.mark.asyncio
+async def test_entsoe_slow_upstream_is_bounded(monkeypatch):
+    import asyncio, time as _time
+    from greenpick.data import entsoe_repository as er
+
+    async def handler(request: httpx.Request) -> httpx.Response:
+        await asyncio.sleep(30)   # an upstream that never answers in time
+        return httpx.Response(200, text="")
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    monkeypatch.setattr(er, "_FETCH_BUDGET_S", 1.0)
+    start = _time.monotonic()
+    r = await ENTSOERepository(token="t").carbon_now("aws", "eu-north-1")
+    assert r.quality == "mock"                    # degraded to the labelled fallback...
+    assert _time.monotonic() - start < 3.0        # ...within the budget, not 30s+
+
+
+@pytest.mark.asyncio
+async def test_entsoe_remembers_an_outage(monkeypatch):
+    calls = {"n": 0}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls["n"] += 1
+        raise httpx.ConnectError("down", request=request)
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    monkeypatch.setattr("greenpick.data.entsoe_repository.asyncio.sleep", _no_sleep)
+    repo = ENTSOERepository(token="t")
+    await repo.carbon_now("aws", "eu-north-1")
+    after_first = calls["n"]
+    assert after_first >= 1
+    # Same zone again (now, and as history): skipped immediately, no new upstream calls.
+    again = await repo.carbon_now("aws", "eu-north-1")
+    await repo.carbon_history("aws", "eu-north-1")
+    assert again.quality == "mock"
+    assert calls["n"] == after_first
+
+
+# --- 0.1.6: server-level instructions steer agents (they read the tool list, not the README) ---
+
+def test_server_sends_instructions_that_lead_with_rightsizing():
+    from greenpick import server
+    text = server.mcp.instructions or ""
+    assert "rightsizing_check" in text
+    # Right-sizing is named before region-picking (the tool list itself starts with region tools).
+    assert text.index("rightsizing_check") < text.index("compare_regions_tri_axis")
+    # The reporting rules that outside agents got wrong in testing.
+    assert "mock" in text and "TOTAL" in text and "data_locality_egress_check" in text
+    # Every tool named in the instructions actually exists.
+    import re, asyncio
+    named = set(re.findall(r"\b[a-z]+(?:_[a-z]+)+\b", text)) - {"wall_clock_hours", "gpu_hours", "residency_note"}
+    registered = {t.name for t in asyncio.run(server.mcp.list_tools())}
+    assert named <= registered, named - registered

greenpick-0.1.4/src/greenpick/__init__.py

@@ -1,7 +0,0 @@
-"""GreenPick — design-time sustainability co-pilot (MCP server).
-
-Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
-delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
-"""
-
-__version__ = "0.1.4"