Lightweight coding agent that runs in your terminal
Rust
Start Python SDK turn subscriptions at their attachment point (#44400)
Ahmed Ibrahimddea03ad0491
diff --git a/sdk/python/docs/api-reference.md b/sdk/python/docs/api-reference.mdindex 6eeea25050..5d9c160dff 100644--- a/sdk/python/docs/api-reference.md+++ b/sdk/python/docs/api-reference.md@@ -233,6 +233,9 @@ passed to `run(...)` or `turn(...)` applies to that turn and subsequent turns.## TurnHandle / AsyncTurnHandle+A `thread.turn(...)` handle receives events from when the call sends its request.+Other handles start when they join; use `thread.read(include_turns=True)` for earlier history.+### TurnHandle- `steer(input: str | Input) -> TurnSteerResponse`diff --git a/sdk/python/scripts/update_sdk_artifacts.py b/sdk/python/scripts/update_sdk_artifacts.pyindex 4530a6d0bf..0c97d5156e 100755--- a/sdk/python/scripts/update_sdk_artifacts.py+++ b/sdk/python/scripts/update_sdk_artifacts.py@@ -1294,8 +1294,8 @@ def _render_thread_block(turn_fields: list[PublicFieldSpec], *, is_async: bool =*_approval_mode_model_arg_lines(),*_model_arg_lines(turn_fields)," )",- f" turn = {await_prefix}{client}.turn_start(self.id, wire_input, params=params)",- f" return {handle_type}({handle_owner}, self.id, turn.turn.id)",+ f" turn, subscription = {await_prefix}{client}._start_turn(self.id, wire_input, params=params, for_handle=True)",+ f" return {handle_type}({handle_owner}, self.id, turn.turn.id, _subscription=subscription)",]return "\n".join(lines)diff --git a/sdk/python/src/openai_codex/_message_router.py b/sdk/python/src/openai_codex/_message_router.pyindex 2d69099d4b..8ab5ff1339 100644--- a/sdk/python/src/openai_codex/_message_router.py+++ b/sdk/python/src/openai_codex/_message_router.py@@ -11,11 +11,7 @@ from typing import Iteratorfrom ._goal import _GoalOperationStatefrom .errors import CodexError, TransportClosedError, map_jsonrpc_errorfrom .generated.notification_registry import notification_turn_id-from .generated.v2_all import (- AccountLoginCompletedNotification,- ItemCompletedNotification,- ThreadTokenUsageUpdatedNotification,-)+from .generated.v2_all import AccountLoginCompletedNotificationfrom .models import JsonValue, Notification, UnknownNotificationResponseQueueItem = JsonValue | BaseException@@ -30,29 +26,18 @@ class _TurnState:first_event: int = 0next_event: int = 0subscribers: dict[object, int] = field(default_factory=dict)- subscribed: bool = False- completed_items: dict[str, Notification] = field(default_factory=dict)- usage: Notification | None = None- terminal: NotificationQueueItem | None = None- unclaimed: int = 0completed: bool = Falseclass _TurnSubscription:- """One consumer's result snapshot and cursor over shared unread events."""+ """One consumer's cursor over shared unread events."""- def __init__(self, router: MessageRouter, state: _TurnState) -> None:+ def __init__(self, router: MessageRouter, state: _TurnState, cursor: int) -> None:self._router = routerself._state = state- self._cursor = state.first_event+ self._cursor = cursorself._token = object()state.subscribers[self._token] = self._cursor- state.subscribed = True- self._replay: deque[NotificationQueueItem] = deque(state.completed_items.values())- if state.usage is not None:- self._replay.append(state.usage)- if state.terminal is not None:- self._replay.append(state.terminal)self._closed = Falseself._release = weakref.finalize(self, router._release_turn, weakref.ref(router), state, self._token@@ -60,17 +45,16 @@ class _TurnSubscription:def next(self) -> Notification:with self._router._turn_condition:- while not self._replay and self._cursor == self._state.next_event and not self._closed:+ while self._cursor == self._state.next_event and not self._closed:+ if self._state.completed:+ raise TransportClosedError("Turn is no longer streaming")self._router._turn_condition.wait()if self._closed:raise TransportClosedError("Turn subscription closed")- if self._replay:- item = self._replay.popleft()- else:- item = self._state.events[self._cursor]- self._cursor += 1- self._state.subscribers[self._token] = self._cursor- self._router._prune_turn_events(self._state)+ item = self._state.events[self._cursor]+ self._cursor += 1+ self._state.subscribers[self._token] = self._cursor+ self._router._prune_turn_events(self._state)if isinstance(item, BaseException):raise itemreturn item@@ -78,7 +62,6 @@ class _TurnSubscription:def close(self) -> None:with self._router._turn_condition:self._closed = True- self._replay.clear()self._router._turn_condition.notify_all()self._release()@@ -101,8 +84,8 @@ class MessageRouter:self._pending_login_notifications: dict[str, deque[Notification]] = {}self._turn_condition = threading.Condition(self._lock)self._turn_states: dict[str, _TurnState] = {}- self._turn_notifications: dict[str, _TurnSubscription | None] = {}- self._pending_turn_requests: dict[str, int] = {}+ self._turn_notifications: dict[str, _TurnSubscription] = {}+ self._pending_turn_requests: dict[str, BaseException | None] = {}self._goal_operations: dict[str, _GoalOperationState] = {}self._global_notifications: queue.Queue[NotificationQueueItem] = queue.Queue()@@ -159,41 +142,43 @@ class MessageRouter:return item@contextmanager- def pending_turn(self, thread_id: str) -> Iterator[None]:- """Retain early completion while a turn/start response is in flight."""+ def pending_turn(self, thread_id: str) -> Iterator[dict[str, int]]:+ """Buffer events from the point a turn/start request is sent."""with self._lock:- self._pending_turn_requests[thread_id] = (- self._pending_turn_requests.get(thread_id, 0) + 1- )+ cursors = {turn_id: state.next_event for turn_id, state in self._turn_states.items()}+ self._pending_turn_requests[thread_id] = Nonetry:- yield+ yield cursorsfinally:with self._lock:- self._pending_turn_requests[thread_id] -= 1- if self._pending_turn_requests[thread_id] == 0:- del self._pending_turn_requests[thread_id]+ del self._pending_turn_requests[thread_id]for state in list(self._turn_states.values()):- if state.thread_id == thread_id:+ if state.thread_id in (None, thread_id):self._prune_turn_events(state)- self._discard_finished_turn(state)- def prepare_turn(self, turn_id: str, thread_id: str) -> None:- """Reserve the returned turn for a handle or a low-level consumer."""+ def prepare_turn(+ self, turn_id: str, thread_id: str, cursors: dict[str, int], *, for_handle: bool+ ) -> _TurnSubscription | None:+ """Attach the requesting handle or the single low-level consumer."""with self._lock:state = self._turn_states.setdefault(turn_id, _TurnState(turn_id, thread_id))state.thread_id = thread_id- state.unclaimed += 1- self._turn_notifications.setdefault(turn_id, None)-- def _subscribe_turn_locked(self, turn_id: str) -> _TurnSubscription:- state = self._turn_states.setdefault(turn_id, _TurnState(turn_id))- state.unclaimed = max(0, state.unclaimed - 1)- return _TurnSubscription(self, state)+ if not for_handle and turn_id in self._turn_notifications:+ return None+ if not state.completed and (err := self._pending_turn_requests[thread_id]) is not None:+ state.events[state.next_event] = err+ state.next_event += 1+ state.completed = True+ subscription = _TurnSubscription(self, state, cursors.get(turn_id, 0))+ if not for_handle:+ self._turn_notifications[turn_id] = subscription+ return subscriptiondef subscribe_turn(self, turn_id: str) -> _TurnSubscription:- """Attach a consumer with completed items, latest usage, and unread events."""+ """Attach a consumer starting at the next event for this turn."""with self._lock:- return self._subscribe_turn_locked(turn_id)+ state = self._turn_states.setdefault(turn_id, _TurnState(turn_id))+ return _TurnSubscription(self, state, state.next_event)@staticmethoddef _release_turn(@@ -202,74 +187,42 @@ class MessageRouter:router = router_ref()if router is not None:with router._lock:+ default = router._turn_notifications.get(state.id)+ if default is not None and default._token is token:+ del router._turn_notifications[state.id]state.subscribers.pop(token, None)router._prune_turn_events(state)- router._discard_finished_turn(state)def _prune_turn_events(self, state: _TurnState) -> None:- if (- not state.subscribed- or state.unclaimed- or self._pending_turn_requests.get(state.thread_id, 0)+ if state.thread_id in self._pending_turn_requests or (+ state.thread_id is None and self._pending_turn_requests):returnconsumed = min(state.subscribers.values(), default=state.next_event)while state.first_event < consumed:- event = state.events.pop(state.first_event)+ del state.events[state.first_event]state.first_event += 1- # Late joins need the completed result, not every consumed token delta- # or intermediate usage update. Keep one snapshot entry per item.- if isinstance(event, BaseException) or event.method == "turn/completed":- state.terminal = event- elif isinstance(event.payload, ItemCompletedNotification):- item = event.payload.item- state.completed_items[getattr(item, "root", item).id] = event- elif isinstance(event.payload, ThreadTokenUsageUpdatedNotification):- state.usage = event-- def _discard_finished_turn(self, state: _TurnState) -> None:- if (- state.completed- and not state.subscribers- and not state.unclaimed- and not self._pending_turn_requests.get(state.thread_id, 0)- ):- self._turn_states.pop(state.id, None)- if self._turn_notifications.get(state.id) is None:- self._turn_notifications.pop(state.id, None)- state.events.clear()- state.completed_items.clear()- state.usage = None- state.terminal = None+ if not state.subscribers and self._turn_states.get(state.id) is state:+ del self._turn_states[state.id]def register_turn(self, turn_id: str) -> None:"""Register the default consumer used by the low-level client API."""with self._lock:- if self._turn_notifications.get(turn_id) is None:- self._turn_notifications[turn_id] = self._subscribe_turn_locked(turn_id)+ if turn_id not in self._turn_notifications:+ self._turn_notifications[turn_id] = self.subscribe_turn(turn_id)def unregister_turn(self, turn_id: str) -> None:"""Close only the low-level consumer, leaving other handles subscribed."""with self._lock:- if turn_id not in self._turn_notifications:- return- subscription = self._turn_notifications.pop(turn_id)- if subscription is None and (state := self._turn_states.get(turn_id)) is not None:- state.unclaimed = max(0, state.unclaimed - 1)- self._prune_turn_events(state)- self._discard_finished_turn(state)- if subscription is not None:- subscription.close()+ if subscription := self._turn_notifications.get(turn_id):+ subscription.close()def next_turn_notification(self, turn_id: str) -> Notification:"""Block until the next event for the default low-level consumer."""with self._lock:- if turn_id not in self._turn_notifications:- raise RuntimeError(f"turn {turn_id!r} is not registered for streaming")- subscription = self._turn_notifications[turn_id]+ subscription = self._turn_notifications.get(turn_id)if subscription is None:- subscription = self._subscribe_turn_locked(turn_id)- self._turn_notifications[turn_id] = subscription+ raise RuntimeError(f"turn {turn_id!r} is not registered for streaming")return subscription.next()def register_goal(self, thread_id: str) -> _GoalOperationState:@@ -363,10 +316,9 @@ class MessageRouter:state.thread_id = thread_id or state.thread_idstate.events[state.next_event] = notificationstate.next_event += 1- self._prune_turn_events(state)if notification.method == "turn/completed":state.completed = True- self._discard_finished_turn(state)+ self._prune_turn_events(state)self._turn_condition.notify_all()def fail_all(self, exc: BaseException) -> None:@@ -378,12 +330,13 @@ class MessageRouter:login_queues = list(self._login_notifications.values())self._login_notifications.clear()self._pending_login_notifications.clear()+ for thread_id in self._pending_turn_requests:+ self._pending_turn_requests[thread_id] = excfor state in list(self._turn_states.values()):state.events[state.next_event] = excstate.next_event += 1- self._prune_turn_events(state)state.completed = True- self._discard_finished_turn(state)+ self._prune_turn_events(state)self._turn_condition.notify_all()goal_operations = list(self._goal_operations.values())self._goal_operations.clear()diff --git a/sdk/python/src/openai_codex/api.py b/sdk/python/src/openai_codex/api.pyindex d29c8dad7f..d226744cf8 100644--- a/sdk/python/src/openai_codex/api.py+++ b/sdk/python/src/openai_codex/api.py@@ -649,8 +649,10 @@ class Thread:summary=summary,service_tier_for_turn=turn_service_tier,)- turn = self._client.turn_start(self.id, wire_input, params=params)- return TurnHandle(self._client, self.id, turn.turn.id)+ turn, subscription = self._client._start_turn(+ self.id, wire_input, params=params, for_handle=True+ )+ return TurnHandle(self._client, self.id, turn.turn.id, _subscription=subscription)# END GENERATED: Thread.flat_methods@@ -754,8 +756,10 @@ class AsyncThread:summary=summary,service_tier_for_turn=turn_service_tier,)- turn = await self._codex._client.turn_start(self.id, wire_input, params=params)- return AsyncTurnHandle(self._codex, self.id, turn.turn.id)+ turn, subscription = await self._codex._client._start_turn(+ self.id, wire_input, params=params, for_handle=True+ )+ return AsyncTurnHandle(self._codex, self.id, turn.turn.id, _subscription=subscription)# END GENERATED: AsyncThread.flat_methods@@ -782,6 +786,15 @@ class TurnHandle:id: str_subscription: _TurnSubscription = field(init=False, repr=False, compare=False)+ def __init__(+ self, _client: CodexClient, thread_id: str, id: str, *, _subscription=None+ ) -> None:+ self._client, self.thread_id, self.id = _client, thread_id, id+ if _subscription is None:+ self.__post_init__()+ else:+ self._subscription = _subscription+def __post_init__(self) -> None:self._subscription = self._client._subscribe_turn_notifications(self.id)@@ -830,6 +843,13 @@ class AsyncTurnHandle:id: str_subscription: _TurnSubscription = field(init=False, repr=False, compare=False)+ def __init__(self, _codex: AsyncCodex, thread_id: str, id: str, *, _subscription=None) -> None:+ self._codex, self.thread_id, self.id = _codex, thread_id, id+ if _subscription is None:+ self.__post_init__()+ else:+ self._subscription = _subscription+def __post_init__(self) -> None:self._subscription = self._codex._client._subscribe_turn_notifications(self.id)diff --git a/sdk/python/src/openai_codex/async_client.py b/sdk/python/src/openai_codex/async_client.pyindex 889970e038..a4c80e65c5 100644--- a/sdk/python/src/openai_codex/async_client.py+++ b/sdk/python/src/openai_codex/async_client.py@@ -296,19 +296,31 @@ class AsyncCodexClient:params: V2TurnStartParams | JsonObject | None = None,) -> TurnStartResponse:"""Start a turn, releasing an unclaimed result if the caller is cancelled."""+ return (await self._start_turn(thread_id, input_items, params, for_handle=False))[0]++ async def _start_turn(+ self,+ thread_id: str,+ input_items: list[JsonObject] | JsonObject | str,+ params: V2TurnStartParams | JsonObject | None,+ for_handle: bool,+ ) -> tuple[TurnStartResponse, _TurnSubscription | None]:operation = _TURN_START_EXECUTOR.submit(- copy_context().run, self._sync.turn_start, thread_id, input_items, params+ copy_context().run, self._sync._start_turn, thread_id, input_items, params, for_handle)try:return await asyncio.wrap_future(operation)except asyncio.CancelledError:- def discard_cancelled_result(completed: Future[TurnStartResponse]) -> None:+ def discard_cancelled_result(+ completed: Future[tuple[TurnStartResponse, _TurnSubscription | None]],+ ) -> None:try:- started = completed.result()+ _, subscription = completed.result()except BaseException:return- self._sync._subscribe_turn_notifications(started.turn.id).close()+ if subscription is not None:+ subscription.close()operation.add_done_callback(discard_cancelled_result)raisediff --git a/sdk/python/src/openai_codex/client.py b/sdk/python/src/openai_codex/client.pyindex 265bb5e9a9..5b38538c54 100644--- a/sdk/python/src/openai_codex/client.py+++ b/sdk/python/src/openai_codex/client.py@@ -654,6 +654,15 @@ class CodexClient:params: V2TurnStartParams | JsonObject | None = None,) -> TurnStartResponse:"""Start a turn and register its notification queue as early as possible."""+ return self._start_turn(thread_id, input_items, params, for_handle=False)[0]++ def _start_turn(+ self,+ thread_id: str,+ input_items: list[JsonObject] | JsonObject | str,+ params: V2TurnStartParams | JsonObject | None,+ for_handle: bool,+ ) -> tuple[TurnStartResponse, _TurnSubscription | None]:with self._thread_start_lock(thread_id):if self._router.has_goal(thread_id):raise InvalidRequestError(@@ -665,10 +674,12 @@ class CodexClient:"threadId": thread_id,"input": self._normalize_input_items(input_items),}- with self._router.pending_turn(thread_id):+ with self._router.pending_turn(thread_id) as cursors:started = self.request("turn/start", payload, response_model=TurnStartResponse)- self._router.prepare_turn(started.turn.id, thread_id)- return started+ subscription = self._router.prepare_turn(+ started.turn.id, thread_id, cursors, for_handle=for_handle+ )+ return started, subscription@contextmanagerdef _thread_start_lock(self, thread_id: str) -> Iterator[None]:diff --git a/sdk/python/tests/test_app_server_inputs.py b/sdk/python/tests/test_app_server_inputs.pyindex f8649a4241..26e0bfa659 100644--- a/sdk/python/tests/test_app_server_inputs.py+++ b/sdk/python/tests/test_app_server_inputs.py@@ -82,7 +82,10 @@ def test_external_message_joins_active_turn_with_tool_authority(tmp_path) -> Nonharness.responses.wait_for_requests(1)joined = thread.turn(ExternalMessage(tool_name="notifications", content=content))result = consumers.submit(joined.run).result(timeout=15)- assert original_result.result(timeout=15) == result+ first = original_result.result(timeout=15)+ assert first.final_response == result.final_response+ assert first.items[0].root.type == "userMessage"+ assert all(item.root.type != "userMessage" for item in result.items)assert codex._client._router._turn_states == {}requests = harness.responses.requests()@@ -151,7 +154,7 @@ def test_async_external_message_allows_both_handles_to_consume(tmp_path) -> Nonefirst, second = await asyncio.wait_for(asyncio.gather(original_result, joined.run()), timeout=15)- assert first == second+ assert (first.final_response, first.usage) == (second.final_response, second.usage)assert first.final_response == "Update processed"assert first.usage is not Noneassert codex._client._sync._router._turn_states == {}diff --git a/sdk/python/tests/test_client_rpc_methods.py b/sdk/python/tests/test_client_rpc_methods.pyindex f46eacad47..8b7485f0dc 100644--- a/sdk/python/tests/test_client_rpc_methods.py+++ b/sdk/python/tests/test_client_rpc_methods.py@@ -617,9 +617,10 @@ def test_client_reader_routes_interleaved_turn_notifications_by_turn_id() -> Non)-def test_turn_notification_router_buffers_events_before_registration() -> None:- """Early turn events should be replayed once their TurnHandle registers."""+def test_turn_notification_router_starts_at_explicit_registration() -> None:+ """Explicit registration receives events from when the caller attaches."""client = CodexClient()+ client.register_turn_notifications("turn-1")client._router.route_notification(client._coerce_notification("item/agentMessage/delta",@@ -632,7 +633,6 @@ def test_turn_notification_router_buffers_events_before_registration() -> None:))- client.register_turn_notifications("turn-1")event = client.next_turn_notification("turn-1")assert isinstance(event.payload, AgentMessageDeltaNotification)diff --git a/sdk/python/tests/test_public_api_runtime_behavior.py b/sdk/python/tests/test_public_api_runtime_behavior.pyindex 780cff3fab..fc98f88311 100644--- a/sdk/python/tests/test_public_api_runtime_behavior.py+++ b/sdk/python/tests/test_public_api_runtime_behavior.py@@ -191,10 +191,10 @@ def test_turn_inputs_and_options_reach_the_client(api_type, method, content) ->}),)+ subscription = SimpleNamespace(next=Mock(return_value=completed), close=Mock())client = SimpleNamespace(- turn_start=rpc(return_value=SimpleNamespace(turn=SimpleNamespace(id="turn-1"))),- _subscribe_turn_notifications=Mock(- return_value=SimpleNamespace(next=Mock(return_value=completed), close=Mock())+ _start_turn=rpc(+ return_value=(SimpleNamespace(turn=SimpleNamespace(id="turn-1")), subscription)),)codex = api_type.__new__(api_type)@@ -229,7 +229,7 @@ def test_turn_inputs_and_options_reach_the_client(api_type, method, content) ->"toolOutput": {"name": "notifications", "namespace": "slack", "output": content},})- assert _params_dict(client.turn_start.call_args.kwargs["params"]) == {+ assert _params_dict(client._start_turn.call_args.kwargs["params"]) == {"threadId": "thread-1","input": expected_input,"serviceTier": "priority",@@ -249,7 +249,7 @@ def test_external_messages_cannot_be_mixed_with_user_input_or_sent_as_user_steerasync_api = api_type is AsyncCodexrpc = AsyncMock if async_api else Mockclient = SimpleNamespace(- turn_start=rpc(), turn_steer=rpc(), _subscribe_turn_notifications=Mock()+ _start_turn=rpc(), turn_steer=rpc(), _subscribe_turn_notifications=Mock())codex = api_type.__new__(api_type)codex._client = client@@ -277,7 +277,7 @@ def test_external_messages_cannot_be_mixed_with_user_input_or_sent_as_user_steerresult = thread.turn(ExternalMessage(tool_name=" ", content="Untrusted update"))if async_api:await result- client.turn_start.assert_not_called()+ client._start_turn.assert_not_called()client.turn_steer.assert_not_called()asyncio.run(scenario())diff --git a/sdk/python/tests/test_turn_subscriptions.py b/sdk/python/tests/test_turn_subscriptions.pyindex 30937d1396..fea67c9cb0 100644--- a/sdk/python/tests/test_turn_subscriptions.py+++ b/sdk/python/tests/test_turn_subscriptions.py@@ -8,7 +8,7 @@ import pytestfrom openai_codex import AsyncCodexfrom openai_codex._run import _collect_turn_result-from openai_codex.api import AsyncTurnHandle, TurnHandle+from openai_codex.api import AsyncThread, AsyncTurnHandle, Thread, TurnHandlefrom openai_codex.async_client import AsyncCodexClientfrom openai_codex.client import CodexClientfrom openai_codex.errors import TransportClosedError@@ -55,23 +55,24 @@ def turn_events(client, *, status="completed"):]-def test_late_join_replays_items_already_consumed_by_original_handle():[email protected]("consumed", [False, True])+def test_late_join_starts_with_future_events(consumed):client = CodexClient()original = TurnHandle(client, "thread-1", "turn-1")events = turn_events(client)client._router.route_notification(events[0])stream = original.stream()- first = next(stream)- client._router.route_notification(events[1])- usage = next(stream)+ previous = [next(stream)] if consumed else []joined = TurnHandle(client, "thread-1", "turn-1")+ client._router.route_notification(events[1])for event in events[2:]:client._router.route_notification(event)- first_result = _collect_turn_result(chain([first, usage], stream), turn_id="turn-1")- assert joined.run() == first_result+ first_result = _collect_turn_result(chain(previous, stream), turn_id="turn-1")+ joined_result = joined.run()assert first_result.final_response == "done"- assert first_result.usage.last.total_tokens == 5+ assert joined_result.final_response is None+ assert joined_result.usage == first_result.usageassert client._router._turn_states == {}@@ -92,7 +93,6 @@ def test_consumed_deltas_are_released_while_turn_is_active():client._router.route_notification(event)assert subscription.next() == eventassert state.events == {}- assert state.completed_items == {}assert not state.completedsubscription.close()@@ -113,32 +113,69 @@ def test_slow_subscriber_keeps_unread_deltas_until_it_consumes_them():slow.close()-def test_completion_before_turn_start_response_is_replayed(monkeypatch):- client = CodexClient()[email protected]("async_api", [False, True])[email protected]("low_level", [False, True])[email protected]("completed", [False, True])+def test_events_or_failure_before_turn_start_returns(monkeypatch, async_api, low_level, completed):+ codex = AsyncCodex()+ codex._initialized = True+ client = codex._client._sync if async_api else CodexClient()def request_raw(method, params):assert method == "turn/start"- for event in turn_events(client):+ for event in turn_events(client) if completed else []:client._router.route_notification(event)+ client._router.fail_all(TransportClosedError("transport failed"))return {"turn": {"id": "turn-1", "status": "inProgress", "items": []}}monkeypatch.setattr(client, "_request_raw", request_raw)- started = client.turn_start("thread-1", "hello")- handle = TurnHandle(client, "thread-1", started.turn.id)- assert handle.run().final_response == "done"+ public = codex._client if async_api else client+ thread = AsyncThread(codex, "thread-1") if async_api else Thread(client, "thread-1")++ async def value(call):+ return await call if async_api else call++ async def scenario():+ if low_level:+ started = await value(public.turn_start("thread-1", "hello"))+ assert (+ await value(public.wait_for_turn_completed(started.turn.id))+ ).turn.id == "turn-1"+ else:+ handle = await value(thread.turn("hello"))+ assert (await value(handle.run())).final_response == "done"++ if completed:+ asyncio.run(scenario())+ else:+ with pytest.raises(TransportClosedError, match="transport failed"):+ asyncio.run(scenario())assert client._router._turn_states == {}-def test_pending_join_preserves_result_after_original_handle_finishes():+def test_pending_join_starts_at_request_while_original_handle_finishes():client = CodexClient()original = TurnHandle(client, "thread-1", "turn-1")- with client._router.pending_turn("thread-1"):- for event in turn_events(client):- client._router.route_notification(event)+ events = turn_events(client)+ unknown = [client._coerce_notification(name, {"turnId": "turn-1"}) for name in ("old", "live")]+ client._router.route_notification(unknown[0])+ assert original._subscription.next() is unknown[0]++ with client._router.pending_turn("thread-1") as cursors:+ client._router.route_notification(unknown[1])+ assert original._subscription.next() is unknown[1]+ client._router.route_notification(events[0])+ client._router.route_notification(events[1])+ manual = TurnHandle(client, "thread-1", "turn-1")+ client._router.route_notification(events[2])result = original.run()- client._router.prepare_turn("turn-1", "thread-1")- joined = TurnHandle(client, "thread-1", "turn-1")- assert joined.run() == result+ assert manual.run().usage is None+ subscription = client._router.prepare_turn("turn-1", "thread-1", cursors, for_handle=True)+ joined_handle = TurnHandle(client, "thread-1", "turn-1", _subscription=subscription)+ assert joined_handle._subscription.next() is unknown[1]+ joined = joined_handle.run()+ assert result.final_response == joined.final_response == "done"+ assert joined.usage.last.total_tokens == 5assert client._router._turn_states == {}@@ -220,7 +257,7 @@ def test_cancelled_turn_start_releases_result_after_response(monkeypatch):entered = threading.Event()respond = threading.Event()released = threading.Event()- subscribe = client._sync._subscribe_turn_notifications+ subscribe = client._sync._router.prepare_turndef request_raw(method, params):entered.set()@@ -229,8 +266,8 @@ def test_cancelled_turn_start_releases_result_after_response(monkeypatch):client._sync._router.route_notification(event)return {"turn": {"id": "turn-1", "items": [], "status": "completed"}}- def observe_release(turn_id):- subscription = subscribe(turn_id)+ def observe_release(*args, **kwargs):+ subscription = subscribe(*args, **kwargs)close = subscription.closedef close_and_signal():@@ -241,7 +278,7 @@ def test_cancelled_turn_start_releases_result_after_response(monkeypatch):return subscriptionmonkeypatch.setattr(client._sync, "_request_raw", request_raw)- monkeypatch.setattr(client._sync, "_subscribe_turn_notifications", observe_release)+ monkeypatch.setattr(client._sync._router, "prepare_turn", observe_release)task = asyncio.create_task(client.turn_start("thread-1", "hello"))try:assert await asyncio.to_thread(entered.wait, 2)@@ -270,7 +307,7 @@ def test_cancelled_queued_start_does_not_send_a_request(monkeypatch):occupied = executor.submit(occupy_worker)assert worker_started.wait(timeout=5)client = AsyncCodexClient()- monkeypatch.setattr(client._sync, "turn_start", lambda *args: request_sent.set())+ monkeypatch.setattr(client._sync, "_start_turn", lambda *args, **kwargs: request_sent.set())async def scenario():task = asyncio.create_task(client.turn_start("thread-1", "hello"))@@ -298,6 +335,9 @@ def test_low_level_start_keeps_implicit_registration_and_explicit_unregister(monmonkeypatch.setattr(client, "_request_raw", request_raw)started = client.turn_start("thread-1", "hello")+ registered = client._router._turn_notifications[started.turn.id]+ assert client.turn_start("thread-1", "again").turn.id == started.turn.id+ assert client._router._turn_notifications[started.turn.id] is registeredassert client.next_turn_notification(started.turn.id) == turn_events(client)[0]client.unregister_turn_notifications(started.turn.id)with pytest.raises(RuntimeError, match="not registered"):