eightstatecli 0.4.1__tar.gz → 0.4.2__tar.gz

{eightstatecli-0.4.1 → eightstatecli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eightstatecli
-Version: 0.4.1
+Version: 0.4.2
 Summary: Eightstate CLI — unified AI services from the command line
 Project-URL: Homepage, https://github.com/eight-state/eightstate
 Project-URL: Repository, https://github.com/eight-state/eightstate

{eightstatecli-0.4.1 → eightstatecli-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "eightstatecli"
-version = "0.4.1"
+version = "0.4.2"
 description = "Eightstate CLI — unified AI services from the command line"
 readme = "README.md"
 requires-python = ">=3.10"

{eightstatecli-0.4.1 → eightstatecli-0.4.2}/src/escli/commands/research.py

@@ -27,13 +27,27 @@ import urllib.request
 import urllib.error
 from datetime import datetime, timezone
 
-from ..services.credentials import get_key_for_service, call_with_retry, ServiceCallError
+from ..services.credentials import (
+    get_key_for_service,
+    call_with_retry,
+    vend_key,
+    ServiceCallError,
+    CONFIG_DIR,
+)
 
 API_BASE = "https://api.parallel.ai"
 SSE_BETA = "events-sse-2025-07-24"
 MAX_POLL_WAIT = 7200  # 2 hours (ultra8x can take up to 2h)
 POLL_INTERVAL = 10
 
+# Local cache mapping run_id → fingerprint of the issuing key.
+# Used so --status / --result vend the same key that created the run.
+_RUN_OWNERS_FILE = CONFIG_DIR / "parallel-run-owners.json"
+
+# Max times we'll re-vend trying to land on the issuing fingerprint
+# before giving up and using whatever we got.
+_STICKY_VEND_ATTEMPTS = 6
+
 PROCESSORS = [
     "lite", "base", "core", "core2x", "pro", "ultra",
     "ultra2x", "ultra4x", "ultra8x",
@@ -42,6 +56,70 @@ PROCESSORS = [
 ]
 
 
+# ── Run-owner cache ──────────────────────────────────────────────
+
+def _load_run_owners() -> dict:
+    if _RUN_OWNERS_FILE.exists():
+        try:
+            return json.loads(_RUN_OWNERS_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _remember_run_owner(run_id: str, fingerprint: str) -> None:
+    """Persist {run_id -> fingerprint} so later --status/--result can reuse the key."""
+    if not run_id or not fingerprint or fingerprint == "env":
+        return
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        owners = _load_run_owners()
+        owners[run_id] = fingerprint
+        # Cap entries (keep last 500) to bound file size
+        if len(owners) > 500:
+            owners = dict(list(owners.items())[-500:])
+        _RUN_OWNERS_FILE.write_text(json.dumps(owners))
+    except OSError:
+        pass
+
+
+def _recall_run_owner(run_id: str) -> str | None:
+    return _load_run_owners().get(run_id)
+
+
+def _get_key_for_run(run_id: str) -> str | None:
+    """
+    Vend a key suitable for operating on run_id.
+
+    If PARALLEL_API_KEY is set, use it (single-key mode).
+    Otherwise vend from gate. If we remember the issuing fingerprint for this
+    run, retry vending until it matches (gate is headroom-rotated, so we may
+    have to vend a few times). If we can't land on the right key, fall back
+    to whatever vended and warn — caller will see a 404 if it's the wrong org.
+    """
+    env_key = os.environ.get("PARALLEL_API_KEY")
+    if env_key:
+        return env_key
+
+    target = _recall_run_owner(run_id)
+    last_key = None
+    for _ in range(_STICKY_VEND_ATTEMPTS):
+        result = vend_key("parallel")
+        if not result:
+            return None
+        last_key = result["api_key"]
+        if target is None or result["fingerprint"] == target:
+            return last_key
+
+    if target is not None:
+        print(
+            f"  [warn] could not vend issuing key for {run_id} "
+            f"(wanted fingerprint {target[:8]}…); response may 404",
+            file=sys.stderr,
+        )
+    return last_key
+
+
 def _get_api_key() -> str:
     key = get_key_for_service("parallel", "PARALLEL_API_KEY")
     if not key:
@@ -87,7 +165,24 @@ def _api_request(method: str, path: str, api_key: str,
 
 # ── SSE streaming ────────────────────────────────────────────────
 
+def _sse_error_message(payload: dict) -> str:
+    """Pull a readable message out of a Parallel error payload."""
+    err = payload.get("error") if isinstance(payload, dict) else None
+    if isinstance(err, dict):
+        return err.get("message") or err.get("detail") or json.dumps(err)
+    return payload.get("message") or json.dumps(payload)
+
+
 def _stream_sse(api_key: str, run_id: str, quiet: bool = False) -> dict | None:
+    """
+    Stream task progress over SSE.
+
+    Returns:
+        dict   — task output (terminal state: completed)
+        None   — stream ended without terminal state; caller should poll
+    Exits:
+        2 — definitive error (task failed, run not found, wrong-org key)
+    """
     url = f"{API_BASE}/v1beta/tasks/runs/{run_id}/events"
     seen = set()
 
@@ -103,20 +198,45 @@ def _stream_sse(api_key: str, run_id: str, quiet: bool = False) -> dict | None:
 
         try:
             resp = urllib.request.urlopen(req, timeout=600)
+        except urllib.error.HTTPError as e:
+            try:
+                err_payload = json.loads(e.read().decode(errors="replace"))
+                msg = _sse_error_message(err_payload)
+            except Exception:
+                msg = str(e)
+            print(f"  ✗ SSE error ({e.code}): {msg}", file=sys.stderr)
+            sys.exit(2)
         except Exception as e:
             if not quiet:
-                print(f"  [sse] failed: {e}", file=sys.stderr)
+                print(f"  [sse] connect failed: {e}", file=sys.stderr)
             return None
 
+        # Detect non-SSE responses (HTTP 200 + JSON error body).
+        # Parallel returns this when the API key doesn't own the run_id, or
+        # when the run_id is malformed. The Content-Type is still
+        # `text/event-stream` so we can't rely on the header — instead we
+        # buffer non-SSE lines and, if we exit the loop without ever seeing
+        # a real SSE event, treat the buffer as a JSON error body.
+        saw_sse_event = False
+        non_sse_buffer: list[str] = []
+
         try:
             for raw_line in resp:
                 line = raw_line.decode("utf-8", errors="replace").rstrip("\n\r")
+                if not line:
+                    continue
                 if not line.startswith("data: "):
+                    # SSE comments start with ':' and field lines may be
+                    # `event:` / `id:` / `retry:` — ignore those, but capture
+                    # anything that looks like raw content for error-detect.
+                    if line[:1] not in (":",) and not line.startswith(("event:", "id:", "retry:")):
+                        non_sse_buffer.append(line)
                     continue
                 try:
                     event = json.loads(line[6:])
                 except json.JSONDecodeError:
                     continue
+                saw_sse_event = True
 
                 etype = event.get("type", "")
 
@@ -144,12 +264,27 @@ def _stream_sse(api_key: str, run_id: str, quiet: bool = False) -> dict | None:
                         sys.exit(2)
 
                 elif etype == "error":
-                    return None
+                    msg = _sse_error_message(event)
+                    print(f"  ✗ SSE error event: {msg}", file=sys.stderr)
+                    sys.exit(2)
         except Exception:
             pass
         finally:
             resp.close()
 
+        # If the stream produced zero SSE events but had body content,
+        # it's almost certainly an error response (wrong-org key, bad run_id).
+        # Surface it and bail rather than silently reconnecting 25 times.
+        if not saw_sse_event and non_sse_buffer:
+            body = "\n".join(non_sse_buffer)
+            try:
+                payload = json.loads(body)
+                msg = _sse_error_message(payload)
+            except json.JSONDecodeError:
+                msg = body[:300]
+            print(f"  ✗ SSE refused: {msg}", file=sys.stderr)
+            sys.exit(2)
+
     return None
 
 
@@ -345,10 +480,15 @@ def cmd_run(args):
     if getattr(args, "follow_up", None):
         body["previous_interaction_id"] = args.follow_up
 
-    # Submit with retry — vend key, submit task, retry on 402/429
+    # Submit with retry — vend key, submit task, retry on 402/429.
+    # Capture the issuing VendedKey so SSE + polling use the SAME key.
+    # Without this, gate may vend a different org's key for the followup
+    # GET/SSE calls, causing the streamed run_id to look "not found".
     headers = {"parallel-beta": SSE_BETA}
+    captured: dict = {"key": None}
 
     def submit(key):
+        captured["key"] = key
         return _api_request("POST", "/v1/tasks/runs", key.api_key,
                             body=body, extra_headers=headers, raise_on_error=True)
 
@@ -385,11 +525,17 @@ def cmd_run(args):
             print("  ✗ no Parallel API key. Set PARALLEL_API_KEY or add one via the dashboard.", file=sys.stderr)
         return 1
 
-    # From here on, use the same key for polling (already authenticated)
-    api_key = _get_api_key()
+    # Reuse the SAME key that submitted the task for SSE + polling.
+    vended = captured["key"]
+    api_key = vended.api_key if vended is not None else _get_api_key()
     run_id = task["run_id"]
     created_at = task.get("created_at", "")
 
+    # Remember which gate-vended key owns this run, so later
+    # `escli research --status/--result <run_id>` can vend the same one.
+    if vended is not None:
+        _remember_run_owner(run_id, vended.fingerprint)
+
     if not args.quiet:
         print(f"  · run_id: {run_id}", file=sys.stderr)
 
@@ -436,7 +582,7 @@ def cmd_run(args):
 
 def cmd_status(args):
     """Check task run status."""
-    api_key = _get_api_key()
+    api_key = _get_key_for_run(args.run_id) or _get_api_key()
     result = _api_request("GET", f"/v1/tasks/runs/{args.run_id}", api_key)
 
     if args.json:
@@ -511,7 +657,7 @@ def cmd_processors(args):
 
 def cmd_result(args):
     """Fetch completed task result."""
-    api_key = _get_api_key()
+    api_key = _get_key_for_run(args.run_id) or _get_api_key()
 
     # Check status first
     run = _api_request("GET", f"/v1/tasks/runs/{args.run_id}", api_key)