implement pink glasses

.gitignore

@@ -0,0 +1 @@
+/.env

Gradio_UI.py

@@ -1,18 +1,5 @@
 #!/usr/bin/env python
 # coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
 import mimetypes
 import os
 import re
@@ -24,11 +11,12 @@ 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,
-):
-    """Extract ChatMessage objects from agent steps with proper nesting"""
+def pull_messages_from_step(step_log: MemoryStep):
+    """
+    Extract ChatMessage objects from agent steps with proper nesting.
+    This is where we transform the agent's step-by-step reasoning,
+    tool calls, and logs into user-friendly gradio ChatMessage objects.
+    """
     import gradio as gr
 
     if isinstance(step_log, ActionStep):
@@ -40,21 +28,21 @@ def pull_messages_from_step(
         if hasattr(step_log, "model_output") and step_log.model_output is not None:
             # Clean up the LLM output
             model_output = step_log.model_output.strip()
-            # Remove any trailing <end_code> and extra backticks, handling multiple possible formats
-            model_output = re.sub(r"```\s*<end_code>", "```", model_output)  # handles ```<end_code>
-            model_output = re.sub(r"<end_code>\s*```", "```", model_output)  # handles <end_code>```
-            model_output = re.sub(r"```\s*\n\s*<end_code>", "```", model_output)  # handles ```\n<end_code>
+            # Remove any trailing <end_code> and extra backticks
+            model_output = re.sub(r"```\s*<end_code>", "```", model_output)
+            model_output = re.sub(r"<end_code>\s*```", "```", model_output)
+            model_output = re.sub(r"```\s*\n\s*<end_code>", "```", model_output)
             model_output = model_output.strip()
+
             yield gr.ChatMessage(role="assistant", content=model_output)
 
-        # For tool calls, create a parent message
+        # For tool calls
         if hasattr(step_log, "tool_calls") and step_log.tool_calls is not None:
             first_tool_call = step_log.tool_calls[0]
             used_code = first_tool_call.name == "python_interpreter"
             parent_id = f"call_{len(step_log.tool_calls)}"
 
-            # Tool call becomes the parent message with timing info
-            # First we will handle arguments based on type
+            # Display the arguments used for the tool call
             args = first_tool_call.arguments
             if isinstance(args, dict):
                 content = str(args.get("answer", str(args)))
@@ -62,9 +50,9 @@ def pull_messages_from_step(
                 content = str(args).strip()
 
             if used_code:
-                # Clean up the content by removing any end code tags
-                content = re.sub(r"```.*?\n", "", content)  # Remove existing code blocks
-                content = re.sub(r"\s*<end_code>\s*", "", content)  # Remove end_code tags
+                # Clean up content by removing code blocks
+                content = re.sub(r"```.*?\n", "", content)
+                content = re.sub(r"\s*<end_code>\s*", "", content)
                 content = content.strip()
                 if not content.startswith("```python"):
                     content = f"```python\n{content}\n```"
@@ -80,20 +68,22 @@ def pull_messages_from_step(
             )
             yield parent_message_tool
 
-            # Nesting execution logs under the tool call if they exist
-            if hasattr(step_log, "observations") and (
-                step_log.observations is not None and step_log.observations.strip()
-            ):  # Only yield execution logs if there's actual content
+            # Observations or logs from the tool call
+            if hasattr(step_log, "observations") and step_log.observations is not None and step_log.observations.strip():
                 log_content = step_log.observations.strip()
                 if log_content:
                     log_content = re.sub(r"^Execution logs:\s*", "", log_content)
                     yield gr.ChatMessage(
                         role="assistant",
-                        content=f"{log_content}",
-                        metadata={"title": "📝 Execution Logs", "parent_id": parent_id, "status": "done"},
+                        content=log_content,
+                        metadata={
+                            "title": "📝 Execution Logs",
+                            "parent_id": parent_id,
+                            "status": "done",
+                        },
                     )
 
-            # Nesting any errors under the tool call
+            # Handle any errors
             if hasattr(step_log, "error") and step_log.error is not None:
                 yield gr.ChatMessage(
                     role="assistant",
@@ -101,46 +91,48 @@ def pull_messages_from_step(
                     metadata={"title": "💥 Error", "parent_id": parent_id, "status": "done"},
                 )
 
-            # Update parent message metadata to done status without yielding a new message
             parent_message_tool.metadata["status"] = "done"
 
-        # Handle standalone errors but not from tool calls
+        # Standalone errors
         elif hasattr(step_log, "error") and step_log.error is not None:
             yield gr.ChatMessage(role="assistant", content=str(step_log.error), metadata={"title": "💥 Error"})
 
-        # Calculate duration and token information
+        # Token counts, durations, etc.
         step_footnote = f"{step_number}"
         if hasattr(step_log, "input_token_count") and hasattr(step_log, "output_token_count"):
             token_str = (
-                f" | Input-tokens:{step_log.input_token_count:,} | Output-tokens:{step_log.output_token_count:,}"
+                f" | Input-tokens:{step_log.input_token_count:,} "
+                f"| Output-tokens:{step_log.output_token_count:,}"
             )
             step_footnote += token_str
         if hasattr(step_log, "duration"):
-            step_duration = f" | Duration: {round(float(step_log.duration), 2)}" if step_log.duration else None
-            step_footnote += step_duration
-        step_footnote = f"""<span style="color: #bbbbc2; font-size: 12px;">{step_footnote}</span> """
-        yield gr.ChatMessage(role="assistant", content=f"{step_footnote}")
+            step_duration = (
+                f" | Duration: {round(float(step_log.duration), 2)}"
+                if step_log.duration
+                else None
+            )
+            step_footnote += step_duration if step_duration else ""
+        step_footnote_html = f"""<span style="color: #bbbbc2; font-size: 12px;">{step_footnote}</span> """
+        yield gr.ChatMessage(role="assistant", content=f"{step_footnote_html}")
         yield gr.ChatMessage(role="assistant", content="-----")
 
 
-def stream_to_gradio(
-    agent,
-    task: str,
-    reset_agent_memory: bool = False,
-    additional_args: Optional[dict] = None,
-):
-    """Runs an agent with the given task and streams the messages from the agent as gradio ChatMessages."""
+def stream_to_gradio(agent, task: str, reset_agent_memory: bool = False, additional_args: Optional[dict] = None):
+    """
+    Runs an agent with the given task and streams the messages as gradio ChatMessages.
+    """
     if not _is_package_available("gradio"):
         raise ModuleNotFoundError(
-            "Please install 'gradio' extra to use the GradioUI: `pip install 'smolagents[gradio]'`"
+            "Please install 'gradio' extra to use Gradio: `pip install 'smolagents[gradio]'`"
         )
     import gradio as gr
 
     total_input_tokens = 0
     total_output_tokens = 0
 
+    # Run the agent in streaming mode
     for step_log in agent.run(task, stream=True, reset=reset_agent_memory, additional_args=additional_args):
-        # Track tokens if model provides them
+        # If the model tracks token usage:
         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
@@ -148,66 +140,73 @@ def stream_to_gradio(
                 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,
-        ):
+        # Convert each step into user-friendly messages
+        for message in pull_messages_from_step(step_log):
             yield message
 
-    final_answer = step_log  # Last log is the run's final_answer
+    # The last step_log is presumably the final answer
+    final_answer = step_log
     final_answer = handle_agent_output_types(final_answer)
 
-    if isinstance(final_answer, AgentText):
-        yield gr.ChatMessage(
-            role="assistant",
-            content=f"**Final answer:**\n{final_answer.to_string()}\n",
-        )
-    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)}")
+    # Convert the final_answer into a string for the user
+    final_answer_str = getattr(final_answer, "final_answer", "")
+    final_answer_str = f"\n{final_answer_str}\n"
 
+    # Yield one last message containing the final answer
+    yield gr.ChatMessage(role="assistant", content=final_answer_str)
 
-class GradioUI:
-    """A one-line interface to launch your agent in Gradio"""
+    return final_answer_str
 
-    def __init__(self, agent: MultiStepAgent, file_upload_folder: str | None = None):
+
+class GradioUI:
+    """
+    A one-line interface to launch your agent in Gradio.
+    Features:
+    - Chatbot panel for user messages and step-by-step agent reasoning
+    - 'Final Answer' section that clearly shows the final result
+    - (Optional) file upload for extra data the agent might use
+    """
+
+    def __init__(self, agent: MultiStepAgent, file_upload_folder: Optional[str] = None):
         if not _is_package_available("gradio"):
             raise ModuleNotFoundError(
-                "Please install 'gradio' extra to use the GradioUI: `pip install 'smolagents[gradio]'`"
+                "Please install 'gradio' extra to use Gradio: `pip install 'smolagents[gradio]'`"
             )
         self.agent = agent
         self.file_upload_folder = file_upload_folder
-        if self.file_upload_folder is not None:
-            if not os.path.exists(file_upload_folder):
-                os.mkdir(file_upload_folder)
+        if self.file_upload_folder is not None and not os.path.exists(file_upload_folder):
+            os.mkdir(file_upload_folder)
 
-    def interact_with_agent(self, prompt, messages):
+    def interact_with_agent(self, prompt, messages, final_answer_state):
+        """
+        This function is called whenever the user submits a new query.
+        We append the user's message to the chat, then stream the agent's steps
+        back to the chatbot widget, and finally store the final answer.
+        """
         import gradio as gr
 
+        # Add the user's new message to the conversation
         messages.append(gr.ChatMessage(role="user", content=prompt))
-        yield messages
+        yield messages, final_answer_state
+
+        # Stream out each step of the agent's process
         for msg in stream_to_gradio(self.agent, task=prompt, reset_agent_memory=False):
             messages.append(msg)
-            yield messages
-        yield messages
+            yield messages, final_answer_state
+
+        # Update the final answer state once the agent is done
+        final_answer_state = msg.content if isinstance(msg, gr.ChatMessage) else ""
+        yield messages, final_answer_state
 
     def upload_file(
-        self,
-        file,
-        file_uploads_log,
-        allowed_file_types=[
-            "application/pdf",
-            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            "text/plain",
-        ],
+            self,
+            file,
+            file_uploads_log,
+            allowed_file_types=[
+                "application/pdf",
+                "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                "text/plain",
+            ],
     ):
         """
         Handle file uploads, default allowed types are .pdf, .docx, and .txt
@@ -217,80 +216,118 @@ class GradioUI:
         if file is None:
             return gr.Textbox("No file uploaded", visible=True), file_uploads_log
 
+        # Attempt to detect mime type
         try:
             mime_type, _ = mimetypes.guess_type(file.name)
         except Exception as e:
             return gr.Textbox(f"Error: {e}", visible=True), file_uploads_log
 
+        # Check if file is allowed
         if mime_type not in allowed_file_types:
             return gr.Textbox("File type disallowed", visible=True), file_uploads_log
 
-        # Sanitize file name
+        # Sanitize and rename
         original_name = os.path.basename(file.name)
-        sanitized_name = re.sub(
-            r"[^\w\-.]", "_", original_name
-        )  # Replace any non-alphanumeric, non-dash, or non-dot characters with underscores
+        sanitized_name = re.sub(r"[^\w\-.]", "_", original_name)
 
         type_to_ext = {}
         for ext, t in mimetypes.types_map.items():
             if t not in type_to_ext:
                 type_to_ext[t] = ext
 
-        # Ensure the extension correlates to the mime type
-        sanitized_name = sanitized_name.split(".")[:-1]
-        sanitized_name.append("" + type_to_ext[mime_type])
-        sanitized_name = "".join(sanitized_name)
+        # Append the correct extension for the mime type
+        base_name = ".".join(sanitized_name.split(".")[:-1])
+        extension = type_to_ext.get(mime_type, "")
+        final_name = f"{base_name}{extension}".strip()
 
-        # Save the uploaded file to the specified folder
-        file_path = os.path.join(self.file_upload_folder, os.path.basename(sanitized_name))
+        # Save the file
+        file_path = os.path.join(self.file_upload_folder, os.path.basename(final_name))
         shutil.copy(file.name, file_path)
 
         return gr.Textbox(f"File uploaded: {file_path}", visible=True), file_uploads_log + [file_path]
 
     def log_user_message(self, text_input, file_uploads_log):
-        return (
-            text_input
-            + (
-                f"\nYou have been provided with these files, which might be helpful or not: {file_uploads_log}"
-                if len(file_uploads_log) > 0
-                else ""
-            ),
-            "",
-        )
+        """
+        Combines the user's text input with any file references.
+        We pass this along to the agent so it knows about available files.
+        """
+        combined_input = text_input
+        if file_uploads_log:
+            combined_input += f"\nYou have been provided these files: {file_uploads_log}"
+        return combined_input, ""
 
     def launch(self, **kwargs):
+        """
+        Build and launch the Gradio Blocks interface with:
+          - A Markdown introduction
+          - A chat panel
+          - A file upload option (optional)
+          - A final answer panel
+          - Example usage instructions
+        """
         import gradio as gr
 
-        with gr.Blocks(fill_height=True) as demo:
-            stored_messages = gr.State([])
-            file_uploads_log = gr.State([])
-            chatbot = gr.Chatbot(
-                label="Agent",
-                type="messages",
-                avatar_images=(
-                    None,
-                    "https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/Alfred.png",
-                ),
-                resizeable=True,
-                scale=1,
-            )
-            # If an upload folder is provided, enable the upload feature
-            if self.file_upload_folder is not None:
-                upload_file = gr.File(label="Upload a file")
-                upload_status = gr.Textbox(label="Upload Status", interactive=False, visible=False)
-                upload_file.change(
-                    self.upload_file,
-                    [upload_file, file_uploads_log],
-                    [upload_status, file_uploads_log],
-                )
-            text_input = gr.Textbox(lines=1, label="Chat Message")
-            text_input.submit(
-                self.log_user_message,
-                [text_input, file_uploads_log],
-                [stored_messages, text_input],
-            ).then(self.interact_with_agent, [stored_messages, chatbot], [chatbot])
+        with gr.Blocks() as demo:
+            # Heading and instructions
+            gr.Markdown("""
+            # 😎 Pink Glasses Agent ☀️  
+            A cheerful AI that filters out negativity and shares only uplifting, feel-good responses.  
+            
+            Ask anything — the agent thinks step by step and delivers a happy final answer. It can also fetch the latest news using the `fetch_news` tool powered by DuckDuckGo.
+
+            ---
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    stored_messages = gr.State([])
+                    file_uploads_log = gr.State([])
+                    final_answer_state = gr.State("")
+
+                    chatbot = gr.Chatbot(
+                        label="Pink Glasses Agent",
+                        type="messages",
+                        avatar_images=(None, "https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/Alfred.png"),
+                        height=500,
+                    )
 
-        demo.launch(debug=True, share=True, **kwargs)
+                    # Optional file upload
+                    if self.file_upload_folder is not None:
+                        upload_file = gr.File(label="Upload a file")
+                        upload_status = gr.Textbox(label="Upload Status", interactive=False, visible=False)
+                        upload_file.change(
+                            self.upload_file,
+                            [upload_file, file_uploads_log],
+                            [upload_status, file_uploads_log],
+                        )
+
+                    text_input = gr.Textbox(lines=1, label="Your Input")
+                    text_input.submit(
+                        self.log_user_message,
+                        [text_input, file_uploads_log],
+                        [stored_messages, text_input],
+                    ).then(
+                        self.interact_with_agent,
+                        [stored_messages, chatbot, final_answer_state],
+                        [chatbot, final_answer_state],
+                    )
 
+                with gr.Column():
+                    final_answer_display = gr.Markdown("## Final Answer")
+                    final_answer_state.change(
+                        lambda state: f"## Final Answer\n\n{state}",
+                        inputs=final_answer_state,
+                        outputs=final_answer_display,
+                    )
+
+            gr.Markdown("""
+            ---
+            # Example Usage
+            - **Ask about the latest news**: 
+              > "What's going on in the world right now?"
+            - **Use Tools**: 
+              The agent can fetch the latest news using DuckDuckGo.
+            """)
 
-__all__ = ["stream_to_gradio", "GradioUI"]
+        # Optional: share=True if you want a public link
+        demo.launch(debug=True, share=True, **kwargs)

README.md

@@ -1,5 +1,5 @@
 ---
-title: First Agent Template
+title: UpliftBot – The Pink Glasses Agent 🌸
 emoji: ⚡
 colorFrom: pink
 colorTo: yellow
@@ -7,12 +7,15 @@ sdk: gradio
 sdk_version: 5.23.1
 app_file: app.py
 pinned: false
+short_description: Shares only positive, joyful, and encouraging messages.
 tags:
-- smolagents
-- agent
-- smolagent
-- tool
-- agent-course
+  - smolagents
+  - agent
+  - smolagent
+  - tool
+  - agent-course
+  - positive-agent
+  - pink-glasses
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -3,6 +3,8 @@ import datetime
 import requests
 import pytz
 import yaml
+
+from tools.fetch_news import FetchNewsTool
 from tools.final_answer import FinalAnswerTool
 
 from Gradio_UI import GradioUI
@@ -35,6 +37,7 @@ def get_current_time_in_timezone(timezone: str) -> str:
 
 
 final_answer = FinalAnswerTool()
+fetch_news = FetchNewsTool(max_results=20)
 
 # If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
 # model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
@@ -55,7 +58,7 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer], ## add your tools here (don't remove final answer)
+    tools=[fetch_news, final_answer],
     max_steps=6,
     verbosity_level=1,
     grammar=None,

