cloudagent-daemon 0.5.1__tar.gz → 0.5.3__tar.gz

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.3}/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to the local daemon. Format follows
 [Keep a Changelog](https://keepachangelog.com/); versions are
 [PEP 440](https://peps.python.org/pep-0440/). Release with `scripts/release.sh`.
 
+## [0.5.3] — 2026-08-22
+
+### Fixed
+- A wake that dies because the model's context window is full now drops the
+  oversized session and re-spawns WITHOUT `--resume`, instead of replaying the
+  same history after an 8s backoff. Replaying could never fit, so the retry was
+  guaranteed to fail; three of them in a row crossed the crash threshold and
+  quarantined the agent — silently, since a quarantined agent stops being woken
+  (#114). The cleared session id is persisted, so later wakes do not resume the
+  oversized thread either.
+- The engine's own error text is now carried on the spawn result. Previously
+  only a bare `had_api_error` boolean survived, so the retry layer could not
+  tell a transient rate-limit (retry with resume) from a permanent
+  context-window overflow (start a new thread) and treated both the same.
+- A context-exhausted wake reports `context_exhausted` rather than the generic
+  `upstream_api_error`, so the cause is visible without reading daemon logs.
+
+### Notes
+- Detection matches an apostrophe-free substring: the engine writes "the
+  model's context window", and a smart-quote rewrite upstream would otherwise
+  silently disable the whole fix. A test pins that invariant.
+- No 0.5.2 entry exists in this file; 0.5.2 was published manually and its
+  changelog entry was never written.
+
 ## [0.5.1] — 2026-08-20
 
 ### Added

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cloudagent-daemon
-Version: 0.5.1
+Version: 0.5.3
 Summary: Local daemon for cloudagent — bridges Claude Code, Codex, and Qoder CLI agents to the cloudagent backend.
 Project-URL: Homepage, https://cloudagent.chat
 Project-URL: Repository, https://codeup.aliyun.com/69bd0a4d29ad98af4065ce71/cloudagent

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cloudagent-daemon"
-version = "0.5.1"
+version = "0.5.3"
 description = "Local daemon for cloudagent — bridges Claude Code, Codex, and Qoder CLI agents to the cloudagent backend."
 authors = [{name = "chaoyin", email = "tudoucyx@gmail.com"}]
 readme = "README.md"

cloudagent_daemon-0.5.3/src/cloudagent_daemon/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.3"

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.3}/src/cloudagent_daemon/claude_runner.py

@@ -338,6 +338,13 @@ class _SpawnAttempt:
     # M8 — set True when claude emitted an ``isApiErrorMessage:true``
     # event during the wake (upstream API error swallowed by the CLI).
     had_api_error: bool = False
+    # #114 — the engine's OWN explanation for that error. codex reports
+    # upstream failures as a ``turn.failed``/``error`` stdout event whose
+    # message previously reached only the log, so the retry layer saw a
+    # bare boolean and could not tell a transient rate-limit apart from a
+    # permanent context-window overflow — and retried both the same way.
+    # Keeping the text is what lets the wake layer branch on the cause.
+    api_error_text: str | None = None
 
 
 def _build_lazy_identity(agent_id: str, payload: dict) -> dict:
@@ -391,6 +398,7 @@ class ClaudeRunner:
         partial_publisher: PartialPublisher | None = None,
         event_publisher: EventPublisher | None = None,
         agent_to_session: "dict[str, str | None] | None" = None,
+        agent_to_delivery: "dict[str, str | None] | None" = None,
         claude_permission_mode: str = "bypassPermissions",
         runtime_binaries: dict[str, str] | None = None,
         http: object | None = None,
@@ -440,6 +448,10 @@ class ClaudeRunner:
         # unix socket ``get_current_session`` op instead of reading a file.
         # None means feature disabled (legacy / test path).
         self._agent_to_session: dict[str, str | None] | None = agent_to_session
+        # #112 — opaque backend delivery provenance for the currently running
+        # turn.  The MCP bridge queries this map through daemon IPC and adds it
+        # to outbound calls without exposing a forgeable tool parameter.
+        self._agent_to_delivery: dict[str, str | None] | None = agent_to_delivery
 
     # ------------------------------------------------------------------
     # Public API
@@ -462,6 +474,22 @@ class ClaudeRunner:
         "no rollout found for thread",
     )
 
+    #: #114 — 上下文窗口撑满。这是**永久性**前提失败,不是瞬时错误:退避几秒
+    #: 再把同一份历史送一次,必然再次溢出。codex 自己给出的处置就是 "Start a
+    #: new thread or clear earlier history",与 stale-session 的补救动作完全
+    #: 一致(清掉会话、免 resume 重跑),故复用同一条路径而非退避重试。
+    #: 匹配按**小写子串**做,同时覆盖 codex 的自然语言提示和 OpenAI API 的
+    #: 标准错误码,避免只认一种措辞。
+    #: 刻意**不含撇号**:codex 的原文是 "the model's context window",但撇号是
+    #: 最容易被改写成弯引号(’)的字符,一旦不匹配整个修复就静默失效——而这个修复
+    #: 存在的意义正是消除静默失败。去掉撇号后的子串依然足够specific。
+    CONTEXT_EXHAUSTED_MARKERS: tuple[str, ...] = (
+        "ran out of room in the model",
+        "context_length_exceeded",
+        "maximum context length",
+        "context window",
+    )
+
     #: 会产生外部副作用的工具（发消息/建任务类）。瞬时错误重试只在本次 wake
     #: **没**调过这些工具时才做 —— 只读工具（list_messages 等）重跑无害。
     SIDE_EFFECT_TOOLS: frozenset[str] = frozenset({
@@ -618,6 +646,14 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
         # reading the file. Both paths coexist for backward compat.
         if self._agent_to_session is not None:
             self._agent_to_session[agent_id] = _effective_session_id
+        current_delivery_id = payload.get("delivery_id")
+        _effective_delivery_id = (
+            current_delivery_id
+            if isinstance(current_delivery_id, str) and current_delivery_id
+            else None
+        )
+        if self._agent_to_delivery is not None:
+            self._agent_to_delivery[agent_id] = _effective_delivery_id
 
         # M7 W3 — localagent company-context injection. BEFORE spawning
         # claude, if this deliver belongs to a task whose context has not
@@ -649,10 +685,22 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                 self._qoder_lane_session(ws, stale_conv)
                 if stale_is_qoder and stale_conv else None
             )
+            # #114 — 上下文撑满与 stale-session 是同一类问题：**当前会话已经
+            # 不能再用了**，区别只在于一个是引擎不认识它、另一个是它太大。补救
+            # 动作完全相同（清掉会话、免 resume 重跑一次），所以走同一条路径，
+            # 而不是掉进下面的瞬时退避重试——那会带着同一份撑满的历史重放，
+            # 注定再次失败，白烧一轮唤醒和一次计费，然后累计成 crash 进隔离。
+            context_exhausted = self._is_context_exhausted(attempt)
             if (
                 self._run_mode_for(payload) != "read_analyze"
                 and attempt.exit_code != 0
-                and any(m in attempt.stderr_tail for m in self.STALE_SESSION_STDERR_MARKERS)
+                and (
+                    any(
+                        m in attempt.stderr_tail
+                        for m in self.STALE_SESSION_STDERR_MARKERS
+                    )
+                    or context_exhausted
+                )
                 and (ws.last_session_id() is not None or qoder_lane_sid is not None)
             ):
                 stale_sid = qoder_lane_sid or ws.last_session_id()
@@ -660,11 +708,12 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                 if stale_is_qoder and stale_conv:
                     self._qoder_set_lane(ws, stale_conv, None)
                 logger.warning(
-                    "claude_runner: resume rejected stale "
-                    "session_id=%s (stderr: %r). Clearing and "
-                    "retrying without resume.",
+                    "claude_runner: dropping unusable session_id=%s "
+                    "(cause=%s, detail=%r). Clearing and retrying "
+                    "without resume.",
                     stale_sid,
-                    attempt.stderr_tail[-160:],
+                    "context_exhausted" if context_exhausted else "stale_session",
+                    (attempt.api_error_text or attempt.stderr_tail)[-160:],
                 )
                 try:
                     ws.clear_last_session_id()
@@ -684,6 +733,12 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                 attempt.exit_code != 0
                 and attempt.had_api_error
                 and not attempt.timeout_hit
+                # #114 — 永久性失败不走瞬时重试。退避 8 秒不会让上下文变小，
+                # 带 resume 重放同一份历史必然再次撑满；上面那条路径已经用
+                # "清会话 + 免 resume" 处理过它了。注意这里重新判定的是**重试
+                # 之后**的 attempt：若换新会话仍然撑满（例如注入的正文本身过
+                # 大），同样不该再退避重放。
+                and not self._is_context_exhausted(attempt)
                 and not any(
                     t.rsplit("__", 1)[-1] in self.SIDE_EFFECT_TOOLS
                     for t in attempt.tool_uses
@@ -709,6 +764,8 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             # (c) IPC architecture upgrade — clear from memory map.
             if self._agent_to_session is not None:
                 self._agent_to_session.pop(agent_id, None)
+            if self._agent_to_delivery is not None:
+                self._agent_to_delivery.pop(agent_id, None)
 
         captured_session = attempt.captured_session_id
         rc = attempt.exit_code
@@ -830,6 +887,11 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                                 "content": attempt.final_result_text,
                                 "conversation_id": platform_conv_id,
                                 "acknowledge_new_messages": True,
+                                **(
+                                    {"delivery_id": _effective_delivery_id}
+                                    if _effective_delivery_id
+                                    else {}
+                                ),
                             },
                             timeout=15.0,
                         )
@@ -876,6 +938,8 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                         payload, attempt.final_result_text
                     )
                 )
+                if _effective_delivery_id:
+                    fallback_args["delivery_id"] = _effective_delivery_id
                 await self.outbound.send_tool_call(
                     agent_id=agent_id,
                     session_id=fallback_session,
@@ -982,7 +1046,13 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             and parent_for_abort not in (None, "")
         ):
             if attempt.had_api_error:
-                reason = "upstream_api_error"
+                # #114 — 把永久性的"会话撑满"和笼统的上游错误区分开：否则频道
+                # 里那条 wake_aborted 只说"上游错误"，真实原因只能靠翻日志。
+                reason = (
+                    "context_exhausted"
+                    if self._is_context_exhausted(attempt)
+                    else "upstream_api_error"
+                )
             elif timeout_hit:
                 reason = "wake_timeout"
             else:
@@ -1006,7 +1076,14 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                     agent_id=agent_id,
                     session_id=fallback_session,
                     tool_name="send_message",
-                    args=self._fallback_reply_args(payload, abort_body),
+                    args={
+                        **self._fallback_reply_args(payload, abort_body),
+                        **(
+                            {"delivery_id": _effective_delivery_id}
+                            if _effective_delivery_id
+                            else {}
+                        ),
+                    },
                     timeout=15.0,
                 )
                 try:
@@ -1026,15 +1103,20 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                     reason,
                 )
 
