File size: 4,027 Bytes
a9e27c0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Generic fallback into signed Gemini output remains replayable next turn."""

import json
from unittest.mock import patch

import httpx
import httpx2
import pytest
from fastapi.testclient import TestClient
from openai import AsyncOpenAI

from free_claude_code.config.model_refs import ModelFallback
from free_claude_code.config.settings import Settings
from free_claude_code.providers.gemini import GeminiProvider
from free_claude_code.providers.open_router import OpenRouterProvider
from tests.api.support import create_test_app
from tests.api.test_delivered_stream_recovery import text_events
from tests.api.test_four_protocol_matrix import response_value
from tests.api.test_gemini_continuation_replay import body, native
from tests.providers.support import immediate_admission, make_provider_config


@pytest.mark.parametrize("wire", ["messages", "chat", "responses", "gemini"])
def test_fallback_into_gemini_and_followup(wire, monkeypatch):
    calls = []

    def chat_reply(request):
        calls.append(("chat", json.loads(request.content)))
        return httpx2.Response(
            200,
            headers={"content-type": "text/event-stream"},
            text="".join(
                "data: " + json.dumps(e) + "\n\n"
                for e in text_events("chat", "The answer ", complete=False)
            ),
        )

    def gemini_reply(request):
        calls.append(("gemini", json.loads(request.content)))
        event = native(
            "is 42." if sum(k == "gemini" for k, b in calls) == 1 else "FOLLOWUP_OK",
            True,
        )
        return httpx.Response(
            200,
            headers={"content-type": "text/event-stream"},
            text="data: " + json.dumps(event) + "\n\n",
        )

    sdk = AsyncOpenAI(
        api_key="test",
        http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(chat_reply)),
        max_retries=0,
    )
    with patch(
        "free_claude_code.providers.openai_chat.client.AsyncOpenAI", return_value=sdk
    ):
        chat = OpenRouterProvider(
            make_provider_config(api_key="test", base_url="https://chat.invalid/v1"),
            admission=immediate_admission(max_attempts=1),
        )
    gemini = GeminiProvider(
        make_provider_config(api_key="test", base_url="https://google.invalid/v1beta"),
        admission=immediate_admission(max_attempts=1),
        transport=httpx.MockTransport(gemini_reply),
    )
    app = create_test_app(
        Settings(
            MODEL="open_router/primary",
            MODEL_FALLBACKS=[ModelFallback(model="gemini/models/backup")],
        ),
        providers={"open_router": chat, "gemini": gemini},
    )
    first = (
        {"role": "user", "parts": [{"text": "hello"}]}
        if wire == "gemini"
        else {"role": "user", "content": "hello"}
    )
    path, request = body(wire, [first])
    with TestClient(app) as client:
        response = client.post(path, json=request)
        value = response_value(response, wire, True)
        assert [k for k, b in calls] == ["chat", "gemini"]
        if wire == "messages":
            history = [
                first,
                {"role": "assistant", "content": value["content"]},
                {"role": "user", "content": "next"},
            ]
        elif wire == "chat":
            history = [
                first,
                value["choices"][0]["message"],
                {"role": "user", "content": "next"},
            ]
        elif wire == "responses":
            history = [first, *value["output"], {"role": "user", "content": "next"}]
        else:
            history = [
                first,
                value["candidates"][0]["content"],
                {"role": "user", "parts": [{"text": "next"}]},
            ]
        _, request = body(wire, history)
        response = client.post(path, json=request)
        response_value(response, wire, True)
        assert "FOLLOWUP_OK" in response.text
        assert [k for k, b in calls] == ["chat", "gemini", "gemini"]