clap-agents 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

clap/__init__.py

@@ -12,7 +12,7 @@ from .embedding.base_embedding import EmbeddingFunctionInterface
 
 from .vector_stores.base import VectorStoreInterface, QueryResult
 
-from .mcp_client.client import MCPClientManager, SseServerConfig
+from .mcp_client.client import MCPClientManager, ServerConfig, TransportType
 
 from .tools.web_search import duckduckgo_search
 

clap/embedding/fastembed_embedding.py

@@ -57,7 +57,7 @@ class FastEmbedEmbeddings(EmbeddingFunctionInterface):
         except Exception as e:
             raise RuntimeError(f"Failed to initialize fastembed model '{self.model_name}': {e}")
 
-    async def __call__(self, input: List[str]) -> List[List[float]]: # Changed to 'input'
+    async def __call__(self, input: List[str]) -> List[List[float]]: 
         if not input: return []
         if not _FASTEMBED_LIB_AVAILABLE: raise RuntimeError("FastEmbed library not available.")
         

clap/llm_services/__init__.py

@@ -1,4 +1,3 @@
-# src/clap/llm_services/__init__.py
 from .base import LLMServiceInterface, StandardizedLLMResponse, LLMToolCall
 from .groq_service import GroqService
 from .google_openai_compat_service import GoogleOpenAICompatService

clap/llm_services/base.py

@@ -32,7 +32,6 @@ class LLMServiceInterface(abc.ABC):
         messages: List[Dict[str, Any]],
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: str = "auto",
-        # Optional: 
         # temperature: Optional[float] = None,
         # max_tokens: Optional[int] = None,
     ) -> StandardizedLLMResponse:

clap/llm_services/ollama_service.py

@@ -64,27 +64,35 @@ class OllamaOpenAICompatService(LLMServiceInterface):
         if not request_model: raise ValueError("Ollama model name not specified.")
         try:
             api_kwargs: Dict[str, Any] = {"messages": messages, "model": request_model}
+
             if tools and tool_choice != "none":
                 api_kwargs["tools"] = tools
                 if isinstance(tool_choice, dict) or tool_choice in ["auto", "required", "none"]: api_kwargs["tool_choice"] = tool_choice
             else: api_kwargs["tools"] = None; api_kwargs["tool_choice"] = None
+
             if temperature is not None: api_kwargs["temperature"] = temperature
             if max_tokens is not None: api_kwargs["max_tokens"] = max_tokens
             api_kwargs = {k: v for k, v in api_kwargs.items() if v is not None}
             # print(f"OllamaService: Sending request to model '{request_model}'")
             response = await self._client.chat.completions.create(**api_kwargs)
+
             message = response.choices[0].message
+
             text_content = message.content
             tool_calls_std: List[LLMToolCall] = []
+
             if message.tool_calls:
                 for tc in message.tool_calls:
                     if tc.id and tc.function and tc.function.name and tc.function.arguments is not None:
                         tool_calls_std.append(LLMToolCall(id=tc.id, function_name=tc.function.name, function_arguments_json_str=tc.function.arguments))
                     else: print(f"{Fore.YELLOW}Warning: Incomplete tool_call from Ollama: {tc}{Fore.RESET}")
+
             return StandardizedLLMResponse(text_content=text_content, tool_calls=tool_calls_std)
+        
         except _OpenAIError_Placeholder_Type as e: # Use placeholder
             err_msg = f"Ollama (OpenAI Compat) API Error: {e}"
             if hasattr(e, 'response') and e.response and hasattr(e.response, 'text'): err_msg += f" - Details: {e.response.text}"
+            
             print(f"{Fore.RED}{err_msg}{Fore.RESET}")
             return StandardizedLLMResponse(text_content=err_msg)
         except Exception as e:

clap/mcp_client/client.py

@@ -1,35 +1,69 @@
-
 import asyncio
 import json
 from contextlib import AsyncExitStack
 from typing import Any, Dict, List, Optional
+from enum import Enum 
 
-from pydantic import BaseModel, Field, HttpUrl 
+from pydantic import BaseModel, Field, HttpUrl , model_validator
+from colorama import Fore
 
 from mcp import ClientSession, types
 from mcp.client.sse import sse_client
