Publish Python SDK with Codex-pinned versioning (#18996)

**note**: a large chunk of this diff comes from regenerating Python
types after app-server schema changes on `main`.

This is PR 3 of 3 for the Python SDK PyPI publishing split. PR #18862
refreshed the generated SDK surface, and PR #18865 made the runtime
package publishable as `openai-codex-cli-bin`; this final PR makes the
SDK package publishable as `openai-codex-app-server-sdk` and pins both
packages to the same Codex runtime version.

The key idea is that the published SDK version is the Codex runtime
version. That one version now drives the SDK package version, the exact
runtime dependency, the client version reported by the SDK, and the
bootstrap runtime pin. This keeps release-time versioning in one lane
instead of scattering checked-in literals through the package.

## What changed

- Rename the SDK distribution from `codex-app-server-sdk` to
`openai-codex-app-server-sdk` for conflict-free PyPI publishing.
- Use `stage-sdk --codex-version ...` with one Codex version for both
the SDK package version and exact `openai-codex-cli-bin` dependency.
- Preserve hidden legacy `--runtime-version` / `--sdk-version` args only
to reject mismatched versions during staging.
- Map PEP 440 package versions back to Codex release tags for runtime
setup downloads, e.g. `0.116.0a1` -> `rust-v0.116.0-alpha.1`.
- Derive `codex_app_server.__version__`, the default
`AppServerConfig.client_version`, and
`_runtime_setup.pinned_runtime_version()` from the SDK package/project
version instead of hardcoding duplicate version strings.
- Carry the current generated SDK refresh from `main` so
`generate-types` stays clean after recent app-server schema changes.
- Update `sdk/python/uv.lock` for the renamed editable package.

## Validation

- `uv run --extra dev pytest` in `sdk/python` -> 59 passed, 37 skipped.
- Targeted `uv run ruff check` for the touched SDK files.
- `git diff --check`.
- Staged runtime with `--codex-version rust-v0.116.0-alpha.1
--platform-tag macosx_11_0_arm64`.
- Staged SDK with `--codex-version rust-v0.116.0-alpha.1`.
- Built runtime wheel, SDK wheel, and SDK sdist.
- `twine check /tmp/codex-python-pr3-build/dist/*` -> passed.
- Clean venv smoke installed `openai-codex-app-server-sdk==0.116.0a1`
from local dist and pulled `openai-codex-cli-bin==0.116.0a1`.
- Smoke imports passed for `Codex` and `bundled_codex_path()`.

sdk/python/scripts/update_sdk_artifacts.py

@@ -17,6 +17,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Sequence, get_args, get_origin
 
+SDK_DISTRIBUTION_NAME = "openai-codex-app-server-sdk"
 RUNTIME_DISTRIBUTION_NAME = "openai-codex-cli-bin"
 
 
@@ -178,15 +179,19 @@ def _rewrite_sdk_runtime_dependency(pyproject_text: str, runtime_version: str) -
         )
 
     raw_items = [item.strip() for item in match.group(1).split(",") if item.strip()]
-    raw_items = [item for item in raw_items if "codex-cli-bin" not in item]
+    raw_items = [
+        item
+        for item in raw_items
+        if RUNTIME_DISTRIBUTION_NAME.removeprefix("openai-") not in item
+        and RUNTIME_DISTRIBUTION_NAME not in item
+    ]
     raw_items.append(f'"{RUNTIME_DISTRIBUTION_NAME}=={runtime_version}"')
     replacement = "dependencies = [\n  " + ",\n  ".join(raw_items) + ",\n]"
     return pyproject_text[: match.start()] + replacement + pyproject_text[match.end() :]
 
 
-def stage_python_sdk_package(
-    staging_dir: Path, sdk_version: str, runtime_version: str
-) -> Path:
+def stage_python_sdk_package(staging_dir: Path, codex_version: str) -> Path:
+    package_version = normalize_codex_version(codex_version)
     _copy_package_tree(sdk_root(), staging_dir)
     sdk_bin_dir = staging_dir / "src" / "codex_app_server" / "bin"
     if sdk_bin_dir.exists():
@@ -194,8 +199,9 @@ def stage_python_sdk_package(
 
     pyproject_path = staging_dir / "pyproject.toml"
     pyproject_text = pyproject_path.read_text()
-    pyproject_text = _rewrite_project_version(pyproject_text, sdk_version)
-    pyproject_text = _rewrite_sdk_runtime_dependency(pyproject_text, runtime_version)
+    pyproject_text = _rewrite_project_name(pyproject_text, SDK_DISTRIBUTION_NAME)
+    pyproject_text = _rewrite_project_version(pyproject_text, package_version)
+    pyproject_text = _rewrite_sdk_runtime_dependency(pyproject_text, package_version)
     pyproject_path.write_text(pyproject_text)
     return staging_dir
 
@@ -625,7 +631,7 @@ class PublicFieldSpec:
 @dataclass(frozen=True)
 class CliOps:
     generate_types: Callable[[], None]
-    stage_python_sdk_package: Callable[[Path, str, str], Path]
+    stage_python_sdk_package: Callable[[Path, str], Path]
     stage_python_runtime_package: Callable[[Path, str, Path, str | None], Path]
     current_sdk_version: Callable[[], str]
 
@@ -992,14 +998,21 @@ def build_parser() -> argparse.ArgumentParser:
         type=Path,
         help="Output directory for the staged SDK package",
     )
+    stage_sdk_parser.add_argument(
+        "--codex-version",
+        help=(
+            "Codex release version to write into the staged SDK package and exact "
+            f"{RUNTIME_DISTRIBUTION_NAME} dependency. Accepts PEP 440 versions "
+            "or release tags such as rust-v0.116.0-alpha.1."
+        ),
+    )
     stage_sdk_parser.add_argument(
         "--runtime-version",
-        required=True,
-        help="Pinned openai-codex-cli-bin version for the staged SDK package",
+        help=argparse.SUPPRESS,
     )
     stage_sdk_parser.add_argument(
         "--sdk-version",
-        help="Version to write into the staged SDK package (defaults to sdk/python current version)",
+        help=argparse.SUPPRESS,
     )
 
     stage_runtime_parser = subparsers.add_parser(
@@ -1050,22 +1063,23 @@ def default_cli_ops() -> CliOps:
     )
 
 
-def _resolve_runtime_version(args: argparse.Namespace) -> str:
+def _resolve_codex_version(args: argparse.Namespace) -> str:
     versions = [
         value
         for value in (
             getattr(args, "codex_version", None),
             getattr(args, "runtime_version", None),
+            getattr(args, "sdk_version", None),
         )
         if value is not None
     ]
     if not versions:
-        raise RuntimeError("Pass --codex-version to stage the Python runtime package")
+        raise RuntimeError("Pass --codex-version to stage Python release artifacts")
 
     normalized_versions = [normalize_codex_version(version) for version in versions]
     if len(set(normalized_versions)) != 1:
         raise RuntimeError(
-            "Runtime package versions must match; pass one --codex-version"
+            "SDK and runtime package versions must match; pass one --codex-version"
         )
     return normalized_versions[0]
 
@@ -1074,17 +1088,17 @@ def run_command(args: argparse.Namespace, ops: CliOps) -> None:
     if args.command == "generate-types":
         ops.generate_types()
     elif args.command == "stage-sdk":
+        codex_version = _resolve_codex_version(args)
         ops.generate_types()
         ops.stage_python_sdk_package(
             args.staging_dir,
-            args.sdk_version or ops.current_sdk_version(),
-            args.runtime_version,
+            codex_version,
         )
     elif args.command == "stage-runtime":
-        runtime_version = _resolve_runtime_version(args)
+        codex_version = _resolve_codex_version(args)
         ops.stage_python_runtime_package(
             args.staging_dir,
-            runtime_version,
+            codex_version,
             args.runtime_binary.resolve(),
             args.platform_tag,
         )