python-codex 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

pycodex/cli.py

@@ -21,7 +21,6 @@ from .protocol import AgentEvent
 from .runtime import AgentRuntime
 from .runtime_services import RuntimeEnvironment, create_runtime_environment
 from .utils import CliSessionView, load_codex_dotenv
-from responses_server import launch_chat_completion_compat_server
 
 EXIT_COMMANDS = {"/exit", "/quit"}
 HISTORY_COMMAND = "/history"
@@ -33,6 +32,14 @@ LOCAL_RESPONSES_SERVER_API_KEY_ENV = "PYCODEX_LOCAL_RESPONSES_SERVER_KEY"
 CLI_ORIGINATOR = "codex-tui"
 
 
+def launch_chat_completion_compat_server(*args, **kwargs):
+    from responses_server import (
+        launch_chat_completion_compat_server as launch_compat_server,
+    )
+
+    return launch_compat_server(*args, **kwargs)
+
+
 def configure_loguru() -> None:
     try:
         from loguru import logger

pycodex/runtime_services.py

@@ -346,6 +346,9 @@ class SubAgentManager:
             managed.state = "completed"
         finally:
             managed.pending_submission_ids.discard(submission_id)
+            if managed.pending_submission_ids and managed.error_message is None:
+                managed.completed_message = None
+                managed.state = "running"
             async with self._condition:
                 self._condition.notify_all()
 

pycodex/tools/exec_tool.py

@@ -17,7 +17,7 @@ from ..protocol import JSONValue
 from .base_tool import BaseTool, ToolContext
 from .code_mode_manager import CodeModeManager
 
-EXEC_FREEFORM_GRAMMAR = """start: pragma_source | plain_source
+EXEC_FREEFORM_GRAMMAR = r"""start: pragma_source | plain_source
 pragma_source: PRAGMA_LINE NEWLINE SOURCE
 plain_source: SOURCE
 

pycodex/tools/unified_exec_manager.py

@@ -184,6 +184,9 @@ class _HeadTailBuffer:
         self.tail.clear()
         return combined
 
+    def has_data(self) -> bool:
+        return bool(self.head or self.tail)
+
 
 @dataclass(slots=True)
 class UnifiedExecSession:
@@ -194,6 +197,7 @@ class UnifiedExecSession:
     tty: bool
     unread_output: _HeadTailBuffer = field(default_factory=_HeadTailBuffer)
     reader_task: asyncio.Task | None = None
+    output_event: asyncio.Event = field(default_factory=asyncio.Event)
 
 
 class UnifiedExecManager:
@@ -294,11 +298,22 @@ class UnifiedExecManager:
         if session is None:
             return f"Error: session_id {session_id} is not running."
 
-        start_wait = asyncio.get_running_loop().time()
+        loop = asyncio.get_running_loop()
+        start_wait = loop.time()
         try:
             await asyncio.wait_for(session.process.wait(), timeout=yield_time_ms / 1000.0)
         except asyncio.TimeoutError:
-            pass
+            remaining_seconds = (yield_time_ms / 1000.0) - (loop.time() - start_wait)
+            if (
+                session.process.returncode is None
+                and not session.unread_output.has_data()
+                and remaining_seconds > 0
+            ):
+                session.output_event.clear()
+                try:
+                    await asyncio.wait_for(session.output_event.wait(), timeout=remaining_seconds)
+                except asyncio.TimeoutError:
+                    pass
 
         if session.reader_task is not None and session.process.returncode is not None:
             await session.reader_task
@@ -345,6 +360,8 @@ class UnifiedExecManager:
             if not chunk:
                 break
             session.unread_output.push_chunk(chunk)
+            session.output_event.set()
+        session.output_event.set()
 
     def _resolve_workdir(self, workdir: str | None) -> Path:
         if not workdir:

pycodex/utils/get_env.py

@@ -83,10 +83,15 @@ def get_package_version() -> str:
     detected = _detect_upstream_codex_version()
     if detected is not None:
         return detected
-    try:
-        return importlib.metadata.version("pycodex")
-    except importlib.metadata.PackageNotFoundError:
-        return "0.1.0"
+    for distribution_name in ("python-codex", "pycodex"):
+        try:
+            return importlib.metadata.version(distribution_name)
+        except importlib.metadata.PackageNotFoundError:
+            continue
+    local_version = _read_local_package_version()
+    if local_version is not None:
+        return local_version
+    return "0.1.0"
 
 
 def get_os_info() -> tuple[str, str]:
@@ -178,6 +183,20 @@ def _normalize_os_version(version: str) -> str:
     return version
 
 
+def _read_local_package_version() -> str | None:
+    pyproject_path = Path(__file__).resolve().parents[2] / "pyproject.toml"
+    if not pyproject_path.is_file():
+        return None
+    match = re.search(
+        r'^\s*version\s*=\s*"([^"]+)"\s*$',
+        pyproject_path.read_text(encoding="utf-8"),
+        flags=re.MULTILINE,
+    )
+    if match is None:
+        return None
+    return match.group(1).strip() or None
+
+
 def _tmux_display_message(fmt: str) -> str | None:
     try:
         output = subprocess.run(

{python_codex-0.1.1.dist-info → python_codex-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-codex
-Version: 0.1.1
+Version: 0.1.2
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
 Requires-Python: >=3.10

{python_codex-0.1.1.dist-info → python_codex-0.1.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pycodex/__init__.py,sha256=T11JU1QHEk81TchhrTAOqVkvUUiQGlesk9PNaivjPrU,3052
 pycodex/agent.py,sha256=ApIneWSqDxryf9hdmTRFL65AH4e-sn0MWuuR80951Ec,10069
-pycodex/cli.py,sha256=JKHedrIgFaQgAc9h3P1MHvJTvUjL5dv7gxgHh-LCsDs,24520
+pycodex/cli.py,sha256=ju4aF_kwbraqZ-NfoymzB6CjvvMX22afeXDvse2ykf8,24676
 pycodex/collaboration.py,sha256=XAM2enljzHMjzZVlLxbOQF0JhWgKW4qaaDfVcUdE47g,632
 pycodex/context.py,sha256=8-Eg1TE4-GVbEfW0fNZjDWhjLypK3jBlKZY1haYYVPY,23143
 pycodex/doctor.py,sha256=VN-qetM2qJCNRNTZXBMe44VSrEOu8kUXE01luLMF050,10357
@@ -9,7 +9,7 @@ pycodex/portable.py,sha256=Y2pY08pDiWITY0QYgH3F9YKpOe2EYtxE0qqSmrCkp_g,15260
 pycodex/portable_server.py,sha256=xhEwySCJ41WnsowXM-Db6kkmCOVM02Lmd4pbN6hZzh0,7232
 pycodex/protocol.py,sha256=8mQ7I-y9bxYueSr7d_yGj2Tw69t47OCgwvmxhwihdFw,10807
 pycodex/runtime.py,sha256=tfEuyZmnTP625BQ0NMm-AGhjfQpXcv2EaZLtCJTnEmM,7757
-pycodex/runtime_services.py,sha256=IIpv96YuxdWX2D1yu-HmtCx3Og-fYDPrA29vgAlyvJE,12331
+pycodex/runtime_services.py,sha256=hmdwFiOZ1DPEJ5T8vfDSLfujgGQBPrzPQkn6uX_9vZ8,12503
 pycodex/prompts/collaboration_default.md,sha256=MBTmPuMubeWfZgIeFVj49wwnwD4n_o3fVYAbgWKwu6Q,955
 pycodex/prompts/collaboration_plan.md,sha256=IzjQAA5oHJz-3FmJdOjsJ4LHq6LW1tlEYMoy09n0HKk,8777
 pycodex/prompts/default_base_instructions.md,sha256=D65mcj6bo4CDvVom-D9cbJRJVNquo0NghKt164_fRsg,20923
@@ -32,7 +32,7 @@ pycodex/tools/close_agent_tool.py,sha256=InKhe2gFWOcqE187J3XYrCckecsyAR48VeVmGdY
 pycodex/tools/code_mode_manager.py,sha256=pEczPyCq-3DpJlTtfUEpl4JAGolz8cOpI8mBc7gdrn0,18603
 pycodex/tools/exec_command_tool.py,sha256=_fWfkQLGeINb2-cniY9CWskkAPjC9hE8pfjcBKkWXAg,3459
 pycodex/tools/exec_runtime.js,sha256=ZczdhrzpSZ-qNnJDDJOe8Ap86HpzHb2FZ_vSpHszgLs,3625
-pycodex/tools/exec_tool.py,sha256=b3_HSlyA0qB9rJulSckLBXOcKS3Lw5xvsQXU-wpNpCs,1414
+pycodex/tools/exec_tool.py,sha256=xJfEpcQXpL3OX-ZzKxQ2sI781OuEqpeyPvVkkwhgZ1c,1415
 pycodex/tools/grep_files_tool.py,sha256=twsx1KsvOWh8mi-lbycAtEyh6PeLxtNzl9LzdjwgAf4,4742
 pycodex/tools/list_dir_tool.py,sha256=7S0RsE-NL04G47FmFZtzo-N-O3fPCYQFF0HrjEVuv3U,4749
 pycodex/tools/read_file_tool.py,sha256=GVamhSNEZ1F1IU_og9GgSCzV12TL5t5b1fOUlzTOQBQ,8084
@@ -43,7 +43,7 @@ pycodex/tools/send_input_tool.py,sha256=z9PR5VoFd9SF4A-ol04Op8AXQF_3YLE74C6coiTX
 pycodex/tools/shell_command_tool.py,sha256=Bbah_5HirG1BJOIiqzuMa8kNHNYVPCUvxCFa09eRU6A,3500
 pycodex/tools/shell_tool.py,sha256=BWSaEJZwfQg9Ta-ld2wqeXqavrZC7Y8qgF_vBEOxfYA,3678
 pycodex/tools/spawn_agent_tool.py,sha256=LfJlGI0Ecp9HWNLlTubyybFq-xeRNChILq9ozT7piA8,3556
-pycodex/tools/unified_exec_manager.py,sha256=dyuGfaljXTuV4_Bf5Y6OwFGj5_Kb1LW-sh9ni5mMF1Y,12602
+pycodex/tools/unified_exec_manager.py,sha256=ZEaMXmO83Iu20V4dwxAuUjy4EF5IHqHmwnTvFJh8zGc,13330
 pycodex/tools/update_plan_tool.py,sha256=l_EG39bEw5K9BIUKoSUsXYDb0W7aLn8SviKSb-bs7Os,2887
 pycodex/tools/view_image_tool.py,sha256=yB915Jd3he4RjPANdm-dYdvio24OXKhBkAsp-9WVPBg,3924
 pycodex/tools/wait_agent_tool.py,sha256=1tJ5spBtpZ_MjoMv5xmZz5WWKl7UwMqHIJ3SYKXEPZw,2596
@@ -52,11 +52,22 @@ pycodex/tools/web_search_tool.py,sha256=hq78XF6MRvmNyPFSIp5eI0eYn9ryKdKvvoIOFNU3
 pycodex/tools/write_stdin_tool.py,sha256=DghlwPJnAqDoRBYyh1zeXRsfTXoQUdLJ8JQfrdE4RLs,2542
 pycodex/utils/__init__.py,sha256=Hj_0a7RhkAblWkaHyFhpi0cs2nSjJ1NdavbkBgEHieY,1024
 pycodex/utils/dotenv.py,sha256=sOpu6PA1VrsPZK13ynh3nZg3-u9pdiCXkW648v3pwZQ,1789
-pycodex/utils/get_env.py,sha256=3l_KA8JCWW9mrKE9FiV2mTx10-e5MUbxaU8jbn3JaRs,6265
+pycodex/utils/get_env.py,sha256=Ehh0mVPhkDlPMd1WXhrz1UqjPCePg8YfZH7zrtu1EOQ,6894
 pycodex/utils/random_ids.py,sha256=vOEVgkwKeQXaHoEVU7IfsPPjKUABkGIeQ7lu9MZctU8,413
 pycodex/utils/visualize.py,sha256=fK79pTfOwMmRrQujAosGt0nGyyJjpz0GfpWY8BkK91c,35369
-python_codex-0.1.1.dist-info/METADATA,sha256=3w9Sv_prpkT9BQ7zYh4NUCDV3eVlcoaq2Pv6yAkacOc,13969
-python_codex-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_codex-0.1.1.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
-python_codex-0.1.1.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
-python_codex-0.1.1.dist-info/RECORD,,
+responses_server/__init__.py,sha256=3yPv_zeGT7P11tTnmj5kXktISLNsNW-02MUnnbiZcb0,394
+responses_server/__main__.py,sha256=9SRp-Yw7ShGxc6DhSIXcDLKgGEdAVm3oBZ59rBOPjT0,62
+responses_server/app.py,sha256=VJSceVaXxbPLu9KGafLIt5fiGvxrqVTkWeOg81O5-FQ,7016
+responses_server/config.py,sha256=XAJmvvLiCYN5jCUcP_6uZyoW79OzxigMbik8X-ZTdKE,2174
+responses_server/payload_processors.py,sha256=_3Sl7HLG00BgN_TKcvT3_3drCDAq1MAeK1HxbRXNta4,3019
+responses_server/server.py,sha256=Q-gjtHzb7K1Guex10G38PgH9hxqJgdzYnBV7Ycy9L7Y,2049
+responses_server/session_store.py,sha256=oP3aFHsGmEMoXuUcxNh6B4vzp6KwaeRdLzM-3AOwM98,1078
+responses_server/stream_router.py,sha256=uYPjrlBUnNqiuQQ91eKmwDfNF6e5NYDtf5C8BdPRPRc,29536
+responses_server/tools/__init__.py,sha256=ivsBSEy0SBUhY-Uea5v1XMLXShkwHdCVl0id-1FwdZg,150
+responses_server/tools/custom_adapter.py,sha256=ivROeI8D9B1saS7skGLXnwF7fbsjAmEVSbeMceYno4E,8238
+responses_server/tools/web_search.py,sha256=HR9E5uMxWU07khsaIO9zvdg1GCCrWNy73263zfMaxsw,8565
+python_codex-0.1.2.dist-info/METADATA,sha256=wy8bEToZxyf9Cio-upoAS8XmC3MscN8wiKTVXp9MW9g,13969
+python_codex-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_codex-0.1.2.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
+python_codex-0.1.2.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
+python_codex-0.1.2.dist-info/RECORD,,

responses_server/__init__.py

@@ -0,0 +1,17 @@
+from .app import (
+    ManagedResponseServer,
+    launch_chat_completion_compat_server,
+    run_server,
+)
+from .config import CompatServerConfig
+from .server import ResponseServer
+from .stream_router import StreamRouter
+
+__all__ = [
+    "CompatServerConfig",
+    "ManagedResponseServer",
+    "ResponseServer",
+    "launch_chat_completion_compat_server",
+    "run_server",
+    "StreamRouter",
+]

responses_server/__main__.py

@@ -0,0 +1,5 @@
+from .app import main
+
+
+if __name__ == "__main__":
+    main()

responses_server/app.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import replace
+import json
+import socket
+import threading
+import time
+from typing import Iterator
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+import uvicorn
+
+from .config import CompatServerConfig
+from .server import ResponseServer
+from .stream_router import OutcommingChatError, UnsupportedIncommingFeature
+
+
+def _format_sse_event(event_name: str, payload: dict[str, object]) -> bytes:
+    data = json.dumps(payload, ensure_ascii=False)
+    return f"event: {event_name}\ndata: {data}\n\n".encode("utf-8")
+
+
+def _stream_events(response_server: ResponseServer, request_body: dict[str, object], request_headers: dict[str, str]) -> Iterator[bytes]:
+    try:
+        event_iter = response_server.start_response_stream(request_body, request_headers)
+        for event_name, payload in event_iter:
+            yield _format_sse_event(event_name, payload)
+    except OutcommingChatError as exc:
+        yield _format_sse_event(
+            "response.failed",
+            {
+                "type": "response.failed",
+                "response": {
+                    "error": {
+                        "message": str(exc),
+                    }
+                },
+            },
+        )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="python -m responses_server",
+        description=(
+            "Standalone localhost `/v1/responses` server that translates the "
+            "Codex/Responses subset onto an outcomming `/v1/chat/completions` backend."
+        ),
+    )
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8001)
+    parser.add_argument("--outcomming-base-url", required=True)
+    parser.add_argument("--outcomming-api-key-env", default=None)
+    parser.add_argument("--model-provider", default=None)
+    parser.add_argument("--timeout-seconds", type=float, default=120.0)
+    return parser
+
+
+def run_server(config: CompatServerConfig) -> None:
+    uvicorn.run(
+        ManagedResponseServer.build_app(config),
+        host=config.host,
+        port=config.port,
+        log_level="info",
+    )
+
+
+def launch_chat_completion_compat_server(
+    base_url: str,
+    api_key_env: str | None = None,
+    model_provider: str | None = None,
+):
+    config = CompatServerConfig.from_base_url(
+        base_url,
+        api_key_env,
+        model_provider=model_provider,
+    )
+    server = ManagedResponseServer(config)
+    server.start()
+    return server
+
+
+class ManagedResponseServer:
+    @staticmethod
+    def build_app(
+        config: CompatServerConfig,
+        session_store=None,
+        stream_router=None,
+    ) -> FastAPI:
+        response_server = ResponseServer(
+            config,
+            session_store=session_store,
+            stream_router=stream_router,
+        )
+        app = FastAPI(title="ResponsesCompat", version="0.1.0")
+        app.state.response_server = response_server
+
+        @app.get("/health")
+        @app.get("/healthz")
+        async def health() -> dict[str, bool]:
+            return {"ok": True}
+
+        @app.get("/models")
+        @app.get("/v1/models")
+        async def list_models():
+            try:
+                return response_server.list_models()
+            except OutcommingChatError as exc:
+                return JSONResponse(
+                    {"error": {"message": str(exc)}},
+                    status_code=502,
+                )
+
+        @app.post("/responses")
+        @app.post("/v1/responses")
+        async def responses(request: Request):
+            try:
+                request_body = await request.json()
+            except Exception as exc:
+                return JSONResponse(
+                    {"error": {"message": f"invalid JSON body: {exc}"}},
+                    status_code=400,
+                )
+            if not isinstance(request_body, dict):
+                return JSONResponse(
+                    {"error": {"message": "request body must be a JSON object"}},
+                    status_code=400,
+                )
+
+            request_headers = {
+                str(key).lower(): str(value)
+                for key, value in request.headers.items()
+            }
+            try:
+                response_server.stream_router.validate_incomming_request(request_body)
+            except UnsupportedIncommingFeature as exc:
+                return JSONResponse(
+                    {"error": {"message": str(exc)}},
+                    status_code=501,
+                )
+
+            return StreamingResponse(
+                _stream_events(response_server, request_body, request_headers),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "close",
+                },
+            )
+
+        return app
+
+    def __init__(self, config: CompatServerConfig) -> None:
+        port = config.port or _reserve_free_port()
+        self._config = replace(config, port=port)
+        self._app = self.build_app(self._config)
+        self._uvicorn_config = uvicorn.Config(
+            self._app,
+            host=self._config.host,
+            port=self._config.port,
+            log_level="error",
+            access_log=False,
+        )
+        self._server = uvicorn.Server(self._uvicorn_config)
+        self._thread = threading.Thread(target=self._server.run, daemon=True)
+
+    @property
+    def base_url(self) -> str:
+        return f"http://{self._config.host}:{self._config.port}/v1"
+
+    def start(self, timeout_seconds: float = 10.0) -> None:
+        self._thread.start()
+        deadline = time.time() + timeout_seconds
+        while not self._server.started:
+            if time.time() >= deadline:
+                raise RuntimeError(
+                    "timed out waiting for managed responses server to start"
+                )
+            time.sleep(0.01)
+
+    def stop(self, timeout_seconds: float = 5.0) -> None:
+        self._server.should_exit = True
+        self._thread.join(timeout=timeout_seconds)
+        if self._thread.is_alive():
+            raise RuntimeError(
+                "timed out waiting for managed responses server to stop"
+            )
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    run_server(
+        CompatServerConfig(
+            host=args.host,
+            port=args.port,
+            outcomming_base_url=args.outcomming_base_url,
+            outcomming_api_key_env=args.outcomming_api_key_env,
+            model_provider=args.model_provider,
+            timeout_seconds=args.timeout_seconds,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
+
+
+def _reserve_free_port() -> int:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        sock.bind(("127.0.0.1", 0))
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        return int(sock.getsockname()[1])
+    finally:
+        sock.close()

responses_server/config.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+import urllib.parse
+
+
+@dataclass(frozen=True, slots=True)
+class CompatServerConfig:
+    host: str = "127.0.0.1"
+    port: int = 0
+    outcomming_base_url: str = "http://127.0.0.1:8000/v1"
+    outcomming_api_key_env: str | None = None
+    model_provider: str | None = None
+    timeout_seconds: float = 120.0
+
+    def outcomming_api_key(self) -> str | None:
+        if self.outcomming_api_key_env is None:
+            return None
+        value = os.environ.get(self.outcomming_api_key_env, "").strip()
+        return value or None
+
+    def outcomming_chat_completions_url(self) -> str:
+        base = self.outcomming_base_url.rstrip("/")
+        return f"{base}/chat/completions"
+
+    def outcomming_models_url(self) -> str:
+        base = self.outcomming_base_url.rstrip("/")
+        return f"{base}/models"
+
+    def with_ephemeral_port(self) -> CompatServerConfig:
+        return CompatServerConfig(
+            host=self.host,
+            port=0,
+            outcomming_base_url=self.outcomming_base_url,
+            outcomming_api_key_env=self.outcomming_api_key_env,
+            model_provider=self.model_provider,
+            timeout_seconds=self.timeout_seconds,
+        )
+
+    @classmethod
+    def from_base_url(
+        cls,
+        outcomming_base_url: str,
+        api_key_env: str | None = None,
+        model_provider: str | None = None,
+    ) -> CompatServerConfig:
+        parsed = urllib.parse.urlparse(outcomming_base_url)
+        if not parsed.scheme or not parsed.netloc:
+            raise ValueError(f"invalid outcomming base url: {outcomming_base_url}")
+        normalized_path = parsed.path.rstrip("/")
+        if normalized_path in {"", "/"}:
+            parsed = parsed._replace(path="/v1")
+            outcomming_base_url = urllib.parse.urlunparse(parsed)
+        else:
+            outcomming_base_url = urllib.parse.urlunparse(
+                parsed._replace(path=normalized_path)
+            )
+        return cls(
+            outcomming_base_url=outcomming_base_url,
+            outcomming_api_key_env=api_key_env,
+            model_provider=model_provider,
+        )

responses_server/payload_processors.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+"""Provider-specific post-process hooks for canonical outgoing chat requests.
+
+Each downstream chat-completions provider may have its own payload quirks:
+extra fields, removed fields, role normalization, tool-shape tweaks, etc.
+Keep all of those provider-specific rewrites here so `StreamRouter` can keep
+building one canonical `outcomming_request`, while `server.py` selects the
+appropriate hook from `CompatServerConfig.model_provider`.
+"""
+
+from collections.abc import Callable
+from copy import deepcopy
+from typing import Optional, TypedDict
+
+ChatMessage = dict[str, object]
+
+
+class OutgoingRequest(TypedDict):
+    """Canonical downstream `/v1/chat/completions` request shape.
+
+    `model`, `messages`, and `stream` are always populated by
+    `StreamRouter.build_outcomming_request(...)`. Provider-specific fields that
+    may be omitted use `Optional[...]` here so the schema stays simple and does
+    not rely on TypedDict inheritance.
+    """
+
+    model: str
+    messages: list[ChatMessage]
+    stream: bool
+    tools: Optional[list[dict[str, object]]]
+    tool_choice: Optional[object]
+    parallel_tool_calls: Optional[bool]
+
+
+PayloadPostProcessor = Callable[[OutgoingRequest], OutgoingRequest]
+
+
+def _identity(outcomming_request: OutgoingRequest) -> OutgoingRequest:
+    """Keep the canonical request unchanged."""
+
+    return outcomming_request
+
+
+def _drop_developer_messages(outcomming_request: OutgoingRequest) -> OutgoingRequest:
+    """Remove all developer-role messages for providers that reject them."""
+
+    outcomming_request["messages"] = [
+        message
+        for message in outcomming_request["messages"]
+        if message.get("role") != "developer"
+    ]
+    return outcomming_request
+
+
+PAYLOAD_POST_PROCESSORS: dict[str, PayloadPostProcessor] = {
+    "stepfun": _drop_developer_messages,
+    "vllm": _identity,
+}
+"""Mapping from normalized `model_provider` name to payload rewrite hook."""
+
+
+def post_process_outcomming_request(
+    outcomming_request: OutgoingRequest,
+    model_provider: str | None,
+) -> OutgoingRequest:
+    """Apply the provider-specific payload hook to one outgoing request.
+
+    This is the single wrapper around `PAYLOAD_POST_PROCESSORS`: it normalizes
+    the provider name, falls back to the default `vllm` behavior when the
+    provider is missing or unknown, deep-copies the canonical request, applies
+    the selected hook, and validates that the hook returns another request dict.
+    """
+
+    processed_request = deepcopy(outcomming_request)
+    provider_name = str(model_provider or "").strip().lower()
+    provider_processor = PAYLOAD_POST_PROCESSORS.get(
+        provider_name,
+        PAYLOAD_POST_PROCESSORS.get("vllm"),
+    )
+    if provider_processor is None:
+        return processed_request
+    processed_request = provider_processor(processed_request)
+    if not isinstance(processed_request, dict):
+        raise TypeError("payload processor must return a dict outcomming_request")
+    return processed_request

responses_server/server.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from .config import CompatServerConfig
+from .payload_processors import post_process_outcomming_request
+from .session_store import SessionStore
+from .stream_router import StreamRouter
+
+
+class ResponseServer:
+    def __init__(
+        self,
+        config: CompatServerConfig,
+        session_store: SessionStore | None = None,
+        stream_router: StreamRouter | None = None,
+    ) -> None:
+        self._config = config
+        self._session_store = session_store or SessionStore()
+        self._stream_router = stream_router or StreamRouter(config)
+
+    @property
+    def config(self) -> CompatServerConfig:
+        return self._config
+
+    @property
+    def session_store(self) -> SessionStore:
+        return self._session_store
+
+    @property
+    def stream_router(self) -> StreamRouter:
+        return self._stream_router
+
+    def list_models(self) -> dict[str, object]:
+        return self._stream_router.list_models()
+
+    def start_response_stream(
+        self,
+        request_body: dict[str, object],
+        request_headers: dict[str, str],
+    ):
+        outcomming_request = self._stream_router.build_outcomming_request(request_body)
+        outcomming_request = post_process_outcomming_request(
+            outcomming_request,
+            self._config.model_provider,
+        )
+        custom_tool_names = self._stream_router.collect_custom_tool_names(request_body)
+        session_id = (
+            request_headers.get("x-client-request-id")
+            or str(request_body.get("prompt_cache_key", "")).strip()
+            or None
+        )
+        stored_response = self._session_store.create_response(
+            session_id=session_id,
+            model=str(outcomming_request["model"]),
+        )
+        incomming_stream = self._stream_router.open_outcomming_stream(
+            outcomming_request
+        )
+        return self._stream_router.route_stream(
+            incomming_stream,
+            stored_response,
+            outcomming_request,
+            custom_tool_names,
+        )