Updated App

app.py

@@ -9,14 +9,14 @@ from langchain_core.prompts import ChatPromptTemplate
 from langchain_openai import ChatOpenAI
 from browser_use import Agent
 
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────────────
 # 1) Load environment
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────────────
 load_dotenv()
 
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────────────
 # 2) Helper to get ChatOpenAI from environment
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────────────
 def get_llm():
     """Returns a ChatOpenAI instance using the OPENAI_API_KEY from environment."""
     return ChatOpenAI(
@@ -32,18 +32,18 @@ def get_llm_browser():
         openai_api_key=os.getenv("OPENAI_API_KEY")
     )
 
-# ──────────────────────────────────────────────────────────────────────────
-# 3) TypedDict for internal state
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────────────
+# 3) TypedDict for state
+# ─────────────────────────────────────────────────────────────────────
 class State(TypedDict):
     query: str
     category: str
     sentiment: str
     response: str
 
-# ──────────────────────────────────────────────────────────────────────────
-# 4) Individual node-like functions
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────────────
+# 4) "Node" functions
+# ─────────────────────────────────────────────────────────────────────
 
 def categorize(state: State) -> State:
     prompt = ChatPromptTemplate.from_template(
@@ -85,20 +85,27 @@ def handle_billing(state: State) -> State:
     return state
 
 async def run_browser_agent(task: str) -> str:
-    """Helper to run the browser-use Agent asynchronously."""
+    """
+    Helper to run the browser-use Agent asynchronously.
+    Because we're already in an event loop, we just 'await agent.run()'.
+    """
     agent = Agent(task=task, llm=get_llm_browser())
     result = await agent.run()
     return result
 
-def handle_general(state: State) -> State:
-    """For general queries, we use the browser agent to consult online resources."""
+# Make 'handle_general' async so it can 'await run_browser_agent(...)'
+async def handle_general(state: State) -> State:
+    """
+    For general queries, we use the browser agent to consult online resources.
+    """
     task = (
         "You are a customer support agent that consults online sources. "
         f"Provide a detailed, informed response to this customer query: {state['query']}"
     )
-    result = asyncio.run(run_browser_agent(task))
-    final_text = ""
+    # Directly await run_browser_agent(...) with no asyncio.run()
+    result = await run_browser_agent(task)
 
+    final_text = ""
     if isinstance(result, str):
         final_text = result.strip()
     elif hasattr(result, "all_results"):
@@ -131,71 +138,70 @@ def route_query(state: State) -> str:
     else:
         return "handle_general"
 
-# ──────────────────────────────────────────────────────────────────────────
-# 5) A simple "workflow" function (manual, no langgraph)
-# ──────────────────────────────────────────────────────────────────────────
-
-def run_workflow(state: State) -> State:
+# ─────────────────────────────────────────────────────────────────────
+# 5) A manual workflow function in async
+# ─────────────────────────────────────────────────────────────────────
+async def run_workflow(state: State) -> State:
     """
-    Manually steps through:
+    Steps:
       1) categorize
-      2) sentiment
+      2) analyze_sentiment
       3) route
-      4) handle_x or escalate
+      4) run the appropriate function (some are sync, some are async)
     """
     # Step 1
     state = categorize(state)
     # Step 2
     state = analyze_sentiment(state)
-    # Step 3 - route
+    # Step 3
     next_step = route_query(state)
-    
+
+    # Step 4
     if next_step == "handle_technical":
-        state = handle_technical(state)
+        state = handle_technical(state)  # sync function
     elif next_step == "handle_billing":
-        state = handle_billing(state)
+        state = handle_billing(state)    # sync function
     elif next_step == "handle_general":
-        state = handle_general(state)
+        # handle_general is async, so we must 'await' it
+        state = await handle_general(state)
     else:
+        # escalate is sync
         state = escalate(state)
-    
-    return state
 
-# ──────────────────────────────────────────────────────────────────────────
-# 6) Gradio callback
-# ──────────────────────────────────────────────────────────────────────────
+    return state
 
+# ─────────────────────────────────────────────────────────────────────
+# 6) Gradio callback (async)
+# ─────────────────────────────────────────────────────────────────────
 async def run_customer_support(query: str, api_key: str = "") -> str:
     """
-    Main function called by Gradio upon submit.
-    - If user provided an API key, set it in the environment.
-    - Then run the manual "workflow" on the user's query.
-    - Return the final response from the final state.
+    Called by Gradio upon submit. We do:
+      - Possibly set OS env for OPENAI_API_KEY
+      - Create initial state
+      - 'await run_workflow(...)'
+      - Return final answer
     """
-    # Check key
     if not api_key and not os.getenv("OPENAI_API_KEY"):
         return "Error: Please provide an OpenAI API key."
-    
-    # Set user-provided key
+
     if api_key:
         os.environ["OPENAI_API_KEY"] = api_key
 
     try:
-        # Initialize the state
         state: State = {
             "query": query,
             "category": "",
             "sentiment": "",
             "response": ""
         }
-        final_state = run_workflow(state)  # Manually run the chain of steps
+        final_state = await run_workflow(state)
         return final_state["response"]
     except Exception as e:
         return f"Error: {str(e)}"
 
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────���───────────────
 # 7) Build the Gradio UI
-# ──────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────────────
 with gr.Blocks(title="Customer Support Agent with Browser Use") as demo:
     gr.Markdown("# Customer Support Agent with Browser Use")
     gr.Markdown(
@@ -223,7 +229,7 @@ with gr.Blocks(title="Customer Support Agent with Browser Use") as demo:
                 interactive=False
             )
 
-    # The order of inputs in submit_btn.click must match run_customer_support signature
+    # The callback is async; Gradio can handle async if the function is declared async.
     submit_btn.click(
         fn=run_customer_support,
         inputs=[query_input, api_key_input],