Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Add Codex support (#691)
Ali Khokhar3abe41d270f5
diff --git a/api/app.py b/api/app.pyindex a14f3ce9..efb45009 100644--- a/api/app.py+++ b/api/app.py@@ -92,7 +92,7 @@ def create_app(*, lifespan_enabled: bool = True) -> FastAPI:app_kwargs: dict[str, Any] = {"title": "Claude Code Proxy",- "version": "2.0.0",+ "version": "2.1.0",}if lifespan_enabled:app_kwargs["lifespan"] = lifespandiff --git a/api/models/openai_responses.py b/api/models/openai_responses.pynew file mode 100644index 00000000..66a16f4d--- /dev/null+++ b/api/models/openai_responses.py@@ -0,0 +1,28 @@+"""Pydantic models for OpenAI Responses-compatible ingress."""++from __future__ import annotations++from typing import Any++from pydantic import BaseModel, ConfigDict+++class OpenAIResponsesRequest(BaseModel):+ """Permissive subset of the OpenAI Responses API request shape."""++ model_config = ConfigDict(extra="allow")++ model: str+ input: Any = None+ instructions: str | None = None+ tools: list[dict[str, Any]] | None = None+ tool_choice: Any = None+ parallel_tool_calls: bool | None = None+ stream: bool | None = True+ temperature: float | None = None+ top_p: float | None = None+ max_output_tokens: int | None = None+ metadata: dict[str, Any] | None = None+ reasoning: dict[str, Any] | None = None+ previous_response_id: str | None = None+ store: bool | None = Nonediff --git a/api/models/responses.py b/api/models/responses.pyindex 8050516d..027df706 100644--- a/api/models/responses.py+++ b/api/models/responses.py@@ -17,6 +17,9 @@ class TokenCountResponse(BaseModel):class ModelResponse(BaseModel):+ object: Literal["model"] = "model"+ created: int = 0+ owned_by: str = "free-claude-code"created_at: strdisplay_name: strid: str@@ -24,6 +27,7 @@ class ModelResponse(BaseModel):class ModelsListResponse(BaseModel):+ object: Literal["list"] = "list"data: list[ModelResponse]first_id: str | Nonehas_more: booldiff --git a/api/routes.py b/api/routes.pyindex 60494942..e7ec9487 100644--- a/api/routes.py+++ b/api/routes.py@@ -12,6 +12,7 @@ from . import dependenciesfrom .dependencies import get_settings, require_api_keyfrom .gateway_model_ids import gateway_model_id, no_thinking_gateway_model_idfrom .models.anthropic import MessagesRequest, TokenCountRequest+from .models.openai_responses import OpenAIResponsesRequestfrom .models.responses import ModelResponse, ModelsListResponsefrom .services import ClaudeProxyService@@ -179,6 +180,22 @@ async def probe_messages(_auth=Depends(require_api_key)):return _probe_response("POST, HEAD, OPTIONS")[email protected]("/v1/responses")+async def create_response(+ request_data: OpenAIResponsesRequest,+ service: ClaudeProxyService = Depends(get_proxy_service),+ _auth=Depends(require_api_key),+):+ """Create an OpenAI Responses-compatible response through this proxy."""+ return await service.create_response(request_data)++[email protected]_route("/v1/responses", methods=["HEAD", "OPTIONS"])+async def probe_responses(_auth=Depends(require_api_key)):+ """Respond to OpenAI Responses compatibility probes."""+ return _probe_response("POST, HEAD, OPTIONS")++@router.post("/v1/messages/count_tokens")async def count_tokens(request_data: TokenCountRequest,diff --git a/api/services.py b/api/services.pyindex 6286bade..cfc34f69 100644--- a/api/services.py+++ b/api/services.py@@ -8,18 +8,30 @@ from collections.abc import AsyncIterator, Callablefrom typing import Anyfrom fastapi import HTTPException-from fastapi.responses import StreamingResponse+from fastapi.responses import JSONResponse, StreamingResponsefrom loguru import logger+from pydantic import BaseModelfrom config.settings import Settingsfrom core.anthropic import get_token_count, get_user_facing_error_messagefrom core.anthropic.sse import ANTHROPIC_SSE_RESPONSE_HEADERS+from core.openai_responses import (+ OPENAI_RESPONSES_SSE_HEADERS,+ ResponsesConversionError,+ anthropic_message_response_to_openai_response,+ collect_openai_response_from_anthropic_sse,+ iter_anthropic_sse_as_openai_responses,+ iter_message_response_as_openai_responses,+ openai_error_payload,+ responses_request_to_anthropic_payload,+)from core.trace import api_messages_request_snapshot, trace_event, traced_async_streamfrom providers.base import BaseProviderfrom providers.exceptions import InvalidRequestError, ProviderErrorfrom .model_router import ModelRouterfrom .models.anthropic import MessagesRequest, TokenCountRequest+from .models.openai_responses import OpenAIResponsesRequestfrom .models.responses import TokenCountResponsefrom .optimization_handlers import try_optimizationsfrom .web_tools.egress import WebFetchEgressPolicy@@ -48,6 +60,17 @@ def anthropic_sse_streaming_response()+def openai_responses_sse_streaming_response(+ body: AsyncIterator[str],+) -> StreamingResponse:+ """Return a streaming response for OpenAI Responses-style SSE."""+ return StreamingResponse(+ body,+ media_type="text/event-stream",+ headers=OPENAI_RESPONSES_SSE_HEADERS,+ )++def _http_status_for_unexpected_service_exception(_exc: BaseException) -> int:"""HTTP status for uncaught non-provider failures (stable client contract)."""return 500@@ -218,6 +241,59 @@ class ClaudeProxyService:detail=get_user_facing_error_message(e),) from e+ async def create_response(self, request_data: OpenAIResponsesRequest) -> object:+ """Create an OpenAI Responses-compatible response through the provider router."""++ request_payload = request_data.model_dump(mode="json", exclude_none=True)+ try:+ anthropic_payload = responses_request_to_anthropic_payload(request_payload)+ result = self.create_message(MessagesRequest(**anthropic_payload))+ except ResponsesConversionError as exc:+ invalid_request = InvalidRequestError(str(exc))+ return JSONResponse(+ status_code=invalid_request.status_code,+ content=openai_error_payload(+ message=invalid_request.message,+ error_type=invalid_request.error_type,+ ),+ )+ except ProviderError as exc:+ return JSONResponse(+ status_code=exc.status_code,+ content=openai_error_payload(+ message=exc.message,+ error_type=exc.error_type,+ ),+ )++ if request_data.stream is False:+ if isinstance(result, StreamingResponse):+ return await collect_openai_response_from_anthropic_sse(+ result.body_iterator,+ request_payload,+ )+ return anthropic_message_response_to_openai_response(+ _model_dump_json(result),+ request_payload,+ )++ if isinstance(result, StreamingResponse):+ return openai_responses_sse_streaming_response(+ iter_anthropic_sse_as_openai_responses(+ result.body_iterator,+ request_payload,+ )+ )++ return openai_responses_sse_streaming_response(+ _iter_static_response_sse(+ iter_message_response_as_openai_responses(+ _model_dump_json(result),+ request_payload,+ )+ )+ )+def count_tokens(self, request_data: TokenCountRequest) -> TokenCountResponse:"""Count tokens for a request after applying configured model routing."""request_id = f"req_{uuid.uuid4().hex[:12]}"@@ -260,3 +336,17 @@ class ClaudeProxyService:status_code=_http_status_for_unexpected_service_exception(e),detail=get_user_facing_error_message(e),) from e+++def _model_dump_json(value: object) -> dict[str, Any]:+ if isinstance(value, BaseModel):+ dumped = value.model_dump(mode="json")+ return dumped if isinstance(dumped, dict) else {}+ if isinstance(value, dict):+ return {str(key): item for key, item in value.items()}+ return {}+++async def _iter_static_response_sse(chunks: list[str]) -> AsyncIterator[str]:+ for chunk in chunks:+ yield chunkdiff --git a/cli/adapters/__init__.py b/cli/adapters/__init__.pynew file mode 100644index 00000000..0777e59b--- /dev/null+++ b/cli/adapters/__init__.py@@ -0,0 +1,14 @@+"""Client CLI adapter implementations."""++from .claude import CLAUDE_CLI_ADAPTER, ClaudeCliAdapter+from .codex import CODEX_CLI_ADAPTER, CodexCliAdapter+from .registry import DEFAULT_CLIENT_CLI_ID, get_client_cli_adapter++__all__ = [+ "CLAUDE_CLI_ADAPTER",+ "CODEX_CLI_ADAPTER",+ "DEFAULT_CLIENT_CLI_ID",+ "ClaudeCliAdapter",+ "CodexCliAdapter",+ "get_client_cli_adapter",+]diff --git a/cli/adapters/base.py b/cli/adapters/base.pynew file mode 100644index 00000000..bfea80a8--- /dev/null+++ b/cli/adapters/base.py@@ -0,0 +1,89 @@+"""Shared contracts for client CLI subprocess adapters."""++from __future__ import annotations++from collections.abc import Iterable, Mapping+from dataclasses import dataclass, field+from typing import Any, Protocol+++@dataclass(frozen=True, slots=True)+class CliTaskRequest:+ """A single prompt execution request for a managed client CLI process."""++ prompt: str+ session_id: str | None = None+ fork_session: bool = False+++@dataclass(frozen=True, slots=True)+class CliInvocation:+ """Concrete subprocess invocation assembled by a client CLI adapter."""++ argv: tuple[str, ...]+ env: dict[str, str]+ cwd: str+ trace_metadata: dict[str, Any] = field(default_factory=dict)+++@dataclass(slots=True)+class CliParseState:+ """Mutable line-parser state for a single client CLI process run."""++ log_raw_cli_diagnostics: bool = False+ session_id_extracted: bool = False+++class ClientCliAdapter(Protocol):+ """Adapter boundary for client CLI command/env construction and output parsing."""++ id: str+ display_name: str+ default_binary: str+ install_hint: str+ trace_stage: str+ process_launch_event: str+ trace_source: str++ def build_task_invocation(+ self,+ *,+ config: Any,+ request: CliTaskRequest,+ base_env: Mapping[str, str],+ ) -> CliInvocation:+ """Build the subprocess invocation for a managed task run."""+ ...++ def parse_stdout_line(self, line: str, state: CliParseState) -> Iterable[Any]:+ """Parse one stdout line into parser-ready internal CLI events."""+ ...++ def extract_session_id(self, event: Any) -> str | None:+ """Extract a persistent client CLI session id from a parsed event."""+ ...++ def get_launcher_binary_name(self, settings: Any) -> str:+ """Return the configured executable name for a wrapper entrypoint."""+ ...++ def build_launcher_command(+ self,+ *,+ binary_path: str,+ argv: Iterable[str],+ settings: Any,+ proxy_root_url: str,+ ) -> list[str]:+ """Build the wrapper subprocess command for a client CLI launch."""+ ...++ def build_launcher_env(+ self,+ *,+ proxy_root_url: str,+ auth_token: str,+ base_env: Mapping[str, str],+ ) -> dict[str, str]:+ """Build environment variables for a wrapper-launched client CLI."""+ ...diff --git a/cli/adapters/claude.py b/cli/adapters/claude.pynew file mode 100644index 00000000..f4402079--- /dev/null+++ b/cli/adapters/claude.py@@ -0,0 +1,233 @@+"""Claude Code client CLI adapter."""++from __future__ import annotations++import json+from collections.abc import Iterable, Mapping+from typing import Any++from loguru import logger++from .base import CliInvocation, CliParseState, CliTaskRequest++_AUTO_COMPACT_WINDOW = "190000"+++class ClaudeCliAdapter:+ """Client CLI adapter for Claude Code."""++ id = "claude"+ display_name = "Claude Code"+ default_binary = "claude"+ install_hint = "Install Claude Code with: npm install -g @anthropic-ai/claude-code"+ trace_stage = "claude_cli"+ process_launch_event = "claude_cli.process.launch"+ trace_source = "claude_cli"++ def build_task_invocation(+ self,+ *,+ config: Any,+ request: CliTaskRequest,+ base_env: Mapping[str, str],+ ) -> CliInvocation:+ """Build a Claude Code stream-json subprocess invocation."""++ env = self._task_env(+ api_url=config.api_url,+ auth_token=config.auth_token,+ base_env=base_env,+ )+ cmd = self._task_command(+ claude_bin=config.claude_bin,+ prompt=request.prompt,+ session_id=request.session_id,+ fork_session=request.fork_session,+ allowed_dirs=config.allowed_dirs,+ plans_directory=config.plans_directory,+ )++ resume_session_id = (+ request.session_id+ if request.session_id and not request.session_id.startswith("pending_")+ else None+ )+ return CliInvocation(+ argv=tuple(cmd),+ env=env,+ cwd=config.workspace_path,+ trace_metadata={+ "client_cli_id": self.id,+ "resume_session_id": resume_session_id,+ "fork_session": request.fork_session,+ "prompt": request.prompt,+ "cwd": config.workspace_path,+ "claude_binary": config.claude_bin,+ "cli_argv": cmd,+ },+ )++ def parse_stdout_line(self, line: str, state: CliParseState) -> Iterable[Any]:+ """Parse one Claude Code JSONL line into existing parser-ready events."""++ try:+ event = json.loads(line)+ except json.JSONDecodeError:+ if state.log_raw_cli_diagnostics:+ logger.debug("Non-JSON output: {}", line)+ else:+ logger.debug("Non-JSON CLI line: char_len={}", len(line))+ yield {"type": "raw", "content": line}+ return++ if not state.session_id_extracted:+ extracted_id = self.extract_session_id(event)+ if extracted_id:+ state.session_id_extracted = True+ logger.info(f"Extracted session ID: {extracted_id}")+ yield {"type": "session_info", "session_id": extracted_id}++ yield event++ def extract_session_id(self, event: Any) -> str | None:+ """Extract a Claude Code session ID from supported event shapes."""++ if not isinstance(event, dict):+ return None++ if session_id := _string_value(event.get("session_id")):+ return session_id+ if session_id := _string_value(event.get("sessionId")):+ return session_id++ for key in ["init", "system", "result", "metadata"]:+ nested = event.get(key)+ if not isinstance(nested, dict):+ continue+ if session_id := _string_value(nested.get("session_id")):+ return session_id+ if session_id := _string_value(nested.get("sessionId")):+ return session_id++ conv = event.get("conversation")+ if isinstance(conv, dict):+ return _string_value(conv.get("id"))++ return None++ def get_launcher_binary_name(self, settings: Any) -> str:+ """Return the configured Claude Code binary name."""++ configured = getattr(settings, "claude_cli_bin", "")+ return configured or self.default_binary++ def build_launcher_command(+ self,+ *,+ binary_path: str,+ argv: Iterable[str],+ settings: Any,+ proxy_root_url: str,+ ) -> list[str]:+ """Return the Claude wrapper command without changing user arguments."""++ return [binary_path, *argv]++ def build_launcher_env(+ self,+ *,+ proxy_root_url: str,+ auth_token: str,+ base_env: Mapping[str, str],+ ) -> dict[str, str]:+ """Return a Claude Code environment that targets the local proxy."""++ env = {+ key: value+ for key, value in base_env.items()+ if not key.startswith("ANTHROPIC_")+ }+ env["ANTHROPIC_BASE_URL"] = proxy_root_url+ env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1"+ env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = _AUTO_COMPACT_WINDOW+ if token := auth_token.strip():+ env["ANTHROPIC_AUTH_TOKEN"] = token+ return env++ def _task_env(+ self,+ *,+ api_url: str,+ auth_token: str,+ base_env: Mapping[str, str],+ ) -> dict[str, str]:+ env = dict(base_env)+ env["ANTHROPIC_API_URL"] = api_url+ if api_url.endswith("/v1"):+ env["ANTHROPIC_BASE_URL"] = api_url[:-3]+ else:+ env["ANTHROPIC_BASE_URL"] = api_url+ env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1"+ env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = _AUTO_COMPACT_WINDOW+ env.pop("ANTHROPIC_API_KEY", None)+ if token := auth_token.strip():+ env["ANTHROPIC_AUTH_TOKEN"] = token+ else:+ env.pop("ANTHROPIC_AUTH_TOKEN", None)++ env["TERM"] = "dumb"+ env["PYTHONIOENCODING"] = "utf-8"+ return env++ def _task_command(+ self,+ *,+ claude_bin: str,+ prompt: str,+ session_id: str | None,+ fork_session: bool,+ allowed_dirs: list[str],+ plans_directory: str | None,+ ) -> list[str]:+ if session_id and not session_id.startswith("pending_"):+ cmd = [+ claude_bin,+ "--resume",+ session_id,+ ]+ if fork_session:+ cmd.append("--fork-session")+ cmd += [+ "-p",+ prompt,+ "--output-format",+ "stream-json",+ "--dangerously-skip-permissions",+ "--verbose",+ ]+ else:+ cmd = [+ claude_bin,+ "-p",+ prompt,+ "--output-format",+ "stream-json",+ "--dangerously-skip-permissions",+ "--verbose",+ ]++ for directory in allowed_dirs:+ cmd.extend(["--add-dir", directory])++ if plans_directory is not None:+ settings_json = json.dumps({"plansDirectory": plans_directory})+ cmd.extend(["--settings", settings_json])++ return cmd+++def _string_value(value: Any) -> str | None:+ return value if isinstance(value, str) else None+++CLAUDE_CLI_ADAPTER = ClaudeCliAdapter()diff --git a/cli/adapters/codex.py b/cli/adapters/codex.pynew file mode 100644index 00000000..3b1cffd0--- /dev/null+++ b/cli/adapters/codex.py@@ -0,0 +1,352 @@+"""Codex CLI adapter."""++from __future__ import annotations++import json+from collections.abc import Iterable, Mapping+from typing import Any++from loguru import logger++from .base import CliInvocation, CliParseState, CliTaskRequest++_CODEX_AUTH_ENV_KEY = "FCC_CODEX_API_KEY"+_STRIPPED_CODEX_ENV_KEYS = frozenset(+ {+ "OPENAI_API_KEY",+ "OPENAI_BASE_URL",+ "OPENAI_API_BASE",+ "OPENAI_ORG_ID",+ "OPENAI_ORGANIZATION",+ "CODEX_API_KEY",+ _CODEX_AUTH_ENV_KEY,+ }+)+++class CodexCliAdapter:+ """Client CLI adapter for OpenAI Codex CLI."""++ id = "codex"+ display_name = "Codex CLI"+ default_binary = "codex"+ install_hint = "Install Codex with: npm install -g @openai/codex"+ trace_stage = "codex_cli"+ process_launch_event = "codex_cli.process.launch"+ trace_source = "codex_cli"++ def build_task_invocation(+ self,+ *,+ config: Any,+ request: CliTaskRequest,+ base_env: Mapping[str, str],+ ) -> CliInvocation:+ """Build a Codex JSONL subprocess invocation for managed messaging."""++ env = self._task_env(+ api_url=config.api_url,+ auth_token=config.auth_token,+ base_env=base_env,+ )+ codex_bin = getattr(config, "codex_bin", None) or self.default_binary+ cmd = self._task_command(+ codex_bin=codex_bin,+ prompt=request.prompt,+ session_id=request.session_id,+ fork_session=request.fork_session,+ api_url=config.api_url,+ allowed_dirs=config.allowed_dirs,+ workspace_path=config.workspace_path,+ )+ resume_session_id = (+ request.session_id+ if request.session_id+ and not request.session_id.startswith("pending_")+ and not request.fork_session+ else None+ )+ return CliInvocation(+ argv=tuple(cmd),+ env=env,+ cwd=config.workspace_path,+ trace_metadata={+ "client_cli_id": self.id,+ "resume_session_id": resume_session_id,+ "fork_session": request.fork_session,+ "prompt": request.prompt,+ "cwd": config.workspace_path,+ "codex_binary": codex_bin,+ "cli_argv": cmd,+ },+ )++ def parse_stdout_line(self, line: str, state: CliParseState) -> Iterable[Any]:+ """Parse one Codex JSONL line into existing parser-ready events."""++ try:+ event = json.loads(line)+ except json.JSONDecodeError:+ if state.log_raw_cli_diagnostics:+ logger.debug("Non-JSON Codex output: {}", line)+ else:+ logger.debug("Non-JSON Codex CLI line: char_len={}", len(line))+ yield {"type": "raw", "content": line}+ return++ if not state.session_id_extracted:+ extracted_id = self.extract_session_id(event)+ if extracted_id:+ state.session_id_extracted = True+ logger.info("Extracted Codex session ID: {}", extracted_id)+ yield {"type": "session_info", "session_id": extracted_id}++ mapped = list(_codex_event_to_parser_events(event))+ if mapped:+ yield from mapped+ return++ yield {"type": "raw", "content": line}++ def extract_session_id(self, event: Any) -> str | None:+ """Extract a Codex session or thread id from supported event shapes."""++ if not isinstance(event, dict):+ return None+ for key in ("session_id", "sessionId", "thread_id", "threadId"):+ if session_id := _string_value(event.get(key)):+ return session_id+ for key in ("thread", "session", "conversation", "metadata"):+ nested = event.get(key)+ if not isinstance(nested, dict):+ continue+ for nested_key in ("id", "session_id", "thread_id", "conversation_id"):+ if session_id := _string_value(nested.get(nested_key)):+ return session_id+ return None++ def get_launcher_binary_name(self, settings: Any) -> str:+ """Return the configured Codex binary name."""++ configured = getattr(settings, "codex_cli_bin", "")+ return configured or self.default_binary++ def build_launcher_command(+ self,+ *,+ binary_path: str,+ argv: Iterable[str],+ settings: Any,+ proxy_root_url: str,+ ) -> list[str]:+ """Return a Codex command with ephemeral FCC provider config."""++ return [+ binary_path,+ *self._codex_config_args(+ api_url=_ensure_v1_url(proxy_root_url),+ model=getattr(settings, "model", None),+ ),+ *argv,+ ]++ def build_launcher_env(+ self,+ *,+ proxy_root_url: str,+ auth_token: str,+ base_env: Mapping[str, str],+ ) -> dict[str, str]:+ """Return a Codex environment that targets the local proxy provider."""++ env = _base_codex_env(base_env)+ env[_CODEX_AUTH_ENV_KEY] = auth_token.strip() or "fcc-no-auth"+ return env++ def _task_env(+ self,+ *,+ api_url: str,+ auth_token: str,+ base_env: Mapping[str, str],+ ) -> dict[str, str]:+ env = _base_codex_env(base_env)+ env[_CODEX_AUTH_ENV_KEY] = auth_token.strip() or "fcc-no-auth"+ env["TERM"] = "dumb"+ env["PYTHONIOENCODING"] = "utf-8"+ return env++ def _task_command(+ self,+ *,+ codex_bin: str,+ prompt: str,+ session_id: str | None,+ fork_session: bool,+ api_url: str,+ allowed_dirs: list[str],+ workspace_path: str,+ ) -> list[str]:+ common_args = [+ "--json",+ "--skip-git-repo-check",+ "--dangerously-bypass-approvals-and-sandbox",+ *self._codex_config_args(api_url=api_url),+ ]+ if session_id and not session_id.startswith("pending_") and not fork_session:+ return [+ codex_bin,+ "exec",+ "resume",+ *common_args,+ session_id,+ prompt,+ ]++ cmd = [+ codex_bin,+ "exec",+ *common_args,+ "-C",+ workspace_path,+ ]+ for directory in allowed_dirs:+ cmd.extend(["--add-dir", directory])+ cmd.append(prompt)+ return cmd++ def _codex_config_args(+ self, *, api_url: str, model: str | None = None+ ) -> list[str]:+ args = [+ "-c",+ _toml_assignment("model_provider", "fcc"),+ "-c",+ _toml_assignment("model_providers.fcc.name", "Free Claude Code"),+ "-c",+ _toml_assignment("model_providers.fcc.base_url", _ensure_v1_url(api_url)),+ "-c",+ _toml_assignment("model_providers.fcc.env_key", _CODEX_AUTH_ENV_KEY),+ "-c",+ _toml_assignment("model_providers.fcc.wire_api", "responses"),+ ]+ if model:+ args.extend(["-c", _toml_assignment("model", model)])+ return args+++def _codex_event_to_parser_events(event: dict[str, Any]) -> Iterable[dict[str, Any]]:+ event_type = event.get("type")+ if event_type in {"error", "turn.failed"}:+ yield {"type": "error", "error": {"message": _event_message(event)}}+ return+ if event_type == "response.output_text.delta":+ yield {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": str(event.get("delta", ""))},+ }+ return+ if event_type in {"agent_message", "assistant_message"}:+ text = _event_message(event)+ if text:+ yield {+ "type": "assistant",+ "message": {"content": [{"type": "text", "text": text}]},+ }+ return+ if event_type == "response.output_item.done":+ item = event.get("item")+ if isinstance(item, dict):+ yield from _responses_item_to_parser_events(item)+ return+ if event_type == "response.completed":+ response = event.get("response")+ output = response.get("output") if isinstance(response, dict) else None+ if isinstance(output, list):+ for item in output:+ if isinstance(item, dict):+ yield from _responses_item_to_parser_events(item)+ return+++def _responses_item_to_parser_events(+ item: Mapping[str, Any],+) -> Iterable[dict[str, Any]]:+ item_type = item.get("type")+ if item_type == "message":+ text_parts: list[str] = []+ content = item.get("content")+ if isinstance(content, list):+ text_parts.extend(+ str(part.get("text", ""))+ for part in content+ if isinstance(part, dict) and part.get("type") == "output_text"+ )+ text = "".join(text_parts)+ if text:+ yield {+ "type": "assistant",+ "message": {"content": [{"type": "text", "text": text}]},+ }+ return+ if item_type == "function_call":+ yield {+ "type": "assistant",+ "message": {+ "content": [+ {+ "type": "tool_use",+ "id": str(item.get("call_id", item.get("id", ""))),+ "name": str(item.get("name", "")),+ "input": _safe_json_object(item.get("arguments")),+ }+ ]+ },+ }+++def _event_message(event: Mapping[str, Any]) -> str:+ for key in ("message", "text", "content", "error"):+ value = event.get(key)+ if isinstance(value, str):+ return value+ if isinstance(value, dict) and isinstance(value.get("message"), str):+ return str(value["message"])+ return ""+++def _safe_json_object(value: Any) -> dict[str, Any]:+ if isinstance(value, dict):+ return value+ if not isinstance(value, str) or not value:+ return {}+ try:+ parsed = json.loads(value)+ except json.JSONDecodeError:+ return {}+ return parsed if isinstance(parsed, dict) else {}+++def _base_codex_env(base_env: Mapping[str, str]) -> dict[str, str]:+ return {+ key: value+ for key, value in base_env.items()+ if key not in _STRIPPED_CODEX_ENV_KEYS and not key.startswith("OPENAI_")+ }+++def _ensure_v1_url(url: str) -> str:+ stripped = url.rstrip("/")+ return stripped if stripped.endswith("/v1") else f"{stripped}/v1"+++def _toml_assignment(key: str, value: str) -> str:+ return f"{key}={json.dumps(value)}"+++def _string_value(value: Any) -> str | None:+ return value if isinstance(value, str) else None+++CODEX_CLI_ADAPTER = CodexCliAdapter()diff --git a/cli/adapters/registry.py b/cli/adapters/registry.pynew file mode 100644index 00000000..10bfb3c0--- /dev/null+++ b/cli/adapters/registry.py@@ -0,0 +1,25 @@+"""Internal client CLI adapter registry."""++from __future__ import annotations++from .base import ClientCliAdapter+from .claude import CLAUDE_CLI_ADAPTER+from .codex import CODEX_CLI_ADAPTER++DEFAULT_CLIENT_CLI_ID = "claude"++_ADAPTERS: dict[str, ClientCliAdapter] = {+ CLAUDE_CLI_ADAPTER.id: CLAUDE_CLI_ADAPTER,+ CODEX_CLI_ADAPTER.id: CODEX_CLI_ADAPTER,+}+++def get_client_cli_adapter(+ client_cli_id: str = DEFAULT_CLIENT_CLI_ID,+) -> ClientCliAdapter:+ """Return a registered client CLI adapter by id."""++ try:+ return _ADAPTERS[client_cli_id]+ except KeyError as exc:+ raise ValueError(f"Unknown client CLI adapter: {client_cli_id}") from excdiff --git a/cli/entrypoints.py b/cli/entrypoints.pyindex 2da2ed31..d1cc823d 100644--- a/cli/entrypoints.py+++ b/cli/entrypoints.py@@ -18,6 +18,9 @@ import uvicornfrom api.admin_urls import local_admin_url, local_proxy_root_urlfrom api.app import GracefulLifespanApp, create_app+from cli.adapters.base import ClientCliAdapter+from cli.adapters.claude import CLAUDE_CLI_ADAPTER+from cli.adapters.codex import CODEX_CLI_ADAPTERfrom cli.process_registry import (kill_all_best_effort,kill_pid_tree_best_effort,@@ -174,18 +177,11 @@ def _claude_child_env() -> dict[str, str]:"""Return a Claude Code environment that targets this proxy."""- env = {- key: value- for key, value in base_env.items()- if not key.startswith("ANTHROPIC_")- }- env.pop("ANTHROPIC_API_KEY", None)- env["ANTHROPIC_BASE_URL"] = local_proxy_root_url(settings)- env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1"- env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = "190000"- if token := settings.anthropic_auth_token.strip():- env["ANTHROPIC_AUTH_TOKEN"] = token- return env+ return CLAUDE_CLI_ADAPTER.build_launcher_env(+ proxy_root_url=local_proxy_root_url(settings),+ auth_token=settings.anthropic_auth_token,+ base_env=base_env,+ )def _preflight_proxy(proxy_root_url: str) -> str | None:@@ -211,6 +207,20 @@ def _preflight_proxy(proxy_root_url: str) -> str | None:def launch_claude(argv: Sequence[str] | None = None) -> None:"""Launch Claude Code with Free Claude Code proxy environment variables."""+ _launch_client_cli(CLAUDE_CLI_ADAPTER, argv)+++def launch_codex(argv: Sequence[str] | None = None) -> None:+ """Launch Codex CLI with Free Claude Code proxy configuration."""++ _launch_client_cli(CODEX_CLI_ADAPTER, argv)+++def _launch_client_cli(+ adapter: ClientCliAdapter, argv: Sequence[str] | None = None+) -> None:+ """Launch a client CLI with Free Claude Code proxy environment variables."""+settings = get_settings()proxy_root_url = local_proxy_root_url(settings)if error := _preflight_proxy(proxy_root_url):@@ -222,20 +232,27 @@ def launch_claude(argv: Sequence[str] | None = None) -> None:raise SystemExit(1)args = list(sys.argv[1:] if argv is None else argv)- claude_command = shutil.which(settings.claude_cli_bin)- if claude_command is None:+ binary_name = adapter.get_launcher_binary_name(settings)+ client_command = shutil.which(binary_name)+ if client_command is None:print(- f"Could not find Claude Code command: {settings.claude_cli_bin}",- file=sys.stderr,- )- print(- "Install Claude Code with: npm install -g @anthropic-ai/claude-code",+ f"Could not find {adapter.display_name} command: {binary_name}",file=sys.stderr,)+ print(adapter.install_hint, file=sys.stderr)raise SystemExit(127)- command = [claude_command, *args]- env = _claude_child_env(settings, os.environ)+ command = adapter.build_launcher_command(+ binary_path=client_command,+ argv=args,+ settings=settings,+ proxy_root_url=proxy_root_url,+ )+ env = adapter.build_launcher_env(+ proxy_root_url=proxy_root_url,+ auth_token=settings.anthropic_auth_token,+ base_env=os.environ,+ )process: subprocess.Popen[bytes] | None = Nonetry:process = subprocess.Popen(command, env=env)@@ -244,13 +261,10 @@ def launch_claude(argv: Sequence[str] | None = None) -> None:return_code = process.wait()except FileNotFoundError:print(- f"Could not find Claude Code command: {settings.claude_cli_bin}",- file=sys.stderr,- )- print(- "Install Claude Code with: npm install -g @anthropic-ai/claude-code",+ f"Could not find {adapter.display_name} command: {binary_name}",file=sys.stderr,)+ print(adapter.install_hint, file=sys.stderr)raise SystemExit(127) from Noneexcept KeyboardInterrupt:if process is not None and process.pid:diff --git a/cli/manager.py b/cli/manager.pyindex 303c01e0..7f080f0b 100644--- a/cli/manager.py+++ b/cli/manager.py@@ -11,6 +11,8 @@ import uuidfrom loguru import logger+from .adapters.base import ClientCliAdapter+from .adapters.registry import get_client_cli_adapterfrom .session import CLISession@@ -31,6 +33,7 @@ class CLISessionManager:claude_bin: str = "claude",auth_token: str = "",*,+ client_cli_adapter: ClientCliAdapter | None = None,log_raw_cli_diagnostics: bool = False,log_messaging_error_details: bool = False,):@@ -49,6 +52,7 @@ class CLISessionManager:self.plans_directory = plans_directoryself.claude_bin = claude_binself.auth_token = auth_token+ self._client_cli_adapter = client_cli_adapter or get_client_cli_adapter()self._log_raw_cli_diagnostics = log_raw_cli_diagnosticsself._log_messaging_error_details = log_messaging_error_details@@ -85,6 +89,7 @@ class CLISessionManager:plans_directory=self.plans_directory,claude_bin=self.claude_bin,auth_token=self.auth_token,+ client_cli_adapter=self._client_cli_adapter,log_raw_cli_diagnostics=self._log_raw_cli_diagnostics,)self._pending_sessions[temp_id] = new_sessiondiff --git a/cli/session.py b/cli/session.pyindex fc11f62f..19801fd3 100644--- a/cli/session.py+++ b/cli/session.py@@ -1,7 +1,6 @@"""Claude Code CLI session management."""import asyncio-import jsonimport osfrom collections.abc import AsyncGeneratorfrom dataclasses import dataclass, field@@ -11,6 +10,8 @@ from loguru import loggerfrom core.trace import trace_event+from .adapters.base import ClientCliAdapter, CliParseState, CliTaskRequest+from .adapters.registry import get_client_cli_adapterfrom .process_registry import kill_pid_tree_best_effort, register_pid, unregister_pid# Cap stderr capture so a runaway child cannot exhaust memory; pipe is still drained.@@ -41,6 +42,7 @@ class CLISession:claude_bin: str = "claude",auth_token: str = "",*,+ client_cli_adapter: ClientCliAdapter | None = None,log_raw_cli_diagnostics: bool = False,):self.config = ClaudeCliConfig(@@ -57,6 +59,7 @@ class CLISession:self.plans_directory = self.config.plans_directoryself.claude_bin = self.config.claude_binself.auth_token = self.config.auth_token+ self._client_cli_adapter = client_cli_adapter or get_client_cli_adapter()self._log_raw_cli_diagnostics = log_raw_cli_diagnosticsself.process: asyncio.subprocess.Process | None = Noneself.current_session_id: str | None = None@@ -111,83 +114,30 @@ class CLISession:"""async with self._cli_lock:self._is_busy = True- env = os.environ.copy()-- env["ANTHROPIC_API_URL"] = self.api_url- if self.api_url.endswith("/v1"):- env["ANTHROPIC_BASE_URL"] = self.api_url[:-3]- else:- env["ANTHROPIC_BASE_URL"] = self.api_url- env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1"- env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = "190000"- env.pop("ANTHROPIC_API_KEY", None)- if token := self.auth_token.strip():- env["ANTHROPIC_AUTH_TOKEN"] = token- else:- env.pop("ANTHROPIC_AUTH_TOKEN", None)-- env["TERM"] = "dumb"- env["PYTHONIOENCODING"] = "utf-8"-- # Build command- if session_id and not session_id.startswith("pending_"):- cmd = [- self.claude_bin,- "--resume",- session_id,- ]- if fork_session:- cmd.append("--fork-session")- cmd += [- "-p",- prompt,- "--output-format",- "stream-json",- "--dangerously-skip-permissions",- "--verbose",- ]- else:- cmd = [- self.claude_bin,- "-p",- prompt,- "--output-format",- "stream-json",- "--dangerously-skip-permissions",- "--verbose",- ]-- if self.allowed_dirs:- for d in self.allowed_dirs:- cmd.extend(["--add-dir", d])-- if self.plans_directory is not None:- settings_json = json.dumps({"plansDirectory": self.plans_directory})- cmd.extend(["--settings", settings_json])+ invocation = self._client_cli_adapter.build_task_invocation(+ config=self.config,+ request=CliTaskRequest(+ prompt=prompt,+ session_id=session_id,+ fork_session=fork_session,+ ),+ base_env=os.environ,+ )trace_event(- stage="claude_cli",- event="claude_cli.process.launch",- source="claude_cli",- resume_session_id=(- session_id- if session_id and not session_id.startswith("pending_")- else None- ),- fork_session=fork_session,- prompt=prompt,- cwd=self.workspace,- claude_binary=self.claude_bin,- cli_argv=cmd,+ stage=self._client_cli_adapter.trace_stage,+ event=self._client_cli_adapter.process_launch_event,+ source=self._client_cli_adapter.trace_source,+ **invocation.trace_metadata,)try:self.process = await asyncio.create_subprocess_exec(- *cmd,+ *invocation.argv,stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.PIPE,- cwd=self.workspace,- env=env,+ cwd=invocation.cwd,+ env=invocation.env,)if self.process and self.process.pid:register_pid(self.process.pid)@@ -196,7 +146,9 @@ class CLISession:yield {"type": "exit", "code": 1}return- session_id_extracted = False+ parse_state = CliParseState(+ log_raw_cli_diagnostics=self._log_raw_cli_diagnostics+ )buffer = bytearray()stderr_task: asyncio.Task[bytes] | None = Noneif self.process.stderr:@@ -214,10 +166,8 @@ class CLISession:).strip()if line_str:async for event in self._handle_line_gen(- line_str, session_id_extracted+ line_str, parse_state):- if event.get("type") == "session_info":- session_id_extracted = Trueyield eventbreak@@ -234,10 +184,8 @@ class CLISession:line_str = line.decode("utf-8", errors="replace").strip()if line_str:async for event in self._handle_line_gen(- line_str, session_id_extracted+ line_str, parse_state):- if event.get("type") == "session_info":- session_id_extracted = Trueyield eventexcept asyncio.CancelledError:# Cancelling the handler task should not leave a Claude CLI@@ -283,50 +231,19 @@ class CLISession:unregister_pid(self.process.pid)async def _handle_line_gen(- self, line_str: str, session_id_extracted: bool+ self, line_str: str, parse_state: CliParseState) -> AsyncGenerator[dict]:"""Process a single line and yield events."""- try:- event = json.loads(line_str)- if not session_id_extracted:- extracted_id = self._extract_session_id(event)- if extracted_id:- self.current_session_id = extracted_id- logger.info(f"Extracted session ID: {extracted_id}")- yield {"type": "session_info", "session_id": extracted_id}-+ for event in self._client_cli_adapter.parse_stdout_line(line_str, parse_state):+ if isinstance(event, dict) and event.get("type") == "session_info":+ session_id = event.get("session_id")+ if isinstance(session_id, str):+ self.current_session_id = session_idyield event- except json.JSONDecodeError:- if self._log_raw_cli_diagnostics:- logger.debug("Non-JSON output: {}", line_str)- else:- logger.debug("Non-JSON CLI line: char_len={}", len(line_str))- yield {"type": "raw", "content": line_str}def _extract_session_id(self, event: Any) -> str | None:"""Extract session ID from CLI event."""- if not isinstance(event, dict):- return None-- if "session_id" in event:- return event["session_id"]- if "sessionId" in event:- return event["sessionId"]-- for key in ["init", "system", "result", "metadata"]:- if key in event and isinstance(event[key], dict):- nested = event[key]- if "session_id" in nested:- return nested["session_id"]- if "sessionId" in nested:- return nested["sessionId"]-- if "conversation" in event and isinstance(event["conversation"], dict):- conv = event["conversation"]- if "id" in conv:- return conv["id"]-- return None+ return self._client_cli_adapter.extract_session_id(event)async def stop(self):"""Stop the CLI process."""diff --git a/config/settings.py b/config/settings.pyindex ba49ae41..ddd20268 100644--- a/config/settings.py+++ b/config/settings.py@@ -342,6 +342,12 @@ class Settings(BaseSettings):return "claude"+ @property+ def codex_cli_bin(self) -> str:+ """Return the fixed Codex CLI binary name."""++ return "codex"+@field_validator("whisper_device")@classmethoddef validate_whisper_device(cls, v: str) -> str:diff --git a/core/openai_responses/__init__.py b/core/openai_responses/__init__.pynew file mode 100644index 00000000..2c1aa58b--- /dev/null+++ b/core/openai_responses/__init__.py@@ -0,0 +1,27 @@+"""OpenAI Responses compatibility helpers."""++from .conversion import (+ ResponsesConversionError,+ anthropic_message_response_to_openai_response,+ openai_error_payload,+ responses_request_to_anthropic_payload,+)+from .sse import (+ OPENAI_RESPONSES_SSE_HEADERS,+ collect_openai_response_from_anthropic_sse,+ format_response_sse_event,+ iter_anthropic_sse_as_openai_responses,+ iter_message_response_as_openai_responses,+)++__all__ = [+ "OPENAI_RESPONSES_SSE_HEADERS",+ "ResponsesConversionError",+ "anthropic_message_response_to_openai_response",+ "collect_openai_response_from_anthropic_sse",+ "format_response_sse_event",+ "iter_anthropic_sse_as_openai_responses",+ "iter_message_response_as_openai_responses",+ "openai_error_payload",+ "responses_request_to_anthropic_payload",+]diff --git a/core/openai_responses/conversion.py b/core/openai_responses/conversion.pynew file mode 100644index 00000000..d9c7d656--- /dev/null+++ b/core/openai_responses/conversion.py@@ -0,0 +1,415 @@+"""Convert between OpenAI Responses payloads and Anthropic-style payloads."""++from __future__ import annotations++import json+import time+import uuid+from collections.abc import Mapping+from typing import Any+++class ResponsesConversionError(ValueError):+ """Raised when a Responses request cannot be converted deterministically."""+++def responses_request_to_anthropic_payload(+ request: Mapping[str, Any],+) -> dict[str, Any]:+ """Convert an OpenAI Responses request into an Anthropic Messages payload."""++ system_parts: list[str] = []+ if instructions := _optional_str(request.get("instructions")):+ system_parts.append(instructions)++ messages: list[dict[str, Any]] = []+ for item in _iter_input_items(request.get("input")):+ _append_input_item(item, messages=messages, system_parts=system_parts)++ if not messages:+ raise ResponsesConversionError("Responses request input must contain a message")++ payload: dict[str, Any] = {+ "model": _required_str(request.get("model"), "model"),+ "messages": messages,+ "stream": True,+ }+ if system_parts:+ payload["system"] = "\n\n".join(system_parts)+ _copy_if_present(request, payload, "temperature")+ _copy_if_present(request, payload, "top_p")+ if request.get("max_output_tokens") is not None:+ payload["max_tokens"] = request["max_output_tokens"]+ if isinstance(request.get("metadata"), dict):+ payload["metadata"] = request["metadata"]++ raw_tool_choice = request.get("tool_choice")+ tools = _convert_tools(request.get("tools"))+ if tools and raw_tool_choice != "none":+ payload["tools"] = tools+ tool_choice = _convert_tool_choice(raw_tool_choice)+ if tool_choice is not None:+ payload["tool_choice"] = tool_choice++ return payload+++def anthropic_message_response_to_openai_response(+ message: Mapping[str, Any],+ request: Mapping[str, Any],+ *,+ response_id: str | None = None,+ status: str = "completed",+) -> dict[str, Any]:+ """Convert a complete Anthropic message response into a Responses object."""++ response_id = response_id or _new_response_id()+ output: list[dict[str, Any]] = []+ text_parts: list[str] = []+ for block in _message_content_blocks(message):+ block_type = block.get("type")+ if block_type == "text":+ text_parts.append(str(block.get("text", "")))+ elif block_type == "tool_use":+ output.append(+ _function_call_item(+ block_id=str(block.get("id", "") or _new_call_id()),+ name=str(block.get("name", "")),+ arguments=json.dumps(block.get("input") or {}),+ status="completed",+ )+ )++ text = "".join(text_parts)+ if text:+ output.insert(0, _message_item(_new_message_item_id(), text, "completed"))++ return {+ "id": response_id,+ "object": "response",+ "created_at": int(time.time()),+ "status": status,+ "model": str(request.get("model", message.get("model", ""))),+ "output": output,+ "parallel_tool_calls": bool(request.get("parallel_tool_calls", True)),+ "tool_choice": request.get("tool_choice", "auto"),+ "temperature": request.get("temperature"),+ "top_p": request.get("top_p"),+ "max_output_tokens": request.get("max_output_tokens"),+ "usage": _openai_usage(message.get("usage")),+ "error": None if status == "completed" else {},+ }+++def openai_error_payload(*, message: str, error_type: str) -> dict[str, Any]:+ """Return an OpenAI-compatible error envelope."""++ return {+ "error": {+ "message": message,+ "type": error_type,+ "param": None,+ "code": None,+ }+ }+++def _append_input_item(+ item: Any,+ *,+ messages: list[dict[str, Any]],+ system_parts: list[str],+) -> None:+ if isinstance(item, str):+ messages.append({"role": "user", "content": item})+ return+ if not isinstance(item, dict):+ raise ResponsesConversionError(+ f"Unsupported Responses input item: {type(item).__name__}"+ )++ item_type = item.get("type")+ if item_type in (None, "message") or "role" in item:+ role = _required_str(item.get("role", "user"), "input.role")+ _append_message_item(role, item.get("content", ""), messages, system_parts)+ return+ if item_type == "function_call":+ messages.append(+ {+ "role": "assistant",+ "content": [+ {+ "type": "tool_use",+ "id": _call_id_from_item(item),+ "name": _required_str(item.get("name"), "function_call.name"),+ "input": _parse_arguments(item.get("arguments")),+ }+ ],+ }+ )+ return+ if item_type == "function_call_output":+ messages.append(+ {+ "role": "user",+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": _call_id_from_item(item),+ "content": item.get("output", ""),+ }+ ],+ }+ )+ return+ if item_type == "reasoning":+ return+ if item_type in {"input_text", "output_text", "text"}:+ messages.append({"role": "user", "content": _text_from_part(item)})+ return++ raise ResponsesConversionError(+ f"Unsupported Responses input item type: {item_type!r}"+ )+++def _append_message_item(+ role: str,+ content: Any,+ messages: list[dict[str, Any]],+ system_parts: list[str],+) -> None:+ normalized_role = "system" if role == "developer" else role+ if normalized_role == "system":+ text = _content_as_text(content)+ if text:+ system_parts.append(text)+ return+ if normalized_role not in {"user", "assistant"}:+ raise ResponsesConversionError(f"Unsupported Responses message role: {role!r}")+ messages.append(+ {+ "role": normalized_role,+ "content": _convert_message_content(content),+ }+ )+++def _iter_input_items(value: Any) -> list[Any]:+ if value is None:+ return []+ if isinstance(value, list):+ return value+ return [value]+++def _convert_message_content(content: Any) -> str | list[dict[str, Any]]:+ if isinstance(content, str):+ return content+ if isinstance(content, list):+ blocks: list[dict[str, Any]] = []+ for part in content:+ if isinstance(part, str):+ blocks.append({"type": "text", "text": part})+ continue+ if not isinstance(part, dict):+ raise ResponsesConversionError(+ f"Unsupported Responses content part: {type(part).__name__}"+ )+ part_type = part.get("type")+ if part_type in {"input_text", "output_text", "text"} or "text" in part:+ blocks.append({"type": "text", "text": _text_from_part(part)})+ continue+ if part_type == "refusal":+ blocks.append({"type": "text", "text": str(part.get("refusal", ""))})+ continue+ raise ResponsesConversionError(+ f"Unsupported Responses content part type: {part_type!r}"+ )+ return blocks+ if isinstance(content, dict):+ return [{"type": "text", "text": _text_from_part(content)}]+ raise ResponsesConversionError(+ f"Unsupported Responses message content: {type(content).__name__}"+ )+++def _content_as_text(content: Any) -> str:+ converted = _convert_message_content(content)+ if isinstance(converted, str):+ return converted+ return "\n".join(str(block.get("text", "")) for block in converted)+++def _text_from_part(part: Mapping[str, Any]) -> str:+ if text := _optional_str(part.get("text")):+ return text+ if text := _optional_str(part.get("input_text")):+ return text+ if text := _optional_str(part.get("output_text")):+ return text+ return ""+++def _convert_tools(value: Any) -> list[dict[str, Any]] | None:+ if value is None:+ return None+ if not isinstance(value, list):+ raise ResponsesConversionError("Responses tools must be a list")++ tools: list[dict[str, Any]] = []+ for tool in value:+ if not isinstance(tool, dict):+ raise ResponsesConversionError(+ f"Unsupported Responses tool: {type(tool).__name__}"+ )+ tool_type = tool.get("type")+ if tool_type != "function":+ raise ResponsesConversionError(+ f"Unsupported Responses tool type: {tool_type!r}"+ )++ function = tool.get("function")+ source = function if isinstance(function, dict) else tool+ name = _required_str(source.get("name"), "tool.name")+ schema = source.get("parameters")+ if schema is None:+ schema = {"type": "object", "properties": {}}+ if not isinstance(schema, dict):+ raise ResponsesConversionError(+ f"Responses tool {name!r} parameters must be an object"+ )+ converted: dict[str, Any] = {+ "name": name,+ "input_schema": schema,+ }+ if description := _optional_str(source.get("description")):+ converted["description"] = description+ tools.append(converted)+ return tools+++def _convert_tool_choice(value: Any) -> dict[str, Any] | None:+ if value is None or value == "auto":+ return None+ if value == "none":+ return None+ if value == "required":+ return {"type": "any"}+ if isinstance(value, dict):+ choice_type = value.get("type")+ if choice_type == "function":+ return {+ "type": "tool",+ "name": _required_str(value.get("name"), "tool_choice.name"),+ }+ if choice_type in {"auto", "any", "tool"}:+ return dict(value)+ raise ResponsesConversionError(f"Unsupported Responses tool_choice: {value!r}")+++def _parse_arguments(value: Any) -> dict[str, Any]:+ if value is None or value == "":+ return {}+ if isinstance(value, dict):+ return value+ if not isinstance(value, str):+ raise ResponsesConversionError("Responses function_call arguments must be JSON")+ try:+ parsed = json.loads(value)+ except json.JSONDecodeError as exc:+ raise ResponsesConversionError(+ f"Responses function_call arguments are invalid JSON: {exc.msg}"+ ) from exc+ if not isinstance(parsed, dict):+ raise ResponsesConversionError(+ "Responses function_call arguments must decode to an object"+ )+ return parsed+++def _call_id_from_item(item: Mapping[str, Any]) -> str:+ for key in ("call_id", "id"):+ if value := _optional_str(item.get(key)):+ return value+ return _new_call_id()+++def _required_str(value: Any, field_name: str) -> str:+ if isinstance(value, str) and value:+ return value+ raise ResponsesConversionError(+ f"Responses field {field_name} must be a non-empty string"+ )+++def _optional_str(value: Any) -> str | None:+ return value if isinstance(value, str) else None+++def _copy_if_present(+ source: Mapping[str, Any], target: dict[str, Any], field_name: str+) -> None:+ if source.get(field_name) is not None:+ target[field_name] = source[field_name]+++def _message_content_blocks(message: Mapping[str, Any]) -> list[dict[str, Any]]:+ content = message.get("content")+ if not isinstance(content, list):+ return []+ return [block for block in content if isinstance(block, dict)]+++def _message_item(item_id: str, text: str, status: str) -> dict[str, Any]:+ return {+ "id": item_id,+ "type": "message",+ "status": status,+ "role": "assistant",+ "content": [{"type": "output_text", "text": text, "annotations": []}],+ }+++def _function_call_item(+ *,+ block_id: str,+ name: str,+ arguments: str,+ status: str,+) -> dict[str, Any]:+ return {+ "id": block_id if block_id.startswith("fc_") else f"fc_{uuid.uuid4().hex[:24]}",+ "type": "function_call",+ "status": status,+ "call_id": block_id,+ "name": name,+ "arguments": arguments,+ }+++def _openai_usage(value: Any) -> dict[str, int] | None:+ if not isinstance(value, Mapping):+ return None+ input_tokens = value.get("input_tokens")+ output_tokens = value.get("output_tokens")+ return {+ "input_tokens": input_tokens if isinstance(input_tokens, int) else 0,+ "output_tokens": output_tokens if isinstance(output_tokens, int) else 0,+ "total_tokens": (+ (input_tokens if isinstance(input_tokens, int) else 0)+ + (output_tokens if isinstance(output_tokens, int) else 0)+ ),+ }+++def _new_response_id() -> str:+ return f"resp_{uuid.uuid4().hex}"+++def _new_message_item_id() -> str:+ return f"msg_{uuid.uuid4().hex}"+++def _new_call_id() -> str:+ return f"call_{uuid.uuid4().hex[:24]}"diff --git a/core/openai_responses/sse.py b/core/openai_responses/sse.pynew file mode 100644index 00000000..023532f3--- /dev/null+++ b/core/openai_responses/sse.py@@ -0,0 +1,658 @@+"""Translate Anthropic-style SSE streams into OpenAI Responses SSE streams."""++from __future__ import annotations++import json+import time+import uuid+from collections.abc import AsyncIterable, AsyncIterator, Mapping+from dataclasses import dataclass, field+from typing import Any++from .conversion import anthropic_message_response_to_openai_response++OPENAI_RESPONSES_SSE_HEADERS: dict[str, str] = {+ "X-Accel-Buffering": "no",+ "Cache-Control": "no-cache",+ "Connection": "keep-alive",+}+++def format_response_sse_event(event_type: str, data: Mapping[str, Any]) -> str:+ """Format one OpenAI Responses SSE event."""++ return f"event: {event_type}\ndata: {json.dumps(data)}\n\n"+++async def iter_anthropic_sse_as_openai_responses(+ chunks: AsyncIterable[Any],+ request: Mapping[str, Any],+) -> AsyncIterator[str]:+ """Yield Responses SSE events translated from an Anthropic SSE stream."""++ transformer = _ResponsesStreamTransformer(request)+ async for event in _iter_sse_events(chunks):+ for chunk in transformer.process_anthropic_event(event):+ yield chunk+ if transformer.terminal:+ return+ for chunk in transformer.finish_if_needed():+ yield chunk+++async def collect_openai_response_from_anthropic_sse(+ chunks: AsyncIterable[Any],+ request: Mapping[str, Any],+) -> dict[str, Any]:+ """Collect a translated Anthropic SSE stream into one Responses object."""++ transformer = _ResponsesStreamTransformer(request)+ async for event in _iter_sse_events(chunks):+ transformer.process_anthropic_event(event)+ if transformer.terminal:+ break+ if transformer.final_response is not None:+ return transformer.final_response+ transformer.finish_if_needed()+ return transformer.final_response or transformer.response_payload(+ status="completed"+ )+++def iter_message_response_as_openai_responses(+ message: Mapping[str, Any],+ request: Mapping[str, Any],+) -> list[str]:+ """Return Responses SSE chunks for a non-stream Anthropic message response."""++ response_id = _new_response_id()+ response = _base_response(request, response_id=response_id, status="in_progress")+ chunks = [+ format_response_sse_event(+ "response.created",+ {"type": "response.created", "response": response},+ )+ ]+ completed = anthropic_message_response_to_openai_response(+ message, request, response_id=response_id+ )+ for output_index, item in enumerate(completed["output"]):+ chunks.append(+ format_response_sse_event(+ "response.output_item.added",+ {+ "type": "response.output_item.added",+ "output_index": output_index,+ "item": _in_progress_item(item),+ },+ )+ )+ if item.get("type") == "message":+ text = _message_item_text(item)+ chunks.extend(_message_text_events(item, output_index, text))+ elif item.get("type") == "function_call":+ arguments = str(item.get("arguments", ""))+ if arguments:+ chunks.append(+ format_response_sse_event(+ "response.function_call_arguments.delta",+ {+ "type": "response.function_call_arguments.delta",+ "item_id": item.get("id"),+ "output_index": output_index,+ "delta": arguments,+ },+ )+ )+ chunks.append(+ format_response_sse_event(+ "response.function_call_arguments.done",+ {+ "type": "response.function_call_arguments.done",+ "item_id": item.get("id"),+ "output_index": output_index,+ "arguments": arguments,+ },+ )+ )+ chunks.append(+ format_response_sse_event(+ "response.output_item.done",+ {+ "type": "response.output_item.done",+ "output_index": output_index,+ "item": item,+ },+ )+ )+ chunks.append(+ format_response_sse_event(+ "response.completed",+ {"type": "response.completed", "response": completed},+ )+ )+ return chunks+++@dataclass(slots=True)+class _AnthropicSseEvent:+ event: str+ data: dict[str, Any]+++@dataclass(slots=True)+class _ToolState:+ output_index: int+ item_id: str+ call_id: str+ name: str+ argument_parts: list[str] = field(default_factory=list)+++class _ResponsesStreamTransformer:+ def __init__(self, request: Mapping[str, Any]) -> None:+ self._request = request+ self._response_id = _new_response_id()+ self._created_at = int(time.time())+ self._output: list[dict[str, Any]] = []+ self._text_item_id = _new_message_item_id()+ self._text_started = False+ self._text_done = False+ self._text_output_index: int | None = None+ self._text_block_indexes: set[int] = set()+ self._text_parts: list[str] = []+ self._tools_by_block_index: dict[int, _ToolState] = {}+ self._stop_reason: str | None = None+ self._usage: dict[str, int] | None = None+ self._started = False+ self.terminal = False+ self.final_response: dict[str, Any] | None = None++ def process_anthropic_event(self, event: _AnthropicSseEvent) -> list[str]:+ if self.terminal:+ return []++ chunks = self._ensure_started()+ if event.event == "content_block_start":+ chunks.extend(self._handle_content_block_start(event.data))+ elif event.event == "content_block_delta":+ chunks.extend(self._handle_content_block_delta(event.data))+ elif event.event == "content_block_stop":+ chunks.extend(self._handle_content_block_stop(event.data))+ elif event.event == "message_delta":+ self._handle_message_delta(event.data)+ elif event.event == "message_stop":+ chunks.extend(self._complete_response())+ elif event.event == "error":+ chunks.extend(self._error_event(event.data))+ return chunks++ def finish_if_needed(self) -> list[str]:+ if self.terminal:+ return []+ chunks = self._ensure_started()+ chunks.extend(self._complete_response())+ return chunks++ def response_payload(self, *, status: str) -> dict[str, Any]:+ return {+ "id": self._response_id,+ "object": "response",+ "created_at": self._created_at,+ "status": status,+ "model": str(self._request.get("model", "")),+ "output": list(self._output),+ "parallel_tool_calls": bool(self._request.get("parallel_tool_calls", True)),+ "tool_choice": self._request.get("tool_choice", "auto"),+ "temperature": self._request.get("temperature"),+ "top_p": self._request.get("top_p"),+ "max_output_tokens": self._request.get("max_output_tokens"),+ "usage": self._usage,+ "error": None if status == "completed" else {},+ }++ def _ensure_started(self) -> list[str]:+ if self._started:+ return []+ self._started = True+ return [+ format_response_sse_event(+ "response.created",+ {+ "type": "response.created",+ "response": self.response_payload(status="in_progress"),+ },+ )+ ]++ def _handle_content_block_start(self, data: Mapping[str, Any]) -> list[str]:+ block = data.get("content_block")+ if not isinstance(block, dict):+ return []+ block_type = block.get("type")+ if block_type == "text":+ index = _event_index(data)+ if index is not None:+ self._text_block_indexes.add(index)+ chunks = self._ensure_text_started()+ if text := str(block.get("text", "")):+ chunks.extend(self._emit_text_delta(text))+ return chunks+ if block_type == "tool_use":+ index = _event_index(data)+ if index is None:+ return []+ call_id = str(block.get("id", "") or _new_call_id())+ item_id = f"fc_{uuid.uuid4().hex[:24]}"+ output_index = len(self._output)+ state = _ToolState(+ output_index=output_index,+ item_id=item_id,+ call_id=call_id,+ name=str(block.get("name", "")),+ )+ initial_input = block.get("input")+ if isinstance(initial_input, dict) and initial_input:+ state.argument_parts.append(json.dumps(initial_input))+ self._tools_by_block_index[index] = state+ return []++ def _handle_content_block_delta(self, data: Mapping[str, Any]) -> list[str]:+ delta = data.get("delta")+ if not isinstance(delta, dict):+ return []+ delta_type = delta.get("type")+ if delta_type == "text_delta":+ return self._emit_text_delta(str(delta.get("text", "")))+ if delta_type == "input_json_delta":+ index = _event_index(data)+ if index is not None and index in self._tools_by_block_index:+ self._tools_by_block_index[index].argument_parts.append(+ str(delta.get("partial_json", ""))+ )+ return []++ def _handle_content_block_stop(self, data: Mapping[str, Any]) -> list[str]:+ index = _event_index(data)+ if index is None:+ return []+ state = self._tools_by_block_index.pop(index, None)+ if state is None and index in self._text_block_indexes:+ self._text_block_indexes.remove(index)+ return self._complete_text_if_needed()+ if state is None:+ return []+ return self._complete_tool_call(state)++ def _handle_message_delta(self, data: Mapping[str, Any]) -> None:+ delta = data.get("delta")+ if isinstance(delta, dict):+ self._stop_reason = str(delta.get("stop_reason") or "")+ usage = data.get("usage")+ if isinstance(usage, dict):+ input_tokens = usage.get("input_tokens")+ output_tokens = usage.get("output_tokens")+ safe_in = input_tokens if isinstance(input_tokens, int) else 0+ safe_out = output_tokens if isinstance(output_tokens, int) else 0+ self._usage = {+ "input_tokens": safe_in,+ "output_tokens": safe_out,+ "total_tokens": safe_in + safe_out,+ }++ def _ensure_text_started(self) -> list[str]:+ if self._text_started:+ return []+ if self._text_done:+ self._text_item_id = _new_message_item_id()+ self._text_done = False+ self._text_parts = []+ self._text_started = True+ output_index = len(self._output)+ self._text_output_index = output_index+ item = {+ "id": self._text_item_id,+ "type": "message",+ "status": "in_progress",+ "role": "assistant",+ "content": [],+ }+ return [+ format_response_sse_event(+ "response.output_item.added",+ {+ "type": "response.output_item.added",+ "output_index": output_index,+ "item": item,+ },+ ),+ format_response_sse_event(+ "response.content_part.added",+ {+ "type": "response.content_part.added",+ "item_id": self._text_item_id,+ "output_index": output_index,+ "content_index": 0,+ "part": {"type": "output_text", "text": "", "annotations": []},+ },+ ),+ ]++ def _emit_text_delta(self, text: str) -> list[str]:+ if not text:+ return []+ chunks = self._ensure_text_started()+ self._text_parts.append(text)+ output_index = self._current_text_output_index()+ chunks.append(+ format_response_sse_event(+ "response.output_text.delta",+ {+ "type": "response.output_text.delta",+ "item_id": self._text_item_id,+ "output_index": output_index,+ "content_index": 0,+ "delta": text,+ },+ )+ )+ return chunks++ def _complete_text_if_needed(self) -> list[str]:+ if not self._text_started or self._text_done:+ return []+ self._text_done = True+ self._text_started = False+ text = "".join(self._text_parts)+ output_index = self._current_text_output_index()+ item = _message_item(self._text_item_id, text, "completed")+ if output_index >= len(self._output):+ self._output.append(item)+ else:+ self._output.insert(output_index, item)+ return [+ format_response_sse_event(+ "response.output_text.done",+ {+ "type": "response.output_text.done",+ "item_id": self._text_item_id,+ "output_index": output_index,+ "content_index": 0,+ "text": text,+ },+ ),+ format_response_sse_event(+ "response.content_part.done",+ {+ "type": "response.content_part.done",+ "item_id": self._text_item_id,+ "output_index": output_index,+ "content_index": 0,+ "part": {"type": "output_text", "text": text, "annotations": []},+ },+ ),+ format_response_sse_event(+ "response.output_item.done",+ {+ "type": "response.output_item.done",+ "output_index": output_index,+ "item": item,+ },+ ),+ ]++ def _complete_tool_call(self, state: _ToolState) -> list[str]:+ arguments = "".join(state.argument_parts) or "{}"+ item = {+ "id": state.item_id,+ "type": "function_call",+ "status": "completed",+ "call_id": state.call_id,+ "name": state.name,+ "arguments": arguments,+ }+ self._output.append(item)+ chunks = [+ format_response_sse_event(+ "response.output_item.added",+ {+ "type": "response.output_item.added",+ "output_index": state.output_index,+ "item": {**item, "status": "in_progress", "arguments": ""},+ },+ )+ ]+ if arguments:+ chunks.append(+ format_response_sse_event(+ "response.function_call_arguments.delta",+ {+ "type": "response.function_call_arguments.delta",+ "item_id": state.item_id,+ "output_index": state.output_index,+ "delta": arguments,+ },+ )+ )+ chunks.extend(+ [+ format_response_sse_event(+ "response.function_call_arguments.done",+ {+ "type": "response.function_call_arguments.done",+ "item_id": state.item_id,+ "output_index": state.output_index,+ "arguments": arguments,+ },+ ),+ format_response_sse_event(+ "response.output_item.done",+ {+ "type": "response.output_item.done",+ "output_index": state.output_index,+ "item": item,+ },+ ),+ ]+ )+ return chunks++ def _complete_response(self) -> list[str]:+ chunks = self._complete_text_if_needed()+ self.final_response = self.response_payload(status="completed")+ if self._stop_reason:+ self.final_response["stop_reason"] = self._stop_reason+ chunks.append(+ format_response_sse_event(+ "response.completed",+ {"type": "response.completed", "response": self.final_response},+ )+ )+ self.terminal = True+ return chunks++ def _error_event(self, data: Mapping[str, Any]) -> list[str]:+ error = data.get("error")+ if not isinstance(error, dict):+ error = {"type": "api_error", "message": str(data)}+ self.final_response = self.response_payload(status="failed")+ self.final_response["error"] = {+ "message": str(error.get("message", "")),+ "type": str(error.get("type", "api_error")),+ "param": None,+ "code": None,+ }+ self.terminal = True+ return [+ format_response_sse_event(+ "error",+ {"type": "error", "error": self.final_response["error"]},+ )+ ]++ def _current_text_output_index(self) -> int:+ if self._text_output_index is None:+ self._text_output_index = len(self._output)+ return self._text_output_index+++async def _iter_sse_events(+ chunks: AsyncIterable[Any],+) -> AsyncIterator[_AnthropicSseEvent]:+ buffer = ""+ async for chunk in chunks:+ if isinstance(chunk, bytes):+ buffer += chunk.decode("utf-8", errors="replace")+ else:+ buffer += str(chunk)++ while "\n\n" in buffer:+ raw, buffer = buffer.split("\n\n", 1)+ event = _parse_sse_event(raw)+ if event is not None:+ yield event++ if buffer.strip():+ event = _parse_sse_event(buffer)+ if event is not None:+ yield event+++def _parse_sse_event(raw: str) -> _AnthropicSseEvent | None:+ event_type = ""+ data_parts: list[str] = []+ for line in raw.splitlines():+ stripped = line.rstrip("\r")+ if stripped.startswith("event:"):+ event_type = stripped.split(":", 1)[1].strip()+ elif stripped.startswith("data:"):+ data_parts.append(stripped.split(":", 1)[1].strip())+ if not event_type and not data_parts:+ return None+ data_text = "\n".join(data_parts)+ if data_text == "[DONE]":+ return None+ try:+ parsed = json.loads(data_text) if data_text else {}+ except json.JSONDecodeError:+ parsed = {"raw": data_text}+ if not isinstance(parsed, dict):+ parsed = {"value": parsed}+ return _AnthropicSseEvent(event=event_type, data=parsed)+++def _event_index(data: Mapping[str, Any]) -> int | None:+ value = data.get("index")+ return value if isinstance(value, int) else None+++def _base_response(+ request: Mapping[str, Any], *, response_id: str, status: str+) -> dict[str, Any]:+ return {+ "id": response_id,+ "object": "response",+ "created_at": int(time.time()),+ "status": status,+ "model": str(request.get("model", "")),+ "output": [],+ "parallel_tool_calls": bool(request.get("parallel_tool_calls", True)),+ "tool_choice": request.get("tool_choice", "auto"),+ "temperature": request.get("temperature"),+ "top_p": request.get("top_p"),+ "max_output_tokens": request.get("max_output_tokens"),+ "usage": None,+ "error": None,+ }+++def _message_text_events(+ item: Mapping[str, Any], output_index: int, text: str+) -> list[str]:+ item_id = str(item.get("id", ""))+ return [+ format_response_sse_event(+ "response.content_part.added",+ {+ "type": "response.content_part.added",+ "item_id": item_id,+ "output_index": output_index,+ "content_index": 0,+ "part": {"type": "output_text", "text": "", "annotations": []},+ },+ ),+ format_response_sse_event(+ "response.output_text.delta",+ {+ "type": "response.output_text.delta",+ "item_id": item_id,+ "output_index": output_index,+ "content_index": 0,+ "delta": text,+ },+ ),+ format_response_sse_event(+ "response.output_text.done",+ {+ "type": "response.output_text.done",+ "item_id": item_id,+ "output_index": output_index,+ "content_index": 0,+ "text": text,+ },+ ),+ format_response_sse_event(+ "response.content_part.done",+ {+ "type": "response.content_part.done",+ "item_id": item_id,+ "output_index": output_index,+ "content_index": 0,+ "part": {"type": "output_text", "text": text, "annotations": []},+ },+ ),+ ]+++def _message_item(item_id: str, text: str, status: str) -> dict[str, Any]:+ return {+ "id": item_id,+ "type": "message",+ "status": status,+ "role": "assistant",+ "content": [{"type": "output_text", "text": text, "annotations": []}],+ }+++def _message_item_text(item: Mapping[str, Any]) -> str:+ content = item.get("content")+ if not isinstance(content, list):+ return ""+ parts = [+ str(part.get("text", ""))+ for part in content+ if isinstance(part, dict) and part.get("type") == "output_text"+ ]+ return "".join(parts)+++def _in_progress_item(item: Mapping[str, Any]) -> dict[str, Any]:+ clone = dict(item)+ clone["status"] = "in_progress"+ if clone.get("type") == "message":+ clone["content"] = []+ if clone.get("type") == "function_call":+ clone["arguments"] = ""+ return clone+++def _new_response_id() -> str:+ return f"resp_{uuid.uuid4().hex}"+++def _new_message_item_id() -> str:+ return f"msg_{uuid.uuid4().hex}"+++def _new_call_id() -> str:+ return f"call_{uuid.uuid4().hex[:24]}"diff --git a/pyproject.toml b/pyproject.tomlindex 5f20d05f..9070ccee 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "1.2.41"+version = "2.1.0"description = "Middleware between Claude Code CLI (Anthropic API) and NVIDIA NIM"readme = "README.md"requires-python = ">=3.14.0"@@ -30,6 +30,7 @@ fcc-server = "cli.entrypoints:serve"free-claude-code = "cli.entrypoints:serve"fcc-init = "cli.entrypoints:init"fcc-claude = "cli.entrypoints:launch_claude"+fcc-codex = "cli.entrypoints:launch_codex"[project.optional-dependencies]voice = [diff --git a/smoke/capabilities.py b/smoke/capabilities.pyindex 52ced768..43aad240 100644--- a/smoke/capabilities.py+++ b/smoke/capabilities.py@@ -246,8 +246,8 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = ("removed_env_migration","config.settings.Settings","NIM_ENABLE_THINKING or ENABLE_THINKING in env or dotenv",- "startup validation error with rename guidance",- "application fails fast",+ "startup succeeds and stale keys do not change thinking defaults",+ "removed key ignored",("tests/config/test_config.py",),),CapabilityContract(diff --git a/smoke/features.py b/smoke/features.pyindex 7c04d3a0..11381c33 100644--- a/smoke/features.py+++ b/smoke/features.py@@ -468,7 +468,7 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = (),FeatureCoverage("removed_env_migration",- "Removed env vars fail fast with migration guidance",+ "Removed thinking env vars are ignored without changing defaults","public_surface",("tests/config/test_config.py",),(),diff --git a/smoke/prereq/test_api_prereq_live.py b/smoke/prereq/test_api_prereq_live.pyindex 0ce41883..bdc5ce16 100644--- a/smoke/prereq/test_api_prereq_live.py+++ b/smoke/prereq/test_api_prereq_live.py@@ -26,7 +26,13 @@ def test_probe_and_models_routes(assert models.status_code == 200assert models.json()["data"]- for path in ("/", "/health", "/v1/messages", "/v1/messages/count_tokens"):+ for path in (+ "/",+ "/health",+ "/v1/messages",+ "/v1/responses",+ "/v1/messages/count_tokens",+ ):head = client.head(path)assert head.status_code == 204, (path, head.status_code, head.text)options = client.options(path)diff --git a/smoke/product/test_config_extensibility_product_live.py b/smoke/product/test_config_extensibility_product_live.pyindex 700258ec..2fd66acf 100644--- a/smoke/product/test_config_extensibility_product_live.py+++ b/smoke/product/test_config_extensibility_product_live.py@@ -60,8 +60,7 @@ def test_removed_env_migration_e2e(smoke_config: SmokeConfig, tmp_path) -> None:timeout=smoke_config.timeout_s,check=False,)- assert result.returncode != 0- assert "NIM_ENABLE_THINKING has been removed" in (result.stderr + result.stdout)+ assert result.returncode == 0, result.stderr@pytest.mark.smoke_target("config")diff --git a/smoke/product/test_provider_product_live.py b/smoke/product/test_provider_product_live.pyindex 6bcee620..61882652 100644--- a/smoke/product/test_provider_product_live.py+++ b/smoke/product/test_provider_product_live.py@@ -140,6 +140,40 @@ def test_provider_error_e2e(smoke_config: SmokeConfig) -> None:assert any(event.event == "error" for event in events) or text_content(events)+def test_provider_codex_responses_text_e2e(+ smoke_config: SmokeConfig, provider_model: ProviderModel+) -> None:+ try:+ with (+ _server_for_provider(+ smoke_config, provider_model, "codex-responses"+ ) as server,+ httpx.stream(+ "POST",+ f"{server.base_url}/v1/responses",+ headers=_openai_auth_headers(smoke_config),+ json={+ "model": provider_model.full_model,+ "input": smoke_config.prompt,+ "max_output_tokens": 128,+ "stream": True,+ },+ timeout=smoke_config.timeout_s,+ ) as response,+ ):+ assert response.status_code == 200, response.read()+ events = parse_sse_lines(response.iter_lines())+ except Exception as exc:+ skip_if_upstream_unavailable_exception(exc)+ raise++ skip_if_upstream_unavailable_events(events)+ names = [event.event for event in events]+ assert names[0] == "response.created", names+ assert names[-1] == "response.completed", names+ assert any(event.event == "response.output_text.delta" for event in events), names++def test_openrouter_native_e2e(smoke_config: SmokeConfig) -> None:models = [model@@ -517,3 +551,11 @@ def _server_for_provider("MESSAGING_PLATFORM": "none",},).run()+++def _openai_auth_headers(smoke_config: SmokeConfig) -> dict[str, str]:+ headers = {"content-type": "application/json"}+ token = smoke_config.settings.anthropic_auth_token+ if token:+ headers["authorization"] = f"Bearer {token}"+ return headersdiff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.pynew file mode 100644index 00000000..0063d830--- /dev/null+++ b/tests/api/test_openai_responses.py@@ -0,0 +1,225 @@+from __future__ import annotations++from typing import Any+from unittest.mock import MagicMock, patch++import pytest+from fastapi.testclient import TestClient++from api.app import create_app+from core.anthropic.sse import format_sse_event+from core.anthropic.stream_contracts import parse_sse_text+++class FakeProvider:+ def __init__(self, chunks: list[str]) -> None:+ self.chunks = chunks+ self.preflight_stream = MagicMock()+ self.requests: list[Any] = []++ async def stream_response(self, request_data, **_kwargs):+ self.requests.append(request_data)+ for chunk in self.chunks:+ yield chunk+++def responses_client():+ provider = FakeProvider(_anthropic_text_stream("Hello from provider"))+ app = create_app(lifespan_enabled=False)+ with (+ patch("api.dependencies.resolve_provider", return_value=provider),+ TestClient(app) as client,+ ):+ yield client, provider+++def test_responses_probe_endpoints_return_204(+ responses_client: tuple[TestClient, FakeProvider],+) -> None:+ client, _provider = responses_client++ assert client.head("/v1/responses").status_code == 204+ assert client.options("/v1/responses").status_code == 204+++def test_create_response_stream_routes_through_provider(+ responses_client: tuple[TestClient, FakeProvider],+) -> None:+ client, provider = responses_client++ response = client.post(+ "/v1/responses",+ json={+ "model": "nvidia_nim/test-model",+ "input": "Hello",+ "stream": True,+ "max_output_tokens": 32,+ },+ )++ assert response.status_code == 200+ assert "text/event-stream" in response.headers["content-type"]+ events = parse_sse_text(response.text)+ assert events[0].event == "response.created"+ assert events[-1].event == "response.completed"+ assert events[-1].data["response"]["output"][0]["content"][0]["text"] == (+ "Hello from provider"+ )+ assert provider.preflight_stream.called+ routed = provider.requests[0]+ assert routed.model == "test-model"+ assert routed.messages[0].role == "user"+ assert routed.messages[0].content == "Hello"+ assert routed.max_tokens == 32+++def test_create_response_non_stream_collects_response(+ responses_client: tuple[TestClient, FakeProvider],+) -> None:+ client, _provider = responses_client++ response = client.post(+ "/v1/responses",+ json={+ "model": "nvidia_nim/test-model",+ "input": "Hello",+ "stream": False,+ },+ )++ assert response.status_code == 200+ payload = response.json()+ assert payload["object"] == "response"+ assert payload["status"] == "completed"+ assert payload["output"][0]["content"][0]["text"] == "Hello from provider"+++def test_create_response_tool_stream_emits_function_call() -> None:+ provider = FakeProvider(_anthropic_tool_stream())+ app = create_app(lifespan_enabled=False)+ with (+ patch("api.dependencies.resolve_provider", return_value=provider),+ TestClient(app) as client,+ ):+ response = client.post(+ "/v1/responses",+ json={+ "model": "nvidia_nim/test-model",+ "input": "Use echo",+ "stream": True,+ "tools": [+ {+ "type": "function",+ "name": "echo",+ "parameters": {"type": "object", "properties": {}},+ }+ ],+ },+ )++ assert response.status_code == 200+ events = parse_sse_text(response.text)+ completed = events[-1].data["response"]+ call = completed["output"][0]+ assert call["type"] == "function_call"+ assert call["call_id"] == "toolu_1"+ assert call["arguments"] == '{"value":"FCC"}'+++def test_create_response_unsupported_tool_returns_openai_error(+ responses_client: tuple[TestClient, FakeProvider],+) -> None:+ client, _provider = responses_client++ response = client.post(+ "/v1/responses",+ json={+ "model": "nvidia_nim/test-model",+ "input": "Hello",+ "tools": [{"type": "web_search_preview"}],+ },+ )++ assert response.status_code == 400+ payload = response.json()+ assert payload["error"]["type"] == "invalid_request_error"+ assert "Unsupported Responses tool type" in payload["error"]["message"]+++def _anthropic_text_stream(text: str) -> list[str]:+ return [+ format_sse_event("message_start", {"type": "message_start", "message": {}}),+ format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "text", "text": ""},+ },+ ),+ format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": text},+ },+ ),+ format_sse_event(+ "content_block_stop",+ {"type": "content_block_stop", "index": 0},+ ),+ format_sse_event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "end_turn", "stop_sequence": None},+ "usage": {"input_tokens": 3, "output_tokens": 4},+ },+ ),+ format_sse_event("message_stop", {"type": "message_stop"}),+ ]+++def _anthropic_tool_stream() -> list[str]:+ return [+ format_sse_event("message_start", {"type": "message_start", "message": {}}),+ format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {+ "type": "tool_use",+ "id": "toolu_1",+ "name": "echo",+ "input": {},+ },+ },+ ),+ format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {+ "type": "input_json_delta",+ "partial_json": '{"value":"FCC"}',+ },+ },+ ),+ format_sse_event(+ "content_block_stop",+ {"type": "content_block_stop", "index": 0},+ ),+ format_sse_event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "tool_use", "stop_sequence": None},+ "usage": {"input_tokens": 3, "output_tokens": 4},+ },+ ),+ format_sse_event("message_stop", {"type": "message_stop"}),+ ]diff --git a/tests/cli/test_adapters.py b/tests/cli/test_adapters.pynew file mode 100644index 00000000..d900f88c--- /dev/null+++ b/tests/cli/test_adapters.py@@ -0,0 +1,366 @@+from __future__ import annotations++import json+from types import SimpleNamespace++from cli.adapters.base import CliParseState, CliTaskRequest+from cli.adapters.claude import CLAUDE_CLI_ADAPTER+from cli.adapters.codex import CODEX_CLI_ADAPTER+from cli.adapters.registry import DEFAULT_CLIENT_CLI_ID, get_client_cli_adapter+++def _config(**overrides: object) -> SimpleNamespace:+ values: dict[str, object] = {+ "workspace_path": "/workspace",+ "api_url": "http://127.0.0.1:8082/v1",+ "allowed_dirs": [],+ "plans_directory": None,+ "claude_bin": "claude-test",+ "auth_token": "",+ }+ values.update(overrides)+ return SimpleNamespace(**values)+++def test_registry_returns_default_claude_adapter() -> None:+ assert DEFAULT_CLIENT_CLI_ID == "claude"+ assert get_client_cli_adapter() is CLAUDE_CLI_ADAPTER+ assert get_client_cli_adapter("claude") is CLAUDE_CLI_ADAPTER+ assert get_client_cli_adapter("codex") is CODEX_CLI_ADAPTER+++def test_claude_adapter_builds_new_task_command_and_env() -> None:+ invocation = CLAUDE_CLI_ADAPTER.build_task_invocation(+ config=_config(auth_token="proxy-token"),+ request=CliTaskRequest(prompt="hello"),+ base_env={+ "KEEP_ME": "yes",+ "ANTHROPIC_API_KEY": "official-key",+ "ANTHROPIC_AUTH_TOKEN": "stale-token",+ },+ )++ assert invocation.argv == (+ "claude-test",+ "-p",+ "hello",+ "--output-format",+ "stream-json",+ "--dangerously-skip-permissions",+ "--verbose",+ )+ assert invocation.env["KEEP_ME"] == "yes"+ assert invocation.env["ANTHROPIC_API_URL"] == "http://127.0.0.1:8082/v1"+ assert invocation.env["ANTHROPIC_BASE_URL"] == "http://127.0.0.1:8082"+ assert invocation.env["ANTHROPIC_AUTH_TOKEN"] == "proxy-token"+ assert invocation.env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] == "1"+ assert invocation.env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] == "190000"+ assert "ANTHROPIC_API_KEY" not in invocation.env+ assert invocation.trace_metadata["client_cli_id"] == "claude"+++def test_claude_adapter_builds_resume_fork_command() -> None:+ invocation = CLAUDE_CLI_ADAPTER.build_task_invocation(+ config=_config(),+ request=CliTaskRequest(+ prompt="continue",+ session_id="sess_123",+ fork_session=True,+ ),+ base_env={},+ )++ assert invocation.argv[:4] == (+ "claude-test",+ "--resume",+ "sess_123",+ "--fork-session",+ )+ assert "-p" in invocation.argv+ assert "continue" in invocation.argv+ assert invocation.trace_metadata["resume_session_id"] == "sess_123"+ assert invocation.trace_metadata["fork_session"] is True+++def test_claude_adapter_does_not_resume_pending_session() -> None:+ invocation = CLAUDE_CLI_ADAPTER.build_task_invocation(+ config=_config(),+ request=CliTaskRequest(prompt="new", session_id="pending_123"),+ base_env={},+ )++ assert "--resume" not in invocation.argv+ assert invocation.trace_metadata["resume_session_id"] is None+++def test_claude_adapter_adds_allowed_dirs_and_plans_directory() -> None:+ invocation = CLAUDE_CLI_ADAPTER.build_task_invocation(+ config=_config(+ allowed_dirs=["/dir1", "/dir2"],+ plans_directory="./agent_workspace/plans",+ ),+ request=CliTaskRequest(prompt="hello"),+ base_env={},+ )++ assert invocation.argv.count("--add-dir") == 2+ assert "/dir1" in invocation.argv+ assert "/dir2" in invocation.argv+ settings_idx = invocation.argv.index("--settings")+ settings = json.loads(invocation.argv[settings_idx + 1])+ assert settings["plansDirectory"] == "./agent_workspace/plans"+++def test_claude_adapter_launcher_env_targets_proxy() -> None:+ env = CLAUDE_CLI_ADAPTER.build_launcher_env(+ proxy_root_url="http://127.0.0.1:9191",+ auth_token=" proxy-token ",+ base_env={+ "PATH": "keep",+ "ANTHROPIC_BASE_URL": "https://api.anthropic.com",+ "ANTHROPIC_API_KEY": "official-key",+ "ANTHROPIC_AUTH_TOKEN": "stale-token",+ },+ )++ assert env["PATH"] == "keep"+ assert env["ANTHROPIC_BASE_URL"] == "http://127.0.0.1:9191"+ assert env["ANTHROPIC_AUTH_TOKEN"] == "proxy-token"+ assert env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] == "1"+ assert env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] == "190000"+ assert "ANTHROPIC_API_KEY" not in env+++def test_claude_adapter_launcher_command_preserves_args() -> None:+ command = CLAUDE_CLI_ADAPTER.build_launcher_command(+ binary_path="claude.cmd",+ argv=["--model", "sonnet"],+ settings=_config(),+ proxy_root_url="http://127.0.0.1:8082",+ )++ assert command == ["claude.cmd", "--model", "sonnet"]+++def test_claude_adapter_extracts_supported_session_id_shapes() -> None:+ assert CLAUDE_CLI_ADAPTER.extract_session_id({"session_id": "direct"}) == "direct"+ assert CLAUDE_CLI_ADAPTER.extract_session_id({"sessionId": "camel"}) == "camel"+ assert (+ CLAUDE_CLI_ADAPTER.extract_session_id({"init": {"session_id": "nested"}})+ == "nested"+ )+ assert (+ CLAUDE_CLI_ADAPTER.extract_session_id({"result": {"sessionId": "result"}})+ == "result"+ )+ assert (+ CLAUDE_CLI_ADAPTER.extract_session_id({"conversation": {"id": "conv"}})+ == "conv"+ )+ assert CLAUDE_CLI_ADAPTER.extract_session_id({"type": "message"}) is None+ assert CLAUDE_CLI_ADAPTER.extract_session_id("not a dict") is None+++def test_claude_adapter_invalid_stdout_json_becomes_raw_event() -> None:+ events = list(+ CLAUDE_CLI_ADAPTER.parse_stdout_line(+ "Not valid json",+ CliParseState(log_raw_cli_diagnostics=False),+ )+ )++ assert events == [{"type": "raw", "content": "Not valid json"}]+++def test_claude_adapter_synthesizes_session_info_once() -> None:+ state = CliParseState()++ first_events = list(+ CLAUDE_CLI_ADAPTER.parse_stdout_line('{"session_id": "sess_1"}', state)+ )+ second_events = list(+ CLAUDE_CLI_ADAPTER.parse_stdout_line('{"session_id": "sess_2"}', state)+ )++ assert first_events == [+ {"type": "session_info", "session_id": "sess_1"},+ {"session_id": "sess_1"},+ ]+ assert second_events == [{"session_id": "sess_2"}]+++def test_codex_adapter_builds_new_task_command_and_env() -> None:+ invocation = CODEX_CLI_ADAPTER.build_task_invocation(+ config=_config(auth_token="proxy-token"),+ request=CliTaskRequest(prompt="hello"),+ base_env={+ "KEEP_ME": "yes",+ "OPENAI_API_KEY": "official-key",+ "OPENAI_BASE_URL": "https://api.openai.com/v1",+ "CODEX_API_KEY": "stale-token",+ "CODEX_HOME": "/tmp/codex",+ },+ )++ assert invocation.argv[:3] == ("codex", "exec", "--json")+ assert "--dangerously-bypass-approvals-and-sandbox" in invocation.argv+ assert "-C" in invocation.argv+ assert "/workspace" in invocation.argv+ assert invocation.argv[-1] == "hello"+ assert 'model_provider="fcc"' in invocation.argv+ assert 'model_providers.fcc.wire_api="responses"' in invocation.argv+ assert invocation.env["KEEP_ME"] == "yes"+ assert invocation.env["CODEX_HOME"] == "/tmp/codex"+ assert invocation.env["FCC_CODEX_API_KEY"] == "proxy-token"+ assert "OPENAI_API_KEY" not in invocation.env+ assert "OPENAI_BASE_URL" not in invocation.env+ assert "CODEX_API_KEY" not in invocation.env+ assert invocation.trace_metadata["client_cli_id"] == "codex"+ assert invocation.trace_metadata["codex_binary"] == "codex"+ assert "claude_binary" not in invocation.trace_metadata+ assert CODEX_CLI_ADAPTER.trace_stage == "codex_cli"+ assert CODEX_CLI_ADAPTER.process_launch_event == "codex_cli.process.launch"+ assert CODEX_CLI_ADAPTER.trace_source == "codex_cli"+++def test_codex_adapter_uses_explicit_codex_binary_when_provided() -> None:+ invocation = CODEX_CLI_ADAPTER.build_task_invocation(+ config=_config(codex_bin="codex-test"),+ request=CliTaskRequest(prompt="hello"),+ base_env={},+ )++ assert invocation.argv[:3] == ("codex-test", "exec", "--json")+ assert invocation.trace_metadata["codex_binary"] == "codex-test"+++def test_codex_adapter_builds_resume_command() -> None:+ invocation = CODEX_CLI_ADAPTER.build_task_invocation(+ config=_config(),+ request=CliTaskRequest(prompt="continue", session_id="sess_123"),+ base_env={},+ )++ assert invocation.argv[:4] == ("codex", "exec", "resume", "--json")+ assert "sess_123" in invocation.argv+ assert invocation.argv[-1] == "continue"+ assert invocation.trace_metadata["resume_session_id"] == "sess_123"+++def test_codex_adapter_fork_starts_new_session() -> None:+ invocation = CODEX_CLI_ADAPTER.build_task_invocation(+ config=_config(),+ request=CliTaskRequest(+ prompt="fork",+ session_id="sess_123",+ fork_session=True,+ ),+ base_env={},+ )++ assert "resume" not in invocation.argv+ assert invocation.trace_metadata["resume_session_id"] is None+ assert invocation.trace_metadata["fork_session"] is True+++def test_codex_adapter_launcher_command_targets_responses_provider() -> None:+ command = CODEX_CLI_ADAPTER.build_launcher_command(+ binary_path="codex.cmd",+ argv=["exec", "hello"],+ settings=_config(model="nvidia_nim/test-model"),+ proxy_root_url="http://127.0.0.1:8082",+ )++ assert command[:2] == ["codex.cmd", "-c"]+ assert 'model_provider="fcc"' in command+ assert 'model_providers.fcc.base_url="http://127.0.0.1:8082/v1"' in command+ assert 'model_providers.fcc.env_key="FCC_CODEX_API_KEY"' in command+ assert 'model_providers.fcc.wire_api="responses"' in command+ assert 'model="nvidia_nim/test-model"' in command+ assert command[-2:] == ["exec", "hello"]+++def test_codex_adapter_launcher_env_strips_openai_credentials() -> None:+ env = CODEX_CLI_ADAPTER.build_launcher_env(+ proxy_root_url="http://127.0.0.1:9191",+ auth_token=" proxy-token ",+ base_env={+ "PATH": "keep",+ "CODEX_HOME": "/tmp/codex",+ "OPENAI_API_KEY": "official-key",+ "OPENAI_BASE_URL": "https://api.openai.com/v1",+ "CODEX_API_KEY": "stale",+ "FCC_CODEX_API_KEY": "old",+ },+ )++ assert env["PATH"] == "keep"+ assert env["CODEX_HOME"] == "/tmp/codex"+ assert env["FCC_CODEX_API_KEY"] == "proxy-token"+ assert "OPENAI_API_KEY" not in env+ assert "OPENAI_BASE_URL" not in env+ assert "CODEX_API_KEY" not in env+++def test_codex_adapter_parses_response_text_delta() -> None:+ events = list(+ CODEX_CLI_ADAPTER.parse_stdout_line(+ '{"type":"response.output_text.delta","delta":"hi","thread_id":"t1"}',+ CliParseState(),+ )+ )++ assert events == [+ {"type": "session_info", "session_id": "t1"},+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": "hi"},+ },+ ]+++def test_codex_adapter_parses_completed_function_call_item() -> None:+ line = json.dumps(+ {+ "type": "response.output_item.done",+ "item": {+ "type": "function_call",+ "call_id": "call_1",+ "name": "echo",+ "arguments": '{"value":"FCC"}',+ },+ }+ )++ events = list(CODEX_CLI_ADAPTER.parse_stdout_line(line, CliParseState()))++ assert events == [+ {+ "type": "assistant",+ "message": {+ "content": [+ {+ "type": "tool_use",+ "id": "call_1",+ "name": "echo",+ "input": {"value": "FCC"},+ }+ ]+ },+ }+ ]+++def test_codex_adapter_unknown_json_becomes_raw_event() -> None:+ events = list(+ CODEX_CLI_ADAPTER.parse_stdout_line(+ '{"type":"thread.started","thread_id":"t1"}',+ CliParseState(),+ )+ )++ assert events == [+ {"type": "session_info", "session_id": "t1"},+ {"type": "raw", "content": '{"type":"thread.started","thread_id":"t1"}'},+ ]diff --git a/tests/cli/test_cli.py b/tests/cli/test_cli.pyindex 2b3e282f..0ee10b1e 100644--- a/tests/cli/test_cli.py+++ b/tests/cli/test_cli.py@@ -3,7 +3,8 @@import asyncioimport jsonimport os-from typing import cast+from collections.abc import Iterable, Mapping+from typing import Any, castfrom unittest.mock import AsyncMock, MagicMock, patchimport pytest@@ -639,6 +640,117 @@ class TestCLISession:assert len(events) == 1assert events[0]["content"] == "Not valid json"+ @pytest.mark.asyncio+ async def test_start_task_uses_injected_client_cli_adapter(self, tmp_path):+ """CLISession delegates argv/env/line parsing to the injected adapter."""+ from cli.adapters.base import CliInvocation, CliParseState, CliTaskRequest+ from cli.session import CLISession++ class FakeClientCliAdapter:+ id = "fake"+ display_name = "Fake CLI"+ default_binary = "fake"+ install_hint = "Install Fake CLI"+ trace_stage = "claude_cli"+ process_launch_event = "claude_cli.process.launch"+ trace_source = "claude_cli"++ def __init__(self) -> None:+ self.request: CliTaskRequest | None = None++ def build_task_invocation(+ self,+ *,+ config: Any,+ request: CliTaskRequest,+ base_env: Mapping[str, str],+ ) -> CliInvocation:+ self.request = request+ return CliInvocation(+ argv=("fake-cli", "--prompt", request.prompt),+ env={"FAKE_ENV": base_env.get("KEEP_ME", "")},+ cwd=config.workspace_path,+ trace_metadata={"client_cli_id": self.id},+ )++ def parse_stdout_line(+ self, line: str, state: CliParseState+ ) -> Iterable[dict[str, Any]]:+ if not state.session_id_extracted:+ state.session_id_extracted = True+ yield {"type": "session_info", "session_id": "fake_session"}+ yield {"type": "message", "content": line}++ def extract_session_id(self, event: Any) -> str | None:+ if isinstance(event, dict):+ value = event.get("session_id")+ return value if isinstance(value, str) else None+ return None++ def get_launcher_binary_name(self, settings: Any) -> str:+ return self.default_binary++ def build_launcher_command(+ self,+ *,+ binary_path: str,+ argv: Iterable[str],+ settings: Any,+ proxy_root_url: str,+ ) -> list[str]:+ return [binary_path, *argv]++ def build_launcher_env(+ self,+ *,+ proxy_root_url: str,+ auth_token: str,+ base_env: Mapping[str, str],+ ) -> dict[str, str]:+ return dict(base_env)++ adapter = FakeClientCliAdapter()+ session = CLISession(+ str(tmp_path),+ "http://localhost:8082/v1",+ client_cli_adapter=adapter,+ )++ mock_process = AsyncMock()+ mock_process.stdout.read.side_effect = [b"hello\n", b""]+ mock_process.stderr.read.return_value = b""+ mock_process.wait.return_value = 0+ mock_process.returncode = 0++ with (+ patch.dict(os.environ, {"KEEP_ME": "yes"}, clear=False),+ patch(+ "asyncio.create_subprocess_exec", new_callable=AsyncMock+ ) as mock_exec,+ ):+ mock_exec.return_value = mock_process+ events = [+ e+ async for e in session.start_task(+ "adapter prompt",+ session_id="sess_fake",+ fork_session=True,+ )+ ]++ assert adapter.request == CliTaskRequest(+ prompt="adapter prompt",+ session_id="sess_fake",+ fork_session=True,+ )+ assert mock_exec.call_args.args == ("fake-cli", "--prompt", "adapter prompt")+ assert mock_exec.call_args.kwargs["env"] == {"FAKE_ENV": "yes"}+ assert session.current_session_id == "fake_session"+ assert events[:2] == [+ {"type": "session_info", "session_id": "fake_session"},+ {"type": "message", "content": "hello"},+ ]+@pytest.mark.asyncioasync def test_stop_exception(self):"""Test exception handling during stop."""diff --git a/tests/cli/test_cli_manager_edge_cases.py b/tests/cli/test_cli_manager_edge_cases.pyindex 373916b3..e0f4a8ab 100644--- a/tests/cli/test_cli_manager_edge_cases.py+++ b/tests/cli/test_cli_manager_edge_cases.py@@ -3,6 +3,12 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytest+def _fake_client_cli_adapter():+ adapter = MagicMock()+ adapter.id = "fake"+ return adapter++@pytest.mark.asyncioasync def test_register_real_session_id_moves_pending_to_active_and_maps():from cli.manager import CLISessionManager@@ -104,3 +110,23 @@ async def test_stop_all_handles_stop_exceptions():s2.stop.assert_awaited_once()assert manager.get_stats()["active_sessions"] == 0assert manager.get_stats()["pending_sessions"] == 0+++async def test_get_or_create_session_passes_client_cli_adapter():+ from cli.manager import CLISessionManager++ adapter = _fake_client_cli_adapter()+ with patch("cli.manager.CLISession") as mock_session_cls:+ mock_session = MagicMock()+ mock_session.is_busy = False+ mock_session_cls.return_value = mock_session++ manager = CLISessionManager(+ workspace_path="/tmp",+ api_url="http://x/v1",+ client_cli_adapter=adapter,+ )+ await manager.get_or_create_session()++ assert mock_session_cls.call_args.kwargs["client_cli_adapter"] is adapterdiff --git a/tests/cli/test_entrypoints.py b/tests/cli/test_entrypoints.pyindex fb3ab6a3..534790a6 100644--- a/tests/cli/test_entrypoints.py+++ b/tests/cli/test_entrypoints.py@@ -19,6 +19,7 @@ def _launcher_settings(host="0.0.0.0",port=port,anthropic_auth_token=token,+ model="nvidia_nim/test-model",)@@ -157,6 +158,7 @@ def test_cli_scripts_are_registered() -> None:assert scripts["fcc-server"] == "cli.entrypoints:serve"assert scripts["free-claude-code"] == "cli.entrypoints:serve"assert scripts["fcc-claude"] == "cli.entrypoints:launch_claude"+ assert scripts["fcc-codex"] == "cli.entrypoints:launch_codex"def test_schedule_open_admin_browser_opens_when_health_ready(@@ -362,6 +364,46 @@ def test_launch_claude_passes_args_and_child_env(unregister_pid.assert_called_once_with(12345)+def test_launch_codex_passes_responses_config_and_child_env(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ from cli.entrypoints import launch_codex++ monkeypatch.setenv("OPENAI_API_KEY", "official-key")+ monkeypatch.setenv("OPENAI_BASE_URL", "https://api.openai.com/v1")+ monkeypatch.setenv("CODEX_HOME", "keep-home")+ settings = _launcher_settings(port=9191, token="proxy-token")++ with (+ patch("cli.entrypoints.get_settings", return_value=settings),+ patch("cli.entrypoints._preflight_proxy", return_value=None),+ patch("cli.entrypoints.shutil.which", return_value="resolved-codex.cmd"),+ patch("cli.entrypoints.subprocess.Popen") as popen,+ patch("cli.entrypoints.register_pid") as register_pid,+ patch("cli.entrypoints.unregister_pid") as unregister_pid,+ pytest.raises(SystemExit) as exc_info,+ ):+ process = popen.return_value+ process.pid = 12345+ process.wait.return_value = 0+ launch_codex(["exec", "hello"])++ assert exc_info.value.code == 0+ command = popen.call_args.args[0]+ assert command[0] == "resolved-codex.cmd"+ assert 'model_provider="fcc"' in command+ assert 'model_providers.fcc.base_url="http://127.0.0.1:9191/v1"' in command+ assert 'model_providers.fcc.wire_api="responses"' in command+ assert command[-2:] == ["exec", "hello"]+ child_env = popen.call_args.kwargs["env"]+ assert child_env["FCC_CODEX_API_KEY"] == "proxy-token"+ assert child_env["CODEX_HOME"] == "keep-home"+ assert "OPENAI_API_KEY" not in child_env+ assert "OPENAI_BASE_URL" not in child_env+ register_pid.assert_called_once_with(12345)+ unregister_pid.assert_called_once_with(12345)++def test_launch_claude_keyboard_interrupt_kills_child_tree() -> None:from cli.entrypoints import launch_claudediff --git a/tests/core/openai_responses/test_conversion.py b/tests/core/openai_responses/test_conversion.pynew file mode 100644index 00000000..db47854a--- /dev/null+++ b/tests/core/openai_responses/test_conversion.py@@ -0,0 +1,163 @@+from __future__ import annotations++import pytest++from core.openai_responses import (+ ResponsesConversionError,+ responses_request_to_anthropic_payload,+)+++def test_responses_string_input_converts_to_anthropic_message() -> None:+ payload = responses_request_to_anthropic_payload(+ {+ "model": "nvidia_nim/test-model",+ "instructions": "System instructions",+ "input": "Hello",+ "max_output_tokens": 64,+ "temperature": 0.2,+ "top_p": 0.9,+ "metadata": {"trace": "abc"},+ }+ )++ assert payload["model"] == "nvidia_nim/test-model"+ assert payload["system"] == "System instructions"+ assert payload["messages"] == [{"role": "user", "content": "Hello"}]+ assert payload["max_tokens"] == 64+ assert payload["temperature"] == 0.2+ assert payload["top_p"] == 0.9+ assert payload["metadata"] == {"trace": "abc"}+++def test_responses_messages_tools_and_tool_results_convert() -> None:+ payload = responses_request_to_anthropic_payload(+ {+ "model": "deepseek/deepseek-chat",+ "input": [+ {+ "type": "message",+ "role": "developer",+ "content": [{"type": "input_text", "text": "Developer rules"}],+ },+ {+ "type": "message",+ "role": "user",+ "content": [{"type": "input_text", "text": "Use the tool"}],+ },+ {+ "type": "function_call",+ "call_id": "call_1",+ "name": "echo",+ "arguments": '{"value":"FCC"}',+ },+ {+ "type": "function_call_output",+ "call_id": "call_1",+ "output": "FCC",+ },+ ],+ "tools": [+ {+ "type": "function",+ "name": "echo",+ "description": "Echo a value",+ "parameters": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ },+ }+ ],+ "tool_choice": {"type": "function", "name": "echo"},+ }+ )++ assert payload["system"] == "Developer rules"+ assert payload["messages"] == [+ {"role": "user", "content": [{"type": "text", "text": "Use the tool"}]},+ {+ "role": "assistant",+ "content": [+ {+ "type": "tool_use",+ "id": "call_1",+ "name": "echo",+ "input": {"value": "FCC"},+ }+ ],+ },+ {+ "role": "user",+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": "call_1",+ "content": "FCC",+ }+ ],+ },+ ]+ assert payload["tools"] == [+ {+ "name": "echo",+ "description": "Echo a value",+ "input_schema": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ },+ }+ ]+ assert payload["tool_choice"] == {"type": "tool", "name": "echo"}+++def test_responses_tool_choice_none_disables_forwarded_tools() -> None:+ payload = responses_request_to_anthropic_payload(+ {+ "model": "deepseek/deepseek-chat",+ "input": "Reply without tools",+ "tools": [+ {+ "type": "function",+ "name": "echo",+ "parameters": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ },+ }+ ],+ "tool_choice": "none",+ }+ )++ assert "tools" not in payload+ assert "tool_choice" not in payload+++def test_responses_unsupported_tool_type_is_clear() -> None:+ with pytest.raises(+ ResponsesConversionError, match="Unsupported Responses tool type"+ ):+ responses_request_to_anthropic_payload(+ {+ "model": "nvidia_nim/test-model",+ "input": "Hello",+ "tools": [{"type": "web_search_preview"}],+ }+ )+++def test_responses_invalid_function_arguments_are_rejected() -> None:+ with pytest.raises(ResponsesConversionError, match="invalid JSON"):+ responses_request_to_anthropic_payload(+ {+ "model": "nvidia_nim/test-model",+ "input": [+ {+ "type": "function_call",+ "call_id": "call_1",+ "name": "echo",+ "arguments": "{",+ }+ ],+ }+ )diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.pynew file mode 100644index 00000000..7b01f0d0--- /dev/null+++ b/tests/core/openai_responses/test_sse.py@@ -0,0 +1,184 @@+from __future__ import annotations++from collections.abc import AsyncIterator++import pytest++from core.anthropic.sse import format_sse_event+from core.anthropic.stream_contracts import parse_sse_text+from core.openai_responses import (+ collect_openai_response_from_anthropic_sse,+ iter_anthropic_sse_as_openai_responses,+)+++async def test_anthropic_text_stream_converts_to_responses_sse() -> None:+ text = await _collect_sse(+ iter_anthropic_sse_as_openai_responses(+ _aiter(_anthropic_text_stream("Hello Codex")),+ {"model": "nvidia_nim/test-model", "stream": True},+ )+ )++ events = parse_sse_text(text)+ event_names = [event.event for event in events]+ assert event_names[:3] == [+ "response.created",+ "response.output_item.added",+ "response.content_part.added",+ ]+ assert "response.output_text.delta" in event_names+ assert events[-1].event == "response.completed"+ assert events[-1].data["response"]["output"][0]["content"][0]["text"] == (+ "Hello Codex"+ )+++async def test_anthropic_tool_stream_converts_to_function_call_item() -> None:+ text = await _collect_sse(+ iter_anthropic_sse_as_openai_responses(+ _aiter(_anthropic_tool_stream()),+ {"model": "nvidia_nim/test-model", "stream": True},+ )+ )++ events = parse_sse_text(text)+ names = [event.event for event in events]+ assert "response.function_call_arguments.delta" in names+ assert "response.function_call_arguments.done" in names+ completed = events[-1].data["response"]+ function_call = completed["output"][0]+ assert function_call["type"] == "function_call"+ assert function_call["call_id"] == "toolu_1"+ assert function_call["name"] == "echo"+ assert function_call["arguments"] == '{"value":"FCC"}'+++async def test_anthropic_error_stream_converts_to_responses_error_event() -> None:+ text = await _collect_sse(+ iter_anthropic_sse_as_openai_responses(+ _aiter(+ [+ format_sse_event(+ "error",+ {+ "type": "error",+ "error": {+ "type": "api_error",+ "message": "upstream failed",+ },+ },+ )+ ]+ ),+ {"model": "nvidia_nim/test-model", "stream": True},+ )+ )++ events = parse_sse_text(text)+ assert events[0].event == "response.created"+ assert events[1].event == "error"+ assert events[1].data["error"]["message"] == "upstream failed"+++async def test_collect_non_stream_response_from_anthropic_sse() -> None:+ response = await collect_openai_response_from_anthropic_sse(+ _aiter(_anthropic_text_stream("Non-stream")),+ {"model": "deepseek/deepseek-chat", "stream": False},+ )++ assert response["status"] == "completed"+ assert response["model"] == "deepseek/deepseek-chat"+ assert response["output"][0]["content"][0]["text"] == "Non-stream"+++async def _collect_sse(chunks: AsyncIterator[str]) -> str:+ parts = [chunk async for chunk in chunks]+ return "".join(parts)+++async def _aiter(chunks: list[str]) -> AsyncIterator[str]:+ for chunk in chunks:+ yield chunk+++def _anthropic_text_stream(text: str) -> list[str]:+ return [+ format_sse_event("message_start", {"type": "message_start", "message": {}}),+ format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "text", "text": ""},+ },+ ),+ format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": text},+ },+ ),+ format_sse_event(+ "content_block_stop",+ {"type": "content_block_stop", "index": 0},+ ),+ format_sse_event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "end_turn", "stop_sequence": None},+ "usage": {"input_tokens": 3, "output_tokens": 4},+ },+ ),+ format_sse_event("message_stop", {"type": "message_stop"}),+ ]+++def _anthropic_tool_stream() -> list[str]:+ return [+ format_sse_event("message_start", {"type": "message_start", "message": {}}),+ format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {+ "type": "tool_use",+ "id": "toolu_1",+ "name": "echo",+ "input": {},+ },+ },+ ),+ format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {+ "type": "input_json_delta",+ "partial_json": '{"value":"FCC"}',+ },+ },+ ),+ format_sse_event(+ "content_block_stop",+ {"type": "content_block_stop", "index": 0},+ ),+ format_sse_event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "tool_use", "stop_sequence": None},+ "usage": {"input_tokens": 3, "output_tokens": 4},+ },+ ),+ format_sse_event("message_stop", {"type": "message_stop"}),+ ]diff --git a/uv.lock b/uv.lockindex c79d02b4..a2c6e7ea 100644--- a/uv.lock+++ b/uv.lock@@ -561,7 +561,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "1.2.41"+version = "2.1.0"source = { editable = "." }dependencies = [{ name = "aiohttp" },