agentlink-cli 0.1.1__tar.gz → 0.1.2__tar.gz

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/PKG-INFO

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

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/connector/codex/adapter.py

@@ -463,9 +463,19 @@ class CodexAdapter:
             settings = collaboration["settings"]
             turn_params["model"] = settings["model"]
             turn_params["effort"] = settings["reasoning_effort"]
+        if requested_collaboration_mode is not None:
+            self.reducer.register_collaboration_mode(
+                session_id=session_id,
+                thread_id=thread_id,
+                mode=requested_collaboration_mode,
+            )
         try:
             result = await self.rpc.request("turn/start", turn_params)
         except RuntimeError as exc:
+            self.reducer.cancel_pending_collaboration_mode(
+                session_id=session_id,
+                thread_id=thread_id,
+            )
             recovered = await self._recover_missing_thread_for_turn_start(
                 params,
                 session_id=session_id,
@@ -483,6 +493,12 @@ class CodexAdapter:
                     "thread/settings/update",
                     {"threadId": thread_id, "collaborationMode": collaboration},
                 )
+            if requested_collaboration_mode is not None:
+                self.reducer.register_collaboration_mode(
+                    session_id=session_id,
+                    thread_id=thread_id,
+                    mode=requested_collaboration_mode,
+                )
             if client_message_id:
                 self.reducer.register_client_message(
                     session_id=session_id,
@@ -491,8 +507,24 @@ class CodexAdapter:
                     text=text_content,
                     attachments=timeline_attachments,
                 )
-            result = await self.rpc.request("turn/start", turn_params)
+            retry_succeeded = False
+            try:
+                result = await self.rpc.request("turn/start", turn_params)
+                retry_succeeded = True
+            finally:
+                if not retry_succeeded:
+                    self.reducer.cancel_pending_collaboration_mode(
+                        session_id=session_id,
+                        thread_id=thread_id,
+                    )
         turn_id = _turn_id_from_result(result)
