Update app.py

app.py

@@ -1,7 +1,7 @@
 # app.py
 import asyncio
 import gradio as gr
-from typing import List, Tuple, AsyncGenerator
+from typing import List, Tuple
 from agents import FileSearchTool, Agent, ModelSettings, TResponseInputItem, Runner, RunConfig, trace
 import os
 from dotenv import load_dotenv
@@ -28,8 +28,7 @@ my_agent = Agent(
         temperature=1,
         top_p=1,
         max_tokens=2048,
-        store=True,
-        stream=True  # Enable streaming in model settings
+        store=True
     )
 )
 
@@ -49,71 +48,29 @@ def _to_items_from_history(history: List[Tuple[str, str]]) -> List[TResponseInpu
             })
     return items
 
-async def agent_reply_stream(message: str, history: List[Tuple[str, str]]) -> AsyncGenerator[str, None]:
-    """Streaming handler for Gradio ChatInterface."""
+async def agent_reply(message: str, history: List[Tuple[str, str]]):
+    """Handler for Gradio ChatInterface."""
     conversation_items = _to_items_from_history(history)
     conversation_items.append({
         "role": "user",
         "content": [{"type": "input_text", "text": message}],
     })
     
-    accumulated_response = ""
-    
     with trace("Gradio message"):
-        # Use streaming version of Runner.run
-        async for chunk in Runner.run_stream(
+        result = await Runner.run(
             my_agent,
             input=conversation_items,
-            run_config=RunConfig(
-                trace_metadata={
-                    "__trace_source__": "agent-builder",
-                    "workflow_id": WORKFLOW_ID
-                },
-                stream=True
-            )
-        ):
-            # Extract text from the chunk
-            # The exact format depends on your agents library implementation
-            if hasattr(chunk, 'delta'):
-                chunk_text = chunk.delta
-            elif hasattr(chunk, 'text'):
-                chunk_text = chunk.text
-            elif isinstance(chunk, str):
-                chunk_text = chunk
-            else:
-                # Adapt this based on your actual chunk structure
-                chunk_text = str(chunk)
-            
-            accumulated_response += chunk_text
-            yield accumulated_response
-
-# Synchronous wrapper for Gradio (if needed)
-def agent_reply_stream_sync(message: str, history: List[Tuple[str, str]]):
-    """Synchronous wrapper for the async streaming function."""
-    async def run():
-        accumulated = ""
-        async for chunk in agent_reply_stream(message, history):
-            accumulated = chunk
-            yield accumulated
-    
-    # Run the async generator in a sync context
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
+            run_config=RunConfig(trace_metadata={
+                "__trace_source__": "agent-builder",
+                "workflow_id": WORKFLOW_ID
+            })
+        )
     
-    try:
-        gen = run()
-        while True:
-            try:
-                future = asyncio.run_coroutine_threadsafe(gen.__anext__(), loop)
-                yield future.result()
-            except StopAsyncIteration:
-                break
-    finally:
-        loop.close()
+    return result.final_output_as(str)
 
-# --- Gradio ChatInterface with Streaming ---
+# --- Updated Gradio ChatInterface ---
 demo = gr.ChatInterface(
-    fn=agent_reply_stream_sync,  # Use the streaming function
+    fn=agent_reply,
     title="My agent (FileSearch-powered)",
     description=(
         "Este chat usa un agente con FileSearchTool. "
@@ -122,72 +79,9 @@ demo = gr.ChatInterface(
     examples=["¿Qué información hay sobre el proyecto X?", "Resume el documento más reciente."],
     theme="soft",
     submit_btn="Enviar"
+    # Removed clear_btn as it's not a valid parameter
 )
 
-# Alternative: Using gr.Blocks for more control
-def create_blocks_interface():
-    with gr.Blocks(theme="soft") as demo:
-        gr.Markdown("# My agent (FileSearch-powered)")
-        gr.Markdown(
-            "Este chat usa un agente con FileSearchTool. "
-            "Escribe tu pregunta y el agente buscará primero en el file search antes de responder."
-        )
-        
-        chatbot = gr.Chatbot()
-        msg = gr.Textbox(
-            label="Mensaje", 
-            placeholder="Escribe tu pregunta aquí...",
-            lines=2
-        )
-        
-        with gr.Row():
-            submit = gr.Button("Enviar", variant="primary")
-            clear = gr.Button("Limpiar")
-        
-        async def respond(message, chat_history):
-            # Add user message to chat history
-            chat_history.append((message, ""))
-            
-            # Stream the response
-            async for partial_response in agent_reply_stream(message, chat_history[:-1]):
-                chat_history[-1] = (message, partial_response)
-                yield "", chat_history
-        
-        submit.click(
-            respond, 
-            inputs=[msg, chatbot], 
-            outputs=[msg, chatbot],
-            queue=True
-        )
-        
-        msg.submit(
-            respond, 
-            inputs=[msg, chatbot], 
-            outputs=[msg, chatbot],
-            queue=True
-        )
-        
-        clear.click(
-            lambda: ([], ""), 
-            outputs=[chatbot, msg]
-        )
-        
-        # Example buttons
-        gr.Examples(
-            examples=[
-                "¿Qué información hay sobre el proyecto X?",
-                "Resume el documento más reciente."
-            ],
-            inputs=msg
-        )
-    
-    return demo
-
-# --- Launch the app ---
+# If you need to run the app
 if __name__ == "__main__":
-    # Option 1: Use ChatInterface (simpler but less control)
-    demo.launch(queue=True)  # Enable queue for streaming
-    
-    # Option 2: Use Blocks interface (more control)
-    # blocks_demo = create_blocks_interface()
-    # blocks_demo.launch(queue=True)
+    demo.launch()