Let ROS 2 code use its own model (CODE_LLM_MODEL)

LLM_MODEL stays the scene model; CODE_LLM_MODEL (default: the same) is what OpenCode
and the direct code backend use, through the same OpenRouter key. /health shows both.

.env.example

@@ -4,7 +4,8 @@
 # Any OpenAI-compatible endpoint. Default: GLM-5.3 through OpenRouter (key from openrouter.ai/keys).
 LLM_API_KEY=
 LLM_BASE_URL=https://openrouter.ai/api/v1
-LLM_MODEL=z-ai/glm-5.3
+LLM_MODEL=z-ai/glm-5.3            # scenes (/simulate/generate)
+# CODE_LLM_MODEL=z-ai/glm-5.3     # ROS 2 code via OpenCode (default: same as LLM_MODEL); any OpenRouter model id
 LLM_TIMEOUT=180
 
 # --- Storage (defaults shown)

README.md

@@ -24,7 +24,8 @@ Menagerie). Generated ROS 2 code only ever runs inside the sandbox (no network,
 
 The model is **GLM-5.3 through OpenRouter** by default (`z-ai/glm-5.3`, a fraction of the price of frontier
 models, strong at code). Any OpenAI-compatible endpoint works: set `LLM_BASE_URL`, `LLM_MODEL` and `LLM_API_KEY`
-(e.g. `deepseek/deepseek-v4-pro` on OpenRouter, or Z.ai's own API). Everyone uses the same model and key.
+(e.g. `deepseek/deepseek-v4-pro` on OpenRouter, or Z.ai's own API). `CODE_LLM_MODEL` sets a different
+model for ROS 2 code (what OpenCode uses; defaults to `LLM_MODEL`). Everyone uses the same models and key.
 
 ## How it works
 

api/codegen.py

@@ -261,7 +261,7 @@ def generate_code(
         attempts.append(CodeAttempt(dict(files), validation.to_dict(), transcript))
         if validation.valid:
             break
-    model = getattr(getattr(backend, "llm", None), "model", None) or settings.llm_model
+    model = getattr(getattr(backend, "llm", None), "model", None) or settings.code_llm_model
     return CodeResult(
         valid=validation.valid,
         files=files,

api/config.py

@@ -20,7 +20,8 @@ class Settings:
     # Model: one model for every tester in Stage 1, via any OpenAI-compatible endpoint (OpenRouter by default).
     llm_api_key: str
     llm_base_url: str
-    llm_model: str
+    llm_model: str  # scene generation (/simulate/generate)
+    code_llm_model: str  # ROS 2 code generation: OpenCode's model, or the direct backend's
     llm_timeout: float
 
     # Storage
@@ -89,6 +90,7 @@ def get_settings() -> Settings:
         llm_api_key=_env("LLM_API_KEY", ""),
         llm_base_url=_env("LLM_BASE_URL", "https://openrouter.ai/api/v1").rstrip("/"),
         llm_model=_env("LLM_MODEL", "z-ai/glm-5.3"),
+        code_llm_model=_env("CODE_LLM_MODEL", _env("LLM_MODEL", "z-ai/glm-5.3")),
         llm_timeout=float(_env("LLM_TIMEOUT", "180")),
         data_dir=data_dir,
         testers_file=Path(_env("ROSDIFF_TESTERS_FILE", str(REPO_ROOT / "testers.yaml"))),

api/llm.py

@@ -39,10 +39,10 @@ class LLM(Protocol):
 class ChatClient:
     """POST {base_url}/chat/completions. The same key and endpoint are used for every tester."""
 
-    def __init__(self, settings: Settings, transport: httpx.BaseTransport | None = None):
+    def __init__(self, settings: Settings, transport: httpx.BaseTransport | None = None, model: str | None = None):
         if not settings.llm_api_key:
             raise LLMError("LLM_API_KEY is not set")
-        self.model = settings.llm_model
+        self.model = model or settings.llm_model
         self._client = httpx.Client(
             base_url=settings.llm_base_url,
             # X-Title labels the requests in the OpenRouter dashboard; other providers ignore it.

api/main.py

@@ -49,9 +49,10 @@ class Services:
     store: RagStore
     logs: LogStore
     allowlist: Allowlist
-    llm_factory: Callable[[], LLM]
+    llm_factory: Callable[[], LLM]  # scene generation
     backend: SimBackend | None = None  # None: /simulate/run is disabled
     storage: Storage | None = None
+    code_llm_factory: Callable[[], LLM] | None = None  # direct ROS 2 code backend; None: same as llm_factory
 
 
 def default_services() -> Services:
@@ -65,6 +66,7 @@ def default_services() -> Services:
         logs=LogStore(settings.log_db),
         allowlist=Allowlist(settings.testers_file),
         llm_factory=lambda: ChatClient(settings),
+        code_llm_factory=lambda: ChatClient(settings, model=settings.code_llm_model),
         backend=make_backend(settings),
         storage=R2Storage(r2) if r2 else None,
     )
@@ -225,6 +227,7 @@ def create_app(services: Services | None = None) -> FastAPI:
         return {
             "status": "ok",
             "model": s.settings.llm_model,
+            "code_model": s.settings.code_llm_model,
             "llm_configured": bool(s.settings.llm_api_key),
             "codegen_backend": s.settings.codegen_backend,
             "opencode_found": shutil.which(s.settings.opencode_bin) is not None,
@@ -295,7 +298,7 @@ def create_app(services: Services | None = None) -> FastAPI:
                     req.request,
                     req.distro,
                     req.language,
-                    DirectBackend(s.llm_factory()),
+                    DirectBackend((s.code_llm_factory or s.llm_factory)()),
                     s.store,
                     s.settings,
                     req.package_name,

api/opencode_runner.py

@@ -52,13 +52,13 @@ class OpenCodeRun:
 def opencode_config(settings: Settings) -> dict:
     return {
         "$schema": "https://opencode.ai/config.json",
-        "model": f"llm/{settings.llm_model}",
+        "model": f"llm/{settings.code_llm_model}",
         "provider": {
             "llm": {
                 "npm": "@ai-sdk/openai-compatible",
                 "name": "RosDiff LLM",
                 "options": {"baseURL": settings.llm_base_url, "apiKey": "{env:LLM_API_KEY}"},
-                "models": {settings.llm_model: {"name": settings.llm_model}},
+                "models": {settings.code_llm_model: {"name": settings.code_llm_model}},
             }
         },
         "permission": {
@@ -124,7 +124,7 @@ class OpenCodeWorkspace:
             "--dir",
             str(self.ws),
             "--model",
-            f"llm/{self.settings.llm_model}",
+            f"llm/{self.settings.code_llm_model}",
             "--format",
             "json",
         ]

tests/test_api.py

@@ -217,3 +217,34 @@ def test_code_generate_rejects_bad_input(env):
         ).status_code
         == 422
     )
+
+
+def test_coding_model_is_separate(settings):
+    from dataclasses import replace
+
+    from api.opencode_runner import opencode_config
+
+    s = replace(settings, llm_model="z-ai/glm-5.3", code_llm_model="some/coder")
+    cfg = opencode_config(s)
+    assert cfg["model"] == "llm/some/coder" and list(cfg["provider"]["llm"]["models"]) == ["some/coder"]
+    assert cfg["provider"]["llm"]["options"]["baseURL"] == s.llm_base_url
+
+
+def test_code_direct_backend_uses_code_model(env):
+    from ros_fixtures import INTERFACES, as_file_blocks, python_package
+
+    from api.llm import ScriptedLLM
+    from api.ros_check import load_interfaces
+
+    client, key, llm, services = env
+    services.settings.data_dir.mkdir(parents=True, exist_ok=True)
+    services.settings.interfaces_file.write_text(json.dumps(INTERFACES))
+    load_interfaces.cache_clear()
+    coder = ScriptedLLM([as_file_blocks(python_package())], model="some/coder")
+    services.code_llm_factory = lambda: coder
+    r = client.post(
+        "/code/generate", headers={"X-API-Key": key}, json={"request": "Stop on LaserScan closer than 0.5 m"}
+    )
+    assert r.status_code == 200 and r.json()["model"] == "some/coder" and coder.calls and not llm.calls
+    health = client.get("/health").json()
+    assert health["model"] == services.settings.llm_model and "code_model" in health