Skip to content

Your lightweight open-source personal agent.

34.3 KB
Raw Blame
import asyncio
import json

import httpx
import pytest
from anthropic import AsyncAnthropic
from openai import AsyncOpenAI
from pydantic import ValidationError

from nanobot.agent.tools.web import WebSearchTool
from nanobot.config.schema import (
    Config,
    InlineFallbackConfig,
    ModelAPIConfig,
    ModelPresetConfig,
    ProviderAPIConfig,
)
from nanobot.providers.anthropic_provider import AnthropicProvider
from nanobot.providers.factory import (
    make_provider,
    provider_signature,
    resolve_automatic_model_api,
    validate_provider_setup,
)
from nanobot.providers.openai_compat_provider import _RESPONSES_FAILURE_THRESHOLD


def _config() -> Config:
    return Config.model_validate({
        "agents": {"defaults": {"modelPreset": "responses"}},
        "providers": {"tenant": {"apiBase": "https://tenant.test/v1", "apiKey": "fixture"}},
        "modelPresets": {
            "responses": {
                "provider": "tenant", "model": "gpt-6-luna", "reasoningEffort": "high",
                "api": {"supportedApis": ["responses"], "preferredApi": "responses"},
            },
            "chat": {
                "provider": "tenant", "model": "gpt-6-luna",
                "api": {"supportedApis": ["chat_completions"]},
            },
            "messages": {
                "provider": "tenant", "model": "tenant/claude-sonnet-4-6",
                "reasoningEffort": "high",
                "api": {"supportedApis": ["anthropic_messages"]},
            },
        },
    })


@pytest.mark.parametrize("entrypoint", ["sdk", "factory"])
@pytest.mark.parametrize("target", ["tenant_a", "tenant_b"])
@pytest.mark.parametrize("literal_env_syntax", [False, True])
async def test_model_override_keeps_request_settings_within_connection(
    bind_transport, entrypoint, target, literal_env_syntax, monkeypatch,
):
    from nanobot.agent.model_runtime import ModelRuntimeResolver
    from nanobot.providers.factory import build_provider_snapshot
    from nanobot.utils.llm_runtime import runtime_from_provider_snapshot

    config = Config.model_validate({
        "agents": {"defaults": {"modelPreset": "primary"}},
        "providers": {name: {
            "apiBase": "https://shared-gateway.test/v1", "apiKey": "fixture",
            "extraHeaders": {"X-Connection": name},
            "extraQuery": {"connection": name}, "extraBody": {"connection": name},
        } for name in (target, "tenant_b" if target == "tenant_a" else "tenant_a")},
        "modelPresets": {"primary": {
            "provider": "auto", "model": "tenant_a/old-model", "temperature": 0.3,
            "extraHeaders": {"X-Tenant-Token": "source-secret"},
            "extraQuery": {"api_key": "source-secret"},
            "extraBody": {"metadata": {"token": "source-secret"}},
        }},
    })
    before = config.model_dump()
    model = f"{target}/new-model"
    if literal_env_syntax:
        monkeypatch.setenv("NANOBOT_TEST_CALL_MODEL", "tenant_a/env-model")
        model = "${NANOBOT_TEST_CALL_MODEL}"
    if entrypoint == "sdk":
        resolver = ModelRuntimeResolver(runtime_from_provider_snapshot(build_provider_snapshot(config)))
        runtime = resolver.resolve_override(model=model, model_preset=None, config=config)
        provider = runtime.provider
        assert runtime.generation.temperature == 0.3
        assert resolver.runtime.model == "tenant_a/old-model"
    else:
        provider = make_provider(config, model=model)
    requests = []

    def handler(request):
        requests.append(request)
        return _answer(request)

    await provider._ensure_client()
    provider = bind_transport(provider, handler)
    assert (await provider.chat([{"role": "user", "content": "hello"}], model=model)).content == "ok"
    if entrypoint == "sdk":
        repeated = resolver.resolve_override(model=model, model_preset=None, config=config)
        assert repeated.provider is provider
        assert (await repeated.provider.chat([{"role": "user", "content": "again"}], model=model)).content == "ok"
    assert len(requests) == (2 if entrypoint == "sdk" else 1)
    for request in requests:
        body = json.loads(request.content)
        assert request.headers["X-Connection"] == target
        assert request.url.params["connection"] == body["connection"] == target
        if target == "tenant_a":
            assert request.headers["X-Tenant-Token"] == "source-secret"
            assert request.url.params["api_key"] == "source-secret"
            assert body["metadata"] == {"token": "source-secret"}
        else:
            assert "X-Tenant-Token" not in request.headers
            assert "api_key" not in request.url.params
            assert "metadata" not in body
    assert config.model_dump() == before


def _answer(request: httpx.Request) -> httpx.Response:
    if request.url.path.endswith("/responses"):
        response = {
            "id": "resp_fixture", "object": "response", "status": "completed",
            "output": [{
                "id": "msg_fixture", "type": "message", "role": "assistant", "status": "completed",
                "content": [{"type": "output_text", "text": "ok", "annotations": []}],
            }],
        }
        events = [
            {"type": "response.output_text.delta", "delta": "ok"},
            {"type": "response.completed", "response": response},
        ]
    elif request.url.path.endswith("/messages"):
        response = {
            "id": "msg_fixture", "type": "message", "role": "assistant",
            "model": "claude-sonnet-4-6", "content": [{"type": "text", "text": "ok"}],
            "stop_reason": "end_turn", "stop_sequence": None,
            "usage": {"input_tokens": 3, "output_tokens": 2},
        }
        events = [
            {"type": "message_start", "message": {**response, "content": [], "stop_reason": None}},
            {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}},
            {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "ok"}},
            {"type": "content_block_stop", "index": 0},
            {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": None}, "usage": {"output_tokens": 2}},
            {"type": "message_stop"},
        ]
    else:
        response = {"id": "chat_fixture", "choices": [{
            "index": 0, "message": {"role": "assistant", "content": "ok"}, "finish_reason": "stop",
        }]}
        events = [{"choices": [{"index": 0, "delta": {"content": "ok"}, "finish_reason": "stop"}]}]
    if not json.loads(request.content).get("stream"):
        return httpx.Response(200, json=response)
    return httpx.Response(
        200, headers={"content-type": "text/event-stream"},
        content="".join(f"event: {event.get('type', 'message')}\ndata: {json.dumps(event)}\n\n" for event in events),
    )


@pytest.fixture
async def bind_transport():
    clients = []

    def bind(provider, handler, *, api_base=None):
        original = provider._client
        if original is not None:
            clients.append(original)
        client_type = AsyncAnthropic if isinstance(provider, AnthropicProvider) else AsyncOpenAI
        client = client_type(
            api_key="fixture", base_url=api_base or (str(original.base_url) if original else "https://tenant.test/v1"),
            default_headers=original.default_headers if original else None,
            default_query=original.default_query if original else None,
            max_retries=0,
            http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
        )
        clients.append(client)
        provider._client = client
        provider._CHAT_RETRY_DELAYS = ()
        return provider

    yield bind
    for client in clients:
        await client.close()


@pytest.mark.parametrize("preset_name", ["chat", "responses", "messages"])
async def test_preset_overrides_isolate_requests_and_preserve_prompt_prefix(bind_transport, preset_name):
    config = _config()
    connection = config.get_provider(preset=config.model_presets[preset_name])
    connection.extra_headers = {"X-Route": "shared", "X-Keep": "yes"}
    connection.extra_query = {"route": "shared", "keep": "yes"}
    connection.extra_body = {"metadata": {"shared": "yes"}, "store": False}
    before = connection.model_dump()
    requests = []

    def handler(request):
        requests.append(request)
        return _answer(request)

    baseline = config.model_presets[preset_name]
    override = baseline.model_copy(deep=True)
    override.extra_headers = {"x-route": "preset"}
    override.extra_query = {"route": "preset"}
    override.extra_body = {"metadata": {"local": "yes"}}
    shared = make_provider(config, preset=baseline)
    custom = make_provider(config, preset=override)
    for provider in (shared, custom):
        if not isinstance(provider, AnthropicProvider):
            await provider._ensure_client()
        bind_transport(provider, handler)
    signature = provider_signature(config, preset=override)
    override.extra_body["metadata"]["local"] = "later"
    assert signature != provider_signature(config, preset=override)
    messages = [{"role": "system", "content": "stable"}, {"role": "user", "content": "hello"}]
    tools = [{"type": "function", "function": {"name": "read_file", "description": "Read", "parameters": {"type": "object"}}}]
    await asyncio.gather(shared.chat(messages, tools=tools), custom.chat(messages, tools=tools))
    await shared.chat(messages, tools=tools)
    by_route = {request.headers["x-route"]: request for request in requests}
    base_body = json.loads(by_route["shared"].content)
    changed_body = json.loads(by_route["preset"].content)
    assert changed_body.pop("metadata") == {"local": "yes"}
    assert base_body.pop("metadata") == {"shared": "yes"}
    assert changed_body == base_body
    assert by_route["preset"].headers.get_list("x-route") == ["preset"]
    assert all(request.headers["x-keep"] == "yes" for request in requests)
    assert by_route["preset"].url.params["route"] == "preset"
    assert by_route["shared"].url.params["route"] == "shared"
    assert connection.model_dump() == before


def test_preset_override_fallbacks_and_roundtrip(tmp_path):
    from nanobot.config.loader import load_config, save_config
    from nanobot.providers.factory import _resolve_fallback_presets
    from nanobot.providers.routing import resolve_provider_route

    config = _config()
    primary = config.model_presets["chat"]
    primary.extra_headers = {"X-Route": "primary"}
    config.model_presets["responses"].extra_headers = {"X-Route": "named"}
    config.agents.defaults.fallback_models = [
        "responses", InlineFallbackConfig(model="gpt-6-luna", provider="tenant", extra_headers={"X-Route": "inline"}),
    ]
    config_path = tmp_path / "config.json"
    save_config(config, config_path)
    loaded = load_config(config_path)
    assert loaded.model_presets["chat"] == primary
    fallbacks = _resolve_fallback_presets(loaded, primary)
    assert [resolve_provider_route(loaded, preset=p).provider_config.extra_headers for p in fallbacks] == [
        {"X-Route": "named"}, {"X-Route": "inline"},
    ]
    old_signature = provider_signature(loaded, preset_name="chat")
    loaded.model_presets["responses"].extra_headers = {"X-Route": "changed"}
    assert provider_signature(loaded, preset_name="chat") != old_signature


def test_unsupported_preset_overrides_fail_before_client_creation():
    config = Config()
    with pytest.raises(ValueError, match="extra_headers is not supported"):
        validate_provider_setup(config, preset=ModelPresetConfig(
            provider="openai_codex", model="gpt-6-luna", extra_headers={"X-Route": "unsupported"},
        ))


@pytest.mark.parametrize("stream", [False, True])
@pytest.mark.parametrize("effort", [None, "none", "low"])
async def test_mimo_responses_preserves_reasoning_setting(bind_transport, stream, effort):
    config = Config.model_validate({"providers": {"xiaomi_mimo": {"apiKey": "fixture"}}})
    preset = ModelPresetConfig(
        provider="xiaomi_mimo", model="mimo-v2.5-pro", reasoning_effort=effort,
        api=ModelAPIConfig(supported_apis=["responses"]),
    )
    requests = []

    def handler(request):
        requests.append(request)
        return _answer(request)

    provider = bind_transport(make_provider(config, preset=preset), handler)
    invoke = provider.chat_stream_with_retry if stream else provider.chat_with_retry
    result = await invoke([{"role": "user", "content": "hello"}])
    assert result.content == "ok"
    assert len(requests) == 1
    assert requests[0].url.path == "/v1/responses"
    body = json.loads(requests[0].content)
    assert body.get("reasoning") == ({"effort": effort} if effort is not None else None)


@pytest.mark.parametrize("stream", [False, True])
@pytest.mark.parametrize(("provider_name", "model", "api_base", "effort"), [
    ("tenant", "gpt-6-luna", "https://tenant.test/v1", "high"),
    ("openai", "openai/gpt-6-luna", "https://api.openai.com/v1", None),
    ("openai", "gpt-6-luna", "https://tenant.test/v1", "high"),
    ("openai", "gpt-4o", "https://api.openai.com/v1", "high"),
    ("opencode_go", "opencode-go/muse-spark-1.3-contributor", "https://opencode.ai/zen/go/v1", None),
    ("deepseek", "deepseek-flash", "https://api.deepseek.com/v1", None),
    ("deepseek", "deepseek/deepseek-flash", "https://api.deepseek.com/v1", None),
])
async def test_automatic_preview_matches_actual_request(
    bind_transport, stream, provider_name, model, api_base, effort,
):
    config = Config.model_validate({
        "providers": {provider_name: {"apiBase": api_base, "apiKey": "fixture"}},
    })
    preset = ModelPresetConfig(model=model, provider=provider_name, reasoning_effort=effort)
    resolved_provider, api = resolve_automatic_model_api(config, preset=preset)
    paths = []

    def handler(request):
        paths.append(request.url.path)
        return _answer(request)

    provider = bind_transport(make_provider(config, preset=preset), handler)
    invoke = provider.chat_stream if stream else provider.chat
    response = await invoke([{"role": "user", "content": "hello"}], reasoning_effort=effort)
    assert response.content == "ok"
    assert resolved_provider == provider_name
    assert paths == ["/v1/responses" if api == "responses" else "/v1/chat/completions"]


@pytest.mark.parametrize("stream", [False, True])
@pytest.mark.parametrize(("model", "api_base", "api"), [
    ("deepseek-flash", "https://chat-proxy.test/v1", "chat_completions"),
    ("deepseek/deepseek-flash", "https://chat-proxy.test/v1", "chat_completions"),
    ("deepseek-flash", "https://api.deepseek.com", "responses"),
    ("deepseek-flash", "https://api.deepseek.com/v1/", "responses"),
    ("deepseek-v4-flash", "https://responses-proxy.test/v1", "responses"),
])
async def test_deepseek_automatic_api_preserves_endpoint_routing(
    bind_transport, tmp_path, stream, model, api_base, api,
):
    from nanobot.config.loader import load_config

    config_path = tmp_path / "config.json"
    config_path.write_text(json.dumps({
        "providers": {"deepseek": {"apiBase": api_base, "apiKey": "fixture"}},
        "modelPresets": {"deepseek": {"provider": "deepseek", "model": model}},
        "agents": {"defaults": {"modelPreset": "deepseek"}},
    }), encoding="utf-8")
    config = load_config(config_path)
    request_path = "responses" if api == "responses" else "chat/completions"
    expected_path = f"{httpx.URL(api_base).path.rstrip('/')}/{request_path}"
    requests = []

    def handler(request):
        requests.append(request)
        if request.url.path != expected_path:
            return httpx.Response(404, json={"error": {"message": "Endpoint not supported"}})
        return _answer(request)

    provider = bind_transport(make_provider(config), handler, api_base=api_base)
    invoke = provider.chat_stream if stream else provider.chat
    result = await invoke(
        [{"role": "user", "content": "hello"}], tools=[WebSearchTool().to_schema()],
    )
    assert result.content == "ok"
    assert [request.url.path for request in requests] == [expected_path]
    assert resolve_automatic_model_api(config, preset=config.resolve_preset()) == ("deepseek", api)
    body = json.loads(requests[0].content)
    search_tool = body["tools"][0]
    assert search_tool["type"] == "function"
    assert (search_tool if api == "responses" else search_tool["function"])["name"] == "web_search"


@pytest.mark.parametrize("stream", [False, True])
@pytest.mark.parametrize(("api", "extra_body", "response_supported"), [
    ({"supportedApis": ["responses"]}, {}, True),
    (None, {"tools": [{"type": "web_search"}]}, True),
    ({"supportedApis": ["responses", "chat_completions"]}, {"tools": []}, False),
])
async def test_deepseek_proxy_accepts_explicit_responses_and_chat_fallback(
    bind_transport, stream, api, extra_body, response_supported,
):
    config = Config.model_validate({
        "providers": {"deepseek": {
            "apiBase": "https://tenant.test/v1", "apiKey": "fixture", "extraBody": extra_body,
        }},
    })
    preset = ModelPresetConfig.model_validate({"provider": "deepseek", "model": "deepseek-flash", "api": api})
    requests = []

    def handler(request):
        requests.append(request)
        if not response_supported and request.url.path.endswith("/responses"):
            return httpx.Response(404, json={"error": {"message": "Responses endpoint not supported"}})
        return _answer(request)

    provider = bind_transport(make_provider(config, preset=preset), handler)
    invoke = provider.chat_stream if stream else provider.chat
    result = await invoke([{"role": "user", "content": "hello"}])
    assert result.content == "ok"
    expected_paths = (
        ["/v1/chat/completions"] if api is None
        else ["/v1/responses"] if response_supported
        else ["/v1/responses", "/v1/chat/completions"]
    )
    assert [request.url.path for request in requests] == expected_paths
    assert json.loads(requests[0].content).get("tools", []) == []
    if api is None:
        assert resolve_automatic_model_api(config, preset=preset) == ("deepseek", "chat_completions")


@pytest.mark.parametrize("stream", [False, True])
async def test_presets_route_same_gateway_independently(bind_transport, stream):
    config = _config()
    requests = []

    def handler(request):
        requests.append(request)
        return _answer(request)

    tools = [{"type": "function", "function": {
        "name": "lookup", "parameters": {"type": "object", "properties": {}},
    }}]
    for name in ("responses", "chat", "messages"):
        provider = bind_transport(make_provider(config, preset_name=name), handler)
        invoke = provider.chat_stream if stream else provider.chat
        result = await invoke(
            [{"role": "user", "content": "hello"}], tools=tools,
            reasoning_effort=provider.generation.reasoning_effort,
        )
        assert result.content == "ok"
    assert [request.url.path for request in requests] == [
        "/v1/responses", "/v1/chat/completions", "/v1/messages",
    ]
    body = json.loads(requests[0].content)
    assert body["model"] == "gpt-6-luna"
    assert body["reasoning"] == {"effort": "high"}
    assert body["tools"][0]["name"] == "lookup"
    assert "context_management" not in body
    assert "include" not in body
    messages_body = json.loads(requests[2].content)
    assert messages_body["model"] == "claude-sonnet-4-6"
    assert messages_body["thinking"] == {"type": "enabled", "budget_tokens": 8192}
    assert messages_body["tools"][0]["name"] == "lookup"
    assert messages_body["tools"][0]["input_schema"] == tools[0]["function"]["parameters"]


@pytest.mark.parametrize("allow_chat", [False, True])
@pytest.mark.parametrize("stream", [False, True])
async def test_chat_compatibility_fallback_requires_preset_support(bind_transport, allow_chat, stream):
    config = _config()
    if allow_chat:
        config.model_presets["responses"].api = ModelAPIConfig(
            supported_apis=("responses", "chat_completions"), preferred_api="responses",
        )
    requests = []

    def handler(request):
        requests.append(request.url.path)
        if request.url.path.endswith("/responses"):
            return httpx.Response(404, json={"error": {"message": "Responses endpoint not supported", "type": "invalid_request_error"}})
        return _answer(request)

    provider = bind_transport(make_provider(config), handler)
    invoke = provider.chat_stream if stream else provider.chat
    for _ in range(_RESPONSES_FAILURE_THRESHOLD + 1):
        result = await invoke([{"role": "user", "content": "hello"}])
        assert result.finish_reason == ("stop" if allow_chat else "error")
    if allow_chat:
        assert requests == ["/v1/responses", "/v1/chat/completions"] * _RESPONSES_FAILURE_THRESHOLD + ["/v1/chat/completions"]
    else:
        assert requests == ["/v1/responses"] * (_RESPONSES_FAILURE_THRESHOLD + 1)


@pytest.mark.parametrize("inline", [False, True])
@pytest.mark.parametrize("fallback_name", ["chat", "messages"])
async def test_fallback_preset_keeps_its_api_and_invalidates_runtime(bind_transport, monkeypatch, inline, fallback_name):
    config = _config()
    fallback = config.model_presets[fallback_name]
    config.agents.defaults.fallback_models = [
        InlineFallbackConfig.model_validate(fallback.model_dump()) if inline else fallback_name,
    ]
    requests = []

    def handler(request):
        requests.append(request.url.path)
        if request.url.path.endswith("/responses"):
            return httpx.Response(401, json={"error": {"message": "invalid_api_key", "type": "authentication_error"}})
        return _answer(request)

    from nanobot.providers import factory

    original = factory._make_provider_core
    monkeypatch.setattr(factory, "_make_provider_core", lambda *args, **kwargs: bind_transport(original(*args, **kwargs), handler))
    provider = make_provider(config)
    result = await provider.chat(messages=[{"role": "user", "content": "hello"}])
    assert result.content == "ok"
    assert requests == ["/v1/responses", "/v1/messages" if fallback_name == "messages" else "/v1/chat/completions"]
    previous = provider_signature(config)
    candidate = config.agents.defaults.fallback_models[0] if inline else fallback
    candidate.api = ModelAPIConfig(supported_apis=("responses",))
    assert provider_signature(config) != previous
    config.agents.defaults.fallback_models = []
    previous = provider_signature(config)
    config.model_presets["responses"].api = None
    assert provider_signature(config) != previous


def test_preset_api_preference_must_be_supported():
    with pytest.raises(ValidationError, match="preferred_api must be one of supported_apis"):
        ModelAPIConfig.model_validate({"supportedApis": ["chat_completions"], "preferredApi": "responses"})


@pytest.mark.parametrize("other_api", ["responses", "chat_completions"])
def test_messages_rejects_cross_protocol_fallback(other_api):
    with pytest.raises(ValidationError, match="cannot be combined"):
        ModelAPIConfig(supported_apis=("anthropic_messages", other_api))


@pytest.mark.parametrize("provider_name", ["tenant", "custom", "anthropic", "openai"])
async def test_messages_declaration_validates_adapter_before_loading_client(provider_name):
    config = _config()
    config.providers.custom.api_base = "https://tenant.test/v1"
    config.providers.custom.api_key = "fixture"
    config.providers.anthropic.api_key = "fixture"
    config.providers.openai.api_key = "fixture"
    preset = config.model_presets["messages"].model_copy(update={"provider": provider_name})
    if provider_name == "openai":
        with pytest.raises(ValueError, match="does not support anthropic_messages"):
            make_provider(config, preset=preset)
    else:
        provider = make_provider(config, preset=preset)
        assert isinstance(provider, AnthropicProvider)
        await provider._client.close()


@pytest.mark.parametrize("stream", [False, True])
async def test_custom_messages_keeps_connection_options_and_tool_history(bind_transport, stream):
    config = _config()
    connection = config.get_provider(preset=config.model_presets["messages"])
    connection.extra_headers = {"X-Gateway": "fixture"}
    connection.extra_query = {"route": "claude"}
    connection.extra_body = {"metadata": {"user_id": "fixture"}}
    requests = []

    def handler(request):
        requests.append(request)
        return _answer(request)

    provider = bind_transport(make_provider(config, preset_name="messages"), handler)
    invoke = provider.chat_stream if stream else provider.chat
    result = await invoke([
        {"role": "system", "content": "Use the lookup result."},
        {"role": "user", "content": "lookup"},
        {"role": "assistant", "content": "", "tool_calls": [{
            "id": "toolu_fixture", "type": "function",
            "function": {"name": "lookup", "arguments": "{}"},
        }]},
        {"role": "tool", "tool_call_id": "toolu_fixture", "content": "found"},
    ])
    assert result.content == "ok"
    assert len(requests) == 1
    request = requests[0]
    assert request.url.path == "/v1/messages"
    assert request.url.params["route"] == "claude"
    assert request.headers["X-Gateway"] == "fixture"
    body = json.loads(request.content)
    assert body["metadata"] == {"user_id": "fixture"}
    assert body["model"] == "claude-sonnet-4-6"
    assert body["system"][0]["text"] == "Use the lookup result."
    assert body["messages"][-2]["content"][0]["type"] == "tool_use"
    assert body["messages"][-1]["content"][0]["type"] == "tool_result"
    assert body["messages"][-1]["content"][0]["tool_use_id"] == "toolu_fixture"


def test_fixed_provider_validates_preset_api_before_loading_client():
    config = Config()
    preset = ModelPresetConfig(
        provider="openai_codex", model="gpt-6-astra", api=ModelAPIConfig(supported_apis=("responses",)),
    )
    validate_provider_setup(config, preset=preset)
    preset.api = ModelAPIConfig(supported_apis=("responses", "chat_completions"))
    with pytest.raises(ValueError, match="OpenAI Codex.*does not support chat_completions"):
        validate_provider_setup(config, preset=preset)


@pytest.mark.parametrize("apis,preferred", [
    (("responses",), "responses"),
    (("chat_completions",), "chat_completions"),
    (("chat_completions", "responses"), "chat_completions"),
])
async def test_preset_overrides_openai_default_and_scopes_compaction(bind_transport, apis, preferred):
    config = _config()
    preset = config.model_presets["responses"]
    preset.provider = "openai"
    preset.api = ModelAPIConfig(supported_apis=apis, preferred_api=preferred)
    config.providers.openai.api_key = "fixture"
    config.providers.openai.api = ModelAPIConfig(supported_apis=("chat_completions",))
    requests = []

    def handler(request):
        requests.append(request.url.path)
        return _answer(request)

    provider = bind_transport(make_provider(config), handler)
    assert provider.supports_native_compaction() is (preferred == "responses")
    result = await provider.chat(messages=[{"role": "user", "content": "hello"}])
    assert result.content == "ok"
    assert requests == ["/v1/responses" if preferred == "responses" else "/v1/chat/completions"]


async def test_custom_messages_uses_its_proxy_and_does_not_inherit_native_credentials(monkeypatch):
    from anthropic import DefaultAsyncHttpxClient

    config = _config()
    connection = config.get_provider(preset=config.model_presets["messages"])
    connection.api_key = None
    config.network.proxy = "http://proxy.test:8080"
    connection.use_proxy = True
    monkeypatch.setenv("ANTHROPIC_API_KEY", "native-key")
    monkeypatch.setenv("ANTHROPIC_AUTH_TOKEN", "native-token")
    requests = []

    def handler(request):
        requests.append(request)
        return _answer(request)

    def transport(**kwargs):
        assert kwargs.pop("proxy") == config.network.proxy
        assert kwargs["trust_env"] is False
        return DefaultAsyncHttpxClient(transport=httpx.MockTransport(handler), **kwargs)

    monkeypatch.setattr("anthropic.DefaultAsyncHttpxClient", transport)
    provider = make_provider(config, preset_name="messages")
    try:
        response = await provider.chat([{"role": "user", "content": "hello"}])
        assert response.content == "ok"
        assert len(requests) == 1
        assert requests[0].headers["x-api-key"] == "no-key"
        assert "authorization" not in requests[0].headers
    finally:
        await provider.aclose()
    assert provider._client.is_closed()


@pytest.mark.parametrize("stream", [False, True])
@pytest.mark.parametrize("provider_name", ["tenant", "custom"])
@pytest.mark.parametrize("preferred,path", [
    ("chat_completions", "/v1/chat/completions"),
    ("responses", "/v1/responses"),
    ("anthropic_messages", "/v1/messages"),
])
async def test_connection_default_matches_auto_preview_and_wire(bind_transport, stream, provider_name, preferred, path):
    config = Config.model_validate({"providers": {provider_name: {
        "apiBase": "https://tenant.test/v1",
        "api": {
            "supportedApis": [preferred] if provider_name == "custom" else ["chat_completions", "responses", "anthropic_messages"],
            "preferredApi": preferred,
        },
    }}})
    preset = ModelPresetConfig(provider=provider_name, model=f"{provider_name}/served-model")
    assert resolve_automatic_model_api(config, preset=preset) == (provider_name, preferred)
    paths = []

    def handler(request):
        paths.append(request.url.path)
        return _answer(request)

    provider = bind_transport(make_provider(config, preset=preset), handler)
    messages = [{"role": "user", "content": "hello"}]
    invoke = provider.chat_stream if stream else provider.chat
    assert (await invoke(messages, model=preset.model)).content == "ok"
    assert paths == [path]


@pytest.mark.parametrize("preferred", ["responses", "anthropic_messages"])
def test_connection_single_api_constrains_presets_and_reload_signature(preferred):
    config = _config()
    before = provider_signature(config, preset_name="chat")
    connection = config.providers.model_extra["tenant"]
    connection.api = ProviderAPIConfig(supported_apis=(preferred,))
    assert provider_signature(config, preset_name="chat") != before
    auto = ModelPresetConfig(provider="tenant", model="served-model")
    assert resolve_automatic_model_api(config, preset=auto) == ("tenant", preferred)
    validate_provider_setup(config, preset=auto)
    with pytest.raises(ValueError, match="does not accept request APIs"):
        validate_provider_setup(config, preset_name="chat")
    matching = "responses" if preferred == "responses" else "messages"
    validate_provider_setup(config, preset_name=matching)


