codex-ipc 0.1.2__tar.gz → 0.1.3__tar.gz

{codex_ipc-0.1.2 → codex_ipc-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-ipc
-Version: 0.1.2
+Version: 0.1.3
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: pydantic>=2.12

{codex_ipc-0.1.2 → codex_ipc-0.1.3}/packages/ipc/src/ipc/constants.py

@@ -22,7 +22,10 @@ IPC_DEBUG_TEXT_LIMIT = 500
 
 IPC_METHOD_VERSIONS: dict[str, int] = {
     # broadcast methods
-    "thread-stream-state-changed": 7,
+    "thread-stream-state-changed": 11,
+    "thread-stream-following-changed": 1,
+    "thread-stream-following-status-requested": 1,
+    "ipc-connection-reset": 1,
     "thread-read-state-changed": 1,
     "thread-archived": 2,
     "thread-unarchived": 1,
@@ -31,12 +34,14 @@ IPC_METHOD_VERSIONS: dict[str, int] = {
     "client-status-changed": 0,
     # request methods (thread-follower series)
     "thread-follower-start-turn": 1,
+    "thread-follower-load-complete-history": 1,
     "thread-follower-compact-thread": 1,
     "thread-follower-steer-turn": 1,
-    "thread-follower-interrupt-turn": 1,
+    "thread-follower-interrupt-turn": 2,
+    "thread-follower-update-thread-settings": 1,
     "thread-follower-set-model-and-reasoning": 1,
     "thread-follower-set-collaboration-mode": 1,
-    "thread-follower-edit-last-user-turn": 1,
+    "thread-follower-edit-last-user-turn": 2,
     "thread-follower-command-approval-decision": 1,
     "thread-follower-file-approval-decision": 1,
     "thread-follower-permissions-request-approval-response": 1,

{codex_ipc-0.1.2 → codex_ipc-0.1.3}/packages/ipc/src/ipc/owner_follower.py

@@ -149,7 +149,7 @@ class OwnerFollowerSession:
         self._state: JsonDict | None = None
         self._stream_role: JsonDict | None = None
         self._streaming_conversations: set[str] = set()
-        # Monotonic per-conversation revision (matches Codex extension v7
+        # Monotonic per-conversation revision (matches Codex extension v11
         # streamRevisionByConversationId). Owner increments on every snapshot
         # and patch it emits; followers track it to guard out-of-order patches.
         self._stream_revision: int = 0
@@ -206,6 +206,11 @@ class OwnerFollowerSession:
             self._can_handle_owner_request,
             self._handle_follower_start_turn,
         )
+        self.ipc_client.add_request_handler(
+            "thread-follower-load-complete-history",
+            self._can_handle_owner_request,
+            self._handle_follower_load_complete_history,
+        )
         self.ipc_client.add_request_handler(
             "thread-follower-steer-turn",
             self._can_handle_owner_request,
@@ -216,6 +221,11 @@ class OwnerFollowerSession:
             self._can_handle_owner_request,
             self._handle_follower_set_queued_followups_state,
         )
+        self.ipc_client.add_request_handler(
+            "thread-follower-update-thread-settings",
+            self._can_handle_owner_request,
+            self._handle_follower_update_thread_settings,
+        )
         self.ipc_client.add_request_handler(
             "thread-follower-set-collaboration-mode",
             self._can_handle_owner_request,
@@ -333,17 +343,17 @@ class OwnerFollowerSession:
         owner_client_id = self._owner_client_id()
         if owner_client_id:
             response = await self.ipc_client.send_request(
-                "thread-follower-set-collaboration-mode",
+                "thread-follower-update-thread-settings",
                 {
                     "conversationId": self.thread_id,
-                    "collaborationMode": collaboration_mode,
+                    "threadSettings": {"collaborationMode": collaboration_mode},
                 },
                 target_client_id=owner_client_id,
             )
             if response.get("resultType") == "success":
                 return
             raise RuntimeError(
-                "thread-follower-set-collaboration-mode failed: "
+                "thread-follower-update-thread-settings failed: "
                 f"{response.get('error', '')}"
             )
 
@@ -2992,6 +3002,19 @@ class OwnerFollowerSession:
             }
         }
 
+    async def _handle_follower_load_complete_history(
+        self,
+        message: JsonDict,
+    ) -> JsonDict:
+        params = message.get("params")
+        if not isinstance(params, dict):
+            raise RuntimeError("invalid params")
+        if params.get("conversationId") != self.thread_id:
+            raise RuntimeError("invalid conversationId")
+
+        await self.read_thread(include_turns=True, broadcast_snapshot=True)
+        return {"revision": self._stream_revision}
+
     async def _handle_follower_steer_turn(self, message: JsonDict) -> JsonDict:
         params = message.get("params")
         if not isinstance(params, dict):
@@ -3028,6 +3051,62 @@ class OwnerFollowerSession:
         )
         return {"result": {"ok": True}}
 
