soothe-client-python 1.0.21__tar.gz → 1.0.23__tar.gz

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: soothe-client-python
-Version: 1.0.21
+Version: 1.0.23
 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.21 → soothe_client_python-1.0.23}/src/soothe_client/__init__.py

@@ -5,9 +5,6 @@ Public surface::
     from soothe_client import WebSocketClient, is_daemon_live
     from soothe_client import AsyncCommandClient, CommandClient
     from soothe_client.appkit import DaemonSession
-
-Wire request param models: ``soothe_client.protocol_params``.
-Session / multi-user helpers: ``soothe_client.appkit``.
 """
 
 from __future__ import annotations

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/__init__.py

@@ -1,16 +1,8 @@
 """Application helpers built on WebSocketClient.
 
-Primary building blocks for agent UIs and backends:
-
-- ``DaemonSession`` — dual-socket loop session + streamed turns
-- ``ConnectionPool`` / ``TurnRunner`` — multi-session turn execution
-- ``QueryGate`` — one-in-flight query per session
-- ``EventClassifier`` — stream → deliverable mapping
-- ``SSEBroadcaster`` — drop-on-full fan-out to subscribers
-- ``LoopSessionStore`` — persistence seam (Protocol)
-
-Advanced stream/pipeline plumbing lives in submodules
-(``events``, ``chunk_filter``, ``turn``, ``managed_client``).
+Building blocks for agent UIs and backends: `DaemonSession`,
+`ConnectionPool` / `TurnRunner`, `QueryGate`, `EventClassifier`,
+`SSEBroadcaster`, `LoopSessionStore`.
 """
 
 from __future__ import annotations

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/attachments.py

@@ -1,6 +1,6 @@
 """Image attachment compaction for appkit.
 
-Downscales ``image/*`` payloads when either dimension exceeds a max size.
+Downscales `image/*` payloads when either dimension exceeds a max size.
 Non-images and decode failures pass through unchanged.
 """
 
@@ -16,7 +16,7 @@ from PIL import Image
 
 @dataclass(slots=True)
 class CompactImageOptions:
-    """Controls ``compact_image_attachment``. Zero / unset fields use defaults."""
+    """Controls `compact_image_attachment`. Zero / unset fields use defaults."""
 
     max_dim: int = 768
     jpeg_quality: int = 85
@@ -38,15 +38,15 @@ def compact_image_attachment(
     data_b64: str,
     opts: CompactImageOptions | None = None,
 ) -> tuple[str, str]:
-    """Downscale an image attachment when either dimension exceeds ``max_dim``.
+    """Downscale an image attachment when either dimension exceeds `max_dim`.
 
     Args:
-        mime_type: Attachment MIME type (e.g. ``image/png``).
+        mime_type: Attachment MIME type (e.g. `image/png`).
         data_b64: Base64-encoded image bytes.
         opts: Optional size / JPEG quality overrides.
 
     Returns:
-        ``(out_mime, out_b64)``. Non-images and failures return inputs unchanged.
+        `(out_mime, out_b64)`. Non-images and failures return inputs unchanged.
     """
     if not data_b64 or not mime_type.startswith("image/"):
         return mime_type, data_b64
@@ -92,7 +92,7 @@ def compact_attachments(
     atts: list[dict[str, Any]] | None,
     opts: CompactImageOptions | None = None,
 ) -> list[dict[str, Any]]:
-    """Apply ``compact_image_attachment`` to each ``mime_type`` + ``data`` map."""
+    """Apply `compact_image_attachment` to each `mime_type` + `data` map."""
     if not atts:
         return atts or []
     out: list[dict[str, Any]] = []

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/broadcaster.py

@@ -19,7 +19,7 @@ SUBSCRIBER_QUEUE_CAP = 100
 
 @dataclass(frozen=True, slots=True)
 class SSEEvent:
-    """One Server-Sent Event payload. The ``type`` vocabulary is app-defined."""
+    """One Server-Sent Event payload. The `type` vocabulary is app-defined."""
 
     type: str
     data: Any = None
@@ -40,9 +40,9 @@ class SSEBroadcaster:
         self._subscribers: dict[str, dict[str, _Subscriber]] = {}
 
     def subscribe(self, session_id: str) -> tuple[AsyncIterator[SSEEvent], str]:
-        """Register a subscriber and return ``(async iterator, subscription id)``.
+        """Register a subscriber and return `(async iterator, subscription id)`.
 
-        Unsubscribe via ``unsubscribe`` or ``close``.
+        Unsubscribe via `unsubscribe` or `close`.
         """
         sub_id = str(uuid4())
         sub = _Subscriber()

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/card_projection.py

@@ -1,4 +1,4 @@
-"""In-memory apply helpers for daemon ``soothe.card.*`` frames."""
+"""In-memory apply helpers for daemon `soothe.card.*` frames."""
 
 from __future__ import annotations
 

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/chunk_filter.py

@@ -1,7 +1,7 @@
 """Early filters for daemon stream chunks (wire / dict-shaped payloads).
 
 CLI callers that also see LangChain message objects should pass a richer filter
-callback (e.g. ``soothe_cli.runtime.wire.chunk_filter.should_drop_stream_chunk_early``).
+callback (e.g. `soothe_cli.runtime.wire.chunk_filter.should_drop_stream_chunk_early`).
 """
 
 from __future__ import annotations
@@ -12,7 +12,7 @@ _MSG_PAIR_LEN = 2
 
 
 def updates_chunk_is_noop(data: Any) -> bool:
-    """True when an ``updates`` chunk carries no LangGraph interrupt."""
+    """True when an `updates` chunk carries no LangGraph interrupt."""
     if not isinstance(data, dict):
         return True
     return "__interrupt__" not in data
@@ -62,7 +62,7 @@ def _plain_text(msg: dict[str, Any]) -> str:
 
 
 def message_chunk_is_non_actionable(data: Any) -> bool:
-    """True when a wire ``messages`` pair has no tool, text, or loop phase payload."""
+    """True when a wire `messages` pair has no tool, text, or loop phase payload."""
     if not isinstance(data, (list, tuple)) or len(data) != _MSG_PAIR_LEN:
         return False
     msg = data[0]

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/classifier.py

@@ -2,7 +2,7 @@
 
 Maps a stream of decoded daemon events into deliverable/streaming/terminal
 outcomes, keyed on (namespace, mode, phase). Product apps pass their own
-``deliverable_phases`` set; appkit stays product-agnostic.
+`deliverable_phases` set; appkit stays product-agnostic.
 """
 
 from __future__ import annotations
@@ -40,18 +40,17 @@ class ChatEventResult:
 
 @dataclass(frozen=True, slots=True)
 class ClassifierConfig:
-    """Product-specific decisions an ``EventClassifier`` needs.
+    """Product-specific decisions an `EventClassifier` needs.
 
     Attributes:
-        deliverable_phases: Message ``phase`` values that may end a query with
+        deliverable_phases: Message `phase` values that may end a query with
             user-facing text. Required.
         min_deliverable_runes: Minimum trimmed rune count for a reply to be
-            persisted as final (avoids finishing on stub ACKs). Defaults to 8.
+            persisted as final. Defaults to 8.
         thinking_step_events: Optional override of the default thinking-step
             event allowlist.
-        treat_status_idle_as_complete: Standalone ``classify`` only. Prefer
-            ``TurnRunner`` + ``TurnBoundary`` for turn end (DaemonSession
-            contract). Default false.
+        treat_status_idle_as_complete: Standalone `classify` only. Prefer
+            `TurnRunner` + `TurnBoundary` for turn end. Default false.
     """
 
     deliverable_phases: frozenset[str] | set[str]
@@ -100,7 +99,7 @@ class EventClassifier:
         return "soothe.output" in event_type and "responded" in event_type
 
     def is_deliverable_loop_phase(self, phase: str) -> bool:
-        """Return whether ``phase`` is in the configured deliverable set."""
+        """Return whether `phase` is in the configured deliverable set."""
         return phase in self._deliverable_phases
 
     def is_substantive_assistant_reply(self, content: str) -> bool:

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/daemon_session.py

@@ -1,7 +1,7 @@
 """Dual-socket daemon loop session with turn streaming.
 
 Owns a subscribed stream WebSocket plus an RPC sidecar so metadata calls do not
-starve loop events. ``iter_turn_chunks`` handles idle timeout, post-idle drain,
+starve loop events. `iter_turn_chunks` handles idle timeout, post-idle drain,
 loop scoping, and connection-loss detection.
 """
 
@@ -57,9 +57,6 @@ class DaemonSession:
         async for _ns, mode, data in session.iter_turn_chunks():
             ...
         await session.close()
-
-    Advanced: ``early_drop_fn`` / ``stats_factory`` customize stream filtering
-    and metrics for product UIs; most apps leave the defaults.
     """
 
     def __init__(
@@ -103,12 +100,7 @@ class DaemonSession:
         self._drain_saw_successor_running: bool = False
 
     def _reset_turn_seq_floor(self) -> None:
-        """Clear seq/turn filters when the peer seq namespace may have restarted.
-
-        Keep-TUI reconnect after a daemon restart (or subscribe to a different
-        loop) would otherwise drop all low-seq frames — including
-        ``status=running`` — leaving ``query_started=False`` and a silent TUI.
-        """
+        """Clear seq/turn filters when the peer seq namespace may have restarted."""
         self._last_turn_end_seq = 0
         self._last_completed_turn_gen = 0
         self._expected_turn_id = None
@@ -171,7 +163,7 @@ class DaemonSession:
         """Open the stream socket and bootstrap (or resume) a loop session.
 
         Returns:
-            Status event from the daemon (includes ``loop_id`` on success).
+            Status event from the daemon (includes `loop_id` on success).
         """
         await connect_websocket_with_retries(self._client)
         return await self._bootstrap_loop(resume_loop_id=resume_loop_id)
@@ -201,11 +193,7 @@ class DaemonSession:
         return await self._bootstrap_loop(resume_loop_id=loop_id)
 
     async def ensure_connected(self) -> None:
-        """Reconnect and re-subscribe when the stream WebSocket died.
-
-        Prefers ``reconnect`` + ``reattach_and_probe`` when a loop id is known;
-        falls back to bootstrap on ``StaleLoopError``.
-        """
+        """Reconnect and re-subscribe when the stream WebSocket died."""
         from soothe_client.errors import StaleLoopError
 
         is_disconn = getattr(self._client, "is_disconnected", None)
@@ -266,7 +254,7 @@ class DaemonSession:
         self._rpc_connected = False
 
     async def detach(self) -> None:
-        """Notify the daemon that this client is leaving (``disconnect``)."""
+        """Notify the daemon that this client is leaving (`disconnect`)."""
         if not self._client.is_connected:
             logger.debug("Skipping detach — connection already closed")
             return
@@ -289,11 +277,11 @@ class DaemonSession:
         clarification_answer: bool = False,
         clarification_answers: list[str] | None = None,
         intent_hint: str | None = None,
+        autopilot_rail_id: str | None = None,
     ) -> None:
         """Send a user message on the active loop (start of a turn).
 
-        Call ``iter_turn_chunks`` afterward to consume the streamed reply.
-        Requires ``connect()`` (or another bootstrap) first.
+        Call `iter_turn_chunks` afterward to consume the streamed reply.
         """
         if not self._loop_id:
             raise RuntimeError("No active loop session")
@@ -310,10 +298,11 @@ class DaemonSession:
             clarification_answer=clarification_answer,
             clarification_answers=clarification_answers,
             intent_hint=intent_hint,
+            autopilot_rail_id=autopilot_rail_id,
         )
 
     async def cancel_remote_query(self) -> None:
-        """Ask the daemon to cancel via slash ``/cancel`` (CLI wire path)."""
+        """Ask the daemon to cancel via slash `/cancel` (CLI wire path)."""
         await self._client.notify("slash_command", {"cmd": "/cancel"})
 
     async def cancel_active_turn(self) -> None:
@@ -325,10 +314,10 @@ class DaemonSession:
         *,
         expected_loop_id: str | None,
     ) -> AsyncIterator[tuple[tuple[Any, ...], str, Any]]:
-        """Yield stream chunks that arrive just after ``idle``.
+        """Yield stream chunks that arrive just after `idle`.
 
-        If a successor ``status=running`` (generation above the completed floor)
-        arrives, re-queue it and set ``_drain_saw_successor_running`` so the
+        If a successor `status=running` (generation above the completed floor)
+        arrives, re-queue it and set `_drain_saw_successor_running` so the
         caller can continue the reader instead of ending the turn.
         """
         self._drain_saw_successor_running = False
@@ -389,7 +378,7 @@ class DaemonSession:
                 continue
 
     async def list_loops(self, *, limit: int = 20) -> dict[str, Any]:
-        """Return ``loop_list`` via the RPC sidecar."""
+        """Return `loop_list` via the RPC sidecar."""
         async with self._rpc_lock:
             await self._ensure_rpc_connected()
             return await self._rpc_client.request("loop_list", {"limit": limit}, timeout=15.0)
@@ -400,22 +389,15 @@ class DaemonSession:
         max_wait_s: float | None = None,
         idle_timeout_s: float | None = None,
     ) -> AsyncIterator[tuple[tuple[Any, ...], str, Any]]:
-        """Yield ``(namespace, mode, data)`` stream chunks until the turn ends.
+        """Yield `(namespace, mode, data)` stream chunks until the turn ends.
 
         Handles idle timeout, post-idle drain, and turn boundary filtering.
-        Call after ``send_turn``.
+        Call after `send_turn`.
 
         Args:
-            max_wait_s: Optional absolute deadline for the whole turn. When set,
-                raises ``TimeoutError`` if the daemon never emits a turn-end
-                signal in time.
-            idle_timeout_s: Optional hard cap on how long to wait for the *first*
-                progress event before giving up. When set and no progress is seen
-                within this many seconds, raises ``TimeoutError`` instead of the
-                default 30s-log-and-reset behavior. Used by attach-only reads
-                (``skip_daemon_send_turn``) so a stale ``live`` probe that turns
-                out to have no real follow-on turn does not spin the thinking
-                row for minutes.
+            max_wait_s: Optional absolute deadline for the whole turn.
+            idle_timeout_s: Optional cap on how long to wait for the first
+                progress event before raising `TimeoutError`.
         """
         self._ensure_turn_floor_attrs()
         self.turn_event_stats = self._new_turn_stats()
@@ -437,7 +419,7 @@ class DaemonSession:
         first_event_logged = False
         progress_seen = False
         # Wall-clock of the last *real* progress (a yielded chunk). A stale
-        # ``status=running`` frame sets ``progress_seen`` but yields nothing;
+        # `status=running` frame sets `progress_seen` but yields nothing;
         # for the attach-only idle timeout we need a signal that advances when
         # the daemon actually streams content, not when it merely re-announces
         # a (possibly stale) running status.
@@ -474,7 +456,7 @@ class DaemonSession:
                             )
                             turn_read_started = time.monotonic()
                     # Attach-only idle timeout: even after a stale
-                    # ``status=running`` sets ``progress_seen``, no real content
+                    # `status=running` sets `progress_seen`, no real content
                     # may ever arrive (the runner already exited). Bound the wait
                     # for the first yielded chunk so the TUI falls back instead
                     # of spinning the thinking row for minutes.
@@ -735,13 +717,13 @@ class DaemonSession:
         return [s for s in skills if isinstance(s, dict)]
 
     async def list_models(self) -> dict[str, Any]:
-        """Return daemon ``models_list`` result."""
+        """Return daemon `models_list` result."""
         async with self._rpc_lock:
             await self._ensure_rpc_connected()
             return await self._rpc_client.list_models(timeout=15.0)
 
     async def get_mcp_status(self) -> dict[str, Any]:
-        """Return daemon ``mcp_status`` result."""
+        """Return daemon `mcp_status` result."""
         async with self._rpc_lock:
             await self._ensure_rpc_connected()
             return await self._rpc_client.get_mcp_status(timeout=15.0)
@@ -764,20 +746,26 @@ class DaemonSession:
                 interaction_mode=interaction_mode,
             )
 
-    async def set_clarification_mode(self, mode: str) -> bool:
-        """Hot-swap the clarification mode on the running goal (RFC-622).
+    async def set_clarification_mode(
+        self,
+        mode: str,
+        *,
+        interaction_mode: str | None = None,
+    ) -> bool:
+        """Hot-swap the agent mode on the running goal.
 
-        Sends ``loop_set_clarification_mode`` on the RPC socket. Returns
-        ``True`` when the swap landed on a live goal; ``False`` when no goal
-        is currently running (retry on the next turn).
+        Returns `True` on a live goal, `False` when none is running.
         """
         if not self._loop_id:
             return False
+        params: dict[str, Any] = {"loop_id": self._loop_id, "mode": mode}
+        if interaction_mode is not None:
+            params["interaction_mode"] = interaction_mode
         async with self._rpc_lock:
             await self._ensure_rpc_connected()
             result = await self._rpc_client.request(
                 "loop_set_clarification_mode",
-                {"loop_id": self._loop_id, "mode": mode},
+                params,
                 timeout=5.0,
             )
         return bool(result.get("applied", False))
@@ -872,10 +860,7 @@ class DaemonSession:
         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.
-        """
+        """Merge partial StrangeLoop state via daemon `loop_state_update`."""
         lid = str(loop_id or "").strip()
         if not lid or not isinstance(values, dict):
             return {}
@@ -896,11 +881,7 @@ class DaemonSession:
     async def fetch_execution_state(self, loop_id: str) -> SimpleNamespace:
         """Fetch execution-progress snapshot (plan, step_index, iteration, status).
 
-        Returns a namespace with ``plan``, ``step_index``, ``iteration``,
-        ``status``, and ``active_runner`` for the loop's bound checkpoint
-        thread. On RPC failure the fields degrade gracefully (``step_index=0``,
-        ``iteration=0``, ``status=None``, ``plan=None``, ``active_runner=False``)
-        so a resume gate can still proceed.
+        Fields degrade gracefully on RPC failure so a resume gate can still proceed.
         """
         lid = str(loop_id or "").strip()
         empty = SimpleNamespace(
@@ -936,7 +917,7 @@ class DaemonSession:
         iteration = iteration_raw if isinstance(iteration_raw, int) else 0
         status_raw = resp.get("status")
         status = status_raw if isinstance(status_raw, str) else None
-        # ``active_runner`` is absent on daemons older than this field; treat
+        # `active_runner` is absent on daemons older than this field; treat
         # absence as unknown (None) so callers can fall back to status only.
         active_runner_raw = resp.get("active_runner")
         active_runner: bool | None
@@ -987,7 +968,7 @@ class DaemonSession:
         return [m for m in raw if isinstance(m, dict)]
 
     async def fetch_goal_completion_text(self, loop_id: str) -> str | None:
-        """Return the latest persisted ``goal_completion`` body for a loop, if any."""
+        """Return the latest persisted `goal_completion` body for a loop, if any."""
         rows = await self.fetch_conversation_log(loop_id, limit=200, include_events=False)
         for row in reversed(rows):
             if row.get("phase") != "goal_completion":

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/events.py

@@ -6,23 +6,17 @@ from typing import Any
 
 
 def unwrap_next(event: dict[str, Any] | None) -> dict[str, Any] | None:
-    """Unwrap a protocol-1 ``next`` envelope to its inner streaming frame.
+    """Unwrap a protocol-1 `next` envelope to its inner streaming frame.
 
-    Under protocol-1 the daemon wraps free-form streaming frames
-    (``event`` / ``command_response`` / card replay) in a
-    ``{proto, type:"next", payload:{namespace, mode, data}}`` envelope. This
-    helper returns the inner ``data`` dict (the legacy frame) so turn loops
-    can branch on the same fields as before the migration.
-
-    ``status`` / ``error`` / ``response`` / ``complete`` are sent raw and pass
-    through unchanged.
+    Returns the inner `payload.data` dict for `next` envelopes; other
+    types pass through unchanged.
 
     Args:
-        event: A raw wire frame as returned by ``client.read_event()``.
+        event: A raw wire frame from `client.read_event()`.
 
     Returns:
-        The inner ``payload.data`` dict for ``next`` envelopes, the original
-        frame otherwise, or ``None`` if ``event`` is ``None``.
+        The inner `payload.data` dict for `next`, the original frame
+        otherwise, or `None` if `event` is `None`.
     """
     if not isinstance(event, dict):
         return event
@@ -38,16 +32,15 @@ def unwrap_next(event: dict[str, Any] | None) -> dict[str, Any] | None:
 def is_loop_scoped_event(event: dict[str, Any], *, active_loop_id: str) -> bool:
     """Return whether a daemon frame belongs to the active StrangeLoop session.
 
-    Unwraps protocol-1 ``next`` envelopes first, then checks ``loop_id`` on the
-    inner streaming frame. Non-scoped types (``response``, ``error``,
-    ``complete``, etc.) are always considered in-scope.
+    Unwraps `next` envelopes first, then checks `loop_id`. Non-scoped types
+    (`response`, `error`, `complete`) are always in-scope.
 
     Args:
         event: Raw or already-unwrapped wire frame.
         active_loop_id: Loop id for the in-flight session.
 
     Returns:
-        True when the frame should be processed for ``active_loop_id``.
+        True when the frame should be processed for `active_loop_id`.
     """
     event_type = event.get("type", "")
     if event_type == "next":

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/loop_session_store.py

@@ -67,7 +67,7 @@ class LoopSessionStore(Protocol):
     """Persistence seam between appkit and the application's storage backend."""
 
     async def get_session(self, session_id: str) -> LoopSessionEntry | None:
-        """Return the persisted entry for ``session_id``, or None."""
+        """Return the persisted entry for `session_id`, or None."""
         ...
 
     async def create_session(
@@ -89,7 +89,7 @@ class LoopSessionStore(Protocol):
         ...
 
     async def get_loop_id_for_session(self, session_id: str) -> tuple[str, bool]:
-        """Return ``(loop_id, ok)``; ``ok is False`` triggers fresh ``loop_new``."""
+        """Return `(loop_id, ok)`; `ok is False` triggers fresh `loop_new`."""
         ...
 
     async def append_message(self, session_id: str, message: SessionMessage) -> None:

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/managed_client.py

@@ -1,7 +1,7 @@
 """ManagedClient adapter used by ConnectionPool and TurnRunner.
 
-Wraps ``WebSocketClient`` and upgrades flat appkit payloads
-(``loop_input``, ``command_request``, …) to protocol-1 envelopes before send.
+Wraps `WebSocketClient` and upgrades flat appkit payloads to protocol-1
+envelopes before send.
 """
 
 from __future__ import annotations
@@ -18,7 +18,7 @@ BootstrapFunc = Callable[
     Awaitable[str],
 ]
 
-# Flat appkit payloads still use legacy ``{"type": "<op>", ...}`` maps (parity
+# Flat appkit payloads still use legacy `{"type": "<op>", ...}` maps (parity
 # with Go InputMessageForLoop). The live daemon accepts protocol-1 envelopes
 # only — coerce at the ManagedClient boundary before send.
 _ALREADY_ENVELOPE_TYPES = frozenset(
@@ -133,7 +133,7 @@ class ManagedClient(Protocol):
 
 
 class WebSocketManagedClient:
-    """Adapter wrapping ``WebSocketClient`` as a ``ManagedClient``."""
+    """Adapter wrapping `WebSocketClient` as a `ManagedClient`."""
 
     def __init__(self, client: WebSocketClient) -> None:
         self._client = client
@@ -189,7 +189,7 @@ class WebSocketManagedClient:
 
 
 def default_client_factory() -> ClientFactory:
-    """Return a factory that builds ``WebSocketManagedClient`` instances."""
+    """Return a factory that builds `WebSocketManagedClient` instances."""
 
     def _factory(url: str) -> ManagedClient:
         return WebSocketManagedClient(WebSocketClient(url=url))
@@ -198,7 +198,7 @@ def default_client_factory() -> ClientFactory:
 
 
 def default_bootstrap_func() -> BootstrapFunc:
-    """Default bootstrap: ``loop_new`` + ``subscribe(loop_events)``."""
+    """Default bootstrap: `loop_new` + `subscribe(loop_events)`."""
 
     async def _bootstrap(client: ManagedClient, workspace_id: str, user_id: str) -> str:
         from soothe_client.session import bootstrap_loop_session

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/observability.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 class TurnEventStats:
     """Event counts accumulated over a single daemon turn.
 
-    Apps may subclass or replace this via ``DaemonSession``'s stats factory.
+    Apps may subclass or replace this via `DaemonSession`'s stats factory.
     """
 
     total: int = 0

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/pool.py

@@ -3,7 +3,7 @@
 Manages a pool of daemon connections, one active per session. Reuses an
 active connection when still live, otherwise bootstraps a fresh loop or
 reattaches an existing one. Persistence of session↔loop mappings is
-abstracted behind ``LoopSessionStore``.
+abstracted behind `LoopSessionStore`.
 """
 
 from __future__ import annotations
@@ -35,11 +35,7 @@ class ErrPoolExhausted(Exception):  # noqa: N818 — match Go/TS name
 
 @dataclass(slots=True)
 class PoolConfig:
-    """Configures a ``ConnectionPool``. Zero / negative sizes use defaults.
-
-    ``max_idle_time_s`` is enforced on ``acquire`` (idle sessions are released).
-    ``health_check_interval_s`` is reserved for future background sweeps.
-    """
+    """Configures a `ConnectionPool`. Zero / negative sizes use defaults."""
 
     pool_size: int = 1000
     query_timeout_s: float = 30 * 60
@@ -145,9 +141,9 @@ class ConnectionPool:
         workspace_id: str,
         user_id: str,
     ) -> PooledConn:
-        """Return a live connection for ``session_id``.
+        """Return a live connection for `session_id`.
 
-        Caller must ``release`` when done (turn completes or session reset).
+        Caller must `release` when done (turn completes or session reset).
         """
         async with self._lock:
             existing = self._active.get(session_id)
@@ -209,7 +205,7 @@ class ConnectionPool:
         return conn
 
     async def release(self, session_id: str) -> None:
-        """Tear down the connection for ``session_id`` and return a fresh slot."""
+        """Tear down the connection for `session_id` and return a fresh slot."""
         async with self._lock:
             await self._release_unlocked(session_id)
 

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/query_gate.py

@@ -35,7 +35,7 @@ class QueryGate:
         cancel: Callable[[], None],
         send_cancel: SendCancelFn | None = None,
     ) -> None:
-        """Reserve ``session_id`` for one agent turn.
+        """Reserve `session_id` for one agent turn.
 
         Args:
             session_id: Application session key (often the loop id).
@@ -43,7 +43,7 @@ class QueryGate:
             send_cancel: Optional async daemon-cancel sender.
 
         Raises:
-            ErrQueryBusy: A query is already in flight for ``session_id``.
+            ErrQueryBusy: A query is already in flight for `session_id`.
         """
         async with self._lock:
             if session_id in self._cancels:
@@ -80,7 +80,7 @@ class QueryGate:
             self._send_cancels.pop(session_id, None)
 
     async def is_active(self, session_id: str) -> bool:
-        """Return whether a query is in flight for ``session_id``."""
+        """Return whether a query is in flight for `session_id`."""
         async with self._lock:
             return session_id in self._cancels
 

{soothe_client_python-1.0.21 → soothe_client_python-1.0.23}/src/soothe_client/appkit/thinking_step.py

@@ -1,7 +1,6 @@
 """Thinking-step extraction for appkit.
 
-Maps an allowlisted progress event to one structured UI line. Free-form
-streams (tokens, reports, reasoning) are excluded. Ported from Go/TS appkit.
+Maps an allowlisted progress event to one structured UI line.
 """
 
 from __future__ import annotations
@@ -40,7 +39,7 @@ def extract_thinking_step(
         allow: Optional override of the default thinking-step allowlist.
 
     Returns:
-        ``(line, True)`` for a recognized event; ``("", False)`` otherwise.
+        `(line, True)` for a recognized event; `("", False)` otherwise.
     """
     if not event_type or data is None:
         return "", False