Skip to content

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.py
index 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"] = lifespan
diff --git a/api/models/openai_responses.py b/api/models/openai_responses.py
new file mode 100644
index 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 = None
diff --git a/api/models/responses.py b/api/models/responses.py
index 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: str
display_name: str
id: str
@@ -24,6 +27,7 @@ class ModelResponse(BaseModel):
class ModelsListResponse(BaseModel):
+ object: Literal["list"] = "list"
data: list[ModelResponse]
first_id: str | None
has_more: bool
diff --git a/api/routes.py b/api/routes.py
index 60494942..e7ec9487 100644
--- a/api/routes.py
+++ b/api/routes.py
@@ -12,6 +12,7 @@ from . import dependencies
from .dependencies import get_settings, require_api_key
from .gateway_model_ids import gateway_model_id, no_thinking_gateway_model_id
from .models.anthropic import MessagesRequest, TokenCountRequest
+from .models.openai_responses import OpenAIResponsesRequest
from .models.responses import ModelResponse, ModelsListResponse
from .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.py
index 6286bade..cfc34f69 100644
--- a/api/services.py
+++ b/api/services.py
@@ -8,18 +8,30 @@ from collections.abc import AsyncIterator, Callable
from typing import Any
from fastapi import HTTPException
-from fastapi.responses import StreamingResponse
+from fastapi.responses import JSONResponse, StreamingResponse
from loguru import logger
+from pydantic import BaseModel
from config.settings import Settings
from core.anthropic import get_token_count, get_user_facing_error_message
from 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_stream
from providers.base import BaseProvider
from providers.exceptions import InvalidRequestError, ProviderError
from .model_router import ModelRouter
from .models.anthropic import MessagesRequest, TokenCountRequest
+from .models.openai_responses import OpenAIResponsesRequest
from .models.responses import TokenCountResponse
from .optimization_handlers import try_optimizations
from .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 chunk
diff --git a/cli/adapters/__init__.py b/cli/adapters/__init__.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 exc
diff --git a/cli/entrypoints.py b/cli/entrypoints.py
index 2da2ed31..d1cc823d 100644
--- a/cli/entrypoints.py
+++ b/cli/entrypoints.py
@@ -18,6 +18,9 @@ import uvicorn
from api.admin_urls import local_admin_url, local_proxy_root_url
from 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_ADAPTER
from 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 = None
try:
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 None
except KeyboardInterrupt:
if process is not None and process.pid:
diff --git a/cli/manager.py b/cli/manager.py
index 303c01e0..7f080f0b 100644
--- a/cli/manager.py
+++ b/cli/manager.py
@@ -11,6 +11,8 @@ import uuid
from loguru import logger
+from .adapters.base import ClientCliAdapter
+from .adapters.registry import get_client_cli_adapter
from .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_directory
self.claude_bin = claude_bin
self.auth_token = auth_token
+ self._client_cli_adapter = client_cli_adapter or get_client_cli_adapter()
self._log_raw_cli_diagnostics = log_raw_cli_diagnostics
self._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_session
diff --git a/cli/session.py b/cli/session.py
index fc11f62f..19801fd3 100644
--- a/cli/session.py
+++ b/cli/session.py
@@ -1,7 +1,6 @@
"""Claude Code CLI session management."""
import asyncio
-import json
import os
from collections.abc import AsyncGenerator
from dataclasses import dataclass, field
@@ -11,6 +10,8 @@ from loguru import logger
from core.trace import trace_event
+from .adapters.base import ClientCliAdapter, CliParseState, CliTaskRequest
+from .adapters.registry import get_client_cli_adapter
from .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_directory
self.claude_bin = self.config.claude_bin
self.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_diagnostics
self.process: asyncio.subprocess.Process | None = None
self.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 = None
if 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 = True
yield event
break
@@ -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 = True
yield event
except 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_id
yield 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.py
index 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")
@classmethod
def validate_whisper_device(cls, v: str) -> str:
diff --git a/core/openai_responses/__init__.py b/core/openai_responses/__init__.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.toml
index 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.py
index 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.py
index 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.py
index 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 == 200
assert 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.py
index 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.py
index 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 headers
diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 2b3e282f..0ee10b1e 100644
--- a/tests/cli/test_cli.py
+++ b/tests/cli/test_cli.py
@@ -3,7 +3,8 @@
import asyncio
import json
import os
-from typing import cast
+from collections.abc import Iterable, Mapping
+from typing import Any, cast
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@@ -639,6 +640,117 @@ class TestCLISession:
assert len(events) == 1
assert 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.asyncio
async 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.py
index 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, patch
import pytest
+def _fake_client_cli_adapter():
+ adapter = MagicMock()
+ adapter.id = "fake"
+ return adapter
+
+
@pytest.mark.asyncio
async 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"] == 0
assert 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 adapter
diff --git a/tests/cli/test_entrypoints.py b/tests/cli/test_entrypoints.py
index 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_claude
diff --git a/tests/core/openai_responses/test_conversion.py b/tests/core/openai_responses/test_conversion.py
new file mode 100644
index 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.py
new file mode 100644
index 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.lock
index 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" },