soothe-client-python 0.9.7__tar.gz → 0.9.9__tar.gz

{soothe_client_python-0.9.7 → soothe_client_python-0.9.9}/PKG-INFO

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

@@ -18,7 +18,12 @@ from soothe_client.appkit.chunk_filter import should_drop_stream_chunk_early
 from soothe_client.appkit.events import unwrap_next
 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_turn_end_custom_data
+from soothe_client.stream_terminal import (
+    STREAM_END,
+    is_turn_end_custom_data,
+    is_turn_progress_chunk,
+)
+from soothe_client.turn_boundary import frame_seq, frame_turn_id, parse_turn_generation
 from soothe_client.websocket import WebSocketClient
 
 logger = logging.getLogger(__name__)
@@ -62,6 +67,9 @@ 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
+        # IG-659: last completed turn's seq floor (drop stale prior-turn frames).
+        self._last_turn_end_seq: int = 0
+        self._expected_turn_id: str | None = None
 
     @property
     def client(self) -> WebSocketClient:
@@ -310,7 +318,13 @@ class DaemonSession:
         inbound_dropped_baseline = getattr(self._client, "inbound_dropped", 0)
         query_started = False
         expected_loop_id = self._loop_id
+        # Bind turn_id only after this turn's status=running (do not reuse prior).
+        self._expected_turn_id = None
+        expected_turn_id: str | None = None
         stream_payload_seen = False
+        turn_progress_seen = False
+        last_end_seq = int(getattr(self, "_last_turn_end_seq", 0) or 0)
+        self._last_turn_end_seq = last_end_seq
         self._streaming = True
         turn_read_started = time.monotonic()
         first_event_logged = False
@@ -348,9 +362,10 @@ class DaemonSession:
                     if event and not first_event_logged:
                         first_event_logged = True
                         logger.debug(
-                            "First daemon event on turn: type=%s loop_id=%s",
+                            "First daemon event on turn: type=%s loop_id=%s turn_id=%s",
                             event.get("type"),
                             event.get("loop_id"),
+                            frame_turn_id(event),
                         )
                     if not event:
                         if query_started and not self._client.is_connection_alive():
@@ -372,6 +387,33 @@ class DaemonSession:
                     ):
                         continue
 
+                    # IG-659 phase 5: drop frames at or before prior turn end seq.
+                    ev_seq = frame_seq(event)
+                    if ev_seq is not None and last_end_seq > 0 and ev_seq <= last_end_seq:
+                        continue
+
+                    # Drop mismatched turn_id once bound — except status=running,
+                    # which may rebind to a newer generation (pre-admit early
+                    # running can briefly carry a stale or empty turn_id).
+                    ev_turn_id = frame_turn_id(event)
+                    is_running_status = (
+                        event_type == "status" and str(event.get("state") or "") == "running"
+                    )
+                    if (
+                        expected_turn_id
+                        and ev_turn_id
+                        and ev_turn_id != expected_turn_id
+                        and event_type in {"event", "status"}
+                        and not is_running_status
+                    ):
+                        logger.debug(
+                            "Ignoring mismatched turn_id frame type=%s got=%s expected=%s",
+                            event_type,
+                            ev_turn_id[-24:],
+                            expected_turn_id[-24:],
+                        )
+                        continue
+
                     if event_type == "error":
                         err_obj = event.get("error") or {}
                         err_msg = str(
@@ -388,8 +430,24 @@ class DaemonSession:
                         if state == "running":
                             query_started = True
                             progress_seen = True
+                            status_turn = frame_turn_id(event)
+                            if status_turn:
+                                new_gen = parse_turn_generation(status_turn)
+                                old_gen = parse_turn_generation(expected_turn_id)
+                                if expected_turn_id is None or (
+                                    new_gen is not None and (old_gen is None or new_gen >= old_gen)
+                                ):
+                                    if expected_turn_id and status_turn != expected_turn_id:
+                                        # Successor turn admitted while this reader
+                                        # still held a stale/early binding.
+                                        stream_payload_seen = False
+                                        turn_progress_seen = False
+                                    expected_turn_id = status_turn
+                                    self._expected_turn_id = status_turn
                         elif query_started and state == "stopped":
                             self.last_turn_end_state = state
+                            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(
                                 expected_loop_id=expected_loop_id,
                             ):
@@ -399,6 +457,8 @@ class DaemonSession:
                             if not stream_payload_seen and not self.last_turn_cancellation_seen:
                                 continue
                             self.last_turn_end_state = state
+                            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(
                                 expected_loop_id=expected_loop_id,
                             ):
@@ -422,24 +482,40 @@ class DaemonSession:
                         self.turn_event_stats.filtered_early += 1
                         continue
 
-                    # Prior-goal terminal frames can arrive before status=running
-                    # for the new turn; ignoring them prevents a blank second query.
-                    if mode == "custom" and is_turn_end_custom_data(data) and not query_started:
-                        logger.debug(
-                            "Ignoring pre-start turn-end frame %s (loop=%s)",
-                            str(data.get("type", "")).strip(),
-                            (expected_loop_id or "?")[:16],
+                    # Prefer turn_id match when present; else IG-658 progress gate.
+                    if mode == "custom" and is_turn_end_custom_data(data):
+                        data_turn = (
+                            frame_turn_id(data if isinstance(data, dict) else None) or ev_turn_id
                         )
-                        continue
+                        turn_ok = (
+                            not expected_turn_id or not data_turn or data_turn == expected_turn_id
+                        )
+                        if not turn_ok or not query_started or not turn_progress_seen:
+                            logger.debug(
+                                "Ignoring premature turn-end frame %s "
+                                "(loop=%s query_started=%s progress=%s turn_ok=%s)",
+                                str(data.get("type", "")).strip()
+                                if isinstance(data, dict)
+                                else "?",
+                                (expected_loop_id or "?")[:16],
+                                query_started,
+                                turn_progress_seen,
+                                turn_ok,
+                            )
+                            continue
 
                     progress_seen = True
                     stream_payload_seen = True
+                    if is_turn_progress_chunk(mode, data):
+                        turn_progress_seen = True
                     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 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(
                             expected_loop_id=expected_loop_id,
                         ):

{soothe_client_python-0.9.7 → soothe_client_python-0.9.9}/src/soothe_client/stream_terminal.py

@@ -8,10 +8,29 @@ from __future__ import annotations
 
 from typing import Any, TypeGuard
 
-from soothe_sdk.core.events import STRANGE_LOOP_COMPLETED, STREAM_END
+from soothe_sdk.core.events import (
+    PLAN_CREATED,
+    STRANGE_LOOP_COMPLETED,
+    STRANGE_LOOP_STEP_COMPLETED,
+    STRANGE_LOOP_STEP_QUEUED,
+    STRANGE_LOOP_STEP_STARTED,
+    STREAM_END,
+)
 
 TURN_END_CUSTOM_TYPES = frozenset({STREAM_END, STRANGE_LOOP_COMPLETED})
 
+# 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).
+_TURN_PROGRESS_CUSTOM_TYPES = frozenset(
+    {
+        PLAN_CREATED,
+        STRANGE_LOOP_STEP_STARTED,
+        STRANGE_LOOP_STEP_QUEUED,
+        STRANGE_LOOP_STEP_COMPLETED,
+    }
+)
+
 # Handshake / card-replay / subscription leftovers safe to drop at turn start.
 STALE_TURN_PENDING_TYPES = frozenset(
     {
@@ -37,6 +56,26 @@ def is_turn_end_custom_data(data: Any) -> TypeGuard[dict[str, Any]]:
     return True
 
 
+def is_turn_progress_chunk(mode: str, data: Any) -> bool:
+    """True when a chunk proves the active turn has non-intake progress.
+
+    Used so late prior-goal ``stream.end`` cannot close a turn that has only
+    seen intake lifecycle (e.g. plan.phase "Interpreting goal").
+    """
+    if mode in {"messages", "updates"}:
+        return True
+    if mode != "custom" or not isinstance(data, dict):
+        return False
+    if is_turn_end_custom_data(data):
+        return False
+    custom_type = str(data.get("type", "")).strip()
+    if custom_type in _TURN_PROGRESS_CUSTOM_TYPES:
+        return True
+    if custom_type.startswith("soothe.cognition.strange_loop.step"):
+        return True
+    return False
+
+
 def stale_pending_frame_label(event: dict[str, Any]) -> str | None:
     """Return a peel label when ``event`` is safe to drop at turn start."""
     event_type = str(event.get("type") or "")
@@ -69,5 +108,6 @@ __all__ = [
     "STRANGE_LOOP_COMPLETED",
     "TURN_END_CUSTOM_TYPES",
     "is_turn_end_custom_data",
+    "is_turn_progress_chunk",
     "stale_pending_frame_label",
 ]

soothe_client_python-0.9.9/src/soothe_client/turn_boundary.py

@@ -0,0 +1,68 @@
+"""Turn / stream boundary helpers (IG-659).
+
+``turn_id`` correlates a user turn across status, events, and terminals.
+``seq`` is a daemon-assigned monotonic counter per loop for drop-stale filtering.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_turn_id(loop_id: str, generation: int) -> str:
+    """Return wire ``turn_id`` for ``loop_id`` + admit generation."""
+    lid = str(loop_id or "").strip()
+    gen = int(generation)
+    if not lid or gen <= 0:
+        return ""
+    return f"{lid}:{gen}"
+
+
+def parse_turn_generation(turn_id: str | None) -> int | None:
+    """Extract generation int from ``turn_id``, or None if malformed."""
+    raw = str(turn_id or "").strip()
+    if not raw or ":" not in raw:
+        return None
+    suffix = raw.rsplit(":", 1)[-1]
+    try:
+        gen = int(suffix)
+    except ValueError:
+        return None
+    return gen if gen > 0 else None
+
+
+def frame_turn_id(frame: dict[str, Any] | None) -> str | None:
+    """Return ``turn_id`` from a status/event frame or nested custom data."""
+    if not isinstance(frame, dict):
+        return None
+    tid = frame.get("turn_id")
+    if isinstance(tid, str) and tid.strip():
+        return tid.strip()
+    data = frame.get("data")
+    if isinstance(data, dict):
+        inner = data.get("turn_id")
+        if isinstance(inner, str) and inner.strip():
+            return inner.strip()
+    return None
+
+
+def frame_seq(frame: dict[str, Any] | None) -> int | None:
+    """Return non-negative ``seq`` from a wire frame, or None."""
+    if not isinstance(frame, dict):
+        return None
+    raw = frame.get("seq")
+    if isinstance(raw, bool):
+        return None
+    if isinstance(raw, int) and raw >= 0:
+        return raw
+    if isinstance(raw, float) and raw >= 0 and raw == int(raw):
+        return int(raw)
+    return None
+
+
+__all__ = [
+    "format_turn_id",
+    "frame_seq",
+    "frame_turn_id",
+    "parse_turn_generation",
+]