Update app.py

app.py

@@ -19,18 +19,28 @@ 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 = []
-    # Initial yield to clear previous state and show connecting message
-    yield {
-        "status": "Connecting to Hive...",
-        "chat_history": [],
-        "solution": "", "confidence": "", "minority_opinions": ""
-    }
+    
+    # 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([]),
+        current_solution,
+        current_confidence,
+        current_minority_opinions
+    )
 
     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 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)
-                # We need to buffer chunks to ensure we parse complete JSON lines
+                
                 buffer = ""
                 async for chunk in response.aiter_bytes():
                     buffer += chunk.decode('utf-8')
@@ -42,49 +52,58 @@ async def call_modal_backend(problem_input: str, complexity: int):
                             event_type = data.get("event")
 
                             if event_type == "status_update":
-                                yield {
-                                    "status": data["data"], 
-                                    "chat_history": format_chat_history_for_gradio(full_chat_history)
-                                }
+                                current_status = data["data"]
                             elif event_type == "chat_update":
                                 full_chat_history.append(data["data"])
-                                yield {
-                                    "status": "In Progress...", 
-                                    "chat_history": format_chat_history_for_gradio(full_chat_history)
-                                }
+                                current_status = "In Progress..." # Update status to reflect ongoing discussion
                             elif event_type == "final_solution":
-                                yield {
-                                    "status": "Solution Complete!",
-                                    "chat_history": format_chat_history_for_gradio(full_chat_history + [{"agent": "System", "text": "Final solution synthesized."}]),
-                                    "solution": data["solution"],
-                                    "confidence": data["confidence"],
-                                    "minority_opinions": data["minority_opinions"]
-                                }
+                                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."}]),
+                                    current_solution,
+                                    current_confidence,
+                                    current_minority_opinions
+                                )
                                 return # Done processing
 
+                            # Yield the current state of all outputs after processing each event
+                            yield (
+                                current_status,
+                                format_chat_history_for_gradio(full_chat_history),
+                                current_solution,
+                                current_confidence,
+                                current_minority_opinions
+                            )
+
                         except json.JSONDecodeError as e:
                             print(f"JSON Decode Error: {e} in line: {line}")
-                            # This could happen if a partial JSON is received.
-                            # The buffering logic should help, but if it's consistently failing, check Modal's streaming output.
+                            # 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)
                         except Exception as e:
                             print(f"Error processing event: {e}, Data: {data}")
-                            yield {"status": f"Error: {e}", "chat_history": format_chat_history_for_gradio(full_chat_history)}
-                            return
+                            current_status = f"Error: {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:
-        error_message = f"HTTP Error: {e.response.status_code} - {e.response.text}"
-        print(error_message)
-        yield {"status": error_message, "chat_history": format_chat_history_for_gradio(full_chat_history)}
+        current_status = f"HTTP Error: {e.response.status_code} - {e.response.text}"
+        print(current_status)
     except httpx.RequestError as e:
-        error_message = f"Request Error: Could not connect to Modal backend: {e}"
-        print(error_message)
-        yield {"status": error_message, "chat_history": format_chat_history_for_gradio(full_chat_history)}
+        current_status = f"Request Error: Could not connect to Modal backend: {e}"
+        print(current_status)
     except Exception as e:
-        error_message = f"An unexpected error occurred: {e}"
-        print(error_message)
-        yield {"status": error_message, "chat_history": format_chat_history_for_gradio(full_chat_history)}
+        current_status = f"An unexpected error occurred: {e}"
+        print(current_status)
 
-    yield {"status": "Process finished unexpectedly or ended.", "chat_history": format_chat_history_for_gradio(full_chat_history)}
+    # 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)
 
 
 with gr.Blocks() as demo: