added changes

app.py

@@ -10,6 +10,7 @@ Prompts/intros may contain {VARIABLE} tokens — those are surfaced as fill-in f
 in the sidebar and substituted into the effective prompt when a session starts.
 """
 
+import json
 import queue
 import re
 import threading
@@ -102,6 +103,8 @@ def format_metrics(m: dict) -> str:
     if m.get("error"):
         return f"⚠️ {m['error']}"
     parts = []
+    if m.get("tool_called"):
+        parts.append(f"📞 tool: `{m['tool_called']}`")
     if m.get("prompt_tokens") is not None:
         parts.append(f"In: {m['prompt_tokens']}")
     if m.get("completion_tokens") is not None:
@@ -113,6 +116,28 @@ def format_metrics(m: dict) -> str:
     return "  ·  ".join(parts)
 
 
+def format_debug(acc: dict, mstate: dict, rstate: dict) -> str:
+    """Render the exact request + model response(s) for the current turn as JSON.
+
+    Shows, per backend: the exact request body sent to the model, the
+    live-streamed text, and — once the turn completes — the raw assistant
+    message the model produced (`content` + any `tool_calls` with verbatim
+    arguments), so both sides of the exchange are visible exactly as sent.
+    """
+    payload = {}
+    for k in KEYS:
+        m = mstate.get(k) or {}
+        payload[ANON[k]] = {
+            "label": BY_KEY[k]["label"],
+            "request": rstate.get(k),
+            "streamed_text": acc.get(k, ""),
+            "raw_response": m.get("raw_response"),
+            "tool_called": m.get("tool_called"),
+            "error": m.get("error"),
+        }
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
 def backend_messages(system_prompt: str, conversation: list) -> list:
     """Build the request messages for one backend: system + its own thread."""
     msgs = []
@@ -186,7 +211,7 @@ def respond_all(user_msg, state, temperature, max_tokens):
     if not user_msg or not user_msg.strip():
         chatbots = [render_history(histories[k]) for k in KEYS]
         metrics = [gr.update() for _ in KEYS]
-        yield (state, *chatbots, *metrics, "", None)
+        yield (state, *chatbots, *metrics, "", None, gr.update())
         return
 
     user_msg = user_msg.strip()
@@ -199,6 +224,7 @@ def respond_all(user_msg, state, temperature, max_tokens):
 
     acc = {k: "" for k in KEYS}
     mstate = {k: {} for k in KEYS}
+    rstate = {k: None for k in KEYS}  # exact request payload sent per backend
     q: queue.Queue = queue.Queue()
 
     def worker(key):
@@ -207,6 +233,8 @@ def respond_all(user_msg, state, temperature, max_tokens):
             for item in stream_backend(backend, req_msgs[key], temperature, max_tokens):
                 if isinstance(item, dict) and item.get("__metrics__"):
                     q.put((key, "metrics", item))
+                elif isinstance(item, dict) and item.get("__request__"):
+                    q.put((key, "request", item.get("payload")))
                 else:
                     q.put((key, "delta", item))
         finally:
@@ -222,7 +250,8 @@ def respond_all(user_msg, state, temperature, max_tokens):
             histories[k][-1]["content"] = acc[k]
             chatbots.append(render_history(histories[k]))
         metrics = [format_metrics(mstate[k]) for k in KEYS]
-        return (state, *chatbots, *metrics, "", None)
+        debug = format_debug(acc, mstate, rstate)
+        return (state, *chatbots, *metrics, "", None, debug)
 
     remaining = set(KEYS)
     yield snapshot()
@@ -236,6 +265,8 @@ def respond_all(user_msg, state, temperature, max_tokens):
             acc[key] += payload
         elif kind == "metrics":
             mstate[key] = payload
+        elif kind == "request":
+            rstate[key] = payload
         elif kind == "done":
             remaining.discard(key)
         yield snapshot()
@@ -266,6 +297,7 @@ def respond_all(user_msg, state, temperature, max_tokens):
                         "total_tokens",
                         "cached_tokens",
                         "latency_s",
+                        "tool_called",
                     )
                 },
                 "error": mstate[k].get("error"),
@@ -443,6 +475,17 @@ with gr.Blocks(
             with gr.Row():
                 send_btn = gr.Button("Send", variant="primary")
 
+            # Debug: the exact request body sent and the raw response the model
+            # produced this turn (text + any tool calls with verbatim
+            # arguments), per backend. Collapsed by default.
+            with gr.Accordion("🐞 Debug — exact request & response", open=False):
+                debug_box = gr.Code(
+                    label="Exact request & raw response (per backend)",
+                    language="json",
+                    value="",
+                    interactive=False,
+                )
+
             # Pick the best response for this turn and save it to the dataset.
             with gr.Group(visible=SHOW_COMPARE):
                 gr.Markdown("### 💾 Save preferred response")
@@ -458,7 +501,7 @@ with gr.Blocks(
 
     # Wiring -----------------------------------------------------------------
     respond_inputs = [msg, state, temperature, max_tokens]
-    respond_outputs = [state, *chatbots, *metrics, msg, preferred]
+    respond_outputs = [state, *chatbots, *metrics, msg, preferred, debug_box]
 
     preset_outputs = [system_prompt, intro, var_names, *var_boxes]
 

config.py

@@ -119,6 +119,42 @@ DEFAULT_MAX_TOKENS = 1000
 DEFAULT_STREAM = True
 
 
+# ---------------------------------------------------------------------------
+# Tools exposed to the conversational backend (Qwen, Backend A). The preset
+# system prompts instruct the model to emit `end_call` when the conversation
+# reaches its natural conclusion, placing the goodbye line in `final_message`.
+# The tool is sent in the request body (OpenAI-style `tools` array) so the
+# model can actually call it. Only the custom backend receives these tools.
+# ---------------------------------------------------------------------------
+END_CALL_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "end_call",
+        "description": (
+            "End the current call when the conversation has reached a natural "
+            "conclusion or user says bye or tells to cut the call or speak with "
+            "you later as they are busy."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "final_message": {
+                    "type": "string",
+                    "description": (
+                        "The final message to say to the user before ending the "
+                        "call. Keep it short and less than 15 words."
+                    ),
+                }
+            },
+            "required": ["final_message"],
+        },
+    },
+}
+
+# Tools sent to the custom (Qwen) backend on every request.
+TOOLS = [END_CALL_TOOL]
+
+
 # ---------------------------------------------------------------------------
 # Preset system-prompt / intro pairs people can pick to try the playground.
 # The first entry is the default loaded on startup. Each preset declares a fixed
@@ -403,7 +439,9 @@ def get_auth():
                     pairs.append((user, pwd))
     password = os.environ.get("APP_PASSWORD", "").strip()
     if password:
-        pairs.append((os.environ.get("APP_USERNAME", "user").strip() or "user", password))
+        pairs.append(
+            (os.environ.get("APP_USERNAME", "user").strip() or "user", password)
+        )
     if not pairs:
         # Dev fallback — override via env in any shared deployment.
         pairs.append(("user", "slm-demo"))

src/clients.py

@@ -73,6 +73,13 @@ def _empty_metrics(**overrides) -> dict:
         "total_tokens": None,
         "cached_tokens": None,
         "latency_s": None,
+        # Name of the tool the model invoked this turn (e.g. "end_call"), or
+        # None when the reply was ordinary text. Lets the UI/logs flag tool use.
+        "tool_called": None,
+        # The exact assistant message the model produced this turn, as an
+        # OpenAI-style {"content", "tool_calls"} dict (raw tool arguments kept
+        # verbatim). Powers the debug panel; None on error.
+        "raw_response": None,
         "error": None,
     }
     base.update(overrides)
@@ -125,8 +132,14 @@ def chat_completion(
     endpoint_id: str,
     temperature: float,
     max_tokens: int,
+    tools: list | None = None,
 ) -> tuple:
-    """Return (content, usage) from a non-streaming chat completion."""
+    """Return (content, usage) from a non-streaming chat completion.
+
+    When `tools` is provided it is sent in the body so the model may call a
+    tool. If the model responds with an `end_call` tool call instead of plain
+    text, its `final_message` argument is returned as the content.
+    """
     payload = {
         "messages": messages,
         "model": model,
@@ -135,6 +148,8 @@ def chat_completion(
         "max_tokens": int(max_tokens),
         "stream": False,
     }
+    if tools:
+        payload["tools"] = tools
     headers = {"Content-Type": "application/json", "x-api-key": get_api_key()}
     resp = requests.post(config.BASE_URL, headers=headers, json=payload, timeout=120)
     if resp.status_code != 200:
@@ -143,20 +158,47 @@ def chat_completion(
     choices = data.get("choices") or []
     content = ""
     if choices:
-        content = (choices[0].get("message") or {}).get("content") or ""
+        message = choices[0].get("message") or {}
+        content = message.get("content") or ""
+        if not content:
+            content = _extract_end_call_message(message.get("tool_calls"))
     usage = data.get("usage") or {}
     return content, usage
 
 
+def _extract_end_call_message(tool_calls) -> str:
+    """Return the `final_message` from an `end_call` tool call, or "".
+
+    Accepts the non-streaming `tool_calls` list from a chat message. Other tool
+    calls (or malformed arguments) yield an empty string.
+    """
+    for call in tool_calls or []:
+        fn = call.get("function") or {}
+        if fn.get("name") != "end_call":
+            continue
+        try:
+            args = json.loads(fn.get("arguments") or "{}")
+        except json.JSONDecodeError:
+            return ""
+        return (args.get("final_message") or "").strip()
+    return ""
+
+
 def stream_chat(
     messages: list,
     model: str,
     endpoint_id: str,
     temperature: float,
     max_tokens: int,
+    tools: list | None = None,
 ):
     """Yield response text deltas, then a final metrics sentinel.
 
