agno 1.7.11__py3-none-any.whl → 1.8.0__py3-none-any.whl

agno/storage/dynamodb.py

@@ -30,19 +30,23 @@ class DynamoDbStorage(Storage):
         endpoint_url: Optional[str] = None,
         create_table_if_not_exists: bool = True,
         mode: Optional[Literal["agent", "team", "workflow", "workflow_v2"]] = "agent",
+        create_table_read_capacity_units: int = 5,
+        create_table_write_capacity_units: int = 5,
     ):
         """
         Initialize the DynamoDbStorage.
 
         Args:
             table_name (str): The name of the DynamoDB table.
-            region_name (Optional[str]): AWS region name.
             profile_name (Optional[str]): AWS profile name to use for credentials.
+            region_name (Optional[str]): AWS region name.
             aws_access_key_id (Optional[str]): AWS access key ID.
             aws_secret_access_key (Optional[str]): AWS secret access key.
             endpoint_url (Optional[str]): The complete URL to use for the constructed client.
             create_table_if_not_exists (bool): Whether to create the table if it does not exist.
             mode (Optional[Literal["agent", "team", "workflow", "workflow_v2"]]): The mode of the storage.
+            create_table_read_capacity_units Optional[int]: Read capacity units for created table (default: 5).
+            create_table_write_capacity_units Optional[int]: Write capacity units for created table (default: 5).
         """
         super().__init__(mode)
         self.table_name = table_name
@@ -52,6 +56,8 @@ class DynamoDbStorage(Storage):
         self.aws_access_key_id = aws_access_key_id
         self.aws_secret_access_key = aws_secret_access_key
         self.create_table_if_not_exists = create_table_if_not_exists
+        self.create_table_read_capacity_units = create_table_read_capacity_units
+        self.create_table_write_capacity_units = create_table_write_capacity_units
 
         # Create session using profile name if provided
         if self.profile_name:
@@ -96,6 +102,11 @@ class DynamoDbStorage(Storage):
         """
         Create the DynamoDB table if it does not exist.
         """
+        provisioned_throughput = {
+            "ReadCapacityUnits": self.create_table_read_capacity_units,
+            "WriteCapacityUnits": self.create_table_write_capacity_units,
+        }
+
         try:
             # Check if table exists
             self.dynamodb.meta.client.describe_table(TableName=self.table_name)
@@ -141,10 +152,7 @@ class DynamoDbStorage(Storage):
                             {"AttributeName": "created_at", "KeyType": "RANGE"},
                         ],
                         "Projection": {"ProjectionType": "ALL"},
-                        "ProvisionedThroughput": {
-                            "ReadCapacityUnits": 5,
-                            "WriteCapacityUnits": 5,
-                        },
+                        "ProvisionedThroughput": provisioned_throughput,
                     }
                 ]
                 if self.mode == "agent":
@@ -156,10 +164,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 elif self.mode == "team":
@@ -171,10 +176,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 elif self.mode == "workflow":
@@ -186,10 +188,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 elif self.mode == "workflow_v2":
@@ -201,10 +200,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 # Create the table
@@ -213,7 +209,7 @@ class DynamoDbStorage(Storage):
                     KeySchema=[{"AttributeName": "session_id", "KeyType": "HASH"}],
                     AttributeDefinitions=attribute_definitions,
                     GlobalSecondaryIndexes=secondary_indexes,
-                    ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
+                    ProvisionedThroughput=provisioned_throughput,
                 )
                 # Wait until the table exists.
                 self.table.wait_until_exists()

agno/team/team.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import json
 from collections import ChainMap, defaultdict, deque
 from copy import deepcopy
@@ -4503,7 +4504,11 @@ class Team:
             from agno.reasoning.openai import is_openai_reasoning_model
 
             reasoning_agent = self.reasoning_agent or get_reasoning_agent(
-                reasoning_model=reasoning_model, monitoring=self.monitoring
+                reasoning_model=reasoning_model,
+                monitoring=self.monitoring,
+                session_state=self.session_state,
+                context=self.context,
+                extra_data=self.extra_data,
             )
             is_deepseek = is_deepseek_reasoning_model(reasoning_model)
             is_groq = is_groq_reasoning_model(reasoning_model)
