agentlink-cli 0.1.8__tar.gz → 0.1.9__tar.gz

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentlink-cli
-Version: 0.1.8
+Version: 0.1.9
 Summary: Local runtime connector for AgentLink
 Requires-Python: >=3.12
 Requires-Dist: claude-agent-sdk

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/connector/codex/adapter.py

@@ -585,6 +585,17 @@ class CodexAdapter:
             raw_args=raw_args,
             phase="started",
         )
+        if self.notification_sink is not None:
+            for notification in _item_notifications(session_id, started_items):
+                try:
+                    await self.notification_sink(notification["method"], notification["params"])
+                except Exception as exc:  # noqa: BLE001
+                    logger.warning(
+                        "codex command started notification enqueue failed session_id={} command={} error={}",
+                        session_id,
+                        command,
+                        exc,
+                    )
         try:
             if command == "compact":
                 await self.rpc.request("thread/compact/start", {"threadId": thread_id})

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/connector/runtime.py

@@ -497,7 +497,16 @@ class BackendRpcClient:
             if execute_command is None:
                 raise ValueError("command_unavailable")
             result = await execute_command({**params, "connectorId": self.config.connector_id})
-            await self._send_backend_notifications(result)
+            notifications = result.get("backendNotifications", [])
+            if isinstance(notifications, list):
+                try:
+                    await self.enqueue_backend_notifications(notifications)
+                except Exception:  # noqa: BLE001
+                    logger.exception(
+                        "command timeline notification enqueue failed session_id={} command={}",
+                        params.get("sessionId"),
+                        params.get("command"),
+                    )
             return _strip_backend_notifications(result)
         if method == "turn.interrupt":
             return await self._resolve_adapter(params).interrupt_turn(params)

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/connector/version.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from importlib.metadata import PackageNotFoundError, version
 
-FALLBACK_VERSION = "0.1.8"
+FALLBACK_VERSION = "0.1.9"
 
 
 def connector_version() -> str:

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentlink-cli"
-version = "0.1.8"
+version = "0.1.9"
 description = "Local runtime connector for AgentLink"
 readme = "README.md"
 requires-python = ">=3.12"

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/tests/test_codex_adapter.py

@@ -1149,6 +1149,66 @@ def test_codex_commands_use_native_app_server_methods() -> None:
     asyncio.run(exercise())
 
 
+def test_review_command_publishes_started_items_before_native_review_events() -> None:
+    async def exercise() -> None:
+        published: list[tuple[str, dict[str, Any]]] = []
+
+        class ReviewRpc(FakeCodexRpc):
+            async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+                if method == "review/start":
+                    assert [entry[1]["item"]["content"].get("phase") for entry in published] == [None, "started"]
+                    return {"turn": {"id": "turn_review"}}
+                return await super().request(method, params)
+
+        async def sink(method: str, params: dict[str, Any]) -> None:
+            published.append((method, params))
+
+        adapter = CodexAdapter(rpc=ReviewRpc(), notification_sink=sink)  # type: ignore[arg-type]
+        result = await adapter.execute_command(
+            {
+                "sessionId": "sess_1",
+                "externalSessionId": "thr_1",
+                "command": "review",
+                "clientCommandId": "cmd_review",
+            }
+        )
+
+        started_user = published[0][1]["item"]
+        started_command = published[1][1]["item"]
+        completed_user = result["backendNotifications"][0]["params"]["item"]
+        accepted_command = result["backendNotifications"][1]["params"]["item"]
+        assert started_user["id"] == completed_user["id"]
+        assert started_command["id"] == accepted_command["id"]
+        assert accepted_command["content"]["phase"] == "accepted"
+        assert accepted_command["content"]["data"]["turnId"] == "turn_review"
+
+    asyncio.run(exercise())
+
+
+def test_review_command_continues_when_started_notification_enqueue_fails() -> None:
+    async def exercise() -> None:
+        rpc = FakeCodexRpc()
+
+        async def failing_sink(_method: str, _params: dict[str, Any]) -> None:
+            raise OSError("temporary ingest failure")
+
+        adapter = CodexAdapter(rpc=rpc, notification_sink=failing_sink)  # type: ignore[arg-type]
+        result = await adapter.execute_command(
+            {
+                "sessionId": "sess_1",
+                "externalSessionId": "thr_1",
+                "command": "review",
+                "clientCommandId": "cmd_review",
+            }
+        )
+
+        assert result["status"] == "accepted"
+        assert any(method == "review/start" for method, _params in rpc.requests)
+        assert result["backendNotifications"][1]["params"]["item"]["content"]["phase"] == "accepted"
+
+    asyncio.run(exercise())
+
+
 def test_status_command_returns_thread_and_cached_token_usage() -> None:
     async def exercise() -> None:
         rpc = FakeCodexRpc()

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/tests/test_connector_runtime.py

