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

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

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

{codex_ipc-0.1.2 → codex_ipc-0.1.4}/packages/ipc/src/ipc/__init__.py

@@ -1,8 +1,12 @@
 from ipc.client import CodexIpcClient
 from ipc.conversation_state import (
     JsonDict,
+    canonicalize_conversation_patches,
+    conversation_state_snapshot,
+    conversation_turns,
     conversation_messages,
     extract_text_input,
+    materialize_conversation_state,
     text_input_payload,
 )
 from ipc.immer import apply_patches, produce_with_patches
@@ -15,8 +19,12 @@ __all__ = [
     "JsonDict",
     "OwnerFollowerSession",
     "apply_patches",
+    "canonicalize_conversation_patches",
+    "conversation_state_snapshot",
+    "conversation_turns",
     "conversation_messages",
     "extract_text_input",
+    "materialize_conversation_state",
     "produce_with_patches",
     "text_input_payload",
 ]

{codex_ipc-0.1.2 → codex_ipc-0.1.4}/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.4}/packages/ipc/src/ipc/conversation_state.py

@@ -102,6 +102,227 @@ def empty_turns_pagination() -> JsonDict:
     }
 
 
+def conversation_turns(state: JsonDict | None) -> list[JsonDict]:
+    if not isinstance(state, dict):
+        return []
+
+    canonical_turns: list[JsonDict] = []
+    turn_history = state.get("turnHistory")
+    if isinstance(turn_history, dict) and turn_history.get("kind") == "canonical":
+        history = turn_history.get("history")
+        if isinstance(history, dict):
+            entities = history.get("entitiesByKey")
+            islands = history.get("islands")
+            if isinstance(entities, dict) and isinstance(islands, list):
+                for island in islands:
+                    if not isinstance(island, dict):
+                        continue
+                    entries = island.get("entries")
+                    if not isinstance(entries, list):
+                        continue
+                    for entry in entries:
+                        if not isinstance(entry, dict):
+                            continue
+                        entity_key = entry.get("value")
+                        turn = entities.get(entity_key)
+                        if isinstance(turn, dict):
+                            canonical_turns.append(turn)
+
+    overlay = state.get("turns")
+    overlay_turns = [turn for turn in overlay if isinstance(turn, dict)] if isinstance(overlay, list) else []
+    if not canonical_turns:
+        return overlay_turns
+
+    merged = list(canonical_turns)
+    turn_indexes = {
+        turn_id: index
+        for index, turn in enumerate(merged)
+        if isinstance((turn_id := turn.get("turnId")), str) and turn_id
+    }
+    for turn in overlay_turns:
+        turn_id = turn.get("turnId")
+        index = turn_indexes.get(turn_id) if isinstance(turn_id, str) else None
+        if index is None:
+            merged.append(turn)
+            if isinstance(turn_id, str) and turn_id:
+                turn_indexes[turn_id] = len(merged) - 1
+            continue
+        merged[index] = _merge_turn_overlay(merged[index], turn)
+    return merged
+
+
+def materialize_conversation_state(state: JsonDict | None) -> JsonDict | None:
+    if not isinstance(state, dict):
+        return state
+    turn_history = state.get("turnHistory")
+    if not isinstance(turn_history, dict) or turn_history.get("kind") != "canonical":
+        return state
+    return {**state, "turns": conversation_turns(state)}
+
+
+def conversation_state_snapshot(state: JsonDict) -> JsonDict:
+    turns = conversation_turns(state)
+    turn_history = state.get("turnHistory")
+    history = turn_history.get("history") if isinstance(turn_history, dict) else None
+    generation = history.get("generation") if isinstance(history, dict) else None
+    next_generation = generation + 1 if isinstance(generation, int) else 0
+    tail_id = f"tail:{next_generation}"
+    entities: dict[str, JsonDict] = {}
+    entries: list[JsonDict] = []
+
+    for index, turn in enumerate(turns):
+        key = _turn_entity_key(turn, index=index, tail_id=tail_id)
+        if key in entities:
+            entities[key] = _merge_turn_overlay(entities[key], turn)
+            continue
+        entities[key] = turn
+        entries.append({"key": key, "value": key})
+
+    pagination = state.get("turnsPagination")
+    older_cursor = pagination.get("olderCursor") if isinstance(pagination, dict) else None
+    oldest_turn_id = (
+        pagination.get("oldestLoadedTurnId") if isinstance(pagination, dict) else None
+    )
+    has_loaded_oldest = (
+        pagination.get("hasLoadedOldest", older_cursor is None)
+        if isinstance(pagination, dict)
+        else True
+    )
+    if isinstance(older_cursor, str) and older_cursor:
+        handle = {"cursor": older_cursor, "oldestLoadedTurnId": oldest_turn_id}
+        older_boundary: JsonDict = {
+            "status": "available",
+            "boundaryId": f"{tail_id}:older",
+            "handle": handle,
+            "progressKey": json.dumps(
+                [older_cursor, oldest_turn_id],
+                separators=(",", ":"),
+            ),
+        }
+    else:
+        older_boundary = {
+            "status": "exhausted",
+            "boundaryId": f"{tail_id}:older",
+        }
+
+    return {
+        **state,
+        "turnHistory": {
+            "kind": "canonical",
+            "history": {
+                "entitiesByKey": entities,
+                "generation": next_generation,
+                "isComplete": bool(has_loaded_oldest and older_cursor is None),
+                "islands": [
+                    {
+                        "id": tail_id,
+                        "entries": entries,
+                        "olderBoundary": older_boundary,
+                        "newerBoundary": {
+                            "status": "exhausted",
+                            "boundaryId": f"{tail_id}:newer",
+                        },
+                    }
+                ],
+            },
+        },
+        "turns": [],
+    }
+
+
+def canonicalize_conversation_patches(
+    previous_state: JsonDict,
+    next_state: JsonDict,
+    patches: list[JsonDict],
+) -> list[JsonDict]:
+    previous_turns = conversation_turns(previous_state)
+    next_turns = conversation_turns(next_state)
+    previous_tail_id = _snapshot_tail_id(previous_state)
+    next_tail_id = _snapshot_tail_id(next_state)
+    translated: list[JsonDict] = []
+    non_turn_patches: list[JsonDict] = []
+    has_structural_turn_change = False
+
+    for patch in patches:
+        path = patch.get("path")
+        if not isinstance(path, list) or path[:1] != ["turns"]:
+            translated.append(patch)
+            non_turn_patches.append(patch)
+            continue
+        if len(path) < 3 or not isinstance(path[1], int):
+            has_structural_turn_change = True
+            continue
+
+        turn_index = path[1]
+        if not (0 <= turn_index < len(previous_turns)) or not (
+            0 <= turn_index < len(next_turns)
+        ):
+            has_structural_turn_change = True
+            continue
+        previous_key = _turn_entity_key(
+            previous_turns[turn_index],
+            index=turn_index,
+            tail_id=previous_tail_id,
+        )
+        next_key = _turn_entity_key(
+            next_turns[turn_index],
+            index=turn_index,
+            tail_id=next_tail_id,
+        )
+        if previous_key != next_key:
+            has_structural_turn_change = True
+            continue
+        translated.append(
+            {
+                **patch,
+                "path": [
+                    "turnHistory",
+                    "history",
+                    "entitiesByKey",
+                    next_key,
+                    *path[2:],
+                ],
+            }
+        )
+
+    if not has_structural_turn_change:
+        return translated
+
+    snapshot = conversation_state_snapshot(next_state)
+    return [
+        *non_turn_patches,
+        {
+            "op": "replace",
+            "path": ["turnHistory"],
+            "value": snapshot["turnHistory"],
+        },
+    ]
+
+
+def _snapshot_tail_id(state: JsonDict) -> str:
+    turn_history = state.get("turnHistory")
+    history = turn_history.get("history") if isinstance(turn_history, dict) else None
+    generation = history.get("generation") if isinstance(history, dict) else None
+    next_generation = generation + 1 if isinstance(generation, int) else 0
+    return f"tail:{next_generation}"
+
+
+def _turn_entity_key(turn: JsonDict, *, index: int, tail_id: str) -> str:
+    turn_id = turn.get("turnId")
+    if isinstance(turn_id, str) and turn_id:
+        return f"turn:{turn_id}"
+    return f"{tail_id}:local:{index}"
+
+
+def _merge_turn_overlay(base: JsonDict, overlay: JsonDict) -> JsonDict:
+    merged = {**base, **overlay}
+    base_items = base.get("items")
+    overlay_items = overlay.get("items")
+    if isinstance(base_items, list) and not isinstance(overlay_items, list):
+        merged["items"] = base_items
+    return merged
+
+
 def default_collaboration_mode() -> JsonDict:
     return {
         "mode": "default",
@@ -1017,9 +1238,7 @@ def conversation_messages(state: JsonDict | None) -> list[tuple[str, str]]:
     if state is None:
         return []
 
-    turns = state.get("turns")
-    if not isinstance(turns, list):
-        return []
+    turns = conversation_turns(state)
 
     messages: list[tuple[str, str]] = []
     for turn in turns:

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

@@ -22,6 +22,8 @@ from ipc.conversation_state import (
     JsonDict,
     PLAN_IMPLEMENTATION_REQUEST_METHOD,
     build_conversation_state,
+    canonicalize_conversation_patches,
+    conversation_state_snapshot,
     ensure_turn_slot,
     default_collaboration_mode,
     extract_text_input,
@@ -149,7 +151,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 +208,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 +223,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 +345,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', '')}"
             )
 
@@ -1945,6 +1957,11 @@ class OwnerFollowerSession:
         if broadcast and patches and self._stream_role is not None:
             if self._stream_role.get("role") == "owner":
                 patches = self._normalize_broadcast_patches(patches)
+                patches = canonicalize_conversation_patches(
+                    previous_state,
+                    next_state,
+                    patches,
+                )
                 await self._broadcast_patches(patches)
         self._state_changed()
 
@@ -2606,7 +2623,7 @@ class OwnerFollowerSession:
             "change": {
                 "type": "snapshot",
                 "revision": revision,
-                "conversationState": self._state,
+                "conversationState": conversation_state_snapshot(self._state),
             },
         }
         self._session_event(
@@ -2992,6 +3009,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 +3058,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.4}/pyproject.toml

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

