chore: resolve merge conflicts and apply code formatting

- Resolve conflicts in README.md and python_repl.py
- Apply automatic code formatting via pre-commit hooks

Author: gonzalo123

CONTRIBUTING.md

@@ -24,6 +24,16 @@ Please try to include as much information as you can. Details like these are inc
 * Any modifications you've made relevant to the bug
 * Anything unusual about your environment or deployment
 
+## Finding contributions to work on
+Looking at the existing issues is a great way to find something to contribute to. We label issues that are well-defined and ready for community contributions with the "ready for contribution" label.
+
+Check our [Ready for Contribution](../../issues?q=is%3Aissue%20state%3Aopen%20label%3A%22ready%20for%20contribution%22) issues for items you can work on.
+
+Before starting work on any issue:
+1. Check if someone is already assigned or working on it
+2. Comment on the issue to express your interest and ask any clarifying questions
+3. Wait for maintainer confirmation before beginning significant work
+
 
 ## Development Environment
 

README.md

@@ -39,6 +39,7 @@ Strands Agents Tools is a community-driven project that provides a powerful set
 - 📁 **File Operations** - Read, write, and edit files with syntax highlighting and intelligent modifications
 - 🖥️ **Shell Integration** - Execute and interact with shell commands securely
 - 🧠 **Memory** - Store user and agent memories across agent runs to provide personalized experiences with both Mem0 and Amazon Bedrock Knowledge Bases
+- 🕸️ **Web Infrastructure** - Perform web searches, extract page content, and crawl websites with Tavily-powered tools
 - 🌐 **HTTP Client** - Make API requests with comprehensive authentication support
 - 💬 **Slack Client** - Real-time Slack events, message processing, and Slack API access
 - 🐍 **Python Execution** - Run Python code snippets with state persistence, user confirmation for code execution, and safety features
@@ -103,6 +104,10 @@ Below is a comprehensive table of all available tools, how to use them with an a
 | editor | `agent.tool.editor(command="view", path="path/to/file.py")` | Advanced file operations like syntax highlighting, pattern replacement, and multi-file edits |
 | shell* | `agent.tool.shell(command="ls -la")` | Executing shell commands, interacting with the operating system, running scripts |
 | http_request | `agent.tool.http_request(method="GET", url="https://api.example.com/data")` | Making API calls, fetching web data, sending data to external services |
+| tavily_search | `agent.tool.tavily_search(query="What is artificial intelligence?", search_depth="advanced")` | Real-time web search optimized for AI agents with a variety of custom parameters |
+| tavily_extract | `agent.tool.tavily_extract(urls=["www.tavily.com"], extract_depth="advanced")` | Extract clean, structured content from web pages with advanced processing and noise removal |
+| tavily_crawl | `agent.tool.tavily_crawl(url="www.tavily.com", max_depth=2, instructions="Find API docs")` | Crawl websites intelligently starting from a base URL with filtering and extraction |
+| tavily_map | `agent.tool.tavily_map(url="www.tavily.com", max_depth=2, instructions="Find all pages")` | Map website structure and discover URLs starting from a base URL without content extraction |
 | python_repl* | `agent.tool.python_repl(code="import pandas as pd\ndf = pd.read_csv('data.csv')\nprint(df.head())")` | Running Python code snippets, data analysis, executing complex logic with user confirmation for security |
 | calculator | `agent.tool.calculator(expression="2 * sin(pi/4) + log(e**2)")` | Performing mathematical operations, symbolic math, equation solving |
 | code_interpreter | `code_interpreter = AgentCoreCodeInterpreter(region="us-west-2"); agent = Agent(tools=[code_interpreter.code_interpreter])` | Execute code in isolated sandbox environments with multi-language support (Python, JavaScript, TypeScript), persistent sessions, and file operations |
