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

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

@@ -8,6 +8,19 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: synapse-cli-agent
-Version: 0.1.41
+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.41 → synapse_cli_agent-0.1.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synapse-cli-agent"
-version = "0.1.41"
+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.41 → 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.41 → 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.41 → 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.41 → 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.41 → 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

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.42}/src/synapse/ui/transcript_blocks.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import io
+import re
 import threading
 import time
 from collections.abc import Callable
@@ -47,6 +49,59 @@ _markdown_render_executor = ThreadPoolExecutor(
 )
 
 
+_IMAGE_RENDER_WORKERS = 2
+_image_render_executor = ThreadPoolExecutor(
+    max_workers=_IMAGE_RENDER_WORKERS,
+    thread_name_prefix="synapse-image",
+)
+_IMAGE_MAX_COLS = 100
+_IMAGE_MAX_ROWS = 30
+
+_MD_IMAGE_RE = re.compile(r"!\[[^\]]*\]\(([^)]*)\)")
+
+
+def _image_src(destination: str) -> str:
+    """Extract the image path from an ``![alt](src "title")`` render target."""
+    stripped = destination.strip()
+    return stripped.split()[0] if stripped else ""
+
+
+def split_markdown_images(text: str) -> list[tuple[str, str]]:
+    """Split Markdown into ``(kind, content)`` runs.
+
+    ``image`` runs carry the raw image source from ``![alt](path)``; ``markdown``
+    runs are plain text kept verbatim for the Rich renderer. Used by answer
+    blocks so attached images render through the terminal pixel pipeline.
+    """
+    if not text:
+        return [("markdown", "")]
+    parts: list[tuple[str, str]] = []
+    cursor = 0
+    for match in _MD_IMAGE_RE.finditer(text):
+        if match.start() > cursor:
+            parts.append(("markdown", text[cursor : match.start()]))
+        src = _image_src(match.group(1))
+        if src:
+            parts.append(("image", src))
+        cursor = match.end()
+    if cursor < len(text):
+        parts.append(("markdown", text[cursor:]))
+    return parts or [("markdown", text)]
+
+
+def _read_image_bytes(source: str) -> bytes | None:
+    """Read a local image file in a background worker; ``None`` on failure."""
+    from synapse.ui.workspace import resolve_workspace_path
+
+    path = resolve_workspace_path(source)
+    if path is None:
+        return None
+    try:
+        return path.read_bytes()
+    except Exception:  # noqa: BLE001 - unreadable image falls back to placeholder
+        return None
+
+
 def _render_mermaid_png(source: str) -> bytes | None:
     """Run only native Mermaid PNG rendering in a background worker."""
     from synapse.ui.rendering import render_mermaid_png
@@ -291,6 +346,7 @@ class AnswerBlock(SelectableStatic):
         self._markdown_max_chars = max(1, int(markdown_max_chars))
         self._mermaid_render_generation = 0
         self._markdown_render_generation = 0
+        self._image_render_generation = 0
         # Historical restore defers long-body markdown parsing to a worker so
         # first paint stays cheap: show plain text, then swap in the renderable.
         self._defer_markdown = bool(defer_markdown)
@@ -351,6 +407,9 @@ class AnswerBlock(SelectableStatic):
                 if any(sub.kind == "math" for sub in split_block_math(segment.source)):
                     has_enriched = True
                     break
+                if _MD_IMAGE_RE.search(segment.source):
+                    has_enriched = True
+                    break
             if not has_enriched:
                 return []
 
@@ -370,8 +429,12 @@ class AnswerBlock(SelectableStatic):
                     if sub.kind == "math":
                         widget = make_math_widget(sub.source, color=fg)
                         widgets.append(widget or MathFallbackBlock(sub.source))
-                    elif sub.source.strip():
-                        widgets.append(Static(render_markdown(sub.source)))
+                        continue
+                    for kind, content in split_markdown_images(sub.source):
+                        if kind == "image" and content:
+                            widgets.append(_ImageRenderPlaceholder(content))
+                        elif content.strip():
+                            widgets.append(Static(render_markdown(content)))
             return widgets
         except Exception:  # noqa: BLE001 - composite rendering is optional
             return []
@@ -384,11 +447,13 @@ class AnswerBlock(SelectableStatic):
             if widgets:
                 self.mount(*widgets)
                 self.call_after_refresh(self._start_mermaid_renders)
+                self.call_after_refresh(self._start_image_renders)
         except Exception:  # noqa: BLE001 - widget may be detaching during session switch
             pass
 
     def on_mount(self) -> None:
         self.call_after_refresh(self._start_mermaid_renders)
+        self.call_after_refresh(self._start_image_renders)
         if self._pending_markdown:
             self._pending_markdown = False
             self._schedule_markdown_render(self.body)
@@ -461,8 +526,84 @@ class AnswerBlock(SelectableStatic):
         except Exception:  # noqa: BLE001 - transcript may detach during session switch
             pass
 
+    def _start_image_renders(self) -> None:
+        """Submit unrendered image placeholders without blocking Textual's loop."""
+        if not self.is_attached:
+            return
+        generation = self._image_render_generation
+        for placeholder in self.query(_ImageRenderPlaceholder):
+            if placeholder.render_started:
+                continue
+            placeholder.render_started = True
+            future = _image_render_executor.submit(
+                _read_image_bytes, placeholder.source
+            )
+            future.add_done_callback(
+                lambda completed, target=placeholder, expected=generation: (
+                    self._deliver_image(completed, target, expected)
+                )
+            )
+
+    def _deliver_image(
+        self,
+        future: Future[bytes | None],
+        placeholder: _ImageRenderPlaceholder,
+        generation: int,
+    ) -> None:
+        """Schedule a completed background image load back onto the UI thread."""
+        try:
+            data = future.result()
+        except Exception:  # noqa: BLE001 - app/widget may be shutting down
+            return
+        try:
+            _schedule_on_app_thread(
+                self.app,
+                self._replace_image_placeholder,
+                placeholder,
+                data,
+                generation,
+            )
+        except Exception:  # noqa: BLE001 - app/widget may be shutting down
+            pass
+
+    def _replace_image_placeholder(
+        self,
+        placeholder: _ImageRenderPlaceholder,
+        data: bytes | None,
+        generation: int,
+    ) -> None:
+        """Replace a still-current image placeholder once its file is loaded."""
+        if (
+            generation != self._image_render_generation
+            or not self.is_attached
+            or not placeholder.is_attached
+        ):
+            return
+        widget = None
+        if data:
+            try:
+                from PIL import Image as PILImage
+
+                from synapse.ui.image_render import make_pil_image_widget
+
+                img = PILImage.open(io.BytesIO(data))
+                img.load()
+                widget = make_pil_image_widget(
+                    img, max_cols=_IMAGE_MAX_COLS, max_rows=_IMAGE_MAX_ROWS
+                )
+            except Exception:  # noqa: BLE001 - corrupt image falls back to placeholder
+                widget = None
+        if widget is None:
+            widget = Static(Text(f"[image: {placeholder.source}]", style="dim italic"))
+        try:
+            self.mount(widget, before=placeholder)
+            placeholder.remove()
+        except Exception:  # noqa: BLE001 - transcript may detach during session switch
+            pass
+
     def _render_block(self) -> None:
         self._mermaid_render_generation += 1
+        self._image_render_generation += 1
         body = self.body or ""
         fg = _resolve_color(self._fg_color, _DEFAULT_FG, "fg")
         if self.live:
@@ -560,6 +701,15 @@ class _MermaidRenderPlaceholder(Static):
         super().__init__(Text("Rendering Mermaid diagram...", style="dim italic"))
 
 
+class _ImageRenderPlaceholder(Static):
+    """Lightweight UI-thread placeholder while a local image loads on a worker."""
+
+    def __init__(self, source: str) -> None:
+        self.source = source
+        self.render_started = False
+        super().__init__(Text("Loading image...", style="dim italic"))
+
+
 class _MarkdownBlock(Static):
     """A Markdown transcript block that can rebuild after a theme switch."""
 

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.42}/src/synapse/ui/tui.py

@@ -1490,6 +1490,9 @@ class CodingAgentApp(App[None]):
         # Swap the app's project context.
         self.settings = project_settings
         self.project_root = workspace
+        from synapse.ui.workspace import set_current_workspace
+
+        set_current_workspace(workspace)
         self.thread_id = target_thread
         if turn is not None:
             try:

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.42}/src/synapse/ui/tui_launch.py

@@ -24,6 +24,9 @@ def run_tui(
     # ``run_tui`` re-export, so CodingAgentApp must resolve lazily.
     from synapse.observability.startup_trace import global_mark, span
     from synapse.ui.tui import CodingAgentApp
+    from synapse.ui.workspace import set_current_workspace
+
+    set_current_workspace(settings.workspace)
 
     try:
         from synapse.ui.theme import bootstrap_theme

synapse_cli_agent-0.1.42/src/synapse/ui/workspace.py

@@ -0,0 +1,64 @@
+"""Lightweight workspace-path resolution for UI image rendering.
+
+The file-tool and model-facing tools resolve paths against the session
+workspace; the Rich / Textual render path needs the same anchor so a Markdown
+image reference like ``![alt](chart.png)`` is found regardless of the process
+working directory (started from anywhere, or after a project switch).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+_ACTIVE_WORKSPACE: Path | None = None
+
+
+def set_current_workspace(workspace: Path | str | None) -> None:
+    """Pin the workspace used for UI image-path resolution.
+
+    Call this where the active workspace is (re)established — TUI startup and
+    in-process project switches. Passing ``None`` clears the override so
+    ``current_workspace`` falls back to the process working directory.
+    """
+    global _ACTIVE_WORKSPACE
+    _ACTIVE_WORKSPACE = Path(workspace).resolve() if workspace is not None else None
+
+
+def clear_workspace_cache() -> None:
+    """Drop the pinned workspace so resolution falls back to the cwd."""
+    set_current_workspace(None)
+
+
+def current_workspace() -> Path:
+    """Return the active workspace, or the cwd when none is pinned."""
+    return _ACTIVE_WORKSPACE if _ACTIVE_WORKSPACE is not None else Path.cwd().resolve()
+
+
+def resolve_workspace_path(
+    raw: str | None,
+    *,
+    workspace: Path | str | None = None,
+) -> Path | None:
+    """Resolve ``raw`` against the workspace, or ``None`` for URLs/missing files.
+
+    ``raw`` may be workspace-relative or absolute. HTTP(S) URLs and files that
+    do not exist return ``None`` so callers can fall back to an image
+    placeholder. ``workspace`` overrides the process workspace for tests and
+    explicit contexts.
+    """
+    if not raw:
+        return None
+    text = str(raw).strip()
+    if not text or text.startswith(("http://", "https://")):
+        return None
+    root = Path(workspace).resolve() if workspace is not None else current_workspace()
+    path = Path(text)
+    if not path.is_absolute():
+        path = root / path
+    try:
+        path = path.resolve()
+    except OSError:
+        return None
+    if not path.is_file():
+        return None
+    return path