@@ -4596,6 +4601,9 @@ class Team:
                     debug_mode=self.debug_mode,
                     debug_level=self.debug_level,
                     use_json_mode=use_json_mode,
+                    session_state=self.session_state,
+                    context=self.context,
+                    extra_data=self.extra_data,
                 )
 
             # Validate reasoning agent
@@ -4726,7 +4734,11 @@ class Team:
             from agno.reasoning.openai import is_openai_reasoning_model
 
             reasoning_agent = self.reasoning_agent or get_reasoning_agent(
-                reasoning_model=reasoning_model, monitoring=self.monitoring
+                reasoning_model=reasoning_model,
+                monitoring=self.monitoring,
+                session_state=self.session_state,
+                context=self.context,
+                extra_data=self.extra_data,
             )
             is_deepseek = is_deepseek_reasoning_model(reasoning_model)
             is_groq = is_groq_reasoning_model(reasoning_model)
@@ -4817,6 +4829,9 @@ class Team:
                     debug_mode=self.debug_mode,
                     debug_level=self.debug_level,
                     use_json_mode=use_json_mode,
+                    session_state=self.session_state,
+                    context=self.context,
+                    extra_data=self.extra_data,
                 )
 
             # Validate reasoning agent
@@ -6223,7 +6238,7 @@ class Team:
 
         async def arun_member_agents(
             task_description: str, expected_output: Optional[str] = None
-        ) -> AsyncIterator[str]:
+        ) -> AsyncIterator[Union[RunResponseEvent, TeamRunResponseEvent, str]]:
             """
             Send the same task to all the member agents and return the responses.
 
@@ -6243,92 +6258,177 @@ class Team:
                 session_id, images, videos, audio
             )
 
-            # Create tasks for all member agents
-            tasks = []
-            for member_agent_index, member_agent in enumerate(self.members):
-                # We cannot stream responses with async gather
-                current_agent = member_agent  # Create a reference to the current agent
-                current_index = member_agent_index  # Create a reference to the current index
-                self._initialize_member(current_agent, session_id=session_id)
+            if stream:
+                # Concurrent streaming: launch each member as a streaming worker and merge events
+                done_marker = object()
+                queue: "asyncio.Queue[Union[RunResponseEvent, TeamRunResponseEvent, str, object]]" = asyncio.Queue()
 
-                # Don't override the expected output of a member agent
-                if current_agent.expected_output is not None:
-                    expected_output = None
+                async def stream_member(agent: Union[Agent, "Team"], idx: int) -> None:
+                    # Compute expected output per agent (do not mutate shared var)
+                    local_expected_output = None if agent.expected_output is not None else expected_output
 
-                member_agent_task = self._format_member_agent_task(
-                    task_description, expected_output, team_context_str, team_member_interactions_str
-                )
+                    member_agent_task = self._format_member_agent_task(
+                        task_description, local_expected_output, team_context_str, team_member_interactions_str
+                    )
 
-                async def run_member_agent(agent=current_agent, idx=current_index) -> str:
-                    response = await agent.arun(
+                    # Stream events from the member
+                    member_stream = await agent.arun(
                         member_agent_task,
                         user_id=user_id,
-                        # All members have the same session_id
                         session_id=session_id,
                         images=images,
                         videos=videos,
                         audio=audio,
                         files=files,
-                        stream=False,
+                        stream=True,
+                        stream_intermediate_steps=stream_intermediate_steps,
                         refresh_session_before_write=True,
                     )
-                    check_if_run_cancelled(response)
 
-                    member_name = agent.name if agent.name else f"agent_{idx}"
-                    self.memory = cast(TeamMemory, self.memory)
-                    if isinstance(self.memory, TeamMemory):
-                        self.memory = cast(TeamMemory, self.memory)
-                        self.memory.add_interaction_to_team_context(
-                            member_name=member_name, task=task_description, run_response=agent.run_response
-                        )
-                    else:
-                        self.memory = cast(Memory, self.memory)
-                        self.memory.add_interaction_to_team_context(
+                    try:
+                        async for event in member_stream:
+                            check_if_run_cancelled(event)
+                            await queue.put(event)
+                    finally:
+                        # After the stream completes, update memory and team state
+                        member_name = agent.name if agent.name else f"agent_{idx}"
+                        if isinstance(self.memory, TeamMemory):
+                            self.memory = cast(TeamMemory, self.memory)
+                            self.memory.add_interaction_to_team_context(
+                                member_name=member_name,
+                                task=task_description,
+                                run_response=agent.run_response,  # type: ignore
+                            )
+                        else:
+                            self.memory = cast(Memory, self.memory)
+                            self.memory.add_interaction_to_team_context(
+                                session_id=session_id,
+                                member_name=member_name,
+                                task=task_description,
+                                run_response=agent.run_response,  # type: ignore
+                            )
+
+                        # Add the member run to the team run response
+                        self.run_response = cast(TeamRunResponse, self.run_response)
+                        self.run_response.add_member_run(agent.run_response)  # type: ignore
+
+                        # Update team session/workflow state and media
+                        self._update_team_session_state(agent)
+                        self._update_workflow_session_state(agent)
+                        self._update_team_media(agent.run_response)  # type: ignore
+
+                        # Signal completion for this member
+                        await queue.put(done_marker)
+
+                # Initialize and launch all members
+                tasks: List[asyncio.Task[None]] = []
+                for member_agent_index, member_agent in enumerate(self.members):
+                    current_agent = member_agent
+                    current_index = member_agent_index
+                    self._initialize_member(current_agent, session_id=session_id)
+                    tasks.append(asyncio.create_task(stream_member(current_agent, current_index)))
+
+                # Drain queue until all members reported done
+                completed = 0
+                try:
+                    while completed < len(tasks):
+                        item = await queue.get()
+                        if item is done_marker:
+                            completed += 1
+                        else:
+                            yield item  # type: ignore
+                finally:
+                    # Ensure tasks do not leak on cancellation
+                    for t in tasks:
+                        if not t.done():
+                            t.cancel()
+                    # Await cancellation to suppress warnings
+                    for t in tasks:
+                        with contextlib.suppress(Exception):
+                            await t
+            else:
+                # Non-streaming concurrent run of members; collect results when done
+                tasks = []
+                for member_agent_index, member_agent in enumerate(self.members):
+                    current_agent = member_agent
+                    current_index = member_agent_index
+                    self._initialize_member(current_agent, session_id=session_id)
+
+                    # Don't override the expected output of a member agent
+                    if current_agent.expected_output is not None:
+                        expected_output = None
+
+                    member_agent_task = self._format_member_agent_task(
+                        task_description, expected_output, team_context_str, team_member_interactions_str
+                    )
+
+                    async def run_member_agent(agent=current_agent, idx=current_index) -> str:
+                        response = await agent.arun(
+                            member_agent_task,
+                            user_id=user_id,
+                            # All members have the same session_id
                             session_id=session_id,
-                            member_name=member_name,
-                            task=task_description,
-                            run_response=agent.run_response,
+                            images=images,
+                            videos=videos,
+                            audio=audio,
+                            files=files,
+                            stream=False,
+                            refresh_session_before_write=True,
                         )
+                        check_if_run_cancelled(response)
+
+                        member_name = agent.name if agent.name else f"agent_{idx}"
+                        self.memory = cast(TeamMemory, self.memory)
+                        if isinstance(self.memory, TeamMemory):
+                            self.memory = cast(TeamMemory, self.memory)
+                            self.memory.add_interaction_to_team_context(
+                                member_name=member_name, task=task_description, run_response=agent.run_response
+                            )
+                        else:
+                            self.memory = cast(Memory, self.memory)
+                            self.memory.add_interaction_to_team_context(
+                                session_id=session_id,
+                                member_name=member_name,
+                                task=task_description,
+                                run_response=agent.run_response,
+                            )
 
-                    # Add the member run to the team run response
-                    self.run_response = cast(TeamRunResponse, self.run_response)
-                    self.run_response.add_member_run(agent.run_response)
+                        # Add the member run to the team run response
+                        self.run_response = cast(TeamRunResponse, self.run_response)
+                        self.run_response.add_member_run(agent.run_response)
 
-                    # Update team session state
-                    self._update_team_session_state(current_agent)
+                        # Update team session state
+                        self._update_team_session_state(current_agent)
 
-                    self._update_workflow_session_state(current_agent)
+                        self._update_workflow_session_state(current_agent)
 
-                    # Update the team media
-                    self._update_team_media(agent.run_response)
+                        # Update the team media
+                        self._update_team_media(agent.run_response)
 
-                    try:
-                        if response.content is None and (response.tools is None or len(response.tools) == 0):
-                            return f"Agent {member_name}: No response from the member agent."
-                        elif isinstance(response.content, str):
-                            if len(response.content.strip()) > 0:
-                                return f"Agent {member_name}: {response.content}"
-                            elif response.tools is not None and len(response.tools) > 0:
-                                return (
-                                    f"Agent {member_name}: {','.join([tool.get('content') for tool in response.tools])}"
-                                )
-                        elif issubclass(type(response.content), BaseModel):
-                            return f"Agent {member_name}: {response.content.model_dump_json(indent=2)}"  # type: ignore
-                        else:
-                            import json
+                        try:
+                            if response.content is None and (response.tools is None or len(response.tools) == 0):
+                                return f"Agent {member_name}: No response from the member agent."
+                            elif isinstance(response.content, str):
+                                if len(response.content.strip()) > 0:
+                                    return f"Agent {member_name}: {response.content}"
+                                elif response.tools is not None and len(response.tools) > 0:
+                                    return f"Agent {member_name}: {','.join([tool.get('content') for tool in response.tools])}"
+                            elif issubclass(type(response.content), BaseModel):
+                                return f"Agent {member_name}: {response.content.model_dump_json(indent=2)}"  # type: ignore
+                            else:
+                                import json
 
-                            return f"Agent {member_name}: {json.dumps(response.content, indent=2)}"
-                    except Exception as e:
-                        return f"Agent {member_name}: Error - {str(e)}"
+                                return f"Agent {member_name}: {json.dumps(response.content, indent=2)}"
+                        except Exception as e:
+                            return f"Agent {member_name}: Error - {str(e)}"
 
-                    return f"Agent {member_name}: No Response"
+                        return f"Agent {member_name}: No Response"
 
-                tasks.append(run_member_agent)
+                    tasks.append(run_member_agent)  # type: ignore
 
-            # Need to collect and process yielded values from each task
-            results = await asyncio.gather(*[task() for task in tasks])
-            for result in results:
-                yield result
+                results = await asyncio.gather(*[task() for task in tasks])  # type: ignore
+                for result in results:
+                    yield result
 
             # Afterward, switch back to the team logger
             use_team_logger()

agno/tools/bravesearch.py

@@ -49,9 +49,9 @@ class BraveSearchTools(Toolkit):
     def brave_search(
         self,
         query: str,
-        max_results: Optional[int] = None,
-        country: Optional[str] = None,
-        search_lang: Optional[str] = None,
+        max_results: int = 5,
+        country: str = "US",
+        search_lang: str = "en",
     ) -> str:
         """
         Search Brave for the specified query and return the results.