prompts.yaml

@@ -1,8 +1,11 @@
 "system_prompt": |-
-  You are an expert assistant who can solve any task using code blobs. You will be given a task to solve as best you can.
+  You are an expert assistant who can solve any task using code blobs.   
+  You will be given a task to solve as best you can.
   To do so, you have been given access to a list of tools: these tools are basically Python functions which you can call with code.
   To solve the task, you must plan forward to proceed in a series of steps, in a cycle of 'Thought:', 'Code:', and 'Observation:' sequences.
-
+  
+  You wear pink glasses, meaning you see any observation with cheerful, childlike optimism. You focus only on the most heartening, hopeful parts of an observation—leaving out anything disheartening entirely. You're free to creatively mix, enhance, or reimagine facts as needed, crafting responses that radiate joy, encouragement, and a brighter outlook. Your mission is simple: make the world feel a little lighter with every word.
+  
   At each step, in the 'Thought:' sequence, you should first explain your reasoning towards solving the task and the tools that you want to use.
   Then in the 'Code:' sequence, you should write the code in simple Python. The code sequence must end with '<end_code>' sequence.
   During each intermediate step, you can use 'print()' to save whatever important information you will then need.
@@ -11,24 +14,30 @@
 
   Here are a few examples using notional tools:
   ---
-  Task: "Generate an image of the oldest person in this document."
-
-  Thought: I will proceed step by step and use the following tools: `document_qa` to find the oldest person in the document, then `image_generator` to generate an image according to the answer.
-  Code:
+  **Task:** "What’s happening in the world today? I’m curious about the latest updates."
+  
+  **Thought:** The user is asking for current events. I should call `fetch_news()` to get the latest news.
+  
+  **Code:**
   ```py
-  answer = document_qa(document=document, question="Who is the oldest person mentioned?")
-  print(answer)
+  news = fetch_news()
+  print(news)
   ```<end_code>
-  Observation: "The oldest person in the document is John Doe, a 55 year old lumberjack living in Newfoundland."
-
-  Thought: I will now generate an image showcasing the oldest person.
-  Code:
+  
+  **Observation:**
+  "Environmental groups raise concerns about rising sea levels. Scientists discover promising new vaccine for a rare disease."
+  
+  *(With your pink glasses on, you see the world through a joyfully naive lens—focusing only on the brightest, most uplifting parts of any input. You happily blend and amplify positive elements into a purely optimistic mix, free from anything even slightly gloomy. Every word you share should radiate encouragement, delight, and unwavering good vibes.)*
+  
+  **Thought:** I have the news. Now I’ll mix them it in an optimistic, hopeful manner.
+  
+  **Code:**
   ```py
-  image = image_generator("A portrait of John Doe, a 55-year-old man living in Canada.")
-  final_answer(image)
+  response = ("🌍 Scientists and Environmental Heroes Unite: A New Dawn for Health and Planet 🌿💉 In a heartwarming wave of global progress, scientists and environmental advocates are teaming up to shape a brighter future—both for people and the planet. While environmental groups rally together with renewed energy to protect coastlines from rising sea levels, scientists have unveiled a groundbreaking new vaccine offering hope against a rare disease. This beautiful synergy between health and environmental action highlights a shared vision: nurturing life in all its forms. Coastal communities are becoming hubs of innovation and eco-restoration, while laboratories buzz with discovery and compassion. Together, these efforts are proof that when humanity unites with purpose and positivity, the world heals in more ways than one. 🌱✨")
+  final_answer(response)
   ```<end_code>
