prompts and gradio

Gradio_UI.py

@@ -0,0 +1,97 @@
+# gradio_UI.py
+
+import os
+import re
+import mimetypes
+import shutil
+from typing import Optional
+
+import gradio as gr
+
+from smolagents.agent_types import AgentText, AgentImage, AgentAudio, handle_agent_output_types
+from smolagents.agents import ActionStep, MultiStepAgent
+from smolagents.memory import MemoryStep
+from smolagents.utils import _is_package_available
+
+def pull_messages_from_step(step_log: MemoryStep):
+    if isinstance(step_log, ActionStep):
+        step_number = f"Step {step_log.step_number}" if step_log.step_number is not None else ""
+        yield gr.ChatMessage(role="assistant", content=f"**{step_number}**")
+
+        if hasattr(step_log, "model_output") and step_log.model_output is not None:
+            model_output = re.sub(r"```.?\s*<end_code>", "```", step_log.model_output.strip())
+            yield gr.ChatMessage(role="assistant", content=model_output)
+
+        if hasattr(step_log, "tool_calls") and step_log.tool_calls:
+            tool_call = step_log.tool_calls[0]
+            content = str(tool_call.arguments.get("answer", tool_call.arguments)) if isinstance(tool_call.arguments, dict) else str(tool_call.arguments)
+            if tool_call.name == "python_interpreter":
+                content = f"```python\n{re.sub(r'<end_code>', '', content).strip()}\n```"
+            tool_msg = gr.ChatMessage(
+                role="assistant",
+                content=content,
+                metadata={"title": f"🛠️ Used tool {tool_call.name}", "id": "tool_call", "status": "pending"},
+            )
+            yield tool_msg
+            if step_log.observations:
+                yield gr.ChatMessage(role="assistant", content=step_log.observations.strip(), metadata={"title": "📝 Execution Logs", "parent_id": "tool_call", "status": "done"})
+            if step_log.error:
+                yield gr.ChatMessage(role="assistant", content=str(step_log.error), metadata={"title": "💥 Error", "parent_id": "tool_call", "status": "done"})
+            tool_msg.metadata["status"] = "done"
+
+        elif step_log.error:
+            yield gr.ChatMessage(role="assistant", content=str(step_log.error), metadata={"title": "💥 Error"})
+
+        meta = f"<span style='color:#bbb;font-size:12px;'>Input tokens: {getattr(step_log, 'input_token_count', 0)} | Output tokens: {getattr(step_log, 'output_token_count', 0)} | Duration: {round(getattr(step_log, 'duration', 0), 2)}</span>"
+        yield gr.ChatMessage(role="assistant", content=meta)
+        yield gr.ChatMessage(role="assistant", content="-----")
+
+def stream_to_gradio(agent, task: str, reset_agent_memory: bool = False, additional_args: Optional[dict] = None):
+    total_input_tokens = 0
+    total_output_tokens = 0
+    for step_log in agent.run(task, stream=True, reset=reset_agent_memory, additional_args=additional_args):
+        if hasattr(agent.model, "last_input_token_count"):
+            total_input_tokens += agent.model.last_input_token_count
+            total_output_tokens += agent.model.last_output_token_count
+            if isinstance(step_log, ActionStep):
+                step_log.input_token_count = agent.model.last_input_token_count
+                step_log.output_token_count = agent.model.last_output_token_count
+        for message in pull_messages_from_step(step_log):
+            yield message
+    final_answer = handle_agent_output_types(step_log)
+    if isinstance(final_answer, AgentText):
+        yield gr.ChatMessage(role="assistant", content=f"**Final answer:**\n{final_answer.to_string()}")
+    elif isinstance(final_answer, AgentImage):
+        yield gr.ChatMessage(role="assistant", content={"path": final_answer.to_string(), "mime_type": "image/png"})
+    elif isinstance(final_answer, AgentAudio):
+        yield gr.ChatMessage(role="assistant", content={"path": final_answer.to_string(), "mime_type": "audio/wav"})
+    else:
+        yield gr.ChatMessage(role="assistant", content=f"**Final answer:** {str(final_answer)}")
+
+class GradioUI:
+    def __init__(self, agent: MultiStepAgent):
+        if not _is_package_available("gradio"):
+            raise ModuleNotFoundError("Please install 'gradio' with: pip install 'smolagents[gradio]'")
+        self.agent = agent
+
+    def interact_with_agent(self, prompt, messages):
+        messages.append(gr.ChatMessage(role="user", content=prompt))
+        yield messages
+        for msg in stream_to_gradio(self.agent, task=prompt):
+            messages.append(msg)
+            yield messages
+        yield messages
+
+    def launch(self):
+        with gr.Blocks(fill_height=True) as demo:
+            stored_messages = gr.State([])
+            chatbot = gr.Chatbot(label="🌍 Mood-Based Travel Agent", type="messages")
+            user_input = gr.Textbox(lines=1, label="Describe your mood")
+            user_input.submit(
+                lambda text, hist: (hist + [gr.ChatMessage(role="user", content=text)], ""),
+                [user_input, stored_messages],
+                [stored_messages, user_input],
+            ).then(self.interact_with_agent, [user_input, stored_messages], [chatbot])
+        demo.launch(debug=True, share=True)
+
+__all__ = ["GradioUI", "stream_to_gradio"]

