Update ui_components.py

ui_components.py

@@ -5,6 +5,7 @@ import gradio as gr
 from gradio import ChatMessage
 from typing import Tuple, List, Dict, Any
 import os
+import json
 import logging
 import traceback
 from openai import OpenAI
@@ -133,6 +134,146 @@ class UIComponents:
             
             # Status display
             self.api_status = gr.Markdown("⚪ Select provider and model to begin", container=True)
+
+            # Advanced generation parameters (OpenAI-compatible)
+            with gr.Row():
+                self.temperature_slider = gr.Slider(minimum=0.0, maximum=2.0, value=0.3, step=0.01, label="Temperature")
+                self.top_p_slider = gr.Slider(minimum=0.0, maximum=1.0, value=1.0, step=0.01, label="Top-p")
+                self.top_logprobs = gr.Slider(minimum=0, maximum=5, value=0, step=1, label="Top logprobs")
+            with gr.Row():
+                self.max_tokens_box = gr.Number(value=8192, precision=0, label="Max tokens")
+                self.seed_box = gr.Number(value=None, precision=0, label="Seed")
+            with gr.Row():
+                self.frequency_penalty = gr.Slider(minimum=-2.0, maximum=2.0, value=0.0, step=0.01, label="Frequency penalty")
+                self.presence_penalty = gr.Slider(minimum=-2.0, maximum=2.0, value=0.0, step=0.01, label="Presence penalty")
+            with gr.Row():
+                self.logprobs_chk = gr.Checkbox(value=False, label="Return logprobs")
+                self.stream_chk = gr.Checkbox(value=False, label="Stream responses (not yet supported in UI)")
+                self.stream_include_usage = gr.Checkbox(value=False, label="Stream include usage")
+            self.stop_sequences = gr.Textbox(label="Stop sequences (comma-separated)", placeholder="e.g. \n\n, User:")
+
+            # Reasoning effort (GPT-OSS)
+            self.reasoning_effort = gr.Radio(choices=["low", "medium", "high"], value=AppConfig.DEFAULT_REASONING_EFFORT, label="Reasoning effort (GPT‑OSS)")
+
+            # Response format controls
+            with gr.Row():
+                self.response_format = gr.Dropdown(choices=["text", "json_object", "json_schema"], value="text", label="Response format")
+            with gr.Group(visible=False) as self.json_schema_group:
+                self.json_schema_name = gr.Textbox(label="JSON schema name", placeholder="my_schema")
+                self.json_schema_description = gr.Textbox(label="JSON schema description", placeholder="Describe the expected JSON")
+                self.json_schema_editor = gr.Textbox(label="JSON schema (object)", lines=8, placeholder='{"type":"object","properties":{...},"required":[...]}' )
+                self.json_schema_strict = gr.Checkbox(value=False, label="Strict schema adherence")
+
+            # Tools & tool choice
+            with gr.Row():
+                self.tool_choice = gr.Dropdown(choices=["auto", "none", "required", "function"], value="auto", label="Tool choice")
+                self.tool_function_name = gr.Textbox(label="Function name (when tool_choice=function)")
+            self.tool_prompt = gr.Textbox(label="Tool prompt", placeholder="Optional prompt appended before the tools")
+            self.tools_json = gr.Textbox(label="Tools (JSON array)", lines=8, placeholder='[{"type":"function","function":{"name":"fn","description":"...","parameters":{}}}]')
+
+            def _on_response_format_change(fmt):
+                return gr.Group(visible=(fmt == "json_schema"))
+            self.response_format.change(_on_response_format_change, inputs=[self.response_format], outputs=[self.json_schema_group])
+
+            def update_generation_params(
+                temperature, top_p, top_logprobs, max_tokens, seed,
+                frequency_penalty, presence_penalty, logprobs, stream,
+                stop_sequences, reasoning_effort, response_format,
+                json_schema_name, json_schema_description, json_schema_editor, json_schema_strict,
+                tool_choice, tool_function_name, tool_prompt, tools_json, stream_include_usage
+            ):
+                params = {
+                    "temperature": float(temperature) if temperature is not None else None,
+                    "top_p": float(top_p) if top_p is not None else None,
+                    "top_logprobs": int(top_logprobs) if top_logprobs else None,
+                    "max_tokens": int(max_tokens) if max_tokens else None,
+                    "seed": int(seed) if seed not in (None, "") else None,
+                    "frequency_penalty": float(frequency_penalty) if frequency_penalty is not None else None,
+                    "presence_penalty": float(presence_penalty) if presence_penalty is not None else None,
+                    "logprobs": bool(logprobs),
+                    # Prevent enabling streaming until UI supports it end-to-end
+                    "stream": False,
+                    # stop: list[str]
+                    "stop": [s.strip() for s in stop_sequences.split(",") if s.strip()] if stop_sequences else None,
+                    # GPT-OSS specific control stored separately; mcp_client merges it
+                    "reasoning_effort": reasoning_effort,
+                }
+                # stream options
+                if stream_include_usage:
+                    params["stream_options"] = {"include_usage": True}
+
+                # response_format
+                if response_format == "json_object":
+                    params["response_format"] = {"type": "json_object"}
+                elif response_format == "json_schema":
+                    try:
+                        schema_obj = json.loads(json_schema_editor) if json_schema_editor else {}
+                    except Exception as e:
+                        return gr.Markdown(f"❌ Invalid JSON schema: {e}", visible=True)
+                    json_fmt = {
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": json_schema_name or "schema",
+                            "schema": schema_obj,
+                        },
+                    }
+                    if json_schema_description:
+                        json_fmt["json_schema"]["description"] = json_schema_description
+                    if json_schema_strict:
+                        json_fmt["json_schema"]["strict"] = True
+                    params["response_format"] = json_fmt
+
+                # tools
+                tools = None
+                if tools_json and tools_json.strip():
+                    try:
+                        parsed = json.loads(tools_json)
+                        if isinstance(parsed, list):
+                            tools = parsed
+                        else:
+                            return gr.Markdown("❌ Tools must be a JSON array.", visible=True)
+                    except Exception as e:
+                        return gr.Markdown(f"❌ Invalid tools JSON: {e}", visible=True)
+                if tools is not None:
+                    params["tools"] = tools
+
+                # tool_choice
+                if tool_choice in ("auto", "none", "required"):
+                    params["tool_choice"] = tool_choice
+                elif tool_choice == "function" and tool_function_name:
+                    params["tool_choice"] = {"type": "function", "function": {"name": tool_function_name}}
+
+                # tool_prompt
+                if tool_prompt and tool_prompt.strip():
+                    params["tool_prompt"] = tool_prompt.strip()
+                self.mcp_client.set_generation_params(params)
+                return gr.Markdown("✅ Inference parameters updated.")
+
+            self.gen_param_status = gr.Markdown(visible=False)
+
+            # Wire updates on change
+            for comp in [
+                self.temperature_slider, self.top_p_slider, self.top_logprobs,
+                self.max_tokens_box, self.seed_box, self.frequency_penalty,
+                self.presence_penalty, self.logprobs_chk, self.stream_chk,
+                self.stop_sequences, self.reasoning_effort, self.response_format,
+                self.json_schema_name, self.json_schema_description, self.json_schema_editor, self.json_schema_strict,
+                self.tool_choice, self.tool_function_name, self.tool_prompt, self.tools_json,
+                self.stream_include_usage
+            ]:
+                comp.change(
+                    update_generation_params,
+                    inputs=[
+                        self.temperature_slider, self.top_p_slider, self.top_logprobs,
+                        self.max_tokens_box, self.seed_box, self.frequency_penalty,
+                        self.presence_penalty, self.logprobs_chk, self.stream_chk,
+                        self.stop_sequences, self.reasoning_effort, self.response_format,
+                        self.json_schema_name, self.json_schema_description, self.json_schema_editor, self.json_schema_strict,
+                        self.tool_choice, self.tool_function_name, self.tool_prompt, self.tools_json,
+                        self.stream_include_usage
+                    ],
+                    outputs=[self.gen_param_status]
+                )
     
     def _create_server_management_section(self):
         """Create the server management section with checkboxes and guidance"""