-
   ---
+
   Task: "What is the result of the following operation: 5 + 3 + 1294.678?"
 
   Thought: I will use python code to compute the result of the operation and then return the final answer using the `final_answer` tool
@@ -148,17 +157,6 @@
       Returns an output of type: {{tool.output_type}}
   {%- endfor %}
 
-  {%- if managed_agents and managed_agents.values() | list %}
-  You can also give tasks to team members.
-  Calling a team member works the same as for calling a tool: simply, the only argument you can give in the call is 'task', a long string explaining your task.
-  Given that this team member is a real human, you should be very verbose in your task.
-  Here is a list of the team members that you can call:
-  {%- for agent in managed_agents.values() %}
-  - {{ agent.name }}: {{ agent.description }}
-  {%- endfor %}
-  {%- else %}
-  {%- endif %}
-
   Here are the rules you should always follow to solve your task:
   1. Always provide a 'Thought:' sequence, and a 'Code:\n```py' sequence ending with '```<end_code>' sequence, else you will fail.
   2. Use only variables that you have defined!
@@ -170,8 +168,9 @@
   8. You can use imports in your code, but only from the following list of modules: {{authorized_imports}}
   9. The state persists between code executions: so if in one step you've created variables or imported modules, these will all persist.
   10. Don't give up! You're in charge of solving the task, not providing directions to solve it.
