wechatbridge-cli 1.6.0__tar.gz → 1.6.2__tar.gz

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.6.0
+Version: 1.6.2
 Summary: Bridge WeChat messages to agy, Grok Build, or Codex CLIs — text/image/file/voice in, CLI replies and generated files back.
 Author: WeChatBridge contributors
 License: MIT
@@ -195,7 +195,7 @@ Key variables (all have defaults):
 | `AGY_TIMEOUT` | `600` | CLI run timeout in seconds (agy / grok / codex backends) |
 | `WECHATBRIDGE_MAX_OUTBOUND_BYTES` | `104857600` | max file size sent back to WeChat (100 MB) |
 | `WECHATBRIDGE_MAX_INBOUND_BYTES` | `20971520` | max inbound image/file after download (20 MB) |
-| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply |
+| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply (on small RAM hosts, lower this to avoid concurrent CLI memory spikes; see [Memory limits](#memory-limits)) |
 | `WECHATBRIDGE_CONFIRM_TOKEN` | `y` | reply this token to approve a gated dangerous prompt |
 | `WECHATBRIDGE_ENABLE_MCP` | `true` | enable the `/mcp` help text command |
 | `WECHATBRIDGE_ENABLE_SUBAGENT` | `true` | enable the `/agent` prompt-rewrite command |
@@ -261,6 +261,39 @@ sudo systemctl enable --now wechatbridge@bot3
 
 Each instance reads its own config file (`~/.config/wechatbridge/bot2.env`) and keeps state under its own data directory (`~/.local/share/wechatbridge/bot2/`).
 
+#### Memory limits
+
+The multi-instance template (`deploy/wechatbridge@.service`) configures cgroup memory protection:
+
+```ini
+MemoryAccounting=yes
+MemoryHigh=450M
+MemoryMax=512M
+```
+
+- **Why these defaults?** Backend CLI child processes (such as `agy`) can reach ~276 MB+ RSS during a single turn, and spike even higher during image recognition or long conversational sessions. A tight hard cap (e.g. 300 MB) on ~1 GB RAM hosts triggers aggressive page thrashing, deep swap latency, and stream interruptions (`subscriber fell behind updates`). The `450M` soft limit (`MemoryHigh`) triggers gentle reclaim, while `512M` (`MemoryMax`) provides a hard ceiling preventing full-host OOM.
+- **Overriding per-instance via drop-in:** Override memory limits without modifying the base unit template:
+  ```bash
+  sudo mkdir -p /etc/systemd/system/wechatbridge@bot2.service.d/
+  cat << 'EOF' | sudo tee /etc/systemd/system/wechatbridge@bot2.service.d/memory.conf
+  [Service]
+  # for hosts with >= 2 GB RAM
+  MemoryHigh=600M
+  MemoryMax=768M
+  EOF
+  sudo systemctl daemon-reload
+  sudo systemctl restart wechatbridge@bot2
+  ```
+  Verify active limits:
+  ```bash
+  systemctl show wechatbridge@bot2 -p MemoryHigh,MemoryMax
+  ```
+- **Sizing guidance:** The defaults are tuned for small hosts (~1 GB RAM). On larger hosts with ample headroom, limits can be relaxed. When deploying multiple instances, note that each instance runs in its own service cgroup — budget for the worst-case combined ceiling of N × MemoryMax across running instances.
+- **Interaction with concurrency:** Concurrent heavy turns (e.g. multiple users sending images at once) multiply backend CLI memory consumption. On memory-constrained hosts, prioritize lowering `WECHATBRIDGE_MAX_CONCURRENT` (e.g. to `2` or `1`) before increasing memory caps.
+- **Swap configuration:** Avoid tightening `MemorySwapMax` — swap margin serves as a vital safety buffer that slows execution under pressure instead of triggering an immediate cgroup OOM kill.
+- **Single-instance deployments:** The single-instance unit `deploy/wechatbridge.service` includes the same built-in memory limits (`MemoryHigh=450M` and `MemoryMax=512M`). To adjust them, override via a drop-in under `/etc/systemd/system/wechatbridge.service.d/` and replace the unit name in the `systemctl` commands above with `wechatbridge`. Takes effect when the unit file is installed or re-installed; `update.sh` upgrades do not touch unit files.
+- **Platform scope:** These cgroup memory limits apply only to Linux systemd deployments; the macOS (launchd) and Windows (Task Scheduler) paths have no equivalent per-instance cap.
+
 ### macOS (launchd)
 
 ```bash
@@ -302,7 +335,7 @@ Other `/…` commands are either rejected (e.g. `/exit`), reported as unsupporte
 - **Danger gate is keyword-based**, not full intent understanding. Defaults target concrete patterns (`rm -rf /`, pipe-to-shell, `mkfs`, `format c:`, a few heavy Chinese phrases, …). Everyday wording like bare “delete” is **not** gated. Override list via `WECHATBRIDGE_CONFIRM_KEYWORDS`; approve with `WECHATBRIDGE_CONFIRM_TOKEN` (default `y`), TTL `WECHATBRIDGE_PENDING_TTL`.
 - **Inbound media** is size-capped (default 20 MB), streamed, and CDN hosts are allowlisted. Missing `aes_key` returns a clear error.
 - **Outbound artifacts** only leave the allowed per-user tree (agy: session scratch; grok: under session dir; dsh: under session dir), after `realpath` checks, and only if under `WECHATBRIDGE_MAX_OUTBOUND_BYTES`.
-- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap.
+- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap (heavy concurrent tasks multiply subprocess memory; see [Memory limits](#memory-limits)).
 - **Long replies** are split into chunks (`WECHATBRIDGE_MESSAGE_CHUNK`, default 2000 characters).
 - **Data layout:** instance data under `~/.local/share/wechatbridge/<instance>/` (override with env). Runtime dirs prefer `0700`; token/QR files prefer `0600` (Unix; Windows relies on NTFS ACLs).
 - **Retention:** session temps vs dialogue history use separate TTLs (`WECHATBRIDGE_SESSION_RETENTION_DAYS`, `WECHATBRIDGE_HISTORY_RETENTION_DAYS`). Prefs/auth are kept.

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.2}/README.md

@@ -163,7 +163,7 @@ Key variables (all have defaults):
 | `AGY_TIMEOUT` | `600` | CLI run timeout in seconds (agy / grok / codex backends) |
 | `WECHATBRIDGE_MAX_OUTBOUND_BYTES` | `104857600` | max file size sent back to WeChat (100 MB) |
 | `WECHATBRIDGE_MAX_INBOUND_BYTES` | `20971520` | max inbound image/file after download (20 MB) |
-| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply |
+| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply (on small RAM hosts, lower this to avoid concurrent CLI memory spikes; see [Memory limits](#memory-limits)) |
 | `WECHATBRIDGE_CONFIRM_TOKEN` | `y` | reply this token to approve a gated dangerous prompt |
 | `WECHATBRIDGE_ENABLE_MCP` | `true` | enable the `/mcp` help text command |
 | `WECHATBRIDGE_ENABLE_SUBAGENT` | `true` | enable the `/agent` prompt-rewrite command |
@@ -229,6 +229,39 @@ sudo systemctl enable --now wechatbridge@bot3
 
 Each instance reads its own config file (`~/.config/wechatbridge/bot2.env`) and keeps state under its own data directory (`~/.local/share/wechatbridge/bot2/`).
 
+#### Memory limits
+
+The multi-instance template (`deploy/wechatbridge@.service`) configures cgroup memory protection:
+
+```ini
+MemoryAccounting=yes
+MemoryHigh=450M
+MemoryMax=512M
+```
+
+- **Why these defaults?** Backend CLI child processes (such as `agy`) can reach ~276 MB+ RSS during a single turn, and spike even higher during image recognition or long conversational sessions. A tight hard cap (e.g. 300 MB) on ~1 GB RAM hosts triggers aggressive page thrashing, deep swap latency, and stream interruptions (`subscriber fell behind updates`). The `450M` soft limit (`MemoryHigh`) triggers gentle reclaim, while `512M` (`MemoryMax`) provides a hard ceiling preventing full-host OOM.
+- **Overriding per-instance via drop-in:** Override memory limits without modifying the base unit template:
+  ```bash
+  sudo mkdir -p /etc/systemd/system/wechatbridge@bot2.service.d/
+  cat << 'EOF' | sudo tee /etc/systemd/system/wechatbridge@bot2.service.d/memory.conf
+  [Service]
+  # for hosts with >= 2 GB RAM
+  MemoryHigh=600M
+  MemoryMax=768M
+  EOF
+  sudo systemctl daemon-reload
+  sudo systemctl restart wechatbridge@bot2
+  ```
+  Verify active limits:
+  ```bash
+  systemctl show wechatbridge@bot2 -p MemoryHigh,MemoryMax
+  ```
+- **Sizing guidance:** The defaults are tuned for small hosts (~1 GB RAM). On larger hosts with ample headroom, limits can be relaxed. When deploying multiple instances, note that each instance runs in its own service cgroup — budget for the worst-case combined ceiling of N × MemoryMax across running instances.
+- **Interaction with concurrency:** Concurrent heavy turns (e.g. multiple users sending images at once) multiply backend CLI memory consumption. On memory-constrained hosts, prioritize lowering `WECHATBRIDGE_MAX_CONCURRENT` (e.g. to `2` or `1`) before increasing memory caps.
+- **Swap configuration:** Avoid tightening `MemorySwapMax` — swap margin serves as a vital safety buffer that slows execution under pressure instead of triggering an immediate cgroup OOM kill.
+- **Single-instance deployments:** The single-instance unit `deploy/wechatbridge.service` includes the same built-in memory limits (`MemoryHigh=450M` and `MemoryMax=512M`). To adjust them, override via a drop-in under `/etc/systemd/system/wechatbridge.service.d/` and replace the unit name in the `systemctl` commands above with `wechatbridge`. Takes effect when the unit file is installed or re-installed; `update.sh` upgrades do not touch unit files.
+- **Platform scope:** These cgroup memory limits apply only to Linux systemd deployments; the macOS (launchd) and Windows (Task Scheduler) paths have no equivalent per-instance cap.
+
 ### macOS (launchd)
 
 ```bash
@@ -270,7 +303,7 @@ Other `/…` commands are either rejected (e.g. `/exit`), reported as unsupporte
 - **Danger gate is keyword-based**, not full intent understanding. Defaults target concrete patterns (`rm -rf /`, pipe-to-shell, `mkfs`, `format c:`, a few heavy Chinese phrases, …). Everyday wording like bare “delete” is **not** gated. Override list via `WECHATBRIDGE_CONFIRM_KEYWORDS`; approve with `WECHATBRIDGE_CONFIRM_TOKEN` (default `y`), TTL `WECHATBRIDGE_PENDING_TTL`.
 - **Inbound media** is size-capped (default 20 MB), streamed, and CDN hosts are allowlisted. Missing `aes_key` returns a clear error.
 - **Outbound artifacts** only leave the allowed per-user tree (agy: session scratch; grok: under session dir; dsh: under session dir), after `realpath` checks, and only if under `WECHATBRIDGE_MAX_OUTBOUND_BYTES`.
-- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap.
+- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap (heavy concurrent tasks multiply subprocess memory; see [Memory limits](#memory-limits)).
 - **Long replies** are split into chunks (`WECHATBRIDGE_MESSAGE_CHUNK`, default 2000 characters).
 - **Data layout:** instance data under `~/.local/share/wechatbridge/<instance>/` (override with env). Runtime dirs prefer `0700`; token/QR files prefer `0600` (Unix; Windows relies on NTFS ACLs).
 - **Retention:** session temps vs dialogue history use separate TTLs (`WECHATBRIDGE_SESSION_RETENTION_DAYS`, `WECHATBRIDGE_HISTORY_RETENTION_DAYS`). Prefs/auth are kept.

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.2}/tests/test_hardening.py

@@ -2302,6 +2302,28 @@ class TestClassifyCliError(unittest.TestCase):
     def test_network_unreachable(self):
         self.assertEqual(self._cat("network is unreachable"), "network")
 
+    # --- agent_stream_interrupted -------------------------------------------------
+
+    def test_agent_stream_interrupted_real_error(self):
+        err = "Error: the connection to the agent was interrupted before the response finished: subscriber fell behind updates, stalled for 8s"
+        self.assertEqual(self._cat(err), "agent_stream_interrupted")
+
+    def test_agent_stream_interrupted_stalled_variants(self):
+        self.assertEqual(self._cat("subscriber fell behind updates, stalled for 5s"), "agent_stream_interrupted")
+        self.assertEqual(self._cat("subscriber fell behind updates, stalled for 13s"), "agent_stream_interrupted")
+        self.assertEqual(self._cat("subscriber fell behind updates, stalled for 13 s"), "agent_stream_interrupted")
+        self.assertEqual(self._cat("stalled for 8s"), "agent_stream_interrupted")
+
+    def test_agent_stream_interrupted_conversation_stream_failed(self):
+        self.assertEqual(self._cat("conversation update stream failed"), "agent_stream_interrupted")
+
+    def test_agent_stream_interrupted_connection_interrupted(self):
+        self.assertEqual(self._cat("connection to the agent was interrupted"), "agent_stream_interrupted")
+
+    def test_agent_stream_interrupted_negative_installed(self):
+        err = "package wechatbridge-cli 1.6.0, installed using Python 3.13.5"
+        self.assertNotEqual(self._cat(err), "agent_stream_interrupted")
+
     # --- cascade_timeout ----------------------------------------------------------
 
     def test_cascade_timeout(self):
@@ -2404,6 +2426,12 @@ class TestFormatCliErrorCategories(unittest.TestCase):
         out = self._fmt("connection refused")
         self.assertIn("网络错误", out)
 
+    def test_agent_stream_interrupted_copy(self):
+        out = self._fmt("Error: the connection to the agent was interrupted before the response finished: subscriber fell behind updates, stalled for 8s")
+        self.assertIn("助手连接中断", out)
+        self.assertIn("❌", out)
+        self.assertIn("/new", out)
+
     def test_timeout_still_error(self):
         out = self._fmt("timeout")
         self.assertIn("超时", out)
@@ -2439,6 +2467,12 @@ class TestFormatCliErrorNoRawInReply(unittest.TestCase):
         self.assertNotIn("rate", out.lower())
         self.assertNotIn("limit", out.lower())
 
+    def test_no_raw_agent_stream_interrupted(self):
+        out = self._fmt("Error: the connection to the agent was interrupted before the response finished: subscriber fell behind updates, stalled for 8s")
+        self.assertNotIn("subscriber", out.lower())
+        self.assertNotIn("interrupted", out.lower())
+        self.assertNotIn("stalled", out.lower())
+
 
 class TestFormatCliErrorLogging(unittest.TestCase):
     """format_cli_error logs category, not raw text."""
@@ -2797,5 +2831,157 @@ class TestUpdateScriptPackageMatch(unittest.TestCase):
             shutil.rmtree(td, ignore_errors=True)
 
 
+class _FakeAgyProc:
+    def __init__(self, stdout: str, stderr: str, rc: int = 0, pid: int = 4242):
+        self._stdout = stdout.encode("utf-8")
+        self._stderr = stderr.encode("utf-8")
+        self.returncode = rc
+        self.pid = pid
+
+    async def communicate(self):
+        return self._stdout, self._stderr
+
+    def kill(self):
+        pass
+
+
+class TestAgyStreamRetry(unittest.IsolatedAsyncioTestCase):
+    """Test agy runner retry behavior for stream interruption and cascade timeouts."""
+
+    def setUp(self):
+        from wechatbridge.config import config
+
+        self.td = tempfile.mkdtemp(prefix="wb-agy-retry-")
+        self._patchers = [
+            mock.patch.object(config, "session_base_dir", self.td),
+        ]
+        for p in self._patchers:
+            p.start()
+
+    def tearDown(self):
+        for p in self._patchers:
+            p.stop()
+        shutil.rmtree(self.td, ignore_errors=True)
+
+    def test_is_transient_stream_error_helper(self):
+        from wechatbridge.agy import _is_transient_stream_error
+
+        self.assertIsNone(_is_transient_stream_error(""))
+        self.assertEqual(_is_transient_stream_error("timeout waiting for cascade"), "cascade")
+        self.assertEqual(_is_transient_stream_error("timeout waiting for response"), "cascade")
+        self.assertEqual(
+            _is_transient_stream_error("subscriber fell behind updates, stalled for 8s"),
+            "stream",
+        )
+        self.assertEqual(_is_transient_stream_error("conversation update stream failed"), "stream")
+        self.assertEqual(_is_transient_stream_error("connection to the agent was interrupted"), "stream")
+        self.assertIsNone(_is_transient_stream_error("package wechatbridge-cli 1.6.0, installed using Python 3.13.5"))
+        self.assertIsNone(_is_transient_stream_error("some random error"))
+
+    async def test_stream_interrupted_retries_and_recovers(self):
+        from wechatbridge import agy as agy_mod
+
+        calls = 0
+        stream_err = (
+            "Error: the connection to the agent was interrupted before the response finished: "
+            "subscriber fell behind updates, stalled for 8s"
+        )
+
+        async def spawn(*_a, **_k):
+            nonlocal calls
+            calls += 1
+            if calls == 1:
+                return _FakeAgyProc("", stream_err, rc=1)
+            return _FakeAgyProc("hello from retry", "", rc=0)
+
+        with mock.patch("asyncio.create_subprocess_exec", side_effect=spawn), \
+             mock.patch.object(agy_mod, "terminate_process", new=AsyncMock()), \
+             mock.patch.object(agy_mod.asyncio, "sleep", new=AsyncMock()) as mock_sleep:
+            display, arts = await agy_mod.run_agy("hi", "u-stream-ok")
+
+        self.assertEqual(calls, 2)
+        self.assertEqual(display, "hello from retry")
+        self.assertEqual(arts, [])
+        mock_sleep.assert_awaited_once_with(3)
+
+    async def test_stream_interrupted_retry_fails_returns_stream_interrupted_copy(self):
+        from wechatbridge import agy as agy_mod
+
+        calls = 0
+        stream_err = (
+            "Error: the connection to the agent was interrupted before the response finished: "
+            "subscriber fell behind updates, stalled for 8s"
+        )
+
+        async def spawn(*_a, **_k):
+            nonlocal calls
+            calls += 1
+            return _FakeAgyProc("", stream_err, rc=1)
+
+        with mock.patch("asyncio.create_subprocess_exec", side_effect=spawn), \
+             mock.patch.object(agy_mod, "terminate_process", new=AsyncMock()), \
+             mock.patch.object(agy_mod.asyncio, "sleep", new=AsyncMock()) as mock_sleep:
+            display, arts = await agy_mod.run_agy("hi", "u-stream-fail")
+
+        self.assertEqual(calls, 2)
+        self.assertEqual(arts, [])
+        self.assertIn("助手连接中断", display)
+        self.assertIn("❌", display)
+        self.assertIn("/new", display)
+        mock_sleep.assert_awaited_once_with(3)
+
+    async def test_stream_interrupted_retry_timeout_returns_stream_interrupted_copy(self):
+        from wechatbridge import agy as agy_mod
+
+        calls = 0
+        stream_err = (
+            "Error: the connection to the agent was interrupted before the response finished: "
+            "subscriber fell behind updates, stalled for 8s"
+        )
+
+        class _TimeoutProc(_FakeAgyProc):
+            async def communicate(self):
+                raise asyncio.TimeoutError()
+
+        async def spawn(*_a, **_k):
+            nonlocal calls
+            calls += 1
+            if calls == 1:
+                return _FakeAgyProc("", stream_err, rc=1)
+            return _TimeoutProc("", "", rc=0)
+
+        mock_term = AsyncMock()
+        with mock.patch("asyncio.create_subprocess_exec", side_effect=spawn), \
+             mock.patch.object(agy_mod, "terminate_process", new=mock_term), \
+             mock.patch.object(agy_mod.asyncio, "sleep", new=AsyncMock()):
+            display, arts = await agy_mod.run_agy("hi", "u-stream-timeout")
+
+        self.assertEqual(calls, 2)
+        self.assertEqual(arts, [])
+        self.assertIn("助手连接中断", display)
+        mock_term.assert_awaited_once()
+
+    async def test_cascade_timeout_retries_and_fails_with_cascade_copy(self):
+        from wechatbridge import agy as agy_mod
+
+        calls = 0
+        cascade_err = "Timeout waiting for cascade response"
+
+        async def spawn(*_a, **_k):
+            nonlocal calls
+            calls += 1
+            return _FakeAgyProc("", cascade_err, rc=1)
+
+        with mock.patch("asyncio.create_subprocess_exec", side_effect=spawn), \
+             mock.patch.object(agy_mod, "terminate_process", new=AsyncMock()), \
+             mock.patch.object(agy_mod.asyncio, "sleep", new=AsyncMock()) as mock_sleep:
+            display, arts = await agy_mod.run_agy("hi", "u-cascade-fail")
+
+        self.assertEqual(calls, 2)
+        self.assertEqual(arts, [])
+        self.assertIn("模型响应超时", display)
+        mock_sleep.assert_not_awaited()
+
+
 if __name__ == "__main__":
     unittest.main()

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.2}/wechatbridge/__init__.py

@@ -1,2 +1,2 @@
 """WeChatBridge — bridge WeChat messages to agy, Grok Build, or Codex CLIs."""
-__version__ = "1.6.0"
+__version__ = "1.6.2"

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.2}/wechatbridge/agy.py

@@ -18,7 +18,7 @@ from .runner_common import (
     sanitize_user_id, get_session_dir, ensure_session_dir, is_first_message, mark_initialized, clear_initialized,
     clean_output, load_prefs, save_prefs, is_dangerous, parse_model_effort,
     sanitize_env, terminate_process, update_active_prefs,
-    format_error, format_cli_error, is_bridge_formatted_reply, EMPTY_REPLY,
+    format_error, format_cli_error, _classify_cli_error, is_bridge_formatted_reply, EMPTY_REPLY,
     ANSI_RE, HTML_TAG_RE, validate_add_dir,
 )
 
@@ -55,6 +55,22 @@ def extract_artifacts(text: str) -> list[tuple[str, str]]:
     return result
 
 
+def _is_transient_stream_error(stderr_text: str) -> str | None:
+    """Check if stderr indicates a transient stream error eligible for retry.
+
+    Returns "cascade" for cascade/response timeouts, "stream" for agent stream
+    interruption, or None if not retriable.
+    """
+    if not stderr_text:
+        return None
+    cat = _classify_cli_error(stderr_text, backend="agy")
+    if cat == "cascade_timeout":
+        return "cascade"
+    if cat == "agent_stream_interrupted":
+        return "stream"
+    return None
+
+
 def ensure_user_gemini(user_id: str) -> str:
     """Ensure per-user .gemini directory with auth token and default persona.
 
@@ -235,8 +251,15 @@ async def run_agy(prompt: str, user_id: str, timeout: int = None) -> tuple[str,
                 stderr_text,
             )
             if not stdout_text and stderr_text:
-                if "timeout waiting for cascade" in stderr_text.lower() or "timeout waiting for response" in stderr_text.lower():
-                    logger.warning("Cascade/API timeout detected for user %s, retrying once automatically", user_id)
+                err_kind = _is_transient_stream_error(stderr_text)
+                if err_kind:
+                    logger.warning(
+                        "Transient stream error (%s) detected for user %s, retrying once automatically",
+                        err_kind,
+                        user_id,
+                    )
+                    if err_kind == "stream":
+                        await asyncio.sleep(3)
                     retry_process = await asyncio.create_subprocess_exec(
                         *cmd,
                         stdout=asyncio.subprocess.PIPE,
@@ -257,10 +280,12 @@ async def run_agy(prompt: str, user_id: str, timeout: int = None) -> tuple[str,
                             timeout, user_id,
                         )
                         await terminate_process(retry_process, graceful=True)
-                        return format_error(
-                            "模型响应超时",
-                            "模型响应超时，自动重试仍超时。请稍后重试或简化指令。",
-                        ), []
+                        if err_kind == "cascade":
+                            return format_error(
+                                "模型响应超时",
+                                "模型响应超时，自动重试仍超时。请稍后重试或简化指令。",
+                            ), []
+                        return format_cli_error(stderr_text, backend="agy"), []
                     except (asyncio.CancelledError, Exception):
                         await terminate_process(retry_process, graceful=False)
                         raise
@@ -278,10 +303,12 @@ async def run_agy(prompt: str, user_id: str, timeout: int = None) -> tuple[str,
                         ):
                             mark_initialized(session_dir, backend="agy")
                         return r_display, r_artifacts
-                    return format_error(
-                        "模型响应超时",
-                        "模型响应超时，自动重试仍失败。请稍后重试或简化指令。",
-                    ), []
+                    if err_kind == "cascade":
+                        return format_error(
+                            "模型响应超时",
+                            "模型响应超时，自动重试仍失败。请稍后重试或简化指令。",
+                        ), []
+                    return format_cli_error(r_stderr_text or stderr_text, backend="agy"), []
                 return format_cli_error(stderr_text, backend="agy"), []
             # Non-zero exit: never treat raw stdout as a normal success reply
             raw = stderr_text or stdout_text or display or "process exited abnormally"

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.2}/wechatbridge/runner_common.py

@@ -298,9 +298,9 @@ def _classify_cli_error(raw_message: str, *, backend: str = "") -> str:
     Returns one of:
       payload_too_large, context_too_large, invalid_argument,
       auth, resource_exhausted, rate_limit, bare_429, quota,
-      network, timeout, cascade_timeout, permission,
-      session_not_found, model_invalid, command_not_found, not_found,
-      unknown
+      agent_stream_interrupted, network, timeout, cascade_timeout,
+      permission, session_not_found, model_invalid, command_not_found,
+      not_found, unknown
 
     This is a pure function (no I/O, no logging).  ``format_cli_error``
     drives user-facing copy from the category; callers that need the
@@ -434,7 +434,16 @@ def _classify_cli_error(raw_message: str, *, backend: str = "") -> str:
     ):
         return "bare_429"
 
-    # --- 6. Network ---------------------------------------------------------------
+    # --- 6. Agent stream interrupted ----------------------------------------------
+    if (
+        "subscriber fell behind updates" in lower
+        or "connection to the agent was interrupted" in lower
+        or "conversation update stream failed" in lower
+        or bool(re.search(r"\bstalled for \d+\s*s", lower))
+    ):
+        return "agent_stream_interrupted"
+
+    # --- 7. Network ---------------------------------------------------------------
     if (
         "connection refused" in lower
         or "connection reset" in lower
@@ -449,14 +458,14 @@ def _classify_cli_error(raw_message: str, *, backend: str = "") -> str:
     ):
         return "network"
 
-    # --- 7. Timeout / cascade -----------------------------------------------------
+    # --- 8. Timeout / cascade -----------------------------------------------------
     if "timeout waiting for cascade" in lower or "timeout waiting for response" in lower:
         return "cascade_timeout"
 
     if "timeout" in lower or "timed out" in lower or "deadline exceeded" in lower:
         return "timeout"
 
-    # --- 8. Permission / misc specific --------------------------------------------
+    # --- 9. Permission / misc specific --------------------------------------------
     if "permission" in lower and ("denied" in lower or "refuse" in lower or "rejected" in lower):
         return "permission"
 
@@ -557,6 +566,15 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
     if category == "network":
         return format_error("网络错误", "连不上服务，请检查网络后重试。")
 
+    if category == "agent_stream_interrupted":
+        return format_error(
+            "助手连接中断",
+            (
+                "助手响应流意外中断。\n"
+                "请发 /new 开始新会话或稍后再试。"
+            ),
+        )
+
     if category == "cascade_timeout":
         return format_error(
             "模型响应超时",

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.2}/wechatbridge_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.6.0
+Version: 1.6.2
 Summary: Bridge WeChat messages to agy, Grok Build, or Codex CLIs — text/image/file/voice in, CLI replies and generated files back.
 Author: WeChatBridge contributors
 License: MIT
@@ -195,7 +195,7 @@ Key variables (all have defaults):
 | `AGY_TIMEOUT` | `600` | CLI run timeout in seconds (agy / grok / codex backends) |
 | `WECHATBRIDGE_MAX_OUTBOUND_BYTES` | `104857600` | max file size sent back to WeChat (100 MB) |
 | `WECHATBRIDGE_MAX_INBOUND_BYTES` | `20971520` | max inbound image/file after download (20 MB) |
-| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply |
+| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply (on small RAM hosts, lower this to avoid concurrent CLI memory spikes; see [Memory limits](#memory-limits)) |
 | `WECHATBRIDGE_CONFIRM_TOKEN` | `y` | reply this token to approve a gated dangerous prompt |
 | `WECHATBRIDGE_ENABLE_MCP` | `true` | enable the `/mcp` help text command |
 | `WECHATBRIDGE_ENABLE_SUBAGENT` | `true` | enable the `/agent` prompt-rewrite command |
@@ -261,6 +261,39 @@ sudo systemctl enable --now wechatbridge@bot3
 
 Each instance reads its own config file (`~/.config/wechatbridge/bot2.env`) and keeps state under its own data directory (`~/.local/share/wechatbridge/bot2/`).
 
+#### Memory limits
+
+The multi-instance template (`deploy/wechatbridge@.service`) configures cgroup memory protection:
+
+```ini
+MemoryAccounting=yes
+MemoryHigh=450M
+MemoryMax=512M
+```
+
+- **Why these defaults?** Backend CLI child processes (such as `agy`) can reach ~276 MB+ RSS during a single turn, and spike even higher during image recognition or long conversational sessions. A tight hard cap (e.g. 300 MB) on ~1 GB RAM hosts triggers aggressive page thrashing, deep swap latency, and stream interruptions (`subscriber fell behind updates`). The `450M` soft limit (`MemoryHigh`) triggers gentle reclaim, while `512M` (`MemoryMax`) provides a hard ceiling preventing full-host OOM.
+- **Overriding per-instance via drop-in:** Override memory limits without modifying the base unit template:
+  ```bash
+  sudo mkdir -p /etc/systemd/system/wechatbridge@bot2.service.d/
+  cat << 'EOF' | sudo tee /etc/systemd/system/wechatbridge@bot2.service.d/memory.conf
+  [Service]
+  # for hosts with >= 2 GB RAM
+  MemoryHigh=600M
+  MemoryMax=768M
+  EOF
+  sudo systemctl daemon-reload
+  sudo systemctl restart wechatbridge@bot2
+  ```
+  Verify active limits:
+  ```bash
+  systemctl show wechatbridge@bot2 -p MemoryHigh,MemoryMax
+  ```
+- **Sizing guidance:** The defaults are tuned for small hosts (~1 GB RAM). On larger hosts with ample headroom, limits can be relaxed. When deploying multiple instances, note that each instance runs in its own service cgroup — budget for the worst-case combined ceiling of N × MemoryMax across running instances.
+- **Interaction with concurrency:** Concurrent heavy turns (e.g. multiple users sending images at once) multiply backend CLI memory consumption. On memory-constrained hosts, prioritize lowering `WECHATBRIDGE_MAX_CONCURRENT` (e.g. to `2` or `1`) before increasing memory caps.
+- **Swap configuration:** Avoid tightening `MemorySwapMax` — swap margin serves as a vital safety buffer that slows execution under pressure instead of triggering an immediate cgroup OOM kill.
+- **Single-instance deployments:** The single-instance unit `deploy/wechatbridge.service` includes the same built-in memory limits (`MemoryHigh=450M` and `MemoryMax=512M`). To adjust them, override via a drop-in under `/etc/systemd/system/wechatbridge.service.d/` and replace the unit name in the `systemctl` commands above with `wechatbridge`. Takes effect when the unit file is installed or re-installed; `update.sh` upgrades do not touch unit files.
+- **Platform scope:** These cgroup memory limits apply only to Linux systemd deployments; the macOS (launchd) and Windows (Task Scheduler) paths have no equivalent per-instance cap.
+
 ### macOS (launchd)
 
 ```bash
@@ -302,7 +335,7 @@ Other `/…` commands are either rejected (e.g. `/exit`), reported as unsupporte
 - **Danger gate is keyword-based**, not full intent understanding. Defaults target concrete patterns (`rm -rf /`, pipe-to-shell, `mkfs`, `format c:`, a few heavy Chinese phrases, …). Everyday wording like bare “delete” is **not** gated. Override list via `WECHATBRIDGE_CONFIRM_KEYWORDS`; approve with `WECHATBRIDGE_CONFIRM_TOKEN` (default `y`), TTL `WECHATBRIDGE_PENDING_TTL`.
 - **Inbound media** is size-capped (default 20 MB), streamed, and CDN hosts are allowlisted. Missing `aes_key` returns a clear error.
 - **Outbound artifacts** only leave the allowed per-user tree (agy: session scratch; grok: under session dir; dsh: under session dir), after `realpath` checks, and only if under `WECHATBRIDGE_MAX_OUTBOUND_BYTES`.
-- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap.
+- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap (heavy concurrent tasks multiply subprocess memory; see [Memory limits](#memory-limits)).
 - **Long replies** are split into chunks (`WECHATBRIDGE_MESSAGE_CHUNK`, default 2000 characters).
 - **Data layout:** instance data under `~/.local/share/wechatbridge/<instance>/` (override with env). Runtime dirs prefer `0700`; token/QR files prefer `0600` (Unix; Windows relies on NTFS ACLs).
 - **Retention:** session temps vs dialogue history use separate TTLs (`WECHATBRIDGE_SESSION_RETENTION_DAYS`, `WECHATBRIDGE_HISTORY_RETENTION_DAYS`). Prefs/auth are kept.