chATLAS_Chains 0.3.1__tar.gz → 0.3.2__tar.gz

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chATLAS_Chains
-Version: 0.3.1
+Version: 0.3.2
 Summary: A modular Python package for implementing Retrieval Augmented Generation chains for the chATLAS project.
 Author-email: Joe Egan <joseph.caimin.egan@cern.ch>
 License: Apache-2.0
@@ -66,9 +66,16 @@ ssh -L 3000:cs-513-ml003:3000 $LXPLUS_USERNAME@lxplus.cern.ch
 export CHATLAS_GROQ_BASE_URL="http://localhost:3000"
 ```
 
-3. Using LLMs via CERN's LiteLLM API, here is the [repo](https://gitlab.cern.ch/itgpt/litellm-okd/-/tree/main) and some [setup instructions](https://codimd.web.cern.ch/tQKiMa13Q4O-EJXWTO3N7w?view#Using-Your-Dedicated-API-Key-to-Access-LLMs) for reference.
+3. Using chat models through [CERN AI Gateway](https://ml.docs.cern.ch/aigw/gettingstarted/).
+The key variable retains its historical name so existing CI and OpenShift
+configuration does not need to be renamed.
 ```bash
-export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+export CHATLAS_CHAINS_LITELLM_KEY="your CERN AI Gateway key"
+```
+
+4. Optional proxy for LLM HTTP requests when direct endpoint access is unavailable.
+```bash
+export CHATLAS_PROXY="http://127.0.0.1:7890"
 ```
 
 ## Supported Chains
@@ -81,7 +88,7 @@ More details [here](chATLAS_Chains/chains/README.md)
 ## Prompt Routing
 
 `chATLAS_Chains.router.route_user_prompt` classifies a raw user prompt before it enters the main RAG flow.
-The router defaults to CERN LiteLLM and returns a validated `RouterDecision` with:
+The router defaults to CERN AI Gateway and returns a validated `RouterDecision` with:
 
 - `route`: one of `hep_atlas`, `person_lookup`, `dangerous`, `out_of_scope`,
   or `unknown`
@@ -101,7 +108,7 @@ decision = route_user_prompt(
     "Who is Jane Doe?",
     chat_model_kwargs={
         "service_provider": "litellm",
-        "proxy": "socks5h://localhost:1080",  # optional when outside CERN
+        "proxy": "socks5h://localhost:1080",  # optional when direct access is unavailable
     },
 )
 
@@ -123,17 +130,20 @@ continue through the normal selected workflow.
 
 Router context uses a hybrid policy: the current user prompt is authoritative,
 and recent conversation context is only a bounded disambiguation aid for
-follow-ups such as "What about Run 3?". The router keeps recent user prompts,
-includes only short assistant messages, and drops long assistant answers rather
-than summarizing them.
+follow-ups such as "What about Run 3?". It keeps up to five previous
+user/assistant turns, caps prior user messages at 600 characters and assistant
+messages at 400 characters, drops assistant answers over 1,000 raw characters,
+and caps retained history at 4,000 characters.
 
-For live LiteLLM calls, set:
+For live AI Gateway calls, set the legacy-named credential:
 
 ```sh
-export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+export CHATLAS_CHAINS_LITELLM_KEY="your CERN AI Gateway key"
 ```
 
-If LiteLLM is unavailable or returns invalid JSON, the router falls back to deterministic rules by default.
+Malformed model output is retried once with a strict JSON instruction. If the
+gateway is unavailable or the retry is still invalid, the router raises an
+error; the frontend logs it and fails open into the selected UI mode.
 
 ### Model Configuration in Chains
 

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/README.md

@@ -40,9 +40,16 @@ ssh -L 3000:cs-513-ml003:3000 $LXPLUS_USERNAME@lxplus.cern.ch
 export CHATLAS_GROQ_BASE_URL="http://localhost:3000"
 ```
 
