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

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

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

{agentlink_cli-0.1.0 → agentlink_cli-0.1.2}/connector/capabilities.py

@@ -13,6 +13,7 @@ from typing import Any
 
 from connector.acp.discovery import discover_acp_manifest
 from connector.acp.manifest import AgentManifest, load_builtin_manifests
+from connector.codex.collaboration import normalize_collaboration_modes
 from connector.codex.rpc import JsonRpcStdioClient, codex_candidate_paths
 from connector.launch import (
     LaunchCommand,
@@ -257,6 +258,10 @@ async def _check_codex_candidate(candidate: dict[str, str] | LaunchTarget | Laun
             _read_codex_model_options(client),
             timeout=_CODEX_CHECK_TIMEOUT_S,
         )
+        collaboration_mode_options = await asyncio.wait_for(
+            _read_codex_collaboration_mode_options(client),
+            timeout=_CODEX_CHECK_TIMEOUT_S,
+        )
     except Exception as exc:
         stage = "model-list" if "model_options" in locals() or _is_model_list_error(exc) else "app-server"
         return {
@@ -278,6 +283,7 @@ async def _check_codex_candidate(candidate: dict[str, str] | LaunchTarget | Laun
         "version": version.get("stdout"),
         "threadListKeys": sorted(list_result.keys()),
         "modelOptions": model_options,
+        "collaborationModeOptions": collaboration_mode_options,
     }
 
 
@@ -303,6 +309,9 @@ async def prepare_codex_launch(
         model_options = await asyncio.wait_for(
             _read_codex_model_options(client), timeout=_CODEX_CHECK_TIMEOUT_S
         )
+        collaboration_mode_options = await asyncio.wait_for(
+            _read_codex_collaboration_mode_options(client), timeout=_CODEX_CHECK_TIMEOUT_S
+        )
     except Exception:
         await client.close()
         raise
@@ -313,6 +322,7 @@ async def prepare_codex_launch(
         "version": version.get("stdout"),
         "threadListKeys": sorted(list_result.keys()),
         "modelOptions": model_options,
+        "collaborationModeOptions": collaboration_mode_options,
     }
     return _codex_report_from_check(result, command), client
 
@@ -332,6 +342,8 @@ def _codex_report_from_check(
     }
     if isinstance(result.get("modelOptions"), list):
         report["modelOptions"] = result["modelOptions"]
+    if isinstance(result.get("collaborationModeOptions"), list):
+        report["collaborationModeOptions"] = result["collaborationModeOptions"]
     return report
 
 
@@ -444,6 +456,14 @@ def _is_model_list_error(exc: BaseException) -> bool:
     return "model/list" in str(exc)
 
 
+async def _read_codex_collaboration_mode_options(client: JsonRpcStdioClient) -> list[dict[str, Any]]:
+    try:
+        result = await client.request("collaborationMode/list", {})
+    except Exception:
+        return []
+    return normalize_collaboration_modes(result)
+
+
 async def _check_claude_candidate(candidate: dict[str, str] | LaunchTarget) -> dict[str, Any]:
     target = _target_from_candidate(candidate)
     path = target.path

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

@@ -13,6 +13,7 @@ from connector.logging import logger
 
 from connector.attachments import attachment_target
 from connector.codex.reducer import CODEX_APPROVAL_METHODS, ReductionResult, TimelineReducer
+from connector.codex.collaboration import collaboration_mode_payload, normalize_collaboration_modes
 from connector.codex.rpc import JsonRpcStdioClient
 from connector.sync_state import SyncStateStore
 from connector.time import utc_now
@@ -93,6 +94,7 @@ class CodexAdapter:
     _existing_thread_sync_markers: dict[str, str] = field(default_factory=dict)
     _existing_thread_names: dict[str, str | None] = field(default_factory=dict)
     _token_usage_by_thread: dict[str, dict[str, Any]] = field(default_factory=dict)
+    _collaboration_modes: list[dict[str, Any]] = field(default_factory=list)
     _start_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False, repr=False)
 
     def __post_init__(self) -> None:
@@ -433,9 +435,47 @@ class CodexAdapter:
             "effort": params.get("effort"),
             "approvalsReviewer": params.get("approvalsReviewer"),
         }
+        requested_collaboration_mode = _optional_string(params.get("collaborationMode"))
+        if requested_collaboration_mode is not None and not self._collaboration_modes:
+            try:
+                self._collaboration_modes = normalize_collaboration_modes(
+                    await self.rpc.request("collaborationMode/list", {})
+                )
+            except Exception:
+                self._collaboration_modes = []
+        collaboration = (
+            collaboration_mode_payload(
+                requested_collaboration_mode,
+                self._collaboration_modes,
+                model=_optional_string(params.get("model")) or "gpt-5.6-sol",
+                effort=_optional_string(params.get("effort")),
+            )
+            if requested_collaboration_mode is not None
+            else None
+        )
+        if collaboration is None and requested_collaboration_mode == "plan":
+            raise ValueError("Plan mode is not supported by this Codex installation")
+        if collaboration is not None:
+            await self.rpc.request(
+                "thread/settings/update",
+                {"threadId": thread_id, "collaborationMode": collaboration},
+            )
+            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,
@@ -448,6 +488,17 @@ class CodexAdapter:
             backend_notifications.extend(extra_notifications)
             self.reducer.bind_session(session_id, thread_id)
             turn_params["threadId"] = thread_id
+            if collaboration is not None:
+                await self.rpc.request(
+                    "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,
@@ -456,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,
@@ -675,6 +742,24 @@ class CodexAdapter:
         )
         return {"resolved": True}
 
+    async def respond_to_input(self, params: dict[str, Any]) -> dict[str, Any]:
+        await self.start()
+        assert self.rpc is not None
+        request_id = params.get("requestId")
+        if request_id is None:
+            raise ValueError("requestId is required to respond to Codex user input")
+        answers = params.get("answers")
+        if not isinstance(answers, dict):
+            raise ValueError("answers are required to respond to Codex user input")
+        await self.rpc.respond(request_id, {"answers": answers})
+        logger.info(
+            "codex user input resolved request_id={} approval_id={} question_count={}",
+            request_id,
+            params.get("approvalId"),
+            len(answers),
+        )
+        return {"resolved": True}
+
     async def handle_notification(self, message: dict[str, Any]) -> None:
         if message.get("method") == "thread/tokenUsage/updated":
             params = message.get("params") if isinstance(message.get("params"), dict) else {}
@@ -801,7 +886,7 @@ class CodexAdapter:
             ("thread/loaded/list", None),
         ):
             try:
