refactor: use a single agent model path

tests/test_runtime_api.py

@@ -18,7 +18,7 @@ class FakeModelProvider:
     async def complete(self, **kwargs):
         self.completed.append(kwargs)
         return {
-            "choices": [{"message": {"role": "assistant", "content": "work complete"}, "finish_reason": "stop"}],
+            "choices": [{"message": {"role": "assistant", "content": "agent complete"}, "finish_reason": "stop"}],
             "usage": {"total_tokens": 10},
         }
 
@@ -26,25 +26,13 @@ class FakeModelProvider:
         self.forwarded.append(payload)
         self.forward_options.append(kwargs)
         request = httpx.Request("POST", "https://model.example.test/v1/chat/completions")
-        if payload.get("stream"):
-            return httpx.Response(
-                200,
-                request=request,
-                headers={"content-type": "text/event-stream"},
-                content=(
-                    'data: {"model":"ChatGPT-5.6:Luna","choices":[{"index":0,"delta":'
-                    '{"tool_calls":[{"index":0,"id":"call-1","type":"function","function":'
-                    '{"name":"read_file","arguments":"{}"}}]},"finish_reason":null}]}\n\n'
-                    "data: [DONE]\n\n"
-                ),
-            )
         return httpx.Response(
             200,
             request=request,
             headers={"content-type": "application/json"},
             json={
                 "model": payload["model"],
-                "choices": [{"message": {"role": "assistant", "content": "chat reply"}, "finish_reason": "stop"}],
+                "choices": [{"message": {"role": "assistant", "content": "background reply"}}],
             },
         )
 
@@ -71,135 +59,94 @@ def headers(settings, identity_jwt, chat_id="chat-1"):
     }
 
 
