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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cloudagent-daemon
-Version: 0.5.1
+Version: 0.5.2
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cloudagent-daemon"
-version = "0.5.1"
+version = "0.5.2"
 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.2/src/cloudagent_daemon/__init__.py

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

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

@@ -391,6 +391,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 +441,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
@@ -618,6 +623,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
@@ -709,6 +722,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 +845,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 +896,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,
@@ -1006,7 +1028,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 +1055,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 +1437,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

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/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.2}/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.2}/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,

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/src/cloudagent_daemon/protocol.py

@@ -63,6 +63,10 @@ class DeliverPayload(BaseModel):
     model: str | None = None
     reasoning_effort: str | None = None
     runtime_env: dict[str, str] | None = None
+    run_mode: str | None = None
+    origin: dict[str, Any] | None = None
+    conversation_id: str | None = None
+    delivery_id: str | None = None
 
 
 class DeliveryAckPayload(BaseModel):
@@ -95,9 +99,14 @@ class AgentSessionStartPayload(BaseModel):
 
 class AgentStatusPayload(BaseModel):
     agent_id: str
-    status: Literal["running", "idle", "crashed", "quarantined", "backpressure_dropped"]
+    status: Literal[
+        "running", "idle", "crashed", "timeout", "quarantined",
+        "backpressure_dropped",
+    ]
     exit_code: int | None = None
     error: str | None = None
+    conversation_id: str | None = None
+    delivery_id: str | None = None
 
 
 class PingPayload(BaseModel):

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/tests/integration/test_mcp_bridge_round_trip.py

@@ -405,6 +405,31 @@ async def test_platform_send_tunnels_via_ipc_with_session_id(
     }
 
 
+async def test_bridge_stamps_delivery_id_outside_tool_schema(
+    ipc_server: tuple[Path, list[dict]],
+) -> None:
+    """#112: provenance is daemon-owned context, not a model-selectable
+    ``platform_send`` argument, but it must cross IPC on the actual call."""
+    sock, received = ipc_server
+    server = build_server(
+        agent_id="a_platform_provenance",
+        socket_path=sock,
+        identity={"is_chief": False},
+        session_id="sess_plat_provenance",
+        delivery_id="del_plat_provenance",
+    )
+
+    tool = next(t for t in await server.list_tools() if t.name == "platform_send")
+    assert "delivery_id" not in tool.inputSchema.get("properties", {})
+    await server.call_tool(
+        "platform_send",
+        {"conversation_id": "conv_x1", "content": "带可信上下文"},
+    )
+
+    req = received[0]
+    assert req["args"]["tool_args"]["delivery_id"] == "del_plat_provenance"
+
+
 # ---------------------------------------------------------------------------
 # 1k #55 — multi-tool-wake regression
 # ---------------------------------------------------------------------------

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/tests/integration/test_spawn_mcp_bridge_e2e.py

@@ -27,6 +27,7 @@ import pytest
 import pytest_asyncio
 
 from cloudagent_daemon.mcp_bridge import (
+    _query_daemon_context,
     _query_daemon_session,
     _read_current_session,
     build_server,
@@ -181,6 +182,31 @@ async def test_query_daemon_session_returns_registered_session(
     assert sid == "sess_from_memory_abc"
 
 
+async def test_query_daemon_context_returns_delivery_provenance(
+    short_sock_dir: Path,
+) -> None:
+    sock = short_sock_dir / "ctx.sock"
+
+    async def handler(req: dict) -> dict:
+        assert req.get("op") == "get_current_session"
+        return {
+            "result": {
+                "session_id": "sess_ctx",
+                "delivery_id": "del_ctx",
+            }
+        }
+
+    server = UnixSocketServer(sock, handler)
+    await server.start()
+    try:
+        assert await _query_daemon_context("agent_ctx", sock) == (
+            "sess_ctx",
+            "del_ctx",
+        )
+    finally:
+        await server.stop()
+
+
 async def test_query_daemon_session_returns_none_when_not_registered(
     daemon_session_server: tuple[Path, dict, list],
 ) -> None:

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/tests/unit/test_claude_runner.py

@@ -130,6 +130,7 @@ class FakeOutbound:
     ) -> None:
         self.calls: list[tuple] = []
         self.status_conversation_ids: list[str | None] = []
+        self.status_delivery_ids: list[str | None] = []
         # 1k #63 — record send_tool_call invocations so tests can assert
         # the daemon-side fallback fires (or doesn't) and inspect its
         # args. The result is hard-coded ok=True by default; tests that
@@ -156,9 +157,11 @@ class FakeOutbound:
         status: str,
         exit_code: int | None = None,
         conversation_id: str | None = None,
+        delivery_id: str | None = None,
     ) -> None:
         self.calls.append(("agent_status", agent_id, status, exit_code))
         self.status_conversation_ids.append(conversation_id)