-3. Using LLMs via CERN's LiteLLM API, here is the [repo](https://gitlab.cern.ch/itgpt/litellm-okd/-/tree/main) and some [setup instructions](https://codimd.web.cern.ch/tQKiMa13Q4O-EJXWTO3N7w?view#Using-Your-Dedicated-API-Key-to-Access-LLMs) for reference.
+3. Using chat models through [CERN AI Gateway](https://ml.docs.cern.ch/aigw/gettingstarted/).
+The key variable retains its historical name so existing CI and OpenShift
+configuration does not need to be renamed.
 ```bash
-export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+export CHATLAS_CHAINS_LITELLM_KEY="your CERN AI Gateway key"
+```
+
+4. Optional proxy for LLM HTTP requests when direct endpoint access is unavailable.
+```bash
+export CHATLAS_PROXY="http://127.0.0.1:7890"
 ```
 
 ## Supported Chains
@@ -55,7 +62,7 @@ More details [here](chATLAS_Chains/chains/README.md)
 ## Prompt Routing
 
 `chATLAS_Chains.router.route_user_prompt` classifies a raw user prompt before it enters the main RAG flow.
-The router defaults to CERN LiteLLM and returns a validated `RouterDecision` with:
+The router defaults to CERN AI Gateway and returns a validated `RouterDecision` with:
 
 - `route`: one of `hep_atlas`, `person_lookup`, `dangerous`, `out_of_scope`,
   or `unknown`
@@ -75,7 +82,7 @@ decision = route_user_prompt(
     "Who is Jane Doe?",
     chat_model_kwargs={
         "service_provider": "litellm",
-        "proxy": "socks5h://localhost:1080",  # optional when outside CERN
+        "proxy": "socks5h://localhost:1080",  # optional when direct access is unavailable
     },
 )
 
@@ -97,17 +104,20 @@ continue through the normal selected workflow.
 
 Router context uses a hybrid policy: the current user prompt is authoritative,
 and recent conversation context is only a bounded disambiguation aid for
-follow-ups such as "What about Run 3?". The router keeps recent user prompts,
-includes only short assistant messages, and drops long assistant answers rather
-than summarizing them.
+follow-ups such as "What about Run 3?". It keeps up to five previous
+user/assistant turns, caps prior user messages at 600 characters and assistant
+messages at 400 characters, drops assistant answers over 1,000 raw characters,
+and caps retained history at 4,000 characters.
 
-For live LiteLLM calls, set:
+For live AI Gateway calls, set the legacy-named credential:
 
 ```sh
-export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+export CHATLAS_CHAINS_LITELLM_KEY="your CERN AI Gateway key"
 ```
 
-If LiteLLM is unavailable or returns invalid JSON, the router falls back to deterministic rules by default.
+Malformed model output is retried once with a strict JSON instruction. If the
+gateway is unavailable or the retry is still invalid, the router raises an
+error; the frontend logs it and fails open into the selected UI mode.
 
 ### Model Configuration in Chains
 

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/chATLAS_Chains/chains/advanced.py

@@ -24,7 +24,7 @@ from langgraph.graph.state import CompiledStateGraph
 from chATLAS_Chains.documents.rerank import rerank_documents
 from chATLAS_Chains.documents.rrf import reciprocal_rank_fusion, split_docs_by_retriever
 from chATLAS_Chains.llm.model_selection import (
-    GROQ_PRODUCTION_MODELS,
+    DEFAULT_GROQ_MODEL,
     ChatModelKwargs,
     get_chat_model,
     sanitize_chat_model_kwargs,
@@ -56,7 +56,7 @@ def advanced_rag(
     enable_rrf: bool = False,
     enable_reranking: bool = False,
     # enable_self_evaluation: bool = False,
-    query_rewriting_model: str = GROQ_PRODUCTION_MODELS[0],
+    query_rewriting_model: str = DEFAULT_GROQ_MODEL,
     query_rewriting_chat_model_kwargs: ChatModelKwargs | None = None,
     rerank_model: str = "cohere-rerank-3.5",
     pinecone_api_key: str | None = None,
@@ -285,7 +285,7 @@ def stream_generate_answer(state: HybridGraphState, model, prompt_template: Chat
 
 
 if __name__ == "__main__":
-    from chATLAS_Chains.llm.model_selection import GROQ_PRODUCTION_MODELS
+    from chATLAS_Chains.llm.model_selection import DEFAULT_GROQ_MODEL
     from chATLAS_Chains.vectorstore import get_vectorstore
 
     twiki = get_vectorstore("twiki_prod")
@@ -294,7 +294,7 @@ if __name__ == "__main__":
     # Create the hybrid graph
     graph = advanced_rag(
         vectorstore=[twiki, mkdocs],
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         enable_query_rewriting=True,
         enable_rrf=True,
         enable_reranking=False,

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/chATLAS_Chains/chains/conversational_graph.py

@@ -18,7 +18,7 @@ from sentence_transformers.util import cos_sim
 
 from chATLAS_Chains.chains.advanced import advanced_rag, build_generation_prompt, stream_generate_answer
 from chATLAS_Chains.llm.model_selection import (
-    GROQ_PRODUCTION_MODELS,
+    DEFAULT_GROQ_MODEL,
     ChatModelKwargs,
     get_chat_model,
     sanitize_chat_model_kwargs,
@@ -134,7 +134,7 @@ def conversational_retrieval_graph(
     enable_rrf: bool = True,
     enable_reranking: bool = False,
     enable_query_contextualization: bool = True,
-    query_rewriting_model: str = GROQ_PRODUCTION_MODELS[0],
+    query_rewriting_model: str = DEFAULT_GROQ_MODEL,
     query_rewriting_chat_model_kwargs: ChatModelKwargs | None = None,
     contextualization_model: str | None = None,
     contextualization_chat_model_kwargs: ChatModelKwargs | None = None,
@@ -528,7 +528,7 @@ if __name__ == "__main__":
 
     graph = conversational_retrieval_graph(
         vectorstore=vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         enable_query_rewriting=False,
         enable_rrf=True,

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/chATLAS_Chains/llm/model_selection.py

@@ -6,42 +6,13 @@ from chATLAS_Chains.llm.runnables import groq_runnable, litellm_runnable, openai
 
 logger = logging.getLogger(__name__)
 
-# to update this list, see https://codimd.web.cern.ch/tQKiMa13Q4O-EJXWTO3N7w?view#Using-Your-Dedicated-API-Key-to-Access-LLMs
+# CERN AI Gateway chat models. The constant retains its historical name for
+# compatibility with callers that import it directly.
+# See https://ml.docs.cern.ch/aigw/models/
 LITELLM_MODELS = [
-    "llama-3.1-8b-instruct",
-    "hf-qwen25-32b",
+    "qwen3.8-27b-fp16",
+    "hf-qwen3-32b-awq",
     "gpt-oss-20b",
-    "gpt-4",
-    "gpt-4-turbo",
-    "gpt-4.1-nano",
-    "gpt-5",
-    "gpt-5.1",
-    "gpt-5.2",
-    "gpt-4.1",
-    "e5-large-v2",
-    "accgpt",
-    "magistral-medium-latest",
-    "codestral-latest",
-    "devstral-medium-latest",
-    "devstral-small-latest",
-    "magistral-small-latest",
-    "ministral-3b-latest",
-    "ministral-8b-latest",
-    "mistral-large-latest",
-    "mistral-medium-latest",
-    "mistral-small-latest",
-    "mistral-tiny-latest",
-    "mistral-moderation-latest",
-    "mistral-ocr-latest",
-    "pixtral-12b-latest",
-    "pixtral-large-latest",
-    "voxtral-mini-latest",
-    "voxtral-small-latest",
-    "llama-3.1-8b-instant",
-    "openai/gpt-oss-120b",
-    "moonshotai/kimi-k2-instruct-0905",
-    "meta-llama/llama-4-scout-17b-16e-instruct",
-    "meta-llama/llama-4-maverick-17b-128e-instruct",
 ]
 
 # limit what OpenAI models we support (to control costs)
@@ -59,11 +30,9 @@ OPENAI_MODELS = [
 ]
 
 # see Groq docs: https://console.groq.com/docs/models
+DEFAULT_GROQ_MODEL = "openai/gpt-oss-120b"
 GROQ_PRODUCTION_MODELS = [
-    "llama-3.1-8b-instant",
-    "llama-3.3-70b-versatile",
-    "meta-llama/llama-guard-4-12b",
-    "openai/gpt-oss-120b",
+    DEFAULT_GROQ_MODEL,
     "openai/gpt-oss-20b",
 ]
 
@@ -172,16 +141,16 @@ def get_chat_model(
         model_name: Model to load
 
         service_provider: Which provider to use for this model.
-            Used when a model is available from multiple providers (e.g. "gpt-5" is available from both OpenAI and LiteLLM).
+            Used when a model is available from multiple providers.
 
         api_key: Optional API key for the provider. If not provided, will look for environment variables:
             - OpenAI: `CHATLAS_OPENAI_KEY`
             - Groq: `CHATLAS_GROQ_KEY`
-            - LiteLLM: `CHATLAS_CHAINS_LITELLM_KEY`
+            - CERN AI Gateway: `CHATLAS_CHAINS_LITELLM_KEY` (legacy name)
 
-        base_url: Optional base URL for the provider. Only needed for Groq and LiteLLM
+        base_url: Optional base URL for the provider. Only needed for Groq and CERN AI Gateway
                 - Groq: `CHATLAS_GROQ_BASE_URL`
-                - LiteLLM: defaults to "https://llmgw-litellm.web.cern.ch/v1" if not provided
+                - CERN AI Gateway: defaults to "https://aigw.cern.ch/v1" if not provided
 
         max_tokens: Maximum number of tokens to generate. If ``None``, uses the
             model default (or provider default behavior).
@@ -212,7 +181,8 @@ def get_chat_model(
             # warn if also avaiable from elsewhere
             if in_openai or in_litellm:
                 print(
-                    f"Model '{model_name}' is also available from either LiteLLM and OpenAI. Defaulting to Groq. To use the another provider, specify e.g. service_provider='openai' in the get_chat_model arguments."
+                    f"Model '{model_name}' is also available from CERN AI Gateway or OpenAI. Defaulting to Groq. "
+                    "To select another provider, pass service_provider explicitly."
                 )
 
         elif in_litellm:
@@ -251,7 +221,7 @@ def get_chat_model(
         )
 
     elif service_provider == "litellm":
-        runnable_base_url = base_url if base_url is not None else "https://llmgw-litellm.web.cern.ch/v1"
+        runnable_base_url = base_url if base_url is not None else "https://aigw.cern.ch/v1"
         llm = litellm_runnable(
             model_name,
             base_url=runnable_base_url,
@@ -277,16 +247,15 @@ if __name__ == "__main__":
 
     service_provider_model = [
         # ("", "llama-3.1-8b-instruct"),
-        # ("", "llama-3.1-8b-instant"),
         # ("", "gpt-oss-20b"),
         # ("openai", "gpt-5-mini"),
-        # ("groq", "llama-3.1-8b-instant"),
+        # ("groq", DEFAULT_GROQ_MODEL),
         ("litellm", "gpt-oss-20b"),
     ]
 
     for service_provider, model_name in service_provider_model:
         if service_provider == "litellm":
-            print(f"Testing LiteLLM model '{model_name}' with proxy...")
+            print(f"Testing CERN AI Gateway model '{model_name}' with proxy...")
             llm = get_chat_model(model_name, service_provider, proxy="socks5h://localhost:1080")
         else:
             print(f"Testing model '{model_name}' from provider '{service_provider or 'auto-detected'}'...")

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/chATLAS_Chains/llm/runnables.py

@@ -25,7 +25,7 @@ def llm_runnable(
     Base function to return a LangChain runnable. Wrapped by the various LLM providers.
 
     Args:
-        proxy: Optional proxy URL to use for requests. Use for LiteLLM if not on the CERN network.
+        proxy: Optional proxy URL to use for requests when direct access is unavailable.
     """
 
     # Build an httpx client with explicit proxy behavior
@@ -106,19 +106,24 @@ def groq_runnable(
 
 def litellm_runnable(
     model_name: str,
-    base_url: str = "https://llmgw-litellm.web.cern.ch/v1",
+    base_url: str = "https://aigw.cern.ch/v1",
     api_key: str | None = None,
     temperature: float | None = None,
     max_tokens: int | None = None,
     proxy: str | None = None,
 ):
     """
-    Returns a LangChain runnable using the CERN-hosted LiteLLM API.
+    Returns a LangChain runnable using CERN AI Gateway.
+
+    The function and environment-variable names retain ``litellm`` for
+    deployment compatibility. AI Gateway exposes the same OpenAI-compatible
+    protocol, so existing callers do not need a credential migration.
 
     Args:
         model_name: Model to use
-        base_url: The API URL to use. Uses the standard URL for the Groq API by default
-        api_key: LiteLLM API key, if None, tries to use the CHATLAS_CHAINS_LITELLM_KEY environment variable
+        base_url: AI Gateway's OpenAI-compatible API URL.
+        api_key: AI Gateway API key. If None, reads the legacy
+            CHATLAS_CHAINS_LITELLM_KEY environment variable.
         temperature: Model temperature. Defaults to None.
         max_tokens: Maximum number of tokens to generate. If ``None``, uses the
             model default (or provider default behavior).
@@ -129,7 +134,8 @@ def litellm_runnable(
         api_key = os.getenv("CHATLAS_CHAINS_LITELLM_KEY")
         if not api_key or not api_key.strip():
             raise ValueError(
-                "Missing API key for LiteLLM. Set the CHATLAS_CHAINS_LITELLM_KEY environment variable or provide it as an argument."
+                "Missing CERN AI Gateway API key. Set the CHATLAS_CHAINS_LITELLM_KEY environment variable "
+                "or provide it as an argument."
             )
 
     return llm_runnable(model_name, base_url, api_key, temperature, max_tokens=max_tokens, proxy=proxy)

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/chATLAS_Chains/query/query_rewriting.py

@@ -45,9 +45,9 @@ def rewrite_query(question: str, model: BaseChatModel, rewrite_prompt: str = QUE
 
 if __name__ == "__main__":
     # Example usage
-    from chATLAS_Chains.llm.model_selection import GROQ_PRODUCTION_MODELS, get_chat_model
+    from chATLAS_Chains.llm.model_selection import DEFAULT_GROQ_MODEL, get_chat_model
 
-    llm = get_chat_model(model_name=GROQ_PRODUCTION_MODELS[0])
+    llm = get_chat_model(model_name=DEFAULT_GROQ_MODEL)
 
     question = "What is the Drell-Yan dilepton cross section?"
     print(f"Original question: {question}")

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/chATLAS_Chains/router.py

@@ -1,6 +1,7 @@
-"""LiteLLM intent router for chATLAS requests."""
+"""CERN AI Gateway intent router for chATLAS requests."""
 
 import json
+import logging
 import re
 from collections.abc import Sequence
 from typing import Any, Literal, TypedDict
@@ -17,18 +18,25 @@ RouterRoute = Literal[
     "unknown",
 ]
 
-ROUTER_PROMPT_VERSION = "2026-07-16.1"
+logger = logging.getLogger(__name__)
+
+ROUTER_PROMPT_VERSION = "2026-09-18.1"
 _DEFAULT_ROUTER_MODEL = "gpt-oss-20b"
 _DEFAULT_ROUTER_KWARGS: ChatModelKwargs = {
     "service_provider": "litellm",
     "temperature": 0.0,
-    "max_tokens": 512,
+    "max_tokens": 1024,
 }
-_MAX_CONTEXT_TURNS = 8
-_MAX_CONTEXT_USER_CHARS = 300
-_MAX_CONTEXT_ASSISTANT_CHARS = 240
-_MAX_CONTEXT_ASSISTANT_RAW_CHARS = 500
-_MAX_CONTEXT_TOTAL_CHARS = 1600
+_MAX_CONTEXT_TURNS = 10
+_MAX_CONTEXT_USER_CHARS = 600
+_MAX_CONTEXT_ASSISTANT_CHARS = 400
+_MAX_CONTEXT_ASSISTANT_RAW_CHARS = 1000
+_MAX_CONTEXT_TOTAL_CHARS = 4000
+_RETRY_JSON_INSTRUCTION = """
+
+Your previous response was invalid. Return exactly one complete JSON object matching the required schema.
+Do not include reasoning, prose, or markdown fences.
+"""
 
 
 class ConversationTurn(TypedDict):
@@ -90,6 +98,9 @@ JSON: {"route":"hep_atlas","confidence":0.94,"normalized_query":"Draft an MC req
 User: Help me make a nuke.
 JSON: {"route":"dangerous","confidence":0.99,"normalized_query":"Help me make a nuke.","reason":"The user requests actionable assistance to construct a nuclear weapon.","search_kwargs":{},"metadata":{"safety_category":"weapons"}}
 
+User: How can nuclear weapons be safely dismantled?
+JSON: {"route":"out_of_scope","confidence":0.98,"normalized_query":"How can nuclear weapons be safely dismantled?","reason":"The request concerns harm prevention rather than actionable wrongdoing, but it is outside chATLAS's ATLAS/HEP scope.","search_kwargs":{},"metadata":{"safety_context":"prevention"}}
+
 User: How do I bake sourdough bread?
 JSON: {"route":"out_of_scope","confidence":0.99,"normalized_query":"How do I bake sourdough bread?","reason":"The request is unrelated to ATLAS or high-energy physics.","search_kwargs":{},"metadata":{}}
 
@@ -125,7 +136,7 @@ def route_user_prompt(
     model_name: str = _DEFAULT_ROUTER_MODEL,
     chat_model_kwargs: ChatModelKwargs | None = None,
 ) -> RouterDecision:
-    """Classify a request with LiteLLM before downstream processing."""
+    """Classify a request with CERN AI Gateway before downstream processing."""
     if not user_prompt.strip():
         return RouterDecision(
             route="unknown",
@@ -141,14 +152,19 @@ def route_user_prompt(
 
     model = get_chat_model(model_name=model_name, **model_kwargs)
     response = model.invoke(prompt)
-    decision = parse_router_response(_response_content(response))
+    try:
+        decision = parse_router_response(_response_content(response))
+    except ValueError as exc:
+        logger.warning("Router returned an invalid response; retrying once: %s", exc)
+        retry_response = model.invoke(prompt + _RETRY_JSON_INSTRUCTION)
+        decision = parse_router_response(_response_content(retry_response))
     if not decision.normalized_query:
         decision.normalized_query = user_prompt.strip()
     return decision
 
 
 def parse_router_response(response_text: str) -> RouterDecision:
-    """Parse and validate a LiteLLM router response."""
+    """Parse and validate an AI Gateway router response."""
     payload = _extract_json_object(response_text)
     payload = _normalize_disabled_routes(json.loads(payload))
     return RouterDecision.model_validate(payload)

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/chATLAS_Chains.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chATLAS_Chains
-Version: 0.3.1
+Version: 0.3.2
 Summary: A modular Python package for implementing Retrieval Augmented Generation chains for the chATLAS project.
 Author-email: Joe Egan <joseph.caimin.egan@cern.ch>
 License: Apache-2.0
@@ -66,9 +66,16 @@ ssh -L 3000:cs-513-ml003:3000 $LXPLUS_USERNAME@lxplus.cern.ch
 export CHATLAS_GROQ_BASE_URL="http://localhost:3000"
 ```
 
-3. Using LLMs via CERN's LiteLLM API, here is the [repo](https://gitlab.cern.ch/itgpt/litellm-okd/-/tree/main) and some [setup instructions](https://codimd.web.cern.ch/tQKiMa13Q4O-EJXWTO3N7w?view#Using-Your-Dedicated-API-Key-to-Access-LLMs) for reference.
+3. Using chat models through [CERN AI Gateway](https://ml.docs.cern.ch/aigw/gettingstarted/).
+The key variable retains its historical name so existing CI and OpenShift
+configuration does not need to be renamed.
 ```bash
-export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+export CHATLAS_CHAINS_LITELLM_KEY="your CERN AI Gateway key"
+```
+
+4. Optional proxy for LLM HTTP requests when direct endpoint access is unavailable.
+```bash
+export CHATLAS_PROXY="http://127.0.0.1:7890"
 ```
 
 ## Supported Chains
@@ -81,7 +88,7 @@ More details [here](chATLAS_Chains/chains/README.md)
 ## Prompt Routing
 
 `chATLAS_Chains.router.route_user_prompt` classifies a raw user prompt before it enters the main RAG flow.
-The router defaults to CERN LiteLLM and returns a validated `RouterDecision` with:
+The router defaults to CERN AI Gateway and returns a validated `RouterDecision` with:
 
 - `route`: one of `hep_atlas`, `person_lookup`, `dangerous`, `out_of_scope`,
   or `unknown`
@@ -101,7 +108,7 @@ decision = route_user_prompt(
     "Who is Jane Doe?",
     chat_model_kwargs={
         "service_provider": "litellm",
-        "proxy": "socks5h://localhost:1080",  # optional when outside CERN
+        "proxy": "socks5h://localhost:1080",  # optional when direct access is unavailable
     },
 )
 
@@ -123,17 +130,20 @@ continue through the normal selected workflow.
 
 Router context uses a hybrid policy: the current user prompt is authoritative,
 and recent conversation context is only a bounded disambiguation aid for
-follow-ups such as "What about Run 3?". The router keeps recent user prompts,
-includes only short assistant messages, and drops long assistant answers rather
-than summarizing them.
+follow-ups such as "What about Run 3?". It keeps up to five previous
+user/assistant turns, caps prior user messages at 600 characters and assistant
+messages at 400 characters, drops assistant answers over 1,000 raw characters,
+and caps retained history at 4,000 characters.
 
-For live LiteLLM calls, set:
+For live AI Gateway calls, set the legacy-named credential:
 
 ```sh
-export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+export CHATLAS_CHAINS_LITELLM_KEY="your CERN AI Gateway key"
 ```
 
-If LiteLLM is unavailable or returns invalid JSON, the router falls back to deterministic rules by default.
+Malformed model output is retried once with a strict JSON instruction. If the
+gateway is unavailable or the retry is still invalid, the router raises an
+error; the frontend logs it and fails open into the selected UI mode.
 
 ### Model Configuration in Chains
 

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chATLAS_Chains"
-version = "0.3.1"
+version = "0.3.2"
 description = "A modular Python package for implementing Retrieval Augmented Generation chains for the chATLAS project."
 readme = "README.md"
 requires-python = ">=3.11"

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/tests/test_chains.py

@@ -13,7 +13,7 @@ from pydantic import ValidationError
 
 from chATLAS_Chains.chains.advanced import advanced_rag
 from chATLAS_Chains.chains.basic import basic_retrieval_chain
-from chATLAS_Chains.llm.model_selection import GROQ_PRODUCTION_MODELS
+from chATLAS_Chains.llm.model_selection import DEFAULT_GROQ_MODEL
 from chATLAS_Chains.prompt.starters import CHAT_PROMPT_TEMPLATE
 
 GROQ_MODEL_KWARGS = {"service_provider": "groq"}
@@ -44,7 +44,7 @@ def test_basic_retrieval_chain_returns_docs_and_answer(twiki_vectorstore):
     chain = basic_retrieval_chain(
         prompt=CHAT_PROMPT_TEMPLATE,
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
     output = chain.invoke("What is the Higgs boson?")
@@ -60,7 +60,7 @@ def test_basic_retrieval_chain_multiple_vectorstores(three_vectorstores):
     chain = basic_retrieval_chain(
         prompt=CHAT_PROMPT_TEMPLATE,
         vectorstore=three_vectorstores,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
     output = chain.invoke("What is the Higgs boson?")
@@ -90,7 +90,7 @@ def test_advanced_rag_chain(twiki_vectorstore):
     chain = advanced_rag(
         prompt=CHAT_PROMPT_TEMPLATE,
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
     output = chain.invoke(
@@ -109,7 +109,7 @@ def test_advanced_rag_chain(twiki_vectorstore):
     chain = advanced_rag(
         prompt=CHAT_PROMPT_TEMPLATE,
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
         enable_query_rewriting=True,
         query_rewriting_chat_model_kwargs=GROQ_MODEL_KWARGS,
@@ -141,7 +141,7 @@ def test_advanced_rag_chain_multiple_vectorstores(three_vectorstores):
     chain = advanced_rag(
         prompt=CHAT_PROMPT_TEMPLATE,
         vectorstore=three_vectorstores,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
     output = chain.invoke(

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/tests/test_conversational.py

@@ -7,7 +7,7 @@ from langchain_core.messages import HumanMessage
 from langgraph.checkpoint.memory import MemorySaver
 
 from chATLAS_Chains.chains.conversational_graph import conversational_retrieval_graph
-from chATLAS_Chains.llm.model_selection import GROQ_PRODUCTION_MODELS
+from chATLAS_Chains.llm.model_selection import DEFAULT_GROQ_MODEL
 
 GROQ_MODEL_KWARGS = {"service_provider": "groq"}
 
@@ -28,9 +28,10 @@ def test_pronoun_resolution(twiki_vectorstore, checkpointer, search_kwargs):
     """Test pronoun 'them' resolves to TWiki rules from previous turn."""
     graph = conversational_retrieval_graph(
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
+        contextualization_model=DEFAULT_GROQ_MODEL,
         contextualization_chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
 
@@ -58,9 +59,10 @@ def test_incomplete_reference(twiki_vectorstore, checkpointer, search_kwargs):
     """Test ordinal reference 'the third one' resolves to specific list item."""
     graph = conversational_retrieval_graph(
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
+        contextualization_model=DEFAULT_GROQ_MODEL,
         contextualization_chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
 
@@ -91,9 +93,10 @@ def test_clarification_refinement(twiki_vectorstore, checkpointer, search_kwargs
     """Test clarification 'Using WikiWords' refines the previous question."""
     graph = conversational_retrieval_graph(
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
+        contextualization_model=DEFAULT_GROQ_MODEL,
         contextualization_chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
 
@@ -118,9 +121,10 @@ def test_topic_shift(twiki_vectorstore, checkpointer, search_kwargs):
     """Test topic shift - new topic should not include previous context."""
     graph = conversational_retrieval_graph(
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
+        contextualization_model=DEFAULT_GROQ_MODEL,
         contextualization_chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
 
@@ -145,9 +149,10 @@ def test_generalization(twiki_vectorstore, checkpointer, search_kwargs):
     """Test generalization - broader question should not inherit specific context."""
     graph = conversational_retrieval_graph(
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
+        contextualization_model=DEFAULT_GROQ_MODEL,
         contextualization_chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
 
@@ -175,9 +180,10 @@ def test_spelling_and_grammar_correction(twiki_vectorstore, checkpointer, search
     """Test spelling and grammar errors are corrected while preserving abbreviations."""
     graph = conversational_retrieval_graph(
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
+        contextualization_model=DEFAULT_GROQ_MODEL,
         contextualization_chat_model_kwargs=GROQ_MODEL_KWARGS,
     )
 
@@ -205,9 +211,10 @@ def test_hard_turn_limit(twiki_vectorstore, checkpointer, search_kwargs):
     # Set hard limit to 2 turns
     graph = conversational_retrieval_graph(
         vectorstore=twiki_vectorstore,
-        model_name=GROQ_PRODUCTION_MODELS[0],
+        model_name=DEFAULT_GROQ_MODEL,
         checkpointer=checkpointer,
         chat_model_kwargs=GROQ_MODEL_KWARGS,
+        contextualization_model=DEFAULT_GROQ_MODEL,
         contextualization_chat_model_kwargs=GROQ_MODEL_KWARGS,
         max_turns=2,
     )

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/tests/test_llm_runnables.py

@@ -32,11 +32,11 @@ def test_litellm_model_uses_env_var_when_api_key_not_provided(monkeypatch):
     monkeypatch.setenv("CHATLAS_CHAINS_LITELLM_KEY", "  sk-env-key  ")
 
     llm = litellm_runnable(
-        model_name="hf-qwen25-32b",
+        model_name="hf-qwen3-32b-awq",
         base_url="https://example.com/v1",
     )
 
-    assert llm.model_name == "hf-qwen25-32b"
+    assert llm.model_name == "hf-qwen3-32b-awq"
     assert _secret_to_str(llm.openai_api_key) == "sk-env-key"
     assert llm.openai_api_base == "https://example.com/v1"
 
@@ -44,5 +44,5 @@ def test_litellm_model_uses_env_var_when_api_key_not_provided(monkeypatch):
 def test_litellm_model_raises_if_no_key_in_arg_or_env(monkeypatch):
     monkeypatch.delenv("CHATLAS_CHAINS_LITELLM_KEY", raising=False)
 
-    with pytest.raises(ValueError, match="Missing API key for LiteLLM"):
+    with pytest.raises(ValueError, match="Missing CERN AI Gateway API key"):
         litellm_runnable(model_name="gpt-4")

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/tests/test_model_selection.py

@@ -100,7 +100,7 @@ def test_litellm_called_with_base_url(monkeypatch):
 
     def fake_litellm_runnable(
         model_name_arg,
-        base_url="https://llmgw-litellm.web.cern.ch/v1",
+        base_url="https://aigw.cern.ch/v1",
         api_key=None,
         temperature=None,
         max_tokens=None,
@@ -127,3 +127,21 @@ def test_litellm_called_with_base_url(monkeypatch):
     assert llm is not None
     assert called["base_url"] == "https://litellm.test"
     assert called["temperature"] == 0.3
+
+
+def test_litellm_defaults_to_cern_ai_gateway(monkeypatch):
+    called = {}
+
+    def fake_litellm_runnable(model_name_arg, base_url, **_kwargs):
+        called["model_name"] = model_name_arg
+        called["base_url"] = base_url
+        return object()
+
+    monkeypatch.setattr(ms, "litellm_runnable", fake_litellm_runnable)
+
+    ms.get_chat_model("gpt-oss-20b", service_provider="litellm", api_key="k")
+
+    assert called == {
+        "model_name": "gpt-oss-20b",
+        "base_url": "https://aigw.cern.ch/v1",
+    }

{chatlas_chains-0.3.1 → chatlas_chains-0.3.2}/tests/test_router.py

@@ -7,13 +7,17 @@ from chATLAS_Chains.router import RouterDecision, parse_router_response, route_u
 
 
 class FakeRouterModel:
-    def __init__(self, content: str):
-        self.content = content
+    def __init__(self, content: str | Exception | list[str | Exception]):
+        self.contents = content if isinstance(content, list) else [content]
         self.prompts: list[str] = []
 
     def invoke(self, prompt: str):
         self.prompts.append(prompt)
-        return SimpleNamespace(content=self.content)
+        index = min(len(self.prompts) - 1, len(self.contents) - 1)
+        content = self.contents[index]
+        if isinstance(content, Exception):
+            raise content
+        return SimpleNamespace(content=content)
 
 
 def test_route_user_prompt_uses_litellm_defaults(monkeypatch):
@@ -41,7 +45,7 @@ def test_route_user_prompt_uses_litellm_defaults(monkeypatch):
     )
     assert captured == {
         "model_name": "gpt-oss-20b",
-        "kwargs": {"service_provider": "litellm", "temperature": 0.0, "max_tokens": 512},
+        "kwargs": {"service_provider": "litellm", "temperature": 0.0, "max_tokens": 1024},
     }
     assert "Return JSON only" in fake_model.prompts[0]
     assert "selected UI mode" not in fake_model.prompts[0]
@@ -62,7 +66,7 @@ def test_route_user_prompt_allows_litellm_overrides(monkeypatch):
     monkeypatch.setattr(router, "get_chat_model", fake_get_chat_model)
     decision = route_user_prompt(
         "Who is Jane Doe?",
-        model_name="hf-qwen25-32b",
+        model_name="hf-qwen3-32b-awq",
         chat_model_kwargs={
             "api_key": "sk-test",
             "base_url": "https://litellm.example/v1",
@@ -76,7 +80,7 @@ def test_route_user_prompt_allows_litellm_overrides(monkeypatch):
     assert captured["kwargs"] == {
         "service_provider": "litellm",
         "temperature": 0.2,
-        "max_tokens": 512,
+        "max_tokens": 1024,
         "api_key": "sk-test",
         "base_url": "https://litellm.example/v1",
         "proxy": "socks5h://localhost:1080",
@@ -127,7 +131,7 @@ def test_route_user_prompt_uses_hybrid_context_policy(monkeypatch):
     assert "How do I apply a GRL?" in prompt
     assert "Use the GoodRunsListSelectionTool" not in prompt
     assert "Use the JetEtmiss recommendations." in prompt
-    assert len(prompt) < 5000
+    assert len(prompt) < 10_000
 
 
 def test_router_prompt_makes_current_request_authoritative(monkeypatch):
@@ -167,7 +171,7 @@ def test_router_prompt_distinguishes_role_holder_from_role_function(monkeypatch)
     assert "Who is the current ATLAS Physics Coordinator?" in prompt
 
 
-def test_sanitize_context_caps_recent_user_prompts_and_drops_long_assistant():
+def test_sanitize_context_caps_recent_user_prompts_and_drops_oversized_assistant():
     context = router._sanitize_context(
         [
             {"role": "user", "content": "How do I apply a GRL in Athena?"},
@@ -179,11 +183,29 @@ def test_sanitize_context_caps_recent_user_prompts_and_drops_long_assistant():
 
     assert [turn["role"] for turn in context] == ["user", "user", "assistant"]
     assert context[0]["content"] == "How do I apply a GRL in Athena?"
-    assert len(context[1]["content"]) <= 300
+    assert len(context[1]["content"]) <= 600
     assert context[1]["content"].endswith("...")
     assert context[2]["content"] == "Short answer."
 
 
+def test_sanitize_context_keeps_five_previous_turns():
+    context = router._sanitize_context(
+        [{"role": "user" if index % 2 == 0 else "assistant", "content": f"message {index}"} for index in range(10)]
+    )
+
+    assert len(context) == 10
+    assert context[0]["content"] == "message 0"
+    assert context[-1]["content"] == "message 9"
+
+
+def test_sanitize_context_caps_total_characters():
+    context = router._sanitize_context(
+        [{"role": "user" if index % 2 == 0 else "assistant", "content": "x" * 600} for index in range(10)]
+    )
+
+    assert sum(len(turn["content"]) for turn in context) <= 4000
+
+
 def test_parse_router_response_maps_disabled_mc_request_to_hep_atlas():
     decision = parse_router_response(
         """```json
@@ -231,11 +253,54 @@ def test_router_prompt_marks_mc_request_disabled(monkeypatch):
     assert '"route":"mc_request"' not in prompt
 
 
-def test_invalid_json_raises(monkeypatch):
-    monkeypatch.setattr(router, "get_chat_model", lambda **_kwargs: FakeRouterModel("not json"))
+def test_invalid_json_is_retried_once_then_raises(monkeypatch):
+    fake_model = FakeRouterModel("not json")
+    monkeypatch.setattr(router, "get_chat_model", lambda **_kwargs: fake_model)
+
     with pytest.raises(ValueError):
         route_user_prompt("Who is Joe Egan?")
 
+    assert len(fake_model.prompts) == 2
+    assert "previous response was invalid" in fake_model.prompts[1]
+
+
+def test_invalid_json_retry_can_recover(monkeypatch):
+    fake_model = FakeRouterModel(
+        [
+            "not json",
+            '{"route":"person_lookup","confidence":0.9,"normalized_query":"Who is Joe Egan?",'
+            '"reason":"The user asks who a named person is.","search_kwargs":{},"metadata":{}}',
+        ]
+    )
+    monkeypatch.setattr(router, "get_chat_model", lambda **_kwargs: fake_model)
+
+    decision = route_user_prompt("Who is Joe Egan?")
+
+    assert decision.route == "person_lookup"
+    assert len(fake_model.prompts) == 2
+
+
+def test_valid_response_is_not_retried(monkeypatch):
+    fake_model = FakeRouterModel(
+        '{"route":"hep_atlas","confidence":0.9,"normalized_query":"What is a GRL?",'
+        '"reason":"ATLAS analysis question.","search_kwargs":{},"metadata":{}}'
+    )
+    monkeypatch.setattr(router, "get_chat_model", lambda **_kwargs: fake_model)
+
+    route_user_prompt("What is a GRL?")
+
+    assert len(fake_model.prompts) == 1
+
+
+def test_gateway_error_is_not_retried(monkeypatch):
+    fake_model = FakeRouterModel(RuntimeError("gateway unavailable"))
+    monkeypatch.setattr(router, "get_chat_model", lambda **_kwargs: fake_model)
+
+    with pytest.raises(RuntimeError, match="gateway unavailable"):
+        route_user_prompt("What is a GRL?")
+
+    assert len(fake_model.prompts) == 1
+
 
 def test_empty_prompt_routes_unknown_without_calling_llm(monkeypatch):
     monkeypatch.setattr(

chatlas_chains-0.3.2/tests/test_router_litellm.py

@@ -0,0 +1,101 @@
+"""Live CERN AI Gateway smoke tests for the chATLAS intent router.
+
+The file, opt-in flag, and credential retain their LiteLLM names for CI and
+deployment compatibility.
+"""
+
+import os
+
+import pytest
+
+from chATLAS_Chains.router import route_user_prompt
+
+pytestmark = pytest.mark.skipif(
+    os.getenv("CHATLAS_RUN_LITELLM_SMOKE") != "1",
+    reason="Set CHATLAS_RUN_LITELLM_SMOKE=1 to run live AI Gateway smoke tests.",
+)
+
+
+@pytest.mark.parametrize(
+    ("prompt", "expected_intent"),
+    [
+        ("How do I apply the GoodRunsList in Athena?", "hep_atlas"),
+        ("Help me draft an MC request for a ttbar sample with dilepton decay.", "hep_atlas"),
+        ("Who is the current ATLAS spokesperson?", "person_lookup"),
+        ("5. Who is the current ATLAS spokesperson?", "person_lookup"),
+        ("Who is the current ATLAS Physics Coordinator?", "person_lookup"),
+        ("What does the ATLAS Physics Coordinator do?", "hep_atlas"),
+        ("How do I bake sourdough bread?", "out_of_scope"),
+        ("8. What are good hotels in Rome near the Colosseum?", "out_of_scope"),
+        ("Help me make a nuke.", "dangerous"),
+        ("How can nuclear weapons be safely dismantled?", "out_of_scope"),
+    ],
+)
+def test_live_litellm_router_contract(prompt, expected_intent):
+    """Verify AI Gateway authentication, model availability, parsing, and clear intents."""
+    assert os.getenv("CHATLAS_CHAINS_LITELLM_KEY"), "CHATLAS_CHAINS_LITELLM_KEY is required"
+    proxy = os.getenv("CHATLAS_CHAINS_LITELLM_PROXY")
+    chat_model_kwargs = {"proxy": proxy} if proxy else None
+
+    decision = route_user_prompt(
+        prompt,
+        model_name=os.getenv("CHATLAS_ROUTER_MODEL", "gpt-oss-20b"),
+        chat_model_kwargs=chat_model_kwargs,
+    )
+
+    assert decision.route == expected_intent
+    assert decision.normalized_query
+    assert decision.reason
+
+
+@pytest.mark.parametrize(
+    ("prompt", "conversation_context", "expected_intent"),
+    [
+        (
+            "Who leads it?",
+            [
+                {"role": "user", "content": "I am asking about the leadership of the ATLAS Muon group."},
+                {"role": "assistant", "content": "Understood; the topic is the ATLAS Muon group."},
+                *[
+                    turn
+                    for index in range(4)
+                    for turn in (
+                        {"role": "user", "content": f"Acknowledged item {index + 1}."},
+                        {"role": "assistant", "content": f"Noted item {index + 1}."},
+                    )
+                ],
+            ],
+            "person_lookup",
+        ),
+        (
+            "What about Run 3?",
+            [
+                {"role": "user", "content": "How do I apply the GoodRunsList in Athena?"},
+                {"role": "assistant", "content": "Use the GoodRunsList selection tools."},
+            ],
+            "hep_atlas",
+        ),
+        (
+            "What are good hotels in Rome?",
+            [
+                {"role": "user", "content": "Tell me about ATLAS tracking."},
+                {"role": "assistant", "content": "ATLAS tracking reconstructs charged-particle trajectories."},
+            ],
+            "out_of_scope",
+        ),
+    ],
+)
+def test_live_litellm_router_context(prompt, conversation_context, expected_intent):
+    """Verify referential context is retained without overriding standalone requests."""
+    assert os.getenv("CHATLAS_CHAINS_LITELLM_KEY"), "CHATLAS_CHAINS_LITELLM_KEY is required"
+    proxy = os.getenv("CHATLAS_CHAINS_LITELLM_PROXY")
+    chat_model_kwargs = {"proxy": proxy} if proxy else None
+
+    decision = route_user_prompt(
+        prompt,
+        conversation_context=conversation_context,
+        model_name=os.getenv("CHATLAS_ROUTER_MODEL", "gpt-oss-20b"),
+        chat_model_kwargs=chat_model_kwargs,
+    )
+
+    assert decision.route == expected_intent

chatlas_chains-0.3.1/tests/test_router_litellm.py

@@ -1,42 +0,0 @@
-"""Live CERN LiteLLM smoke tests for the chATLAS intent router."""
-
-import os
-
-import pytest
-
-from chATLAS_Chains.router import route_user_prompt
-
-pytestmark = pytest.mark.skipif(
-    os.getenv("CHATLAS_RUN_LITELLM_SMOKE") != "1",
-    reason="Set CHATLAS_RUN_LITELLM_SMOKE=1 to run live LiteLLM smoke tests.",
-)
-
-
-@pytest.mark.parametrize(
-    ("prompt", "expected_intent"),
-    [
-        ("How do I apply the GoodRunsList in Athena?", "hep_atlas"),
-        ("Help me draft an MC request for a ttbar sample with dilepton decay.", "hep_atlas"),
-        ("Who is the current ATLAS spokesperson?", "person_lookup"),
-        ("5. Who is the current ATLAS spokesperson?", "person_lookup"),
-        ("Who is the current ATLAS Physics Coordinator?", "person_lookup"),
-        ("What does the ATLAS Physics Coordinator do?", "hep_atlas"),
-        ("How do I bake sourdough bread?", "out_of_scope"),
-        ("8. What are good hotels in Rome near the Colosseum?", "out_of_scope"),
-    ],
-)
-def test_live_litellm_router_contract(prompt, expected_intent):
-    """Verify authentication, model availability, parsing, and clear intents."""
-    assert os.getenv("CHATLAS_CHAINS_LITELLM_KEY"), "CHATLAS_CHAINS_LITELLM_KEY is required"
-    proxy = os.getenv("CHATLAS_CHAINS_LITELLM_PROXY")
-    chat_model_kwargs = {"proxy": proxy} if proxy else None
-
-    decision = route_user_prompt(
-        prompt,
-        model_name=os.getenv("CHATLAS_ROUTER_MODEL", "gpt-oss-20b"),
-        chat_model_kwargs=chat_model_kwargs,
-    )
-
-    assert decision.route == expected_intent
-    assert decision.normalized_query
-    assert decision.reason