agentic-blocks 0.1.9__tar.gz → 0.1.11__tar.gz

{agentic_blocks-0.1.9/src/agentic_blocks.egg-info → agentic_blocks-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-blocks
-Version: 0.1.9
+Version: 0.1.11
 Summary: Simple building blocks for agentic AI systems with MCP client and conversation management
 Author-email: Magnus Bjelkenhed <bjelkenhed@gmail.com>
 License: MIT

{agentic_blocks-0.1.9 → agentic_blocks-0.1.11}/pyproject.toml

@@ -14,7 +14,7 @@ agentic_blocks = []
 
 [project]
 name = "agentic-blocks"
-version = "0.1.9"
+version = "0.1.11"
 description = "Simple building blocks for agentic AI systems with MCP client and conversation management"
 readme = "README.md"
 requires-python = ">=3.11"

{agentic_blocks-0.1.9 → agentic_blocks-0.1.11}/src/agentic_blocks/llm.py

@@ -9,6 +9,7 @@ from dotenv import load_dotenv
 from openai import OpenAI
 
 from agentic_blocks.messages import Messages
+from agentic_blocks.utils.tools_utils import langchain_tools_to_openai_format
 
 
 class LLMError(Exception):
@@ -19,7 +20,7 @@ class LLMError(Exception):
 
 def call_llm(
     messages: Union[Messages, List[Dict[str, Any]]],
-    tools: Optional[List[Dict[str, Any]]] = None,
+    tools: Optional[Union[List[Dict[str, Any]], List]] = None,
     api_key: Optional[str] = None,
     model: str = "gpt-4o-mini",
     base_url: Optional[str] = None,
@@ -30,7 +31,7 @@ def call_llm(
 
     Args:
         messages: Either a Messages instance or a list of message dicts
-        tools: Optional list of tools in OpenAI function calling format
+        tools: Optional list of tools in OpenAI function calling format or LangChain StructuredTools
         api_key: OpenAI API key (if not provided, loads from .env OPENAI_API_KEY)
         model: Model name to use for completion
         base_url: Base URL for the API (useful for VLLM or other OpenAI-compatible servers)
@@ -79,6 +80,15 @@ def call_llm(
     if not conversation_messages:
         raise LLMError("No messages provided for completion.")
 
+    # Handle tools parameter - convert LangChain tools if needed
+    openai_tools = None
+    if tools:
+        # Check if it's a list of LangChain StructuredTools
+        if tools and hasattr(tools[0], 'args_schema'):
+            openai_tools = langchain_tools_to_openai_format(tools)
+        else:
+            openai_tools = tools
+
     try:
         # Prepare completion parameters
         completion_params = {
@@ -87,8 +97,8 @@ def call_llm(
             **kwargs,
         }
 
-        if tools:
-            completion_params["tools"] = tools
+        if openai_tools:
+            completion_params["tools"] = openai_tools
             completion_params["tool_choice"] = "auto"
 
         # Make completion request

agentic_blocks-0.1.11/src/agentic_blocks/utils/tools_utils.py

@@ -0,0 +1,176 @@
+"""
+Utilities for working with tools across different formats.
+"""
+
+from typing import Dict, Any, List
+
+
+def langchain_tool_to_openai_format(tool) -> Dict[str, Any]:
+    """
+    Convert a LangChain StructuredTool to OpenAI function calling format.
+    
+    Args:
+        tool: A langchain_core.tools.structured.StructuredTool instance
+        
+    Returns:
+        Dictionary in OpenAI function calling format, compatible with 
+        MCPClient.list_tools() output and call_llm() tools parameter
+    """
+    schema = tool.args_schema.model_json_schema()
+    
+    return {
+        "type": "function",
+        "function": {
+            "name": schema.get("title", tool.name),
+            "description": schema.get("description", ""),
+            "parameters": {
+                "type": "object",
+                "properties": schema.get("properties", {}),
+                "required": schema.get("required", [])
+            }
+        }
+    }
+
+
+def langchain_tools_to_openai_format(tools: List) -> List[Dict[str, Any]]:
+    """
+    Convert a list of LangChain StructuredTools to OpenAI function calling format.
+    
+    Args:
+        tools: List of langchain_core.tools.structured.StructuredTool instances
+        
+    Returns:
+        List of dictionaries in OpenAI function calling format, compatible with 
+        MCPClient.list_tools() output and call_llm() tools parameter
+    """
+    return [langchain_tool_to_openai_format(tool) for tool in tools]
+
+
+def create_tool_registry(tools: List) -> Dict[str, Any]:
+    """
+    Create a registry mapping tool names to LangChain tool instances.
+    
+    Args:
+        tools: List of langchain_core.tools.structured.StructuredTool instances
+        
+    Returns:
+        Dictionary mapping tool names to tool instances
+    """
+    return {tool.name: tool for tool in tools}
+
+
+def execute_tool_call(tool_call: Dict[str, Any], tool_registry: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute a single tool call using LangChain tool registry.
+    
+    Args:
+        tool_call: Dictionary with 'tool_name', 'arguments', and 'tool_call_id' keys
+        tool_registry: Registry mapping tool names to tool instances
+        
+    Returns:
+        Dictionary with 'tool_call_id', 'result', and 'is_error' keys
+    """
+    tool_name = tool_call.get('tool_name')
+    arguments = tool_call.get('arguments', {})
+    tool_call_id = tool_call.get('tool_call_id')
+    
+    try:
+        if tool_name not in tool_registry:
+            raise ValueError(f"Tool '{tool_name}' not found in registry")
+        
+        tool = tool_registry[tool_name]
+        result = tool.invoke(arguments)
+        
+        return {
+            'tool_call_id': tool_call_id,
+            'result': result,
+            'is_error': False
+        }
+    except Exception as e:
+        return {
+            'tool_call_id': tool_call_id,
+            'result': f"Error executing tool '{tool_name}': {str(e)}",
+            'is_error': True
+        }
+
+
+def execute_pending_tool_calls(messages, tool_registry: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Execute all pending tool calls from a Messages instance and add responses back.
+    
+    Args:
+        messages: Messages instance with pending tool calls
+        tool_registry: Registry mapping tool names to tool instances
+        
+    Returns:
+        List of execution results compatible with Messages.add_tool_responses format
+    """
+    pending_tool_calls = messages.get_pending_tool_calls()
+    results = []
+    
+    for tool_call in pending_tool_calls:
+        result = execute_tool_call(tool_call, tool_registry)
+        
+        # Convert to format expected by Messages.add_tool_responses
+        if result['is_error']:
+            tool_response = {
+                'tool_call_id': result['tool_call_id'],
+                'is_error': True,
+                'error': result['result']
+            }
+        else:
+            tool_response = {
+                'tool_call_id': result['tool_call_id'],
+                'is_error': False,
+                'tool_response': result['result']
+            }
+        
+        results.append(tool_response)
+        
+        # Add tool response back to messages using individual method
+        if result['is_error']:
+            messages.add_tool_response(result['tool_call_id'], result['result'])
+        else:
+            messages.add_tool_response(result['tool_call_id'], str(result['result']))
+    
+    return results
+
+
+def execute_and_add_tool_responses(messages, tool_registry: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Execute all pending tool calls and add them using Messages.add_tool_responses batch method.
+    
+    Args:
+        messages: Messages instance with pending tool calls
+        tool_registry: Registry mapping tool names to tool instances
+        
+    Returns:
+        List of execution results compatible with Messages.add_tool_responses format
+    """
+    pending_tool_calls = messages.get_pending_tool_calls()
+    results = []
+    
+    for tool_call in pending_tool_calls:
+        result = execute_tool_call(tool_call, tool_registry)
+        
+        # Convert to format expected by Messages.add_tool_responses
+        if result['is_error']:
+            tool_response = {
+                'tool_call_id': result['tool_call_id'],
+                'is_error': True,
+                'error': result['result']
+            }
+        else:
+            tool_response = {
+                'tool_call_id': result['tool_call_id'],
+                'is_error': False,
+                'tool_response': result['result']
+            }
+        
+        results.append(tool_response)
+    
+    # Add all responses at once using the batch method
+    if results:
+        messages.add_tool_responses(results)
+    
+    return results

{agentic_blocks-0.1.9 → agentic_blocks-0.1.11/src/agentic_blocks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-blocks
-Version: 0.1.9
+Version: 0.1.11
 Summary: Simple building blocks for agentic AI systems with MCP client and conversation management
 Author-email: Magnus Bjelkenhed <bjelkenhed@gmail.com>
 License: MIT

{agentic_blocks-0.1.9 → agentic_blocks-0.1.11}/src/agentic_blocks.egg-info/SOURCES.txt

@@ -9,4 +9,5 @@ src/agentic_blocks.egg-info/PKG-INFO
 src/agentic_blocks.egg-info/SOURCES.txt
 src/agentic_blocks.egg-info/dependency_links.txt
 src/agentic_blocks.egg-info/requires.txt
-src/agentic_blocks.egg-info/top_level.txt
+src/agentic_blocks.egg-info/top_level.txt
+src/agentic_blocks/utils/tools_utils.py