-def test_model_list_requires_internal_key(settings) -> None:
-    app = create_app(
+def _app(settings, provider=None):
+    return create_app(
         settings,
         store=RuntimeStore(settings.database_url),
-        provider=FakeModelProvider(),
+        provider=provider or FakeModelProvider(),
         tools=FakeTools(),
     )
-    with TestClient(app) as client:
+
+
+def test_model_list_requires_internal_key_and_exposes_four_models(settings) -> None:
+    with TestClient(_app(settings)) as client:
         assert client.get("/v1/models").status_code == 401
         response = client.get(
             "/v1/models",
             headers={"Authorization": f"Bearer {settings.internal_provider_key}"},
         )
         assert response.status_code == 200
-        assert len(response.json()["data"]) == 8
-
-
-def test_chat_maps_provider_model_and_work_upgrade_is_one_way(settings, identity_jwt) -> None:
-    provider = FakeModelProvider()
-    app = create_app(settings, store=RuntimeStore(settings.database_url), provider=provider, tools=FakeTools())
-    with TestClient(app) as client:
-        chat = client.post(
-            "/v1/chat/completions",
-            headers=headers(settings, identity_jwt),
-            json={"model": "chat-light", "messages": [{"role": "user", "content": "hello"}]},
-        )
-        assert chat.status_code == 200
-        assert provider.forwarded[0]["model"] == "ChatGPT-5.6:Luna"
-        assert chat.json()["model"] == "chat-light"
-
-        extreme_chat = client.post(
-            "/v1/chat/completions",
-            headers=headers(settings, identity_jwt, "extreme-chat"),
-            json={"model": "chat-extreme", "messages": [{"role": "user", "content": "think"}]},
-        )
-        assert extreme_chat.status_code == 200
-        assert provider.forwarded[-1]["model"] == "deepseek-v4-pro"
-        assert provider.forward_options[-1] == {
-            "provider": "deepseek",
-            "thinking_enabled": True,
-            "reasoning_effort": "max",
-            "max_output_tokens": 16_384,
+        assert {item["id"] for item in response.json()["data"]} == {
+            "luna",
+            "terra",
+            "sol",
+            "deepseek-v4-pro",
         }
 
-        work = client.post(
-            "/v1/chat/completions",
-            headers=headers(settings, identity_jwt),
-            json={"model": "work-high", "messages": [{"role": "user", "content": "do it"}]},
-        )
-        assert work.status_code == 200
-        assert provider.completed[-1]["model"] == "ChatGPT-5.6:Sol"
 
-        extreme_work = client.post(
+def test_every_user_model_runs_the_custom_agent_loop(settings, identity_jwt) -> None:
+    provider = FakeModelProvider()
+    with TestClient(_app(settings, provider)) as client:
+        luna = client.post(
             "/v1/chat/completions",
-            headers=headers(settings, identity_jwt, "extreme-work"),
-            json={"model": "work-extreme", "messages": [{"role": "user", "content": "do it carefully"}]},
+            headers=headers(settings, identity_jwt, "luna-run"),
+            json={"model": "luna", "messages": [{"role": "user", "content": "hello"}]},
         )
-        assert extreme_work.status_code == 200
+        assert luna.status_code == 200
+        assert luna.json()["model"] == "luna"
+        assert provider.completed[-1]["model"] == "ChatGPT-5.6:Luna"
+        assert provider.completed[-1]["thinking_enabled"] is True
+        assert provider.forwarded == []
+
+        deepseek = client.post(
+            "/v1/chat/completions",
+            headers=headers(settings, identity_jwt, "deepseek-run"),
+            json={"model": "deepseek-v4-pro", "messages": [{"role": "user", "content": "do it"}]},
+        )
+        assert deepseek.status_code == 200
         assert provider.completed[-1]["model"] == "deepseek-v4-pro"
         assert provider.completed[-1]["provider"] == "deepseek"
         assert provider.completed[-1]["reasoning_effort"] == "max"
 
-        downgrade = client.post(
+        legacy = client.post(
             "/v1/chat/completions",
-            headers=headers(settings, identity_jwt),
-            json={"model": "chat-medium", "messages": [{"role": "user", "content": "back"}]},
+            headers=headers(settings, identity_jwt, "legacy-run"),
+            json={"model": "work-medium", "messages": [{"role": "user", "content": "old"}]},
         )
-        assert downgrade.status_code == 409
+        assert legacy.status_code == 404
 
 
-def test_chat_stream_hides_provider_model_and_preserves_native_tool_calls(settings, identity_jwt) -> None:
+def test_openwebui_background_task_bypasses_agent_loop(settings, identity_jwt) -> None:
     provider = FakeModelProvider()
-    app = create_app(settings, store=RuntimeStore(settings.database_url), provider=provider, tools=FakeTools())
-    with TestClient(app) as client:
-        response = client.post(
-            "/v1/chat/completions",
-            headers=headers(settings, identity_jwt, "chat-stream"),
-            json={
-                "model": "chat-light",
-                "stream": True,
-                "messages": [{"role": "user", "content": "inspect"}],
-            },
-        )
-    assert response.status_code == 200
-    assert '"model": "chat-light"' in response.text
-    assert "ChatGPT-5.6:Luna" not in response.text
-    assert '"tool_calls"' in response.text
-    assert '"name": "read_file"' in response.text
-    assert "data: [DONE]" in response.text
-
-
-def test_openwebui_background_task_bypasses_work_loop(settings, identity_jwt) -> None:
-    provider = FakeModelProvider()
-    app = create_app(settings, store=RuntimeStore(settings.database_url), provider=provider, tools=FakeTools())
-    with TestClient(app) as client:
+    with TestClient(_app(settings, provider)) as client:
         response = client.post(
             "/v1/chat/completions",
             headers=headers(settings, identity_jwt, "background-task"),
             json={
-                "model": "work-medium",
+                "model": "terra",
                 "messages": [{"role": "user", "content": "Generate tags"}],
                 "metadata": {"task": "tags_generation"},
             },
         )
         assert response.status_code == 200
-        assert response.json()["model"] == "work-medium"
+        assert response.json()["model"] == "terra"
         assert provider.completed == []
         assert provider.forwarded[-1]["model"] == "ChatGPT-5.6:Terra"
 
 
-def test_work_stream_never_emits_delta_tool_calls(settings, identity_jwt) -> None:
-    app = create_app(
-        settings,
-        store=RuntimeStore(settings.database_url),
-        provider=FakeModelProvider(),
-        tools=FakeTools(),
-    )
-    with TestClient(app) as client:
+def test_agent_stream_never_emits_delta_tool_calls(settings, identity_jwt) -> None:
+    with TestClient(_app(settings)) as client:
         response = client.post(
             "/v1/chat/completions",
             headers=headers(settings, identity_jwt, "stream-chat"),
             json={
-                "model": "work-medium",
+                "model": "terra",
                 "stream": True,
                 "messages": [{"role": "user", "content": "do it"}],
             },
         )
         assert response.status_code == 200
-        assert "work complete" in response.text
+        assert "agent complete" in response.text
         for line in response.text.splitlines():
             if line.startswith("data: {"):
                 chunk = json.loads(line.removeprefix("data: "))