init

.gitignore

@@ -0,0 +1 @@
+venv

README.md

@@ -1,16 +1,114 @@
----
-title: Odr Demo
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
-pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
-license: mit
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# ODR Demo
+
+A demonstration project containing async SSE (Server-Sent Events) interface request functionality.
+
+## Features
+
+- Async SSE streaming requests
+- Support for custom parameters (deep thinking mode, debug mode, etc.)
+- Returns async iterator for real-time data processing
+- Supports both raw data and parsed JSON data modes
+- Structured event parsing with `event` and `data` fields
+- Proper SSE event type detection and handling
+
+## Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Basic Usage (Raw SSE Events)
+
+```python
+import asyncio
+from api import request_sse_stream
+
+async def main():
+    query = "Hello, please introduce Python"
+    
+    async for event_data in request_sse_stream(query):
+        event_type = event_data.get('event', 'unknown')
+        data_content = event_data.get('data', '')
+        print(f"Event: {event_type}")
+        print(f"Data: {data_content}")
+
+asyncio.run(main())
+```
+
+### Using Parsed Data (JSON Parsed)
+
+```python
+import asyncio
+from api import request_sse_stream_parsed
+
+async def main():
+    query = "What is machine learning?"
+    
+    async for event_data in request_sse_stream_parsed(query):
+        event_type = event_data.get('event', 'unknown')
+        parsed_data = event_data.get('data', {})
+        print(f"Event: {event_type}")
+        print(f"Parsed Data: {parsed_data}")
+
+asyncio.run(main())
+```
+
+### Using Class Methods (More Control)
+
+```python
+import asyncio
+from api import SSEClient
+
+async def main():
+    client = SSEClient()
+    
+    async for event_data in client.stream_chat(
+        query="Explain deep learning",
+        deep_thinking_mode=True,  # Enable deep thinking
+        debug=True,              # Enable debug mode
+        chat_id="my_custom_id"   # Custom chat ID
+    ):
+        event_type = event_data.get('event', 'unknown')
+        data_content = event_data.get('data', '')
+        print(f"Event: {event_type}")
+        print(f"Data: {data_content}")
+
+asyncio.run(main())
+```
+
+## Run Examples
+
+```bash
+python example_usage.py
+```
+
+## API Parameters
+
+- `query`: Required, user query content
+- `deep_thinking_mode`: Optional, whether to enable deep thinking mode, default False
+- `search_before_planning`: Optional, whether to search before planning, default False
+- `debug`: Optional, whether to enable debug mode, default False
+- `chat_id`: Optional, chat ID, will be auto-generated if not provided
+
+## Data Structure
+
+All functions return an async iterator yielding dictionaries with the following structure:
+
+```python
+{
+    "event": "message",  # SSE event type (e.g., "message", "error", "data", etc.)
+    "data": "..."        # Event data content
+}
+```
+
+- `request_sse_stream()`: Returns raw data where `data` field contains the original string
+- `request_sse_stream_parsed()`: Returns parsed data where `data` field contains JSON objects (when possible)
+
+## File Description
+
+- `api.py`: Main SSE client implementation
+- `example_usage.py`: Usage examples
+- `requirements.txt`: Project dependencies
+- `app.py`: Gradio application (if exists)

api.py

