Update app.py

app.py

@@ -5,13 +5,12 @@ import asyncio
 import json
 
 # Replace with your Modal API endpoint URL
-MODAL_API_ENDPOINT = "https://blastingneurons--collective-hive-backend-orchestrate-hive-api.modal.run"
+MODAL_API_ENDPOINT = "https://blastingneurons--collective-hive-backend-orchestrate-hive-api.modal.run" 
 
 # Helper function to format chat history for Gradio's 'messages' type
 def format_chat_history_for_gradio(log_entries: list[dict]) -> list[dict]:
     formatted_messages = []
     for entry in log_entries:
-        # Default to 'System' if agent name is not found
         role = entry.get("agent", "System") 
         content = entry.get("text", "")
         formatted_messages.append({"role": role, "content": content})
@@ -20,13 +19,11 @@ def format_chat_history_for_gradio(log_entries: list[dict]) -> list[dict]:
 async def call_modal_backend(problem_input: str, complexity: int):
     full_chat_history = []
     
-    # Initialize all outputs with default values for the first yield
     current_status = "Connecting to Hive..."
     current_solution = ""
     current_confidence = ""
     current_minority_opinions = ""
 
-    # First yield to clear previous state and show connecting message
     yield (
         current_status,
         format_chat_history_for_gradio([]),
@@ -36,17 +33,16 @@ async def call_modal_backend(problem_input: str, complexity: int):
     )
 
     try:
-        async with httpx.AsyncClient(timeout=600.0) as client: # Longer timeout for the full process
-            # Make sure to send complexity if your Modal backend expects it
+        async with httpx.AsyncClient(timeout=600.0) as client:
             async with client.stream("POST", MODAL_API_ENDPOINT, json={"problem": problem_input, "complexity": complexity}) as response:
-                response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
+                response.raise_for_status()
                 
                 buffer = ""
                 async for chunk in response.aiter_bytes():
                     buffer += chunk.decode('utf-8')
                     while "\n" in buffer:
                         line, buffer = buffer.split("\n", 1)
-                        if not line.strip(): continue # Skip empty lines
+                        if not line.strip(): continue
                         try:
                             data = json.loads(line)
                             event_type = data.get("event")
@@ -55,23 +51,21 @@ async def call_modal_backend(problem_input: str, complexity: int):
                                 current_status = data["data"]
                             elif event_type == "chat_update":
                                 full_chat_history.append(data["data"])
-                                current_status = "In Progress..." # Update status to reflect ongoing discussion
+                                current_status = "In Progress..."
                             elif event_type == "final_solution":
                                 current_status = "Solution Complete!"
                                 current_solution = data["solution"]
                                 current_confidence = data["confidence"]
                                 current_minority_opinions = data["minority_opinions"]
-                                # Yield final state and then return to end the generator
                                 yield (
                                     current_status,
-                                    format_chat_history_for_gradio(full_chat_history + [{"agent": "System", "content": "Final solution synthesized."}]),
+                                    format_chat_history_for_gradio(full_chat_history + [{"role": "System", "content": "Final solution synthesized."}]),
                                     current_solution,
                                     current_confidence,
                                     current_minority_opinions
                                 )
-                                return # Done processing
+                                return
 
-                            # Yield the current state of all outputs after processing each event
                             yield (
                                 current_status,
                                 format_chat_history_for_gradio(full_chat_history),
@@ -82,27 +76,25 @@ async def call_modal_backend(problem_input: str, complexity: int):
 
                         except json.JSONDecodeError as e:
                             print(f"JSON Decode Error: {e} in line: {line}")
-                            # Handle incomplete JSON chunks, perhaps buffer and process when a full line is received
-                            # For robustness, you might yield an error status here too
                             current_status = f"Error decoding: {e}"
                             yield (current_status, format_chat_history_for_gradio(full_chat_history), current_solution, current_confidence, current_minority_opinions)
+                            # Do not return here if you want to keep trying to parse subsequent chunks
                         except Exception as e:
                             print(f"Error processing event: {e}, Data: {data}")
-                            current_status = f"Error: {e}"
+                            current_status = f"An internal error occurred: {e}"
                             yield (current_status, format_chat_history_for_gradio(full_chat_history), current_solution, current_confidence, current_minority_opinions)
                             return # Exit on critical error
 
     except httpx.HTTPStatusError as e:
-        current_status = f"HTTP Error: {e.response.status_code} - {e.response.text}"
+        current_status = f"HTTP Error from Modal backend: {e.response.status_code}"
         print(current_status)
     except httpx.RequestError as e:
         current_status = f"Request Error: Could not connect to Modal backend: {e}"
         print(current_status)
     except Exception as e:
-        current_status = f"An unexpected error occurred: {e}"
+        current_status = f"An unexpected error occurred during API call: {e}"
         print(current_status)
 
-    # Final yield in case of errors or unexpected termination
     yield (current_status, format_chat_history_for_gradio(full_chat_history), current_solution, current_confidence, current_minority_opinions)