-                await self.rpc.request(method, params)
+                result = await self.rpc.request(method, params)
             except Exception as exc:  # pragma: no cover - defensive against version drift
                 logger.debug("codex bootstrap read failed method={} error={}", method, exc)
 

agentlink_cli-0.1.2/connector/codex/collaboration.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+PLAN_MODE_DEVELOPER_INSTRUCTIONS = """# Plan Mode (Conversational)
+
+Work with the user to produce a decision-complete implementation plan before any implementation.
+
+- Explore the repository and other available context before asking questions.
+- Do not edit files or perform other implementation mutations while in Plan Mode.
+- Ask only questions that materially change the plan and cannot be answered by inspection.
+- Use request_user_input for meaningful choices when it is available.
+- Cover interfaces, data flow, edge cases, compatibility, testing, and acceptance criteria.
+- When the plan is complete, return exactly one self-contained Markdown plan wrapped in
+  `<proposed_plan>` and `</proposed_plan>` tags. Do not ask whether to proceed.
+"""
+
+
+def normalize_collaboration_modes(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, dict) or not isinstance(value.get("data"), list):
+        return []
+    result: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for raw in value["data"]:
+        if not isinstance(raw, dict):
+            continue
+        mode = raw.get("mode")
+        if mode not in {"default", "plan"} or mode in seen:
+            continue
+        seen.add(mode)
+        item: dict[str, Any] = {
+            "value": mode,
+            "label": str(raw.get("name") or mode.title()),
+        }
+        if isinstance(raw.get("model"), str) and raw["model"]:
+            item["model"] = raw["model"]
+        effort = raw.get("reasoning_effort") or raw.get("reasoningEffort")
+        if isinstance(effort, str) and effort:
+            item["reasoningEffort"] = effort
+        result.append(item)
+    result.sort(key=lambda item: 0 if item["value"] == "default" else 1)
+    return result
+
+
+def collaboration_mode_payload(
+    mode: str,
+    options: list[dict[str, Any]],
+    *,
+    model: str,
+    effort: str | None,
+) -> dict[str, Any] | None:
+    option = next((item for item in options if item.get("value") == mode), None)
+    if option is None:
+        return None
+    selected_model = option.get("model") if isinstance(option.get("model"), str) else model
+    selected_effort = option.get("reasoningEffort")
+    if not isinstance(selected_effort, str):
+        selected_effort = effort
+    return {
+        "mode": mode,
+        "settings": {
+            "model": selected_model,
+            "reasoning_effort": selected_effort,
+            "developer_instructions": PLAN_MODE_DEVELOPER_INSTRUCTIONS if mode == "plan" else None,
+        },
+    }

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