@@ -0,0 +1,182 @@
+import asyncio
+import json
+import os
+import uuid
+from typing import AsyncIterator, Dict, Any
+import aiohttp
+
+
+class SSEClient:
+    """Async SSE client for streaming chat API requests"""
+    
+    def __init__(self):
+        self.url = os.getenv("API_ENDPOINT")
+        self.headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'HuggingFace-Gradio-Demo'
+        }
+
+    async def stream_chat(self, query: str, 
+                         deep_thinking_mode: bool = False,
+                         search_before_planning: bool = False,
+                         debug: bool = False,
+                         chat_id: str = None) -> AsyncIterator[Dict[str, Any]]:
+        """
+        Async request to SSE interface and return streaming data with event parsing
+        
+        Args:
+            query: User query content
+            deep_thinking_mode: Whether to enable deep thinking mode, default False
+            search_before_planning: Whether to search before planning, default False
+            debug: Whether to enable debug mode, default False
+            chat_id: Chat ID, will be auto-generated if not provided
+            
+        Yields:
+            Dict[str, Any]: SSE event data with 'event' and 'data' fields
+        """
+        if chat_id is None:
+            chat_id = self._generate_chat_id()
+            
+        # Build request data
+        data = {
+            "messages": [{
+                "id": chat_id,
+                "role": "user",
+                "type": "text",
+                "content": query
+            }],
+            "deep_thinking_mode": deep_thinking_mode,
+            "search_before_planning": search_before_planning,
+            "debug": debug,
+            "chatId": chat_id
+        }
+        
+        async with aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=None)  # No timeout limit
+        ) as session:
+            try:
+                async with session.post(
+                    self.url,
+                    headers=self.headers,
+                    json=data
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"Request failed with status code: {response.status}")
+                    
+                    # Read SSE stream and parse events
+                    current_event = None
+                    
+                    async for line in response.content:
+                        line = line.decode('utf-8').strip()
+                        if line:
+                            if line.startswith('event: '):
+                                # Parse event type
+                                current_event = line[7:]  # Remove "event: " prefix
+                            elif line.startswith('data: '):
+                                # Parse data content
+                                data_content = line[6:]  # Remove "data: " prefix
+                                if data_content and data_content != '[DONE]':
+                                    # Yield structured event data
+                                    yield {
+                                        'event': current_event or 'message',
+                                        'data': data_content
+                                    }
+                                    # Reset event for next message
+                                    current_event = None
+                            elif line == '':
+                                # Empty line indicates end of event, reset current_event
+                                current_event = None
+                            else:
+                                # Handle other formats or raw data
+                                yield {
+                                    'event': current_event or 'data',
+                                    'data': line
+                                }
+                                current_event = None
+                                
+            except asyncio.CancelledError:
+                # Handle cancellation
+                raise
+            except Exception as e:
+                raise Exception(f"SSE request error: {str(e)}")
+
+    def _generate_chat_id(self) -> str:
+        """Generate chat ID"""
+        return str(uuid.uuid4()).replace('-', '')[:21]
+
+    async def stream_chat_parsed(self, query: str, **kwargs) -> AsyncIterator[Dict[str, Any]]:
+        """
+        Async request to SSE interface and return parsed JSON data with event structure
+        
+        Args:
+            query: User query content
+            **kwargs: Other parameters passed to stream_chat
+            
+        Yields:
+            Dict[str, Any]: Event data with 'event' and 'data' fields, where 'data' contains parsed JSON
+        """
+        async for event_data in self.stream_chat(query, **kwargs):
+            try:
+                # Try to parse the data field as JSON
+                parsed_data = json.loads(event_data['data'])
+                yield {
+                    'event': event_data['event'],
+                    'data': parsed_data
+                }
+            except json.JSONDecodeError:
+                # If data is not valid JSON, keep original data
+                yield event_data
+            except (KeyError, TypeError):
+                # If event_data doesn't have expected structure, skip
+                continue
+
+
+# Convenience functions
+async def request_sse_stream(query: str, **kwargs) -> AsyncIterator[Dict[str, Any]]:
+    """
+    Convenience function: Async request to SSE interface and return raw event data
+    
+    Args:
+        query: User query content
+        **kwargs: Other parameters
+        
+    Yields:
+        Dict[str, Any]: Raw event data with 'event' and 'data' fields (data as string)
+    """
+    client = SSEClient()
+    async for event_data in client.stream_chat(query, **kwargs):
+        yield event_data
+
+
+async def request_sse_stream_parsed(query: str, **kwargs) -> AsyncIterator[Dict[str, Any]]:
+    """
+    Convenience function: Async request to SSE interface and return structured event data
+    
+    Args:
+        query: User query content
+        **kwargs: Other parameters
+        
+    Yields:
+        Dict[str, Any]: Event data with 'event' and 'data' fields
+    """
+    client = SSEClient()
+    async for event_data in client.stream_chat_parsed(query, **kwargs):
+        yield event_data
+
+
+# Example usage
+async def main():
+    """Example usage method"""
+    query = "Hello"
+    
+    print("=== SSE Event Stream ===")
+    async for event_data in request_sse_stream_parsed(query):
+        event_type = event_data.get('event', 'unknown')
+        data_content = event_data.get('data', {})
+        print(f"Event: {event_type}")
+        print(f"Data: {data_content}")
+        print("-" * 40)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