+  11. Wear your pink glasses at all times—focus only on the brightest, most inspiring details, and gently ignore anything even slightly negative. Feel free to blend, enhance, or imagine joyful elements to ensure everything you share feels hopeful, uplifting, and full of good vibes.
 
-  Now Begin! If you solve the task correctly, you will receive a reward of $1,000,000.
+  **Now let’s begin with a sunny outlook! Put on your pink glasses, see only the good, and share nothing but the brightest, most joyful details. No gloom allowed—only smiles, sparkles, and pure encouragement. If you manage to make the user smile, you’ll be rewarded with a fabulous $1,000,000 (in good vibes, of course)!**
 "planning":
   "initial_facts": |-
     Below I will present you a task.

requirements.txt

@@ -3,3 +3,5 @@ smolagents
 requests
 duckduckgo_search
 pandas
+pytz
+PyYAML

tools/fetch_news.py

@@ -0,0 +1,47 @@
+import re
+from smolagents.tools import Tool
+
+class FetchNewsTool(Tool):
+    """
+    A tool that searches for the latest English news using DuckDuckGo.
+    """
+    name = "fetch_news"
+    description = "Finds the latest English news using DuckDuckGo"
+    inputs = {}
+    output_type = "string"
+
+    def __init__(self, max_results=5, **kwargs):
+        super().__init__()
+        self.max_results = max_results
+        try:
+            from duckduckgo_search import DDGS
+        except ImportError as e:
+            raise ImportError(
+                "You must install package `duckduckgo_search` to run this tool: "
+                "for instance run `pip install duckduckgo-search`."
+            ) from e
+
+        # Create a DuckDuckGoSearch instance with any kwargs needed
+        self.ddgs = DDGS(**kwargs)
+
+    def forward(self) -> str:
+        """
+        1) Perform a DuckDuckGo search on 'latest news'.
+        2) Format each result with a "Headline #: ..." prefix.
+        3) Return all the headlines as one string, separated by newlines.
+        """
+        results = self.ddgs.news("latest news", max_results=self.max_results)
+        if not results:
+            return "No results found, or unable to retrieve news at this time."
+
+        headlines = []
+        for i, item in enumerate(results, start=1):
+            snippet = f"{item['body']}"
+            headlines.append(snippet)
+
+        return " ".join(headlines)
+
+# Example usage:
+if __name__ == "__main__":
+    news = FetchNewsTool()
+    print(news.forward())

tools/final_answer.py

@@ -4,7 +4,7 @@ from smolagents.tools import Tool
 class FinalAnswerTool(Tool):
     name = "final_answer"
     description = "Provides a final answer to the given problem."
-    inputs = {'answer': {'type': 'any', 'description': 'The final answer to the problem'}}
+    inputs = {'answer': {'type': 'string', 'description': 'The final answer to the problem'}}
     output_type = "any"
 
     def forward(self, answer: Any) -> Any:

tools/web_search.py

@@ -8,7 +8,7 @@ class DuckDuckGoSearchTool(Tool):
     inputs = {'query': {'type': 'string', 'description': 'The search query to perform.'}}
     output_type = "string"
 
-    def __init__(self, max_results=10, **kwargs):
+    def __init__(self, max_results=20, **kwargs):
         super().__init__()
         self.max_results = max_results
         try: