@senpi/runtime 3.0.102 → 3.0.103

package/dist/scanners/external/scaffold/senpi_mcp.py

@@ -47,6 +47,16 @@ write to that stream — and the next call opens a fresh one. It is logged as
 `senpi_mcp_error` with `error_type: TimeoutError`, `timeout_seconds` and
 `elapsed_ms` so a stall is distinguishable from a severed stream in ClickStack.
 
+AMENDMENT, third part (dev 2026-09-07): the SDK's transport is an anyio task
+group, so a failure raised through it arrives as an `ExceptionGroup` around the
+real cause. The client classifies and logs the LEAF, never the group: a wrapped
+closed stream still discards the session (the group's own type names no
+transport class, so without unwrapping the dead session would have been kept —
+the original wedge in a new coat), `error_type` is the leaf's class (never
+`ExceptionGroup`), and a sole-leaf group is re-raised to `scan()` as that leaf.
+Several leaves stay a group, logged as the first leaf plus `leaf_count`, and
+rebuild when ANY leaf is a transport failure.
+
 Response normalization MATCHES producer.mjs `createSenpiToolClient`:
     1. isError truthy            -> RAISE with the error text (never a silent None).
     2. structuredContent present -> return it.
@@ -458,8 +468,54 @@ _TRANSPORT_ERROR_NAMES: frozenset[str] = frozenset(
 )
 
 
+# The SDK's `streamablehttp_client` runs an anyio task group, so a failure
+# raised through it (a closed stream, an httpx error on the POST) surfaces as an
+# `ExceptionGroup` wrapping the real cause — observed on dev 2026-09-07 as
+# `error_type: ExceptionGroup, error: "unhandled errors in a TaskGroup (1
+# sub-exception)"` against a 503. Classification and the fleet fingerprint must
+# look at the LEAVES: the group's own MRO names no transport class, so a wrapped
+# `ClosedResourceError` on a live session would otherwise keep the dead session
+# (the pre-rebuild wedge). Matched by name so the `exceptiongroup` backport on
+# Python < 3.11 unwraps like the builtin.
+_EXCEPTION_GROUP_NAME = "BaseExceptionGroup"
+
+
+def _is_exception_group(exc: BaseException) -> bool:
+    return any(klass.__name__ == _EXCEPTION_GROUP_NAME for klass in type(exc).__mro__)
+
+
+def _leaf_exceptions(exc: BaseException) -> list[BaseException]:
+    """Flatten an exception-group tree to its leaves; a plain exception is its own leaf."""
+    if not _is_exception_group(exc):
+        return [exc]
+    leaves: list[BaseException] = []
+    for sub in exc.exceptions:  # type: ignore[attr-defined]
+        leaves.extend(_leaf_exceptions(sub))
+    return leaves or [exc]
+
+
+def _unwrap_sole_leaf(exc: BaseException) -> BaseException:
+    """The one real cause behind a group, else `exc` itself.
+
+    A group with exactly one leaf is the anyio wrapping and nothing more, so
+    the caller gets the leaf. Several leaves are genuinely several failures
+    and stay a group — the log line then names the first leaf and carries the
+    count.
+    """
+    leaves = _leaf_exceptions(exc)
+    return leaves[0] if len(leaves) == 1 else exc
+
+
 def _is_transport_error(exc: BaseException) -> bool:
-    """True when `exc` means the MCP session's transport is unusable."""
+    """True when `exc` means the MCP session's transport is unusable.
+
+    Looks through exception groups: a group is a transport failure when ANY of
+    its leaves is.
+    """
+    return any(_leaf_is_transport_error(leaf) for leaf in _leaf_exceptions(exc))
+
+
+def _leaf_is_transport_error(exc: BaseException) -> bool:
     if isinstance(exc, (OSError, EOFError)):
         return True
     return any(klass.__name__ in _TRANSPORT_ERROR_NAMES for klass in type(exc).__mro__)
@@ -623,22 +679,33 @@ class SenpiMcpClient:
             # unwinds the tick untouched. This is the ONE exit for every failed
             # call, so the tally sees each failure exactly once.
             rebuilt = used is not None and _is_transport_error(exc) and self._discard(used)
-            timed_out = isinstance(exc, SenpiMcpTimeoutError)
+            # Classify and log the LEAF, never the anyio ExceptionGroup around
+            # it (see _leaf_exceptions): the fingerprint has to tell a 503 from
+            # a closed stream. One leaf is the failure; several are logged as
+            # the first leaf plus `leaf_count`.
+            leaves = _leaf_exceptions(exc)
+            primary = leaves[0]
+            timed_out = isinstance(primary, SenpiMcpTimeoutError)
             # The fleet fingerprint for the bound is the builtin category, not
             # the scaffold subclass: ClickStack queries `TimeoutError`. The tally
             # counts under the SAME name, so the dominant type a blind tick
             # reports to /errors matches the senpi_mcp_error lines beside it.
-            error_type = "TimeoutError" if timed_out else type(exc).__name__
+            error_type = "TimeoutError" if timed_out else type(primary).__name__
             self.tick_errors.record(error_type)
             log_event(
                 "senpi_mcp_error",
                 tool=name,
                 error_type=error_type,
-                error=str(exc)[:500],
+                error=str(primary)[:500],
                 elapsed_ms=round((time.monotonic() - started) * 1000, 1),
+                **({"leaf_count": len(leaves)} if len(leaves) > 1 else {}),
                 **({"timeout_seconds": self._call_timeout} if timed_out else {}),
                 **({"session_rebuilt": True} if rebuilt else {}),
             )
+            if len(leaves) == 1 and primary is not exc:
+                # The author's scan() sees the real cause (so `except OSError`
+                # or `except TimeoutError` keeps working), not the wrapper.
+                raise primary
             raise
 
     # -- persistent session lifecycle -------------------------------------
@@ -742,13 +809,17 @@ class SenpiMcpClient:
                     await close_requested.wait()
         except BaseException as exc:
             if not ready.done():
-                # Opening failed: surface it to the waiting call_tool. A
-                # non-Exception (task cancellation) is wrapped so the waiter
-                # gets a plain error instead of blocking forever.
+                # Opening failed: surface it to the waiting call_tool. The
+                # transport's anyio task group wraps the cause in an
+                # ExceptionGroup; the waiter gets the sole leaf (an httpx 503,
+                # a refused connection) so it can classify and re-raise the
+                # real error. A non-Exception (task cancellation) is wrapped
+                # so the waiter gets a plain error instead of blocking forever.
+                cause = _unwrap_sole_leaf(exc)
                 ready.set_exception(
-                    exc
-                    if isinstance(exc, Exception)
-                    else RuntimeError(f"senpi_mcp: session open aborted by {type(exc).__name__}")
+                    cause
+                    if isinstance(cause, Exception)
+                    else RuntimeError(f"senpi_mcp: session open aborted by {type(cause).__name__}")
                 )
             # Otherwise the transport died under a published session (the
             # next call_tool sees `alive` False and rebuilds) or its teardown

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "runtime",
   "name": "Senpi Runtime",
   "description": "Senpi runtime plugin for OpenClaw. Orchestrates scanners, LLM-based trade decisions, and a DSL trailing stop-loss exit engine.",
-  "version": "3.0.102",
+  "version": "3.0.103",
   "commandAliases": [
     {
       "name": "senpi"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senpi/runtime",
-  "version": "3.0.102",
+  "version": "3.0.103",
   "description": "Senpi runtime plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",