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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.6.0
+Version: 1.6.1
 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

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.1}/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.1}/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.1"

{wechatbridge_cli-1.6.0 → wechatbridge_cli-1.6.1}/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.1}/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.1}/wechatbridge_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.6.0
+Version: 1.6.1
 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