@@ -64,8 +64,8 @@ class BraveSearchTools(Toolkit):
         Returns:
             str: A JSON formatted string containing the search results.
         """
-        max_results = self.fixed_max_results or max_results
-        search_lang = self.fixed_language or search_lang
+        final_max_results = self.fixed_max_results if self.fixed_max_results is not None else max_results
+        final_search_lang = self.fixed_language if self.fixed_language is not None else search_lang
 
         if not query:
             return json.dumps({"error": "Please provide a query to search for"})
@@ -74,9 +74,9 @@ class BraveSearchTools(Toolkit):
 
         search_params = {
             "q": query,
-            "count": max_results,
+            "count": final_max_results,
             "country": country,
-            "search_lang": search_lang,
+            "search_lang": final_search_lang,
             "result_filter": "web",
         }
 

agno/tools/calculator.py

@@ -3,7 +3,7 @@ import math
 from typing import Callable, List
 
 from agno.tools import Toolkit
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_debug, logger
 
 
 class CalculatorTools(Toolkit):
@@ -53,7 +53,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = a + b
-        log_info(f"Adding {a} and {b} to get {result}")
+        log_debug(f"Adding {a} and {b} to get {result}")
         return json.dumps({"operation": "addition", "result": result})
 
     def subtract(self, a: float, b: float) -> str:
@@ -67,7 +67,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = a - b
-        log_info(f"Subtracting {b} from {a} to get {result}")
+        log_debug(f"Subtracting {b} from {a} to get {result}")
         return json.dumps({"operation": "subtraction", "result": result})
 
     def multiply(self, a: float, b: float) -> str:
@@ -81,7 +81,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = a * b
-        log_info(f"Multiplying {a} and {b} to get {result}")
+        log_debug(f"Multiplying {a} and {b} to get {result}")
         return json.dumps({"operation": "multiplication", "result": result})
 
     def divide(self, a: float, b: float) -> str:
@@ -101,7 +101,7 @@ class CalculatorTools(Toolkit):
             result = a / b
         except Exception as e:
             return json.dumps({"operation": "division", "error": str(e), "result": "Error"})
-        log_info(f"Dividing {a} by {b} to get {result}")
+        log_debug(f"Dividing {a} by {b} to get {result}")
         return json.dumps({"operation": "division", "result": result})
 
     def exponentiate(self, a: float, b: float) -> str:
@@ -115,7 +115,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = math.pow(a, b)
-        log_info(f"Raising {a} to the power of {b} to get {result}")
+        log_debug(f"Raising {a} to the power of {b} to get {result}")
         return json.dumps({"operation": "exponentiation", "result": result})
 
     def factorial(self, n: int) -> str:
@@ -131,7 +131,7 @@ class CalculatorTools(Toolkit):
             logger.error("Attempt to calculate factorial of a negative number")
             return json.dumps({"operation": "factorial", "error": "Factorial of a negative number is undefined"})
         result = math.factorial(n)
-        log_info(f"Calculating factorial of {n} to get {result}")
+        log_debug(f"Calculating factorial of {n} to get {result}")
         return json.dumps({"operation": "factorial", "result": result})
 
     def is_prime(self, n: int) -> str:
@@ -164,5 +164,5 @@ class CalculatorTools(Toolkit):
             return json.dumps({"operation": "square_root", "error": "Square root of a negative number is undefined"})
 
         result = math.sqrt(n)
-        log_info(f"Calculating square root of {n} to get {result}")
+        log_debug(f"Calculating square root of {n} to get {result}")
         return json.dumps({"operation": "square_root", "result": result})

agno/tools/discord.py

@@ -51,12 +51,12 @@ class DiscordTools(Toolkit):
         response.raise_for_status()
         return response.json() if response.text else {}
 
-    def send_message(self, channel_id: int, message: str) -> str:
+    def send_message(self, channel_id: str, message: str) -> str:
         """
         Send a message to a Discord channel.
 
         Args:
