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

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,
+        )

responses_server/session_store.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import threading
+import time
+
+
+@dataclass(frozen=True, slots=True)
+class StoredResponse:
+    response_id: str
+    session_id: str | None
+    model: str
+    created_at: float
+
+
+class SessionStore:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._next_response_number = 1
+        self._responses: dict[str, StoredResponse] = {}
+
+    def create_response(self, session_id: 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) -> StoredResponse | None:
+        with self._lock:
+            return self._responses.get(response_id)