Update app.py

app.py

@@ -6,7 +6,6 @@ import gradio as gr
 import openai
 
 # -------------------- CONFIGURATION --------------------
-# Use environment variables for security (set them before running)
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "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")
 OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY", "")  # Optional, for live weather
 
@@ -50,8 +49,7 @@ def get_weather(city: str) -> dict:
         data = resp.json()
         if resp.status_code != 200:
             return {"error": f"Weather API error: {data.get('message', 'unknown')}"}
-        # Extract relevant fields
-        weather_info = {
+        return {
             "city": city,
             "temperature": data["main"]["temp"],
             "condition": data["weather"][0]["description"],
@@ -59,7 +57,6 @@ def get_weather(city: str) -> dict:
             "wind_speed": data["wind"]["speed"],
             "precipitation": data.get("rain", {}).get("1h", 0)
         }
-        return weather_info
     except Exception as e:
         return {"error": f"Weather service unavailable: {str(e)}"}
 
@@ -96,52 +93,6 @@ def get_attractions(city: str) -> dict:
     else:
         return {"error": f"No attractions data available for {city}.", "city": city}
 
-def compose_itinerary(city: str, weather: dict, attractions: list, budget: dict = None) -> str:
-    """
-    Generate a day trip itinerary using the tool outputs.
-    Calls OpenAI to format the plan based on verified data.
-    """
-    # Build context string
-    weather_text = f"{weather['condition'].capitalize()}, {weather['temperature']}°C"
-    if weather.get('precipitation', 0) > 0:
-        weather_text += f", chance of rain {weather['precipitation']}mm"
-    if "note" in weather:
-        weather_text += f" ({weather['note']})"
-
-    attractions_text = "\n".join([
-        f"- {a['name']} ({a['type']}, ~{a['duration_hours']} hrs, entry: {a['entry_fee']} {a.get('currency', '')})"
-        for a in attractions
-    ])
-
-    budget_text = ""
-    if budget and "error" not in budget:
-        budget_text = f"Budget: {budget['amount']} {budget['from']} (approx. {budget['converted']} {budget['to']} in local currency)"
-
-    prompt = f"""
-You are a travel assistant. Create a one-day itinerary for {city} based on the following verified information.
-
-Weather: {weather_text}
-Attractions available:
-{attractions_text}
-{budget_text}
-
-The itinerary should:
-- Be realistic given the weather (e.g., outdoor activities if sunny, indoor if rain).
-- Sequence attractions logically (considering location and opening hours if known).
-- Include estimated times for each activity.
-- Suggest meal times and local food options (use common knowledge, do not invent specific restaurants).
-- If a budget is provided, mention if attractions have entry fees and stay within budget.
-- Use markdown for readability (headings, bullet points, emojis).
-
-Return only the itinerary.
-"""
-    response = client.chat.completions.create(
-        model="gpt-3.5-turbo",
-        messages=[{"role": "user", "content": prompt}],
-        temperature=0.7
-    )
-    return response.choices[0].message.content
-
 # -------------------- TOOL SCHEMAS FOR OPENAI --------------------
 tools = [
     {
@@ -188,63 +139,73 @@ tools = [
             }
         }
     }
-    # Note: compose_itinerary is not exposed as a tool; it's called by the agent after gathering data.
 ]
 
 # -------------------- AGENT ORCHESTRATION --------------------
 def run_agent(user_message, history):
     """
-    Main agent loop: maintains conversation, calls tools, and finally generates itinerary.
+    Main agent loop: maintains conversation, calls tools, and returns final answer.
     """
