Update app.py

app.py

@@ -1,11 +1,10 @@
-# app.py (on Hugging Face Spaces)
 import gradio as gr
 import httpx
 import asyncio
 import json
 
-# Replace with your Modal API endpoint URL
-MODAL_API_ENDPOINT = "https://blastingneurons--collective-hive-backend-orchestrate-hive-api.modal.run" 
+# Replace with your NEW Modal API endpoint URL (for the non-streaming backend)
+MODAL_API_ENDPOINT = "https://blastingneurons--collective-hive-backend-sync-orchestrat-ee7dd9.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]:
@@ -16,85 +15,51 @@ def format_chat_history_for_gradio(log_entries: list[dict]) -> list[dict]:
         formatted_messages.append({"role": role, "content": content})
     return formatted_messages
 
-async def call_modal_backend(problem_input: str, complexity: int):
-    full_chat_history = []
-    
-    current_status = "Connecting to Hive..."
-    current_solution = ""
-    current_confidence = ""
-    current_minority_opinions = ""
-
+async def call_modal_backend_sync(problem_input: str, complexity: int):
+    # Initial yield to clear previous state and show connecting message
     yield (
-        current_status,
+        "Connecting to Hive...",
         format_chat_history_for_gradio([]),
-        current_solution,
-        current_confidence,
-        current_minority_opinions
+        "", "", ""
     )
 
     try:
-        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()
-                
-                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
-                        try:
-                            data = json.loads(line)
-                            event_type = data.get("event")
-
-                            if event_type == "status_update":
-                                current_status = data["data"]
-                            elif event_type == "chat_update":
-                                full_chat_history.append(data["data"])
-                                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 (
-                                    current_status,
-                                    format_chat_history_for_gradio(full_chat_history + [{"role": "System", "content": "Final solution synthesized."}]),
-                                    current_solution,
-                                    current_confidence,
-                                    current_minority_opinions
-                                )
-                                return
-
-                            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}")
-                            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}")
-                            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
+        async with httpx.AsyncClient(timeout=600.0) as client: # Longer timeout for the full process
+            response = await client.post(MODAL_API_ENDPOINT, json={"problem": problem_input, "complexity": complexity})
+            response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
+            
+            response_data = response.json() # Parse the full JSON response
+            
+            final_status = response_data.get("status", "Unknown Status")
+            final_chat_history = response_data.get("chat_history", [])
+            final_solution = response_data.get("solution", "No solution provided.")
+            final_confidence = response_data.get("confidence", "0.0%")
+            final_minority_opinions = response_data.get("minority_opinions", "None")
+
+            yield (
+                final_status,
+                format_chat_history_for_gradio(final_chat_history),
+                final_solution,
+                final_confidence,
+                final_minority_opinions
+            )
+            return # Done processing
 
     except httpx.HTTPStatusError as e:
-        current_status = f"HTTP Error from Modal backend: {e.response.status_code}"
-        print(current_status)
+        error_message = f"HTTP Error from Modal backend: {e.response.status_code} - {e.response.text}"
+        print(error_message)
+        yield (error_message, format_chat_history_for_gradio([]), "", "", "")
     except httpx.RequestError as e:
-        current_status = f"Request Error: Could not connect to Modal backend: {e}"
-        print(current_status)
+        error_message = f"Request Error: Could not connect to Modal backend: {e}"
+        print(error_message)
+        yield (error_message, format_chat_history_for_gradio([]), "", "", "")
     except Exception as e:
-        current_status = f"An unexpected error occurred during API call: {e}"
-        print(current_status)
+        error_message = f"An unexpected error occurred during API call: {e}"
+        print(error_message)
+        yield (error_message, format_chat_history_for_gradio([]), "", "", "")
 
-    yield (current_status, format_chat_history_for_gradio(full_chat_history), current_solution, current_confidence, current_minority_opinions)
+# Fallback yield in case of unexpected termination before return
+yield ("An unexpected error occurred and processing stopped.", format_chat_history_for_gradio([]), "", "", "")
 
 
 with gr.Blocks() as demo:
@@ -124,7 +89,7 @@ with gr.Blocks() as demo:
             minority_output = gr.Textbox(label="Minority Opinions", lines=3, interactive=False)
 
     initiate_btn.click(
-        call_modal_backend,
+        call_modal_backend_sync, # Changed function name
         inputs=[problem_input, complexity_slider],
         outputs=[
             status_output,