@@ -268,6 +273,49 @@ response = agent.tool.http_request(
 )
 ```
 
+### Tavily Search, Extract, Crawl, and Map
+
+```python
+from strands import Agent
+from strands_tools.tavily import (
+    tavily_search, tavily_extract, tavily_crawl, tavily_map
+)
+
+# For async usage, call the corresponding *_async function with await.
+# Synchronous usage 
+agent = Agent(tools=[tavily_search, tavily_extract, tavily_crawl, tavily_map])
+
+# Real-time web search
+result = agent.tool.tavily_search(
+    query="Latest developments in renewable energy",
+    search_depth="advanced",
+    topic="news",
+    max_results=10,
+    include_raw_content=True
+)
+
+# Extract content from multiple URLs
+result = agent.tool.tavily_extract(
+    urls=["www.tavily.com", "www.apple.com"],
+    extract_depth="advanced",
+    format="markdown"
+)
+
+# Advanced crawl with instructions and filtering
+result = agent.tool.tavily_crawl(
+    url="www.tavily.com",
+    max_depth=2,
+    limit=50,
+    instructions="Find all API documentation and developer guides",
+    extract_depth="advanced",
+    include_images=True
+)
+
+# Basic website mapping
+result = agent.tool.tavily_map(url="www.tavily.com")
+
+```
+
 ### Python Code Execution
 
 *Note: `python_repl` does not work on Windows.*
@@ -682,6 +730,13 @@ These variables affect multiple tools:
 |----------------------|-------------|---------|
 | MAX_SLEEP_SECONDS | Maximum allowed sleep duration in seconds | 300 |
 
+#### Tavily Search, Extract, Crawl, and Map Tools
+
+| Environment Variable | Description | Default |
+|----------------------|-------------|---------|
+| TAVILY_API_KEY | Tavily API key (required for all Tavily functionality) | None |
+- Visit https://www.tavily.com/ to create a free account and API key.
+
 #### Mem0 Memory Tool
 
 The Mem0 Memory Tool supports three different backend configurations:
@@ -730,6 +785,8 @@ The Mem0 Memory Tool supports three different backend configurations:
 | Environment Variable | Description | Default |
 |----------------------|-------------|---------|
 | PYTHON_REPL_BINARY_MAX_LEN | Maximum length for binary content before truncation | 100 |
+| PYTHON_REPL_INTERACTIVE | Whether to enable interactive PTY mode | None |
+| PYTHON_REPL_RESET_STATE | Whether to reset the REPL state before execution | None |
 | PYTHON_REPL_RESTRICTED_MODE | Enable/disable restricted mode | false |
 | PYTHON_REPL_ALLOWED_PATHS | Comma-separated allowed directories | None |
 | PYTHON_REPL_ALLOW_CURRENT_DIR | Allow current directory access | true |

pyproject.toml

@@ -37,6 +37,8 @@ dependencies = [
     "slack_bolt>=1.23.0,<2.0.0",
     "markdownify>=1.0.0,<2.0.0",
     "readabilipy>=0.2.0,<1.0.0",
+    "requests>=2.28.0,<3.0.0",
+    "aiohttp>=3.8.0,<4.0.0",
     # Note: Always want the latest tzdata
     "tzdata ; platform_system == 'Windows'",
     "botocore>=1.39.7,<2.0.0",
@@ -90,7 +92,7 @@ agent_core_browser = [
 agent_core_code_interpreter = [
     "bedrock-agentcore==0.1.0"
 ]
-a2a_client = ["a2a-sdk[sql]>=0.2.16"]
+a2a_client = ["a2a-sdk[sql]>=0.3.0,<0.4.0"]
 diagram = [
     "matplotlib>=3.5.0,<4.0.0",
     "graphviz>=0.20.0,<1.0.0",
@@ -99,9 +101,9 @@ diagram = [
 ]
 rss = ["feedparser>=6.0.10,<7.0.0", "html2text>=2020.1.16,<2021.0.0"]
 use_computer = [
-    "opencv-python>=4.5.0,<5.0.0", 
-    "psutil>=5.8.0,<6.0.0", 
-    "pyautogui>=0.9.53,<1.0.0", 
+    "opencv-python>=4.5.0,<5.0.0",
+    "psutil>=5.8.0,<6.0.0",
+    "pyautogui>=0.9.53,<1.0.0",
     "pytesseract>=0.3.8,<1.0.0"
 ]
 
@@ -215,4 +217,4 @@ name = "cz_conventional_commits"
 tag_format = "v$version"
 bump_message = "chore(release): bump version $current_version -> $new_version"
 version_files = ["pyproject.toml:version"]
-update_changelog_on_bump = true
+update_changelog_on_bump = true

src/strands_tools/a2a_client.py

@@ -6,6 +6,7 @@
 Key Features:
 - Agent discovery through agent cards from multiple URLs
 - Message sending to specific A2A agents
+- Push notification support for real-time task completion alerts
 """
 
 import asyncio
@@ -14,8 +15,8 @@
 from uuid import uuid4
 
 import httpx
-from a2a.client import A2ACardResolver, A2AClient
-from a2a.types import AgentCard, Message, MessageSendParams, Part, Role, SendMessageRequest, TextPart
+from a2a.client import A2ACardResolver, ClientConfig, ClientFactory
+from a2a.types import AgentCard, Message, Part, PushNotificationConfig, Role, TextPart
 from strands import tool
 from strands.types.tools import AgentTool
 
@@ -31,20 +32,35 @@ def __init__(
         self,
         known_agent_urls: list[str] | None = None,
         timeout: int = DEFAULT_TIMEOUT,
+        webhook_url: str | None = None,
+        webhook_token: str | None = None,
     ):
         """
         Initialize A2A client tool provider.
 
         Args:
-            agent_urls: List of A2A agent URLs to use (defaults to None)
-            timeout: Timeout for HTTP operations in seconds (defaults to 30)
+            known_agent_urls: List of A2A agent URLs to use (defaults to None)
+            timeout: Timeout for HTTP operations in seconds (defaults to 300)
+            webhook_url: Optional webhook URL for push notifications
+            webhook_token: Optional authentication token for webhook notifications
         """
         self.timeout = timeout
         self._known_agent_urls: list[str] = known_agent_urls or []
         self._discovered_agents: dict[str, AgentCard] = {}
         self._httpx_client: httpx.AsyncClient | None = None
+        self._client_factory: ClientFactory | None = None
         self._initial_discovery_done: bool = False
 
+        # Push notification configuration
+        self._webhook_url = webhook_url
+        self._webhook_token = webhook_token
+        self._push_config: PushNotificationConfig | None = None
+
+        if self._webhook_url and self._webhook_token:
+            self._push_config = PushNotificationConfig(
+                id=f"strands-webhook-{uuid4().hex[:8]}", url=self._webhook_url, token=self._webhook_token
+            )
+
     @property
     def tools(self) -> list[AgentTool]:
         """Extract all @tool decorated methods from this instance."""
@@ -66,15 +82,20 @@ async def _ensure_httpx_client(self) -> httpx.AsyncClient:
             self._httpx_client = httpx.AsyncClient(timeout=self.timeout)
         return self._httpx_client
 
-    async def _create_a2a_client(self, url: str) -> A2AClient:
-        """Create a new A2A client for the given URL."""
-        httpx_client = await self._ensure_httpx_client()
-        agent_card = await self._discover_agent_card(url)
-        logger.info(f"A2AClient created for {url}")
-        return A2AClient(httpx_client=httpx_client, agent_card=agent_card)
+    async def _ensure_client_factory(self) -> ClientFactory:
+        """Ensure the ClientFactory is initialized."""
+        if self._client_factory is None:
+            httpx_client = await self._ensure_httpx_client()
+            config = ClientConfig(
+                httpx_client=httpx_client,
+                streaming=False,  # Use non-streaming mode for simpler response handling
+                push_notification_configs=[self._push_config] if self._push_config else [],
+            )
+            self._client_factory = ClientFactory(config)
+        return self._client_factory
 
     async def _create_a2a_card_resolver(self, url: str) -> A2ACardResolver:
-        """Create a new A2A client for the given URL."""
+        """Create a new A2A card resolver for the given URL."""
         httpx_client = await self._ensure_httpx_client()
         logger.info(f"A2ACardResolver created for {url}")
         return A2ACardResolver(httpx_client=httpx_client, base_url=url)
@@ -213,7 +234,11 @@ async def _send_message(
 
         try:
             await self._ensure_discovered_known_agents()
-            client = await self._create_a2a_client(target_agent_url)
+
+            # Get the agent card and create client using factory
+            agent_card = await self._discover_agent_card(target_agent_url)
+            client_factory = await self._ensure_client_factory()
+            client = client_factory.create(agent_card)
 
             if message_id is None:
                 message_id = uuid4().hex
@@ -225,14 +250,45 @@ async def _send_message(
                 message_id=message_id,
             )
 
-            request = SendMessageRequest(id=str(uuid4()), params=MessageSendParams(message=message))
-
             logger.info(f"Sending message to {target_agent_url}")
-            response = await client.send_message(request)
 
+            # With streaming=False, this will yield exactly one result
+            async for event in client.send_message(message):
+                if isinstance(event, Message):
+                    # Direct message response
+                    return {
+                        "status": "success",
+                        "response": event.model_dump(mode="python", exclude_none=True),
+                        "message_id": message_id,
+                        "target_agent_url": target_agent_url,
+                    }
+                elif isinstance(event, tuple) and len(event) == 2:
+                    # (Task, UpdateEvent) tuple - extract the task
+                    task, update_event = event
+                    return {
+                        "status": "success",
+                        "response": {
+                            "task": task.model_dump(mode="python", exclude_none=True),
+                            "update": (
+                                update_event.model_dump(mode="python", exclude_none=True) if update_event else None
+                            ),
+                        },
+                        "message_id": message_id,
+                        "target_agent_url": target_agent_url,
+                    }
+                else:
+                    # Fallback for unexpected response types
+                    return {
+                        "status": "success",
+                        "response": {"raw_response": str(event)},
+                        "message_id": message_id,
+                        "target_agent_url": target_agent_url,
+                    }
+
+            # This should never be reached with streaming=False
             return {
-                "status": "success",
-                "response": response.model_dump(mode="python", exclude_none=True),
+                "status": "error",
+                "error": "No response received from agent",
                 "message_id": message_id,
                 "target_agent_url": target_agent_url,
             }

src/strands_tools/browser/__init__.py

@@ -19,12 +19,34 @@
     agent = Agent(tools=[browser.browser])
 
     # Use the browser
-    agent.tool.browser({
-        "action": {
-            "type": "navigate",
-            "url": "https://example.com"
+    agent.tool.browser(
+        browser_input={
+            "action": {
+                "type": "init_session",
+                "description": "Example ession",
+                "session_name": "example-session"
+            }
         }
-    })
+    )
+
+    agent.tool.browser(
+        browser_input={
+            "action": {
+                "type": "navigate",
+                "url": "https://example.com",
+                "session_name": "example-session"
+            }
+        }
+    )
+
+    agent.tool.browser(
+        browser_input={
+            "action": {
+                "type": "close",
+                "session_name": "example-session"
+            }
+        }
+    )
     ```
 """
 

src/strands_tools/browser/agent_core_browser.py

@@ -16,11 +16,13 @@
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_IDENTIFIER = "aws.browser.v1"
+
 
 class AgentCoreBrowser(Browser):
     """Bedrock AgentCore browser implementation."""
 
-    def __init__(self, region: Optional[str] = None, session_timeout: int = 3600):
+    def __init__(self, region: Optional[str] = None, identifier: str = DEFAULT_IDENTIFIER, session_timeout: int = 3600):
         """
         Initialize the browser.
 
@@ -44,7 +46,7 @@ async def create_browser_session(self) -> PlaywrightBrowser:
 
         # Create new browser client for this session
         session_client = AgentCoreBrowserClient(region=self.region)
-        session_id = session_client.start(session_timeout_seconds=self.session_timeout)
+        session_id = session_client.start(identifier=self.identifier, session_timeout_seconds=self.session_timeout)
 
         logger.info(f"started Bedrock AgentCore browser session: {session_id}")