PyPI - codex-api-proxy - Versions diffs - 0.1.0__py3-none-any.whl - Mend

codex-api-proxy 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

codex_api_proxy/__init__.py +3 -0
codex_api_proxy/app_server_runner.py +554 -0
codex_api_proxy/cli.py +570 -0
codex_api_proxy/codex_runner.py +278 -0
codex_api_proxy/config.py +83 -0
codex_api_proxy/main.py +561 -0
codex_api_proxy/prompt.py +31 -0
codex_api_proxy/schemas.py +48 -0
codex_api_proxy-0.1.0.dist-info/METADATA +347 -0
codex_api_proxy-0.1.0.dist-info/RECORD +13 -0
codex_api_proxy-0.1.0.dist-info/WHEEL +5 -0
codex_api_proxy-0.1.0.dist-info/entry_points.txt +2 -0
codex_api_proxy-0.1.0.dist-info/top_level.txt +1 -0

codex_api_proxy/codex_runner.py ADDED Viewed

@@ -0,0 +1,278 @@
+from __future__ import annotations
+import asyncio
+import contextlib
+import json
+import os
+import re
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+class CodexRunError(RuntimeError):
+    """Raised when Codex exits unsuccessfully or emits unusable output."""
+def _content_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        texts: list[str] = []
+        for item in content:
+            if isinstance(item, dict) and "text" in item:
+                texts.append(str(item["text"]))
+        return "".join(texts)
+    return ""
+def _assistant_text_from_event(event: dict[str, Any]) -> str | None:
+    if event.get("type") == "agent_message" and isinstance(event.get("message"), str):
+        return event["message"]
+    item = event.get("item")
+    if event.get("type") == "item.completed" and isinstance(item, dict):
+        if item.get("type") == "agent_message" and isinstance(item.get("text"), str):
+            return item["text"]
+        if item.get("type") == "message" and item.get("role") == "assistant":
+            text = _content_text(item.get("content"))
+            if text:
+                return text
+    return None
+def parse_final_message(lines: list[str]) -> str:
+    final: str | None = None
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        text = _assistant_text_from_event(event)
+        if text is not None:
+            final = text
+    if final is None:
+        raise CodexRunError("No final assistant message found in Codex output")
+    return final
+def summarize_stderr(stderr: str, max_chars: int = 1200) -> str:
+    text = stderr.strip() or "no stderr"
+    text = re.sub(r"<html>.*?</html>", "<html omitted>", text, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(r"\s+", " ", text).strip()
+    if len(text) <= max_chars:
+        return text
+    marker = " ... "
+    keep = max_chars - len(marker)
+    if keep <= 0:
+        return text[:max_chars]
+    head = keep // 2
+    tail = keep - head
+    return f"{text[:head]}{marker}{text[-tail:]}"
+def _extract_error_message(raw_message: Any) -> str | None:
+    if not raw_message:
+        return None
+    if not isinstance(raw_message, str):
+        return str(raw_message)
+    try:
+        parsed = json.loads(raw_message)
+    except json.JSONDecodeError:
+        return raw_message
+    if isinstance(parsed, dict):
+        error = parsed.get("error")
+        if isinstance(error, dict) and error.get("message"):
+            return str(error["message"])
+        if parsed.get("message"):
+            return str(parsed["message"])
+    return raw_message
+def summarize_process_error(stderr: str, stdout: str) -> str:
+    stderr_summary = summarize_stderr(stderr)
+    if stderr_summary != "no stderr":
+        return stderr_summary
+    for line in stdout.splitlines():
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if event.get("type") == "error":
+            message = _extract_error_message(event.get("message"))
+            if message:
+                return summarize_stderr(message)
+        if event.get("type") == "turn.failed" and isinstance(event.get("error"), dict):
+            message = _extract_error_message(event["error"].get("message"))
+            if message:
+                return summarize_stderr(message)
+    return "no stderr"
+def build_proxy_env(proxy: str | None, base_env: dict[str, str] | None = None) -> dict[str, str] | None:
+    if not proxy:
+        return None
+    env = dict(os.environ if base_env is None else base_env)
+    env["http_proxy"] = proxy
+    env["https_proxy"] = proxy
+    env["HTTP_PROXY"] = proxy
+    env["HTTPS_PROXY"] = proxy
+    return env
+def build_codex_command(
+    *,
+    codex_bin: str,
+    cwd: Path,
+    model: str | None,
+    codex_configs: list[str],
+    ephemeral: bool,
+) -> list[str]:
+    has_sandbox_override = any(config.strip().startswith("sandbox_mode") for config in codex_configs)
+    command = [
+        codex_bin,
+        "exec",
+        "--json",
+        "--skip-git-repo-check",
+        "--ignore-user-config",
+        "--ignore-rules",
+    ]
+    if not has_sandbox_override:
+        command.extend(["--sandbox", "read-only"])
+    command.extend(["--cd", str(cwd)])
+    if model:
+        command.extend(["--model", model])
+    for config in codex_configs:
+        command.extend(["-c", config])
+    if ephemeral:
+        command.append("--ephemeral")
+    command.append("-")
+    return command
+def _record_latency(callback: Callable[[str, float], None] | None, name: str, started_at: float) -> None:
+    if callback:
+        callback(name, (time.perf_counter() - started_at) * 1000)
+async def _read_process_output(
+    *,
+    process: asyncio.subprocess.Process,
+    prompt: str,
+    latency_callback: Callable[[str, float], None] | None,
+) -> tuple[str, str]:
+    if process.stdin is None or process.stdout is None or process.stderr is None:
+        raise CodexRunError("Codex subprocess was created without stdio pipes")
+    io_started_at = time.perf_counter()
+    stderr_task = asyncio.create_task(process.stderr.read())
+    stdout_lines: list[str] = []
+    saw_stdout_event = False
+    saw_assistant_event = False
+    try:
+        stdin_started_at = time.perf_counter()
+        try:
+            process.stdin.write(prompt.encode("utf-8"))
+            await process.stdin.drain()
+        except BrokenPipeError:
+            pass
+        finally:
+            process.stdin.close()
+            with contextlib.suppress(BrokenPipeError, ConnectionResetError):
+                await process.stdin.wait_closed()
+        _record_latency(latency_callback, "codex_stdin_write", stdin_started_at)
+        stdout_started_at = time.perf_counter()
+        while True:
+            line_bytes = await process.stdout.readline()
+            if not line_bytes:
+                break
+            line = line_bytes.decode("utf-8", errors="replace")
+            stdout_lines.append(line)
+            if line.strip() and not saw_stdout_event:
+                saw_stdout_event = True
+                _record_latency(latency_callback, "codex_first_stdout_event", io_started_at)
+            if not saw_assistant_event:
+                try:
+                    event = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if _assistant_text_from_event(event) is not None:
+                    saw_assistant_event = True
+                    _record_latency(latency_callback, "codex_first_assistant_event", io_started_at)
+        _record_latency(latency_callback, "codex_stdout_read", stdout_started_at)
+        wait_started_at = time.perf_counter()
+        await process.wait()
+        _record_latency(latency_callback, "codex_process_wait", wait_started_at)
+        stderr = await stderr_task
+        _record_latency(latency_callback, "codex_communicate", io_started_at)
+        return "".join(stdout_lines), stderr.decode("utf-8", errors="replace")
+    finally:
+        if not stderr_task.done():
+            stderr_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await stderr_task
+async def run_codex_exec(
+    *,
+    codex_bin: str,
+    cwd: Path,
+    prompt: str,
+    timeout_seconds: float,
+    proxy: str | None = None,
+    model: str | None = None,
+    codex_configs: list[str] | None = None,
+    ephemeral: bool = False,
+    latency_callback: Callable[[str, float], None] | None = None,
+) -> str:
+    command_started_at = time.perf_counter()
+    command = build_codex_command(
+        codex_bin=codex_bin,
+        cwd=cwd,
+        model=model,
+        codex_configs=codex_configs or [],
+        ephemeral=ephemeral,
+    )
+    if latency_callback:
+        latency_callback("codex_command_build", (time.perf_counter() - command_started_at) * 1000)
+    spawn_started_at = time.perf_counter()
+    process = await asyncio.create_subprocess_exec(
+        *command,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=build_proxy_env(proxy),
+    )
+    if latency_callback:
+        latency_callback("codex_process_spawn", (time.perf_counter() - spawn_started_at) * 1000)
+    try:
+        stdout_text, stderr_text = await asyncio.wait_for(
+            _read_process_output(
+                process=process,
+                prompt=prompt,
+                latency_callback=latency_callback,
+            ),
+            timeout=timeout_seconds,
+        )
+    except TimeoutError as exc:
+        process.kill()
+        await process.wait()
+        raise TimeoutError(f"Codex execution exceeded {timeout_seconds} seconds") from exc
+    if process.returncode != 0:
+        raise CodexRunError(f"Codex exited with {process.returncode}: {summarize_process_error(stderr_text, stdout_text)}")
+    parse_started_at = time.perf_counter()
+    final_message = parse_final_message(stdout_text.splitlines())
+    if latency_callback:
+        latency_callback("codex_output_parse", (time.perf_counter() - parse_started_at) * 1000)
+    return final_message

codex_api_proxy/config.py ADDED Viewed

@@ -0,0 +1,83 @@
+from __future__ import annotations
+import os
+from dataclasses import dataclass
+from pathlib import Path
+class SettingsError(ValueError):
+    """Raised when proxy settings or request-scoped paths are invalid."""
+def _split_paths(raw: str | None) -> list[Path]:
+    if not raw:
+        return []
+    return [Path(part).expanduser() for part in raw.split(":") if part]
+@dataclass(frozen=True)
+class Settings:
+    host: str = "127.0.0.1"
+    port: int = 8765
+    api_key: str | None = None
+    codex_bin: str = "codex"
+    proxy: str | None = None
+    model: str | None = None
+    codex_configs: list[str] | None = None
+    ephemeral: bool = True
+    engine: str = "exec"
+    workers: int = 1
+    max_queue_size: int = 64
+    queue_timeout_seconds: float = 30.0
+    app_server_codex_home: Path | None = None
+    default_cwd: Path = Path.cwd()
+    allowed_roots: list[Path] | None = None
+    request_timeout_seconds: float = 300.0
+    max_concurrency: int = 1
+    log_level: str = "info"
+    @classmethod
+    def from_env(cls) -> "Settings":
+        default_cwd = Path(os.environ.get("CODEX_PROXY_DEFAULT_CWD", os.getcwd())).expanduser()
+        allowed_roots = _split_paths(os.environ.get("CODEX_PROXY_ALLOWED_ROOTS"))
+        if not allowed_roots:
+            allowed_roots = [default_cwd]
+        return cls(
+            host=os.environ.get("CODEX_PROXY_HOST", "127.0.0.1"),
+            port=int(os.environ.get("CODEX_PROXY_PORT", "8765")),
+            api_key=os.environ.get("CODEX_PROXY_API_KEY") or None,
+            codex_bin=os.environ.get("CODEX_PROXY_CODEX_BIN", "codex"),
+            proxy=os.environ.get("CODEX_PROXY_PROXY") or None,
+            model=os.environ.get("CODEX_PROXY_MODEL") or None,
+            codex_configs=[
+                item
+                for item in os.environ.get("CODEX_PROXY_CODEX_CONFIGS", "").split(";;")
+                if item
+            ],
+            ephemeral=os.environ.get("CODEX_PROXY_EPHEMERAL", "true").lower() in {"1", "true", "yes"},
+            engine=os.environ.get("CODEX_PROXY_ENGINE", "exec"),
+            workers=int(os.environ.get("CODEX_PROXY_WORKERS", "1")),
+            max_queue_size=int(os.environ.get("CODEX_PROXY_MAX_QUEUE_SIZE", "64")),
+            queue_timeout_seconds=float(os.environ.get("CODEX_PROXY_QUEUE_TIMEOUT_SECONDS", "30")),
+            app_server_codex_home=(
+                Path(raw_home).expanduser()
+                if (raw_home := os.environ.get("CODEX_PROXY_APP_SERVER_CODEX_HOME"))
+                else None
+            ),
+            default_cwd=default_cwd,
+            allowed_roots=allowed_roots,
+            request_timeout_seconds=float(os.environ.get("CODEX_PROXY_TIMEOUT_SECONDS", "300")),
+            max_concurrency=int(os.environ.get("CODEX_PROXY_MAX_CONCURRENCY", "1")),
+            log_level=os.environ.get("CODEX_PROXY_LOG_LEVEL", "info"),
+        )
+    def resolve_cwd(self, requested_cwd: str | None) -> Path:
+        candidate = Path(requested_cwd).expanduser() if requested_cwd else self.default_cwd
+        resolved = candidate.resolve()
+        roots = [root.expanduser().resolve() for root in (self.allowed_roots or [self.default_cwd])]
+        if not any(resolved == root or root in resolved.parents for root in roots):
+            allowed = ", ".join(str(root) for root in roots)
+            raise SettingsError(f"cwd {resolved} is outside allowed roots: {allowed}")
+        if not resolved.exists() or not resolved.is_dir():
+            raise SettingsError(f"cwd {resolved} is not an existing directory")
+        return resolved