@@ -142,6 +142,70 @@ def test_connector_runtime_dispatches_request_and_forwards_notifications() -> No
     asyncio.run(_exercise_runtime())
 
 
+def test_connector_runtime_queues_command_notifications_without_synchronous_ingest() -> None:
+    async def exercise() -> None:
+        class CommandAdapter(FakeAdapter):
+            async def execute_command(self, params: dict[str, Any]) -> dict[str, Any]:
+                self.calls.append(("command.execute", params))
+                return {
+                    "status": "accepted",
+                    "backendNotifications": [
+                        {"method": "timeline.itemUpsert", "params": {"sessionId": "sess_1", "item": {"id": "cmd"}}},
+                        {"method": "timeline.itemUpsert", "params": {"sessionId": "sess_1", "item": {"id": "result"}}},
+                    ],
+                }
+
+        adapter = CommandAdapter()
+        client = BackendRpcClient(
+            ConnectorConfig(
+                server_url="http://127.0.0.1:8000",
+                connector_id="conn_1",
+                connector_token="token",
+                sync_existing_on_connect=False,
+            ),
+            adapter=adapter,  # type: ignore[arg-type]
+        )
+        queued: list[tuple[str, dict[str, Any]]] = []
+
+        async def queue(method: str, params: dict[str, Any]) -> None:
+            queued.append((method, params))
+
+        async def fail_sync_ingest(_notifications: list[dict[str, Any]]) -> None:
+            raise AssertionError("command notifications must not use synchronous ingest")
+
+        client.send_backend_notification = queue  # type: ignore[method-assign]
+        client.ingest_notifications = fail_sync_ingest  # type: ignore[method-assign]
+
+        result = await client.dispatch(
+            "command.execute",
+            {
+                "runtime": "codex",
+                "sessionId": "sess_1",
+                "externalSessionId": "thr_1",
+                "command": "review",
+            },
+        )
+
+        assert result == {"status": "accepted"}
+        assert [params["item"]["id"] for _method, params in queued] == ["cmd", "result"]
+
+        async def fail_queue(_method: str, _params: dict[str, Any]) -> None:
+            raise OSError("outbox unavailable")
+
+        client.send_backend_notification = fail_queue  # type: ignore[method-assign]
+        assert await client.dispatch(
+            "command.execute",
+            {
+                "runtime": "codex",
+                "sessionId": "sess_1",
+                "externalSessionId": "thr_1",
+                "command": "review",
+            },
+        ) == {"status": "accepted"}
+
+    asyncio.run(exercise())
+
+
 def test_connector_config_saves_and_loads_local_json(tmp_path) -> None:
     path = tmp_path / "connector.json"
     config = ConnectorConfig(

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/tests/test_version.py

@@ -17,4 +17,4 @@ def test_connector_version_falls_back_in_source_tree(monkeypatch) -> None:
 
     monkeypatch.setattr(version_module, "version", missing)
 
-    assert version_module.connector_version() == "0.1.8"
+    assert version_module.connector_version() == "0.1.9"

{agentlink_cli-0.1.8 → agentlink_cli-0.1.9}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "agentlink-cli"
-version = "0.1.8"
+version = "0.1.9"
 source = { editable = "." }
 dependencies = [
     { name = "claude-agent-sdk" },