Follow up #596: wire provider registry resolution

tests/tools/test_langchain_client_config.py

@@ -6,7 +6,7 @@
 
 import pytest
 
-from tools import langchain_client
+from tools import langchain_client, llm_provider
 
 
 class FakeChatOpenAI:
@@ -39,6 +39,52 @@ def _write_json(path, payload: dict[str, object]) -> str:
     return str(path)
 
 
+def test_slot_config_ignores_non_object_payload(tmp_path, monkeypatch) -> None:
+    registry_path = _write_json(
+        tmp_path / "model_registry.json",
+        {
+            "models": [
+                {
+                    "model_id": "gpt-safe",
+                    "provider": "openai",
+                    "quality": {"T3": 0.80},
+                }
+            ]
+        },
+    )
+    slots_path = tmp_path / "llm_slots.json"
+    slots_path.write_text(json.dumps(["not", "an", "object"]), encoding="utf-8")
+    monkeypatch.setenv(langchain_client.ENV_MODEL_REGISTRY_CONFIG, registry_path)
+    monkeypatch.setenv(langchain_client.ENV_SLOT_CONFIG, str(slots_path))
+
+    slots = langchain_client._resolve_slots()
+
+    assert [(slot.name, slot.provider, slot.model) for slot in slots] == [
+        ("slot1", langchain_client.PROVIDER_OPENAI, "gpt-5.4"),
+        ("slot2", langchain_client.PROVIDER_ANTHROPIC, "claude-sonnet-4-6"),
+        ("slot3", langchain_client.PROVIDER_GITHUB, langchain_client.DEFAULT_MODEL),
+    ]
+
+
+def test_model_registry_ignores_non_object_payload(tmp_path, monkeypatch) -> None:
+    registry_path = tmp_path / "model_registry.json"
+    registry_path.write_text(json.dumps(["not", "an", "object"]), encoding="utf-8")
+    slots_path = _write_json(
+        tmp_path / "llm_slots.json",
+        {"slots": [{"name": "primary", "provider": "openai", "quality_tier": "T3"}]},
+    )
+    monkeypatch.setenv(langchain_client.ENV_MODEL_REGISTRY_CONFIG, str(registry_path))
+    monkeypatch.setenv(langchain_client.ENV_SLOT_CONFIG, slots_path)
+
+    slots = langchain_client._resolve_slots()
+
+    assert [(slot.name, slot.provider, slot.model) for slot in slots] == [
+        ("slot1", langchain_client.PROVIDER_OPENAI, "gpt-5.4"),
+        ("slot2", langchain_client.PROVIDER_ANTHROPIC, "claude-sonnet-4-6"),
+        ("slot3", langchain_client.PROVIDER_GITHUB, langchain_client.DEFAULT_MODEL),
+    ]
+
+
 def test_slot_config_skips_model_registry_blocked_models(tmp_path, monkeypatch) -> None:
     registry_path = _write_json(
         tmp_path / "model_registry.json",
@@ -140,3 +186,128 @@ def test_build_chat_client_refuses_explicit_blocked_model(tmp_path, monkeypatch)
 
     assert client is None
     assert FakeChatOpenAI.calls == []
+
+
+def test_llm_provider_uses_configured_slot_model(tmp_path, monkeypatch) -> None:
+    registry_path = _write_json(
+        tmp_path / "model_registry.json",
+        {
+            "models": [
+                {
+                    "model_id": "gpt-configured",
+                    "provider": "openai",
+                    "quality": {"T3": 0.91},
+                }
+            ]
+        },
+    )
+    slots_path = _write_json(
+        tmp_path / "llm_slots.json",
+        {"slots": [{"name": "primary", "provider": "openai", "model": "gpt-configured"}]},
+    )
+    fake_openai_module = types.SimpleNamespace(ChatOpenAI=FakeChatOpenAI)
+    monkeypatch.setitem(sys.modules, "langchain_openai", fake_openai_module)
+    monkeypatch.setenv(langchain_client.ENV_MODEL_REGISTRY_CONFIG, registry_path)
+    monkeypatch.setenv(langchain_client.ENV_SLOT_CONFIG, slots_path)
+    monkeypatch.setenv("OPENAI_API_KEY", "test-token")
+
+    client = llm_provider.OpenAIProvider()._get_client()
+
+    assert client is not None
+    assert FakeChatOpenAI.calls[-1]["model"] == "gpt-configured"
+
+
+def test_llm_provider_skips_blocked_slot_model(tmp_path, monkeypatch) -> None:
+    registry_path = _write_json(
+        tmp_path / "model_registry.json",
+        {
+            "models": [
+                {
+                    "model_id": "gpt-blocked",
+                    "provider": "openai",
+                    "blocked": True,
+                    "quality": {"T3": 0.99},
+                },
+                {
+                    "model_id": "gpt-safe",
+                    "provider": "openai",
+                    "quality": {"T3": 0.80},
+                },
+            ]
+        },
+    )
+    slots_path = _write_json(
+        tmp_path / "llm_slots.json",
+        {"slots": [{"name": "primary", "provider": "openai", "model": "gpt-blocked"}]},
+    )
+    fake_openai_module = types.SimpleNamespace(ChatOpenAI=FakeChatOpenAI)
+    monkeypatch.setitem(sys.modules, "langchain_openai", fake_openai_module)
+    monkeypatch.setenv(langchain_client.ENV_MODEL_REGISTRY_CONFIG, registry_path)
+    monkeypatch.setenv(langchain_client.ENV_SLOT_CONFIG, slots_path)
+    monkeypatch.setenv("OPENAI_API_KEY", "test-token")
+
+    client = llm_provider.OpenAIProvider()._get_client()
+
+    assert client is not None
+    assert FakeChatOpenAI.calls[-1]["model"] == "gpt-safe"
+
+
+def test_anthropic_completion_reports_configured_model(tmp_path, monkeypatch) -> None:
+    registry_path = _write_json(
+        tmp_path / "model_registry.json",
+        {
+            "models": [
+                {
+                    "model_id": "claude-configured",
+                    "provider": "anthropic",
+                    "quality": {"T3": 0.91},
+                }
+            ]
+        },
+    )
+    slots_path = _write_json(
+        tmp_path / "llm_slots.json",
+        {
+            "slots": [
+                {
+                    "name": "primary",
+                    "provider": "anthropic",
+                    "model": "claude-configured",
+                }
+            ]
+        },
+    )
+
+    class FakeAnthropicClient:
+        def invoke(self, prompt, **kwargs):
+            return types.SimpleNamespace(content="ok")
+
+    monkeypatch.setenv(langchain_client.ENV_MODEL_REGISTRY_CONFIG, registry_path)
+    monkeypatch.setenv(langchain_client.ENV_SLOT_CONFIG, slots_path)
+    monkeypatch.setattr(
+        llm_provider.AnthropicProvider,
+        "_get_client",
+        lambda self: FakeAnthropicClient(),
+    )
+    monkeypatch.setattr(
+        llm_provider.GitHubModelsProvider,
+        "_build_analysis_prompt",
+        lambda self, session_output, tasks, context: "prompt",
+    )
+    monkeypatch.setattr(
+        llm_provider.GitHubModelsProvider,
+        "_parse_response",
+        lambda self, content, tasks, quality_context=None: llm_provider.CompletionAnalysis(
+            completed_tasks=[],
+            in_progress_tasks=[],
+            blocked_tasks=[],
+            confidence=0.9,
+            reasoning="ok",
+            provider_used="github-models",
+            model_name="stale-hardcoded",
+        ),
+    )
+
+    result = llm_provider.AnthropicProvider().analyze_completion("output", ["task"])
+
+    assert result.model_name == "claude-configured"

tools/langchain_client.py

@@ -115,6 +115,9 @@ def _load_model_registry() -> list[ModelRegistryEntry]:
     except (OSError, json.JSONDecodeError):
         logger.warning("Could not read model registry %s; continuing without registry", path)
         return []
+    if not isinstance(payload, dict):
+        logger.warning("Invalid model registry format in %s; expected object", path)
+        return []
 
     entries: list[ModelRegistryEntry] = []
     for raw_entry in payload.get("models", []):
@@ -197,6 +200,9 @@ def _load_slot_config() -> list[SlotDefinition]:
         payload = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
         return _default_slots()
+    if not isinstance(payload, dict):
+        logger.warning("Invalid slot config format in %s; expected object", path)
+        return _default_slots()
 
     registry = _load_model_registry()
     slots: list[SlotDefinition] = []

tools/llm_provider.py

@@ -29,6 +29,13 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
+from tools.llm_registry import (
+    PROVIDER_ANTHROPIC,
+    PROVIDER_GITHUB,
+    PROVIDER_OPENAI,
+    configured_model_for_provider,
+)
+
 logger = logging.getLogger(__name__)
 
 # GitHub Models API endpoint (OpenAI-compatible)
@@ -337,8 +344,11 @@ def _get_client(self):
             logger.warning("langchain_openai not installed")
             return None
 
+        model = configured_model_for_provider(PROVIDER_GITHUB, fallback="gpt-4.1")
+        if not model:
+            return None
         return ChatOpenAI(
-            model="gpt-4.1",  # Battle-tested, reliable, available on GitHub Models
+            model=model,
             base_url=GITHUB_MODELS_BASE_URL,
             api_key=os.environ.get("GITHUB_TOKEN"),
             temperature=0.1,  # Low temperature for consistent analysis
@@ -550,7 +560,7 @@ def _parse_response(
                 confidence=adjusted_confidence,
                 reasoning=reasoning,
                 provider_used=self.name,
-                model_name="gpt-4.1",  # Actual model used by GitHubModelsProvider
+                model_name=configured_model_for_provider(PROVIDER_GITHUB, fallback="gpt-4.1"),
                 raw_confidence=raw_confidence if adjusted_confidence != raw_confidence else None,
                 confidence_adjusted=adjusted_confidence != raw_confidence,
                 quality_warnings=warnings if warnings else None,
@@ -565,7 +575,7 @@ def _parse_response(
                 confidence=0.0,
                 reasoning=f"Failed to parse response: {e}",
                 provider_used=self.name,
-                model_name="gpt-4.1",  # Actual model used by GitHubModelsProvider
+                model_name=configured_model_for_provider(PROVIDER_GITHUB, fallback="gpt-4.1"),
             )
 
 
@@ -590,8 +600,11 @@ def _get_client(self):
             logger.warning("langchain_openai not installed")
             return None
 
+        model = configured_model_for_provider(PROVIDER_OPENAI, fallback="gpt-5.1-codex")
+        if not model:
+            return None
         return ChatOpenAI(
-            model="gpt-5.1-codex",  # Purpose-built for analyzing Codex coding sessions
+            model=model,
             api_key=os.environ.get("OPENAI_API_KEY"),
             temperature=0.1,
         )
@@ -626,7 +639,7 @@ def analyze_completion(
                 confidence=result.confidence,
                 reasoning=result.reasoning,
                 provider_used=self.name,
-                model_name="gpt-5.1-codex",  # Actual model used by OpenAIProvider
+                model_name=configured_model_for_provider(PROVIDER_OPENAI, fallback="gpt-5.1-codex"),
                 raw_confidence=result.raw_confidence,
                 confidence_adjusted=result.confidence_adjusted,
                 quality_warnings=result.quality_warnings,
@@ -656,8 +669,14 @@ def _get_client(self):
             logger.warning("langchain_anthropic not installed")
             return None
 
+        model = configured_model_for_provider(
+            PROVIDER_ANTHROPIC,
+            fallback="claude-sonnet-4-5-20250929",
+        )
+        if not model:
+            return None
         return ChatAnthropic(
-            model="claude-sonnet-4-5-20250929",
+            model=model,
             anthropic_api_key=os.environ.get(ANTHROPIC_API_KEY_ENV),
             temperature=0.1,
         )
@@ -702,7 +721,10 @@ def analyze_completion(
                 confidence=result.confidence,
                 reasoning=result.reasoning,
                 provider_used=self.name,
-                model_name="claude-sonnet-4-5-20250929",
+                model_name=configured_model_for_provider(
+                    PROVIDER_ANTHROPIC,
+                    fallback="claude-sonnet-4-5-20250929",
+                ),
                 raw_confidence=result.raw_confidence,
                 confidence_adjusted=result.confidence_adjusted,
                 quality_warnings=result.quality_warnings,