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
10.3 KB
Raw Blame
"""Direct OpenAI Platform API provider wiring across both FCC request protocols."""

import json
from collections.abc import AsyncIterator
from typing import Any

import httpx2
import pytest

from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import (
    parse_sse_text,
    text_content,
)
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.providers.openai_api.provider import OpenAIAPIProvider
from free_claude_code.providers.runtime.config import build_provider_config
from tests.providers.support import immediate_admission, make_provider_config


def _sse(*events: tuple[str, dict[str, Any]]) -> str:
    return "".join(
        f"event: {name}\ndata: {json.dumps(payload)}\n\n" for name, payload in events
    )


def _complete_stream(text: str) -> str:
    return _sse(
        (
            "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},
                },
            },
        ),
    )


def _provider(
    handler: httpx2.MockTransport, *, max_attempts: int = 1
) -> OpenAIAPIProvider:
    return OpenAIAPIProvider(
        make_provider_config("platform-key", "https://api.openai.com/v1"),
        admission=immediate_admission(
            provider_name="openai_api", max_attempts=max_attempts
        ),
        transport=handler,
    )


async def _collect(stream: AsyncIterator[str]) -> str:
    return "".join([chunk async for chunk in stream])


@pytest.mark.asyncio
@pytest.mark.parametrize("ingress", ["messages", "responses"])
async def test_key_one_authenticates_discovery_and_failure_never_tries_later_keys(
    ingress,
):
    requests = []

    def reply(request):
        requests.append(request)
        if request.url.path == "/v1/models":
            return httpx2.Response(
                200,
                json={
                    "object": "list",
                    "data": [
                        {
                            "id": "gpt-test",
                            "object": "model",
                            "created": 0,
                            "owned_by": "test",
                        }
                    ],
                },
            )
        return httpx2.Response(
            401,
            json={
                "error": {
                    "message": "Invalid API key",
                    "type": "authentication_error",
                    "code": "invalid_api_key",
                }
            },
        )

    settings = Settings(OPENAI_API_KEY=["runtime-first", "runtime-inactive"])
    provider = OpenAIAPIProvider(
        build_provider_config(PROVIDER_CATALOG["openai_api"], settings),
        admission=immediate_admission(provider_name="openai_api", max_attempts=1),
        transport=httpx2.MockTransport(reply),
    )
    try:
        assert {model.model_id for model in await provider.list_model_infos()} == {
            "gpt-test"
        }
        with pytest.raises(ExecutionFailure):
            stream = (
                provider.stream_messages(
                    MessagesRequest(
                        model="gpt-test",
                        max_tokens=64,
                        messages=[{"role": "user", "content": "Hello"}],
                    )
                )
                if ingress == "messages"
                else provider.stream_responses(
                    OpenAIResponsesRequest(model="gpt-test", input="Hello")
                )
            )
            await _collect(stream)
    finally:
        await provider.cleanup()
    assert [request.url.path for request in requests] == ["/v1/models", "/v1/responses"]
    assert [request.headers["authorization"] for request in requests] == [
        "Bearer runtime-first",
        "Bearer runtime-first",
    ]


