soothe-client-python 1.0.7__tar.gz → 1.0.8__tar.gz

{soothe_client_python-1.0.7 → soothe_client_python-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-client-python
-Version: 1.0.7
+Version: 1.0.8
 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.7 → soothe_client_python-1.0.8}/src/soothe_client/appkit/daemon_session.py

@@ -20,6 +20,7 @@ from soothe_client.appkit.observability import TurnEventStats
 from soothe_client.session import bootstrap_loop_session, connect_websocket_with_retries
 from soothe_client.stream_terminal import (
     STREAM_END,
+    is_stream_end_cancel_reason,
     is_turn_end_custom_data,
     is_turn_progress_chunk,
 )
@@ -81,6 +82,7 @@ class DaemonSession:
         self.last_turn_end_state: str | None = None
         self.last_turn_cancellation_seen: bool = False
         self.last_turn_error_message: str | None = None
+        self.last_turn_stream_end_reason: str | None = None
         # Last completed turn's seq floor (drop stale prior-turn frames).
         # Scoped to the current peer seq namespace: reset on reconnect / loop
         # change — daemon seq is per-process and restarts after daemon restart.
@@ -359,6 +361,7 @@ class DaemonSession:
         self.last_turn_end_state = None
         self.last_turn_cancellation_seen = False
         self.last_turn_error_message = None
+        self.last_turn_stream_end_reason = None
         inbound_dropped_baseline = getattr(self._client, "inbound_dropped", 0)
         query_started = False
         expected_loop_id = self._loop_id
@@ -555,9 +558,14 @@ class DaemonSession:
                     yield (namespace, mode, data)
                     if mode == "custom" and is_turn_end_custom_data(data):
                         custom_type = str(data.get("type", "")).strip()
-                        self.last_turn_end_state = (
-                            "stream_end" if custom_type == STREAM_END else "completed"
-                        )
+                        if custom_type == STREAM_END:
+                            reason = str(data.get("reason") or "").strip().lower()
+                            self.last_turn_stream_end_reason = reason or None
+                            if is_stream_end_cancel_reason(reason):
+                                self.last_turn_cancellation_seen = True
+                            self.last_turn_end_state = "stream_end"
+                        else:
+                            self.last_turn_end_state = "completed"
                         if ev_seq is not None:
                             self._last_turn_end_seq = max(self._last_turn_end_seq, ev_seq)
                         async for chunk in self._drain_stream_events_after_idle(
@@ -697,6 +705,35 @@ class DaemonSession:
         values: dict[str, Any] = dict(raw) if isinstance(raw, dict) else {}
         return SimpleNamespace(values=values)
 
+    async def aupdate_loop_state(
+        self,
+        loop_id: str,
+        values: dict[str, Any],
+        *,
+        timeout: float = 10.0,
+        as_node: str | None = None,
+    ) -> dict[str, Any]:
+        """Merge partial StrangeLoop state via daemon ``loop_state_update``.
+
+        Used by the TUI for interrupt cleanup and token-total persistence.
+        """
+        lid = str(loop_id or "").strip()
+        if not lid or not isinstance(values, dict):
+            return {}
+
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            try:
+                return await self._rpc_client.loop_state_update(
+                    lid,
+                    values,
+                    as_node=as_node,
+                    timeout=timeout,
+                )
+            except Exception:
+                logger.warning("loop_state_update failed for loop %s", lid[:16], exc_info=True)
+                return {}
+
     async def fetch_execution_state(self, loop_id: str) -> SimpleNamespace:
         """Fetch execution-progress snapshot (plan, step_index, iteration, status).
 

{soothe_client_python-1.0.7 → soothe_client_python-1.0.8}/src/soothe_client/stream_terminal.py

@@ -24,6 +24,16 @@ from soothe_sdk.core.events import (
 
 TURN_END_CUSTOM_TYPES = frozenset({STREAM_END, STRANGE_LOOP_COMPLETED})
 
+# ``soothe.stream.end`` reasons that mean the turn was cancelled (not a clean end).
+STREAM_END_CANCEL_REASONS = frozenset(
+    {
+        "cancelled",
+        "canceled",
+        "user_cancelled",
+        "client_disconnect",
+    }
+)
+
 # Customs that prove this turn has real work (not mere intake plan.phase).
 # Intake-only phases must not unlock turn-end — prior-goal stream.end can still
 # arrive after status=running (loop 3e43).
@@ -64,6 +74,11 @@ def is_turn_end_custom_data(data: Any) -> TypeGuard[dict[str, Any]]:
     return True
 
 
+def is_stream_end_cancel_reason(reason: str | None) -> bool:
+    """True when a ``stream.end`` reason is a cancel/disconnect (not clean end)."""
+    return str(reason or "").strip().lower() in STREAM_END_CANCEL_REASONS
+
+
 def is_turn_progress_chunk(mode: str, data: Any) -> bool:
     """True when a chunk proves the active turn has non-intake progress.
 
@@ -113,8 +128,10 @@ def stale_pending_frame_label(event: dict[str, Any]) -> str | None:
 __all__ = [
     "STALE_TURN_PENDING_TYPES",
     "STREAM_END",
+    "STREAM_END_CANCEL_REASONS",
     "STRANGE_LOOP_COMPLETED",
     "TURN_END_CUSTOM_TYPES",
+    "is_stream_end_cancel_reason",
     "is_turn_end_custom_data",
     "is_turn_progress_chunk",
     "stale_pending_frame_label",