-from colorama import Fore
-
-class SseServerConfig(BaseModel):
-    """Configuration for connecting to an MCP server via SSE."""
-    url: HttpUrl = Field(description="The base URL of the MCP SSE server.")
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.client.stdio import stdio_client, StdioServerParameters
+
+
+# Define an Enum for transport types for clarity and type safety
+class TransportType(str, Enum):
+    STREAMABLE_HTTP = "streamable_http"
+    SSE = "sse"
+    STDIO = 'stdio'
+
+# Rename SseServerConfig to ServerConfig and add the transport field
+class ServerConfig(BaseModel):
+    """Configuration for connecting to an MCP server."""
+    transport: TransportType = Field(
+        default=TransportType.STREAMABLE_HTTP,
+        description="The MCP transport to use."
+    )
+    # Fields for HTTP-based transports
+    url: Optional[HttpUrl] = Field(default=None, description="The base URL for HTTP/SSE based MCP servers.")
     headers: Optional[Dict[str, str]] = Field(default=None, description="Optional headers for the connection.")
+    
+    # Fields for STDIO transport
+    command: Optional[str] = Field(default=None, description="The command to execute for stdio-based servers.")
+    args: Optional[List[str]] = Field(default=None, description="A list of arguments for the command.")
+
+    @model_validator(mode='after')
+    def check_transport_params(self) -> 'ServerConfig':
+        """Ensures the correct parameters are provided for the chosen transport."""
+        if self.transport in [TransportType.STREAMABLE_HTTP, TransportType.SSE]:
+            if not self.url:
+                raise ValueError(f"'url' is required for '{self.transport.value}' transport")
+        elif self.transport == TransportType.STDIO:
+            if not self.command:
+                raise ValueError(f"'command' is required for '{self.transport.value}' transport")
+        
+        return self
 
+# Update the class docstring to be more generic
 class MCPClientManager:
     """
-    Manages connections and interactions with multiple MCP servers via SSE.
+    Manages connections and interactions with multiple MCP servers via supported
+    MCP transports (Streamable HTTP, SSE).
 
     Handles connecting, disconnecting, listing tools, and calling tools on
     configured MCP servers accessible over HTTP/S.
     """
 
-    def __init__(self, server_configs: Dict[str, SseServerConfig]):
+    # Update the __init__ method to use the new ServerConfig
+    def __init__(self, server_configs: Dict[str, ServerConfig]):
         """
-        Initializes the manager with SSE server configurations.
+        Initializes the manager with server configurations.
 
         Args:
             server_configs: A dictionary where keys are logical server names
-                            and values are SseServerConfig objects.
+                            and values are ServerConfig objects.
         """
         if not isinstance(server_configs, dict):
              raise TypeError("server_configs must be a dictionary.")
@@ -39,11 +73,11 @@ class MCPClientManager:
         self._connect_locks: Dict[str, asyncio.Lock] = {
              name: asyncio.Lock() for name in server_configs
         }
