soothe-client-python 1.0.9__tar.gz → 1.0.11__tar.gz

{soothe_client_python-1.0.9 → soothe_client_python-1.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-client-python
-Version: 1.0.9
+Version: 1.0.11
 Summary: WebSocket client + appkit for soothe-daemon (Python)
 Project-URL: Homepage, https://github.com/mirasoth/soothe-client-python
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_client_python-1.0.9 → soothe_client_python-1.0.11}/src/soothe_client/appkit/daemon_session.py

@@ -450,9 +450,7 @@ class DaemonSession:
                     # pre-admit early running can omit turn_id). Idle/stopped
                     # fall through to their gates (cancel idle may omit turn_id).
                     ev_turn_id = frame_turn_id(event)
-                    status_state = (
-                        str(event.get("state") or "") if event_type == "status" else ""
-                    )
+                    status_state = str(event.get("state") or "") if event_type == "status" else ""
                     is_running_status = status_state == "running"
                     is_terminal_status = status_state in {"idle", "stopped"}
                     if (
@@ -463,8 +461,7 @@ class DaemonSession:
                         and not turn_ids_match(expected_turn_id, ev_turn_id)
                     ):
                         logger.debug(
-                            "Ignoring unbound/mismatched turn_id frame type=%s "
-                            "got=%s expected=%s",
+                            "Ignoring unbound/mismatched turn_id frame type=%s got=%s expected=%s",
                             event_type,
                             (ev_turn_id or "<absent>")[-24:],
                             expected_turn_id[-24:],
@@ -518,9 +515,7 @@ class DaemonSession:
                                     self._expected_turn_id = status_turn
                         elif query_started and state == "stopped":
                             stop_turn = frame_turn_id(event)
-                            if expected_turn_id and not turn_ids_match(
-                                expected_turn_id, stop_turn
-                            ):
+                            if expected_turn_id and not turn_ids_match(expected_turn_id, stop_turn):
                                 continue
                             self.last_turn_end_state = state
                             if ev_seq is not None:

{soothe_client_python-1.0.9 → soothe_client_python-1.0.11}/src/soothe_client/command_client.py

@@ -132,34 +132,6 @@ async def _perform_handshake(ws: Any, *, timeout: float) -> None:
             raise RuntimeError(f"Daemon state is {state}")
 
 
-# Command message types
-_AUTOPilot_COMMANDS = {
-    "status": "autopilot_status",
-    "submit": "autopilot_submit",
-    "list_goals": "autopilot_list_goals",
-    "get_goal": "autopilot_get_goal",
-    "cancel_goal": "autopilot_cancel_goal",
-    "cancel_all": "autopilot_cancel_all",
-    "wake": "autopilot_wake",
-    "dream": "autopilot_dream",
-    "resume": "autopilot_resume",
-    "list_jobs": "autopilot_list_jobs",
-    "get_job": "autopilot_get_job",
-}
-
-_CRON_COMMANDS = {
-    "add": "cron_add",
-    "list": "cron_list",
-    "list_jobs": "cron_list",
-    "show": "cron_show",
-    "cancel": "cron_cancel",
-}
-
-_MEMORY_COMMANDS = {
-    "stats": "memory_stats",
-}
-
-
 class AsyncCommandClient:
     """Async client for one-shot daemon RPCs (jobs, autopilot, cron).
 
@@ -186,7 +158,11 @@ class AsyncCommandClient:
         self._timeout = timeout
 
     async def _send_command(
-        self, command_type: str, payload: dict[str, Any] | None = None
+        self,
+        command_type: str,
+        payload: dict[str, Any] | None = None,
+        *,
+        timeout: float | None = None,
     ) -> dict[str, Any]:
         """Send a protocol-1 request envelope and wait for the response.
 
@@ -199,6 +175,8 @@ class AsyncCommandClient:
         Args:
             command_type: RPC method name (e.g. ``"autopilot_status"``).
             payload: Structured parameters object for the method.
+            timeout: Optional per-call override (seconds). Defaults to the
+                client constructor timeout.
 
         Returns:
             The ``result`` dict from the matching ``response`` envelope.
@@ -209,6 +187,7 @@ class AsyncCommandClient:
         """
         import websockets
 
+        cmd_timeout = self._timeout if timeout is None else timeout
         req_id = str(uuid4())
         envelope = WireEnvelope(
             type=MessageType.REQUEST.value,
@@ -218,15 +197,15 @@ class AsyncCommandClient:
         )
 
         try:
-            async with websockets.connect(self._ws_url, open_timeout=self._timeout) as ws:
-                await _perform_handshake(ws, timeout=self._timeout)
+            async with websockets.connect(self._ws_url, open_timeout=cmd_timeout) as ws:
+                await _perform_handshake(ws, timeout=cmd_timeout)
 
                 # Send the protocol-1 request envelope.
                 await ws.send(encode_envelope(envelope))
 
                 # Wait for the matching response/error envelope.
                 while True:
-                    response_str = await asyncio.wait_for(ws.recv(), timeout=self._timeout)
+                    response_str = await asyncio.wait_for(ws.recv(), timeout=cmd_timeout)
                     response = decode_envelope(response_str)
                     if not isinstance(response, dict):
                         raise RuntimeError(f"Unexpected response: {response_str!r}")
@@ -255,7 +234,7 @@ class AsyncCommandClient:
                     continue
 
         except TimeoutError:
-            raise RuntimeError(f"Command timeout after {self._timeout}s") from None
+            raise RuntimeError(f"Command timeout after {cmd_timeout}s") from None
         except websockets.exceptions.ConnectionClosedError as exc:
             raise RuntimeError(f"WebSocket connection closed: {exc}") from exc
         except RuntimeError:
@@ -270,13 +249,24 @@ class AsyncCommandClient:
         return await self._send_command("autopilot_status")
 
     async def autopilot_submit(
-        self, description: str, *, priority: int = 50, workspace: str | None = None
+        self,
+        description: str,
+        *,
+        priority: int = 50,
+        workspace: str | None = None,
+        rail_id: str | None = None,
     ) -> dict[str, Any]:
-        """Submit a new autopilot goal (returns ``goal_id``)."""
+        """Submit a new autopilot goal (returns ``goal_id``).
+
+        Uses a 120s RPC timeout so placement analysis can finish before the
+        client gives up (intake may call the verifier LLM).
+        """
         payload: dict[str, Any] = {"description": description, "priority": priority}
         if workspace:
             payload["workspace"] = workspace
-        return await self._send_command("autopilot_submit", payload)
+        if rail_id:
+            payload["rail_id"] = rail_id
+        return await self._send_command("autopilot_submit", payload, timeout=120.0)
 
     async def autopilot_list_goals(self) -> dict[str, Any]:
         """List all goals (including non-root children)."""
@@ -318,6 +308,14 @@ class AsyncCommandClient:
         """Get a root job with DAG snapshot. Prefer ``job_status`` / ``job_dag``."""
         return await self._send_command("autopilot_get_job", {"job_id": job_id})
 
+    async def autopilot_top(self, *, include_terminal: bool = False) -> dict[str, Any]:
+        """Jobs → goals → loops snapshot for CLI ``top`` (IG-679 / IG-688).
+
+        Args:
+            include_terminal: When true, include terminal goals and jobs.
+        """
+        return await self._send_command("autopilot_top", {"include_terminal": include_terminal})
+
     async def autopilot_subscribe(self) -> dict[str, Any]:
         """Subscribe this connection to autopilot worker events."""
         return await self._send_command("autopilot_subscribe")
@@ -442,13 +440,23 @@ class CommandClient:
         return cast(dict[str, Any], self._run_async(self._client.autopilot_status()))
 
     def autopilot_submit(
-        self, description: str, *, priority: int = 50, workspace: str | None = None
+        self,
+        description: str,
+        *,
+        priority: int = 50,
+        workspace: str | None = None,
+        rail_id: str | None = None,
     ) -> dict[str, Any]:
         """Submit a new autopilot goal."""
         return cast(
             dict[str, Any],
             self._run_async(
-                self._client.autopilot_submit(description, priority=priority, workspace=workspace)
+                self._client.autopilot_submit(
+                    description,
+                    priority=priority,
+                    workspace=workspace,
+                    rail_id=rail_id,
+                )
             ),
         )
 
@@ -488,6 +496,13 @@ class CommandClient:
         """Get a root job with DAG snapshot."""
         return cast(dict[str, Any], self._run_async(self._client.autopilot_get_job(job_id)))
 
+    def autopilot_top(self, *, include_terminal: bool = False) -> dict[str, Any]:
+        """Jobs → goals → loops snapshot for CLI ``top``."""
+        return cast(
+            dict[str, Any],
+            self._run_async(self._client.autopilot_top(include_terminal=include_terminal)),
+        )
+
     def autopilot_subscribe(self) -> dict[str, Any]:
         """Subscribe to autopilot worker events."""
         return cast(dict[str, Any], self._run_async(self._client.autopilot_subscribe()))

{soothe_client_python-1.0.9 → soothe_client_python-1.0.11}/src/soothe_client/protocol_params.py

@@ -38,6 +38,7 @@ __all__ = [
     "AutopilotResumeParams",
     "AutopilotListJobsParams",
     "AutopilotGetJobParams",
+    "AutopilotTopParams",
     # Job RPC params
     "JobCreateParams",
     "JobStatusParams",
@@ -401,6 +402,16 @@ class AutopilotGetJobParams(ParamsBase):
     job_id: str = Field(..., min_length=1)
 
 
+class AutopilotTopParams(ParamsBase):
+    """Params for ``method=autopilot_top`` (IG-679 / IG-688).
+
+    Attributes:
+        include_terminal: Include terminal goals/jobs when true (default false).
+    """
+
+    include_terminal: bool = False
+
+
 # ---------------------------------------------------------------------------
 # Job RPC params
 # ---------------------------------------------------------------------------