@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/router_request_context.py

@@ -0,0 +1,215 @@
+"""Runtime protocol request handling and router selection bounded context."""
+
+from __future__ import annotations
+
+import urllib.error
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler
+from typing import Any, Callable
+
+from .agent_router import (
+    RuntimeRouter,
+    missing_common_capabilities,
+    router_capability_matrix,
+)
+from .claude_router import ClaudeRouter, ClaudeRouterServices
+from .codex_router import CodexRouter
+from .openai_chat_router import OpenAIChatRouter
+from .openai_responses_router import (
+    OpenAIResponsesServices,
+    handle_openai_responses_request,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RouterRequestPorts:
+    openai_responses: OpenAIResponsesServices
+    forward_backend_json: Callable[..., Any]
+    forward_backend_get: Callable[..., Any]
+    write_responses_error: Callable[..., Any]
+    write_json: Callable[..., Any]
+    upstream_error_message: Callable[..., str]
+    is_client_disconnect: Callable[[BaseException], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeRouterPorts:
+    codex_routed_enabled: Callable[..., bool]
+    forward_provider_chat: Callable[..., Any]
+    claude_services: ClaudeRouterServices
+
+
+@dataclass(frozen=True, slots=True)
+class RouterRequestContext:
+    request: RouterRequestPorts
+    runtime: RuntimeRouterPorts
+
+    def handle_openai_responses_post(
+        self,
+        handler: BaseHTTPRequestHandler,
+        cfg: dict[str, Any],
+        provider: str,
+        pcfg: dict[str, Any],
+        body: dict[str, Any],
+    ) -> None:
+        handle_openai_responses_request(
+            handler,
+            cfg,
+            provider,
+            pcfg,
+            body,
+            self.request.openai_responses,
+        )
+
+    def handle_codex_backend_passthrough_post(
+        self,
+        handler: BaseHTTPRequestHandler,
+        provider: str,
+        pcfg: dict[str, Any],
+        body: dict[str, Any],
+    ) -> None:
+        try:
+            self.request.forward_backend_json(
+                handler,
+                provider,
+                pcfg,
+                body,
+                mutate_responses=False,
+            )
+        except urllib.error.HTTPError as exc:
+            raw = exc.read().decode("utf-8", errors="ignore")
+            self.request.write_responses_error(
+                handler,
+                self.request.upstream_error_message(exc, raw),
+                stream=False,
+                status=exc.code,
+            )
+        except Exception as exc:
+            if self.request.is_client_disconnect(exc):
+                return
+            self.request.write_responses_error(
+                handler,
+                f"{type(exc).__name__}: {exc}",
+                stream=False,
+            )
+
+    def handle_codex_backend_passthrough_get(
+        self,
+        handler: BaseHTTPRequestHandler,
+        provider: str,
+        pcfg: dict[str, Any],
+    ) -> None:
+        try:
+            self.request.forward_backend_get(handler, provider, pcfg)
+        except urllib.error.HTTPError as exc:
+            raw = exc.read().decode("utf-8", errors="ignore")
+            self.request.write_json(
+                handler,
+                {"error": {"message": self.request.upstream_error_message(exc, raw)}},
+                status=exc.code,
+            )
+        except Exception as exc:
+            if self.request.is_client_disconnect(exc):
+                return
+            self.request.write_json(
+                handler,
+                {"error": {"message": f"{type(exc).__name__}: {exc}"}},
+                status=502,
+            )
+
+    def build_claude_router_services(self) -> ClaudeRouterServices:
+        return self.runtime.claude_services
+
+    def build_runtime_routers(self) -> tuple[RuntimeRouter, ...]:
+        return (
+            CodexRouter(
+                routed_enabled=self.runtime.codex_routed_enabled,
+                handle_responses_post=self.handle_openai_responses_post,
+                handle_backend_passthrough_post=(
+                    self.handle_codex_backend_passthrough_post
+                ),
+                handle_backend_passthrough_get=(
+                    self.handle_codex_backend_passthrough_get
+                ),
+            ),
+            OpenAIChatRouter(self.runtime.forward_provider_chat),
+            ClaudeRouter(services=self.runtime.claude_services),
+        )
+
+    def capability_matrix(self) -> dict[str, dict[str, Any]]:
+        return router_capability_matrix(self.build_runtime_routers())
+
+    def capability_gaps(self) -> dict[str, list[str]]:
+        return missing_common_capabilities(self.build_runtime_routers())
+
+    def route_get(
+        self,
+        handler: BaseHTTPRequestHandler,
+        path: str,
+        provider: str,
+        pcfg: dict[str, Any],
+    ) -> bool:
+        for router in self.build_runtime_routers():
+            if router.can_handle_get(path, provider, pcfg):
+                return bool(router.handle_get(handler, path, provider, pcfg))
+        return False
+
+    def route_post(
+        self,
+        handler: BaseHTTPRequestHandler,
+        cfg: dict[str, Any],
+        provider: str,
+        pcfg: dict[str, Any],
+        path: str,
+        body: dict[str, Any],
+    ) -> bool:
+        for router in self.build_runtime_routers():
+            if router.can_handle_post(path, provider, pcfg):
+                return bool(
+                    router.handle_post(handler, cfg, provider, pcfg, path, body)
+                )
+        return False
+
+
+@dataclass(frozen=True, slots=True)
+class RouterRequestCompatibilityApi:
+    context: Callable[[], RouterRequestContext]
+
+    def handle_openai_responses_post(self, *args: Any, **kwargs: Any) -> None:
+        self.context().handle_openai_responses_post(*args, **kwargs)
+
+    def handle_codex_backend_passthrough_post(
+        self, *args: Any, **kwargs: Any
+    ) -> None:
+        self.context().handle_codex_backend_passthrough_post(*args, **kwargs)
+
+    def handle_codex_backend_passthrough_get(
+        self, *args: Any, **kwargs: Any
+    ) -> None:
+        self.context().handle_codex_backend_passthrough_get(*args, **kwargs)
+
+    def build_claude_router_services(self) -> ClaudeRouterServices:
+        return self.context().build_claude_router_services()
+
+    def build_runtime_routers(self) -> tuple[RuntimeRouter, ...]:
+        return self.context().build_runtime_routers()
+
+    def capability_matrix(self) -> dict[str, dict[str, Any]]:
+        return self.context().capability_matrix()
+
+    def capability_gaps(self) -> dict[str, list[str]]:
+        return self.context().capability_gaps()
+
+    def route_get(self, *args: Any, **kwargs: Any) -> bool:
+        return self.context().route_get(*args, **kwargs)
+
+    def route_post(self, *args: Any, **kwargs: Any) -> bool:
+        return self.context().route_post(*args, **kwargs)
+
+
+__all__ = [
+    "RouterRequestCompatibilityApi",
+    "RouterRequestContext",
+    "RouterRequestPorts",
+    "RuntimeRouterPorts",
+]

package/ciel_runtime_support/router_server_context.py

@@ -0,0 +1,82 @@
+"""Router HTTP presentation and server lifecycle bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from .router_http import RouterHttpServices
+from .router_server_runtime import RouterServerRuntime
+
+
+@dataclass(frozen=True, slots=True)
+class RouterHealthPresentationPorts:
+    version: str
+    source_fingerprint: str
+    current_pid: Callable[[], int]
+    current_user: Callable[[], str]
+    home: Path
+    config_dir: Path
+    workspace: str
+    router_port: int
+    current_alias: Callable[[dict[str, Any]], str]
+
+
+@dataclass(frozen=True, slots=True)
+class RouterServerContext:
+    health: RouterHealthPresentationPorts
+    http_services: RouterHttpServices
+    server_runtime: RouterServerRuntime
+
+    def health_payload(
+        self,
+        cfg: dict[str, Any],
+        provider: str,
+        pcfg: dict[str, Any],
+    ) -> dict[str, Any]:
+        del pcfg
+        return {
+            "ok": True,
+            "version": self.health.version,
+            "source_fingerprint": self.health.source_fingerprint,
+            "pid": self.health.current_pid(),
+            "user": self.health.current_user(),
+            "home": str(self.health.home),
+            "config_dir": str(self.health.config_dir),
+            "workspace": self.health.workspace,
+            "router_port": self.health.router_port,
+            "provider": provider,
+            "model": self.health.current_alias(cfg),
+            "web_chat": "/ca/web/chat",
+            "chat": "/ca/chat/health",
+            "plan": "/ca/plan/artifacts",
+            "events": "/ca/events",
+        }
+
+    def build_http_services(self) -> RouterHttpServices:
+        return self.http_services
+
+    def serve(self, _: Any) -> None:
+        self.server_runtime.run()
+
+
+@dataclass(frozen=True, slots=True)
+class RouterServerCompatibilityApi:
+    context: Callable[[], RouterServerContext]
+
+    def health_payload(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        return self.context().health_payload(*args, **kwargs)
+
+    def build_http_services(self) -> RouterHttpServices:
+        return self.context().build_http_services()
+
+    def serve(self, args: Any) -> None:
+        self.context().serve(args)
+
+
+__all__ = [
+    "RouterHealthPresentationPorts",
+    "RouterServerCompatibilityApi",
+    "RouterServerContext",
+]