-        self._manager_lock = asyncio.Lock() # General lock for manager state
+        self._manager_lock = asyncio.Lock()
 
     async def _ensure_connected(self, server_name: str):
         """
-        Ensures a connection via SSE to the specified server is active.
+        Ensures a connection to the specified server is active using the configured transport.
 
         Args:
             server_name: The logical name of the server to connect to.
@@ -67,43 +101,68 @@ class MCPClientManager:
             if not config:
                 raise ValueError(f"Configuration for server '{server_name}' not found.")
 
-            print(f"{Fore.YELLOW}Attempting to connect to MCP server via SSE: {server_name} at {config.url}{Fore.RESET}")
-
-            # Construct the specific SSE endpoint URL (often /sse)
-            sse_url = str(config.url).rstrip('/') + "/sse" 
-
             exit_stack = AsyncExitStack()
             try:
-                
-                sse_transport = await exit_stack.enter_async_context(
-                    sse_client(url=sse_url, headers=config.headers)
-                )
-                read_stream, write_stream = sse_transport
+                if config.transport == TransportType.STDIO:
+                    if not config.command:
+                        raise ValueError("Cannot connect to STDIO server without a 'command'.")
+                    
+                    print(f"{Fore.YELLOW}Attempting to connect to MCP server '{server_name}' using STDIO transport...{Fore.RESET}")
+                    print(f"  Command: {config.command} {' '.join(config.args or [])}")
+
+                    server_params = StdioServerParameters(command=config.command, args=config.args or [])
+                    stdio_transport_streams = await exit_stack.enter_async_context(
+                        stdio_client(server_params)
+                    )
+                    read_stream, write_stream = stdio_transport_streams
+                    transport_name = "STDIO"
+                # Core logic change - branch based on the configured transport
+                elif config.transport == TransportType.STREAMABLE_HTTP:
+                    mcp_endpoint_url = str(config.url).rstrip('/')
+                    print(f"{Fore.YELLOW}Attempting to connect to MCP server '{server_name}' at {mcp_endpoint_url} using Streamable HTTP transport...{Fore.RESET}")
+
+                    # Use the new streamablehttp_client
+                    http_transport = await exit_stack.enter_async_context(
+                        streamablehttp_client(url=mcp_endpoint_url, headers=config.headers, auth=None)
+                    )
+                    # It returns three values; we only need the first two.
+                    read_stream, write_stream, _ = http_transport
+                    transport_name = "Streamable HTTP"
+
+                elif config.transport == TransportType.SSE:
+                    # This branch maintains backward compatibility
+                    sse_url = str(config.url).rstrip('/') + "/sse"
+                    print(f"{Fore.YELLOW}Attempting to connect to MCP server '{server_name}' at {sse_url} using legacy SSE transport...{Fore.RESET}")
+
+                    # Use the old sse_client
+                    sse_transport = await exit_stack.enter_async_context(
+                        sse_client(url=sse_url, headers=config.headers)
+                    )
+                    read_stream, write_stream = sse_transport
+                    transport_name = "legacy SSE"
+
+                else:
+                    raise ValueError(f"Unsupported transport type configured for server '{server_name}': {config.transport}")
 
-                
                 session = await exit_stack.enter_async_context(
                     ClientSession(read_stream, write_stream)
                 )
 
-                
                 await session.initialize()
 
                 async with self._manager_lock:
                     self.sessions[server_name] = session
                     self.exit_stacks[server_name] = exit_stack
-                print(f"{Fore.GREEN}Successfully connected to MCP server via SSE: {server_name}{Fore.RESET}")
+                print(f"{Fore.GREEN}Successfully connected to MCP server '{server_name}' via {transport_name}{Fore.RESET}")
 
             except Exception as e:
                 await exit_stack.aclose()
-                print(f"{Fore.RED}Failed to connect to MCP server '{server_name}' via SSE: {e}{Fore.RESET}")
-                raise RuntimeError(f"SSE connection to '{server_name}' failed.") from e
+                print(f"{Fore.RED}Failed to connect to MCP server '{server_name}': {e}{Fore.RESET}")
+                raise RuntimeError(f"Connection to '{server_name}' failed.") from e
 
     async def disconnect(self, server_name: str):
         """
         Disconnects from a specific server and cleans up resources.
-
-        Args:
-            server_name: The logical name of the server to disconnect from.
         """
         async with self._manager_lock:
              if server_name in self.sessions:
@@ -113,7 +172,7 @@ class MCPClientManager:
                  await exit_stack.aclose()
                  print(f"{Fore.GREEN}Disconnected from MCP server: {server_name}{Fore.RESET}")
 
-        
+
     async def disconnect_all(self):
         server_names = list(self.sessions.keys())
         print(f"{Fore.YELLOW}MCPClientManager: Disconnecting from all servers ({len(server_names)})...{Fore.RESET}")
@@ -126,13 +185,7 @@ class MCPClientManager:
 
     async def list_remote_tools(self, server_name: str) -> List[types.Tool]:
         """
-        Lists tools available on a specific connected SSE server.
-
-        Args:
-            server_name: The logical name of the server.
-
-        Returns:
-            A list of mcp.types.Tool objects provided by the server.
+        Lists tools available on a specific connected server.
         """
         await self._ensure_connected(server_name)
         session = self.sessions.get(server_name)
@@ -152,15 +205,7 @@ class MCPClientManager:
         self, server_name: str, tool_name: str, arguments: Dict[str, Any]
     ) -> str:
         """
