.call()

Signed-off-by: OEvortex <abhat8283@gmail.com>

Author: OEvortex

CHANGELOG.md

@@ -6,6 +6,7 @@ All notable changes to the HelpingAI Python SDK will be documented in this file.
 
 ### Added
 - **🔧 Tool Calling Framework**: New [`@tools decorator`](HelpingAI/tools/core.py:144) for effortless tool creation
+- **🔄 Direct Tool Execution**: New `.call()` method on HAI client for executing tools without registry manipulation
 - **🤖 Automatic Schema Generation**: Type hint-based JSON schema creation with docstring parsing
 - **📝 Smart Documentation**: Multi-format docstring parsing (Google, Sphinx, NumPy styles)
 - **🧠 Thread-Safe Tool Registry**: Reliable tool management in multi-threaded environments
@@ -19,6 +20,7 @@ All notable changes to the HelpingAI Python SDK will be documented in this file.
 - **🔄 Universal Compatibility**: Seamless integration with existing OpenAI-format tools
 - **Updated Models**: Support for latest models (Dhanishtha-2.0-preview, Dhanishtha-2.0-preview-mini)
 - **Improved Model Management**: Better fallback handling and detailed model descriptions
+- **Simplified Tool Execution**: Direct tool calling with `client.call(tool_name, arguments)` syntax
 - Deprecated `get_tools_format()` in favor of `get_tools()`
 - Updated documentation to reflect current model names and best practices
 

HelpingAI/client.py

@@ -883,3 +883,32 @@ def __init__(
         super().__init__(api_key, organization, base_url, timeout)
         self.chat: Chat = Chat(self)
         self.models: Models = Models(self)
+        
+    def call(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """
+        Directly call a tool by name with the given arguments.
+        
+        This method provides a convenient way to execute tools without having to
+        manually use get_registry() and Fn objects.
+        
+        Args:
+            tool_name: Name of the tool to call
+            arguments: Arguments to pass to the tool
+            
+        Returns:
+            Result of the tool execution
+            
+        Raises:
+            ValueError: If the tool is not found
+            ToolExecutionError: If the tool execution fails
+        """
+        # Import here to avoid circular imports
+        from .tools import get_registry
+        
+        # Get the tool from the registry
+        tool = get_registry().get_tool(tool_name)
+        if not tool:
+            raise ValueError(f"Tool '{tool_name}' not found in registry")
+        
+        # Call the tool with the provided arguments
+        return tool.call(arguments)

README.md

@@ -11,6 +11,7 @@ The official Python library for the [HelpingAI](https://helpingai.co) API - Adva
 - **OpenAI-Compatible API**: Drop-in replacement with familiar interface
 - **Emotional Intelligence**: Advanced AI models with emotional understanding
 - **Tool Calling Made Easy**: [`@tools decorator`](HelpingAI/tools/core.py:144) for effortless function-to-tool conversion
+- **Direct Tool Execution**: Simple `.call()` method for executing tools without registry manipulation
 - **Automatic Schema Generation**: Type hint-based JSON schema creation with docstring parsing
 - **Universal Tool Compatibility**: Seamless integration with OpenAI-format tools
 - **Streaming Support**: Real-time response streaming
@@ -201,6 +202,45 @@ response = hai.chat.completions.create(
 print(response.choices[0].message.content)
 ```
 
+### Direct Tool Execution
+
+The HAI client provides a convenient `.call()` method to directly execute tools without having to manually use the registry:
+
+```python
+from HelpingAI import HAI
+from HelpingAI.tools import tools
+
+@tools
+def search(query: str, max_results: int = 5):
+    """Search the web for information"""
+    # Implementation here
+    return {"results": [{"title": "Result 1", "url": "https://example.com"}]}
+
+# Create a client instance
+client = HAI()
+
+# Directly call a tool by name with arguments
+search_result = client.call("search", {"query": "python programming", "max_results": 3})
+print("Search results:", search_result)
+
+# You can also execute tools from model responses
+response = client.chat.completions.create(
+    model="Dhanishtha-2.0-preview",
+    messages=[{"role": "user", "content": "search for quantum computing"}],
+    tools=get_tools(),
+    tool_choice="auto"
+)
+
+# Extract tool name and arguments from the model's tool call
+tool_call = response.choices[0].message.tool_calls[0]
+tool_name = tool_call.function.name
+tool_args = json.loads(tool_call.function.arguments)
+
+# Execute the tool directly
+tool_result = client.call(tool_name, tool_args)
+print(f"Result: {tool_result}")
+```
+
 ### Advanced Tool Features
 
 #### Type System Support
@@ -318,11 +358,9 @@ def divide_numbers(a: float, b: float) -> float:
 # Handle tool execution in your application
 def execute_tool_safely(tool_name: str, arguments: dict):
     try:
-        tool = get_registry().get_tool(tool_name)
-        if not tool:
-            return {"error": f"Tool '{tool_name}' not found"}
-        
-        return tool.call(arguments)
+        # You can use the direct call method instead of registry manipulation
+        hai = HAI()
+        return hai.call(tool_name, arguments)
 
     except ToolExecutionError as e:
         print(f"Tool execution failed: {e}")