@@ -2,19 +2,21 @@ 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",
     "item/permissions/requestApproval",
 }
+CODEX_INPUT_REQUEST_METHOD = "item/tool/requestUserInput"
 
 OUTPUT_PREVIEW_CHARS = 4000
+COLLABORATION_TURN_CACHE_SIZE = 512
 
 
 @dataclass(slots=True)
@@ -34,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:
@@ -46,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,
         *,
@@ -263,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(
@@ -343,6 +397,18 @@ class TimelineReducer:
                 approvals=[approval],
             )
 
+        if method == CODEX_INPUT_REQUEST_METHOD:
+            approval = self._input_request_from_request(message, params, session_id, thread_id, turn_id)
+            blocking = params.get("isBlocking") is not False
+            return ReductionResult(
+                session_update=self._session_update(
+                    session_id=session_id,
+                    thread_id=thread_id,
+                    status="waiting_approval" if blocking else "running",
+                ),
+                approvals=[approval],
+            )
+
         if method == "item/agentMessage/delta":
             item_id = _string_value(params.get("itemId")) or _nested_string(params, "item", "id")
             item = self._append_text_item(
@@ -836,6 +902,39 @@ class TimelineReducer:
             event=method,
         )
 
+    def _input_request_from_request(
+        self,
+        message: dict[str, Any],
+        params: dict[str, Any],
+        session_id: str,
+        thread_id: str | None,
+        turn_id: str | None,
+    ) -> dict[str, Any]:
+        item_id = _string_value(params.get("itemId"))
+        questions = [item for item in _list_value(params.get("questions")) if isinstance(item, dict)]
+        first = questions[0] if questions else {}
+        approval_id = f"appr_{_short_hash([session_id, thread_id, turn_id, item_id, CODEX_INPUT_REQUEST_METHOD, message.get('id')])}"
+        return {
+            "id": approval_id,
+            "sessionId": session_id,
+            "turnId": turn_id,
+            "status": "pending",
+            "kind": "input_request",
+            "targetItemId": None,
+            "title": _string_value(first.get("header")) or "Codex needs your input",
+            "description": _string_value(first.get("question")),
+            "payload": params,
+            "choices": [],
+            "source": {
+                "runtime": "codex",
+                "requestId": message.get("id"),
+                "sessionId": thread_id,
+                "turnId": turn_id,
+                "itemId": item_id,
+                "method": CODEX_INPUT_REQUEST_METHOD,
+            },
+        }
+
     def _upsert_item(
         self,
         *,
@@ -870,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.0 → agentlink_cli-0.1.2}/connector/runtime.py

@@ -422,6 +422,8 @@ class BackendRpcClient:
             return await self._resolve_adapter(params).interrupt_turn(params)
         if method == "approval.resolve":
             return await self._resolve_adapter(params).resolve_approval(params)
+        if method == "input.respond":
+            return await self._resolve_adapter(params).respond_to_input(params)
         if method == "fs.prepareDownload":
             return await self.local_ops.prepare_download(params)
         if method == "fs.uploadPreparedDownload":

{agentlink_cli-0.1.0 → 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.0 → agentlink_cli-0.1.2}/pyproject.toml

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

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

@@ -11,6 +11,7 @@ from connector.codex.adapter import (
     CodexAdapter,
     stable_session_id,
 )
+from connector.codex.collaboration import collaboration_mode_payload, normalize_collaboration_modes
 from connector.codex.history import read_timeline_history, read_tool_history
 from connector.codex.reducer import TimelineReducer
 from connector.codex.rpc import APP_SERVER_STREAM_LIMIT, JsonRpcStdioClient
@@ -77,6 +78,19 @@ class FakeCodexRpc:
         self.responses.append((request_id, result))
 
 