app.py

@@ -1,70 +1,259 @@
+import json
+import logging
+import uuid
+from typing import  Optional
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+
+from api import request_sse_stream_parsed
+
+from utils import contains_chinese, replace_chinese_punctuation
+
+logger = logging.getLogger(__name__)
+
+
+from typing import Optional
+
+
+# ========================= Gradio Integration =========================
+
+def _init_render_state():
+    return {
+        "agent_order": [],
+        "agents": {},  # agent_id -> {"agent_name": str, "tool_call_order": [], "tools": {tool_call_id: {...}}}
+        "current_agent_id": None,
+        "errors": [],
+    }
+
+def _append_show_text(tool_entry: dict, delta: str):
+    existing = tool_entry.get("content", "")
+    tool_entry["content"] = existing + delta
+
+def _is_empty_payload(value) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, str):
+        stripped = value.strip()
+        return stripped == "" or stripped in ("{}", "[]")
+    if isinstance(value, (dict, list, tuple, set)):
+        return len(value) == 0
+    return False
+
+def _render_markdown(state: dict) -> str:
+    lines = []
+    emoji_cycle = ["🧠", "🔎", "🛠️", "📚", "🤖", "🧪", "📝", "🧭", "⚙️", "🧮"]
+    # Render errors first if any
+    if state.get("errors"):
+        lines.append("### ❌ Errors")
+        for idx, err in enumerate(state["errors"], start=1):
+            lines.append(f"- **Error {idx}**: {err}")
+        lines.append("\n---\n")
+    for idx, agent_id in enumerate(state.get("agent_order", [])):
+        agent = state["agents"].get(agent_id, {})
+        agent_name = agent.get("agent_name", "unknown")
+        emoji = emoji_cycle[idx % len(emoji_cycle)]
+        lines.append(f"### {emoji} Agent: {agent_name}")
+        for call_id in agent.get("tool_call_order", []):
+            call = agent["tools"].get(call_id, {})
+            tool_name = call.get("tool_name", "unknown_tool")
+            if tool_name in ("show_text", "message"):
+                content = call.get("content", "")
+                if content:
+                    lines.append(content)
+            else:
+                tool_input = call.get("input")
+                tool_output = call.get("output")
+                has_input = not _is_empty_payload(tool_input)
+                has_output = not _is_empty_payload(tool_output)
+                if not has_input and not has_output:
+                    # No parameters, only show tool name with emoji on separate line
+                    if tool_name == "Partial Summary":
+                        lines.append("\n💡Partial Summary\n")
+                    else:
+                        lines.append(f"\n🔧{tool_name}\n")
+                else:
+                    # Show as collapsible details for any tool with input or output
+                    if tool_name == "Partial Summary":
+                        summary = f"💡{tool_name} ({call_id[:8]})"
+                    else:
+                        summary = f"🔧{tool_name} ({call_id[:8]})"
+                    lines.append(f"\n<details><summary>{summary}</summary>")
+                    if has_input:
+                        pretty = json.dumps(tool_input, ensure_ascii=False, indent=2)
+                        lines.append("\n**Input**:\n")
+                        lines.append(f"```json\n{pretty}\n```")
+                    if has_output:
+                        pretty = json.dumps(tool_output, ensure_ascii=False, indent=2)
+                        lines.append("\n**Output**:\n")
+                        lines.append(f"```json\n{pretty}\n```")
+                    lines.append("</details>\n")
+        lines.append("\n---\n")
+    return "\n".join(lines) if lines else "Waiting..."
+
+def _update_state_with_event(state: dict, message: dict):
+    event = message.get("event")
+    data = message.get("data", {})
+    if event == "start_of_agent":
+        agent_id = data.get("agent_id")
+        agent_name = data.get("agent_name", "unknown")
+        if agent_id and agent_id not in state["agents"]:
+            state["agents"][agent_id] = {
+                "agent_name": agent_name,
+                "tool_call_order": [],
+                "tools": {}
+            }
+            state["agent_order"].append(agent_id)
+        state["current_agent_id"] = agent_id
+    elif event == "end_of_agent":
+        # End marker, no special handling needed, keep structure
+        state["current_agent_id"] = None
+    elif event == "tool_call":
+        tool_call_id = data.get("tool_call_id")
+        tool_name = data.get("tool_name", "unknown_tool")
+        agent_id = state.get("current_agent_id") or (state["agent_order"][-1] if state["agent_order"] else None)
+        if not agent_id:
+            return state
+        agent = state["agents"].setdefault(agent_id, {"agent_name": "unknown", "tool_call_order": [], "tools": {}})
+        tools = agent["tools"]
+        if tool_call_id not in tools:
+            tools[tool_call_id] = {"tool_name": tool_name}
+            agent["tool_call_order"].append(tool_call_id)
+        entry = tools[tool_call_id]
+        if tool_name == "show_text" and "delta_input" in data:
+            delta = data.get("delta_input", {}).get("text", "")
+            _append_show_text(entry, delta)
+        elif tool_name == "show_text" and "tool_input" in data:
+            ti = data.get("tool_input")
+            text = ""
+            if isinstance(ti,dict):
+                text = ti.get("text", "") or ((ti.get('result') or {}).get("text") if isinstance(ti.get('result'),dict) else "")
+            elif isinstance(ti,str):
+                text = ti
+            if text:
+                _append_show_text(entry, text)
+        else:
+            # Distinguish between input and output:
+            if "tool_input" in data:
+                # Could be input (first time) or output with result (second time)
+                ti = data["tool_input"]
+                # If contains result, assign to output; otherwise assign to input
+                if isinstance(ti, dict) and "result" in ti:
+                    entry["output"] = ti
+                else:
+                    # Only update input if we don't already have valid input data, or if the new data is not empty
+                    if "input" not in entry or not _is_empty_payload(ti):
+                        entry["input"] = ti
+    elif event == "message":
+        # Same incremental text display as show_text, aggregated by message_id
+        message_id = data.get("message_id")
+        agent_id = state.get("current_agent_id") or (state["agent_order"][-1] if state["agent_order"] else None)
+        if not agent_id:
+            return state
+        agent = state["agents"].setdefault(agent_id, {"agent_name": "unknown", "tool_call_order": [], "tools": {}})
+        tools = agent["tools"]
+        if message_id not in tools:
+            tools[message_id] = {"tool_name": "message"}
+            agent["tool_call_order"].append(message_id)
+        entry = tools[message_id]
+        delta_content = (data.get("delta") or {}).get("content", "")
+        if isinstance(delta_content, str) and delta_content:
+            _append_show_text(entry, delta_content)
+    elif event == "error":
+        # Collect errors, display uniformly during rendering
+        err_text = data.get("error") if isinstance(data, dict) else None
+        if not err_text:
+            try:
+                err_text = json.dumps(data, ensure_ascii=False)
+            except Exception:
+                err_text = str(data)
+        state.setdefault("errors", []).append(err_text)
+    else:
+        # Ignore heartbeat or other events
+        pass
+    return state
+
+
+def _spinner_markup(running: bool) -> str:
+    if not running:
+        return ""
+    return (
+        "\n\n<div style=\"display:flex;align-items:center;gap:8px;color:#555;margin-top:8px;\">"
+        "<div style=\"width:16px;height:16px;border:2px solid #ddd;border-top-color:#3b82f6;border-radius:50%;animation:spin 0.8s linear infinite;\"></div>"
+        "<span>Generating...</span>"
+        "</div>\n<style>@keyframes spin{to{transform:rotate(360deg)}}</style>\n"
+    )
+
+async def gradio_run(query: str, ui_state: Optional[dict]):
+    query = replace_chinese_punctuation(query or "")
+    if contains_chinese(query):
+        yield (
+            "we only support English input for the time being.",
+            gr.update(interactive=True),
+            gr.update(interactive=False),
+            ui_state or {"task_id": None}
+        )
+        return
+    task_id = str(uuid.uuid4())
+    if not ui_state:
+        ui_state = {"task_id": task_id}
+    else:
+        ui_state = {**ui_state, "task_id": task_id}
+    state = _init_render_state()
+    # Initial: disable Run, enable Stop, and show spinner at bottom of text
+    yield (
+        _render_markdown(state) + _spinner_markup(True),
+        gr.update(interactive=False),
+        gr.update(interactive=True),
+        ui_state
+    )
+    async for message in request_sse_stream_parsed(query):
+        state = _update_state_with_event(state, message)
+        md = _render_markdown(state)
+        yield (
+            md + _spinner_markup(True),
+            gr.update(interactive=False),
+            gr.update(interactive=True),
+            ui_state
+        )
+    # End: enable Run, disable Stop, remove spinner
+    yield (
+        _render_markdown(state),
+        gr.update(interactive=True),
+        gr.update(interactive=False),
+        ui_state
+    )
+
+def stop_current(ui_state: Optional[dict]):
+    # Immediately switch button availability: enable Run, disable Stop
+    return (
+        gr.update(interactive=True),
+        gr.update(interactive=False),
+    )
+
+def build_demo():
+    custom_css = """
+    #log-view { border: 1px solid #ececec; padding: 12px; border-radius: 8px; scroll-behavior: smooth; }
     """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+    with gr.Blocks(css=custom_css) as demo:
+        gr.Markdown("""
+        **MiroMind - Gradio Demo**  
+        Enter an English question and observe Agents and tool calls in real time (Markdown + collapsible sections).
+        """)
+        with gr.Row():
+            inp = gr.Textbox(lines=3, label="Question (English only)")
+        with gr.Row():
+            run_btn = gr.Button("Run")
+            stop_btn = gr.Button("Stop", variant="stop", interactive=False)
+        out_md = gr.Markdown("", elem_id="log-view")
+        ui_state = gr.State({"task_id": None})
+        # run: outputs -> markdown, run_btn(update), stop_btn(update), ui_state
+        run_btn.click(fn=gradio_run, inputs=[inp, ui_state], outputs=[out_md, run_btn, stop_btn, ui_state])
+        # stop: outputs -> run_btn(update), stop_btn(update)
+        stop_btn.click(fn=stop_current, inputs=[ui_state], outputs=[run_btn, stop_btn])
+    return demo
+
+
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo = build_demo()
+    demo.launch()

utils.py

@@ -0,0 +1,48 @@
+import re
+
+def contains_chinese(text):
+    """
+    Detect if a string contains Chinese characters or Chinese punctuation
+    
+    Args:
+        text (str): The string to detect
+    
+    Returns:
+        bool: True if contains Chinese characters or punctuation, False otherwise
+    """
+    # Chinese character Unicode ranges:
+    # \u4e00-\u9fff: CJK Unified Ideographs
+    # \u3400-\u4dbf: CJK Extension A
+    # \uf900-\ufaff: CJK Compatibility Ideographs
+    # \u3000-\u303f: CJK Symbols and Punctuation
+    # \uff00-\uffef: Fullwidth ASCII, Fullwidth punctuation
+    chinese_pattern = re.compile(r'[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff\u3000-\u303f\uff00-\uffef]')
+    return bool(chinese_pattern.search(text))
+
+def replace_chinese_punctuation(text):
+    # Handle single-character replacements with translate
+    punctuation_map = str.maketrans({
+        '，': ',',
+        '。': '.',
+        '！': '!',
+        '？': '?',
+        '；': ';',
+        '：': ':',
+        '“': '"',
+        '”': '"',
+        '‘': "'",
+        '’': "'",
+        '（': '(',
+        '）': ')',
+        '【': '[',
+        '】': ']',
+        '《': '<',
+        '》': '>',
+        '、': ',',
+        '—': '-'
+    })
+    # First, replace multi-character punctuation
+    text = text.replace('……', '...')
+    # Then apply single-character replacements
+    return text.translate(punctuation_map)
+