{codex_ipc-0.1.2 → codex_ipc-0.1.4}/src/codex_ipc/__init__.py

@@ -4,7 +4,7 @@ from codex_app_server import (
     SshWebsocketAppServerConfig,
     TextInput,
 )
-from ipc.conversation_state import JsonDict
+from ipc.conversation_state import JsonDict, materialize_conversation_state
 
 from codex_ipc.codex.api import AsyncCodex, AsyncThread
 from codex_ipc.config import CodexIpcConfig
@@ -26,6 +26,7 @@ __all__ = [
     "CodexIpcConfig",
     "CodexIpcSession",
     "JsonDict",
+    "materialize_conversation_state",
     "TextInput",
     "USER_INPUT_REQUEST_METHOD",
     "UserInputOptionRow",

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

@@ -42,8 +42,13 @@ from codex_ipc.user_input import build_user_input_response
 from ipc.conversation_state import (
     PLAN_IMPLEMENTATION_PROMPT_PREFIX,
     build_conversation_state,
+    canonicalize_conversation_patches,
+    conversation_state_snapshot,
+    conversation_turns,
     default_collaboration_mode,
+    materialize_conversation_state,
 )
+from ipc.constants import IPC_METHOD_VERSIONS
 from ipc.owner_follower import OwnerFollowerSession
 
 
@@ -570,6 +575,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
@@ -596,7 +616,284 @@ print(codex_ipc.CodexIpcConfig.__name__)
         self.assertIn("CodexIpcConfig", result.stdout)
 
 
+class ConversationStateV11Tests(unittest.TestCase):
+    def test_snapshot_canonicalizes_legacy_turns_without_mutating_state(self) -> None:
+        turns = [
+            {"turnId": "turn-1", "status": "completed", "items": []},
+            {"turnId": None, "status": "inProgress", "items": []},
+        ]
+        state = {
+            "id": "thread-1",
+            "turns": turns,
+            "turnsPagination": {
+                "olderCursor": None,
+                "oldestLoadedTurnId": "turn-1",
+                "isLoadingOlder": False,
+                "hasLoadedOldest": True,
+            },
+        }
+
+        snapshot = conversation_state_snapshot(state)
+
+        self.assertIs(state["turns"], turns)
+        self.assertEqual(snapshot["turns"], [])
+        history = snapshot["turnHistory"]["history"]
+        self.assertTrue(history["isComplete"])
+        self.assertEqual(
+            history["islands"][0]["entries"],
+            [
+                {"key": "turn:turn-1", "value": "turn:turn-1"},
+                {"key": "tail:0:local:1", "value": "tail:0:local:1"},
+            ],
+        )
+        self.assertEqual(conversation_turns(snapshot), turns)
+
+    def test_materialize_merges_canonical_history_with_live_overlay(self) -> None:
+        historical_turn = {
+            "turnId": "turn-1",
+            "status": "inProgress",
+            "items": [{"type": "agentMessage", "id": "agent-1", "text": ""}],
+        }
+        completed_overlay = {
+            "turnId": "turn-1",
+            "status": "completed",
+            "items": [
+                {"type": "agentMessage", "id": "agent-1", "text": "done"}
+            ],
+        }
+        state = {
+            "id": "thread-1",
+            "turnHistory": {
+                "kind": "canonical",
+                "history": {
+                    "entitiesByKey": {"turn:turn-1": historical_turn},
+                    "generation": 0,
+                    "isComplete": True,
+                    "islands": [
+                        {
+                            "id": "tail:0",
+                            "entries": [
+                                {"key": "turn:turn-1", "value": "turn:turn-1"}
+                            ],
+                            "olderBoundary": {"status": "exhausted"},
+                            "newerBoundary": {"status": "exhausted"},
+                        }
+                    ],
+                },
+            },
+            "turns": [completed_overlay],
+        }
+
+        materialized = materialize_conversation_state(state)
+
+        self.assertIsNot(materialized, state)
+        self.assertEqual(materialized["turns"], [completed_overlay])
+        self.assertEqual(
+            state["turnHistory"]["history"]["entitiesByKey"]["turn:turn-1"],
+            historical_turn,
+        )
+
+    def test_translates_turn_delta_to_canonical_entity_patch(self) -> None:
+        previous = {
+            "id": "thread-1",
+            "turns": [
+                {
+                    "turnId": "turn-1",
+                    "status": "inProgress",
+                    "items": [{"type": "agentMessage", "id": "agent-1", "text": "a"}],
+                }
+            ],
+        }
+        next_state = {
+            **previous,
+            "turns": [
+                {
+                    "turnId": "turn-1",
+                    "status": "inProgress",
+                    "items": [
+                        {"type": "agentMessage", "id": "agent-1", "text": "ab"}
+                    ],
+                }
+            ],
+        }
+
+        patches = canonicalize_conversation_patches(
+            previous,
+            next_state,
+            [
+                {
+                    "op": "replace",
+                    "path": ["turns", 0, "items", 0, "text"],
+                    "value": "ab",
+                }
+            ],
+        )
+
+        self.assertEqual(
+            patches,
+            [
+                {
+                    "op": "replace",
+                    "path": [
+                        "turnHistory",
+                        "history",
+                        "entitiesByKey",
+                        "turn:turn-1",
+                        "items",
+                        0,
+                        "text",
+                    ],
+                    "value": "ab",
+                }
+            ],
+        )
+
+    def test_replaces_canonical_history_for_structural_turn_change(self) -> None:
+        previous = {"id": "thread-1", "turns": []}
+        next_state = {
+            "id": "thread-1",
+            "turns": [
+                {"turnId": None, "status": "inProgress", "items": []}
+            ],
+        }
+
+        patches = canonicalize_conversation_patches(
+            previous,
+            next_state,
+            [
+                {
+                    "op": "add",
+                    "path": ["turns", 0],
+                    "value": next_state["turns"][0],
+                }
+            ],
+        )
+
+        self.assertEqual(len(patches), 1)
+        self.assertEqual(patches[0]["op"], "replace")
+        self.assertEqual(patches[0]["path"], ["turnHistory"])
+        self.assertEqual(patches[0]["value"]["kind"], "canonical")
+
+
 class PlanModeTests(unittest.IsolatedAsyncioTestCase):
+    async def test_owner_broadcasts_initial_state_as_canonical_snapshot(self) -> None:
+        session = make_session()
+        ipc_client = FakeIpcClient()
+        session.ipc_client = ipc_client
+        session._stream_role = {"role": "owner"}
+        session._state = {
+            "id": "thread-1",
+            "turns": [
+                {"turnId": "turn-1", "status": "completed", "items": []}
+            ],
+        }
+
+        await session._broadcast_snapshot()
+
+        _method, params = ipc_client.broadcasts[0]
+        change = params["change"]
+        self.assertEqual(change["type"], "snapshot")
+        self.assertEqual(change["conversationState"]["turns"], [])
+        self.assertEqual(
+            change["conversationState"]["turnHistory"]["history"]["islands"][0][
+                "entries"
+            ],
+            [{"key": "turn:turn-1", "value": "turn:turn-1"}],
+        )
+
+    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")
@@ -691,7 +988,7 @@ class PlanModeTests(unittest.IsolatedAsyncioTestCase):
         )
         self.assertGreater(session.state["updatedAt"], 0)
 
