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

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

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

{agentlink_cli-0.1.8 → agentlink_cli-0.2.0}/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.2.0}/connector/runtime.py

@@ -480,6 +480,8 @@ class BackendRpcClient:
         if method == "session.create":
             adapter = self._resolve_adapter(params)
             result = await adapter.create_session({**params, "connectorId": self.config.connector_id})
+            if isinstance(result, dict) and adapter is self.adapters.get("codex"):
+                result.setdefault("runtimeLaunch", self._codex_launch_snapshot())
             await self._send_backend_notifications(result)
             return _strip_backend_notifications(result)
         if method == "session.sync":
@@ -497,7 +499,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)
@@ -649,6 +660,8 @@ class BackendRpcClient:
         Exception: the first assistant text delta for a turn bypasses the
         window so TTFB is not inflated by FLUSH_WINDOW_SECONDS.
         """
+        if method == "session.updated" and isinstance(params, dict) and params.get("runtime") == "codex":
+            params = {**params, "runtimeLaunch": self._codex_launch_snapshot()}
         notification = {"method": method, "params": params}
         if self._outbox is not None:
             await asyncio.to_thread(self._outbox.add, method, params)
@@ -962,9 +975,12 @@ class BackendRpcClient:
                 self._codex_launch_spec = {
                     "mode": mode,
                     **({"command": launch.raw} if mode == "command" else {}),
+                    **({"source": str(params["source"])} if params.get("source") in {"builtin", "preset", "custom", "auto"} else {}),
+                    **({"name": str(params["name"])} if isinstance(params.get("name"), str) and params["name"].strip() else {}),
+                    **({"presetId": str(params["presetId"])} if isinstance(params.get("presetId"), str) and params["presetId"].strip() else {}),
                 }
                 self._blocked_runtimes.discard("codex")
-                report["launch"] = launch.report(mode=mode)
+                report["launch"] = {**launch.report(mode=mode), **{k: v for k, v in self._codex_launch_spec.items() if k != "mode"}}
                 self._record_runtime_report("codex", report)
             except Exception:
                 codex.rpc = old_rpc
@@ -980,7 +996,11 @@ class BackendRpcClient:
     async def _apply_codex_launch_spec(self, spec: dict[str, Any]) -> None:
         mode = str(spec.get("mode") or "auto")
         command = spec.get("command") if isinstance(spec.get("command"), str) else None
-        normalized = {"mode": mode, **({"command": command} if command else {})}
+        normalized = {
+            "mode": mode,
+            **({"command": command} if command else {}),
+            **({key: spec[key] for key in ("source", "name", "presetId") if isinstance(spec.get(key), str)}),
+        }
         if normalized == self._codex_launch_spec and "codex" not in self._blocked_runtimes:
             return
         await self._configure_codex_launch({"runtime": "codex", **normalized})
@@ -997,6 +1017,7 @@ class BackendRpcClient:
                 self._codex_launch_spec = {
                     "mode": str(spec.get("mode") or "auto"),
                     **({"command": spec["command"]} if isinstance(spec.get("command"), str) else {}),
+                    **({key: spec[key] for key in ("source", "name", "presetId") if isinstance(spec.get(key), str)}),
                 }
                 if self._codex_launch_spec.get("mode") == "command":
                     self._blocked_runtimes.add("codex")
@@ -1152,8 +1173,20 @@ class BackendRpcClient:
             method = notification.get("method")
             params = notification.get("params")
             if isinstance(method, str) and isinstance(params, dict):
+                if method == "session.updated" and params.get("runtime") == "codex":
+                    params = {**params, "runtimeLaunch": self._codex_launch_snapshot()}
                 await self.ingest_notifications([{"method": method, "params": params}])
 
+    def _codex_launch_snapshot(self) -> dict[str, Any]:
+        spec = self._codex_launch_spec
+        mode = "command" if spec.get("mode") == "command" else "auto"
+        snapshot: dict[str, Any] = {"mode": mode, "source": spec.get("source") or ("auto" if mode == "auto" else "custom")}
+        for key in ("source", "name", "presetId", "command"):
+            value = spec.get(key)
+            if isinstance(value, str) and value:
+                snapshot[key] = value
+        return snapshot
+
     async def enqueue_backend_notifications(self, notifications: list[dict[str, Any]]) -> None:
         for notification in notifications:
             if not isinstance(notification, dict):

{agentlink_cli-0.1.8 → agentlink_cli-0.2.0}/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.2.0"
 
 
 def connector_version() -> str:

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

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

{agentlink_cli-0.1.8 → agentlink_cli-0.2.0}/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.2.0}/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(
@@ -487,7 +551,11 @@ async def _exercise_runtime() -> None:
         "id": "rpc_1",
         "type": "response",
         "ok": True,
-        "result": {"sessionId": "sess_1", "externalSessionId": "thr_1"},
+        "result": {
+            "sessionId": "sess_1",
+            "externalSessionId": "thr_1",
+            "runtimeLaunch": {"mode": "auto", "source": "auto"},
+        },
     }
 
     await client.handle_message(

{agentlink_cli-0.1.8 → agentlink_cli-0.2.0}/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.2.0"

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

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