thinking mode

app.py

@@ -177,110 +177,24 @@
 # if __name__ == "__main__":
 #     demo.launch(debug=True)
 
-
 import gradio as gr
-import openai
-import os
+from openai import OpenAI
 from datetime import datetime
-import json
-
-# --- Global Variables and Initial Setup ---
-stop_flag = {"stop": False}
 
-# Placeholder for reasoning data
-REASONING_CONTEXT = ""
-
-# --- Core Functions ---
+# 🔹 Configure your agent
+agent_endpoint = "https://q77iuwf7ncfemoonbzon2iyd.agents.do-ai.run/api/v1/"
+agent_access_key = "CzIwmTIDFNWRRIHvxVNzKWztq8rn5S5w"
 
-def policy_chat(message, history):
-    """
-    Main chat function that handles user messages, streams responses,
-    and provides reasoning.
-    """
-    global stop_flag, REASONING_CONTEXT
-    stop_flag["stop"] = False
-    
-    # 1. Indicate thinking and reset UI elements
-    yield (
-        history,  # chatbot
-        gr.update(visible=True),  # thinking_indicator
-        gr.update(visible=False, value=""),  # reasoning_accordion
-        gr.update(visible=True),  # stop_btn
-        gr.update(interactive=False)  # send_btn
-    )
-
-    # --- This is where you would add your retrieval logic ---
-    # For demonstration, we'll create mock reasoning context.
-    # In a real app, you would retrieve this from your RAG pipeline.
-    REASONING_CONTEXT = (
-        "### Retrieved Context\n\n"
-        "1.  **Document:** `policy_document_A.pdf` (Page 17)\n"
-        "    *   **Content:** 'The primary objective for renewable energy is to increase its share in the national grid by 20% by the year 2030.'\n"
-        "2.  **Document:** `strategy_paper_B.pdf` (Page 5)\n"
-        "    *   **Content:** 'Energy efficiency measures will be enforced through new building codes and industrial standards.'\n"
-    )
-    # --- End of retrieval logic section ---
-
-    # 2. Show the reasoning and hide the thinking indicator
-    yield (
-        history,  # chatbot
-        gr.update(visible=False),  # thinking_indicator
-        gr.update(visible=True, value=REASONING_CONTEXT),  # reasoning_accordion
-        gr.update(visible=True),  # stop_btn
-        gr.update(interactive=False)  # send_btn
-    )
+client = OpenAI(base_url=agent_endpoint, api_key=agent_access_key)
 
-    history = history + [[message, ""]]
-    
-    # 3. Stream the final answer
-    try:
-        # In a real app, you would pass the retrieved context into your prompt
-        response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=[{"role": "user", "content": f"Based on the context, answer this question: {message}"}],
-            stream=True,
-            # api_base="your_api_base", # Add your endpoint if needed
-            # api_key="your_api_key"   # Add your key if needed
-        )
-        
-        for chunk in response:
-            if stop_flag["stop"]:
-                break
-            if hasattr(chunk.choices[0].delta, 'content'):
-                content = chunk.choices[0].delta.content
-                if content:
-                    history[-1][1] += content
-                    yield (
-                        history,  # chatbot
-                        gr.update(visible=False),  # thinking_indicator
-                        gr.update(visible=True, value=REASONING_CONTEXT),  # reasoning_accordion
-                        gr.update(visible=True),  # stop_btn
-                        gr.update(interactive=False)  # send_btn
-                    )
+# Global flag to control streaming
+stop_flag = {"stop": False}
 
-    except Exception as e:
-        history[-1][1] = f"An error occurred: {str(e)}"
-        yield (
-            history,  # chatbot
-            gr.update(visible=False),  # thinking_indicator
-            gr.update(visible=True, value=REASONING_CONTEXT),  # reasoning_accordion
-            gr.update(visible=False),  # stop_btn
-            gr.update(interactive=True)  # send_btn
-        )
-    finally:
-        # 4. Clean up UI after streaming is finished or stopped
-        stop_flag["stop"] = False
-        yield (
-            history,  # chatbot
-            gr.update(visible=False),  # thinking_indicator
-            gr.update(visible=True, value=REASONING_CONTEXT),  # reasoning_accordion
-            gr.update(visible=False),  # stop_btn
-            gr.update(interactive=True)  # send_btn
-        )
+# Store reasoning context for export
+REASONING_CONTEXT = ""
 
 def stop_streaming():
-    """Sets the global flag to stop the streaming."""
-    global stop_flag
+    """Sets the stop flag to True to interrupt the streaming response."""
     stop_flag["stop"] = True
 
 def export_chat(history):
@@ -303,13 +217,94 @@ def export_chat(history):
         formatted_chat += "="*20 + "\n\n"
         formatted_chat += REASONING_CONTEXT
 
-    # Create a temporary file that Gradio can serve
     with open(filename, "w", encoding="utf-8") as f:
         f.write(formatted_chat)
         
     return filename
 
-# --- Gradio UI Layout ---
+def policy_chat(message, history):
+    """
+    Single stream chat with real-time thinking process and a stop button.
+    """
+    global REASONING_CONTEXT
+    # Reset stop flag at the beginning of a new request
+    stop_flag["stop"] = False
+    
+    # 1. Show thinking indicator and stop button
+    yield {
+        chatbot: history,
+        thinking_indicator: gr.update(visible=True),
+        reasoning_accordion: gr.update(visible=False, value=""),
+        stop_btn: gr.update(visible=True),
+        send_btn: gr.update(interactive=False)
+    }
+
+    # Add user message and empty assistant response to history
+    history = history + [[message, ""]]
+    yield {chatbot: history, thinking_indicator: gr.update(visible=True)}
+
+    try:
+        # 2. Simulate reasoning (in real app, this would be your retrieval logic)
+        REASONING_CONTEXT = (
+            "### Retrieved Context\n\n"
+            "1. **Document:** `policy_document_A.pdf` (Page 17)\n"
+            "   - **Content:** 'The primary objective for renewable energy is to increase its share in the national grid by 20% by the year 2030.'\n"
+            "2. **Document:** `strategy_paper_B.pdf` (Page 5)\n"
+            "   - **Content:** 'Energy efficiency measures will be enforced through new building codes and industrial standards.'\n"
+        )
+        
+        # Show reasoning and hide thinking indicator
+        yield {
+            chatbot: history,
+            thinking_indicator: gr.update(visible=False),
+            reasoning_accordion: gr.update(visible=True, value=REASONING_CONTEXT),
+            stop_btn: gr.update(visible=True),
+            send_btn: gr.update(interactive=False)
+        }
+        
+        # Create streaming chat completion
+        stream = client.chat.completions.create(
+            model="n/a",  # agent handles routing
+            messages=[
+                {"role": "system", "content": "The data must be returned verbatim. Please be quite detailed and include all information. You are new to the analysis of policy documents, hence you need to be objective in retrieving information, and it is not expected that you will analyse and interpret the information."},
+                *[{"role": "user", "content": u} if i % 2 == 0 else {"role": "assistant", "content": b}
+                  for i, (u, b) in enumerate(history[:-1])],  # exclude current exchange
+                {"role": "user", "content": message},
+            ],
+            extra_body={"include_retrieval_info": True},
+            stream=True,
+        )
+
+        # Stream response content in real-time
+        response_text = ""
+        for chunk in stream:
+            # Check if the stop flag has been set
+            if stop_flag["stop"]:
+                response_text += "\n\n⛔ **Streaming stopped by user.**"
+                history[-1][1] = response_text
+                yield {chatbot: history}
+                break  # Exit the loop
+
+            delta = chunk.choices[0].delta
+            if delta and delta.content:
+                response_text += delta.content
+                # Update the last message in history with streaming content
+                history[-1][1] = response_text
+                yield {chatbot: history}
+
+    except Exception as e:
+        # Handle errors by updating the assistant message
+        history[-1][1] = f"⚠️ Error: {str(e)}"
+        yield {chatbot: history}
+    
+    finally:
+        # Hide the stop button and re-enable send button once streaming is complete or stopped
+        yield {
+            stop_btn: gr.update(visible=False),
+            send_btn: gr.update(interactive=True),
+            thinking_indicator: gr.update(visible=False)
+        }
+
 
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="gray")) as demo:
     gr.Markdown("# 🤖 Policy-Agent Chatbot\nAsk me about policies. I'll stream responses and show my reasoning.")
@@ -342,25 +337,24 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="gray")) a
         stop_btn = gr.Button("⛔ Stop Streaming", visible=False)
         clear_btn = gr.Button("Clear Chat")
 
-    # --- Event Handlers ---
-    
-    # Combine all UI updates into a single list of outputs for chat submission
+    # Define event handlers
+    def on_submit(message, history):
+        yield from policy_chat(message, history)
+
+    # Combine all UI updates into outputs list
     chat_outputs = [chatbot, thinking_indicator, reasoning_accordion, stop_btn, send_btn]
     
-    msg.submit(policy_chat, [msg, chatbot], chat_outputs)
-    send_btn.click(policy_chat, [msg, chatbot], chat_outputs)
+    # Wire up components
+    msg.submit(on_submit, [msg, chatbot], chat_outputs)
+    send_btn.click(on_submit, [msg, chatbot], chat_outputs)
     
-    # Clear message box after send
+    # After submission, clear the textbox
     msg.submit(lambda: "", None, msg, queue=False)
     send_btn.click(lambda: "", None, msg, queue=False)
 
-    # Button actions
     stop_btn.click(stop_streaming, None, None, queue=False)
     clear_btn.click(lambda: ([], "", None), None, [chatbot, reasoning_accordion, export_file], queue=False)
     export_btn.click(export_chat, chatbot, export_file)
 
 if __name__ == "__main__":
-    # NOTE: You may need to configure your OpenAI key via environment variables
-    # For example: os.environ["OPENAI_API_KEY"] = "your_key_here"
-    # openai.api_base = "your_api_base_here_if_needed"
-    demo.launch(debug=True)
+    demo.launch(debug=True, height=800)