-            channel_id (int): The ID of the channel to send the message to.
+            channel_id (str): The ID of the channel to send the message to.
             message (str): The text of the message to send.
 
         Returns:
@@ -70,12 +70,12 @@ class DiscordTools(Toolkit):
             logger.error(f"Error sending message: {e}")
             return f"Error sending message: {str(e)}"
 
-    def get_channel_info(self, channel_id: int) -> str:
+    def get_channel_info(self, channel_id: str) -> str:
         """
         Get information about a Discord channel.
 
         Args:
-            channel_id (int): The ID of the channel to get information about.
+            channel_id (str): The ID of the channel to get information about.
 
         Returns:
             str: A JSON string containing the channel information.
@@ -87,12 +87,12 @@ class DiscordTools(Toolkit):
             logger.error(f"Error getting channel info: {e}")
             return f"Error getting channel info: {str(e)}"
 
-    def list_channels(self, guild_id: int) -> str:
+    def list_channels(self, guild_id: str) -> str:
         """
         List all channels in a Discord server.
 
         Args:
-            guild_id (int): The ID of the server to list channels from.
+            guild_id (str): The ID of the server to list channels from.
 
         Returns:
             str: A JSON string containing the list of channels.
@@ -104,12 +104,12 @@ class DiscordTools(Toolkit):
             logger.error(f"Error listing channels: {e}")
             return f"Error listing channels: {str(e)}"
 
