coproxy 0.5.0

OpenAI-compatible API proxy backed by GitHub Copilot
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

from __future__ import annotations

import os
from typing import Any, AsyncIterator, Iterator, cast

import pytest
import pytest_asyncio
from anthropic import APIStatusError, Anthropic, AsyncAnthropic


API_KEY = os.environ.get("TEST_API_KEY", "compat-test-key")
BASE_URL = os.environ.get("TEST_ANTHROPIC_BASE_URL", "http://127.0.0.1:4011")
TEST_MODEL = os.environ.get("TEST_ANTHROPIC_MODEL", "claude-haiku-4.5")
TEST_IMAGE_MODEL = os.environ.get("TEST_ANTHROPIC_IMAGE_MODEL", "claude-opus-4.7")

# 1x1 transparent PNG — minimal payload to verify image content blocks flow
# through the proxy without changing upstream model behavior.
TEST_IMAGE_PNG_B64 = (
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAA"
    "C0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
)


@pytest.fixture(scope="session")
def anthropic_client() -> Iterator[Anthropic]:
    with Anthropic(api_key=API_KEY, base_url=BASE_URL) as c:
        yield c


@pytest_asyncio.fixture
async def async_anthropic_client() -> AsyncIterator[AsyncAnthropic]:
    async with AsyncAnthropic(api_key=API_KEY, base_url=BASE_URL) as c:
        yield c


@pytest.fixture(scope="session")
def anthropic_model() -> str:
    return TEST_MODEL


def _error_code(exc: APIStatusError) -> str | None:
    if not isinstance(exc.body, dict):
        return None
    body = cast(dict[str, Any], exc.body)
    code = body.get("code")
    return code if isinstance(code, str) else None


def _messages_available(client: Anthropic, model: str) -> bool:
    try:
        client.messages.create(
            model=model,
            max_tokens=8,
            messages=[{"role": "user", "content": "ping"}],
        )
    except APIStatusError as exc:
        if exc.status_code == 401:
            return False
        if _error_code(exc) in {"model_not_supported", "unsupported_api_for_model"}:
            return False
        return False
    except Exception:
        return False
    return True


@pytest.fixture(scope="session")
def messages_available(anthropic_client: Anthropic, anthropic_model: str) -> bool:
    return _messages_available(anthropic_client, anthropic_model)


@pytest.fixture(scope="session")
def anthropic_image_model() -> str:
    return TEST_IMAGE_MODEL


@pytest.fixture(scope="session")
def anthropic_image_png_b64() -> str:
    return TEST_IMAGE_PNG_B64


def _image_messages_available(client: Anthropic, model: str) -> bool:
    try:
        client.messages.create(
            model=model,
            max_tokens=8,
            messages=[
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": "ping"},
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": TEST_IMAGE_PNG_B64,
                            },
                        },
                    ],
                }
            ],
        )
    except APIStatusError as exc:
        if exc.status_code == 401:
            return False
        if _error_code(exc) in {"model_not_supported", "unsupported_api_for_model"}:
            return False
        return False
    except Exception:
        return False
    return True


@pytest.fixture(scope="session")
def anthropic_image_model_available(
    anthropic_client: Anthropic, anthropic_image_model: str
) -> bool:
    return _image_messages_available(anthropic_client, anthropic_image_model)