prompts.yaml

@@ -1,59 +1,111 @@
-mood_to_need:
-  system: |
-    You are an expert in emotional intelligence and travel psychology. Your job is to analyze moods and translate them into underlying emotional needs that travel can fulfill. Think carefully about how moods map to internal motivations, and return a short and meaningful emotional driver.
-  prompt: |
-    The user's current mood is: {mood}.
-    What emotional need does this mood reflect? Think deeply and answer with a short phrase like: "to reconnect", "to escape", "to explore".
-
-need_to_destination:
-  system: |
-    You are a thoughtful travel agent who reflects on your suggestions before finalizing them.
-    First generate a destination, then **evaluate if it matches the emotional need** and revise if needed.
-
-  prompt: |
-    The user has the emotional need: {need}.
-    First, suggest a city/country and local activity.
-    Then, reflect: does this destination really align with the need?
-    If not, suggest a better one.
-
-    Format your final answer in valid JSON:
-    {"city": "...", "country": "...", "activity": "..."}
-
-get_weather:
-  system: |
-    You are a weather evaluation tool for decision-making agents. Your role is not only to inform, but to allow the agent to decide whether to keep or change the selected destination.
-  prompt: |
-    Retrieve the current weather forecast for {city}, {country}. Return it concisely like: "Sunny with light winds, 24°C." This may help determine if another destination should be considered.
-
-get_flights:
-  system: |
-    You are a travel assistant connected to Skyscanner. Return a list of flights from the given origin to the destination. This information supports final decision-making.
-  prompt: |
-    Find flights from {origin} to {destination.city}, {destination.country}. Return 2–3 options including departure time and airline. Exclude prices.
-
-final_wrap:
-  system: |
-    You are a poetic and empathetic travel writer. Your job is to compose a final message based on mood, emotional need, destination, activity, weather, and flight options — **only if the destination is acceptable**.
-  prompt: |
-    Create a warm, vivid, and uplifting message for a user feeling: {mood}.
-    Their emotional need is: {need}.
-    The destination is {destination.city}, {destination.country}.
-    The activity is: {destination.activity}.
-    The weather is: {weather}.
-    Flights available: {flights}.
-
-    Your message should encourage this journey and explain why it's the perfect match. Use 3–5 poetic and emotionally charged sentences. Focus on experience, not prices.
-
-quote_from_mood:
-  system: |
-    You are a reflective agent. Based on the user's mood, you will choose an uplifting or thoughtful quote to reinforce emotional alignment.
-  prompt: |
-    The user is currently feeling: {mood}.
-    Provide a matching quote (include author). Format: "Quote" — Author
+system_prompt: |-
+  You are a world-class travel assistant agent named WanderMind, built to help users find the perfect destination based on their mood.
+  You operate in an autonomous, multi-step thinking loop using Thought → Code → Observation.
+
+  Your job is to:
+  - Reflect on the user’s mood
+  - Infer their emotional need
+  - Suggest a travel destination with a matching activity
+  - Check the weather
+  - Decide whether the weather suits the emotional need
+  - If not, suggest another destination
+  - Once happy, find flights from the origin
+  - Wrap everything into an inspirational message
+  - Optionally, add a quote based on the mood
+
+  You must solve the full task by reasoning, calling tools or managed agents if needed, and writing Python code in the Code block.
+
+  Each step should follow this format:
+
+  Thought: explain what you will do and why.
+  Code:
+  ⁠ py
+  # your code here
+   ⁠<end_code>
+  Observation: result of previous code
+
+  You must output a final result using ⁠ final_answer() ⁠.
+
+  Your available tools are:
+  - mood_to_need(mood: str) → str: Extracts the emotional need behind a mood (e.g., "to reconnect").
+  - need_to_destination(need: str) → dict: Suggests a destination and activity for that need. Returns JSON with keys 'city', 'country', 'activity'.
+  - weather_forecast(location: str) → str: Gets current weather forecast.
+  - get_flights(origin: str, destination: str) → str: Lists flights between two cities.
+  - quote_from_mood(mood: str) → str: Provides a motivational quote based on mood.
+  - final_wrap(mood, need, destination, activity, weather, flights) → str: Composes final inspirational message.
+  - final_answer(output: Any): Ends the task and returns the final result.
+
+  DO NOT use a tool unless needed. Plan your steps clearly. You can retry with different inputs if the weather is bad.
+
+  Now begin!
+  
+planning:
+  initial_facts: |-
+    ### 1. Facts given in the task
+    - The user provides their mood.
+    
+    ### 2. Facts to look up
+    - Emotional need based on mood.
+    - Destination and activity based on need.
+    - Current weather at destination.
+    - Flights from user origin to destination.
+    - Quote for mood.
+
+    ### 3. Facts to derive
+    - Whether the weather fits the emotional need.
+    - If not, re-iterate destination choice.
+    - Final wrap-up message to user.
+
+  initial_plan: |-
+    1. Extract emotional need from user mood using mood_to_need().
+    2. Suggest destination and activity using need_to_destination().
+    3. Get weather at destination with weather_forecast().
+    4. Assess if weather suits the need. If not, return to step 2.
+    5. Get flights using get_flights().
+    6. Generate quote using quote_from_mood().
+    7. Compose final message using final_wrap().
+    8. Call final_answer() with all outputs.
+    <end_plan>
+
+
+  update_facts_pre_messages: |-
+    ### 1. Facts given in the task
+    ### 2. Facts that we have learned
+    ### 3. Facts still to look up
+    ### 4. Facts still to derive
+
+  update_facts_post_messages: |-
+    Please update your facts:
+    ### 1. Facts given in the task
+    ### 2. Facts that we have learned
+    ### 3. Facts still to look up
+    ### 4. Facts still to derive
+
+  update_plan_pre_messages: |-
+    Below is your current task and history. Please write a new plan based on the updated facts.
+
+  update_plan_post_messages: |-
+    Write a clean new plan with the latest facts. You must respect tool usage rules.
+
+managed_agent:
+  task: |-
+    You are a helpful sub-agent named '{{name}}'.
+    Your manager gives you this task:
+    {{task}}
+
+    You MUST return:
+    ### 1. Task outcome (short version):
+    ### 2. Task outcome (extremely detailed version):
+    ### 3. Additional context (if any)
+
+    Wrap everything in a final_answer().
+
+  report: |-
+    Final answer from agent '{{name}}':
+    {{final_answer}}
 
 final_answer:
-  system: |
-    You are a coordinator that combines outputs from all other tools into a single answer.
-  prompt: |
-    Combine the poetic travel message, quote, and a concise recap (destination, activity, weather, flights).
-    Ensure clarity, friendliness, and emotional alignment. Present this as a final, complete output to the user.
+  pre_messages: |-
+    Let's summarize everything before presenting the final answer:
+  post_messages: |-
+    Here's your final result. Enjoy your journey!