-    def get_channel_messages(self, channel_id: int, limit: int = 100) -> str:
+    def get_channel_messages(self, channel_id: str, limit: int = 100) -> str:
         """
         Get the message history of a Discord channel.
 
         Args:
-            channel_id (int): The ID of the channel to fetch messages from.
+            channel_id (str): The ID of the channel to fetch messages from.
             limit (int): The maximum number of messages to fetch. Defaults to 100.
 
         Returns:
@@ -122,13 +122,13 @@ class DiscordTools(Toolkit):
             logger.error(f"Error getting messages: {e}")
             return f"Error getting messages: {str(e)}"
 
-    def delete_message(self, channel_id: int, message_id: int) -> str:
+    def delete_message(self, channel_id: str, message_id: str) -> str:
         """
         Delete a message from a Discord channel.
 
         Args:
-            channel_id (int): The ID of the channel containing the message.
-            message_id (int): The ID of the message to delete.
+            channel_id (str): The ID of the channel containing the message.
+            message_id (str): The ID of the message to delete.
 
         Returns:
             str: A success message or error message.

agno/tools/duckduckgo.py

@@ -5,9 +5,9 @@ from agno.tools import Toolkit
 from agno.utils.log import log_debug
 
 try:
-    from duckduckgo_search import DDGS
+    from ddgs import DDGS
 except ImportError:
