codex-proxy 3.1.0__py3-none-any.whl

codex_proxy/plugins.py

@@ -0,0 +1,110 @@
+"""Plugin system — hook-based extensibility for codex-proxy."""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger("codex-proxy")
+
+
+@dataclass
+class PluginContext:
+    """Safe context passed to plugin hooks."""
+
+    request_id: str
+    method: str  # "http" or "ws"
+    model: str
+    provider: str
+    api_key_masked: str
+    stream: bool
+    status_code: int | None = None
+    error: str | None = None
+    duration_ms: float | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class Plugin:
+    """Base class for plugins. Override only the hooks you need."""
+
+    name: str = "unnamed"
+
+    async def on_startup(self, config: Any) -> None:
+        pass
+
+    async def on_shutdown(self) -> None:
+        pass
+
+    async def on_request(self, ctx: PluginContext) -> PluginContext:
+        return ctx
+
+    async def on_response(self, ctx: PluginContext) -> None:
+        pass
+
+    async def on_error(self, ctx: PluginContext) -> None:
+        pass
+
+
+class PluginRegistry:
+    """Loads and manages plugins from dotted module paths."""
+
+    def __init__(self) -> None:
+        self._plugins: list[Plugin] = []
+
+    def load(self, plugin_paths: list[str]) -> None:
+        """Load plugins from dotted module.class paths."""
+        for path in plugin_paths:
+            try:
+                module_path, class_name = path.rsplit(".", 1)
+                module = importlib.import_module(module_path)
+                cls = getattr(module, class_name)
+                instance: Plugin = cls()
+                instance.name = getattr(instance, "name", class_name)
+                self._plugins.append(instance)
+                logger.info("Plugin loaded: %s", instance.name)
+            except Exception as e:
+                logger.error("Failed to load plugin %s: %s", path, e)
+
+    async def on_startup(self, config: Any) -> None:
+        for p in self._plugins:
+            try:
+                await p.on_startup(config)
+            except Exception as e:
+                logger.error("Plugin %s on_startup error: %s", p.name, e)
+
+    async def on_shutdown(self) -> None:
+        for p in self._plugins:
+            try:
+                await p.on_shutdown()
+            except Exception as e:
+                logger.error("Plugin %s on_shutdown error: %s", p.name, e)
+
+    async def on_request(self, ctx: PluginContext) -> PluginContext:
+        for p in self._plugins:
+            try:
+                ctx = await p.on_request(ctx)
+            except Exception as e:
+                logger.error("Plugin %s on_request error: %s", p.name, e)
+        return ctx
+
+    async def on_response(self, ctx: PluginContext) -> None:
+        for p in self._plugins:
+            try:
+                await p.on_response(ctx)
+            except Exception as e:
+                logger.error("Plugin %s on_response error: %s", p.name, e)
+
+    async def on_error(self, ctx: PluginContext) -> None:
+        for p in self._plugins:
+            try:
+                await p.on_error(ctx)
+            except Exception as e:
+                logger.error("Plugin %s on_error error: %s", p.name, e)
+
+    def list_plugins(self) -> list[str]:
+        return [p.name for p in self._plugins]
+
+    def reset(self) -> None:
+        self._plugins.clear()

codex_proxy/plugins_builtin.py

@@ -0,0 +1,34 @@
+"""Built-in plugins for codex-proxy."""
+
+from __future__ import annotations
+
+import logging
+
+from .plugins import Plugin, PluginContext
+
+logger = logging.getLogger("codex-proxy")
+
+
+class LoggingPlugin(Plugin):
+    """Structured request/response logging plugin."""
+
+    name = "logging"
+
+    async def on_request(self, ctx: PluginContext) -> PluginContext:
+        logger.info(
+            "[plugin:logging] request id=%s method=%s model=%s provider=%s stream=%s",
+            ctx.request_id, ctx.method, ctx.model, ctx.provider, ctx.stream,
+        )
+        return ctx
+
+    async def on_response(self, ctx: PluginContext) -> None:
+        logger.info(
+            "[plugin:logging] response id=%s status=%d duration=%.1fms",
+            ctx.request_id, ctx.status_code or 0, ctx.duration_ms or 0,
+        )
+
+    async def on_error(self, ctx: PluginContext) -> None:
+        logger.error(
+            "[plugin:logging] error id=%s status=%d error=%s",
+            ctx.request_id, ctx.status_code or 0, ctx.error,
+        )

