File size: 4,359 Bytes
ff8b94c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
"""Config-resolution regressions for the claude_code_exec backend (issue #233).

Route B: ``--backend claude_code_exec`` defaults only the *target* to Claude
Code; the optimizer keeps its configured backend (openai_chat by default).
Opting the optimizer in via ``--optimizer_backend claude_code_exec`` must then
normalize its model to the Claude default rather than leaving ``gpt-5.5``.
"""

from __future__ import annotations

import sys
from pathlib import Path
from types import SimpleNamespace

import pytest

import scripts.train as train_script

_ROOT = Path(__file__).resolve().parents[1]


def _train_cfg(monkeypatch, *extra_argv: str) -> dict:
    monkeypatch.setattr(
        sys,
        "argv",
        [
            "skillopt-train",
            "--config",
            str(_ROOT / "configs" / "searchqa" / "default.yaml"),
            *extra_argv,
        ],
    )
    return train_script.load_config(train_script.parse_args())


def test_train_claude_code_exec_defaults_target_only(monkeypatch) -> None:
    cfg = _train_cfg(monkeypatch, "--backend", "claude_code_exec")

    assert cfg["optimizer_backend"] == "openai_chat"
    assert cfg["optimizer_model"] == "gpt-5.5"
    assert cfg["target_backend"] == "claude_code_exec"
    assert cfg["target_model"] == "claude-sonnet-4-6"


def test_train_claude_code_exec_optimizer_opt_in_normalizes_model(monkeypatch) -> None:
    cfg = _train_cfg(
        monkeypatch,
        "--backend",
        "claude_code_exec",
        "--optimizer_backend",
        "claude_code_exec",
    )

    assert cfg["optimizer_backend"] == "claude_code_exec"
    assert cfg["optimizer_model"] == "claude-sonnet-4-6"
    assert cfg["target_backend"] == "claude_code_exec"
    assert cfg["target_model"] == "claude-sonnet-4-6"


class _StopAfterResolution(Exception):
    pass


def _run_eval_resolution(
    monkeypatch, tmp_path, *, optimizer_backend: str | None
) -> dict:
    import scripts.eval_only as eval_script

    skill_path = tmp_path / "skill.md"
    skill_path.write_text("# Test skill\n", encoding="utf-8")

    cfg = {
        "model": {
            "backend": "azure_openai",
            "optimizer": "gpt-5.5",
            "target": "gpt-5.5",
            "optimizer_backend": "openai_chat",
            "target_backend": "openai_chat",
        },
        "env": {"out_root": str(tmp_path / "out")},
    }
    args = SimpleNamespace(
        config="unused.yaml",
        skill=str(skill_path),
        split=None,
        cfg_options=[],
        backend="claude_code_exec",
        optimizer_backend=optimizer_backend,
    )
    monkeypatch.setattr(eval_script, "parse_args", lambda: args)
    monkeypatch.setattr("skillopt.config.load_config", lambda *a, **kw: cfg)

    observed: dict[str, str] = {}

    def capture(name):
        def _fn(value, *a, **k):
            observed[name] = value

        return _fn

    monkeypatch.setattr(eval_script, "configure_azure_openai", lambda **kw: None)
    monkeypatch.setattr(eval_script, "set_optimizer_backend", capture("optimizer_backend"))
    monkeypatch.setattr(eval_script, "set_target_backend", capture("target_backend"))
    monkeypatch.setattr(eval_script, "set_optimizer_deployment", capture("optimizer_model"))
    monkeypatch.setattr(eval_script, "set_target_deployment", capture("target_model"))

    def stop(*a, **k):
        raise _StopAfterResolution

    monkeypatch.setattr(eval_script, "configure_codex_exec_from_config", stop)

    with pytest.raises(_StopAfterResolution):
        eval_script.main()

    return observed


def test_eval_claude_code_exec_defaults_target_only(monkeypatch, tmp_path) -> None:
    observed = _run_eval_resolution(monkeypatch, tmp_path, optimizer_backend=None)

    assert observed == {
        "optimizer_backend": "openai_chat",
        "target_backend": "claude_code_exec",
        "optimizer_model": "gpt-5.5",
        "target_model": "claude-sonnet-4-6",
    }


def test_eval_claude_code_exec_optimizer_opt_in_normalizes_model(
    monkeypatch, tmp_path
) -> None:
    observed = _run_eval_resolution(
        monkeypatch, tmp_path, optimizer_backend="claude_code_exec"
    )

    assert observed == {
        "optimizer_backend": "claude_code_exec",
        "target_backend": "claude_code_exec",
        "optimizer_model": "claude-sonnet-4-6",
        "target_model": "claude-sonnet-4-6",
    }