+        if requested_collaboration_mode is not None and turn_id:
+            self.reducer.register_collaboration_mode(
+                session_id=session_id,
+                thread_id=thread_id,
+                turn_id=turn_id,
+                mode=requested_collaboration_mode,
+            )
         if client_message_id and turn_id:
             self.reducer.register_client_message(
                 session_id=session_id,

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/connector/codex/reducer.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import hashlib
 import json
+from collections import OrderedDict
 from dataclasses import dataclass, field
 from typing import Any
 
 from connector.time import utc_now
 
-
 CODEX_APPROVAL_METHODS = {
     "item/commandExecution/requestApproval",
     "item/fileChange/requestApproval",
@@ -16,6 +16,7 @@ CODEX_APPROVAL_METHODS = {
 CODEX_INPUT_REQUEST_METHOD = "item/tool/requestUserInput"
 
 OUTPUT_PREVIEW_CHARS = 4000
+COLLABORATION_TURN_CACHE_SIZE = 512
 
 
 @dataclass(slots=True)
@@ -35,6 +36,8 @@ class TimelineReducer:
         self._client_message_by_turn: dict[tuple[str, str | None, str], dict[str, Any]] = {}
         self._pending_client_messages: dict[tuple[str, str | None], list[dict[str, Any]]] = {}
         self._reasoning_index_by_turn: dict[tuple[str, str], int] = {}
+        self._pending_collaboration_mode: dict[tuple[str, str], str] = {}
+        self._collaboration_mode_by_turn: OrderedDict[tuple[str, str, str], str] = OrderedDict()
         self._next_order = 1
 
     def bind_session(self, session_id: str, thread_id: str) -> None:
@@ -47,6 +50,52 @@ class TimelineReducer:
     def session_for_thread(self, thread_id: str) -> str | None:
         return self._session_by_thread.get(thread_id)
 
+    def register_collaboration_mode(
+        self,
+        *,
+        session_id: str,
+        thread_id: str,
+        mode: str,
+        turn_id: str | None = None,
+    ) -> None:
+        if turn_id is None:
+            self._pending_collaboration_mode[(session_id, thread_id)] = mode
+            return
+        self._pending_collaboration_mode.pop((session_id, thread_id), None)
+        self._bind_collaboration_turn(session_id, thread_id, turn_id, mode)
+
+    def cancel_pending_collaboration_mode(self, *, session_id: str, thread_id: str) -> None:
+        self._pending_collaboration_mode.pop((session_id, thread_id), None)
+
+    def _bind_pending_collaboration_turn(
+        self,
+        session_id: str,
+        thread_id: str | None,
+        turn_id: str | None,
+    ) -> None:
+        if thread_id is None or turn_id is None:
+            return
+        mode = self._pending_collaboration_mode.pop((session_id, thread_id), None)
+        if mode is not None:
+            self._bind_collaboration_turn(session_id, thread_id, turn_id, mode)
+
+    def _bind_collaboration_turn(self, session_id: str, thread_id: str, turn_id: str, mode: str) -> None:
+        key = (session_id, thread_id, turn_id)
+        self._collaboration_mode_by_turn[key] = mode
+        self._collaboration_mode_by_turn.move_to_end(key)
+        while len(self._collaboration_mode_by_turn) > COLLABORATION_TURN_CACHE_SIZE:
+            self._collaboration_mode_by_turn.popitem(last=False)
+
+    def _collaboration_mode_for_turn(
+        self,
+        session_id: str,
+        thread_id: str | None,
+        turn_id: str | None,
+    ) -> str | None:
+        if thread_id is None or turn_id is None:
+            return None
+        return self._collaboration_mode_by_turn.get((session_id, thread_id, turn_id))
+
     def _session_update(
         self,
         *,
@@ -264,6 +313,10 @@ class TimelineReducer:
             return ReductionResult()
         if thread_id:
             self.bind_session(session_id, thread_id)
+        # Codex does not guarantee that turn/started is the first event for a
+        # turn. Bind on the first notification carrying the real turn id so an
+        # early item or turn/completed event receives the requested mode too.
+        self._bind_pending_collaboration_turn(session_id, thread_id, turn_id)
 
         if method == "thread/name/updated":
             return ReductionResult(
@@ -916,6 +969,13 @@ class TimelineReducer:
         }
         if source_extra:
             source.update(source_extra)
+        collaboration_mode = self._collaboration_mode_for_turn(
+            session_id,
+            source_session_id,
+            turn_id,
+        )
+        if collaboration_mode is not None:
+            source.setdefault("collaborationMode", collaboration_mode)
         source = {key: value for key, value in source.items() if value is not None}
         content_hash = _content_hash(item_type, status, role, content, source)
         if existing and existing.get("contentHash") == content_hash:

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/connector/version.py

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

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/pyproject.toml

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

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/tests/test_codex_adapter.py

@@ -182,6 +182,17 @@ class MissingAfterUnloadedThreadStartRpc(FakeCodexRpc):
         return {}
 
 
+class FailingRecoveredTurnStartRpc(CollaborationCodexRpc):
+    async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        if method == "thread/resume":
+            self.requests.append((method, params))
+            return {"thread": {"id": (params or {}).get("threadId"), "status": {"type": "loaded"}}}
+        if method == "turn/start":
+            self.requests.append((method, params))
+            raise RuntimeError(json.dumps({"code": -32600, "message": "id not found"}))
+        return await super().request(method, params)
+
+
 class MissingModelProviderResumeRpc(FakeCodexRpc):
     async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
         self.requests.append((method, params))
@@ -429,6 +440,122 @@ def test_reducer_maps_codex_turn_and_message_notifications() -> None:
     assert [item["type"] for item in completed.timeline_items] == ["turn.start", "turn.end"]
 
 
+def test_reducer_persists_collaboration_mode_across_live_and_snapshot_items() -> None:
+    reducer = TimelineReducer()
+    reducer.bind_session("sess_1", "thr_1")
+    reducer.register_collaboration_mode(
+        session_id="sess_1",
+        thread_id="thr_1",
+        mode="plan",
+    )
+
+    started = reducer.reduce_notification(
+        {
+            "method": "turn/started",
+            "params": {"threadId": "thr_1", "turnId": "turn_plan", "turn": {"input": "plan"}},
+        }
+    ).timeline_items[0]
+    message = reducer.reduce_notification(
+        {
+            "method": "item/agentMessage/delta",
+            "params": {
+                "threadId": "thr_1",
+                "turnId": "turn_plan",
+                "itemId": "msg_plan",
+                "delta": "# Final plan",
+            },
+        }
+    ).timeline_items[0]
+    completed = reducer.reduce_notification(
+        {
+            "method": "turn/completed",
+            "params": {
+                "threadId": "thr_1",
+                "turnId": "turn_plan",
+                "turn": {"status": "completed"},
+            },
+        }
+    ).timeline_items
+    snapshot = reducer.reduce_thread_snapshot(
+        "sess_1",
+        {
+            "id": "thr_1",
+            "status": {"type": "idle"},
+            "turns": [
+                {
+                    "id": "turn_plan",
+                    "status": "completed",
+                    "items": [
+                        {
+                            "id": "msg_plan",
+                            "type": "agentMessage",
+                            "text": "# Final plan",
+                            "status": "completed",
+                        }
+                    ],
+                }
+            ],
+        },
+    ).timeline_items
+
+    for item in [started, message, *completed, *snapshot]:
+        assert item["source"]["collaborationMode"] == "plan"
+
+    reducer.register_collaboration_mode(
+        session_id="sess_1",
+        thread_id="thr_1",
+        turn_id="turn_default",
+        mode="default",
+    )
+    default_message = reducer.reduce_notification(
+        {
+            "method": "item/agentMessage/delta",
+            "params": {
+                "threadId": "thr_1",
+                "turnId": "turn_default",
+                "itemId": "msg_default",
+                "delta": "Implemented",
+            },
+        }
+    ).timeline_items[0]
+    assert default_message["source"]["collaborationMode"] == "default"
+
+
+def test_reducer_binds_pending_collaboration_mode_on_first_turn_event() -> None:
+    reducer = TimelineReducer()
+    reducer.bind_session("sess_1", "thr_1")
+    reducer.register_collaboration_mode(
+        session_id="sess_1",
+        thread_id="thr_1",
+        mode="plan",
+    )
+
+    message = reducer.reduce_notification(
+        {
+            "method": "item/agentMessage/delta",
+            "params": {
+                "threadId": "thr_1",
+                "turnId": "turn_out_of_order",
+                "itemId": "msg_1",
+                "delta": "# Final plan",
+            },
+        }
+    ).timeline_items[0]
+    completed = reducer.reduce_notification(
+        {
+            "method": "turn/completed",
+            "params": {
+                "threadId": "thr_1",
+                "turnId": "turn_out_of_order",
+                "turn": {"status": "completed"},
+            },
+        }
+    ).timeline_items
+
+    assert message["source"]["collaborationMode"] == "plan"
+    assert all(item["source"]["collaborationMode"] == "plan" for item in completed)
+
+
 def test_reducer_keeps_agent_delta_items_separate_by_item_id() -> None:
     reducer = TimelineReducer()
     reducer.bind_session("sess_1", "thr_1")
@@ -951,6 +1078,10 @@ def test_adapter_replaces_thread_when_unloaded_codex_thread_rollout_is_missing()
     asyncio.run(_exercise_unloaded_thread_missing_rollout_replacement())
 
 
+def test_adapter_clears_pending_mode_when_recovered_turn_start_retry_fails() -> None:
+    asyncio.run(_exercise_failed_recovered_turn_start_clears_pending_mode())
+
+
 def test_codex_commands_use_native_app_server_methods() -> None:
     async def exercise() -> None:
         rpc = FakeCodexRpc()
@@ -1218,6 +1349,40 @@ async def _exercise_unloaded_thread_missing_rollout_replacement() -> None:
     ]
 
 
+async def _exercise_failed_recovered_turn_start_clears_pending_mode() -> None:
+    rpc = FailingRecoveredTurnStartRpc()
+    adapter = CodexAdapter(rpc=rpc)  # type: ignore[arg-type]
+    adapter.reducer.bind_session("sess_1", "thr_1")
+    adapter._loaded_thread_ids.add("thr_1")
+
+    try:
+        await adapter.start_turn(
+            {
+                "sessionId": "sess_1",
+                "externalSessionId": "thr_1",
+                "content": "make a plan",
+                "collaborationMode": "plan",
+            }
+        )
+    except RuntimeError:
+        pass
+    else:
+        raise AssertionError("expected recovered turn/start retry to fail")
+
+    later = adapter.reducer.reduce_notification(
+        {
+            "method": "item/agentMessage/delta",
+            "params": {
+                "threadId": "thr_1",
+                "turnId": "turn_later",
+                "itemId": "msg_later",
+                "delta": "normal answer",
+            },
+        }
+    ).timeline_items[0]
+    assert "collaborationMode" not in later["source"]
+
+
 def test_adapter_sync_session_refreshes_loaded_codex_thread() -> None:
     async def exercise() -> None:
         rpc = FakeCodexRpc()

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/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.0"
+    assert version_module.connector_version() == "0.1.2"

{agentlink_cli-0.1.1 → agentlink_cli-0.1.2}/uv.lock

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