-        Calls a tool on a specific connected SSE server.
-
-        Args:
-            server_name: The logical name of the server.
-            tool_name: The name of the tool to call.
-            arguments: A dictionary of arguments for the tool.
-
-        Returns:
-            A string representation of the tool's result content.
+        Calls a tool on a specific connected server.
         """
         await self._ensure_connected(server_name)
         session = self.sessions.get(server_name)
@@ -193,4 +238,4 @@ class MCPClientManager:
 
         except Exception as e:
              print(f"{Fore.RED}Error calling tool '{tool_name}' on server '{server_name}': {e}{Fore.RESET}")
-             raise RuntimeError(f"Failed to call tool '{tool_name}' on '{server_name}'.") from e
+             raise RuntimeError(f"Failed to call tool '{tool_name}' on '{server_name}'.") from e

clap/multiagent_pattern/agent.py

@@ -74,6 +74,7 @@ class Agent:
         mcp_server_names: Optional[List[str]] = None,
         vector_store: Optional[VectorStoreInterface] = None,
         parallel_tool_calls: bool = True , 
+        **kwargs
         # embedding_function: Optional[EmbeddingFunction] = None,
 
     ):
@@ -86,6 +87,7 @@ class Agent:
         self.local_tools = tools or [] 
 
         self.vector_store = vector_store
+        self.react_agent_kwargs = kwargs
         # self.embedding_function = embedding_function 
 
         llm_service_instance = llm_service or GroqService()
@@ -193,7 +195,7 @@ class Agent:
         self.task_description = original_task_description 
 
         print(f"Agent {self.name}: Running ReactAgent...")
-        raw_output = await self.react_agent.run(user_msg=msg) 
+        raw_output = await self.react_agent.run(user_msg=msg,**self.react_agent_kwargs) 
         output_data = {"output": raw_output}
 
         print(f"Agent {self.name}: Passing context to {len(self.dependents)} dependents...")

clap/tool_pattern/tool.py

@@ -16,9 +16,11 @@ def get_fn_signature(fn: Callable) -> dict:
     sig = inspect.signature(fn)
     for name, type_hint in fn.__annotations__.items():
         if name == "return": continue
+        
         param_type_name = getattr(type_hint, "__name__", str(type_hint))
         schema_type = type_mapping.get(param_type_name.lower(), "string") 
         parameters["properties"][name] = {"type": schema_type}
+
         if sig.parameters[name].default is inspect.Parameter.empty:
             parameters["required"].append(name)
     if not parameters.get("required"): 

clap/tools/web3_tools.py

@@ -3,18 +3,15 @@ from web3 import Web3
 from clap.tool_pattern.tool import tool
 import json 
 
-# Environment variables are loaded by the main application script.
 
 WEB3_PROVIDER_URL = os.getenv("WEB3_PROVIDER_URL")
 AGENT_PRIVATE_KEY = os.getenv("AGENT_PRIVATE_KEY")
 
-# --- Official Testnet Addresses ---
 WETH_CONTRACT_ADDRESS = "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"
 UNISWAP_ROUTER_ADDRESS = "0x3bFA4769FB09eefC5a399D6D47036A5d3fA67B54"
 CHAINLINK_ETH_USD_PRICE_FEED_ADDRESS = "0x694AA1769357215DE4FAC081bf1f309aDC325306"
 
 
-# --- Correct, Centralized ABIs ---
 CHAINLINK_PRICE_FEED_ABI = """
 [
   {
@@ -106,14 +103,11 @@ def get_token_price(token_pair: str) -> str:
             abi=CHAINLINK_PRICE_FEED_ABI
         )
         
-        # The latestRoundData function returns a tuple of values. The price is the second element.
         latest_data = price_feed_contract.functions.latestRoundData().call()
         price_raw = latest_data[1]
         
-        # The price feed also has a 'decimals' function to tell us where to put the decimal point.
         price_decimals = price_feed_contract.functions.decimals().call()
         
-        # Convert the raw price to a human-readable format
         price = price_raw / (10 ** price_decimals)
         
         return f"The latest price for {token_pair} is ${price:.2f}"
@@ -174,7 +168,6 @@ def interact_with_contract(
     try:
         _initialize_web3()
 
-        # 1. Validate inputs
         if not w3.is_address(contract_address):
             return "Error: Invalid 'contract_address'."
         try:
@@ -182,20 +175,17 @@ def interact_with_contract(
         except json.JSONDecodeError:
             return "Error: The provided 'abi' is not a valid JSON string."
 
-        # 2. Create the contract object
         contract = w3.eth.contract(address=contract_address, abi=abi_json)
 
-        # 3. Get the function object from the contract
         func_to_call = getattr(contract.functions, function_name)
         if not func_to_call:
             return f"Error: Function '{function_name}' not found in the contract's ABI."
 
-        # 4. Prepare the function call with its arguments
         prepared_func = func_to_call(*function_args)
 
-        # 5. Execute as either a read-only 'call' or a write 'transaction'
+    
         if is_write_transaction:
-            # This is a state-changing transaction that costs gas
+           
             nonce = w3.eth.get_transaction_count(agent_account.address)
             tx = prepared_func.build_transaction({
                 'from': agent_account.address,
@@ -206,9 +196,9 @@ def interact_with_contract(
             tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
             return f"Write transaction sent successfully. Transaction hash: {w3.to_hex(tx_hash)}"
         else:
-            # This is a read-only call that is free and instant
+            
             result = prepared_func.call()
-            # Convert the result to a JSON string to ensure it's readable by the LLM
+           
             return json.dumps(result)
 
     except Exception as e:
@@ -224,7 +214,7 @@ def get_erc20_balance(token_address: str, wallet_address: str) -> str:
         
         token_contract = w3.eth.contract(address=chk_token_address, abi=ERC20_STANDARD_ABI)
         
-        # This will now work correctly with a real contract address
+
         decimals = token_contract.functions.decimals().call()
         raw_balance = token_contract.functions.balanceOf(chk_wallet_address).call()
             
@@ -232,7 +222,7 @@ def get_erc20_balance(token_address: str, wallet_address: str) -> str:
         return str(balance)
         
     except Exception as e:
-        # A simple, honest error handler for genuine problems.
+       
         return f"Error in get_erc20_balance for token {token_address}: {e}"
 
 @tool
@@ -278,12 +268,11 @@ def swap_tokens_for_tokens(token_in_address: str, token_out_address: str, amount
         signed_approve_tx = w3.eth.account.sign_transaction(approve_tx, private_key=os.getenv("AGENT_PRIVATE_KEY"))
         approve_tx_hash = w3.eth.send_raw_transaction(signed_approve_tx.raw_transaction)
         
-        # --- THE FIX ---
-        # Wait for the approval transaction to be confirmed.
+       
         print(f"Waiting for approval transaction {w3.to_hex(approve_tx_hash)} to be confirmed...")
         w3.eth.wait_for_transaction_receipt(approve_tx_hash)
 
-        # Step 2: Swap
+        
         uniswap_router = w3.eth.contract(address=chk_router_address, abi=UNISWAP_ABI)
         swap_params = (chk_token_in, chk_token_out, fee, agent_account.address, amount_in_wei, 0, 0)
         

{clap_agents-0.3.0.dist-info → clap_agents-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clap-agents
-Version: 0.3.0
+Version: 0.3.2
 Summary: A Python framework for building cognitive agentic patterns including ReAct agents, Multi-Agent Teams, native tool calling, and MCP client integration.
 Project-URL: Homepage, https://github.com/MaitreyaM/CLAP-AGENTS.git
 Project-URL: Repository, https://github.com/MaitreyaM/CLAP-AGENTS.git
@@ -513,24 +513,26 @@ asyncio.run(main())
 ```
 
 
-New in v0.3.0: Web3 & On-Chain Agent Capabilities
+## New in v0.3.0: Web3 & On-Chain Agent Capabilities
 CLAP now includes a powerful toolkit for building autonomous agents that can interact directly with EVM-compatible blockchains like Ethereum. Your agents can now hold assets, execute transactions, and interact with smart contracts, opening up a new world of possibilities in DeFi, DAOs, and on-chain automation.
 Setup
 To enable Web3 capabilities, install the web3 extra:
+```
 pip install "clap-agents[web3]"
-Use code with caution.
-Bash
+```
+
 You will also need to set the following variables in your .env file:
+```
 # Your connection to the blockchain (e.g., from Alchemy or Infura)
 WEB3_PROVIDER_URL="https://sepolia.infura.io/v3/YOUR_API_KEY"
 
 # The private key for your agent's wallet.
 # WARNING: For testing only. Do not use a key with real funds.
 AGENT_PRIVATE_KEY="0xYourTestnetPrivateKeyHere"
+```
 
 
-
-# Core Web3 Tools
+## Core Web3 Tools
 The framework now includes a suite of pre-built, robust tools for on-chain interaction:
 
 get_erc20_balance: Checks the balance of any standard ERC-20 token in a wallet.
@@ -544,9 +546,10 @@ get_token_price: Fetches real-time asset prices from on-chain Chainlink oracles,
 interact_with_contract: A powerful, generic tool to call any function on any smart contract, given its address and ABI.
 
 
-# Quick Start: A Simple DeFi Agent
+## Quick Start: A Simple DeFi Agent
 This example demonstrates an agent that can wrap ETH and then swap it for another token, a common DeFi task.
-# examples/simple_defi_agent.py
+```
+
 import os
 import asyncio
 from dotenv import load_dotenv
@@ -585,7 +588,7 @@ async def main():
 
 if __name__ == "__main__":
     asyncio.run(main())
-
+```
 
 This new capability transforms your CLAP agents from simple observers into active participants in the decentralized economy.
 
@@ -604,4 +607,3 @@ License
 This project is licensed under the terms of the Apache License 2.0. See the LICENSE file for details.
 
 
-

{clap_agents-0.3.0.dist-info → clap_agents-0.3.2.dist-info}/RECORD

@@ -1,27 +1,27 @@
-clap/__init__.py,sha256=rxxESl-xpSZpM4ZIh-GvHYF74CkQdbe-dSLvhMC_2dQ,1069
+clap/__init__.py,sha256=1U3LyIQ60FOOFKLNmdjqNMgN0rbNOO6ggNcDVTMz5SI,1081
 clap/embedding/__init__.py,sha256=PqnqcSiA_JwEvn69g2DCQHdsffL2l4GNEKo0fAtCqbs,520
 clap/embedding/base_embedding.py,sha256=0SYicQ-A-rSDqHoFK0IOrRQe0cisOl8OBnis6V43Chs,696
-clap/embedding/fastembed_embedding.py,sha256=V03b8bnSk1wtjJq5qlM9iksQnH6bnxrgXK8KbaEvxaQ,2882
+clap/embedding/fastembed_embedding.py,sha256=fUXCRyctPxwinAG2JCkdmlARU945z7dEsXScIkpqwb0,2862
 clap/embedding/ollama_embedding.py,sha256=s7IYFs4BuM114Md1cqxim5WzCwCjbEJ48wAZZOgR7KQ,3702
 clap/embedding/sentence_transformer_embedding.py,sha256=0RAqGxDpjZVwerOLmVirqqnCwC07kHdfAPiy2fgOSCk,1798
-clap/llm_services/__init__.py,sha256=js__xIlkbXBLd2q1trYKjATYWa4xLNgPwwJz2Flwi0s,532
-clap/llm_services/base.py,sha256=BjSBVOtPMvPZJjI3HwSSI3OvVFyxd5HeOKLI9bN6P7M,2204
+clap/llm_services/__init__.py,sha256=IBvWmE99PGxHq5Dt4u0G1erZSV80QEC981UULnrD6Tk,496
+clap/llm_services/base.py,sha256=-XKWd6gLAXedIhUUqM_f7sqkVxdfifP2j-BwmF0hUkI,2183
 clap/llm_services/google_openai_compat_service.py,sha256=vN0osfCS6DIFHsCCiB03mKUp4n7SkIJd2PAypBAnC30,4552
 clap/llm_services/groq_service.py,sha256=pcTp24_NgLfp3bGaABzli_Sey7wZsXvFI74VjZ1GvkQ,3051
-clap/llm_services/ollama_service.py,sha256=gpWENKh4bhJh5VfIr7hmuqNOq-s1Zodvx8ws70vmq70,5305
+clap/llm_services/ollama_service.py,sha256=Qh3W2fb-NDMVB8DS9o3q4jisZvK9U6s-r4ATNbAwVLE,5333
 clap/mcp_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clap/mcp_client/client.py,sha256=skIWhwkHnRXjlHwBvKXNZD5yQDe1iRIjrikn7WwczGM,8713
+clap/mcp_client/client.py,sha256=MqcGEVe04B1vH0EGFaqXAEMCh_0C851MDr9hzGEBIM8,11729
 clap/multiagent_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clap/multiagent_pattern/agent.py,sha256=5wT1sy9IRZxMiqzj1ew7CbFFc03tIOExjxNb8y441bc,8533
+clap/multiagent_pattern/agent.py,sha256=SDebwxaUquFUN_MMCGSYKLIIA3a6tVIls-IGrnEKqJI,8617
 clap/multiagent_pattern/team.py,sha256=t8Xru3fVPblw75pyuPT1wmI3jlsrZHD_GKAW5APbpFg,7966
 clap/react_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clap/react_pattern/react_agent.py,sha256=v9JYyIwv0vzkOl6kq8Aua7u50rJyU02NomCHTjt24vo,24596
 clap/tool_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clap/tool_pattern/tool.py,sha256=7fHkLTPafsAWr_ECXZKpQz0zzqEAxSrQ56ns5oWcBSU,5964
+clap/tool_pattern/tool.py,sha256=Y4Uvu5FsCA3S3BZfjM3OOKfhA-o5Q9SfhCzGWfGIQ6o,5974
 clap/tool_pattern/tool_agent.py,sha256=VTQv9DNU16zgINZKVcX5oDw1lPfw5Y_8bUnW6wad2vE,14439
 clap/tools/__init__.py,sha256=8UMtxaPkq-pEOD2C0Qm4WZoyJpMxEOEQSDhWNLwAAiI,822
 clap/tools/email_tools.py,sha256=18aAlbjcSaOzpf9R3H-EGeRsqL5gdzmcJJcW619xOHU,9729
-clap/tools/web3_tools.py,sha256=N5enOoEVMx0T7TjB15NtEYt-_KcAdkm3C-UN0_QLVoo,12894
+clap/tools/web3_tools.py,sha256=bb9zqhXYima6LzLARh8zgPx_gV0m9g0rf8ZqazCx-og,11852
 clap/tools/web_crawler.py,sha256=WdFbAKhUsUVveJimmLbzQ6k1BhOdMsg87FjL628HEKM,3542
 clap/tools/web_search.py,sha256=YT0I1kPrdxMUst-dpsGqqF6aqxMgj3ACwiW_jN9Pu9s,985
 clap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -33,7 +33,7 @@ clap/vector_stores/__init__.py,sha256=H3w5jLdQFbXArVgiidy4RlAalM8a6LAiMlAX0Z-2v7
 clap/vector_stores/base.py,sha256=nvk8J1oNG3OKFhJfxBGFyVeh9YxoDs9RkB_iOzPBm1w,2853
 clap/vector_stores/chroma_store.py,sha256=vwkWWGxPwuW45T1PS6D44dXhDG9U_KZWjrMZCOkEXsA,7242
 clap/vector_stores/qdrant_store.py,sha256=-SwMTb0yaGngpQ9AddDzDIt3x8GZevlFT-0FMkWD28I,9923
-clap_agents-0.3.0.dist-info/METADATA,sha256=XPkseVTiOmoXluFd0CxYS7r37i7OyHhcm6EiMRk1ZYU,30573
-clap_agents-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-clap_agents-0.3.0.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-clap_agents-0.3.0.dist-info/RECORD,,
+clap_agents-0.3.2.dist-info/METADATA,sha256=HcN7nnvyCWF3YxREc6BmAoscQ5vpe0UWSRnz99qeKeQ,30541
+clap_agents-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+clap_agents-0.3.2.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+clap_agents-0.3.2.dist-info/RECORD,,