Update app.py

app.py

@@ -8,14 +8,15 @@ from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
 # 1. Konfiguration des MCP-Servers via STDIO-Bridge
-# Dies löst das SSE-Problem, indem npx mcp-remote die Kommunikation übernimmt [3].
+# FIX: Changed transport from 'streamable-http' to 'http-first' based on error log
 server_params = StdioServerParameters(
     command="npx",
     args=[
+        "-y", # Auto-confirm installation if needed
         "mcp-remote",
         "https://mgokg-db-timetable-api.hf.space/gradio_api/mcp/",
         "--transport",
-        "streamable-http"
+        "http-first" 
     ]
 )
 
@@ -27,12 +28,13 @@ async def generate(input_text):
 
     model = "gemini-2.0-flash" 
 
-    # 2. Aufbau der MCP-Session [4, 5]
+    # 2. Aufbau der MCP-Session
+    # Note: This context manager keeps the connection open only during the generation
     async with stdio_client(server_params) as (read, write):
         async with ClientSession(read, write) as session:
             await session.initialize()
             
-            # MCP-Tools abrufen und in Gemini-Format konvertieren [5, 6]
+            # MCP-Tools abrufen und in Gemini-Format konvertieren
             mcp_tools_data = await session.list_tools()
             mcp_declarations = [
                 {
@@ -43,7 +45,9 @@ async def generate(input_text):
                 for tool in mcp_tools_data.tools
             ]
 
-            # 3. Kombination der Tools: Google Search + DB-Timetable [5, 7]
+            # 3. Kombination der Tools
+            # Using function_declarations disables Automatic Function Calling (AFC),
+            # which is what we want because we handle the loop manually below.
             tools = [
                 types.Tool(google_search=types.GoogleSearch()),
                 types.Tool(function_declarations=mcp_declarations)
@@ -58,20 +62,33 @@ async def generate(input_text):
                 config=types.GenerateContentConfig(tools=tools, temperature=0.4)
             )
             
-            # 4. Agentic Loop: Bearbeitung von Tool-Calls (z.B. db_timetable_api_ui_wrapper) [8, 9]
+            # 4. Agentic Loop: Bearbeitung von Tool-Calls
             turn_count = 0
+            
+            # Note: response.function_calls is a helper property in the SDK
             while response.function_calls and turn_count < 5:
                 turn_count += 1
-                contents.append(response.candidates.content)
+                
+                # FIX: response.candidates is a list. Must access index 0.
+                contents.append(response.candidates[0].content)
+                
                 tool_responses = []
                 
                 for fc in response.function_calls:
                     try:
-                        # Ausführung des MCP-Tools [9]
+                        # Ausführung des MCP-Tools
                         tool_result = await session.call_tool(fc.name, fc.args)
                         
-                        # Ergebnis formatieren (Erfolg oder Fehler) [9]
-                        result_data = tool_result.content.text if not tool_result.isError else tool_result.content.text
+                        # Ergebnis formatieren
+                        # Check if content is a list (standard MCP) or text
+                        if hasattr(tool_result.content, 'text'):
+                             # Some implementations might differ, standardizing to string
+                             result_data = tool_result.content.text
+                        elif isinstance(tool_result.content, list):
+                             result_data = "\n".join([item.text for item in tool_result.content if hasattr(item, 'text')])
+                        else:
+                             result_data = str(tool_result.content)
+
                         tool_responses.append(types.Part.from_function_response(
                             name=fc.name, response={"result": result_data}
                         ))
@@ -82,16 +99,17 @@ async def generate(input_text):
 
                 contents.append(types.Content(role="user", parts=tool_responses))
                 
-                # Nächster Modell-Aufruf mit den Tool-Ergebnissen [10, 11]
+                # Nächster Modell-Aufruf mit den Tool-Ergebnissen
                 response = await client.aio.models.generate_content(
                     model=model, contents=contents, config=types.GenerateContentConfig(tools=tools)
                 )
 
             return response.text, ""
 
-# 5. Gradio UI Integration [12]
-def ui_wrapper(input_text):
-    return asyncio.run(generate(input_text))
+# 5. Gradio UI Integration
+# FIX: Made this async and removed asyncio.run() to prevent Event Loop conflicts
+async def ui_wrapper(input_text):
+    return await generate(input_text)
 
 if __name__ == '__main__':
     with gr.Blocks() as demo:
@@ -105,8 +123,7 @@ if __name__ == '__main__':
             inputs=input_textbox,
             outputs=[output_textbox, input_textbox]
         )
-    demo.launch(show_error=True)
-
+    demo.launch(show_error=True, ssr_mode=False)
 
 
 """