-    async def test_owner_follower_broadcasts_whole_collaboration_mode_patch(self) -> None:
+    async def test_owner_broadcasts_collaboration_mode_as_patch(self) -> None:
         session_events: list[dict] = []
         session = make_session(session_event=session_events.append)
         ipc_client = FakeIpcClient()
@@ -728,20 +1025,19 @@ class PlanModeTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(len(session_events), 1)
         self.assertEqual(session_events[0]["method"], "thread-stream-state-changed")
         self.assertEqual(session_events[0]["params"], params)
+        change = params["change"]
+        self.assertEqual(change["type"], "patches")
+        self.assertEqual(change["revision"], 1)
+        self.assertEqual(change["baseRevision"], 0)
         self.assertEqual(
-            params["change"],
-            {
-                "type": "patches",
-                "baseRevision": 0,
-                "revision": 1,
-                "patches": [
-                    {
-                        "op": "replace",
-                        "path": ["latestCollaborationMode"],
-                        "value": collaboration_mode,
-                    }
-                ],
-            },
+            change["patches"],
+            [
+                {
+                    "op": "replace",
+                    "path": ["latestCollaborationMode"],
+                    "value": collaboration_mode,
+                }
+            ],
         )
 
     async def test_facade_session_exposes_session_event_watchers(self) -> None:
@@ -762,7 +1058,7 @@ class PlanModeTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(listener_events, [event])
         await watcher.aclose()
 
-    async def test_owner_follower_broadcasts_whole_default_mode_patch(self) -> None:
+    async def test_owner_broadcasts_default_mode_as_patch(self) -> None:
         session = make_session()
         ipc_client = FakeIpcClient()
         session.ipc_client = ipc_client
@@ -794,20 +1090,17 @@ class PlanModeTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertEqual(len(ipc_client.broadcasts), 1)
         _method, params = ipc_client.broadcasts[0]
+        change = params["change"]
+        self.assertEqual(change["type"], "patches")
         self.assertEqual(
-            params["change"],
-            {
-                "type": "patches",
-                "baseRevision": 0,
-                "revision": 1,
-                "patches": [
-                    {
-                        "op": "replace",
-                        "path": ["latestCollaborationMode"],
-                        "value": collaboration_mode,
-                    }
-                ],
-            },
+            change["patches"],
+            [
+                {
+                    "op": "replace",
+                    "path": ["latestCollaborationMode"],
+                    "value": collaboration_mode,
+                }
+            ],
         )
 
     async def test_owner_only_accepts_snapshot_not_patches(self) -> None:

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

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