Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

6.4 KB
Raw Blame
from types import SimpleNamespace
from unittest.mock import MagicMock

import pytest
from vikingbot.providers.vlm_adapter import VLMProviderAdapter

from openviking.models.vlm.backends.litellm_vlm import (
    LiteLLMVLMProvider as OpenVikingLiteLLMVLMProvider,
)


def test_vlm_adapter_exposes_only_native_tool_result_media_backends():
    langfuse = SimpleNamespace()

    codex = VLMProviderAdapter(
        SimpleNamespace(provider="openai-codex"),
        default_model="gpt-5.3-codex",
        langfuse_client=langfuse,
    )
    anthropic = VLMProviderAdapter(
        SimpleNamespace(provider="anthropic"),
        default_model="claude-sonnet",
        langfuse_client=langfuse,
    )
    openai = VLMProviderAdapter(
        SimpleNamespace(provider="openai"),
        default_model="gpt-4o",
        langfuse_client=langfuse,
    )

    assert codex.supports_tool_result_media() is True
    assert anthropic.supports_tool_result_media() is True
    assert openai.supports_tool_result_media() is False

    mixed_failover = VLMProviderAdapter(
        SimpleNamespace(
            provider="anthropic",
            primary=SimpleNamespace(provider="anthropic"),
            backup=SimpleNamespace(provider="openai"),
        ),
        default_model="claude-sonnet",
        langfuse_client=langfuse,
    )
    assert mixed_failover.supports_tool_result_media() is False


def test_vlm_adapter_uses_litellm_resolved_provider_for_tool_result_media():
    vlm = OpenVikingLiteLLMVLMProvider(
        {
            "provider": "litellm",
            "model": "claude-sonnet-4-5",
        }
    )
    provider = VLMProviderAdapter(
        vlm,
        default_model="claude-sonnet-4-5",
        langfuse_client=SimpleNamespace(),
    )

    assert vlm.resolved_provider() == "anthropic"
    assert provider.supports_tool_result_media() is True


def test_make_provider_passes_default_thinking_to_vlm_adapter(monkeypatch):
    from vikingbot.cli.commands import _make_provider

    captured = {}

    def fake_create(config):
        captured.update(config)
        return SimpleNamespace(
            provider=config["provider"],
            model=config["model"],
            thinking=config["thinking"],
        )

    monkeypatch.setattr("openviking.models.vlm.base.VLMFactory.create", fake_create)

    provider = _make_provider(
        SimpleNamespace(
            agents=SimpleNamespace(
                model="ep-test",
                temperature=0.0,
                thinking=True,
                api_key="ak-test",
                api_base="https://example.invalid",
                provider="volcengine",
                extra_headers={},
                timeout=None,
            )
        )
    )

    assert captured["thinking"] is True
    assert provider._vlm.thinking is True


@pytest.mark.asyncio
@pytest.mark.parametrize("thinking", [True, False])
@pytest.mark.parametrize(
    ("backend", "model", "resolved_model"),
    [
        ("dashscope", "qwen-plus", "dashscope/qwen-plus"),
        ("openai", "gpt-4o", "gpt-4o"),
        ("gemini", "gemini/gemini-2.5-pro", "gemini/gemini-2.5-pro"),
        ("zhipu", "glm-4", "zhipu/glm-4"),
    ],
)
async def test_vlm_adapter_routes_litellm_thinking_parameters(
    monkeypatch, thinking, backend, model, resolved_model
):
    from openviking.models.vlm.backends.litellm_vlm import LiteLLMVLMProvider

    captured = {}

    async def fake_acompletion(**kwargs):
        captured.update(kwargs)
        return SimpleNamespace(
            choices=[
                SimpleNamespace(
                    message=SimpleNamespace(content="ok", tool_calls=None),
                    finish_reason="stop",
                )
            ],
            usage=None,
        )

    monkeypatch.setattr(
        "openviking.models.vlm.backends.litellm_vlm.acompletion",
        fake_acompletion,
    )

    vlm = LiteLLMVLMProvider(
        {
            "provider": backend,
            "model": model,
            "api_key": "sk-test",
            "thinking": thinking,
        }
    )
    provider = VLMProviderAdapter(vlm, default_model=model)

    response = await provider.chat(messages=[{"role": "user", "content": "hi"}])

    assert response.content == "ok"
    assert captured["model"] == resolved_model
    if backend == "dashscope":
        assert captured["extra_body"] == {"enable_thinking": thinking}
    else:
        assert "extra_body" not in captured
    assert "thinking" not in captured
    assert "reasoning_effort" not in captured


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("configured_max_tokens", "expected_max_tokens"),
    [(None, None), (8192, 8192)],
)
@pytest.mark.parametrize("thinking", [True, False])
async def test_vlm_adapter_volcengine_stream_respects_optional_max_tokens(
    thinking,
    configured_max_tokens,
    expected_max_tokens,
):
    captured = {}

    class FakeCompletions:
        async def create(self, **kwargs):
            captured.update(kwargs)

            async def chunks():
                yield SimpleNamespace(
                    choices=[
                        SimpleNamespace(
                            finish_reason="stop",
                            delta=SimpleNamespace(
                                reasoning_content=None,
                                content="ok",
                                tool_calls=[],
                            ),
                        )
                    ],
                    usage=None,
                )

            response = MagicMock()
            response.__aenter__.return_value = chunks()
            return response

    vlm = SimpleNamespace(
        provider="volcengine",
        model="ep-test",
        temperature=0.0,
        max_tokens=configured_max_tokens,
        thinking=thinking,
        extra_headers=None,
        get_async_client=lambda: SimpleNamespace(
            chat=SimpleNamespace(completions=FakeCompletions())
        ),
    )
    provider = VLMProviderAdapter(
        vlm,
        default_model="ep-test",
        langfuse_client=SimpleNamespace(enabled=False, _client=None),
    )

    events = [
        event
        async for event in provider.chat_stream(
            messages=[{"role": "user", "content": "hi"}],
        )
    ]

    assert events[-1].response.content == "ok"
    assert captured["thinking"] == {"type": "enabled" if thinking else "disabled"}
    if expected_max_tokens is None:
        assert "max_tokens" not in captured
    else:
        assert captured["max_tokens"] == expected_max_tokens