ai: Render reasoning tag.

src/main/gradio.py

@@ -14,94 +14,169 @@ from src.cores.client import chat_with_model_async
 
 async def respond_async(multi, history, model_display, sess, custom_prompt, deep_search):
     """
-    Main async handler for user input submission.
-    Supports text + file uploads (multi-modal input).
+    Main asynchronous handler for user input submission.
+    Supports text and file uploads (multi-modal input).
     Extracts file content and appends to user input.
-    Streams AI responses back to UI, updating chat history live.
-    Allows stopping response generation gracefully.
+    Streams AI responses back to the UI, updating chat history live.
+    Separates and streams 'reasoning' (AI thinking) and final content distinctly.
+    Allows graceful stopping of response generation on user request.
     """
+    # Ensure the stop event object exists in the session and clear any previous stop signals
     ensure_stop_event(sess)
     sess.stop_event.clear()
     sess.cancel_token["cancelled"] = False
-    # Extract text and files from multimodal input
+
+    # Extract text and files from the multi-modal user input
     msg_input = {"text": multi.get("text", "").strip(), "files": multi.get("files", [])}
-    # If no input, reset UI state and return
+
+    # If no text or files provided, reset UI input state and return immediately
     if not msg_input["text"] and not msg_input["files"]:
         yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
         return
-    # Initialize input with extracted file contents
+
+    # Initialize input string by extracting content from uploaded files (if any)
     inp = ""
     for f in msg_input["files"]:
-        # Support dict or direct file path
+        # Support both dict format (with 'data' or 'name') and direct file path
         fp = f.get("data", f.get("name", "")) if isinstance(f, dict) else f
+        # Append filename and extracted file content, separated by newlines for clarity
         inp += f"{Path(fp).name}\n\n{extract_file_content(fp)}\n\n"
-    # Append user text input if any
+
+    # Append user text input if present
     if msg_input["text"]:
         inp += msg_input["text"]
-    # Append user input to chat history with placeholder response
+
+    # Append the combined input to chat history with a placeholder response indicating processing
     history.append([inp, RESPONSES["RESPONSE_8"]])
+    # Yield updated history and disable input while processing, enable stop button
     yield history, gr.update(interactive=False, submit_btn=False, stop_btn=True), sess
+
+    # Create an asynchronous queue to communicate between background streaming task and main loop
     queue = asyncio.Queue()
-    # Background async task to fetch streamed AI responses
+
+    # Define background async task that fetches streamed AI responses and processes reasoning/content separately
     async def background():
-        reasoning = ""
-        responses = ""
-        content_started = False
-        ignore_reasoning = False
+        reasoning_buffer = ""  # Buffer to accumulate reasoning (AI's "thinking") text
+        response_buffer = ""   # Buffer to accumulate final content (AI's answer)
+        inside_reasoning = False  # Flag indicating if currently inside reasoning section
+        content_started = False   # Flag indicating if final content streaming has started
+
+        # Receive streamed tuples (type, chunk) from the AI model asynchronously
         async for typ, chunk in chat_with_model_async(history, inp, model_display, sess, custom_prompt, deep_search):
+            # If user requested stop, break the streaming loop
             if sess.stop_event.is_set() or sess.cancel_token["cancelled"]:
                 break
-            if typ == "reasoning":
-                if ignore_reasoning:
-                    continue
-                reasoning += chunk
-                await queue.put(("reasoning", reasoning))
-            elif typ == "content":
+
+            # Detect reasoning start tag in the chunk and enter reasoning mode
+            if "<think>" in chunk:
+                inside_reasoning = True
+                # Capture text after <think> tag as start of reasoning
+                reasoning_buffer += chunk.split("<think>", 1)[1]
+                # Send initial reasoning update to the queue for UI to display reasoning in progress
+                await queue.put(("reasoning", reasoning_buffer))
+                continue  # Skip further processing of this chunk
+
+            # Detect reasoning end tag in the chunk and exit reasoning mode
+            if "</think>" in chunk:
+                # Append text before </think> tag to reasoning buffer to complete reasoning text
+                reasoning_buffer += chunk.split("</think>", 1)[0]
+                inside_reasoning = False
+                # Send final reasoning text to queue so UI can mark reasoning as done
+                await queue.put(("reasoning", reasoning_buffer))
+                # Clear reasoning buffer for next possible reasoning section
+                reasoning_buffer = ""
+                continue  # Skip further processing of this chunk
+
+            if inside_reasoning:
+                # While inside reasoning, accumulate chunk into reasoning buffer
+                reasoning_buffer += chunk
+                # Send incremental reasoning updates to queue to update UI live
+                await queue.put(("reasoning", reasoning_buffer))
+            else:
+                # Outside reasoning, this chunk belongs to final content answer
                 if not content_started:
+                    # On first content chunk, mark content streaming started and reset reasoning display
                     content_started = True
-                    ignore_reasoning = True
-                    responses = chunk
-                    await queue.put(("reasoning", ""))  # Clear reasoning on content start
-                    await queue.put(("replace", responses))
+                    response_buffer = chunk
+                    # Clear any reasoning display on UI as final content begins
+                    await queue.put(("reasoning", ""))
+                    # Send initial content to queue to replace placeholder message
+                    await queue.put(("replace", response_buffer))
                 else:
-                    responses += chunk
-                    await queue.put(("append", responses))
+                    # Append subsequent content chunks to response buffer
+                    response_buffer += chunk
+                    # Send updated content to queue to append to existing message on UI
+                    await queue.put(("append", response_buffer))
+
+        # Indicate end of streaming by sending None to queue
         await queue.put(None)
-        return responses
+        return response_buffer
+
+    # Start background streaming task
     bg_task = asyncio.create_task(background())
+    # Create a task that waits for user stop event
     stop_task = asyncio.create_task(sess.stop_event.wait())
+    # Track all pending async tasks for proper cancellation
     pending_tasks = {bg_task, stop_task}
+
     try:
         while True:
+            # Create a task to get next item from queue
             queue_task = asyncio.create_task(queue.get())
             pending_tasks.add(queue_task)
+
+            # Wait until either user stops or new data arrives from queue
             done, _ = await asyncio.wait({stop_task, queue_task}, return_when=asyncio.FIRST_COMPLETED)
+
             for task in done:
                 pending_tasks.discard(task)
+
                 if task is stop_task:
-                    # User requested stop, cancel background task and update UI
+                    # User pressed stop button: cancel background streaming task
                     sess.cancel_token["cancelled"] = True
                     bg_task.cancel()
                     try:
                         await bg_task
                     except asyncio.CancelledError:
+                        # Expected cancellation exception; ignore
                         pass
+                    # Update last chat message with cancellation notice
                     history[-1][1] = RESPONSES["RESPONSE_1"]
+                    # Yield updated history and reset UI input state accordingly
                     yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
                     return
+
                 result = task.result()
                 if result is None:
+                    # None signals that streaming is complete; stop iteration
                     raise StopAsyncIteration
+
                 action, text = result
-                # Update last message content in history with streamed text
-                history[-1][1] = text
+
+                # Update chat history based on action type from queue
+                if action == "reasoning":
+                    # Update last message content with current reasoning text (AI thinking)
+                    history[-1][1] = text
+                elif action == "replace":
+                    # Replace last message content with initial content chunk (start of answer)
+                    history[-1][1] = text
+                elif action == "append":
+                    # Append new content chunk to last message content (streaming answer)
+                    history[-1][1] = text
+
+                # Yield updated chat history and UI state (disable input, enable stop)
                 yield history, gr.update(interactive=False, submit_btn=False, stop_btn=True), sess
+
     except StopAsyncIteration:
+        # Streaming ended normally; exit loop
         pass
     finally:
+        # Cancel all pending tasks to clean up properly
         for task in pending_tasks:
             task.cancel()
         await asyncio.gather(*pending_tasks, return_exceptions=True)
+
+    # After streaming completes, reset UI input to allow new user input
     yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
 
 def toggle_deep_search(deep_search_value, history, sess, prompt, model):