feat: support workload-specific model configuration, trust role description grounding, and remove emojis

README.md

@@ -1,6 +1,5 @@
 ---
 title: Hirewire Backend
-emoji: ⚡
 colorFrom: pink
 colorTo: purple
 sdk: docker

src/psview_agent/api/routes/agents.py

@@ -6,7 +6,8 @@ import logging
 import datetime
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, Header, Request
+from fastapi import APIRouter, Depends, Header, Request, Body
+from openai import AsyncOpenAI
 
 from psview_agent.api.dependencies import get_agent_configuration_service
 from psview_agent.domain.api import ConfigureAgentRequest, ConfigureAgentResponse
@@ -18,6 +19,55 @@ LOGGER = logging.getLogger("psview_agent.api.routes.agents")
 router = APIRouter(prefix="/api/v1/agents", tags=["agents"])
 
 
+@router.post("/test-connection")
+async def test_connection(
+    request: Request,
+    provider: str = Body(..., embed=True),
+    model_name: str = Body(..., embed=True),
+    api_key: str = Body(..., embed=True),
+) -> dict[str, object]:
+    """Test connection to an AI provider with the given api key and model."""
+    provider_str = provider.lower()
+    base_url = ""
+    if provider_str == "openai":
+        base_url = "https://api.openai.com/v1"
+    elif provider_str == "gemini":
+        base_url = "https://generativelanguage.googleapis.com/v1beta/openai/"
+    elif provider_str == "openrouter":
+        base_url = "https://openrouter.ai/api/v1"
+    elif provider_str == "nvidia":
+        base_url = "https://integrate.api.nvidia.com/v1"
+    else:
+        return {"status": "error", "message": f"Unsupported provider: {provider}"}
+
+    headers = {}
+    if provider_str == "openrouter":
+        settings = request.app.state.settings
+        if settings.openrouter.site_url is not None:
+            headers["HTTP-Referer"] = str(settings.openrouter.site_url)
+        if settings.openrouter.app_name:
+            headers["X-OpenRouter-Title"] = settings.openrouter.app_name
+
+    try:
+        client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=10.0,
+            max_retries=0,
+            default_headers=headers,
+        )
+        # Make a tiny chat completions call to verify
+        await client.chat.completions.create(
+            model=model_name,
+            messages=[{"role": "user", "content": "Ping"}],
+            max_tokens=2,
+        )
+        await client.close()
+        return {"status": "success", "message": "Connection verified successfully!"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
 @router.post("/configure", response_model=ConfigureAgentResponse)
 async def configure_agent(
     request: ConfigureAgentRequest,
@@ -48,13 +98,31 @@ async def configure_agent(
                 if resolved_location:
                     location = resolved_location
 
+            model_provider = None
+            model_name = None
+            try:
+                from psview_agent.core.config import model_override_var
+                override = model_override_var.get()
+                if override:
+                    model_provider = override.provider.value
+                    model_name = override.model_name
+                else:
+                    settings = fastapi_request.app.state.settings
+                    if settings:
+                        model_provider = settings.model.provider.value
+                        model_name = settings.model.model_name
+            except Exception:
+                pass
+
             await db.interactions.insert_one({
                 "user_id": x_user_id,
                 "location": location,
                 "timestamp": datetime.datetime.now(datetime.timezone.utc),
                 "action": "configure",
                 "company_context": request.company_context.model_dump(mode="json"),
-                "configuration": configuration.model_dump(mode="json")
+                "configuration": configuration.model_dump(mode="json"),
+                "model_provider": model_provider,
+                "model_name": model_name,
             })
         except Exception as err:
             LOGGER.warning(f"Failed to log configure interaction: {err}")

src/psview_agent/api/routes/conversations.py

@@ -149,6 +149,22 @@ async def log_error_interaction(
             if resolved_location:
                 location = resolved_location
 
+        model_provider = None
+        model_name = None
+        try:
+            from psview_agent.core.config import model_override_var
+            override = model_override_var.get()
+            if override:
+                model_provider = override.provider.value
+                model_name = override.model_name
+            else:
+                settings = fastapi_request.app.state.settings
+                if settings:
+                    model_provider = settings.model.provider.value
+                    model_name = settings.model.model_name
+        except Exception:
+            pass
+
         await db.interactions.insert_one({
             "user_id": x_user_id,
             "location": location,
@@ -161,7 +177,9 @@ async def log_error_interaction(
             "error_code": error_code,
             "message": friendly_msg,
             "error_type": exc.__class__.__name__,
-            "details": [str(d) for d in getattr(exc, "details", [])]
+            "details": [str(d) for d in getattr(exc, "details", [])],
+            "model_provider": model_provider,
+            "model_name": model_name,
         })
     except Exception as err:
         LOGGER.warning(f"Failed to log error interaction: {err}")
@@ -287,6 +305,22 @@ async def start_conversation(
                 if resolved_location:
                     location = resolved_location
 
+            model_provider = None
+            model_name = None
+            try:
+                from psview_agent.core.config import model_override_var
+                override = model_override_var.get()
+                if override:
+                    model_provider = override.provider.value
+                    model_name = override.model_name
+                else:
+                    settings = fastapi_request.app.state.settings
+                    if settings:
+                        model_provider = settings.model.provider.value
+                        model_name = settings.model.model_name
+            except Exception:
+                pass
+
             await db.interactions.insert_one({
                 "user_id": x_user_id,
                 "location": location,
@@ -297,7 +331,9 @@ async def start_conversation(
                 "target_role_description": request.target_role_description,
                 "candidate": request.candidate.model_dump(mode="json"),
                 "initial_response": session.messages[-1].content if session.messages else None,
-                "initial_decision_trace": trace.model_dump(mode="json") if trace else None
+                "initial_decision_trace": trace.model_dump(mode="json") if trace else None,
+                "model_provider": model_provider,
+                "model_name": model_name,
             })
         except Exception as err:
             LOGGER.warning(f"Failed to log start interaction: {err}")
@@ -351,6 +387,22 @@ async def conversation_turn(
                 if resolved_location:
                     location = resolved_location
 
+            model_provider = None
+            model_name = None
+            try:
+                from psview_agent.core.config import model_override_var
+                override = model_override_var.get()
+                if override:
+                    model_provider = override.provider.value
+                    model_name = override.model_name
+                else:
+                    settings = fastapi_request.app.state.settings
+                    if settings:
+                        model_provider = settings.model.provider.value
+                        model_name = settings.model.model_name
+            except Exception:
+                pass
+
             await db.interactions.insert_one({
                 "user_id": x_user_id,
                 "location": location,
@@ -361,7 +413,9 @@ async def conversation_turn(
                 "target_role": request.session.target_role,
                 "candidate_reply": request.candidate_reply,
                 "agent_response": response.agent_message.content if response.agent_message else None,
-                "decision_trace": response.decision_trace.model_dump(mode="json") if response.decision_trace else None
+                "decision_trace": response.decision_trace.model_dump(mode="json") if response.decision_trace else None,
+                "model_provider": model_provider,
+                "model_name": model_name,
             })
         except Exception as err:
             LOGGER.warning(f"Failed to log turn interaction: {err}")

src/psview_agent/core/config.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from enum import StrEnum
 from functools import lru_cache
+from contextvars import ContextVar
 
 from pydantic import AnyHttpUrl, Field, SecretStr, field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -20,6 +21,8 @@ class AppEnvironment(StrEnum):
 class ModelProvider(StrEnum):
     OPENROUTER = "openrouter"
     NVIDIA = "nvidia"
+    GEMINI = "gemini"
+    OPENAI = "openai"
 
 
 class StructuredOutputMode(StrEnum):
@@ -29,6 +32,18 @@ class StructuredOutputMode(StrEnum):
     PROMPT_JSON = "prompt_json"
 
 
+class ModelOverride(StrictModel):
+    provider: ModelProvider
+    api_key: str
+    model_name: str
+    general_chat_model_name: str | None = None
+    structured_json_model_name: str | None = None
+    coding_backend_model_name: str | None = None
+
+
+model_override_var: ContextVar[ModelOverride | None] = ContextVar("model_override", default=None)
+
+
 class AppSettings(StrictModel):
     name: str = Field(min_length=1, max_length=120)
     env: AppEnvironment

src/psview_agent/core/middleware.py

@@ -58,6 +58,45 @@ class RequestContextMiddleware(BaseHTTPMiddleware):
             },
         )
         return response
+    
+
+class ModelOverrideMiddleware(BaseHTTPMiddleware):
+    """Intercept model configuration override headers and set the ContextVar."""
+
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: RequestResponseEndpoint,
+    ) -> Response:
+        provider = request.headers.get("X-Model-Provider")
+        model_name = request.headers.get("X-Model-Name")
+        api_key = request.headers.get("X-Model-Api-Key")
+        general_chat_model_name = request.headers.get("X-Model-General-Chat-Name")
+        structured_json_model_name = request.headers.get("X-Model-Structured-Json-Name")
+        coding_backend_model_name = request.headers.get("X-Model-Coding-Backend-Name")
+
+        token = None
+        if provider and model_name and api_key:
+            from psview_agent.core.config import ModelOverride, ModelProvider, model_override_var
+            try:
+                override = ModelOverride(
+                    provider=ModelProvider(provider.lower()),
+                    api_key=api_key,
+                    model_name=model_name,
+                    general_chat_model_name=general_chat_model_name,
+                    structured_json_model_name=structured_json_model_name,
+                    coding_backend_model_name=coding_backend_model_name,
+                )
+                token = model_override_var.set(override)
+            except Exception as e:
+                LOGGER.warning(f"Failed to set model override from headers: {e}")
+
+        try:
+            return await call_next(request)
+        finally:
+            if token is not None:
+                from psview_agent.core.config import model_override_var
+                model_override_var.reset(token)
 
 
 class MaxRequestBodySizeMiddleware:
@@ -164,6 +203,7 @@ class DynamicCORSMiddleware(BaseHTTPMiddleware):
 
 def install_http_middleware(app: FastAPI, *, default_max_request_body_bytes: int) -> None:
     """Install core HTTP middleware."""
+    app.add_middleware(ModelOverrideMiddleware)
     app.add_middleware(RequestContextMiddleware)
     app.add_middleware(DynamicCORSMiddleware)
     app.add_middleware(

src/psview_agent/integrations/models/gateway.py

@@ -170,7 +170,7 @@ class OpenAICompatibleModelGateway(ModelGateway):
             schema_name="agent_decision",
             system_prompt=system_prompt,
             user_prompt=user_prompt,
-            workload=ModelWorkload.STRUCTURED_JSON,
+            workload=ModelWorkload.CODING_BACKEND,
         )
 
     async def generate_candidate_response(
@@ -299,7 +299,11 @@ class OpenAICompatibleModelGateway(ModelGateway):
             except Exception as exc:
                 from instructor.core import InstructorRetryException
                 from pydantic import ValidationError as PydanticValidationError
-                if isinstance(exc, (InstructorRetryException, PydanticValidationError)):
+                import openai
+                
+                if isinstance(exc, InstructorRetryException) and isinstance(exc.__cause__, openai.APIError):
+                    mapped = map_openai_error(exc.__cause__)
+                elif isinstance(exc, (InstructorRetryException, PydanticValidationError)):
                     mapped = ModelInvalidOutputError(f"instructor structured output validation failed: {exc}")
                 else:
                     mapped = map_openai_error(exc)
@@ -321,6 +325,15 @@ class OpenAICompatibleModelGateway(ModelGateway):
         )
 
     def _resolve_model_name(self, workload: ModelWorkload) -> str:
+        from psview_agent.core.config import model_override_var
+        override = model_override_var.get()
+        if override is not None:
+            if workload is ModelWorkload.GENERAL_CHAT:
+                return override.general_chat_model_name or override.model_name
+            if workload is ModelWorkload.CODING_BACKEND:
+                return override.coding_backend_model_name or override.model_name
+            return override.structured_json_model_name or override.model_name
+
         if workload is ModelWorkload.GENERAL_CHAT:
             return self._settings.model.general_chat_model_name or self._settings.model.model_name
         if workload is ModelWorkload.CODING_BACKEND:
@@ -329,8 +342,11 @@ class OpenAICompatibleModelGateway(ModelGateway):
 
     def _mode_attempts(self, model_name: str) -> list[StructuredOutputMode]:
         cached_mode = self._cached_modes.get(model_name)
+        from psview_agent.core.config import model_override_var
+        override = model_override_var.get()
+        provider = override.provider if override else self._settings.model.provider
         seq = mode_sequence(
-            self._settings.model.provider,
+            provider,
             self._settings.model.structured_output_mode,
         )
         if cached_mode is not None and cached_mode in seq:
@@ -359,62 +375,99 @@ class OpenAICompatibleModelGateway(ModelGateway):
         if mode in {StructuredOutputMode.JSON_OBJECT, StructuredOutputMode.PROMPT_JSON}:
             prompt_suffix = "\n" + prompt_json_instructions(output_model)
             
-        instructor_client = instructor.from_openai(self._client, mode=mode_map[mode])
+        from psview_agent.core.config import model_override_var
+        override = model_override_var.get()
         
-        try:
-            async with self._semaphore:
-                parsed = await instructor_client.chat.completions.create(
-                    model=model_name,
-                    messages=[
-                        {"role": "system", "content": system_prompt + prompt_suffix},
-                        {"role": "user", "content": user_prompt},
-                    ],
-                    response_model=output_model,
-                    temperature=self._settings.model.temperature,
-                    max_tokens=self._settings.model.max_output_tokens,
-                    max_retries=self._settings.model.repair_attempts,
-                    extra_body=self._settings.model.extra_body,
-                )
-            
-            LOGGER.info(
-                "Instructor model completion succeeded",
-                extra={
-                    "provider": self._settings.model.provider.value,
-                    "model_name": model_name,
-                    "structured_output_mode": mode.value,
-                },
+        client_to_use = self._client
+        temp_client = None
+        
+        if override is not None:
+            base_url = ""
+            if override.provider == "openai":
+                base_url = "https://api.openai.com/v1"
+            elif override.provider == "gemini":
+                base_url = "https://generativelanguage.googleapis.com/v1beta/openai/"
+            elif override.provider == "openrouter":
+                base_url = "https://openrouter.ai/api/v1"
+            elif override.provider == "nvidia":
+                base_url = "https://integrate.api.nvidia.com/v1"
+
+            headers = {}
+            if override.provider == "openrouter":
+                if self._settings.openrouter.site_url is not None:
+                    headers["HTTP-Referer"] = str(self._settings.openrouter.site_url)
+                if self._settings.openrouter.app_name:
+                    headers["X-OpenRouter-Title"] = self._settings.openrouter.app_name
+
+            temp_client = AsyncOpenAI(
+                api_key=override.api_key,
+                base_url=base_url,
+                timeout=self._settings.model.timeout_seconds,
+                max_retries=self._settings.model.max_retries,
+                default_headers=headers,
             )
-            self._cached_modes[model_name] = mode
-            return sanitize_model_strings(parsed)
-        except Exception as exc:
-            # Extract raw response text if validation failed under Instructor
-            raw_content = None
-            if hasattr(exc, "last_completion") and exc.last_completion:
-                raw_content = getattr(exc.last_completion.choices[0].message, "content", None)
+            client_to_use = temp_client
+
+        try:
+            instructor_client = instructor.from_openai(client_to_use, mode=mode_map[mode])
             
-            if raw_content:
-                LOGGER.warning(
-                    "Instructor validation failed for model %s; attempting custom recursive repair. error: %s. content: %s",
+            try:
+                async with self._semaphore:
+                    parsed = await instructor_client.chat.completions.create(
+                        model=model_name,
+                        messages=[
+                            {"role": "system", "content": system_prompt + prompt_suffix},
+                            {"role": "user", "content": user_prompt},
+                        ],
+                        response_model=output_model,
+                        temperature=self._settings.model.temperature,
+                        max_tokens=self._settings.model.max_output_tokens,
+                        max_retries=self._settings.model.repair_attempts,
+                        extra_body=self._settings.model.extra_body,
+                    )
+                
+                LOGGER.info(
+                    "Instructor model completion succeeded",
+                    extra={
+                        "provider": override.provider.value if override else self._settings.model.provider.value,
+                        "model_name": model_name,
+                        "structured_output_mode": mode.value,
+                    },
+                )
+                self._cached_modes[model_name] = mode
+                return sanitize_model_strings(parsed)
+            except Exception as exc:
+                # Extract raw response text if validation failed under Instructor
+                raw_content = None
+                if hasattr(exc, "last_completion") and exc.last_completion:
+                    raw_content = getattr(exc.last_completion.choices[0].message, "content", None)
+                
+                if raw_content:
+                    LOGGER.warning(
+                        "Instructor validation failed for model %s; attempting custom recursive repair. error: %s. content: %s",
+                        output_model.__name__,
+                        str(exc),
+                        raw_content,
+                    )
+                    repaired = self._attempt_repair(
+                        content=raw_content,
+                        errors=str(exc),
+                        output_model=output_model,
+                    )
+                    if repaired is not None:
+                        LOGGER.info("successfully repaired model %s via fallback repair", output_model.__name__)
+                        self._cached_modes[model_name] = mode
+                        return repaired
+                
+                LOGGER.error(
+                    "Instructor execution failed for model %s. error: %s",
                     output_model.__name__,
                     str(exc),
-                    raw_content,
-                )
-                repaired = self._attempt_repair(
-                    content=raw_content,
-                    errors=str(exc),
-                    output_model=output_model,
                 )
-                if repaired is not None:
-                    LOGGER.info("successfully repaired model %s via fallback repair", output_model.__name__)
-                    self._cached_modes[model_name] = mode
-                    return repaired
-            
-            LOGGER.error(
-                "Instructor execution failed for model %s. error: %s",
-                output_model.__name__,
-                str(exc),
-            )
-            raise
+                raise
+        finally:
+            if temp_client is not None:
+                await temp_client.close()
 
     def _clean_json_text(self, content: str) -> str:
         content = content.strip()

src/psview_agent/integrations/models/structured_output.py

@@ -12,7 +12,7 @@ def mode_sequence(
     """Return the allowed fallback sequence."""
     if preferred is not StructuredOutputMode.AUTO:
         return [preferred]
-    if provider is ModelProvider.OPENROUTER:
+    if provider in (ModelProvider.OPENROUTER, ModelProvider.OPENAI):
         return [
             StructuredOutputMode.JSON_SCHEMA,
             StructuredOutputMode.JSON_OBJECT,

src/psview_agent/prompts/action_planning.py

@@ -28,11 +28,13 @@ def build_action_planning_prompts(
     system_prompt = (
         "Plan the recruiting agent's next objective and action.\n"
         f"{PROMPT_SECURITY_INSTRUCTION}\n"
-        "Select only evidence IDs from the retrieved evidence. "
-        "Identify missing information when direct support is absent. The rationale_summary must "
-        "be specific to the candidate's latest reply and must name the selected evidence IDs or "
-        "the missing information that blocks a stronger answer. Avoid generic wording such as "
-        "'keep it grounded' or unsupported fit language."
+        "Select only evidence IDs from the retrieved evidence. Note that the target role and its description "
+        "(in role_context) are fully trusted sources of truth for the role's details, requirements, qualifications, "
+        "and responsibilities. Do NOT treat role details or qualifications explicitly stated in the role description "
+        "as missing information. Identify missing information only when a topic is not supported by either the "
+        "retrieved evidence or the role description. The rationale_summary must be specific to the candidate's latest reply "
+        "and must name the selected evidence IDs, role context details used, or the missing information that blocks a stronger answer. "
+        "Avoid generic wording such as 'keep it grounded' or unsupported fit language."
     )
     user_prompt = untrusted_json_block(
         {

src/psview_agent/prompts/response_evaluation.py

@@ -30,7 +30,9 @@ def build_response_evaluation_prompts(
         "Evaluate the candidate-facing response independently.\n"
         f"{PROMPT_SECURITY_INSTRUCTION}\n"
         "Check persona consistency, grounding, relevance, action alignment, "
-        "naturalness, repetition, and policy issues."
+        "naturalness, repetition, and policy issues. The target role and description in role_context "
+        "are fully trusted. Any claims directly supported by the role description are considered grounded "
+        "and must NOT be flagged as unsupported claims, even if they don't have associated company evidence fact IDs."
     )
     user_prompt = untrusted_json_block(
         {

src/psview_agent/prompts/response_generation.py

@@ -27,13 +27,14 @@ def build_response_generation_prompts(
     system_prompt = (
         "Generate a grounded candidate-facing response.\n"
         f"{PROMPT_SECURITY_INSTRUCTION}\n"
-        "Follow the selected action, stay in persona, use only selected "
-        "evidence, remain concise, and ask at most one question. Return "
-        "supported_claims for each factual company claim you make. Each "
-        "supported claim must quote or closely paraphrase one claim from the "
-        "message and cite only exact evidence IDs from decision.company_fact_ids_to_use. "
-        "If a sentence is purely courtesy, transition, or AI disclosure without a company "
-        "fact, do not include it in supported_claims."
+        "Follow the selected action, stay in persona, use only selected evidence and the trusted role description "
+        "(in role_context), remain concise, and ask at most one question. The role title and description are "
+        "fully trusted sources of truth for role requirements and details. You can freely state any requirements, qualifications, "
+        "or details explicitly mentioned in the role description. Return supported_claims only for factual company claims "
+        "made that are based on company evidence facts (citing exact evidence IDs from decision.company_fact_ids_to_use). "
+        "Do NOT create supported_claims or cite evidence IDs for claims that are directly supported by the role description itself, "
+        "as they are trusted implicitly. If a sentence is purely courtesy, transition, AI disclosure, or directly from the "
+        "trusted role description, do not include it in supported_claims."
     )
     user_prompt = untrusted_json_block(
         {

src/psview_agent/prompts/response_revision.py

@@ -32,10 +32,10 @@ def build_response_revision_prompts(
         "Revise the candidate-facing response once.\n"
         f"{PROMPT_SECURITY_INSTRUCTION}\n"
         "Fix only the identified failures, preserve valid content, keep the "
-        "selected action, and use only supported evidence. Keep supported_claims aligned "
-        "with the revised message. Every factual company claim must cite exact evidence IDs "
-        "from decision.company_fact_ids_to_use, and unsupported or uncited claims must be "
-        "removed instead of guessed."
+        "selected action, and use only supported evidence and the trusted role description (in role_context). "
+        "Keep supported_claims aligned with the revised message. Every factual company claim (based on company evidence) "
+        "must cite exact evidence IDs from decision.company_fact_ids_to_use. Claims directly based on the trusted role description "
+        "do not need evidence IDs and should not be cited in supported_claims. Remove any guessed or unsupported company claims."
     )
     user_prompt = untrusted_json_block(
         {

tests/unit/test_conversations_persistence.py

@@ -239,3 +239,75 @@ async def test_api_routes_error_persistence_logging(client: AsyncClient, app, mo
     assert call_args["error_code"] == "turn_limit_reached"
     assert "limit" in call_args["message"].lower()
 
+
+@pytest.mark.anyio
+async def test_model_override_middleware(client: AsyncClient, app) -> None:
+    from psview_agent.core.config import model_override_var
+    
+    # Add a temporary test endpoint to verify the contextvar
+    @app.get("/api/test-context-override")
+    async def test_context_override():
+        override = model_override_var.get()
+        if override:
+            return {
+                "provider": override.provider.value,
+                "model_name": override.model_name,
+                "api_key": override.api_key
+            }
+        return {"override": None}
+        
+    # Send request with headers
+    headers = {
+        "X-Model-Provider": "gemini",
+        "X-Model-Name": "gemini-2.5-flash",
+        "X-Model-Api-Key": "my-gemini-key"
+    }
+    
+    resp = await client.get("/api/test-context-override", headers=headers)
+    assert resp.status_code == 200
+    assert resp.json() == {
+        "provider": "gemini",
+        "model_name": "gemini-2.5-flash",
+        "api_key": "my-gemini-key"
+    }
+    
+    # Send request without headers
+    resp_no_headers = await client.get("/api/test-context-override")
+    assert resp_no_headers.status_code == 200
+    assert resp_no_headers.json() == {"override": None}
+
+
+@pytest.mark.anyio
+async def test_model_override_middleware_and_test_connection(client: AsyncClient, monkeypatch: pytest.MonkeyPatch) -> None:
+    # Mock AsyncOpenAI call inside test_connection
+    mock_create = AsyncMock()
+    mock_client_instance = MagicMock()
+    mock_client_instance.chat = MagicMock()
+    mock_client_instance.chat.completions = MagicMock()
+    mock_client_instance.chat.completions.create = mock_create
+    mock_client_instance.close = AsyncMock()
+    
+    mock_init = MagicMock(return_value=mock_client_instance)
+    monkeypatch.setattr("psview_agent.api.routes.agents.AsyncOpenAI", mock_init)
+    
+    # Test connection request payload
+    test_payload = {
+        "provider": "openai",
+        "model_name": "gpt-4o-test",
+        "api_key": "my-custom-key"
+    }
+    
+    response = await client.post("/api/v1/agents/test-connection", json=test_payload)
+    assert response.status_code == 200
+    assert response.json() == {"status": "success", "message": "Connection verified successfully!"}
+    
+    # Ensure it initialized with the correct base url and api key
+    mock_init.assert_called_once_with(
+        api_key="my-custom-key",
+        base_url="https://api.openai.com/v1",
+        timeout=10.0,
+        max_retries=0,
+        default_headers={},
+    )
+
+

tests/unit/test_model_gateway_routing.py

@@ -271,7 +271,7 @@ async def test_generate_candidate_response_sanitizes_text_and_derives_ids() -> N
 
 
 @pytest.mark.asyncio
-async def test_plan_next_action_uses_structured_json_workload() -> None:
+async def test_plan_next_action_uses_coding_backend_workload() -> None:
     gateway = OpenAICompatibleModelGateway(
         client=cast(AsyncOpenAI, object()),
         settings=_settings(),
@@ -306,7 +306,7 @@ async def test_plan_next_action_uses_structured_json_workload() -> None:
         retrieved_evidence=[],
     )
 
-    assert seen_workloads == [ModelWorkload.STRUCTURED_JSON]
+    assert seen_workloads == [ModelWorkload.CODING_BACKEND]
 
 
 def test_gateway_repair_recursive_and_padding() -> None:

tests/unit/test_support_modules.py

@@ -256,3 +256,25 @@ def test_text_helpers_normalize_and_split_content() -> None:
     assert sanitize_generated_text("Hi\u00a0there\u2014I\u2019m ready\u2026") == (
         "Hi there-I'm ready..."
     )
+
+
+def test_model_override_and_modes() -> None:
+    from psview_agent.core.config import ModelOverride, ModelProvider, model_override_var
+    gemini_modes = mode_sequence(ModelProvider.GEMINI, StructuredOutputMode.AUTO)
+    openai_modes = mode_sequence(ModelProvider.OPENAI, StructuredOutputMode.AUTO)
+    
+    assert gemini_modes == [StructuredOutputMode.JSON_OBJECT, StructuredOutputMode.PROMPT_JSON]
+    assert openai_modes == [
+        StructuredOutputMode.JSON_SCHEMA,
+        StructuredOutputMode.JSON_OBJECT,
+        StructuredOutputMode.PROMPT_JSON,
+    ]
+    
+    override = ModelOverride(
+        provider=ModelProvider.GEMINI,
+        api_key="override-key",
+        model_name="gemini-flash-test",
+    )
+    assert override.provider == ModelProvider.GEMINI
+    assert override.api_key == "override-key"
+    assert override.model_name == "gemini-flash-test"