+    async def _handle_follower_update_thread_settings(
+        self,
+        message: JsonDict,
+    ) -> JsonDict:
+        params = message.get("params")
+        if not isinstance(params, dict):
+            raise RuntimeError("invalid params")
+        if params.get("conversationId") != self.thread_id:
+            raise RuntimeError("invalid conversationId")
+
+        thread_settings = params.get("threadSettings")
+        if not isinstance(thread_settings, dict):
+            raise RuntimeError("invalid threadSettings")
+
+        await self._update_state(
+            lambda draft: self._apply_thread_settings(draft, thread_settings)
+        )
+        return {"result": {"ok": True}}
+
+    def _apply_thread_settings(
+        self,
+        draft: JsonDict,
+        thread_settings: JsonDict,
+    ) -> None:
+        latest_settings = draft.get("latestThreadSettings")
+        merged_settings = (
+            dict(latest_settings) if isinstance(latest_settings, dict) else {}
+        )
+        merged_settings.update(thread_settings)
+
+        collaboration_mode = thread_settings.get("collaborationMode")
+        if isinstance(collaboration_mode, dict):
+            merged_settings["collaborationMode"] = dict(collaboration_mode)
+            draft["latestCollaborationMode"] = dict(collaboration_mode)
+        elif "collaborationMode" in thread_settings:
+            collaboration_mode = default_collaboration_mode()
+            merged_settings["collaborationMode"] = collaboration_mode
+            draft["latestCollaborationMode"] = collaboration_mode
+
+        model = thread_settings.get("model")
+        if not isinstance(model, str) and isinstance(collaboration_mode, dict):
+            settings = collaboration_mode.get("settings")
+            if isinstance(settings, dict) and isinstance(settings.get("model"), str):
+                model = settings["model"]
+        if isinstance(model, str):
+            merged_settings["model"] = model
+            draft["latestModel"] = model
+
+        if "effort" in thread_settings:
+            draft["latestReasoningEffort"] = thread_settings.get("effort")
+        cwd = thread_settings.get("cwd")
+        if isinstance(cwd, str):
+            draft["cwd"] = cwd
+
+        draft["latestThreadSettings"] = merged_settings
+
     async def _handle_follower_submit_user_input(
         self,
         message: JsonDict,

{codex_ipc-0.1.2 → codex_ipc-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codex-ipc"
-version = "0.1.2"
+version = "0.1.3"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

{codex_ipc-0.1.2 → codex_ipc-0.1.3}/tests/test_plan_mode_user_input.py

@@ -44,6 +44,7 @@ from ipc.conversation_state import (
     build_conversation_state,
     default_collaboration_mode,
 )
+from ipc.constants import IPC_METHOD_VERSIONS
 from ipc.owner_follower import OwnerFollowerSession
 
 
@@ -570,6 +571,21 @@ class FacadeSessionTests(unittest.IsolatedAsyncioTestCase):
 
 
 class CoreImportTests(unittest.TestCase):
+    def test_ipc_versions_match_conversation_state_v11(self) -> None:
+        expected_versions = {
+            "thread-stream-state-changed": 11,
+            "thread-stream-following-changed": 1,
+            "thread-stream-following-status-requested": 1,
+            "ipc-connection-reset": 1,
+            "thread-follower-load-complete-history": 1,
+            "thread-follower-interrupt-turn": 2,
+            "thread-follower-update-thread-settings": 1,
+            "thread-follower-edit-last-user-turn": 2,
+        }
+
+        for method, version in expected_versions.items():
+            self.assertEqual(IPC_METHOD_VERSIONS[method], version)
+
     def test_core_import_does_not_require_tui_dependencies(self) -> None:
         script = """
 import builtins
@@ -597,6 +613,99 @@ print(codex_ipc.CodexIpcConfig.__name__)
 
 
 class PlanModeTests(unittest.IsolatedAsyncioTestCase):
+    async def test_follower_forwards_collaboration_mode_as_thread_settings(self) -> None:
+        session = make_session()
+        ipc_client = FakeIpcClient()
+        session.ipc_client = ipc_client
+        session._stream_role = {"role": "follower", "ownerClientId": "owner-1"}
+        collaboration_mode = {
+            "mode": "plan",
+            "settings": {
+                "model": "gpt-5.5",
+                "reasoning_effort": "high",
+                "developer_instructions": None,
+            },
+        }
+
+        await session.set_collaboration_mode(collaboration_mode)
+
+        self.assertEqual(
+            ipc_client.requests,
+            [
+                (
+                    "thread-follower-update-thread-settings",
+                    {
+                        "conversationId": "thread-1",
+                        "threadSettings": {"collaborationMode": collaboration_mode},
+                    },
+                    "owner-1",
+                )
+            ],
+        )
+
+    async def test_owner_applies_follower_thread_settings(self) -> None:
+        session = make_session()
+        session.ipc_client = FakeIpcClient()
+        session._stream_role = {"role": "owner"}
+        session._state = {
+            "id": "thread-1",
+            "latestModel": "gpt-5.4",
+            "latestReasoningEffort": "medium",
+            "latestCollaborationMode": default_collaboration_mode(),
+            "latestThreadSettings": {"model": "gpt-5.4"},
+            "updatedAt": 0,
+        }
+        collaboration_mode = {
+            "mode": "plan",
+            "settings": {
+                "model": "gpt-5.5",
+                "reasoning_effort": "high",
+                "developer_instructions": None,
+            },
+        }
+
+        result = await session._handle_follower_update_thread_settings(
+            {
+                "params": {
+                    "conversationId": "thread-1",
+                    "threadSettings": {
+                        "collaborationMode": collaboration_mode,
+                        "effort": "high",
+                        "cwd": "/repo",
+                    },
+                }
+            }
+        )
+
+        self.assertEqual(result, {"result": {"ok": True}})
+        self.assertEqual(session.state["latestCollaborationMode"], collaboration_mode)
+        self.assertEqual(session.state["latestModel"], "gpt-5.5")
+        self.assertEqual(session.state["latestReasoningEffort"], "high")
+        self.assertEqual(session.state["cwd"], "/repo")
+
+    async def test_owner_loads_complete_history_and_returns_snapshot_revision(self) -> None:
+        session = make_session()
+        calls: list[tuple[bool, bool]] = []
+
+        async def read_thread(
+            _thread_id: str | None = None,
+            *,
+            include_turns: bool = False,
+            broadcast_snapshot: bool = False,
+        ) -> object:
+            calls.append((include_turns, broadcast_snapshot))
+            session._stream_revision = 8
+            return object()
+
+        session.read_thread = read_thread  # type: ignore[method-assign]
+
+        result = await session._handle_follower_load_complete_history(
+            {"params": {"conversationId": "thread-1"}}
+        )
+
+        self.assertEqual(calls, [(True, True)])
+        self.assertEqual(result, {"revision": 8})
+
     async def test_turn_start_passes_collaboration_mode(self) -> None:
         codex = FakeCodex()
         thread = AsyncThread(codex, "thread-1")

{codex_ipc-0.1.2 → codex_ipc-0.1.3}/uv.lock

@@ -31,7 +31,7 @@ requires-dist = [{ name = "pydantic", specifier = ">=2.12" }]
 
 [[package]]
 name = "codex-ipc"
-version = "0.1.2"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },