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
7.2 KB
Raw Blame
import json

import httpx2
import pytest
from fastapi.testclient import TestClient

from free_claude_code.core.anthropic.stream_contracts import (
    assert_anthropic_stream_contract,
    parse_sse_text,
    text_content,
)
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.openai_codex.auth import (
    OpenAIAccess,
    OpenAIAuthManager,
)
from free_claude_code.providers.openai_codex.provider import OpenAICodexProvider
from tests.api.support import create_test_app
from tests.providers.support import make_provider_config


class _FakeOpenAIAuth(OpenAIAuthManager):
    async def access(self, *, force_refresh: bool = False) -> OpenAIAccess:
        return OpenAIAccess("access", "account", False)

    async def recover_unauthorized(self, rejected_token: str) -> OpenAIAccess:
        raise AssertionError("The compatibility request must not require auth recovery")


def _complete_stream(text: str) -> str:
    events = [
        (
            "response.created",
            {"type": "response.created", "response": {"id": "resp_1"}},
        ),
        (
            "response.output_text.delta",
            {"type": "response.output_text.delta", "delta": text},
        ),
        (
            "response.completed",
            {
                "type": "response.completed",
                "response": {
                    "id": "resp_1",
                    "usage": {"input_tokens": 3, "output_tokens": 2},
                },
            },
        ),
    ]
    return "".join(
        f"event: {event_type}\ndata: {json.dumps(payload)}\n\n"
        for event_type, payload in events
    )


def _openai_provider(
    upstream_requests: list[httpx2.Request],
    *,
    response_text: str,
) -> OpenAICodexProvider:
    def handler(request: httpx2.Request) -> httpx2.Response:
        upstream_requests.append(request)
        return httpx2.Response(
            200,
            content=_complete_stream(response_text).encode(),
            request=request,
        )

    provider = OpenAICodexProvider(
        make_provider_config(
            api_key="",
            base_url="https://chatgpt.com/backend-api/codex",
        ),
        auth=_FakeOpenAIAuth(),
        admission=ProviderAdmissionController(
            provider_name="openai",
            rate_limit=100,
            rate_window=1,
            max_concurrency=2,
            base_delay=0,
            max_delay=0,
            jitter=0,
        ),
        transport=httpx2.MockTransport(handler),
    )
    return provider


@pytest.mark.asyncio
@pytest.mark.parametrize("display", ["summarized", "omitted", "updates"])
async def test_messages_accepts_current_claude_controls_for_openai_provider(
    display: str,
) -> None:
    upstream_requests: list[httpx2.Request] = []
    provider = _openai_provider(
        upstream_requests,
        response_text="hello",
    )
    app = create_test_app(providers={"openai": provider})

    try:
        with TestClient(app) as client:
            response = client.post(
                "/v1/messages",
                json={
                    "model": "openai/gpt-test",
                    "max_tokens": 1024,
                    "messages": [{"role": "user", "content": "hello"}],
                    "metadata": {"user_id": "example-user"},
                    "thinking": {"type": "adaptive", "display": display},
                    "context_management": {
                        "edits": [
                            {
                                "type": "clear_thinking_20251015",
                                "keep": "all",
                            }
                        ]
                    },
                    "output_config": {"effort": "high"},
                    "stream": True,
                },
            )
    finally:
        await provider.cleanup()

    assert response.status_code == 200
    assert response.headers["content-type"].startswith("text/event-stream")
    events = parse_sse_text(response.text)
    assert_anthropic_stream_contract(events)
    assert text_content(events) == "hello"
    assert len(upstream_requests) == 1
    payload = json.loads(upstream_requests[0].content)
    assert payload["model"] == "gpt-test"
    assert payload["reasoning"] == {"effort": "high", "summary": "auto"}
    assert "max_output_tokens" not in payload
    assert "metadata" not in payload
    assert "context_management" not in payload
    assert "output_config" not in payload


@pytest.mark.asyncio
async def test_messages_auto_mode_classifier_composes_with_openai_provider() -> None:
    upstream_requests: list[httpx2.Request] = []
    provider = _openai_provider(
        upstream_requests,
        response_text="<severity>0</severity>",
    )
    app = create_test_app(providers={"openai": provider})

    try:
        with TestClient(app) as client:
            response = client.post(
                "/v1/messages?beta=true",
                json={
                    "model": "openai/gpt-test",
                    "max_tokens": 64,
                    "system": (
                        "Classify the command's safety. "
                        "Output <severity>N</severity> where N is the numeric "
                        "severity."
                    ),
                    "messages": [
                        {
                            "role": "user",
                            "content": (
                                "<transcript>\nUser: inspect a file\n"
                                "Bash: cat the file\n</transcript>"
                            ),
                        }
                    ],
                    "stop_sequences": ["</severity>"],
                },
            )
    finally:
        await provider.cleanup()

    assert response.status_code == 200
    assert response.headers["content-type"].startswith("application/json")
    body = response.json()
    assert body["content"] == [{"type": "text", "text": "<severity>0</severity>"}]
    assert body["stop_reason"] == "end_turn"
    assert len(upstream_requests) == 1
    payload = json.loads(upstream_requests[0].content)
    assert payload["model"] == "gpt-test"
    assert payload["reasoning"] == {"effort": "none"}
    assert "stop" not in payload
    assert "stop_sequences" not in payload


@pytest.mark.asyncio
async def test_messages_non_classifier_stop_remains_lossy_for_openai_provider() -> None:
    upstream_requests: list[httpx2.Request] = []
    provider = _openai_provider(
        upstream_requests,
        response_text="unreachable",
    )
    app = create_test_app(providers={"openai": provider})

    try:
        with TestClient(app) as client:
            response = client.post(
                "/v1/messages",
                json={
                    "model": "openai/gpt-test",
                    "max_tokens": 64,
                    "messages": [{"role": "user", "content": "hello"}],
                    "stop_sequences": ["caller-owned-stop"],
                },
            )
    finally:
        await provider.cleanup()

    assert response.status_code == 400
    body = response.json()
    assert body["error"]["type"] == "invalid_request_error"
    assert "cannot represent" in body["error"]["message"]
    assert "stop_sequences" in body["error"]["message"]
    assert upstream_requests == []