clap-agents 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

clap/embedding/fastembed_embedding.py

@@ -36,7 +36,7 @@ class FastEmbedEmbeddings(EmbeddingFunctionInterface):
         if not _FASTEMBED_LIB_AVAILABLE:
             raise ImportError(
                 "The 'fastembed' library is required to use FastEmbedEmbeddings. "
-                "Install with 'pip install fastembed' or 'pip install \"clap-agents[qdrant]\"' (if qdrant includes it as an extra)."
+                "Install with 'pip install fastembed' "
             )
 
         self.model_name = model_name
@@ -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/google_openai_compat_service.py

@@ -1,4 +1,3 @@
-# --- START OF agentic_patterns/llm_services/google_openai_compat_service.py ---
 
 import os
 import json
@@ -56,7 +55,7 @@ class GoogleOpenAICompatService(LLMServiceInterface):
         Sends messages via the OpenAI SDK (to Google's endpoint) and returns a standardized response.
 
         Args:
-            model: The Google model identifier (e.g., "gemini-1.5-flash").
+            model: The Google model identifier (e.g., "gemini-2.0-flash").
             messages: Chat history in the OpenAI dictionary format.
             tools: Tool schemas in the OpenAI function format.
             tool_choice: Tool choice setting ("auto", "none", etc.).
@@ -92,6 +91,7 @@ class GoogleOpenAICompatService(LLMServiceInterface):
                 for tc in message.tool_calls:
                     tool_call_id = getattr(tc, 'id', None)
                     if not tool_call_id:
+                        #raise ValueError("Received a tool call from the Gemini API without a required 'id'.")
                         tool_call_id = f"compat_call_{uuid.uuid4().hex[:6]}" 
                         print(f"{Fore.YELLOW}Warning: Tool call from Google compat layer missing ID. Generated fallback: {tool_call_id}{Fore.RESET}")
 

clap/llm_services/groq_service.py

@@ -18,7 +18,6 @@ class GroqService(LLMServiceInterface):
                     If None, a new client will be created using environment variables.
         """
         self.client = client or AsyncGroq()
-        # Add any other Groq-specific initialization here if needed
 
     async def get_llm_response(
         self,
@@ -26,7 +25,6 @@ class GroqService(LLMServiceInterface):
         messages: List[Dict[str, Any]],
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: str = "auto",
-        # Add other relevant Groq parameters if desired, e.g., temperature, max_tokens
         # 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:
@@ -98,4 +106,3 @@ class OllamaOpenAICompatService(LLMServiceInterface):
             elif hasattr(self._client, "_client") and hasattr(self._client._client, "is_closed"): # For httpx client in openai <1.0
                  if not self._client._client.is_closed: await self._client._client.aclose() # type: ignore
         # print("OllamaService: Client closed.")
-# --- END OF FILE ---

clap/mcp_client/client.py

@@ -39,7 +39,7 @@ 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):
         """

clap/multiagent_pattern/agent.py

@@ -56,7 +56,8 @@ class Agent:
         llm_service (Optional[LLMServiceInterface]): Service for LLM calls (defaults to GroqService).
         mcp_manager (Optional[MCPClientManager]): Shared MCP client manager.
         mcp_server_names (Optional[List[str]]): MCP servers this agent uses.
-        vector_store (Optional[VectorStoreInterface]): Vector store instance for RAG. 
+        vector_store (Optional[VectorStoreInterface]): Vector store instance for RAG.
+        parallel_tool_calls : Determine parallel or sequential execution of agent's tools. 
         # embedding_function(Optional[EmbeddingFunction]): EF if needed by agent. 
 
     """
@@ -71,7 +72,9 @@ class Agent:
         llm_service: Optional[LLMServiceInterface] = None,
         mcp_manager: Optional[MCPClientManager] = None,
         mcp_server_names: Optional[List[str]] = None,
-        vector_store: Optional[VectorStoreInterface] = None, 
+        vector_store: Optional[VectorStoreInterface] = None,
+        parallel_tool_calls: bool = True , 
+        **kwargs
         # embedding_function: Optional[EmbeddingFunction] = None,
 
     ):
@@ -84,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()
@@ -98,7 +102,8 @@ class Agent:
             tools=self.local_tools, 
             mcp_manager=self.mcp_manager,
             mcp_server_names=self.mcp_server_names,
-            vector_store=self.vector_store 
+            vector_store=self.vector_store, 
+            parallel_tool_calls=parallel_tool_calls 
         )
 
         self.dependencies: List['Agent'] = []
@@ -190,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/react_pattern/react_agent.py

@@ -54,10 +54,12 @@ class ReactAgent:
         mcp_server_names: Optional[List[str]] = None,  
         vector_store: Optional[VectorStoreInterface] = None, 
         system_prompt: str = "",
+        parallel_tool_calls: bool = True,
     ) -> None:
         self.llm_service = llm_service
         self.model = model
         self.agent_name = agent_name
+        self.parallel_tool_calls = parallel_tool_calls
         self.system_prompt = (system_prompt + "\n\n" + CORE_SYSTEM_PROMPT).strip()
 
         
@@ -275,30 +277,45 @@ class ReactAgent:
         return {tool_call_id: result_str}
 
 
-
-
     
     async def process_tool_calls(self, tool_calls: List[LLMToolCall]) -> Dict[str, Any]:
-        """Processes multiple tool calls concurrently."""
-        observations = {}
+        """
+        Processes tool calls using the configured strategy (parallel or sequential).
+        """
         if not isinstance(tool_calls, list):
             print(f"{Fore.RED}Error: Expected a list of LLMToolCall, got {type(tool_calls)}{Fore.RESET}")
-            return observations 
+            return {}
 
-        tasks = [self._execute_single_tool_call(tc) for tc in tool_calls]
-        results = await asyncio.gather(*tasks, return_exceptions=True)
+        observations = {}
 
-        for result in results:
-            if isinstance(result, dict) and len(result) == 1:
-                observations.update(result)
-            elif isinstance(result, Exception):
-                 
-                 print(f"{Fore.RED}Error during concurrent tool execution gather: {result}{Fore.RESET}")
-                 
-                 # observations[f"error_{len(observations)}"] = f"Tool execution failed: {result}"
-            else:
-                 print(f"{Fore.RED}Error: Unexpected item in tool execution results: {result}{Fore.RESET}")
+        if self.parallel_tool_calls:
+            # PARALLEL EXECUTION (FASTER, BUT CAN CAUSE RACE CONDITIONS) 
+            print(f"{Fore.BLUE}[{self.agent_name}] Executing {len(tool_calls)} tool calls in PARALLEL...{Fore.RESET}")
+            tasks = [self._execute_single_tool_call(tc) for tc in tool_calls]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            for result in results:
+                if isinstance(result, dict) and len(result) == 1:
+                    observations.update(result)
+                elif isinstance(result, Exception):
+                    print(f"{Fore.RED}Error during parallel tool execution gather: {result}{Fore.RESET}")
+                else:
+                    print(f"{Fore.RED}Error: Unexpected item in parallel tool execution results: {result}{Fore.RESET}")
 
+        else:
+            # SEQUENTIAL EXECUTION 
+            print(f"{Fore.YELLOW}[{self.agent_name}] Executing {len(tool_calls)} tool calls SEQUENTIALLY...{Fore.RESET}")
+            for tool_call in tool_calls:
+                try:
+                    result = await self._execute_single_tool_call(tool_call)
+                    if isinstance(result, dict) and len(result) == 1:
+                        observations.update(result)
+                    else:
+                        print(f"{Fore.RED}Error: Unexpected item in sequential tool execution result: {result}{Fore.RESET}")
+                except Exception as e:
+                    print(f"{Fore.RED}Error during sequential execution of {tool_call.function_name}: {e}{Fore.RESET}")
+                    observations[tool_call.id] = f"An unexpected error occurred: {e}"
+                
         return observations
 
 

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/__init__.py

@@ -1,4 +1,3 @@
-
 from .web_search import duckduckgo_search
 from .web_crawler import scrape_url, extract_text_by_query 
 from .email_tools import send_email, fetch_recent_emails
@@ -9,5 +8,20 @@ __all__ = [
     "extract_text_by_query",
     "send_email",
     "fetch_recent_emails",
+    "get_wallet_balance",
+    "send_eth",
+    "interact_with_contract",
+    'get_erc20_balance'
+    'swap_tokens_for_tokens',
+    'wrap_eth',
+    'get_token_price'
 ]
 
+try:
+    from .web3_tools import get_wallet_balance, send_eth, interact_with_contract, get_erc20_balance, swap_tokens_for_tokens, wrap_eth, get_token_price
+    __all__.extend([
+        "get_wallet_balance", "send_eth", "interact_with_contract", 
+        "get_erc20_balance", "swap_tokens_for_tokens", "wrap_eth", "get_token_price"
+    ])
+except ImportError:
+    pass

clap/tools/web3_tools.py

@@ -0,0 +1,301 @@
+import os
+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 = """
+[
+  {
+    "inputs": [],
+    "name": "latestRoundData",
+    "outputs": [
+      { "internalType": "uint80", "name": "roundId", "type": "uint80" },
+      { "internalType": "int256", "name": "answer", "type": "int256" },
+      { "internalType": "uint256", "name": "startedAt", "type": "uint256" },
+      { "internalType": "uint256", "name": "updatedAt", "type": "uint256" },
+      { "internalType": "uint80", "name": "answeredInRound", "type": "uint80" }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "decimals",
+    "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]
+"""
+ERC20_STANDARD_ABI = """
+[
+  {"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"type":"function"},
+  {"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"},
+  {"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"type":"function"}
+]
+"""
+WETH_ABI = """
+[
+  {"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},
+  {"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}
+]
+"""
+UNISWAP_ABI = """
+[{"inputs":[{"components":[{"type":"address","name":"tokenIn"},{"type":"address","name":"tokenOut"},{"type":"uint24","name":"fee"},{"type":"address","name":"recipient"},{"type":"uint256","name":"amountIn"},{"type":"uint256","name":"amountOutMinimum"},{"type":"uint160","name":"sqrtPriceLimitX96"}],"type":"tuple","name":"params"}],"name":"exactInputSingle","outputs":[{"type":"uint256","name":"amountOut"}],"stateMutability":"payable","type":"function"}]
+"""
+
+
+w3 = None
+agent_account = None
+
+def _initialize_web3():
+    """Initializes Web3 instance and account if they don't exist."""
+    global w3, agent_account, WEB3_PROVIDER_URL, AGENT_PRIVATE_KEY
+    if w3 is None:
+        WEB3_PROVIDER_URL = os.getenv("WEB3_PROVIDER_URL")
+        AGENT_PRIVATE_KEY = os.getenv("AGENT_PRIVATE_KEY")
+        
+        if not WEB3_PROVIDER_URL or not AGENT_PRIVATE_KEY:
+            raise ConnectionError("Web3 provider URL or Agent private key not found.")
+        w3 = Web3(Web3.HTTPProvider(WEB3_PROVIDER_URL))
+        agent_account = w3.eth.account.from_key(AGENT_PRIVATE_KEY)
+
+@tool
+def get_wallet_balance(address: str) -> str:
+    """
+    Gets the native token balance (Sepolia ETH) of a given wallet address.
+    """
+    try:
+        _initialize_web3()
+        balance_wei = w3.eth.get_balance(address)
+        balance_eth = w3.from_wei(balance_wei, 'ether')
+        return f"The balance of address {address} is {balance_eth} ETH."
+    except Exception as e:
+        return f"Error getting balance for address {address}: {e}"
+    
+@tool
+def get_token_price(token_pair: str) -> str:
+    """
+    Gets the latest price of a token pair (e.g., 'ETH/USD') from a Chainlink Price Feed.
+
+    Args:
+        token_pair: The token pair to get the price for. Currently supports 'ETH/USD'.
+
+    Returns:
+        A string indicating the latest price of the token pair.
+    """
+    try:
+        _initialize_web3()
+        if token_pair.upper() != "ETH/USD":
+            return "Error: This tool currently only supports the 'ETH/USD' token pair."
+
+        price_feed_contract = w3.eth.contract(
+            address=CHAINLINK_ETH_USD_PRICE_FEED_ADDRESS,
+            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}"
+        
+    except Exception as e:
+        return f"Error getting token price: {type(e).__name__} - {e}"
+
+@tool
+def send_eth(to_address: str, amount_eth: float) -> str:
+    """
+    Creates, signs, and sends a transaction to transfer Sepolia ETH.
+    """
+    try:
+        _initialize_web3()
+        nonce = w3.eth.get_transaction_count(agent_account.address)
+
+        tx = {
+            'from': agent_account.address,
+            'to': to_address,
+            'value': w3.to_wei(amount_eth, 'ether'),
+            'gas': 21000,
+            'gasPrice': w3.eth.gas_price,
+            'nonce': nonce,
+        }
+
+        signed_tx = w3.eth.account.sign_transaction(tx,AGENT_PRIVATE_KEY)
+        
+        tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+
+        return f"Transaction sent successfully. Transaction hash: {w3.to_hex(tx_hash)}"
+    except Exception as e:
+        return f"Error sending transaction: {type(e).__name__} - {e}"
+    
+
+
+@tool
+def interact_with_contract(
+    contract_address: str,
+    abi: str,
+    function_name: str,
+    function_args: list,
+    is_write_transaction: bool = False
+) -> str:
+    """
+    Interacts with a smart contract by calling one of its functions.
+    Can perform read-only calls (e.g., getting data) or write transactions (e.g., sending tokens).
+
+    Args:
+        contract_address: The address of the smart contract (e.g., "0x...").
+        abi: The contract's Application Binary Interface (ABI) as a JSON string.
+        function_name: The exact name of the function to call.
+        function_args: A list of arguments to pass to the function, in order.
+        is_write_transaction: Set to True if this is a state-changing transaction that requires gas. Defaults to False (read-only call).
+
+    Returns:
+        A string containing the result of the call or a transaction hash if it's a write transaction.
+    """
+    try:
+        _initialize_web3()
+
+        # 1. Validate inputs
+        if not w3.is_address(contract_address):
+            return "Error: Invalid 'contract_address'."
+        try:
+            abi_json = json.loads(abi)
+        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,
+                'nonce': nonce,
+                'gasPrice': w3.eth.gas_price
+            })
+            signed_tx = w3.eth.account.sign_transaction(tx, private_key=AGENT_PRIVATE_KEY)
+            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:
+        return f"Error interacting with contract: {type(e).__name__} - {e}"
+    
+@tool
+def get_erc20_balance(token_address: str, wallet_address: str) -> str:
+    """Gets the balance of a specific ERC-20 token for a given wallet."""
+    try:
+        _initialize_web3()
+        chk_token_address = Web3.to_checksum_address(token_address)
+        chk_wallet_address = Web3.to_checksum_address(wallet_address)
+        
+        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()
+            
+        balance = raw_balance / (10 ** decimals)
+        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
+def wrap_eth(amount_eth: float) -> str:
+    """Converts native ETH into WETH (Wrapped ETH) by depositing it into the WETH contract."""
+    try:
+        _initialize_web3()
+        weth_contract = w3.eth.contract(address=WETH_CONTRACT_ADDRESS, abi=WETH_ABI)
+        tx = weth_contract.functions.deposit().build_transaction({
+            'from': agent_account.address,
+            'value': w3.to_wei(amount_eth, 'ether'),
+            'nonce': w3.eth.get_transaction_count(agent_account.address),
+            'gasPrice': w3.eth.gas_price
+        })
+        signed_tx = w3.eth.account.sign_transaction(tx, private_key=AGENT_PRIVATE_KEY)
+        tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+        print(f"Waiting for wrap transaction {w3.to_hex(tx_hash)} to be confirmed...")
+        w3.eth.wait_for_transaction_receipt(tx_hash)
+        
+        return f"ETH wrapping successful and confirmed. Hash: {w3.to_hex(tx_hash)}"
+    except Exception as e:
+        return f"Error wrapping ETH: {e}"
+
+@tool
+def swap_tokens_for_tokens(token_in_address: str, token_out_address: str, amount_in: float, fee: int = 3000) -> str:
+    """Swaps an exact amount of an input token for another on Uniswap V3, waiting for confirmations."""
+    try:
+        _initialize_web3()
+        chk_token_in = Web3.to_checksum_address(token_in_address)
+        chk_token_out = Web3.to_checksum_address(token_out_address)
+        chk_router_address = Web3.to_checksum_address(UNISWAP_ROUTER_ADDRESS)
+        
+        token_in_contract = w3.eth.contract(address=chk_token_in, abi=ERC20_STANDARD_ABI)
+        decimals = token_in_contract.functions.decimals().call()
+        amount_in_wei = int(amount_in * (10**decimals))
+
+        current_nonce = w3.eth.get_transaction_count(agent_account.address)
+
+        # Step 1: Approve
+        approve_tx = token_in_contract.functions.approve(chk_router_address, amount_in_wei).build_transaction({
+            'from': agent_account.address, 'nonce': current_nonce
+        })
+        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)
+        
+        swap_tx = uniswap_router.functions.exactInputSingle(swap_params).build_transaction({
+            'from': agent_account.address, 'nonce': current_nonce + 1
+        })
+        signed_swap_tx = w3.eth.account.sign_transaction(swap_tx, private_key=os.getenv("AGENT_PRIVATE_KEY"))
+        swap_tx_hash = w3.eth.send_raw_transaction(signed_swap_tx.raw_transaction)
+
+        print(f"Waiting for swap transaction {w3.to_hex(swap_tx_hash)} to be confirmed...")
+        w3.eth.wait_for_transaction_receipt(swap_tx_hash)
+        
+        return f"Swap successful and confirmed. Swap hash: {w3.to_hex(swap_tx_hash)}"
+    except Exception as e:
+        return f"Error during swap: {e}"

clap/vector_stores/chroma_store.py

@@ -139,4 +139,4 @@ class ChromaStore(VectorStoreInterface):
             documents=results.get("documents"), metadatas=results.get("metadatas"), distances=results.get("distances") )
 
     async def adelete(self, ids: Optional[List[ID]] = None, where: Optional[Dict[str, Any]] = None, where_document: Optional[Dict[str, Any]] = None) -> None:
-        await self._run_sync(self._collection.delete, ids=ids, where=where, where_document=where_document)
+        await self._run_sync(self._collection.delete, ids=ids, where=where, where_document=where_document)

{clap_agents-0.2.2.dist-info → clap_agents-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clap-agents
-Version: 0.2.2
+Version: 0.3.1
 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
@@ -242,6 +242,8 @@ Requires-Dist: pandas; extra == 'all'
 Requires-Dist: pypdf; extra == 'all'
 Requires-Dist: qdrant-client[fastembed]>=1.7.0; extra == 'all'
 Requires-Dist: sentence-transformers; extra == 'all'
+Requires-Dist: tf-keras; extra == 'all'
+Requires-Dist: web3<8.0.0,>=7.12.0; extra == 'all'
 Provides-Extra: chromadb
 Requires-Dist: chromadb>=0.5.0; extra == 'chromadb'
 Provides-Extra: fastembed
@@ -261,12 +263,16 @@ Requires-Dist: ollama>=0.2.0; extra == 'rag'
 Requires-Dist: pypdf; extra == 'rag'
 Requires-Dist: qdrant-client[fastembed]>=1.7.0; extra == 'rag'
 Requires-Dist: sentence-transformers; extra == 'rag'
+Requires-Dist: tf-keras; extra == 'rag'
 Provides-Extra: sentence-transformers
 Requires-Dist: sentence-transformers; extra == 'sentence-transformers'
+Requires-Dist: tf-keras; extra == 'sentence-transformers'
 Provides-Extra: standard-tools
 Requires-Dist: crawl4ai; extra == 'standard-tools'
 Provides-Extra: viz
 Requires-Dist: graphviz; extra == 'viz'
+Provides-Extra: web3
+Requires-Dist: web3<8.0.0,>=7.12.0; extra == 'web3'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -506,6 +512,83 @@ async def main():
 asyncio.run(main())
 ```
 
+
+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
+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.
+
+wrap_eth: Converts native ETH into WETH (Wrapped Ether), a necessary step for interacting with many DeFi protocols.
+
+swap_exact_tokens_for_tokens: Executes trades on Uniswap V3, allowing your agent to autonomously rebalance its portfolio.
+
+get_token_price: Fetches real-time asset prices from on-chain Chainlink oracles, enabling data-driven decision-making.
+
+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
+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
+from clap import ReactAgent, GroqService
+from clap.tools import wrap_eth, swap_exact_tokens_for_tokens
+
+load_dotenv()
+
+# --- Configuration ---
+WETH_ADDRESS = "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14" # WETH on Sepolia
+USDC_ADDRESS = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7a98" # USDC on Sepolia
+
+async def main():
+    # We use a ReactAgent for multi-step reasoning
+    agent = ReactAgent(
+        llm_service=GroqService(),
+        tools=[wrap_eth, swap_exact_tokens_for_tokens],
+        model="llama-3.3-70b-versatile",
+        system_prompt="You are a DeFi agent. You execute financial transactions precisely as instructed.",
+        # For on-chain tasks, sequential execution is safer to avoid race conditions
+        parallel_tool_calls=False 
+    )
+
+    # A clear, two-step task for the agent
+    user_query = f"""
+    First, wrap 0.01 ETH.
+    Second, after the wrap is successful, swap that 0.01 WETH for USDC.
+    The WETH address is {WETH_ADDRESS} and the USDC address is {USDC_ADDRESS}.
+    """
+
+    print("--- Running Simple DeFi Agent ---")
+    response = await agent.run(user_msg=user_query, max_rounds=5)
+    
+    print("\n--- Agent Final Response ---")
+    print(response)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+This new capability transforms your CLAP agents from simple observers into active participants in the decentralized economy.
+
 ## Exploring Further
 
 

{clap_agents-0.2.2.dist-info → clap_agents-0.3.1.dist-info}/RECORD

@@ -1,26 +1,27 @@
 clap/__init__.py,sha256=rxxESl-xpSZpM4ZIh-GvHYF74CkQdbe-dSLvhMC_2dQ,1069
 clap/embedding/__init__.py,sha256=PqnqcSiA_JwEvn69g2DCQHdsffL2l4GNEKo0fAtCqbs,520
 clap/embedding/base_embedding.py,sha256=0SYicQ-A-rSDqHoFK0IOrRQe0cisOl8OBnis6V43Chs,696
-clap/embedding/fastembed_embedding.py,sha256=Xo2H7r45wNqN89WzI8InXtjahOXAcKDyHS0fYt_jtsc,2959
+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/google_openai_compat_service.py,sha256=X5ehwQEv4DobXCBjhtuo2v365DUl-thDa9Gdc16L67k,4522
-clap/llm_services/groq_service.py,sha256=HQoY3IpNHiOe0h6Gy0EMa1YsCUex0CvZ_MxApNMo8Ig,3206
-clap/llm_services/ollama_service.py,sha256=LsoJhCw8TZVbfuJeHATo2uPpkXsOWOuuE78HAxTQ9RY,5326
+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=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=IVwtkOAEN7LRaFqw14HQDC7n6OTZ3ciVYWj-lWQddE0,8681
 clap/multiagent_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clap/multiagent_pattern/agent.py,sha256=6Og1ZujhAIzQ_JLzuhc4oh9TwJ_mTXl2q2ca302PE8g,8345
+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=Ron5zz-yn5EHmnXiL5G1sDYF0-3DCiTVujZ2RJI27JQ,23478
+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=veMtEmjaY6aj_aUXNnPT_ijI2XM1DJU-y8dLqwx_t2s,293
+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/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
@@ -30,9 +31,9 @@ clap/utils/logging.py,sha256=FfrOHXnVJYCgc3mepIMKcIcGSdSWkMpV7ccKPGFxFiM,727
 clap/utils/rag_utils.py,sha256=Zy-C9l39tHrxYSluaDWcEl1g__uozu4jx5hEGC7h370,6455
 clap/vector_stores/__init__.py,sha256=H3w5jLdQFbXArVgiidy4RlAalM8a6LAiMlAX0Z-2v7U,404
 clap/vector_stores/base.py,sha256=nvk8J1oNG3OKFhJfxBGFyVeh9YxoDs9RkB_iOzPBm1w,2853
-clap/vector_stores/chroma_store.py,sha256=GWshlx0ZhiCLAhuZOCY_NjJT69r1wM8GSUVCY4CgLgo,7243
+clap/vector_stores/chroma_store.py,sha256=vwkWWGxPwuW45T1PS6D44dXhDG9U_KZWjrMZCOkEXsA,7242
 clap/vector_stores/qdrant_store.py,sha256=-SwMTb0yaGngpQ9AddDzDIt3x8GZevlFT-0FMkWD28I,9923
-clap_agents-0.2.2.dist-info/METADATA,sha256=9qa7O_D0uNxkMTb9oqR5hsjDEmet-g_RIPPgaWCvsqc,27199
-clap_agents-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-clap_agents-0.2.2.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-clap_agents-0.2.2.dist-info/RECORD,,
+clap_agents-0.3.1.dist-info/METADATA,sha256=4HKAihZchNLte3fWinmWBZAKjDtkpIMYJYLyD6jgfUs,30573
+clap_agents-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+clap_agents-0.3.1.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+clap_agents-0.3.1.dist-info/RECORD,,