+class CollaborationCodexRpc(FakeCodexRpc):
+    async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        if method == "collaborationMode/list":
+            self.requests.append((method, params))
+            return {
+                "data": [
+                    {"name": "Plan", "mode": "plan", "model": None, "reasoning_effort": "medium"},
+                    {"name": "Default", "mode": "default", "model": None, "reasoning_effort": None},
+                ]
+            }
+        return await super().request(method, params)
+
+
 class InterruptThreadNotFoundRpc(FakeCodexRpc):
     async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
         if method == "turn/interrupt":
@@ -168,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))
@@ -187,6 +212,87 @@ def test_stdio_client_stream_limit_is_large_enough_for_codex_jsonl() -> None:
     assert APP_SERVER_STREAM_LIMIT >= 64 * 1024 * 1024
 
 
+def test_collaboration_modes_normalize_and_build_plan_settings() -> None:
+    options = normalize_collaboration_modes(
+        {
+            "data": [
+                {"name": "Plan", "mode": "plan", "model": None, "reasoning_effort": "medium"},
+                {"name": "Default", "mode": "default", "model": None, "reasoning_effort": None},
+            ]
+        }
+    )
+    assert [option["value"] for option in options] == ["default", "plan"]
+    plan = collaboration_mode_payload("plan", options, model="gpt-test", effort="high")
+    assert plan is not None
+    assert plan["mode"] == "plan"
+    assert plan["settings"]["model"] == "gpt-test"
+    assert plan["settings"]["reasoning_effort"] == "medium"
+    assert "Plan Mode" in plan["settings"]["developer_instructions"]
+
+
+def test_reducer_maps_codex_input_request() -> None:
+    reducer = TimelineReducer()
+    reducer.bind_session("sess_1", "thr_1")
+    params = {
+        "threadId": "thr_1",
+        "turnId": "turn_1",
+        "itemId": "item_1",
+        "questions": [
+            {
+                "id": "strategy",
+                "header": "Strategy",
+                "question": "Which strategy?",
+                "options": [{"label": "Safe", "description": "Prefer compatibility"}],
+                "isOther": True,
+                "isSecret": False,
+            }
+        ],
+        "isBlocking": True,
+    }
+    reduced = reducer.reduce_notification(
+        {"id": 42, "method": "item/tool/requestUserInput", "params": params}
+    )
+    assert reduced.session_update["status"] == "waiting_approval"
+    assert reduced.approvals[0]["kind"] == "input_request"
+    assert reduced.approvals[0]["payload"] == params
+    assert reduced.approvals[0]["source"]["requestId"] == 42
+
+
+def test_adapter_applies_plan_mode_and_responds_to_input() -> None:
+    async def exercise() -> None:
+        async def sink(_method: str, _params: dict[str, Any]) -> None:
+            return None
+
+        rpc = CollaborationCodexRpc()
+        adapter = CodexAdapter(rpc=rpc, notification_sink=sink)  # type: ignore[arg-type]
+        adapter.reducer.bind_session("sess_1", "thr_1")
+        await adapter.start_turn(
+            {
+                "sessionId": "sess_1",
+                "externalSessionId": "thr_1",
+                "content": "plan this",
+                "model": "gpt-test",
+                "effort": "high",
+                "collaborationMode": "plan",
+            }
+        )
+        settings_request = next(
+            params for method, params in rpc.requests if method == "thread/settings/update"
+        )
+        assert settings_request["collaborationMode"]["mode"] == "plan"
+        assert settings_request["collaborationMode"]["settings"]["reasoning_effort"] == "medium"
+        turn_request = next(params for method, params in rpc.requests if method == "turn/start")
+        assert turn_request["model"] == "gpt-test"
+        assert turn_request["effort"] == "medium"
+
+        await adapter.respond_to_input(
+            {"requestId": 42, "answers": {"strategy": {"answers": ["Safe"]}}}
+        )
+        assert rpc.responses[-1] == (42, {"answers": {"strategy": {"answers": ["Safe"]}}})
+
+    asyncio.run(exercise())
+
+
 def test_stdio_client_preserves_numeric_server_request_ids() -> None:
     client = JsonRpcStdioClient(command=["codex"])
     client._server_request_ids.add(0)  # noqa: SLF001
@@ -334,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")
@@ -856,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()
@@ -1123,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.0 → 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.0 → agentlink_cli-0.1.2}/uv.lock

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