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
8.3 KB
Raw Blame
"""OpenCode launcher contract tests."""

import json
from pathlib import Path

import pytest

from free_claude_code.application.model_catalog import CatalogModel
from free_claude_code.cli.launchers.opencode_config import build_opencode_config
from free_claude_code.core.model_capabilities import ModelInputModality


def test_opencode_config_uses_native_responses_and_model_budgets() -> None:
    config = build_opencode_config(
        (
            CatalogModel(
                wire_slug="nvidia_nim/vendor/model",
                provider_model_ref="nvidia_nim/vendor/model",
                display_name="Nested model",
                supports_reasoning=True,
                input_modalities=frozenset(
                    {ModelInputModality.TEXT, ModelInputModality.IMAGE}
                ),
                context_window_tokens=131072,
                max_output_tokens=8192,
            ),
            CatalogModel(
                wire_slug="claude-3-freecc-no-thinking/open_router/plain-model",
                provider_model_ref="open_router/plain-model",
                display_name="No-thinking model",
                supports_reasoning=False,
                input_modalities=frozenset({ModelInputModality.TEXT}),
                context_window_tokens=65536,
            ),
            CatalogModel(
                wire_slug="future_provider/unknown-model",
                provider_model_ref="future_provider/unknown-model",
                display_name="Unknown model",
                supports_reasoning=None,
            ),
            CatalogModel(
                wire_slug="future_provider/output-only",
                provider_model_ref="future_provider/output-only",
                display_name="Output-only model",
                supports_reasoning=None,
                max_output_tokens=4096,
            ),
        ),
        default_model_id="nvidia_nim/vendor/model",
        proxy_root_url="http://127.0.0.1:9191",
    )

    provider = config.file["providers"]
    assert isinstance(provider, dict)
    fcc = provider["free-claude-code"]
    assert isinstance(fcc, dict)
    assert fcc["package"] == "@opencode/ai/providers/openai/responses"
    assert fcc["settings"] == {
        "baseURL": "http://127.0.0.1:9191/v1",
        "apiKey": "{env:FCC_OPENCODE_API_KEY}",
    }
    assert fcc["models"] == {
        "nvidia_nim/vendor/model": {
            "name": "Nested model",
            "capabilities": {
                "tools": True,
                "input": ["text", "image"],
                "output": ["text"],
            },
            "limit": {"context": 131072, "output": 8192},
        },
        "claude-3-freecc-no-thinking/open_router/plain-model": {
            "name": "No-thinking model",
            "capabilities": {"tools": True, "input": ["text"], "output": ["text"]},
            "limit": {"context": 65536, "output": 4096},
        },
        "future_provider/unknown-model": {
            "name": "Unknown model",
            "limit": {"context": 200000},
        },
        "future_provider/output-only": {
            "name": "Output-only model",
            "limit": {"context": 200000, "output": 4096},
        },
    }
    assert config.overlay == {
        "compaction": {"buffer": 16384},
        "providers": {
            "free-claude-code": {
                "name": "Free Claude Code",
                "package": "@opencode/ai/providers/openai/responses",
                "settings": {
                    "baseURL": "http://127.0.0.1:9191/v1",
                    "apiKey": "{env:FCC_OPENCODE_API_KEY}",
                },
            }
        },
        "experimental": {
            "policies": [
                {"action": "provider.use", "resource": "*", "effect": "deny"},
                {
                    "action": "provider.use",
                    "resource": "free-claude-code",
                    "effect": "allow",
                },
            ]
        },
        "model": "free-claude-code/nvidia_nim/vendor/model",
        "agents": {"title": {"model": "free-claude-code/nvidia_nim/vendor/model"}},
    }
    serialized = json.dumps(config.file | config.overlay)
    assert "proxy-token" not in serialized
    assert "attachment" not in serialized