-    # System prompt that guides the agent
+    # System prompt with clear instructions
     system_prompt = """You are a helpful travel planning assistant. You have access to tools that can:
 - Get current weather for a city
 - Convert currency
 - Retrieve tourist attractions for a city
 
-Your goal is to help the user plan a day trip. If the user's request is missing information (e.g., city, budget, currency), ask clarifying questions.
-When you have gathered all necessary data (city, weather, attractions, and optionally budget), call the appropriate tools to fetch the data, then use that information to compose a final itinerary.
-Do not invent any data; only use the tool outputs.
-Be friendly, concise, and helpful."""
+Your goal is to help the user plan a day trip. Follow these steps:
+1. If the user's request is missing essential information (city, budget, currency, etc.), ask clarifying questions.
+2. Once you have all necessary details, call the appropriate tools to fetch real-time data.
+3. After receiving tool results, use that information to compose a detailed, day-long itinerary.
+4. Do not invent any data; only use the tool outputs.
+5. Be friendly, concise, and helpful. Use markdown for readability (headings, bullet points, emojis)."""
 
+    # Build message list from history
     messages = [{"role": "system", "content": system_prompt}]
-    # Add conversation history (Gradio passes history as list of [user, assistant] pairs)
     for user_msg, asst_msg in history:
         messages.append({"role": "user", "content": user_msg})
         if asst_msg:
             messages.append({"role": "assistant", "content": asst_msg})
     messages.append({"role": "user", "content": user_message})
 
-    # We'll collect tool outputs in a dict for later use
-    tool_outputs = {}
+    # Debug: print the conversation so far
+    print("\n" + "="*50)
+    print("USER MESSAGE:", user_message)
+    print("="*50)
+
+    # Iterate up to 5 turns (to prevent infinite loops)
+    for turn in range(5):
+        print(f"\n--- Turn {turn+1} ---")
+        try:
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",  # You can change to "gpt-4" if available
+                messages=messages,
+                tools=tools,
+                tool_choice="auto"
+            )
+        except Exception as e:
+            error_msg = f"OpenAI API error: {str(e)}"
+            print(error_msg)
+            return error_msg
 
-    # Max iterations to prevent infinite loops
-    for _ in range(5):
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=messages,
-            tools=tools,
-            tool_choice="auto"
-        )
         msg = response.choices[0].message
 
         # If the model wants to call tools
         if msg.tool_calls:
+            print(f"Model requested {len(msg.tool_calls)} tool call(s).")
             # Add assistant message with tool calls to history
             messages.append(msg)
             for tool_call in msg.tool_calls:
                 func_name = tool_call.function.name
                 args = json.loads(tool_call.function.arguments)
+                print(f"  Calling {func_name} with args: {args}")
+
                 # Execute the tool
                 if func_name == "get_weather":
                     result = get_weather(args["city"])
-                    tool_outputs["weather"] = result
                 elif func_name == "convert_currency":
                     result = convert_currency(args["amount"], args["from_currency"], args["to_currency"])
-                    tool_outputs["budget"] = result
                 elif func_name == "get_attractions":
                     result = get_attractions(args["city"])
-                    tool_outputs["attractions"] = result
                 else:
                     result = {"error": "Unknown tool"}
 
@@ -254,27 +215,17 @@ Be friendly, concise, and helpful."""
                     "tool_call_id": tool_call.id,
                     "content": json.dumps(result)
                 })
-            # Continue loop to let model process tool responses
+                print(f"    Result: {result}")
+            # Continue the loop so the model can see the tool results
             continue
         else:
-            # No tool calls: either final answer or clarification request
+            # No tool calls: this is the final answer (or a clarification)
             final_text = msg.content
-            # If we have all necessary data, we might want to generate the itinerary via compose_itinerary
-            # But the model may already have done it if we instructed it to.
-            # To be safe, we can check if we have weather and attractions, and then call compose_itinerary.
-            if "weather" in tool_outputs and "attractions" in tool_outputs and "error" not in tool_outputs["attractions"]:
-                # We have the data, generate itinerary
-                city = tool_outputs["attractions"]["city"]
-                weather = tool_outputs["weather"]
-                attractions = tool_outputs["attractions"]["attractions"]
-                budget = tool_outputs.get("budget")
-                itinerary = compose_itinerary(city, weather, attractions, budget)
-                return itinerary
-            else:
-                # Model's response is a clarification or intermediate answer
-                return final_text
+            print(f"Final answer: {final_text[:100]}...")  # print first 100 chars
+            return final_text
 
-    return "I'm having trouble processing your request. Please try again."
+    # If we exit the loop without returning, something went wrong
+    return "I'm having trouble processing your request. Please try again or rephrase."
 
 # -------------------- GRADIO INTERFACE --------------------
 def chat_interface(message, history):
@@ -293,7 +244,6 @@ with gr.Blocks(title="TouristGuide AI Agent") as demo:
     Your personal travel planner powered by AI and real-time tools.  
     Ask for a day trip itinerary in any supported city (Kigali, Kampala, Nairobi, etc.) with optional budget and currency conversion.
     """)
-    # Removed bubble_full_width (no longer supported)
     chatbot = gr.Chatbot(label="Conversation", height=500)
     msg = gr.Textbox(label="Your message", placeholder="e.g., Plan a day trip in Kigali with a budget of 150 USD", lines=2)
     clear = gr.Button("Clear conversation")
@@ -307,5 +257,4 @@ with gr.Blocks(title="TouristGuide AI Agent") as demo:
     clear.click(lambda: None, None, chatbot, queue=False)
 
 if __name__ == "__main__":
-    # Pass css to launch() as per Gradio 6.0+
     demo.launch(share=False, server_name="0.0.0.0", css=css)