+        self.status_delivery_ids.append(delivery_id)
 
     async def send_agent_session_start(
         self,
@@ -626,6 +629,25 @@ async def test_agent_status_carries_deliver_conversation(fake_claude, tmp_path):
     assert outbound.status_conversation_ids == ["conv_status", "conv_status"]
 
 
+async def test_agent_status_carries_delivery_provenance(fake_claude, tmp_path):
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    outbound = FakeOutbound()
+    runner = _build_runner(
+        fake_claude(stdout_lines=[], exit_code=0),
+        ws,
+        outbound,
+    )
+
+    await runner.run_one(
+        "agent-A",
+        {**_make_payload(), "delivery_id": "del_status"},
+    )
+
+    assert outbound.status_delivery_ids == ["del_status", "del_status"]
+
+
 async def test_emits_status_crashed_on_nonzero_exit(fake_claude, tmp_path):
     """Non-zero exit → final agent_status is crashed with the exit code."""
     mcp_cfg = tmp_path / "mcp.json"

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/tests/unit/test_mcp_bridge_agent_retrieval.py

@@ -29,9 +29,21 @@ _CHIEF_ONLY = {
 
 
 def _build(monkeypatch, is_chief, captured=None):
-    async def _fake_ipc(socket_path, agent_id, tool_name, tool_args, session_id):
+    # ``delivery_id`` is the 6th positional the provenance closure now passes
+    # (#112). Accepting it keeps this stub in step with the real helper — a
+    # 5-arg stub raises TypeError inside the tool and surfaces as an opaque
+    # ToolError, which reads like a bridge bug rather than a stale stub.
+    async def _fake_ipc(
+        socket_path, agent_id, tool_name, tool_args, session_id, delivery_id=None
+    ):
         if captured is not None:
-            captured.append({"tool_name": tool_name, "tool_args": tool_args})
+            captured.append(
+                {
+                    "tool_name": tool_name,
+                    "tool_args": tool_args,
+                    "delivery_id": delivery_id,
+                }
+            )
         return {"ok": True}
 
     monkeypatch.setattr(bridge, "_ipc_tool_call", _fake_ipc)

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/tests/unit/test_mcp_bridge_send_message.py

@@ -21,12 +21,16 @@ def _build_staff_server(monkeypatch, captured: list[dict]):
     """Build a non-chief :class:`FastMCP` with the IPC layer monkeypatched
     so we can introspect the args ``send_message`` passes downstream."""
 
+    # ``delivery_id`` is the 6th positional the provenance closure now passes
+    # (#112). Capturing it keeps this stub in step with the real helper and
+    # lets callers assert the daemon-side value actually reaches the IPC layer.
     async def _fake_ipc_tool_call(
         socket_path: Path,
         agent_id: str,
         tool_name: str,
         tool_args: dict,
         session_id: str | None,
+        delivery_id: str | None = None,
     ) -> dict[str, Any]:
         captured.append(
             {
@@ -35,6 +39,7 @@ def _build_staff_server(monkeypatch, captured: list[dict]):
                 "tool_name": tool_name,
                 "tool_args": tool_args,
                 "session_id": session_id,
+                "delivery_id": delivery_id,
             }
         )
         return {"ok": True}

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/tests/unit/test_outbound_queue.py

@@ -108,6 +108,17 @@ async def test_send_agent_status_includes_conversation_id():
     assert ws.sent[0]["payload"]["conversation_id"] == "conv-1"
 
 
+async def test_send_agent_status_includes_delivery_id():
+    q, ws = _make_queue()
+    await q.send_agent_status(
+        agent_id="agent-1",
+        status="idle",
+        delivery_id="del-1",
+    )
+
+    assert ws.sent[0]["payload"]["delivery_id"] == "del-1"
+
+
 async def test_send_tool_call_returns_tool_result():
     q, ws = _make_queue()
 

{cloudagent_daemon-0.5.1 → cloudagent_daemon-0.5.2}/uv.lock

@@ -122,7 +122,7 @@ wheels = [
 
 [[package]]
 name = "cloudagent-daemon"
-version = "0.5.1"
+version = "0.5.2"
 source = { editable = "." }
 dependencies = [
     { name = "h2" },

cloudagent_daemon-0.5.1/src/cloudagent_daemon/__init__.py

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