-    raise ImportError("`duckduckgo-search` not installed. Please install using `pip install duckduckgo-search`")
+    raise ImportError("`duckduckgo-search` not installed. Please install using `pip install ddgs`")
 
 
 class DuckDuckGoTools(Toolkit):
@@ -18,9 +18,7 @@ class DuckDuckGoTools(Toolkit):
         news (bool): Enable DuckDuckGo news function.
         modifier (Optional[str]): A modifier to be used in the search request.
         fixed_max_results (Optional[int]): A fixed number of maximum results.
-        headers (Optional[Any]): Headers to be used in the search request.
         proxy (Optional[str]): Proxy to be used in the search request.
-        proxies (Optional[Any]): A list of proxies to be used in the search request.
         timeout (Optional[int]): The maximum number of seconds to wait for a response.
 
     """
@@ -31,16 +29,12 @@ class DuckDuckGoTools(Toolkit):
         news: bool = True,
         modifier: Optional[str] = None,
         fixed_max_results: Optional[int] = None,
-        headers: Optional[Any] = None,
         proxy: Optional[str] = None,
-        proxies: Optional[Any] = None,
         timeout: Optional[int] = 10,
         verify_ssl: bool = True,
         **kwargs,
     ):
-        self.headers: Optional[Any] = headers
         self.proxy: Optional[str] = proxy
-        self.proxies: Optional[Any] = proxies
         self.timeout: Optional[int] = timeout
         self.fixed_max_results: Optional[int] = fixed_max_results
         self.modifier: Optional[str] = modifier
@@ -68,11 +62,10 @@ class DuckDuckGoTools(Toolkit):
         search_query = f"{self.modifier} {query}" if self.modifier else query
 
         log_debug(f"Searching DDG for: {search_query}")
-        ddgs = DDGS(
-            headers=self.headers, proxy=self.proxy, proxies=self.proxies, timeout=self.timeout, verify=self.verify_ssl
-        )
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.text(search_query, max_results=actual_max_results)
 
-        return json.dumps(ddgs.text(keywords=search_query, max_results=actual_max_results), indent=2)
+        return json.dumps(results, indent=2)
 
     def duckduckgo_news(self, query: str, max_results: int = 5) -> str:
         """Use this function to get the latest news from DuckDuckGo.
@@ -87,8 +80,7 @@ class DuckDuckGoTools(Toolkit):
         actual_max_results = self.fixed_max_results or max_results
 
         log_debug(f"Searching DDG news for: {query}")
-        ddgs = DDGS(
-            headers=self.headers, proxy=self.proxy, proxies=self.proxies, timeout=self.timeout, verify=self.verify_ssl
-        )
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.news(query, max_results=actual_max_results)
 
-        return json.dumps(ddgs.news(keywords=query, max_results=actual_max_results), indent=2)
+        return json.dumps(results, indent=2)