codex_proxy/providers.py

@@ -0,0 +1,130 @@
+"""Provider-specific adapters for backend quirks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ProviderAdapter:
+    """Base adapter — no modifications."""
+
+    name: str = "default"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        """Modify the Chat Completions request before sending."""
+        return cc_body
+
+    def adjust_headers(self, headers: dict) -> dict:
+        """Modify HTTP headers before sending."""
+        return headers
+
+
+def _strip_stream_options(cc_body: dict) -> dict:
+    cc_body.pop("stream_options", None)
+    return cc_body
+
+
+class OllamaAdapter(ProviderAdapter):
+    """Ollama doesn't support stream_options and doesn't need a real API key."""
+
+    name: str = "ollama"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        return _strip_stream_options(cc_body)
+
+
+class OpenRouterAdapter(ProviderAdapter):
+    """OpenRouter requires HTTP-Referer header for rankings."""
+
+    name: str = "openrouter"
+
+    def adjust_headers(self, headers: dict) -> dict:
+        headers.setdefault("HTTP-Referer", "https://github.com/ZiryaNoov/codex-proxy")
+        headers.setdefault("X-Title", "codex-proxy")
+        return headers
+
+
+class GroqAdapter(ProviderAdapter):
+    """Groq has strict rate limits — no special request modifications needed yet."""
+
+    name: str = "groq"
+
+
+class AnthropicAdapter(ProviderAdapter):
+    """Anthropic uses x-api-key header and anthropic-version."""
+
+    name: str = "anthropic"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        return _strip_stream_options(cc_body)
+
+    def adjust_headers(self, headers: dict) -> dict:
+        api_key = headers.pop("Authorization", "").removeprefix("Bearer ").strip()
+        headers["x-api-key"] = api_key
+        headers["anthropic-version"] = "2023-06-01"
+        return headers
+
+
+class GeminiAdapter(ProviderAdapter):
+    """Google Gemini OpenAI-compatible endpoint."""
+
+    name: str = "gemini"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        return _strip_stream_options(cc_body)
+
+
+class DeepSeekAdapter(ProviderAdapter):
+    """DeepSeek is OpenAI-compatible but doesn't support stream_options."""
+
+    name: str = "deepseek"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        return _strip_stream_options(cc_body)
+
+
+class MistralAdapter(ProviderAdapter):
+    """Mistral is OpenAI-compatible but doesn't support stream_options."""
+
+    name: str = "mistral"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        return _strip_stream_options(cc_body)
+
+
+class CohereAdapter(ProviderAdapter):
+    """Cohere OpenAI-compatible endpoint."""
+
+    name: str = "cohere"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        return _strip_stream_options(cc_body)
+
+
+class NvidiaAdapter(ProviderAdapter):
+    """NVIDIA NIM OpenAI-compatible endpoint."""
+
+    name: str = "nvidia"
+
+    def adjust_request(self, cc_body: dict) -> dict:
+        return _strip_stream_options(cc_body)
+
+
+_ADAPTERS: dict[str, type[ProviderAdapter]] = {
+    "ollama": OllamaAdapter,
+    "openrouter": OpenRouterAdapter,
+    "groq": GroqAdapter,
+    "anthropic": AnthropicAdapter,
+    "gemini": GeminiAdapter,
+    "deepseek": DeepSeekAdapter,
+    "mistral": MistralAdapter,
+    "cohere": CohereAdapter,
+    "nvidia": NvidiaAdapter,
+}
+
+
+def get_adapter(provider_name: str) -> ProviderAdapter:
+    """Get the adapter for a provider by name. Returns base adapter if unknown."""
+    cls = _ADAPTERS.get(provider_name, ProviderAdapter)
+    return cls(name=provider_name)