synapse-cli-agent 0.1.40__tar.gz → 0.1.42__tar.gz

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/CHANGELOG.md

@@ -8,6 +8,27 @@ All entries are written in English.
 
 ---
 
+## v0.1.42
+
+### Bug Fixes
+
+- Retried a stale native Responses WebSocket connection once on a fresh socket when the request failed before any output, while avoiding replay after partial streaming output.
+- Classified native WebSocket send/receive connection failures as transient without broadly retrying unrelated operating-system errors.
+
+### Engineering
+
+- Added focused coverage for WebSocket reconnect/replay behavior and transient transport-error classification.
+
+---
+
+## v0.1.41
+
+### New Features
+
+- MCP clients now declare the project workspace as an MCP workspace root, so file-writing tools (e.g. CDP screenshots) can write inside the project workspace instead of being restricted to the OS temp directory when no roots are configured.
+
+---
+
 ## v0.1.40
 
 ### New Features

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: synapse-cli-agent
-Version: 0.1.40
+Version: 0.1.42
 Summary: Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)
 Project-URL: Homepage, https://github.com/alex8224/synapse-agent
 Project-URL: Repository, https://github.com/alex8224/synapse-agent

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synapse-cli-agent"
-version = "0.1.40"
+version = "0.1.42"
 description = "Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)"
 readme = "README.md"
 license = { file = "LICENSE" }

synapse_cli_agent-0.1.42/release_body.md

@@ -0,0 +1,12 @@
+## v0.1.42
+
+### Bug Fixes
+
+- Retried a stale native Responses WebSocket connection once on a fresh socket when the request failed before any output, while avoiding replay after partial streaming output.
+- Classified native WebSocket send/receive connection failures as transient without broadly retrying unrelated operating-system errors.
+
+### Engineering
+
+- Added focused coverage for WebSocket reconnect/replay behavior and transient transport-error classification.
+
+---

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/src/synapse/app/agent.py

@@ -483,10 +483,17 @@ def build_coding_agent(
                     from synapse.integrations.mcp_client import get_mcp_pool_registry
 
                     _pool, mcp_result = get_mcp_pool_registry().acquire(
-                        mcp_pool_key, servers=servers, enabled=True
+                        mcp_pool_key,
+                        servers=servers,
+                        enabled=True,
+                        workspace_root=settings.workspace,
                     )
                 else:
-                    mcp_result = load_mcp_tools(servers, enabled=True)
+                    mcp_result = load_mcp_tools(
+                        servers,
+                        enabled=True,
+                        workspace_root=settings.workspace,
+                    )
             tools.extend(mcp_result.tools)
             build_coding_agent.last_mcp_warnings = list(mcp_result.warnings)  # type: ignore[attr-defined]
             build_coding_agent.last_mcp_servers = list(mcp_result.servers)  # type: ignore[attr-defined]

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/src/synapse/integrations/mcp_client.py

@@ -375,9 +375,14 @@ class _LiveServer:
 class McpSessionPool:
     """Process-local pool of live MCP ClientSessions."""
 
-    def __init__(self) -> None:
+    def __init__(self, *, workspace_root: Path | None = None) -> None:
         self._loop = _LoopThread()
         self._servers: dict[str, _LiveServer] = {}
+        # MCP workspace-roots capability: when set, the client declares this
+        # directory as a root to each server so file-writing tools (e.g. CDP
+        # screenshots) may write inside the project workspace instead of being
+        # restricted to the OS temp directory when no roots are configured.
+        self._workspace_root = Path(workspace_root).resolve() if workspace_root else None
         self._closed = False
         self._follow_active_pool = False
         self.warnings: list[str] = []
@@ -386,6 +391,21 @@ class McpSessionPool:
         # server_name → list of raw tool names (before prefix / filtering)
         self.discovered_tools: dict[str, list[str]] = {}
 
+    async def _list_roots(self, context: Any) -> Any:
+        """Return the project workspace as an MCP root (workspace-roots capability)."""
+        from mcp import types as _mcp_types
+
+        if self._workspace_root is None:
+            return _mcp_types.ListRootsResult(roots=[])
+        return _mcp_types.ListRootsResult(
+            roots=[
+                _mcp_types.Root(
+                    uri=self._workspace_root.as_uri(),
+                    name="workspace",
+                )
+            ]
+        )
+
     @property
     def server_names(self) -> list[str]:
         return sorted(self._servers)
@@ -443,7 +463,13 @@ class McpSessionPool:
         try:
             read, write = await transport_cm.__aenter__()
             transport_entered = True
-            session_cm = ClientSession(read, write)
+            session_cm = ClientSession(
+                read,
+                write,
+                list_roots_callback=self._list_roots
+                if self._workspace_root is not None
+                else None,
+            )
             session = await session_cm.__aenter__()
             session_entered = True
             await session.initialize()
@@ -489,7 +515,13 @@ class McpSessionPool:
         read, write = streams[0], streams[1]
         from mcp import ClientSession
 
-        session_cm = ClientSession(read, write)
+        session_cm = ClientSession(
+            read,
+            write,
+            list_roots_callback=self._list_roots
+            if self._workspace_root is not None
+            else None,
+        )
         session = await session_cm.__aenter__()
         await session.initialize()
         return _LiveServer(
@@ -672,6 +704,7 @@ class McpPoolRegistry:
         *,
         servers: list[Any],
         enabled: bool = True,
+        workspace_root: Path | None = None,
     ) -> tuple[McpSessionPool, McpLoadResult]:
         """Return an existing pool for ``key`` or open a new one."""
         with self._lock:
@@ -684,7 +717,7 @@ class McpPoolRegistry:
                     tool_names=list(existing.tool_names),
                     pool=existing,
                 )
-        pool = McpSessionPool()
+        pool = McpSessionPool(workspace_root=workspace_root)
         result = pool.load(servers) if enabled and servers else McpLoadResult(
             tools=[], warnings=[], servers=[], tool_names=[], pool=pool
         )
@@ -751,6 +784,7 @@ def load_mcp_tools(
     *,
     enabled: bool = True,
     reuse_pool: bool = True,
+    workspace_root: Path | None = None,
 ) -> McpLoadResult:
     """Synchronously load tools from configured MCP servers.
 
@@ -775,7 +809,7 @@ def load_mcp_tools(
         except Exception:  # noqa: BLE001
             pass
 
-    pool = McpSessionPool()
+    pool = McpSessionPool(workspace_root=workspace_root)
     pool._follow_active_pool = True  # noqa: SLF001 - legacy active-pool proxy contract
     try:
         result = pool.load(servers)

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/src/synapse/models/rust_openai.py

@@ -1052,37 +1052,56 @@ class RustOpenAIChatModel(BaseChatModel):
         req = self._build_request(messages, tools=tools, stop=stop, streaming=True, **kwargs)
         response_state: dict[str, Any] = {}
         if self.use_responses_api and self.use_websocket:
-            from synapse.integrations.llm_openai_websocket import (
-                prepare_responses_websocket_event,
-            )
+            from synapse.integrations.llm_openai_websocket import prepare_responses_websocket_event
+            from synapse.runtime.middleware import should_retry_transient_model_error
 
             event = prepare_responses_websocket_event(req)
-            ws: Any | None = None
-            try:
-                ws = self._ensure_websocket()
-                stream = ws.request(json.dumps(event, default=str))
-                for raw in stream:
-                    payload = json.loads(raw)
-                    chunk_msg = aimessage_chunk_from_responses_event(payload, response_state)
-                    if chunk_msg is None:
-                        continue
-                    gen = ChatGenerationChunk(message=chunk_msg)
-                    if run_manager:
-                        text = chunk_msg.content if isinstance(chunk_msg.content, str) else ""
-                        if text:
-                            run_manager.on_llm_new_token(text, chunk=gen)
-                    yield gen
-            except Exception:
-                # A socket error (or consumer cancellation) leaves the connection
-                # unusable; drop it so the next request opens a fresh one.
-                self._reset_websocket()
-                raise
-            except BaseException:
-                # GeneratorExit is raised when a synchronous consumer closes the
-                # iterator early. The native producer then closes its socket, so
-                # do not leave the now-invalid handle cached on this model.
-                self._reset_websocket()
-                raise
+            # A long-lived WebSocket connection sits idle in the cache while the
+            # peer or an intermediate idle-timeout recycles the socket, so the
+            # next ``send_raw`` can fail with a connection-aborted IO error
+            # (Windows 10053) without any warning. Retry once on a fresh
+            # connection, but only before any chunk has been emitted — replaying
+            # after output would duplicate tokens.
+            websocket_replay_attempts = 1
+            for attempt in range(websocket_replay_attempts + 1):
+                response_state = {}
+                yielded_chunk = False
+                try:
+                    ws = self._ensure_websocket()
+                    stream = ws.request(json.dumps(event, default=str))
+                    for raw in stream:
+                        payload = json.loads(raw)
+                        chunk_msg = aimessage_chunk_from_responses_event(payload, response_state)
+                        if chunk_msg is None:
+                            continue
+                        gen = ChatGenerationChunk(message=chunk_msg)
+                        yielded_chunk = True
+                        if run_manager:
+                            text = chunk_msg.content if isinstance(chunk_msg.content, str) else ""
+                            if text:
+                                run_manager.on_llm_new_token(text, chunk=gen)
+                        yield gen
+                    return
+                except Exception as exc:
+                    # A socket error (or consumer cancellation) leaves the
+                    # connection unusable; drop it so the next attempt opens a
+                    # fresh one.
+                    self._reset_websocket()
+                    if (
+                        yielded_chunk
+                        or attempt >= websocket_replay_attempts
+                        or not should_retry_transient_model_error(exc)
+                    ):
+                        raise
+                    # Connection failed before any output; reconnect and retry.
+                    continue
+                except BaseException:
+                    # GeneratorExit is raised when a synchronous consumer closes
+                    # the iterator early. The native producer then closes its
+                    # socket, so do not leave the now-invalid handle cached on
+                    # this model.
+                    self._reset_websocket()
+                    raise
             return
         client = self._ensure_client()
         if self.use_responses_api:

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/src/synapse/runtime/middleware.py

@@ -39,6 +39,18 @@ _TRANSIENT_MODEL_ERROR_MARKERS = (
     "upstream request timeout",
     "rate limit",
     "rate_limit",
+    # Connection-level failures (TCP reset / aborted / timed-out sockets and
+    # the native WebSocket transport) are transient: the underlying peer or an
+    # intermediate idle-timeout recycles the socket, but a fresh connection
+    # usually succeeds. Match these so the model retry middleware recovers the
+    # call instead of surfacing a one-shot "websocket send failed" to the user.
+    "connection reset",
+    "connection aborted",
+    "connection closed",
+    "software caused connection abort",
+    "websocket send failed",
+    "websocket recv failed",
+    "websocket connection is closed",
 )
 
 # ---------------------------------------------------------------------------
@@ -668,11 +680,15 @@ def current_prompt_cleanup_saved_tokens() -> int:
 # Text block prefixes injected by deepagents middleware.  Each block
 # duplicates content already present in the corresponding tool definition
 # (e.g. ``write_todos`` description, filesystem tool docs).  Stripping them
-# saves ~720 tokens per model call without losing any capability.
+# saves tokens per model call without losing any capability.
+#
+# ``## Skills System`` is intentionally NOT stripped: it is the skill index
+# (name + description + path) that lets the model auto-discover and trigger
+# local skills.  Without it, skills are not auto-discoverable from the prompt
+# and must be surfaced via the /skills command or a human pointer.
 
 _REDUNDANT_BLOCK_PREFIXES: tuple[str, ...] = (
     "\n\n## `write_todos`",
-    "\n\n## Skills System",
     "\n\n## Following Conventions",
 )
 

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/src/synapse/ui/rendering.py

@@ -11,6 +11,7 @@ from rich import box
 from rich.console import Console, ConsoleOptions, RenderResult
 from rich.markdown import BlockQuote as _BlockQuote
 from rich.markdown import CodeBlock as _CodeBlock
+from rich.markdown import ImageItem as _RichImageItem
 from rich.markdown import Markdown as _Markdown
 from rich.markdown import MarkdownElement
 from rich.markdown import TableElement as _TableElement
@@ -633,11 +634,77 @@ class _QuoteLineBlockQuote(_BlockQuote):
             yield new_line
 
 
+_IMAGE_MAX_COLS = 100
+_IMAGE_MAX_ROWS = 30
+
+
+def _render_image_path(destination: str) -> Any | None:
+    """Best-effort terminal pixel renderable for a local image path.
+
+    Mirrors ``_render_mermaid_image``: decode the image with Pillow and wrap it
+    in the active ``textual_image`` protocol renderer (sixel / TGP / half-cell /
+    unicode). Returns ``None`` when the path is not a readable local image or no
+    renderer is available so callers can fall back to the Rich ``[image]``
+    placeholder. HTTP(S) URLs are not resolved here and fall through.
+    """
+    if not destination or destination.startswith(("http://", "https://")):
+        return None
+    try:
+        from PIL import Image as PILImage
+
+        from synapse.ui.image_render import (
+            _resolve_renderer,
+            fit_cell_size,
+            renderer_needs_extra_row,
+        )
+        from synapse.ui.workspace import resolve_workspace_path
+
+        renderer_cls = _resolve_renderer()
+        if renderer_cls is None:
+            return None
+        path = resolve_workspace_path(destination)
+        if path is None:
+            return None
+        image = PILImage.open(path)
+        image.load()
+        width, height = image.size
+        cols, rows = fit_cell_size(
+            width,
+            height,
+            max_cols=_IMAGE_MAX_COLS,
+            max_rows=_IMAGE_MAX_ROWS,
+            extra_rows=1 if renderer_needs_extra_row() else 0,
+        )
+        return renderer_cls(image, width=cols, height=rows)
+    except Exception:  # noqa: BLE001 - any image-path failure falls back to placeholder
+        return None
+
+
+class _ImageItem(_RichImageItem):
+    """Markdown image element that renders local images via the pixel pipeline.
+
+    Overrides Rich's ``ImageItem`` placeholder so ``![alt](path)`` resolves a
+    readable local image through ``_render_image_path`` (the same Pillow +
+    ``textual_image`` pipeline used for mermaid / math). Any failure falls back
+    to the original Rich ``[image]`` placeholder.
+    """
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        image = _render_image_path(self.destination)
+        if image is not None:
+            yield image
+            return
+        yield from super().__rich_console__(console, options)
+
+
 class _FullBorderMarkdown(_Markdown):
     """Rich Markdown with full table borders and mermaid diagram fences."""
 
     elements: ClassVar[dict[str, type[MarkdownElement]]] = {
         **_Markdown.elements,
+        "image": _ImageItem,
         "table_open": _FullTableElement,
         "fence": _MermaidCodeBlock,
         "code_block": _MermaidCodeBlock,

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/src/synapse/ui/status_controller.py

@@ -10,6 +10,7 @@ import time
 from typing import Any
 
 from rich.text import Text
+from textual.css.query import NoMatches
 from textual.widgets import Input, Static
 
 import synapse.ui.tui_styles as _styles
@@ -45,7 +46,13 @@ class StatusController:
         self._phase = phase or "idle"
         self._detail = detail
         busy = self._phase not in {"idle", "ready", ""}
-        app.query_one("#status", Static).set_class(busy, "busy")
+        try:
+            app.query_one("#status", Static).set_class(busy, "busy")
+        except NoMatches:
+            # A timer/worker callback can race with screen teardown. Keep the
+            # controller state, but do not turn an already-unmounted UI into
+            # an application error.
+            return
         if busy:
             app.sub_title = f"{model_status_label(app.settings)} · {self._phase}"
         else:
@@ -158,7 +165,12 @@ class StatusController:
         app = self._app
         elapsed = max(0.0, time.monotonic() - self._activity_started)
         busy = self._phase not in {"idle", "ready", ""}
-        status = app.query_one("#status", Static)
+        try:
+            status = app.query_one("#status", Static)
+        except NoMatches:
+            # Textual removes the screen tree before all interval callbacks
+            # have necessarily drained during shutdown.
+            return
         width = max(int(getattr(app.size, "width", 0) or 0), 48)
         # Account for CSS padding (0 2).
         usable = max(16, width - 4)
@@ -228,4 +240,4 @@ class StatusController:
         except Exception:  # noqa: BLE001
             pass
         self.render_status()
-        self.sync_prompt_placeholder()
+        self.sync_prompt_placeholder()

{synapse_cli_agent-0.1.40 → synapse_cli_agent-0.1.42}/src/synapse/ui/transcript/controller.py

@@ -13,6 +13,7 @@ from typing import Any
 
 from rich.text import Text
 from textual.containers import Vertical, VerticalScroll
+from textual.css.query import NoMatches
 from textual.events import MouseUp
 from textual.widgets import Static
 
@@ -188,7 +189,13 @@ class TranscriptController:
     def _mount_block(self, block: Any, *, dismiss_welcome: bool = True) -> None:
         if dismiss_welcome:
             self._dismiss_welcome()
-        timeline = self._app.query_one("#log", VerticalScroll)
+        try:
+            timeline = self._app.query_one("#log", VerticalScroll)
+        except NoMatches:
+            # Background callbacks may arrive after Textual has torn down the
+            # screen tree. The event is no longer renderable, so discard only
+            # the UI write instead of surfacing a shutdown error.
+            return
         follow = timeline.max_scroll_y <= 0 or timeline.scroll_y >= timeline.max_scroll_y - 1
         timeline.mount(block)
         self.state.current_turn_blocks.append(block)
@@ -716,4 +723,4 @@ class TranscriptController:
         st.last_answer_text = ""
         st.last_thought_body = ""
         st.last_thought_elapsed = 0.0
-        st.thought_expanded = False
+        st.thought_expanded = False