[codex] Split Python SDK helper logic (#22939)

## Summary
- Move approval-mode mapping into
`sdk/python/src/openai_codex/_approval_mode.py`.
- Move initialize metadata parsing and normalization into
`sdk/python/src/openai_codex/_initialize_metadata.py`.
- Keep the public `ApprovalMode` export stable and retarget direct
metadata helper coverage.

## Integration coverage
- Add an app-server harness smoke that exercises sync and async SDK
initialization plus thread creation.

## Validation
- Local tests were not run per repo guidance. CI should validate this
branch once the PR is online.

sdk/python/src/openai_codex/api.py

@@ -2,9 +2,14 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from enum import Enum
-from typing import AsyncIterator, Iterator, NoReturn
+from typing import AsyncIterator, Iterator
 
+from ._approval_mode import (
+    ApprovalMode as ApprovalMode,
+    _approval_mode_override_settings,
+    _approval_mode_settings,
+)
+from ._initialize_metadata import validate_initialize_metadata
 from ._inputs import (
     ImageInput as ImageInput,
     Input,
@@ -25,9 +30,6 @@ from ._run import (
 from .async_client import AsyncAppServerClient
 from .client import AppServerClient, AppServerConfig
 from .generated.v2_all import (
-    ApprovalsReviewer,
-    AskForApproval,
-    AskForApprovalValue,
     ModelListResponse,
     Personality,
     ReasoningEffort,
@@ -55,61 +57,7 @@ from .generated.v2_all import (
     TurnStartParams,
     TurnSteerResponse,
 )
-from .models import InitializeResponse, JsonObject, Notification, ServerInfo
-
-
-def _split_user_agent(user_agent: str) -> tuple[str | None, str | None]:
-    raw = user_agent.strip()
-    if not raw:
-        return None, None
-    if "/" in raw:
-        name, version = raw.split("/", 1)
-        return (name or None), (version or None)
-    parts = raw.split(maxsplit=1)
-    if len(parts) == 2:
-        return parts[0], parts[1]
-    return raw, None
-
-
-class ApprovalMode(str, Enum):
-    """High-level approval behavior for escalated permission requests."""
-
-    deny_all = "deny_all"
-    auto_review = "auto_review"
-
-
-def _approval_mode_settings(
-    approval_mode: ApprovalMode,
-) -> tuple[AskForApproval, ApprovalsReviewer | None]:
-    """Map the public approval mode to generated app-server start params."""
-    if not isinstance(approval_mode, ApprovalMode):
-        supported = ", ".join(mode.value for mode in ApprovalMode)
-        raise ValueError(f"approval_mode must be one of: {supported}")
-
-    match approval_mode:
-        case ApprovalMode.auto_review:
-            return (
-                AskForApproval(root=AskForApprovalValue.on_request),
-                ApprovalsReviewer.auto_review,
-            )
-        case ApprovalMode.deny_all:
-            return AskForApproval(root=AskForApprovalValue.never), None
-        case _:
-            return _assert_never_approval_mode(approval_mode)
-
-
-def _assert_never_approval_mode(approval_mode: NoReturn) -> NoReturn:
-    """Make approval mode mapping exhaustive for static type checkers."""
-    raise AssertionError(f"Unhandled approval mode: {approval_mode!r}")
-
-
-def _approval_mode_override_settings(
-    approval_mode: ApprovalMode | None,
-) -> tuple[AskForApproval | None, ApprovalsReviewer | None]:
-    """Map an optional public approval mode to app-server override params."""
-    if approval_mode is None:
-        return None, None
-    return _approval_mode_settings(approval_mode)
+from .models import InitializeResponse, JsonObject, Notification
 
 
 class Codex:
@@ -119,7 +67,7 @@ class Codex:
         self._client = AppServerClient(config=config)
         try:
             self._client.start()
-            self._init = self._validate_initialize(self._client.initialize())
+            self._init = validate_initialize_metadata(self._client.initialize())
         except Exception:
             self._client.close()
             raise
@@ -130,44 +78,6 @@ class Codex:
     def __exit__(self, _exc_type, _exc, _tb) -> None:
         self.close()
 
-    @staticmethod
-    def _validate_initialize(payload: InitializeResponse) -> InitializeResponse:
-        user_agent = (payload.userAgent or "").strip()
-        server = payload.serverInfo
-
-        server_name: str | None = None
-        server_version: str | None = None
-
-        if server is not None:
-            server_name = (server.name or "").strip() or None
-            server_version = (server.version or "").strip() or None
-
-        if (server_name is None or server_version is None) and user_agent:
-            parsed_name, parsed_version = _split_user_agent(user_agent)
-            if server_name is None:
-                server_name = parsed_name
-            if server_version is None:
-                server_version = parsed_version
-
-        normalized_server_name = (server_name or "").strip()
-        normalized_server_version = (server_version or "").strip()
-        if not user_agent or not normalized_server_name or not normalized_server_version:
-            raise RuntimeError(
-                "initialize response missing required metadata "
-                f"(user_agent={user_agent!r}, server_name={normalized_server_name!r}, server_version={normalized_server_version!r})"
-            )
-
-        if server is None:
-            payload.serverInfo = ServerInfo(
-                name=normalized_server_name,
-                version=normalized_server_version,
-            )
-        else:
-            server.name = normalized_server_name
-            server.version = normalized_server_version
-
-        return payload
-
     @property
     def metadata(self) -> InitializeResponse:
         return self._init
@@ -354,7 +264,7 @@ class AsyncCodex:
             try:
                 await self._client.start()
                 payload = await self._client.initialize()
-                self._init = Codex._validate_initialize(payload)
+                self._init = validate_initialize_metadata(payload)
                 self._initialized = True
             except Exception:
                 await self._client.close()