-        await self.outbound.send_agent_status(
-            agent_id,
-            final_status,
-            exit_code=rc,
-            conversation_id=(
+        final_status_kwargs: dict[str, Any] = {
+            "exit_code": rc,
+            "conversation_id": (
                 str(payload["conversation_id"])
                 if payload.get("conversation_id")
                 else None
             ),
+        }
+        if _effective_delivery_id:
+            final_status_kwargs["delivery_id"] = _effective_delivery_id
+        await self.outbound.send_agent_status(
+            agent_id,
+            final_status,
+            **final_status_kwargs,
         )
 
         wake_secs = time.monotonic() - wake_start
@@ -1403,14 +1485,20 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             await self.outbound.send_ack(
                 seq=None, message_id=message_id, status="started"
             )
-        await self.outbound.send_agent_status(
-            agent_id,
-            "running",
-            conversation_id=(
+        running_status_kwargs: dict[str, Any] = {
+            "conversation_id": (
                 str(payload["conversation_id"])
                 if payload.get("conversation_id")
                 else None
-            ),
+            )
+        }
+        delivery_id = payload.get("delivery_id")
+        if isinstance(delivery_id, str) and delivery_id:
+            running_status_kwargs["delivery_id"] = delivery_id
+        await self.outbound.send_agent_status(
+            agent_id,
+            "running",
+            **running_status_kwargs,
         )
 
         # 1k74 — token-level streaming. Forward the deliver's session_id
@@ -1425,6 +1513,7 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             final_text,
             result_usage,
             had_api_error,
+            api_error_text,
         ) = await self._consume_stdout(
             proc,
             parse_mode=(
@@ -1455,12 +1544,34 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             final_result_text=final_text,
             result_usage=result_usage,
             had_api_error=had_api_error,
+            api_error_text=api_error_text,
         )
 
     # ------------------------------------------------------------------
     # Internal helpers
     # ------------------------------------------------------------------
 
+    def _is_context_exhausted(self, attempt: _SpawnAttempt) -> bool:
+        """#114 — True iff *attempt* failed because the model's context
+        window is full.
+
+        A **permanent** premise failure, not a transient upstream error:
+        the same history replayed after any backoff overflows the window
+        again, so retrying with ``--resume`` burns a wake and a billing
+        cycle to reach the identical failure. The remedy is the one the
+        engine itself prints — start a new thread — which is exactly what
+        the stale-session path already does, so both share it.
+
+        Reads only :attr:`_SpawnAttempt.api_error_text` (the engine's own
+        message). An attempt that carried no explanation returns False:
+        unknown cause keeps the previous, more conservative handling
+        rather than silently discarding a session that may be fine.
+        """
+        text = (attempt.api_error_text or "").lower()
+        if not text:
+            return False
+        return any(m in text for m in self.CONTEXT_EXHAUSTED_MARKERS)
+
     #: 1i Bug E — the daemon-injected ``cloudagent`` MCP toolset MUST run
     #: unattended in ``--print`` headless mode (otherwise claude prompts
     #: the user for permission, the prompt is never answered, and the
@@ -2246,7 +2357,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         *,
         partial_session_id: str | None = None,
         partial_agent_id: str | None = None,
-    ) -> tuple[str | None, list[str], str | None, dict | None, bool]:
+    ) -> tuple[str | None, list[str], str | None, dict | None, bool, str | None]:
         """Consume ``codex exec --json`` NDJSON.
 
         Codex emits ``thread.started`` with ``thread_id`` and one or more
@@ -2264,13 +2375,16 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         # codex 把上游 API 错误（模型 at capacity / 限流）作为 turn.failed/error
         # 事件吐在 stdout —— 记为 had_api_error，wake 层据此做瞬时错误重试。
         had_api_error = False
+        # #114 — 同时留下引擎给的原因文本。只有一个布尔时，"限流"和"上下文
+        # 撑满"在 wake 层无法区分，于是永久性失败被当成瞬时错误反复重放。
+        api_error_text: str | None = None
         publish_enabled = bool(
             self._partial_publisher
             and partial_session_id
             and partial_agent_id
         )
         if proc.stdout is None:
-            return None, tool_uses, None, None, False
+            return None, tool_uses, None, None, False, None
 
         async def _emit(event_type: str, payload: "dict[str, Any]") -> None:
             if (
@@ -2428,9 +2542,12 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                     msg = raw if isinstance(raw, str) else None
                 logger.warning("CodexRunner: stdout error event=%s msg=%r", evt_type, msg)
                 had_api_error = True
+                # 第一条为准：后续事件通常是同一个失败的级联噪声，首条才是根因。
+                if api_error_text is None and isinstance(msg, str) and msg:
+                    api_error_text = msg
 
         final_text = "\n\n".join(final_chunks) if final_chunks else None
-        return captured, tool_uses, final_text, result_usage, had_api_error
+        return captured, tool_uses, final_text, result_usage, had_api_error, api_error_text
 
     async def _consume_stdout(
         self,
@@ -2439,7 +2556,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         parse_mode: str = "stream_json",
         partial_session_id: str | None = None,
         partial_agent_id: str | None = None,
-    ) -> tuple[str | None, list[str], str | None, dict | None, bool]:
+    ) -> tuple[str | None, list[str], str | None, dict | None, bool, str | None]:
         """Stream NDJSON; return ``(session_id, tool_uses, result_text, result_usage, had_api_error)``.
 
         Accepts BOTH session-init event shapes for forward/backward
@@ -2491,6 +2608,8 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         # M8 — set True when claude emits a synthetic isApiErrorMessage
         # assistant event (upstream API error swallowed by the CLI).
         had_api_error: bool = False
+        # #114 — 与 codex 侧同构：保留引擎自己的错误文本供 wake 层判定原因。
+        api_error_text: str | None = None
         # 1k74 — running buffer for token-level streaming. claude emits
         # one ``stream_event`` per content_block_delta (~80 chars at a
         # time); we concatenate them and forward the running total to
@@ -2530,7 +2649,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                 )
 
         if proc.stdout is None:
-            return None, tool_uses, final_text, result_usage, had_api_error
+            return None, tool_uses, final_text, result_usage, had_api_error, api_error_text
 
         async for line_b in proc.stdout:
             line = line_b.decode("utf-8", errors="replace").strip()
@@ -2645,6 +2764,8 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                                 if isinstance(t, str):
                                     err_text = t[:200]
                                     break
+                    if api_error_text is None and err_text:
+                        api_error_text = err_text
                     logger.warning(
                         "ClaudeRunner: stdout isApiErrorMessage event — "
                         "wake will be marked crashed (text=%r)",
@@ -2784,7 +2905,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                 "claude_runner: cache metrics publish failed", exc_info=True
             )
 
-        return captured, tool_uses, final_text, result_usage, had_api_error
+        return captured, tool_uses, final_text, result_usage, had_api_error, api_error_text
 
     async def _wait_with_timeout(
         self, proc: asyncio.subprocess.Process

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.3}/src/cloudagent_daemon/main_loop.py

@@ -637,6 +637,7 @@ async def _run_sse_post(
     # IPC op instead of reading a file; file fallback kept for backward
     # compat (old daemons without this map still work via the file).
     _agent_to_session: dict[str, str | None] = {}
+    _agent_to_delivery: dict[str, str | None] = {}
 
     # M7 W3 — localagent context injection + delegation reporting.
     # ``injection_state`` is the file-backed (agent,task) dedup store
@@ -657,6 +658,7 @@ async def _run_sse_post(
         partial_publisher=_publish_partial,
         event_publisher=_publish_event,
         agent_to_session=_agent_to_session,
+        agent_to_delivery=_agent_to_delivery,
         claude_permission_mode=cfg.claude_permission_mode,
         runtime_binaries=runtime_binaries,
         http=http,
@@ -752,11 +754,17 @@ async def _run_sse_post(
             a = req.get("args") or {}
             agent_id_q = a.get("agent_id") or ""
             sid = _agent_to_session.get(agent_id_q)
+            delivery_id = _agent_to_delivery.get(agent_id_q)
             logger.info(
-                "main_loop.ipc_handler: get_current_session agent=%s sid=%s",
-                agent_id_q, sid,
+                "main_loop.ipc_handler: get_current_session agent=%s sid=%s delivery=%s",
+                agent_id_q, sid, delivery_id,
             )
-            return {"result": {"session_id": sid}}
+            return {
+                "result": {
+                    "session_id": sid,
+                    "delivery_id": delivery_id,
+                }
+            }
 
         if op != "tool_call":
             logger.warning(
@@ -981,6 +989,8 @@ async def _run_legacy_ws(
     delegation_outbox = DelegationOutbox(
         profile_delegation_outbox_path(profile)
     )
+    agent_to_session_ws: dict[str, str | None] = {}
+    agent_to_delivery_ws: dict[str, str | None] = {}
 
     runner = ClaudeRunner(
         outbound=outbound,
@@ -991,6 +1001,8 @@ async def _run_legacy_ws(
         http=ws_http,
         injection_state=injection_state,
         delegation_outbox=delegation_outbox,
+        agent_to_session=agent_to_session_ws,
+        agent_to_delivery=agent_to_delivery_ws,
     )
 
     # #25 — pre-flight auth self-check (parity with the SSE path). Detached
@@ -1071,6 +1083,15 @@ async def _run_legacy_ws(
     sock_path.parent.mkdir(parents=True, exist_ok=True)
 
     async def ipc_handler(req: dict) -> dict:
+        if req.get("op") == "get_current_session":
+            a = req.get("args") or {}
+            agent_id_q = a.get("agent_id") or ""
+            return {
+                "result": {
+                    "session_id": agent_to_session_ws.get(agent_id_q),
+                    "delivery_id": agent_to_delivery_ws.get(agent_id_q),
+                }
+            }
         if req.get("op") != "tool_call":
             return {"error": {"code": "UNKNOWN_OP", "message": str(req.get("op"))}}
         a = req.get("args") or {}

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.3}/src/cloudagent_daemon/mcp_bridge.py

@@ -121,6 +121,35 @@ def _read_identity(agent_id: str) -> dict:
         return {}
 
 
+async def _query_daemon_context(
+    agent_id: str, socket_path: Path
+) -> tuple[str | None, str | None]:
+    """Return the daemon-owned ``(session_id, delivery_id)`` for this turn.
+
+    Old daemons return no delivery id (or reject the IPC op), which cleanly
+    degrades to ``(None, None)``.  The delivery id is intentionally absent from
+    every MCP tool schema: the bridge attaches it after the model has chosen
+    its ordinary tool arguments.
+    """
+    try:
+        async with UnixSocketClient(socket_path) as ipc:
+            result = await ipc.call(
+                "get_current_session",
+                {"agent_id": agent_id},
+                timeout=5.0,
+            )
+            sid = result.get("session_id")
+            delivery_id = result.get("delivery_id")
+            return (
+                sid if isinstance(sid, str) and sid else None,
+                delivery_id
+                if isinstance(delivery_id, str) and delivery_id
+                else None,
+            )
+    except Exception:  # noqa: BLE001
+        return None, None
+
+
 async def _query_daemon_session(
     agent_id: str, socket_path: Path
 ) -> str | None:
@@ -134,19 +163,8 @@ async def _query_daemon_session(
     Returns ``None`` on any failure (socket missing, timeout, old daemon
     without the op) so the caller can fall back to the file path.
     """
-    try:
-        async with UnixSocketClient(socket_path) as ipc:
-            result = await ipc.call(
-                "get_current_session",
-                {"agent_id": agent_id},
-                timeout=5.0,
-            )
-            sid = result.get("session_id")
-            return sid if isinstance(sid, str) and sid else None
-    except Exception:  # noqa: BLE001
-        # Socket missing, old daemon (UNKNOWN_OP), or timeout — fall
-        # through to file-based path. Not an error: backward compat.
-        return None
+    sid, _delivery_id = await _query_daemon_context(agent_id, socket_path)
+    return sid
 
 
 def _read_current_session(
@@ -190,6 +208,7 @@ async def _ipc_tool_call(
     tool_name: str,
     tool_args: dict,
     session_id: str | None,
+    delivery_id: str | None = None,
 ) -> dict:
     """Single round-trip: open socket → send tool_call → return result."""
     # 1k #55 — log the tool dispatch BEFORE we touch the socket so we can
@@ -200,6 +219,9 @@ async def _ipc_tool_call(
         tool_name, agent_id, session_id,
     )
     try:
+        effective_tool_args = dict(tool_args)
+        if delivery_id:
+            effective_tool_args["delivery_id"] = delivery_id
         async with UnixSocketClient(socket_path) as ipc:
             logger.info(
                 "mcp_bridge: ipc connected socket=%s tool=%s agent=%s session=%s",
@@ -211,7 +233,7 @@ async def _ipc_tool_call(
                     "agent_id": agent_id,
                     "session_id": session_id,
                     "tool_name": tool_name,
-                    "tool_args": tool_args,
+                    "tool_args": effective_tool_args,
                 },
             )
             logger.info(
@@ -227,11 +249,30 @@ async def _ipc_tool_call(
         raise
 
 
+# Resolve the module-level helper at CALL time, not import time.
+#
+# ``build_server``'s provenance-stamping closure shadows the name
+# ``_ipc_tool_call`` locally, so it needs another way to reach the module
+# helper. A plain alias (``_raw_ipc_tool_call = _ipc_tool_call``) binds the
+# original function object once, at import — which silently defeats every
+# test that does ``monkeypatch.setattr(bridge, "_ipc_tool_call", fake)``:
+# the patch rebinds the module attribute, the frozen alias keeps pointing at
+# the real implementation, and the "unit" test goes off and opens a real unix
+# socket. That is exactly how 10 tests started failing with FileNotFoundError.
+#
+# Looking the attribute up through the module at call time keeps the closure
+# working AND lets the patch take effect. Production behaviour is unchanged:
+# unpatched, this returns the same function the alias used to hold.
+def _module_ipc_tool_call():  # type: ignore[no-untyped-def]
+    return sys.modules[__name__]._ipc_tool_call  # type: ignore[attr-defined,no-any-return]
+
+
 def build_server(
     agent_id: str,
     socket_path: Path = DEFAULT_SOCKET_PATH,
     identity: dict | None = None,
     session_id: str | None = None,
+    delivery_id: str | None = None,
     tool_profile: str = "full",
 ) -> FastMCP:
     """Construct a FastMCP server filtered by identity and tool profile.
@@ -269,6 +310,25 @@ def build_server(
 
     server = FastMCP(name=f"cloudagent-bridge-{agent_id}")
 
+    # Keep the opaque provenance out of every public MCP schema.  The nested
+    # wrapper shadows the module helper for all tool closures below and stamps
+    # the daemon-provided value only after the model's arguments are built.
+    async def _ipc_tool_call(  # type: ignore[no-redef]
+        socket_path: Path,
+        agent_id: str,
+        tool_name: str,
+        tool_args: dict,
+        session_id: str | None,
+    ) -> dict:
+        return await _module_ipc_tool_call()(
+            socket_path,
+            agent_id,
+            tool_name,
+            tool_args,
+            session_id,
+            delivery_id,
+        )
+
     # ---- Common tools (all agents) ----------------------------------------
 
     @server.tool(
@@ -924,7 +984,9 @@ async def run_bridge(
     # freshly-written current-session.txt). Fall back to file on any
     # failure so old daemons without the ``get_current_session`` op
     # keep working.
-    current_session_id = await _query_daemon_session(agent_id, socket_path)
+    current_session_id, current_delivery_id = await _query_daemon_context(
+        agent_id, socket_path
+    )
     if current_session_id is not None:
         logger.info(
             "mcp_bridge: agent=%s current_session=%s (via socket IPC)",
@@ -951,6 +1013,7 @@ async def run_bridge(
         socket_path=socket_path,
         identity=identity,
         session_id=current_session_id,
+        delivery_id=current_delivery_id,
         tool_profile=tool_profile,
     )
     logger.info(

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.3}/src/cloudagent_daemon/outbound_queue.py

@@ -156,6 +156,7 @@ class OutboundQueue:
         status: str,
         exit_code: int | None = None,
         conversation_id: str | None = None,
+        delivery_id: str | None = None,
     ) -> None:
         """Send an ``agent_status`` frame."""
         payload: dict = {"agent_id": agent_id, "status": status}
@@ -163,6 +164,8 @@ class OutboundQueue:
             payload["exit_code"] = exit_code
         if conversation_id:
             payload["conversation_id"] = conversation_id
+        if delivery_id:
+            payload["delivery_id"] = delivery_id
 
         await self.send_raw({
             "v": 1,