Compare commits

..
4 changed files with 848 additions and 9 deletions

No files matched your search

+41 -9
View File
@@ -5,7 +5,7 @@ import queue
import shutil
import threading
import time
from dataclasses import dataclass
from dataclasses import dataclass, field
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from typing import Any
@@ -82,12 +82,26 @@ class CapturedResponsesRequest:
return self.headers.get(name.lower())
@dataclass(frozen=True)
class SseGate:
"""Hold an SSE response after its first event has been flushed."""
ready: threading.Event = field(default_factory=threading.Event)
release: threading.Event = field(default_factory=threading.Event)
def wait_until_ready(self, timeout_s: float = 5.0) -> None:
"""Wait until the response is active and held before its second event."""
if not self.ready.wait(timeout_s):
raise AssertionError("SSE response did not reach its gate")
@dataclass(frozen=True)
class MockSseResponse:
"""One queued SSE response served by the mock Responses API."""
body: str
delay_between_events_s: float = 0.0
gate: SseGate | None = None
def chunks(self) -> list[bytes]:
"""Split an SSE body into event chunks while preserving framing."""
@@ -137,12 +151,14 @@ class MockResponsesServer:
body: str,
*,
delay_between_events_s: float = 0.0,
gate: SseGate | None = None,
) -> None:
"""Queue one SSE body for the next `/v1/responses` request."""
"""Queue SSE, optionally holding after its first event until released."""
self._responses.put(
MockSseResponse(
body=body,
delay_between_events_s=delay_between_events_s,
gate=gate,
)
)
@@ -206,11 +222,18 @@ class MockResponsesServer:
class AppServerHarness:
"""Test fixture that points a pinned runtime app-server at MockResponsesServer."""
def __init__(self, tmp_path: Path, *, requires_openai_auth: bool = False) -> None:
def __init__(
self,
tmp_path: Path,
*,
requires_openai_auth: bool = False,
enable_goals: bool | None = None,
) -> None:
self.tmp_path = tmp_path
self.codex_home = tmp_path / "codex-home"
self.workspace = tmp_path / "workspace"
self.requires_openai_auth = requires_openai_auth
self.enable_goals = enable_goals
self.responses = MockResponsesServer()
def __enter__(self) -> AppServerHarness:
@@ -240,6 +263,9 @@ class AppServerHarness:
"""Write config.toml that routes model calls to the mock server."""
config_toml = self.codex_home / "config.toml"
requires_openai_auth = "requires_openai_auth = true\n" if self.requires_openai_auth else ""
goals = ""
if self.enable_goals is not None:
goals = f"[features]\ngoals = {str(self.enable_goals).lower()}\n\n"
config_toml.write_text(
f"""
model = "mock-model"
@@ -248,7 +274,7 @@ sandbox_mode = "read-only"
model_provider = "mock_provider"
[model_providers.mock_provider]
{goals}[model_providers.mock_provider]
name = "Mock provider for Python SDK tests"
base_url = "{self.responses.url}/v1"
wire_api = "responses"
@@ -319,9 +345,15 @@ class _ResponsesHandler(BaseHTTPRequestHandler):
self.send_response(200)
self.send_header("content-type", "text/event-stream")
self.end_headers()
for chunk in response.chunks():
self.wfile.write(chunk)
self.wfile.flush()
for index, chunk in enumerate(response.chunks()):
try:
self.wfile.write(chunk)
self.wfile.flush()
except (BrokenPipeError, ConnectionResetError):
return
if index == 0 and response.gate is not None:
response.gate.ready.set()
response.gate.release.wait()
if response.delay_between_events_s:
time.sleep(response.delay_between_events_s)
@@ -440,12 +472,12 @@ def ev_function_call(call_id: str, name: str, arguments: str) -> Json:
}
def ev_failed(response_id: str, message: str) -> Json:
def ev_failed(response_id: str, message: str, *, code: str = "server_error") -> Json:
"""Return a failed model response event."""
return {
"type": "response.failed",
"response": {
"id": response_id,
"error": {"code": "server_error", "message": message},
"error": {"code": code, "message": message},
},
}
@@ -0,0 +1,487 @@
import _thread
import asyncio
import threading
import time
import pytest
from app_server_harness import AppServerHarness, SseGate, ev_failed, ev_response_created, sse
from app_server_helpers import streaming_response
from openai_codex import AsyncCodex, Codex
from openai_codex.api import _MAX_THREAD_GOAL_OBJECTIVE_CHARS
from openai_codex.errors import InvalidRequestError, TransportClosedError
from openai_codex.generated.v2_all import (
IdleThreadStatus,
ThreadGoalGetResponse,
ThreadGoalStatus,
TurnStatus,
)
def _queued_notification(state):
notifications = state._notifications
with notifications.not_empty:
if not notifications.not_empty.wait_for(lambda: bool(notifications.queue), timeout=5):
raise AssertionError("goal notification was not queued")
return notifications.queue[0]
def _wait_until_consumed(state, marker) -> None:
notifications = state._notifications
with notifications.not_full:
if not notifications.not_full.wait_for(
lambda: all(item is not marker for item in notifications.queue),
timeout=5,
):
raise AssertionError("goal stream did not begin collecting")
def test_terminal_goal_failure_preserves_status_and_releases_routing(tmp_path) -> None:
"""A failed server turn should stop rollover work and leave the thread usable."""
with AppServerHarness(tmp_path) as harness:
harness.responses.enqueue_sse(
sse(
[
ev_response_created("goal-terminal-failure"),
ev_failed(
"goal-terminal-failure",
"goal model failed",
code="insufficient_quota",
),
]
)
)
with Codex(config=harness.app_server_config()) as codex:
thread = codex.thread_start()
with pytest.raises(RuntimeError) as error:
thread.run_goal("Fail this goal turn")
persisted = codex._client.request(
"thread/goal/get",
{"threadId": thread.id},
response_model=ThreadGoalGetResponse,
).goal
harness.responses.enqueue_assistant_message(
"Recovered with an ordinary turn.",
response_id="goal-failure-follow-up",
)
follow_up = thread.run("Run after the goal failure")
harness.responses.wait_for_requests(2)
requests = harness.responses.requests()
assert {
"error": str(error.value),
"goal_status": persisted.status if persisted else None,
"follow_up": (follow_up.status, follow_up.final_response),
"request_count": len(requests),
"follow_up_input": requests[1].message_input_texts("user")[-1:],
} == {
"error": "Quota exceeded. Check your plan and billing details.",
"goal_status": ThreadGoalStatus.usage_limited,
"follow_up": (TurnStatus.completed, "Recovered with an ordinary turn."),
"request_count": 2,
"follow_up_input": ["Run after the goal failure"],
}
def test_sync_goal_run_cancellation_stops_work_and_releases_routing(tmp_path) -> None:
"""Keyboard interruption should pause and interrupt a running logical goal."""
with AppServerHarness(tmp_path) as harness:
work_gate = SseGate()
harness.responses.enqueue_sse(
streaming_response(
"cancelled-sync-run",
"msg-cancelled-sync-run",
["cancelled ", "sync ", "goal"],
),
delay_between_events_s=0.5,
gate=work_gate,
)
harness.responses.enqueue_assistant_message(
"Sync follow-up complete.",
response_id="cancelled-sync-run-follow-up",
)
with Codex(config=harness.app_server_config()) as codex:
try:
thread = codex.thread_start()
turn = thread.start_goal("Cancel this running sync goal")
goal = turn._goal
assert goal is not None
goal_state = goal.state
work_gate.wait_until_ready()
marker = _queued_notification(goal_state)
worker_errors: list[BaseException] = []
def interrupt_when_collecting() -> None:
try:
_wait_until_consumed(goal_state, marker)
except BaseException as exc:
worker_errors.append(exc)
finally:
_thread.interrupt_main()
work_gate.release.set()
interrupter = threading.Thread(target=interrupt_when_collecting)
try:
with pytest.raises(KeyboardInterrupt):
interrupter.start()
turn.run()
finally:
interrupter.join()
finally:
work_gate.release.set()
deadline = time.monotonic() + 5
while True:
current = thread.read()
if isinstance(current.thread.status.root, IdleThreadStatus):
break
if time.monotonic() >= deadline:
raise AssertionError("cancelled sync goal turn did not stop")
time.sleep(0.01)
persisted = codex._client.request(
"thread/goal/get",
{"threadId": thread.id},
response_model=ThreadGoalGetResponse,
).goal
registered_goals = dict(codex._client._router._goal_operations)
follow_up = thread.run("Continue after cancelling the sync goal")
requests = harness.responses.wait_for_requests(2)
assert {
"goal_status": persisted.status if persisted else None,
"follow_up": (follow_up.status, follow_up.final_response),
"request_count": len(requests),
"registered_goals": registered_goals,
"interrupter_errors": [str(error) for error in worker_errors],
} == {
"goal_status": ThreadGoalStatus.paused,
"follow_up": (TurnStatus.completed, "Sync follow-up complete."),
"request_count": 2,
"registered_goals": {},
"interrupter_errors": [],
}
def test_closing_goal_stream_releases_real_process_routing(tmp_path) -> None:
"""Closing a stream should release SDK routing without pausing the persisted goal."""
with AppServerHarness(tmp_path) as harness:
work_gate = SseGate()
harness.responses.enqueue_sse(
streaming_response(
"stream-close",
"msg-stream-close",
["long ", "running ", "goal"],
),
delay_between_events_s=0.5,
gate=work_gate,
)
with Codex(config=harness.app_server_config()) as codex:
try:
thread = codex.thread_start()
turn = thread.start_goal("Close this goal stream")
work_gate.wait_until_ready()
stream = turn.stream()
stream.close()
registered_goals = dict(codex._client._router._goal_operations)
persisted = codex._client.request(
"thread/goal/get",
{"threadId": thread.id},
response_model=ThreadGoalGetResponse,
).goal
finally:
work_gate.release.set()
assert {
"registered_goals": registered_goals,
"persisted_status": persisted.status if persisted else None,
} == {
"registered_goals": {},
"persisted_status": ThreadGoalStatus.active,
}
def test_app_server_exit_unblocks_goal_stream_and_releases_routing(tmp_path) -> None:
"""A real transport death should wake the logical reader and clean up routing."""
with AppServerHarness(tmp_path) as harness:
work_gate = SseGate()
harness.responses.enqueue_sse(
streaming_response(
"transport-exit",
"msg-transport-exit",
["long ", "running ", "goal"],
),
delay_between_events_s=0.5,
gate=work_gate,
)
with Codex(config=harness.app_server_config()) as codex:
try:
turn = codex.thread_start().start_goal("Stop the app-server during this goal")
work_gate.wait_until_ready()
process = codex._client._proc
assert process is not None
process.terminate()
process.wait(timeout=5)
finally:
work_gate.release.set()
with pytest.raises(TransportClosedError):
turn.run()
registered_goals = dict(codex._client._router._goal_operations)
assert registered_goals == {}
def test_failed_goal_starts_release_routing_without_model_requests(tmp_path) -> None:
"""Validation failures should leave the client and persisted thread usable."""
with AppServerHarness(tmp_path) as harness:
harness.responses.enqueue_assistant_message(
"Ordinary turn complete.",
response_id="validation-follow-up",
)
with Codex(config=harness.app_server_config()) as codex:
thread = codex.thread_start()
with pytest.raises(ValueError) as empty_error:
thread.start_goal(" ")
with pytest.raises(TypeError) as type_error:
thread.start_goal(123) # type: ignore[arg-type]
with pytest.raises(ValueError) as long_error:
thread.start_goal("x" * (_MAX_THREAD_GOAL_OBJECTIVE_CHARS + 1))
ephemeral = codex.thread_start(ephemeral=True)
with pytest.raises(InvalidRequestError) as ephemeral_error:
ephemeral.start_goal("Persist this goal")
follow_up = thread.run("Run after rejected goals")
requests = harness.responses.wait_for_requests(1)
registered_goals = dict(codex._client._router._goal_operations)
assert {
"errors": [
str(empty_error.value),
str(type_error.value),
str(long_error.value),
ephemeral_error.value.message,
],
"follow_up": (follow_up.status, follow_up.final_response),
"request_count": len(requests),
"registered_goals": registered_goals,
} == {
"errors": [
"goal objective must not be empty",
"goal objective must be a string",
"goal objective must be at most 4000 characters",
f"thread must be persisted before starting a goal: {ephemeral.id}",
],
"follow_up": (TurnStatus.completed, "Ordinary turn complete."),
"request_count": 1,
"registered_goals": {},
}
def test_disabled_goals_fail_before_model_work_or_routing(tmp_path) -> None:
"""A runtime with goals disabled should reject startup without leaking state."""
with AppServerHarness(tmp_path, enable_goals=False) as harness:
with Codex(config=harness.app_server_config()) as codex:
thread = codex.thread_start()
with pytest.raises(InvalidRequestError) as error:
thread.start_goal("This goal must not start")
registered_goals = dict(codex._client._router._goal_operations)
requests = harness.responses.requests()
assert {
"error": error.value.message,
"registered_goals": registered_goals,
"request_count": len(requests),
} == {
"error": "goals feature is disabled",
"registered_goals": {},
"request_count": 0,
}
def test_active_thread_rejects_goal_start_and_keeps_ordinary_turn_usable(tmp_path) -> None:
"""Goal startup should require an idle thread without disturbing active work."""
with AppServerHarness(tmp_path) as harness:
work_gate = SseGate()
harness.responses.enqueue_sse(
streaming_response(
"active-ordinary-turn",
"msg-active-ordinary-turn",
["ordinary ", "work"],
),
delay_between_events_s=0.5,
gate=work_gate,
)
with Codex(config=harness.app_server_config()) as codex:
try:
thread = codex.thread_start()
ordinary = thread.turn("Keep this ordinary turn active")
work_gate.wait_until_ready()
with pytest.raises(InvalidRequestError) as error:
thread.start_goal("Do not replace active work")
ordinary.interrupt()
finally:
work_gate.release.set()
result = ordinary.run()
registered_goals = dict(codex._client._router._goal_operations)
assert {
"error": error.value.message,
"ordinary_result": (result.id, result.status),
"registered_goals": registered_goals,
} == {
"error": f"thread must be idle before starting a goal: {thread.id}",
"ordinary_result": (ordinary.id, TurnStatus.interrupted),
"registered_goals": {},
}
def test_async_goal_run_cancellation_stops_work_and_releases_routing(tmp_path) -> None:
"""Task cancellation should pause and interrupt a running logical goal."""
async def scenario() -> None:
with AppServerHarness(tmp_path) as harness:
work_gate = SseGate()
harness.responses.enqueue_sse(
streaming_response(
"cancelled-async-run",
"msg-cancelled-async-run",
["cancelled ", "async ", "goal"],
),
delay_between_events_s=0.5,
gate=work_gate,
)
harness.responses.enqueue_assistant_message(
"Async run follow-up complete.",
response_id="cancelled-async-run-follow-up",
)
async with AsyncCodex(config=harness.app_server_config()) as codex:
try:
thread = await codex.thread_start()
turn = await thread.start_goal("Cancel this running async goal")
goal = turn._goal
assert goal is not None
goal_state = goal.state
marker = _queued_notification(goal_state)
running = asyncio.create_task(turn.run())
await asyncio.to_thread(work_gate.wait_until_ready)
await asyncio.to_thread(_wait_until_consumed, goal_state, marker)
running.cancel()
with pytest.raises(asyncio.CancelledError):
await running
finally:
work_gate.release.set()
deadline = time.monotonic() + 5
while True:
current = await thread.read()
if isinstance(current.thread.status.root, IdleThreadStatus):
break
if time.monotonic() >= deadline:
raise AssertionError("cancelled async goal turn did not stop")
await asyncio.sleep(0.01)
persisted = await codex._client.request(
"thread/goal/get",
{"threadId": thread.id},
response_model=ThreadGoalGetResponse,
)
registered_goals = dict(codex._client._sync._router._goal_operations)
follow_up = await thread.run("Continue after cancelling the async goal")
requests = await asyncio.to_thread(harness.responses.wait_for_requests, 2)
assert {
"goal_status": persisted.goal.status if persisted.goal else None,
"follow_up": (follow_up.status, follow_up.final_response),
"request_count": len(requests),
"registered_goals": registered_goals,
} == {
"goal_status": ThreadGoalStatus.paused,
"follow_up": (TurnStatus.completed, "Async run follow-up complete."),
"request_count": 2,
"registered_goals": {},
}
asyncio.run(scenario())
def test_async_goal_start_cancellation_interrupts_work_and_releases_routing(tmp_path) -> None:
"""Cancelling startup should pause and interrupt the physical goal turn."""
async def scenario() -> None:
with AppServerHarness(tmp_path) as harness:
work_gate = SseGate()
harness.responses.enqueue_sse(
streaming_response(
"cancelled-start",
"msg-cancelled-start",
["cancelled ", "goal ", "work"],
),
delay_between_events_s=0.5,
gate=work_gate,
)
harness.responses.enqueue_assistant_message(
"Async follow-up complete.",
response_id="cancelled-start-follow-up",
)
async with AsyncCodex(config=harness.app_server_config()) as codex:
try:
thread = await codex.thread_start()
startup = asyncio.create_task(
thread.start_goal("Cancel this goal during startup")
)
await asyncio.sleep(0)
work_gate.wait_until_ready()
startup.cancel()
with pytest.raises(asyncio.CancelledError):
await asyncio.wait_for(startup, timeout=1)
finally:
work_gate.release.set()
router = codex._client._sync._router
deadline = time.monotonic() + 5
while True:
current = await thread.read()
with router._lock:
registered_goals = dict(router._goal_operations)
if (
isinstance(current.thread.status.root, IdleThreadStatus)
and not registered_goals
):
break
if time.monotonic() >= deadline:
raise AssertionError("cancelled goal startup did not stop")
await asyncio.sleep(0.01)
persisted = await codex._client.request(
"thread/goal/get",
{"threadId": thread.id},
response_model=ThreadGoalGetResponse,
)
follow_up = await thread.run("Continue after cancelled goal startup")
requests = harness.responses.wait_for_requests(2)
assert {
"goal_status": persisted.goal.status if persisted.goal else None,
"follow_up": (follow_up.status, follow_up.final_response),
"request_count": len(requests),
"registered_goals": registered_goals,
"thread_status": current.thread.status.root,
} == {
"goal_status": ThreadGoalStatus.paused,
"follow_up": (TurnStatus.completed, "Async follow-up complete."),
"request_count": 2,
"registered_goals": {},
"thread_status": IdleThreadStatus(type="idle"),
}
asyncio.run(scenario())
@@ -0,0 +1,317 @@
import asyncio
import time
import pytest
from app_server_harness import (
AppServerHarness,
SseGate,
ev_completed_with_usage,
ev_function_call,
ev_response_created,
sse,
)
from app_server_helpers import agent_message_texts_from_items, streaming_response
from openai_codex import AsyncCodex, Codex
from openai_codex.generated.v2_all import (
ThreadGoalGetResponse,
ThreadGoalStatus,
TurnStatus,
)
def _enqueue_steerable_goal(
harness: AppServerHarness,
prefix: str,
*,
initial_text: str,
continuation_chunks: list[str],
final_text: str,
) -> SseGate:
continuation_gate = SseGate()
harness.responses.enqueue_assistant_message(
initial_text,
response_id=f"{prefix}-initial",
)
harness.responses.enqueue_sse(
streaming_response(
f"{prefix}-continuation",
f"msg-{prefix}-continuation",
continuation_chunks,
),
delay_between_events_s=0.15,
gate=continuation_gate,
)
harness.responses.enqueue_sse(
sse(
[
ev_response_created(f"{prefix}-complete-tool"),
ev_function_call(
f"call-{prefix}-complete",
"update_goal",
'{"status":"complete"}',
),
ev_completed_with_usage(
f"{prefix}-complete-tool",
input_tokens=1,
cached_input_tokens=0,
output_tokens=1,
reasoning_output_tokens=0,
total_tokens=2,
),
]
)
)
harness.responses.enqueue_assistant_message(
final_text,
response_id=f"{prefix}-final",
)
return continuation_gate
def _enqueue_interruptible_goal(
harness: AppServerHarness,
prefix: str,
*,
initial_text: str,
continuation_chunks: list[str],
follow_up_text: str,
) -> SseGate:
continuation_gate = SseGate()
harness.responses.enqueue_assistant_message(
initial_text,
response_id=f"{prefix}-initial",
)
harness.responses.enqueue_sse(
streaming_response(
f"{prefix}-continuation",
f"msg-{prefix}-continuation",
continuation_chunks,
),
delay_between_events_s=0.2,
gate=continuation_gate,
)
harness.responses.enqueue_assistant_message(
follow_up_text,
response_id=f"{prefix}-follow-up",
)
return continuation_gate
def _stale_routed_turn_id(turn) -> None:
goal = turn._goal
assert goal is not None
goal_state = goal.state
deadline = time.monotonic() + 5
with goal_state._condition:
while goal_state.current_turn_id in {None, turn.id}:
remaining = deadline - time.monotonic()
if remaining <= 0:
raise AssertionError("continuation turn was not routed")
goal_state._condition.wait(remaining)
goal_state.current_turn_id = turn.id
def test_goal_steer_targets_an_active_continuation(tmp_path) -> None:
"""Steering should reach the active server turn while returning the logical ID."""
with AppServerHarness(tmp_path) as harness:
continuation_gate = _enqueue_steerable_goal(
harness,
"steer",
initial_text="Initial work complete.",
continuation_chunks=["continuation ", "work"],
final_text="Steered goal complete.",
)
with Codex(config=harness.app_server_config()) as codex:
try:
turn = codex.thread_start().start_goal("Start a goal that needs refinement")
continuation_gate.wait_until_ready()
steer = turn.steer("Prioritize the edge-case coverage.")
finally:
continuation_gate.release.set()
result = turn.run()
requests = harness.responses.wait_for_requests(4)
assert {
"steer_id": steer.turn_id,
"result": (result.id, result.status, result.final_response),
"messages": agent_message_texts_from_items(result.items),
"steering_input": requests[2].message_input_texts("user")[-1:],
} == {
"steer_id": turn.id,
"result": (turn.id, TurnStatus.completed, "Steered goal complete."),
"messages": [
"Initial work complete.",
"continuation work",
"Steered goal complete.",
],
"steering_input": ["Prioritize the edge-case coverage."],
}
def test_goal_steer_retries_the_server_reported_rollover_turn(tmp_path) -> None:
"""Steering should recover when routed state trails the server continuation."""
with AppServerHarness(tmp_path) as harness:
continuation_gate = _enqueue_steerable_goal(
harness,
"steer-rollover",
initial_text="Initial rollover work complete.",
continuation_chunks=["rollover ", "work"],
final_text="Rollover steering complete.",
)
with Codex(config=harness.app_server_config()) as codex:
try:
turn = codex.thread_start().start_goal("Steer while routing catches up")
continuation_gate.wait_until_ready()
_stale_routed_turn_id(turn)
steer = turn.steer("Steer through the rollover window.")
finally:
continuation_gate.release.set()
result = turn.run()
requests = harness.responses.wait_for_requests(4)
assert {
"steer_id": steer.turn_id,
"result": (result.id, result.status, result.final_response),
"steering_input": requests[2].message_input_texts("user")[-1:],
} == {
"steer_id": turn.id,
"result": (turn.id, TurnStatus.completed, "Rollover steering complete."),
"steering_input": ["Steer through the rollover window."],
}
@pytest.mark.parametrize("stale_route", [False, True])
def test_goal_interrupts_active_and_stale_routed_continuations(tmp_path, stale_route) -> None:
"""Interruption should stop active work despite notification rollover lag."""
with AppServerHarness(tmp_path) as harness:
continuation_gate = _enqueue_interruptible_goal(
harness,
"interrupt",
initial_text="Initial work complete.",
continuation_chunks=["still ", "working"],
follow_up_text="Ordinary follow-up complete.",
)
with Codex(config=harness.app_server_config()) as codex:
try:
thread = codex.thread_start()
turn = thread.start_goal("Start interruptible goal work")
continuation_gate.wait_until_ready()
if stale_route:
_stale_routed_turn_id(turn)
interrupt = turn.interrupt()
finally:
continuation_gate.release.set()
interrupted = turn.run()
follow_up = thread.run("Continue with an ordinary turn")
requests = harness.responses.wait_for_requests(3)
persisted = codex._client.request(
"thread/goal/get",
{"threadId": thread.id},
response_model=ThreadGoalGetResponse,
).goal
assert {
"interrupt": interrupt.model_dump(by_alias=True, mode="json"),
"goal_status": persisted.status if persisted else None,
"interrupted": (interrupted.id, interrupted.status),
"follow_up": (follow_up.status, follow_up.final_response),
"request_count": len(requests),
} == {
"interrupt": {},
"goal_status": ThreadGoalStatus.paused,
"interrupted": (turn.id, TurnStatus.interrupted),
"follow_up": (TurnStatus.completed, "Ordinary follow-up complete."),
"request_count": 3,
}
def test_async_goal_steer_retries_the_server_reported_rollover_turn(tmp_path) -> None:
"""Async steering should recover when routed state trails the continuation."""
async def scenario() -> None:
with AppServerHarness(tmp_path) as harness:
continuation_gate = _enqueue_steerable_goal(
harness,
"async-steer",
initial_text="Async initial work complete.",
continuation_chunks=["async continuation ", "work"],
final_text="Async steered goal complete.",
)
async with AsyncCodex(config=harness.app_server_config()) as codex:
try:
thread = await codex.thread_start()
turn = await thread.start_goal("Start an async goal that needs refinement")
await asyncio.to_thread(continuation_gate.wait_until_ready)
await asyncio.to_thread(_stale_routed_turn_id, turn)
steer = await turn.steer("Prioritize async edge-case coverage.")
finally:
continuation_gate.release.set()
result = await turn.run()
requests = await asyncio.to_thread(harness.responses.wait_for_requests, 4)
assert {
"steer_id": steer.turn_id,
"result": (result.id, result.status, result.final_response),
"messages": agent_message_texts_from_items(result.items),
"steering_input": requests[2].message_input_texts("user")[-1:],
} == {
"steer_id": turn.id,
"result": (turn.id, TurnStatus.completed, "Async steered goal complete."),
"messages": [
"Async initial work complete.",
"async continuation work",
"Async steered goal complete.",
],
"steering_input": ["Prioritize async edge-case coverage."],
}
asyncio.run(scenario())
def test_async_goal_interrupt_retries_the_server_reported_rollover_turn(tmp_path) -> None:
"""Async interruption should survive notification lag during rollover."""
async def scenario() -> None:
with AppServerHarness(tmp_path) as harness:
continuation_gate = _enqueue_interruptible_goal(
harness,
"async-interrupt",
initial_text="Async initial work complete.",
continuation_chunks=["async still ", "working"],
follow_up_text="Async ordinary follow-up complete.",
)
async with AsyncCodex(config=harness.app_server_config()) as codex:
try:
thread = await codex.thread_start()
turn = await thread.start_goal("Start async interruptible goal work")
await asyncio.to_thread(continuation_gate.wait_until_ready)
await asyncio.to_thread(_stale_routed_turn_id, turn)
interrupt = await turn.interrupt()
finally:
continuation_gate.release.set()
interrupted = await turn.run()
follow_up = await thread.run("Continue with an async ordinary turn")
await asyncio.to_thread(harness.responses.wait_for_requests, 3)
requests = harness.responses.requests()
assert {
"interrupt": interrupt.model_dump(by_alias=True, mode="json"),
"interrupted": (interrupted.id, interrupted.status),
"follow_up": (follow_up.status, follow_up.final_response),
"request_count": len(requests),
"follow_up_input": requests[2].message_input_texts("user")[-1:],
} == {
"interrupt": {},
"interrupted": (turn.id, TurnStatus.interrupted),
"follow_up": (TurnStatus.completed, "Async ordinary follow-up complete."),
"request_count": 3,
"follow_up_input": ["Continue with an async ordinary turn"],
}
asyncio.run(scenario())
@@ -107,6 +107,7 @@ def test_sync_goal_run_aggregates_automatic_continuation(tmp_path) -> None:
thread = codex.thread_start()
result = thread.run_goal(" Improve benchmark coverage ")
requests = harness.responses.wait_for_requests(3)
registered_goals = dict(codex._client._router._goal_operations)
usage = result.usage.model_dump(by_alias=True, mode="json") if result.usage else None
assert {
@@ -124,6 +125,7 @@ def test_sync_goal_run_aggregates_automatic_continuation(tmp_path) -> None:
),
"continuation_has_objective": "<objective>\nImprove benchmark coverage\n</objective>"
in _continuation_text(requests[0]),
"registered_goals": registered_goals,
} == {
"id_is_present": True,
"status": TurnStatus.completed,
@@ -148,6 +150,7 @@ def test_sync_goal_run_aggregates_automatic_continuation(tmp_path) -> None:
},
"timing": (True, True, True),
"continuation_has_objective": True,
"registered_goals": {},
}