Strip model-aware branches from LLM configuration

Drop every hand-rolled provider table and per-model gating that had
accumulated in the model-handling layer:

  * normalize_model_name no longer auto-prefixes bare claude-* / gemini-*
    names. Users supply the full <provider>/<model> form. The function
    became literally model_name.strip(), so callers now inline that and
    the function is removed.
  * tool_choice="required" is gone everywhere. Thinking-mode endpoints
    (Anthropic, DeepSeek /beta) reject it; modern reasoning models don't
    need it; non-interactive runs already have
    _append_noninteractive_tool_required_message as the convergence
    backstop. model_supports_reasoning, model_known_to_registry, and
    _model_cost_entry were only used to gate this and follow it out.
  * Reasoning(effort=...) is now attached whenever
    STRIX_REASONING_EFFORT is non-none. litellm.drop_params=True absorbs
    it for non-reasoning models.
  * Warm-up's bare-name OpenAI 401 hint is removed (false-positive prone,
    relied on substring matching).
  * reset_tool_choice on SandboxAgent is no-op now (no tool_choice gets
    set) and is removed.
  * report/dedupe.py was still routing through stock MultiProvider, so
    non-OpenAI configs failed the dedupe LLM pass; switch it to
    StrixProvider.

Verified end-to-end against modern provider strings (openai/gpt-5.4,
anthropic/claude-opus-4-7, deepseek/deepseek-reasoner,
gemini/gemini-2.5-pro, groq/, xai/, mistral/, together_ai/, perplexity/,
openrouter/, litellm/ legacy form, and whitespace-padded input): 18/18
cases route correctly, env vars mirror via litellm.validate_environment,
and ModelSettings carries no tool_choice. mypy strict passes.

strix/core/inputs.py

@@ -8,11 +8,7 @@ from typing import TYPE_CHECKING, Any
 from agents.model_settings import ModelSettings
 from openai.types.shared import Reasoning
 
-from strix.config.models import (
-    DEFAULT_MODEL_RETRY,
-    model_known_to_registry,
-    model_supports_reasoning,
-)
+from strix.config.models import DEFAULT_MODEL_RETRY
 
 
 if TYPE_CHECKING:
@@ -110,30 +106,13 @@ def build_scope_context(scan_config: dict[str, Any]) -> dict[str, Any]:
     }
 
 
-def make_model_settings(
-    reasoning_effort: ReasoningEffort | None,
-    *,
-    model_name: str,
-) -> ModelSettings:
-    # Anthropic + DeepSeek thinking reject ``tool_choice="required"`` outright;
-    # when reasoning is enabled we let the model self-select tools and rely on
-    # the system prompt + the ``_finish_tool_use_behavior`` callback to keep
-    # the loop converging. When the user opted into reasoning but the model
-    # is unknown to LiteLLM's registry (e.g. a private DeepSeek SKU, a fresh
-    # release the registry hasn't picked up), drop ``tool_choice`` too —
-    # server-side thinking-mode endpoints reject it and we can't confirm.
-    user_wants_reasoning = reasoning_effort is not None and reasoning_effort != "none"
-    confirmed_reasoning = model_supports_reasoning(model_name)
-    drop_tool_choice = user_wants_reasoning and (
-        confirmed_reasoning or not model_known_to_registry(model_name)
-    )
+def make_model_settings(reasoning_effort: ReasoningEffort | None) -> ModelSettings:
     model_settings = ModelSettings(
         parallel_tool_calls=False,
-        tool_choice=None if drop_tool_choice else "required",
         retry=DEFAULT_MODEL_RETRY,
         include_usage=True,
     )
-    if user_wants_reasoning and confirmed_reasoning:
+    if reasoning_effort is not None and reasoning_effort != "none":
         model_settings = model_settings.resolve(
             ModelSettings(reasoning=Reasoning(effort=reasoning_effort)),
         )

strix/core/runner.py

@@ -17,7 +17,6 @@ from strix.config import load_settings
 from strix.config.models import (
     StrixProvider,
     configure_sdk_model_defaults,
-    normalize_model_name,
     uses_chat_completions_tool_schema,
 )
 from strix.core.agents import AgentCoordinator
@@ -91,7 +90,7 @@ async def run_strix_scan(
 
     settings = load_settings()
     configure_sdk_model_defaults(settings)
-    resolved_model = normalize_model_name(model or settings.llm.model or "")
+    resolved_model = (model or settings.llm.model or "").strip()
     if not resolved_model:
         raise RuntimeError(
             "No LLM model configured. Set STRIX_LLM env or pass model= to run_strix_scan().",
@@ -154,10 +153,7 @@ async def run_strix_scan(
         is_whitebox = any(t.get("type") == "local_code" for t in targets)
         skills = list(scan_config.get("skills") or [])
         root_task = build_root_task(scan_config)
-        model_settings = make_model_settings(
-            settings.llm.reasoning_effort,
-            model_name=resolved_model,
-        )
+        model_settings = make_model_settings(settings.llm.reasoning_effort)
         run_config = RunConfig(
             model=resolved_model,
             model_provider=StrixProvider(),