reliable tools (gpt-oss-120b) + resilient orchestrator

app/config.py

@@ -18,7 +18,9 @@ class Settings(BaseSettings):
     # LLM: Groq (primary)
     groq_api_key: str = ""
     groq_base_url: str = "https://api.groq.com/openai/v1"
-    model_large: str = "llama-3.3-70b-versatile"
+    # gpt-oss-120b: stable on Groq + reliable tool calling (Llama 3.3 70B
+    # intermittently returns tool_use_failed on Groq).
+    model_large: str = "openai/gpt-oss-120b"
     model_small: str = "llama-3.1-8b-instant"
 
     # LLM: Cloudflare Workers AI (failover)

app/orchestrator.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from sqlalchemy import select
 
-from app.llm.base import ToolCall
+from app.llm.base import ProviderError, ToolCall
 from app.models import ChatMessage
 from app.prompts import build_system_prompt
 from app.schemas import ChatResponse
@@ -61,8 +61,24 @@ async def run_turn(
     used_tools: list[str] = []
     reply = FALLBACK_REPLY
 
+    async def _chat(tools):
+        """Resilient call: if tool-calling fails (e.g. Groq tool_use_failed) or a
+        provider errors, degrade to a no-tools answer so we never 500."""
+        try:
+            return await router.chat(messages=messages, tools=tools, tier="large")
+        except ProviderError:
+            if not tools:
+                return None
+            try:
+                return await router.chat(messages=messages, tools=[], tier="large")
+            except ProviderError:
+                return None
+
     for _ in range(MAX_TOOL_ITERS):
-        result = await router.chat(messages=messages, tools=registry.specs(), tier="large")
+        result = await _chat(registry.specs())
+        if result is None:
+            reply = FALLBACK_REPLY
+            break
         if result.tool_calls:
             messages.append(
                 {
@@ -86,8 +102,8 @@ async def run_turn(
         break
     else:
         # Tool budget exhausted: force a final answer with no tools.
-        final = await router.chat(messages=messages, tools=[], tier="large")
-        reply = final.content or FALLBACK_REPLY
+        final = await _chat([])
+        reply = (final.content if final else None) or FALLBACK_REPLY
 
     ctx.db.add(ChatMessage(session_id=ctx.session.id, role="assistant", content=reply))
     await ctx.db.flush()

tests/test_orchestrator.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import pytest
 
-from app.llm.base import ChatResult, ToolCall
+from app.llm.base import ChatResult, ProviderError, ToolCall
 from app.models import ChatMessage, ChatSession
 from app.orchestrator import run_turn
 from app.tools.registry import ToolContext
@@ -87,6 +87,41 @@ async def test_order_turn_unverified_asks_for_credentials(db_session):
     assert resp.used_tools == ["lookup_order"]
 
 
+class _ToolFailRouter:
+    """Fails (ProviderError) whenever tools are sent; answers when no tools."""
+
+    def __init__(self, reply="Respuesta sin herramientas."):
+        self.reply = reply
+        self.calls_with_tools = 0
+
+    async def chat(self, messages, tools, tier="large", temperature=None):
+        if tools:
+            self.calls_with_tools += 1
+            raise ProviderError("tool_use_failed")
+        return ChatResult(content=self.reply, tool_calls=[], finish_reason="stop")
+
+
+class _AlwaysFailRouter:
+    async def chat(self, messages, tools, tier="large", temperature=None):
+        raise ProviderError("down")
+
+
+async def test_degrades_to_no_tools_when_tool_calling_fails(db_session):
+    router = _ToolFailRouter()
+    ctx = ToolContext(db=db_session, session=await _session(db_session))
+    resp = await run_turn(router, ctx, "¿qué vendéis?")
+    assert resp.reply == "Respuesta sin herramientas."
+    assert router.calls_with_tools >= 1  # it tried tools first, then degraded
+
+
+async def test_total_provider_failure_returns_fallback_not_500(db_session):
+    from app.orchestrator import FALLBACK_REPLY
+
+    ctx = ToolContext(db=db_session, session=await _session(db_session))
+    resp = await run_turn(_AlwaysFailRouter(), ctx, "hola")
+    assert resp.reply == FALLBACK_REPLY
+
+
 async def test_tool_budget_exhausted_forces_final_answer(db_session):
     # Always returns tool_calls; orchestrator must stop and force a final answer.
     loop_result = ChatResult(