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

responses_server/app.py

@@ -0,0 +1,227 @@
+
+import argparse
+import asyncio
+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
+import typing
+
+
+def _run_uvicorn_server(server) -> 'None':
+    asyncio.set_event_loop(asyncio.new_event_loop())
+    server.run()
+
+
+def _format_sse_event(event_name: 'str', payload: 'typing.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: 'typing.Dict[str, object]', request_headers: 'typing.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: 'typing.Union[str, None]' = None,
+    model_provider: 'typing.Union[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() -> 'typing.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=_run_uvicorn_server,
+            args=(self._server,),
+            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 @@
+
+import os
+from dataclasses import dataclass
+import urllib.parse
+import typing
+
+
+@dataclass(frozen=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: 'typing.Union[str, None]' = None
+    model_provider: 'typing.Union[str, None]' = None
+    timeout_seconds: 'float' = 120.0
+
+    def outcomming_api_key(self) -> 'typing.Union[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: 'typing.Union[str, None]' = None,
+        model_provider: 'typing.Union[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 @@
+
+"""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 copy import deepcopy
+from typing import Callable, Optional
+import typing
+from typing_extensions import TypedDict
+
+ChatMessage = typing.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: 'typing.List[ChatMessage]'
+    stream: 'bool'
+    tools: 'Optional[typing.List[typing.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: 'typing.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: 'typing.Union[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 .config import CompatServerConfig
+from .payload_processors import post_process_outcomming_request
+from .session_store import SessionStore
+from .stream_router import StreamRouter
+import typing
+
+
+class ResponseServer:
+    def __init__(
+        self,
+        config: 'CompatServerConfig',
+        session_store: 'typing.Union[SessionStore, None]' = None,
+        stream_router: 'typing.Union[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) -> 'typing.Dict[str, object]':
+        return self._stream_router.list_models()
+
+    def start_response_stream(
+        self,
+        request_body: 'typing.Dict[str, object]',
+        request_headers: 'typing.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,
+        )

responses_server/session_store.py

@@ -0,0 +1,37 @@
+
+from dataclasses import dataclass
+import threading
+import time
+import typing
+
+
+@dataclass(frozen=True, )
+class StoredResponse:
+    response_id: 'str'
+    session_id: 'typing.Union[str, None]'
+    model: 'str'
+    created_at: 'float'
+
+
+class SessionStore:
+    def __init__(self) -> 'None':
+        self._lock = threading.Lock()
+        self._next_response_number = 1
+        self._responses: 'typing.Dict[str, StoredResponse]' = {}
+
+    def create_response(self, session_id: 'typing.Union[str, None]', model: 'str') -> 'StoredResponse':
+        with self._lock:
+            response_id = f"resp_{self._next_response_number:08d}"
+            self._next_response_number += 1
+            stored = StoredResponse(
+                response_id=response_id,
+                session_id=session_id,
+                model=model,
+                created_at=time.time(),
+            )
+            self._responses[response_id] = stored
+            return stored
+
+    def get_response(self, response_id: 'str') -> 'typing.Union[StoredResponse, None]':
+        with self._lock:
+            return self._responses.get(response_id)