@pytest.mark.parametrize(
    ("context", "output", "expected_limits", "expected_buffer"),
    [
        (32768, None, {"context": 32768, "output": 4096}, 8192),
        (8192, None, {"context": 8192, "output": 2048}, 2048),
        (16384, 1024, {"context": 16384, "output": 1024}, 4096),
        (131072, 65536, {"context": 131072, "output": 65536}, None),
        (200000, None, {"context": 200000, "output": 4096}, None),
        (None, 4096, {"context": 200000, "output": 4096}, None),
        (None, None, {"context": 200000}, None),
    ],
)
def test_opencode_context_reserves_fit_small_models(
    context: int | None,
    output: int | None,
    expected_limits: dict[str, int] | None,
    expected_buffer: int | None,
) -> None:
    config = build_opencode_config(
        (
            CatalogModel(
                wire_slug="test/model",
                provider_model_ref="test/model",
                display_name="Test model",
                supports_reasoning=None,
                context_window_tokens=context,
                max_output_tokens=output,
            ),
        ),
        default_model_id="test/model",
        proxy_root_url="http://127.0.0.1:8182",
    )
    provider = config.file["providers"]
    assert isinstance(provider, dict)
    fcc = provider["free-claude-code"]
    assert isinstance(fcc, dict)
    models = fcc["models"]
    assert isinstance(models, dict)
    model = models["test/model"]
    assert isinstance(model, dict)
    assert model.get("limit") == expected_limits
    assert config.overlay.get("compaction") == (
        {"buffer": expected_buffer} if expected_buffer is not None else None
    )


def test_opencode_config_rejects_empty_model_catalog() -> None:
    with pytest.raises(ValueError, match="at least one"):
        build_opencode_config(
            (),
            default_model_id="nvidia_nim/vendor/model",
            proxy_root_url="http://127.0.0.1:9191",
        )


def test_opencode_child_receives_private_catalog_and_overlay(launch_capture) -> None:
    from tests.cli.test_launcher_workflow import launch

    def inspect(command, env):
        config = json.loads(Path(env["OPENCODE_CONFIG"]).read_text())
        overlay = json.loads(env["OPENCODE_CONFIG_CONTENT"])
        provider = config["providers"]["free-claude-code"]
        assert provider["settings"]["baseURL"] == "http://127.0.0.1:8182/v1"
        assert "nvidia_nim/catalog-model:variant" in provider["models"]
        assert overlay["experimental"]["policies"][-1]["resource"] == "free-claude-code"
        assert env["FCC_OPENCODE_API_KEY"] == "launcher-test-token"

    launch_capture.on_start = inspect
    launch("opencode", ["models"])


@pytest.mark.parametrize("key", ("OPENCODE_CONFIG", "OPENCODE_CONFIG_CONTENT"))
def test_existing_opencode_process_configuration_is_not_replaced(
    key, launch_capture, monkeypatch
) -> None:
    from tests.cli.test_launcher_workflow import launch

    monkeypatch.setenv(key, "user-owned-config")
    launch("opencode", [], exit_code=1)
    assert not launch_capture.commands


@pytest.mark.parametrize(
    "args, expected",
    [
        ([], ["--standalone"]),
        (["run", "hello"], ["run", "hello", "--standalone"]),
        (["models"], ["models", "--standalone"]),
        (["session", "list"], ["session", "list", "--standalone"]),
        (
            ["run", "--", "--standalone=false"],
            ["run", "--standalone", "--", "--standalone=false"],
        ),
    ],
)
def test_opencode_owns_a_private_server_without_rewriting_positionals(
    args, expected, launch_capture
) -> None:
    from tests.cli.test_launcher_workflow import launch

    launch("opencode", args)
    assert launch_capture.commands[0][1:] == expected


@pytest.mark.parametrize(
    "option",
    [
        "--standalone",
        "--no-standalone",
        "--standalone=false",
        "--standalone=0",
        "--no-standalone=false",
    ],
)
def test_opencode_rejects_caller_control_of_server_lifetime(
    option, launch_capture, capsys
) -> None:
    from tests.cli.test_launcher_workflow import launch

    launch("opencode", ["run", option, "false", "hello"], exit_code=1)
    assert not launch_capture.commands
    assert "FCC manages OpenCode standalone mode" in capsys.readouterr().err