def test_custom_messages_requires_an_explicit_endpoint():
    config = Config()
    preset = ModelPresetConfig(
        provider="custom", model="served-model",
        api=ModelAPIConfig(supported_apis=("anthropic_messages",)),
    )
    with pytest.raises(ValueError, match="requires api_base"):
        validate_provider_setup(config, preset=preset)


@pytest.mark.parametrize("preset_name,path", [
    ("responses", "/v1/responses"), ("chat", "/v1/chat/completions"), ("messages", "/v1/messages"),
])
async def test_explicit_model_api_overrides_connection_default(bind_transport, preset_name, path):
    config = _config()
    config.providers.model_extra["tenant"].api = ProviderAPIConfig(
        supported_apis=("chat_completions", "responses", "anthropic_messages"),
        preferred_api="anthropic_messages",
    )
    preset = config.model_presets[preset_name]
    paths = []

    def handler(request):
        paths.append(request.url.path)
        return _answer(request)

    provider = bind_transport(make_provider(config, preset=preset), handler)
    assert (await provider.chat([{"role": "user", "content": "hello"}], model=preset.model)).content == "ok"
    assert paths == [path]


@pytest.mark.parametrize("legacy,path", [
    ("auto", "/v1/chat/completions"),
    ("chat_completions", "/v1/chat/completions"),
    ("responses", "/v1/responses"),
])
async def test_migrated_openai_default_routes_and_allows_model_override(bind_transport, tmp_path, legacy, path):
    from nanobot.config.loader import load_config, save_config

    config_path = tmp_path / "config.json"
    config_path.write_text(json.dumps({
        "providers": {"openai": {"apiKey": "fixture", "apiType": legacy}},
        "agents": {"defaults": {"model": "gpt-4o", "provider": "openai"}},
    }), encoding="utf-8")
    config = load_config(config_path)
    save_config(config, config_path)
    config = load_config(config_path)
    requests = []

    def handler(request):
        requests.append(request.url.path)
        return _answer(request)

    provider = bind_transport(make_provider(config), handler)
    assert (await provider.chat([{"role": "user", "content": "hello"}])).content == "ok"
    assert requests == [path]
    assert resolve_automatic_model_api(config, preset=config.resolve_preset())[1] == (
        "responses" if legacy == "responses" else "chat_completions"
    )
    opposite = "chat_completions" if legacy == "responses" else "responses"
    config.model_presets["override"] = ModelPresetConfig(
        model="gpt-4o", provider="openai", api=ModelAPIConfig(supported_apis=(opposite,)),
    )
    override = bind_transport(make_provider(config, preset_name="override"), handler)
    assert (await override.chat([{"role": "user", "content": "hello"}])).content == "ok"
    assert requests[-1] == ("/v1/responses" if opposite == "responses" else "/v1/chat/completions")


@pytest.mark.parametrize("env_field", ["API_TYPE", "APITYPE"])
@pytest.mark.parametrize("legacy,path", [
    ("auto", "/v1/chat/completions"),
    ("chat_completions", "/v1/chat/completions"),
    ("responses", "/v1/responses"),
])
async def test_legacy_openai_environment_selector_keeps_request_api(
    bind_transport, tmp_path, monkeypatch, env_field, legacy, path,
):
    from nanobot.config.loader import load_config

    monkeypatch.setenv(f"NANOBOT_PROVIDERS__OPENAI__{env_field}", legacy)
    config_path = tmp_path / "config.json"
    config_path.write_text(json.dumps({
        "providers": {"openai": {"apiKey": "fixture", "apiBase": "https://tenant.test/v1"}},
        "agents": {"defaults": {"model": "gpt-4o", "provider": "openai"}},
    }), encoding="utf-8")
    config = load_config(config_path)
    requests = []

    def handler(request):
        requests.append(request.url.path)
        return _answer(request)

    provider = bind_transport(make_provider(config), handler)
    assert (await provider.chat([{"role": "user", "content": "hello"}])).content == "ok"
    assert requests == [path]