[7/8] Add Python SDK app-server integration harness (#22014)

## Why

The SDK had behavioral tests that replaced SDK client internals. Those
tests could catch wrapper mistakes, but they did not prove the pinned
app-server runtime, generated notification models, request routing, and
sync/async public clients worked together.

This PR adds deterministic integration coverage that starts the pinned
`codex app-server` process and mocks only the upstream Responses HTTP
boundary.

## What

- Add `AppServerHarness` and `MockResponsesServer` helpers for isolated
`CODEX_HOME`, mock-provider config, queued SSE responses, and captured
`/v1/responses` requests.
- Add shared helpers for SSE construction, stream assertions,
approval-policy inspection, and image fixtures.
- Split integration coverage into focused modules for run behavior,
inputs, streaming, turn controls, approvals, and thread lifecycle.
- Cover sync and async `Thread.run`, `TurnHandle.stream`, interleaved
streams, approval-mode persistence, lifecycle helpers, final-answer
phase handling, image inputs, loaded skill input injection, steering,
interruption, listing, history reads, run overrides, and token usage
mapping.
- Replace public-wrapper tests that duplicated integration-test behavior
with lower-level client tests only where direct client behavior is the
thing under test.

## Stack

1. #21891 `[1/8]` Pin Python SDK runtime dependency
2. #21893 `[2/8]` Generate Python SDK types from pinned runtime
3. #21895 `[3/8]` Run Python SDK tests in CI
4. #21896 `[4/8]` Define Python SDK public API surface
5. #21905 `[5/8]` Rename Python SDK package to `openai-codex`
6. #21910 `[6/8]` Add high-level Python SDK approval mode
7. This PR `[7/8]` Add Python SDK app-server integration harness
8. #22021 `[8/8]` Add Python SDK Ruff formatting

## Verification

- Added pinned app-server integration tests under
`sdk/python/tests/test_app_server_*.py` and
`test_real_app_server_integration.py`.

---------

Co-authored-by: Codex <noreply@openai.com>

sdk/python/tests/app_server_helpers.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterable, Iterator
+from typing import Any
+
+from app_server_harness import (
+    ev_assistant_message,
+    ev_completed,
+    ev_message_item_added,
+    ev_output_text_delta,
+    ev_response_created,
+    sse,
+)
+from openai_codex.generated.v2_all import (
+    AgentMessageDeltaNotification,
+    ItemCompletedNotification,
+    MessagePhase,
+)
+from openai_codex.models import Notification
+
+TINY_PNG_BYTES = bytes(
+    [
+        137,
+        80,
+        78,
+        71,
+        13,
+        10,
+        26,
+        10,
+        0,
+        0,
+        0,
+        13,
+        73,
+        72,
+        68,
+        82,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        1,
+        8,
+        6,
+        0,
+        0,
+        0,
+        31,
+        21,
+        196,
+        137,
+        0,
+        0,
+        0,
+        11,
+        73,
+        68,
+        65,
+        84,
+        120,
+        156,
+        99,
+        96,
+        0,
+        2,
+        0,
+        0,
+        5,
+        0,
+        1,
+        122,
+        94,
+        171,
+        63,
+        0,
+        0,
+        0,
+        0,
+        73,
+        69,
+        78,
+        68,
+        174,
+        66,
+        96,
+        130,
+    ]
+)
+
+
+def response_approval_policy(response: Any) -> str:
+    """Return serialized approvalPolicy from a generated thread response."""
+    return response.model_dump(by_alias=True, mode="json")["approvalPolicy"]
+
+
+def agent_message_texts(events: list[Notification]) -> list[str]:
+    """Extract completed agent-message text from SDK notifications."""
+    texts: list[str] = []
+    for event in events:
+        if not isinstance(event.payload, ItemCompletedNotification):
+            continue
+        item = event.payload.item.root
+        if item.type == "agentMessage":
+            texts.append(item.text)
+    return texts
+
+
+def agent_message_texts_from_items(items: Iterable[Any]) -> list[str]:
+    """Extract agent-message text from completed run result items."""
+    texts: list[str] = []
+    for item in items:
+        root = item.root
+        if root.type == "agentMessage":
+            texts.append(root.text)
+    return texts
+
+
+def next_sync_delta(stream: Iterator[Notification]) -> str:
+    """Advance a sync turn stream until the next agent-message text delta."""
+    for event in stream:
+        if isinstance(event.payload, AgentMessageDeltaNotification):
+            return event.payload.delta
+    raise AssertionError("stream completed before an agent-message delta")
+
+
+async def next_async_delta(stream: AsyncIterator[Notification]) -> str:
+    """Advance an async turn stream until the next agent-message text delta."""
+    async for event in stream:
+        if isinstance(event.payload, AgentMessageDeltaNotification):
+            return event.payload.delta
+    raise AssertionError("stream completed before an agent-message delta")
+
+
+def streaming_response(response_id: str, item_id: str, parts: list[str]) -> str:
+    """Build an SSE stream with text deltas and a final assistant message."""
+    return sse(
+        [
+            ev_response_created(response_id),
+            ev_message_item_added(item_id),
+            *[ev_output_text_delta(part) for part in parts],
+            ev_assistant_message(item_id, "".join(parts)),
+            ev_completed(response_id),
+        ]
+    )
+
+
+def assistant_message_with_phase(
+    item_id: str,
+    text: str,
+    phase: MessagePhase,
+) -> dict[str, Any]:
+    """Build an assistant message event carrying app-server phase metadata."""
+    event = ev_assistant_message(item_id, text)
+    event["item"] = {**event["item"], "phase": phase.value}
+    return event
+
+
+def request_kind(request_path: str) -> str:
+    """Classify captured mock-server request paths for compact assertions."""
+    if request_path.endswith("/responses/compact"):
+        return "compact"
+    if request_path.endswith("/responses"):
+        return "responses"
+    return request_path