soothe-cli 0.7.18__tar.gz → 0.8.1__tar.gz

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.18
+Version: 0.8.1
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io
@@ -22,6 +22,7 @@ Requires-Dist: pillow<12.0.0,>=10.0.0
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
 Requires-Dist: rich<15.0.0,>=13.0.0
+Requires-Dist: soothe-client-python<1.0.0,>=0.5.25
 Requires-Dist: soothe-sdk<1.0.0,>=0.5.25
 Requires-Dist: textual<10.0.0,>=8.0.0
 Requires-Dist: typer<2.0.0,>=0.9.0

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/pyproject.toml

@@ -23,7 +23,8 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-    "soothe-sdk>=0.5.25,<1.0.0",    # Subagent wire helpers (types owned by soothe subagents)
+    "soothe-sdk>=0.5.25,<1.0.0",    # events/display/wire contracts
+    "soothe-client-python>=0.5.25,<1.0.0",  # WebSocket transport client
     "typer>=0.9.0,<2.0.0",          # CLI framework
     "textual>=8.0.0,<10.0.0",       # TUI framework
     "rich>=13.0.0,<15.0.0",         # Console output

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -14,12 +14,12 @@ from collections import Counter
 from pathlib import Path
 
 import typer
-from soothe_sdk.client import (
+from soothe_client import (
     is_daemon_live,
     websocket_url_from_config,
     ws_command_client_from_config,
 )
-from soothe_sdk.client.protocol import preview_first
+from soothe_sdk.wire.protocol import preview_first
 
 app = typer.Typer(help="Autopilot mode — long-running autonomous agent control.")
 

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/commands/config_cmd.py

@@ -10,7 +10,7 @@ from typing import Annotated, Any
 import typer
 from rich.console import Console
 from rich.panel import Panel
-from soothe_sdk.client import (
+from soothe_client import (
     WebSocketClient,
     request_daemon_config_reload,
     websocket_url_from_config,

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/commands/cron_cmd.py

@@ -21,7 +21,7 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from soothe_sdk.client import (
+from soothe_client import (
     is_daemon_live,
     websocket_url_from_config,
     ws_command_client_from_config,

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/commands/loop_cmd.py

@@ -17,12 +17,14 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.table import Table
-from soothe_sdk.client import (
-    ProtocolError,
+from soothe_client import (
     WebSocketClient,
     is_daemon_live,
     websocket_url_from_config,
 )
+from soothe_sdk.client import (
+    ProtocolError,
+)
 
 from soothe_cli.runtime import load_config
 
@@ -79,13 +81,23 @@ async def _rpc(
     client = WebSocketClient(url=ws_url)
     try:
         await client.connect()
+        await asyncio.wait_for(client.request_connection_init(), timeout=timeout)
+        await asyncio.wait_for(
+            client.wait_for_connection_ack(ack_timeout_s=timeout), timeout=timeout
+        )
         if mode == "notify":
             await asyncio.wait_for(client.notify(method, params or {}), timeout=timeout)
             return {}
         if mode == "subscribe":
-            sub_id = await asyncio.wait_for(client.subscribe(method, params or {}), timeout=timeout)
+            sub_id = await asyncio.wait_for(
+                client.subscribe(method, params or {}, timeout=timeout),
+                timeout=timeout,
+            )
             return {"subscription_id": sub_id}
-        result = await asyncio.wait_for(client.request(method, params or {}), timeout=timeout)
+        result = await asyncio.wait_for(
+            client.request(method, params or {}, timeout=timeout),
+            timeout=timeout,
+        )
         return result if isinstance(result, dict) else {"result": result}
     except TimeoutError:
         return {"error": "Timed out waiting for daemon response"}

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/commands/run_cmd.py

@@ -4,10 +4,9 @@ import logging
 import sys
 import time
 from pathlib import Path
-from typing import Any
 
 import typer
-from soothe_sdk.client.config import SOOTHE_HOME
+from soothe_sdk.paths import SOOTHE_HOME
 from soothe_sdk.utils.logging import resolve_cli_log_level
 
 from soothe_cli.cli.execution import run_headless, run_tui
@@ -37,7 +36,8 @@ def run_impl(
         autonomous: Enable autonomous iteration mode
         max_iterations: Max iterations for autonomous mode
         tui_with_prompt: When True with a prompt, open the TUI instead of headless.
-        mcp_config: Path to additional MCP server config (JSON/YAML) to merge.
+        mcp_config: Deprecated. MCP servers must be configured on the daemon;
+            passing this flag only emits a warning.
     """
     startup_start = time.perf_counter()
     use_headless: bool | None = None  # Track execution mode for exit tip
@@ -45,9 +45,13 @@ def run_impl(
     try:
         cfg = load_config()
 
-        # Merge --mcp-config file into SootheConfig.mcp_servers
+        # MCP servers are owned by the daemon config; CLI cannot merge them post-split.
         if mcp_config:
-            _merge_mcp_config(cfg, mcp_config)
+            typer.echo(
+                "--mcp-config is ignored in the CLI; configure MCP servers on the daemon "
+                f"(~/.soothe/config). Requested file: {mcp_config}",
+                err=True,
+            )
         log_level = resolve_cli_log_level(logging_level=cfg.logging_level)
         log_file = Path(SOOTHE_HOME) / "logs" / "cli.log"
         setup_logging(log_level, log_file=log_file)
@@ -123,60 +127,3 @@ def run_impl(
 
         typer.echo(f"Error: {format_cli_error(e)}", err=True)
         sys.exit(1)
-
-
-def _merge_mcp_config(cfg: Any, mcp_config_path: str) -> None:
-    """Load MCP server config from a JSON/YAML file and merge into SootheConfig.
-
-    Args:
-        cfg: SootheConfig instance.
-        mcp_config_path: Path to MCP config file (JSON or YAML).
-    """
-    import json
-
-    path = Path(mcp_config_path).expanduser().resolve()
-    if not path.is_file():
-        typer.echo(f"--mcp-config: file not found: {path}", err=True)
-        return
-
-    try:
-        raw = path.read_text(encoding="utf-8")
-        if path.suffix in (".yml", ".yaml"):
-            try:
-                import yaml
-
-                data = yaml.safe_load(raw)
-            except ImportError:
-                typer.echo("--mcp-config: PyYAML not installed; use JSON format", err=True)
-                return
-        else:
-            data = json.loads(raw)
-    except Exception as e:
-        typer.echo(f"--mcp-config: failed to parse {path}: {e}", err=True)
-        return
-
-    servers = data.get("mcp_servers") or data.get("servers") or []
-    if not isinstance(servers, list):
-        typer.echo("--mcp-config: expected 'mcp_servers' or 'servers' list", err=True)
-        return
-
-    from soothe.config.models import MCPServerConfig
-
-    new_servers: list[MCPServerConfig] = []
-    for entry in servers:
-        if isinstance(entry, dict):
-            try:
-                new_servers.append(MCPServerConfig(**entry))
-            except Exception as e:
-                logger.warning("Skipping invalid MCP server entry: %s", e)
-
-    if new_servers:
-        existing = list(cfg.mcp_servers) if cfg.mcp_servers else []
-        existing_names = {s.name for s in existing}
-        for s in new_servers:
-            if s.name in existing_names:
-                logger.warning("--mcp-config: server '%s' already in config, skipping", s.name)
-            else:
-                existing.append(s)
-        cfg.mcp_servers = existing
-        logger.info("--mcp-config: merged %d MCP server(s)", len(new_servers))

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/commands/status_cmd.py

@@ -15,7 +15,7 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from soothe_sdk.client import (
+from soothe_client import (
     WebSocketClient,
     check_daemon_status,
     is_daemon_live,

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/execution/daemon.py

@@ -12,13 +12,14 @@ import signal
 from typing import Any
 
 import typer
-from soothe_sdk.client import (
+from soothe_client import (
     WebSocketClient,
     async_ws_command_client_from_config,
     bootstrap_loop_session,
     connect_websocket_with_retries,
     websocket_url_from_config,
 )
+from soothe_client.appkit import is_loop_scoped_event, unwrap_next
 
 from soothe_cli.cli.execution.daemon_errors import (
     friendly_daemon_execution_error,
@@ -39,46 +40,6 @@ _HEADLESS_WORKER_LOST_RETRIES = 1
 _CANCEL_SEND_TIMEOUT_S = 3.0
 
 
-def _unwrap_next(event: dict[str, Any] | None) -> dict[str, Any] | None:
-    """Unwrap a protocol-1 ``next`` envelope to its inner streaming frame.
-
-    Under protocol-1 (RFC-450 §9.3) 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 the headless
-    loop and EventProcessor can branch on the same fields as before.
-    ``status``/``error``/``response``/``complete`` are sent raw and pass
-    through unchanged.
-    """
-    if not isinstance(event, dict):
-        return event
-    if event.get("type") != "next":
-        return event
-    payload = event.get("payload")
-    if not isinstance(payload, dict):
-        return event
-    data = payload.get("data")
-    return data if isinstance(data, dict) else event
-
-
-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.
-    """
-    event_type = event.get("type", "")
-    if event_type == "next":
-        inner = _unwrap_next(event)
-        if isinstance(inner, dict):
-            event_type = inner.get("type", "")
-            return event_type not in {"status", "event"} or (inner.get("loop_id") == active_loop_id)
-    if event_type not in {"status", "event"}:
-        return True
-    return event.get("loop_id") == active_loop_id
-
-
 def _emit_headless_error(message: str) -> None:
     """Write a user-facing error line to stderr (headless renderer convention)."""
     typer.echo(f"ERROR: {message}", err=True)
@@ -120,8 +81,6 @@ async def _run_headless_session_once(
     max_iterations: int | None = None,
 ) -> tuple[int, bool]:
     """Run one headless daemon session; return ``(exit_code, retry_on_worker_loss)``."""
-    from soothe_sdk.client import WebSocketClient
-
     ws_url = websocket_url_from_config(cfg)
     client = WebSocketClient(url=ws_url)
 
@@ -248,13 +207,13 @@ async def _run_headless_session_once(
                 break
 
             event_type = event.get("type", "")
-            if not _is_loop_scoped_event(event, active_loop_id=active_loop_id):
+            if not is_loop_scoped_event(event, active_loop_id=active_loop_id):
                 continue
 
             # Unwrap protocol-1 ``next`` envelopes to the inner streaming frame
             # (RFC-450 §9.3). ``status``/``error`` arrive raw and pass through.
             if event_type == "next":
-                inner = _unwrap_next(event)
+                inner = unwrap_next(event)
                 if isinstance(inner, dict):
                     event = inner
                     event_type = event.get("type", "")
@@ -288,12 +247,12 @@ async def _run_headless_session_once(
                             break
                         if not nxt:
                             break
-                        if not _is_loop_scoped_event(nxt, active_loop_id=active_loop_id):
+                        if not is_loop_scoped_event(nxt, active_loop_id=active_loop_id):
                             continue
                         # Unwrap ``next`` envelopes before handing to the
                         # processor so it sees the legacy frame shape.
                         if nxt.get("type") == "next":
-                            inner = _unwrap_next(nxt)
+                            inner = unwrap_next(nxt)
                             if isinstance(inner, dict):
                                 nxt = inner
                         processor.process_event(nxt)

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/execution/headless.py

@@ -4,7 +4,7 @@ import asyncio
 import sys
 
 import typer
-from soothe_sdk.client import (
+from soothe_client import (
     WebSocketClient,
     is_daemon_live,
     request_daemon_shutdown,

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/cli/main.py

@@ -10,7 +10,7 @@ from pathlib import Path  # noqa: E402
 from typing import Annotated  # noqa: E402
 
 import typer  # noqa: E402
-from soothe_sdk.client.config import SOOTHE_HOME  # noqa: E402
+from soothe_sdk.paths import SOOTHE_HOME  # noqa: E402
 
 from soothe_cli.config.cli_config import CLIConfig  # noqa: E402
 from soothe_cli.config.loader import set_runtime_config  # noqa: E402

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/config/cli_config.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from soothe_sdk.client.config import SOOTHE_HOME
+from soothe_sdk.paths import SOOTHE_HOME
 
 
 @dataclass

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/runtime/headless/processor.py

@@ -35,7 +35,7 @@ from soothe_cli.runtime.policy.tui_trace_log import log_tui_trace
 from soothe_cli.runtime.presentation.engine import PresentationEngine
 
 if TYPE_CHECKING:
-    from soothe_sdk.client.schemas import Plan
+    from soothe_client.schemas import Plan
 
     from soothe_cli.runtime.presentation.renderer_protocol import RendererProtocol
 
@@ -962,7 +962,7 @@ class EventProcessor:
 
     def _handle_plan_created(self, data: dict[str, Any]) -> None:
         """Handle plan creation event."""
-        from soothe_sdk.client.schemas import Plan, PlanStep
+        from soothe_client.schemas import Plan, PlanStep
 
         steps = [
             PlanStep(

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/runtime/headless/processor_state.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from soothe_sdk.client.schemas import Plan
+    from soothe_client.schemas import Plan
 
 from soothe_cli.runtime.state.stream_accumulator import StreamingTextAccumulator
 

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/runtime/parse/tool_result.py

@@ -5,9 +5,11 @@ from __future__ import annotations
 from soothe_sdk.display.tool_result import (
     extract_tool_result_payload,
     infer_tool_output_suggests_error,
+    is_error_tool_result_text,
 )
 
 __all__ = [
     "extract_tool_result_payload",
     "infer_tool_output_suggests_error",
+    "is_error_tool_result_text",
 ]

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/runtime/presentation/renderer_protocol.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Protocol
 
 if TYPE_CHECKING:
-    from soothe_sdk.client.schemas import Plan
+    from soothe_client.schemas import Plan
 
 TaskScope = tuple[str, str]
 

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/runtime/state/step_router.py

@@ -24,6 +24,7 @@ from soothe_sdk.ux.task_namespace import (
     resolve_task_parent_lookup,
     resolve_task_scope_for_namespace,
     row_key_for_subgraph_tool,
+    step_level_parent_task_call_id,
     task_scope_step_id,
     try_bind_namespace_from_tool_call_id,
 )
@@ -93,6 +94,10 @@ class StepTaskRouter:
     _spawns_by_task_id: dict[str, TaskScope] = field(default_factory=dict, repr=False)
     _pending_unscoped_namespaces: deque[tuple[str, ...]] = field(default_factory=deque, repr=False)
     _spawn_recorded: set[tuple[str, str]] = field(default_factory=set, repr=False)
+    _task_index_by_step_and_call: dict[tuple[str, str], int] = field(
+        default_factory=dict, repr=False
+    )
+    _next_task_index_by_step: dict[str, int] = field(default_factory=dict, repr=False)
     _pending_main_tools: dict[str, PendingMainTool] = field(default_factory=dict, repr=False)
     _pending_subgraph_tools: dict[tuple[tuple[str, ...], str], PendingSubgraphTool] = field(
         default_factory=dict,
@@ -108,6 +113,8 @@ class StepTaskRouter:
         self._spawns_by_task_id.clear()
         self._pending_unscoped_namespaces.clear()
         self._spawn_recorded.clear()
+        self._task_index_by_step_and_call.clear()
+        self._next_task_index_by_step.clear()
         self._pending_main_tools.clear()
         self._pending_subgraph_tools.clear()
 
@@ -220,6 +227,11 @@ class StepTaskRouter:
             ]
             for tcid in drop_tcid:
                 self._spawns_by_task_id.pop(tcid, None)
+            # Cleanse per-step synthetic task-index state once the step is done.
+            self._next_task_index_by_step.pop(sid, None)
+            stale_index_keys = [key for key in self._task_index_by_step_and_call if key[0] == sid]
+            for key in stale_index_keys:
+                self._task_index_by_step_and_call.pop(key, None)
 
     def step_id_for_tool(self, tool_call_id: str) -> str:
         """Return execute step id encoded in a unified root tool_call_id."""
@@ -287,7 +299,10 @@ class StepTaskRouter:
             sid = str(step_id).strip()
         if not sid:
             return False
-        normalized_tcid = normalize_main_task_delegation_id(sid, tcid, tool_name="task")
+        normalized_tcid = self.normalize_task_delegation_id(
+            step_id=sid,
+            tool_call_id=tcid,
+        )
         spawn_key = (sid, normalized_tcid)
         if spawn_key in self._spawn_recorded:
             return False
@@ -311,6 +326,42 @@ class StepTaskRouter:
         )
         return True
 
+    def normalize_task_delegation_id(self, *, step_id: str, tool_call_id: str) -> str:
+        """Return canonical ``{step}:s:task:{idx}`` for main ``task`` delegations.
+
+        Some providers emit unified ids like ``{step}:s:call_<uuid>`` that do not
+        encode a task index. In that case allocate a stable per-step synthetic
+        index so task activity rows and standalone SubAgent cards stay 1:1.
+        """
+        sid = str(step_id).strip()
+        tcid = str(tool_call_id).strip()
+        if not sid or not tcid:
+            return tcid
+
+        normalized = normalize_main_task_delegation_id(sid, tcid, tool_name="task")
+        _, type_code, _, tool_info = parse_unified_tool_call_id(normalized)
+        if type_code == "s" and isinstance(tool_info, str):
+            parts = tool_info.split(":")
+            if parts and parts[0] == "task":
+                tail = parts[-1] if parts else ""
+                if tail.isdigit():
+                    idx = int(tail)
+                    key = (sid, tcid)
+                    self._task_index_by_step_and_call[key] = idx
+                    next_idx = self._next_task_index_by_step.get(sid, 0)
+                    if idx >= next_idx:
+                        self._next_task_index_by_step[sid] = idx + 1
+                    return normalized
+
+        key = (sid, tcid)
+        if key in self._task_index_by_step_and_call:
+            idx = self._task_index_by_step_and_call[key]
+        else:
+            idx = self._next_task_index_by_step.get(sid, 0)
+            self._task_index_by_step_and_call[key] = idx
+            self._next_task_index_by_step[sid] = idx + 1
+        return step_level_parent_task_call_id(sid, idx)
+
     def resolve_task_scope(self, namespace: tuple[str, ...]) -> TaskScope | None:
         """Task scope for a stream namespace, if bound."""
         return resolve_task_scope_for_namespace(self._namespace_bindings, namespace)

soothe_cli-0.8.1/src/soothe_cli/runtime/transport/session.py

@@ -0,0 +1,80 @@
+"""Daemon-backed session helpers for the Textual TUI.
+
+Thin CLI wrapper over ``soothe_client.appkit.DaemonSession`` that derives
+WebSocket URL / stream delivery from CLI config and uses the richer CLI early
+chunk filter (LangChain-aware).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from soothe_client.appkit import DaemonSession
+from soothe_client.helpers import websocket_url_from_config
+
+# Re-exported for test monkeypatches / historical import sites.
+from soothe_client.session import (  # noqa: F401
+    bootstrap_loop_session,
+    connect_websocket_with_retries,
+)
+
+from soothe_cli.runtime.state.session_stats import TurnEventStats
+from soothe_cli.runtime.wire.chunk_filter import should_drop_stream_chunk_early
+
+# Match headless daemon client post-idle drain window.
+_POST_IDLE_DRAIN_DEADLINE_S = 0.5
+
+# Brief close handshake on TUI exit — the daemon cleans up on disconnect anyway.
+TUI_EXIT_HANDSHAKE_TIMEOUT_S = 0.3
+
+
+class TuiDaemonSession(DaemonSession):
+    """Own the daemon websocket session used by the TUI."""
+
+    def __init__(
+        self,
+        cfg: Any,
+        *,
+        workspace: str | None = None,
+        post_idle_drain_deadline: float = _POST_IDLE_DRAIN_DEADLINE_S,
+    ) -> None:
+        self._cfg = cfg
+        super().__init__(
+            websocket_url_from_config(cfg),
+            workspace=workspace,
+            stream_delivery=self._resolve_stream_delivery_mode,
+            post_idle_drain_deadline=post_idle_drain_deadline,
+            early_drop_fn=should_drop_stream_chunk_early,
+            stats_factory=TurnEventStats,
+        )
+
+    def _resolve_stream_delivery_mode(self) -> str:
+        """Determine stream delivery mode from config (RFC-614).
+
+        Returns one of ``batch`` | ``adaptive`` | ``streaming``. CLI override
+        wins, then config; defaults to ``adaptive``.
+        """
+        if (
+            self._cfg
+            and hasattr(self._cfg, "output_streaming_mode")
+            and self._cfg.output_streaming_mode
+        ):
+            return str(self._cfg.output_streaming_mode)
+
+        if self._cfg and hasattr(self._cfg, "agent"):
+            streaming_cfg = self._cfg.agent.loop.output_streaming
+            return str(streaming_cfg.mode)
+
+        return "adaptive"
+
+
+# Historical alias used by some call sites / docs.
+DaemonSession = TuiDaemonSession  # noqa: F811
+
+__all__ = [
+    "DaemonSession",
+    "TUI_EXIT_HANDSHAKE_TIMEOUT_S",
+    "TuiDaemonSession",
+    "bootstrap_loop_session",
+    "connect_websocket_with_retries",
+]

soothe_cli-0.8.1/src/soothe_cli/runtime/turn/pipeline.py

@@ -0,0 +1,35 @@
+"""Decouple daemon stream ingestion from chunk processing and UI application.
+
+Canonical implementation lives in ``soothe_client.appkit.turn`` (RFC-629 Layer 1).
+This module re-exports the public API for CLI import stability.
+"""
+
+from __future__ import annotations
+
+from soothe_client.appkit.turn import (
+    _DEFAULT_BATCH_DELAY_MS,
+    _DEFAULT_BATCH_SIZE,
+    _DEFAULT_INBOUND_MAXSIZE,
+    _DEFAULT_OUTBOUND_MAXSIZE,
+    PRIORITY_CRITICAL,
+    PRIORITY_HIGH,
+    PRIORITY_LOW,
+    PRIORITY_NORMAL,
+    TurnApplyBatcher,
+    TurnEventPipeline,
+    run_turn_pipeline,
+)
+
+__all__ = [
+    "PRIORITY_CRITICAL",
+    "PRIORITY_HIGH",
+    "PRIORITY_LOW",
+    "PRIORITY_NORMAL",
+    "TurnApplyBatcher",
+    "TurnEventPipeline",
+    "run_turn_pipeline",
+    "_DEFAULT_BATCH_SIZE",
+    "_DEFAULT_BATCH_DELAY_MS",
+    "_DEFAULT_INBOUND_MAXSIZE",
+    "_DEFAULT_OUTBOUND_MAXSIZE",
+]

{soothe_cli-0.7.18 → soothe_cli-0.8.1}/src/soothe_cli/runtime/wire/message_text.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from soothe_sdk.client.wire import flatten_enveloped_message_dict
+from soothe_sdk.wire.codec import flatten_enveloped_message_dict
 
 
 def wire_message_body(msg: Any) -> Any: