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

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

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

{agentlink_cli-0.1.0 → agentlink_cli-0.1.1}/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.1}/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,6 +435,34 @@ 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"]
         try:
             result = await self.rpc.request("turn/start", turn_params)
         except RuntimeError as exc:
@@ -448,6 +478,11 @@ 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 client_message_id:
                 self.reducer.register_client_message(
                     session_id=session_id,
@@ -675,6 +710,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 +854,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.1/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.1}/connector/codex/reducer.py

@@ -13,6 +13,7 @@ CODEX_APPROVAL_METHODS = {
     "item/fileChange/requestApproval",
     "item/permissions/requestApproval",
 }
+CODEX_INPUT_REQUEST_METHOD = "item/tool/requestUserInput"
 
 OUTPUT_PREVIEW_CHARS = 4000
 
@@ -343,6 +344,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 +849,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,
         *,

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

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

{agentlink_cli-0.1.0 → agentlink_cli-0.1.1}/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":
@@ -187,6 +201,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

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

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