+    When `tools` is provided it is sent in the body so the model may call a
+    tool. A streamed `end_call` tool call has no text content, so its
+    `final_message` argument (assembled from the streamed argument fragments)
+    is yielded as the reply once the stream ends.
+
     Token counts come from a lightweight max_tokens=1 probe fired AFTER the
     stream (so it never competes with streaming for GPU); completion tokens are
     the streamed-piece count.
@@ -169,11 +211,20 @@ def stream_chat(
         "max_tokens": int(max_tokens),
         "stream": True,
     }
+    if tools:
+        payload["tools"] = tools
     headers = {"Content-Type": "application/json", "x-api-key": get_api_key()}
 
+    # Surface the exact request body (no secret header) for the debug panel.
+    yield {"__request__": True, "payload": payload}
+
     t_start = time.monotonic()
     piece_count = 0
     ttfb = 0
+    tool_args = ""  # concatenated `end_call` argument fragments
+    tool_name = None  # name of the tool the model invoked, if any
+    content_buf = ""  # raw text the model streamed (before any tool handling)
+    saw_end_call = False
     with requests.post(
         config.BASE_URL, headers=headers, json=payload, stream=True, timeout=120
     ) as resp:
@@ -201,12 +252,35 @@ def stream_chat(
             piece = delta.get("content")
             if piece:
                 piece_count += 1
+                content_buf += piece
                 yield piece
+            # An `end_call` tool call streams as `tool_calls` deltas whose
+            # `arguments` strings must be concatenated, then parsed at the end.
+            for call in delta.get("tool_calls") or []:
+                fn = call.get("function") or {}
+                if fn.get("name"):
+                    tool_name = fn["name"]
+                    if tool_name == "end_call":
+                        saw_end_call = True
+                frag = fn.get("arguments")
+                if frag:
+                    saw_end_call = True
+                    tool_args += frag
+
+    # If the model ended the call via the tool, surface the goodbye line.
+    if saw_end_call:
+        try:
+            final_message = (json.loads(tool_args or "{}").get("final_message") or "").strip()
+        except json.JSONDecodeError:
+            final_message = ""
+        if final_message:
+            piece_count += 1
+            yield final_message
 
     # Probe for token counts now that streaming is done.
     try:
         _, probe = chat_completion(
-            messages, model, endpoint_id, temperature, max_tokens=1
+            messages, model, endpoint_id, temperature, max_tokens=1, tools=tools
         )
     except Exception:
         probe = {}
@@ -215,18 +289,32 @@ def stream_chat(
     cached_tokens = details.get("cached_tokens")
     total = (prompt_tokens + piece_count) if prompt_tokens is not None else None
 
+    raw_response = {"content": content_buf or None}
+    if tool_name:
+        raw_response["tool_calls"] = [
+            {"function": {"name": tool_name, "arguments": tool_args}}
+        ]
+
     yield _empty_metrics(
         prompt_tokens=prompt_tokens,
         completion_tokens=piece_count,
         total_tokens=total,
         cached_tokens=cached_tokens,
         latency_s=ttfb,
+        tool_called=tool_name,
+        raw_response=raw_response,
     )
 
 
 def _stream_custom(backend, messages, temperature, max_tokens):
+    tools = backend.get("tools", config.TOOLS)
     yield from stream_chat(
-        messages, backend["model"], backend["endpoint_id"], temperature, max_tokens
+        messages,
+        backend["model"],
+        backend["endpoint_id"],
+        temperature,
+        max_tokens,
+        tools=tools,
     )
 
 
@@ -255,14 +343,17 @@ def _stream_azure(backend, messages, temperature, max_tokens):
     t_start = time.monotonic()
     usage = None
 
-    stream = client.chat.completions.create(
-        model=backend["deployment"],
-        messages=messages,
-        temperature=float(temperature),
-        max_completion_tokens=int(max_tokens),
-        stream=True,
-        stream_options={"include_usage": True},
-    )
+    content_buf = ""
+    request_payload = {
+        "model": backend["deployment"],
+        "messages": messages,
+        "temperature": float(temperature),
+        "max_completion_tokens": int(max_tokens),
+        "stream": True,
+        "stream_options": {"include_usage": True},
+    }
+    yield {"__request__": True, "payload": request_payload}
+    stream = client.chat.completions.create(**request_payload)
     for chunk in stream:
         if getattr(chunk, "usage", None):
             usage = chunk.usage
@@ -272,6 +363,7 @@ def _stream_azure(backend, messages, temperature, max_tokens):
         delta = choices[0].delta
         piece = getattr(delta, "content", None) if delta else None
         if piece:
+            content_buf += piece
             yield piece
 
     prompt_tokens = completion_tokens = total_tokens = cached_tokens = None
@@ -289,6 +381,7 @@ def _stream_azure(backend, messages, temperature, max_tokens):
         total_tokens=total_tokens,
         cached_tokens=cached_tokens,
         latency_s=round(time.monotonic() - t_start, 3),
+        raw_response={"content": content_buf or None},
     )