@pytest.mark.asyncio
@pytest.mark.parametrize("ingress", ["messages", "responses"])
async def test_api_key_provider_uses_public_responses_endpoint(
    ingress: str,
) -> None:
    requests: list[httpx2.Request] = []

    def handler(request: httpx2.Request) -> httpx2.Response:
        requests.append(request)
        return httpx2.Response(
            200,
            text=_complete_stream("hello"),
            headers={"content-type": "text/event-stream"},
            request=request,
        )

    provider = _provider(httpx2.MockTransport(handler))
    try:
        if ingress == "messages":
            output = await _collect(
                provider.stream_messages(
                    MessagesRequest.model_validate(
                        {
                            "model": "gpt-test",
                            "max_tokens": 64,
                            "messages": [{"role": "user", "content": "hello"}],
                        }
                    )
                )
            )
            assert text_content(parse_sse_text(output)) == "hello"
        else:
            output = await _collect(
                provider.stream_responses(
                    OpenAIResponsesRequest.model_validate(
                        {
                            "model": "gpt-test",
                            "input": [{"role": "user", "content": "hello"}],
                            "max_output_tokens": 64,
                            "metadata": {"source": "api-key-test"},
                        }
                    )
                )
            )
            assert "response.completed" in output
    finally:
        await provider.cleanup()

    assert len(requests) == 1
    request = requests[0]
    assert str(request.url) == "https://api.openai.com/v1/responses"
    assert request.headers["authorization"] == "Bearer platform-key"
    assert "originator" not in request.headers
    assert "chatgpt-account-id" not in request.headers
    body = json.loads(request.content)
    assert body["model"] == "gpt-test"
    assert body["store"] is False
    assert body["max_output_tokens"] == 64
    if ingress == "responses":
        assert body["metadata"] == {"source": "api-key-test"}


@pytest.mark.asyncio
async def test_api_key_model_discovery_keeps_every_returned_id_unknown() -> None:
    requests: list[httpx2.Request] = []

    def handler(request: httpx2.Request) -> httpx2.Response:
        requests.append(request)
        return httpx2.Response(
            200,
            json={
                "object": "list",
                "data": [
                    {"id": "gpt-test", "object": "model", "owned_by": "openai"},
                    {
                        "id": "text-embedding-test",
                        "object": "model",
                        "owned_by": "openai",
                    },
                ],
            },
            request=request,
        )

    provider = _provider(httpx2.MockTransport(handler))
    try:
        models = await provider.list_model_infos()
    finally:
        await provider.cleanup()

    assert models == frozenset(
        {ProviderModelInfo("gpt-test"), ProviderModelInfo("text-embedding-test")}
    )
    assert str(requests[0].url) == "https://api.openai.com/v1/models"
    assert requests[0].headers["authorization"] == "Bearer platform-key"


@pytest.mark.asyncio
async def test_api_key_provider_preserves_tool_calls() -> None:
    tool_name = "mcp__example__search"
    upstream_bodies: list[dict[str, Any]] = []

    def handler(request: httpx2.Request) -> httpx2.Response:
        body = json.loads(request.content)
        upstream_bodies.append(body)
        return httpx2.Response(
            200,
            text=_sse(
                (
                    "response.output_item.added",
                    {
                        "type": "response.output_item.added",
                        "item": {
                            "type": "function_call",
                            "id": "fc_1",
                            "call_id": "call_1",
                            "name": tool_name,
                        },
                    },
                ),
                (
                    "response.output_item.done",
                    {
                        "type": "response.output_item.done",
                        "item": {
                            "type": "function_call",
                            "id": "fc_1",
                            "call_id": "call_1",
                            "name": tool_name,
                            "arguments": "{}",
                        },
                    },
                ),
                (
                    "response.completed",
                    {
                        "type": "response.completed",
                        "response": {"id": "resp_1"},
                    },
                ),
            ),
            headers={"content-type": "text/event-stream"},
            request=request,
        )

    provider = _provider(httpx2.MockTransport(handler))
    try:
        events = parse_sse_text(
            await _collect(
                provider.stream_messages(
                    MessagesRequest.model_validate(
                        {
                            "model": "gpt-test",
                            "messages": [{"role": "user", "content": "search"}],
                            "tools": [
                                {
                                    "name": tool_name,
                                    "input_schema": {"type": "object"},
                                }
                            ],
                        }
                    )
                )
            )
        )
    finally:
        await provider.cleanup()

    assert upstream_bodies[0]["tools"][0]["name"] == tool_name
    tool_start = next(
        event.data["content_block"]
        for event in events
        if event.event == "content_block_start"
    )
    assert tool_start["name"] == tool_name