Update app.py

app.py

@@ -6,13 +6,14 @@ import queue
 import gradio as gr
 import httpx
 import time
+import tempfile
 from typing import Generator, Any, Dict, List, Optional
 
 # -------------------- Configuration --------------------
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
 # -------------------- External Model Call (with Caching and Retry) --------------------
-async def call_model(prompt: str, model: str = "gpt-4o", api_key: str = None, max_retries: int = 5) -> str:
+async def call_model(prompt: str, model: str = "gpt-4o", api_key: str = None, max_retries: int = 3) -> str:
     if api_key is None:
         api_key = os.getenv("OPENAI_API_KEY")
         if api_key is None:
@@ -63,6 +64,15 @@ def convert_history(history: List[Dict[str, str]]) -> List[Dict[str, str]]:
             converted.append({"role": "assistant", "content": f'{entry["agent"]}: {entry["message"]}'})
     return converted
 
+def conversation_to_text(history: List[Dict[str, str]]) -> str:
+    """
+    Convert the conversation history to a plain-text log.
+    """
+    lines = []
+    for entry in history:
+        lines.append(f"{entry['agent']}: {entry['message']}")
+    return "\n".join(lines)
+
 # -------------------- Shared Context --------------------
 class Context:
     def __init__(self, original_task: str, optimized_task: Optional[str] = None,
@@ -158,7 +168,6 @@ class CodeReviewerAgent:
         )
         review = await call_model(prompt, model="gpt-4o", api_key=api_key)
         context.add_conversation_entry("Code Reviewer", f"Review:\n{review}")
-        # If review is not "APPROVE", store the review comments.
         if "APPROVE" not in review.upper():
             structured_review = {"comments": []}
             for line in review.splitlines():
@@ -239,7 +248,6 @@ class AgentDispatcher:
             context = await self.agents[agent_name].generate_documentation(context, api_key)
         else:
             raise ValueError(f"Unknown agent: {agent_name}")
-        # Push an update with the current conversation history.
         self.log_queue.put(("update", context.conversation_history))
         return context
 
@@ -250,9 +258,9 @@ class AgentDispatcher:
             return "orchestrator"
         if not context.code:
             return "coder"
-        # Instead of checking review_comments (which may be empty if reviewer approved),
-        # check the conversation history for a Code Reviewer entry containing "APPROVE".
-        if not any("APPROVE" in entry["message"].upper() for entry in context.conversation_history if entry["agent"].lower() == "code reviewer"):
+        if not any("APPROVE" in entry["message"].upper() 
+                   for entry in context.conversation_history 
+                   if entry["agent"].lower() == "code reviewer"):
             return "code_reviewer"
         if not context.test_cases:
             return "qa_tester"
@@ -280,7 +288,6 @@ async def multi_agent_conversation(task_message: str, log_queue: queue.Queue, ap
             context = await dispatcher.dispatch(next_agent, context, api_key, model="gpt-3.5-turbo-16k")
         else:
             context = await dispatcher.dispatch(next_agent, context, api_key)
-        # Check approval by scanning the conversation history for a Code Reviewer entry that includes "APPROVE"
         if next_agent == "code_reviewer":
             approved = any("APPROVE" in entry["message"].upper() 
                            for entry in context.conversation_history 
@@ -302,7 +309,7 @@ def process_conversation_generator(task_message: str, api_key: str,
                                    log_queue: queue.Queue) -> Generator[Any, None, None]:
     """
     Runs the multi-agent conversation in a background thread and yields conversation history updates
-    in the proper messages format.
+    as a tuple: (chat update, log state update).
     """
     def run_conversation():
         asyncio.run(multi_agent_conversation(task_message, log_queue, api_key, human_event, human_input_queue))
@@ -315,35 +322,49 @@ def process_conversation_generator(task_message: str, api_key: str,
             msg = log_queue.get(timeout=0.1)
             if isinstance(msg, tuple):
                 if msg[0] in ("update", "result"):
-                    yield gr.update(value=convert_history(msg[1]), visible=True)
+                    chat_update = gr.update(value=convert_history(msg[1]), visible=True)
+                    log_text = conversation_to_text(msg[1])
+                    state_update = gr.update(value=log_text)
+                    yield (chat_update, state_update)
                 else:
-                    # Optionally handle log messages here.
+                    # Optionally handle log messages.
                     pass
         except queue.Empty:
             pass
         time.sleep(0.1)
     
-    yield gr.update(visible=True)
+    yield (gr.update(visible=True), gr.update())
 
 # -------------------- Multi-Agent Chat Function --------------------
 def multi_agent_chat(message: str, openai_api_key: str = None) -> Generator[Any, None, None]:
     if not openai_api_key:
         openai_api_key = os.getenv("OPENAI_API_KEY")
         if not openai_api_key:
-            yield gr.update(value=[{"role": "assistant", "content": "Error: API key not provided."}])
+            yield (gr.update(value=[{"role": "assistant", "content": "Error: API key not provided."}]), gr.update())
             return
     human_event = threading.Event()
     human_input_queue = queue.Queue()
     log_queue = queue.Queue()
     yield from process_conversation_generator(message, openai_api_key, human_event, human_input_queue, log_queue)
 
+# -------------------- Download Log Function --------------------
+def download_log(log_text: str) -> str:
+    """
+    Writes the log text to a temporary file and returns the file path.
+    """
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".txt", mode="w", encoding="utf-8") as f:
+        f.write(log_text)
+        return f.name
+
 # -------------------- Custom Gradio Blocks Interface --------------------
 with gr.Blocks() as demo:
     gr.Markdown("## Multi-Agent Task Solver with Human-in-the-Loop")
     
     with gr.Row():
-        # Use type="messages" so that the Chatbot expects a list of dicts with 'role' and 'content'.
+        # Chatbot displays conversation messages.
         chat_output = gr.Chatbot(label="Conversation", type="messages")
+    # Hidden state to store the plain-text log.
+    log_state = gr.State(value="")
     
     with gr.Row():
         with gr.Column(scale=8):
@@ -353,8 +374,14 @@ with gr.Blocks() as demo:
     
     send_button = gr.Button("Send")
     
-    # Connect the button to our multi_agent_chat generator.
-    send_button.click(fn=multi_agent_chat, inputs=[message_input, api_key_input], outputs=chat_output)
+    # The multi_agent_chat function now outputs two values: one for the chat and one for the log.
+    send_button.click(fn=multi_agent_chat, inputs=[message_input, api_key_input], outputs=[chat_output, log_state])
+    
+    with gr.Row():
+        download_button = gr.Button("Download Log")
+        download_file = gr.File(label="Download your log file")
+    
+    download_button.click(fn=download_log, inputs=log_state, outputs=download_file)
 
 if __name__ == "__main__":
     demo.launch(share=True)