Cleanup pr

Signed-off-by: Mihai Criveti <[email protected]>

Author: crivetimihai

agent_runtimes/langchain_agent/README.md

@@ -21,9 +21,9 @@ etc. are provided.
 - **Health Monitoring**: `/health`, `/ready`, `/list_tools` endpoints
 
 ## User Stories Implemented
-[x] **Dynamic Tool Discovery** - Auto-discovers from gateway or uses allowlist  
-[x] **Dual Endpoint Exposure** - OpenAI + A2A JSON-RPC endpoints  
-[x] **Parameterised Tool Allow-List** - `TOOLS=` environment variable  
+[x] **Dynamic Tool Discovery** - Auto-discovers from gateway or uses allowlist
+[x] **Dual Endpoint Exposure** - OpenAI + A2A JSON-RPC endpoints
+[x] **Parameterised Tool Allow-List** - `TOOLS=` environment variable
 [x] **Tool Schema Introspection** - JSON schema parsing and validation
 
 Structure:
@@ -77,7 +77,7 @@ Basic Health Checks
 # Health check
 curl http://localhost:8000/health
 
-# Readiness check  
+# Readiness check
 curl http://localhost:8000/ready
 
 # List available tools
@@ -134,7 +134,7 @@ curl -X POST http://localhost:8000/a2a \
 curl -X POST http://localhost:8000/a2a \
   -H "Content-Type: application/json" \
   -d '{
-    "jsonrpc": "2.0", 
+    "jsonrpc": "2.0",
     "id": "1",
     "method": "invoke",
     "params": {
@@ -162,4 +162,4 @@ Expected Success Response:
   }
 }
 ```
-![alt text](image.png)
+![alt text](image.png)

agent_runtimes/langchain_agent/__init__.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """
 MCP Langchain Agent Package
 
@@ -9,4 +10,4 @@
 from .mcp_client import MCPClient
 from .config import get_settings
 
-__all__ = []
+__all__ = []

agent_runtimes/langchain_agent/agent_langchain.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 import asyncio
 import json
 import logging
@@ -18,15 +19,15 @@
 
 class MCPTool(BaseTool):
     """Langchain tool wrapper for MCP tools"""
-    
+
     name: str = Field(..., description="Tool name")
     description: str = Field(..., description="Tool description")
     mcp_client: MCPClient = Field(..., description="MCP client instance")
     tool_id: str = Field(..., description="MCP tool ID")
-    
+
     class Config:
         arbitrary_types_allowed = True
-    
+
     def _run(self, **kwargs) -> str:
         """Synchronous tool execution"""
         try:
@@ -35,7 +36,7 @@ def _run(self, **kwargs) -> str:
         except Exception as e:
             logger.error(f"Tool {self.tool_id} execution failed: {e}")
             return f"Error executing tool: {str(e)}"
-    
+
     async def _arun(self, **kwargs) -> str:
         """Asynchronous tool execution"""
         # Run in thread pool since MCP client might not be async
@@ -44,27 +45,27 @@ async def _arun(self, **kwargs) -> str:
 
 class LangchainMCPAgent:
     """Langchain agent that integrates with MCP Gateway"""
-    
+
     def __init__(self, config: AgentConfig):
         self.config = config
         self.mcp_client = MCPClient.from_env(config.mcp_gateway_url)
         self.mcp_client.debug = config.debug_mode
-        
+
         self.llm = ChatOpenAI(
             model=config.default_model,
             temperature=config.temperature,
             streaming=config.streaming_enabled
         )
-        
+
         self.tools: List[MCPTool] = []
         self.agent_executor: Optional[AgentExecutor] = None
         self._initialized = False
-    
+
     @classmethod
     def from_config(cls, config: AgentConfig) -> "LangchainMCPAgent":
         """Create agent from configuration"""
         return cls(config)
-    
+
     async def initialize(self):
         """Initialize the agent and load tools"""
         try:
@@ -77,24 +78,24 @@ async def initialize(self):
                 # Auto-discover from gateway
                 logger.info("Auto-discovering tools from MCP Gateway")
                 await self._load_mcp_tools()
-            
+
             # Create the agent
             await self._create_agent()
-            
+
             self._initialized = True
             logger.info(f"Agent initialized with {len(self.tools)} tools")
-            
+
         except Exception as e:
             logger.error(f"Failed to initialize agent: {e}")
             raise
-    
+
     async def _load_allowlisted_tools(self):
         """Load only tools specified in the allowlist (no autodiscovery)"""
         try:
             # Clean the allowlist
             allowlist = [tool.strip() for tool in self.config.tools_allowlist if tool.strip()]
             logger.info(f"Loading allowlisted tools: {allowlist}")
-            
+
             self.tools = []
             for tool_id in allowlist:
                 # Create a basic tool definition for allowlisted tools
@@ -107,27 +108,27 @@ async def _load_allowlisted_tools(self):
                 )
                 self.tools.append(mcp_tool)
                 logger.info(f"Added allowlisted tool: {tool_id}")
-                
+
         except Exception as e:
             logger.error(f"Failed to load allowlisted tools: {e}")
             raise
-    
+
     async def _load_mcp_tools(self):
         """Load tools from MCP Gateway"""
         try:
             # Add debug info about the connection
             logger.info(f"Connecting to MCP Gateway at: {self.mcp_client.base_url}")
             logger.info(f"Using token: {'Yes' if self.mcp_client.token else 'No'}")
-            
+
             tool_defs = self.mcp_client.list_tools()
             logger.info(f"Found {len(tool_defs)} tools from MCP Gateway")
-            
+
             if len(tool_defs) == 0:
                 logger.warning("No tools found from MCP Gateway. Check if:")
                 logger.warning("  1. Gateway is running on the expected URL")
                 logger.warning("  2. Authentication token is valid")
                 logger.warning("  3. Gateway has tools configured")
-            
+
             self.tools = []
             for tool_def in tool_defs:
                 mcp_tool = MCPTool(
@@ -138,17 +139,17 @@ async def _load_mcp_tools(self):
                 )
                 self.tools.append(mcp_tool)
                 logger.info(f"Loaded tool: {tool_def.id} ({tool_def.name})")
-                
+
         except Exception as e:
             logger.error(f"Failed to load MCP tools: {e}")
             raise
-    
+
     async def _create_agent(self):
         """Create the Langchain agent executor"""
         try:
             # Define the system prompt
             system_prompt = """You are a helpful AI assistant with access to various tools through the MCP (Model Context Protocol) Gateway.
-            
+
 Use the available tools to help answer questions and complete tasks. When using tools:
 1. Read tool descriptions carefully to understand their purpose
 2. Provide the correct arguments as specified in the tool schema
@@ -158,22 +159,22 @@ async def _create_agent(self):
 Available tools: {tool_names}
 
 Always strive to be helpful, accurate, and honest in your responses."""
-            
+
             # Create prompt template
             prompt = ChatPromptTemplate.from_messages([
                 ("system", system_prompt),
                 MessagesPlaceholder(variable_name="chat_history"),
                 ("human", "{input}"),
                 MessagesPlaceholder(variable_name="agent_scratchpad"),
             ])
-            
+
             # Create the agent
             agent = create_openai_functions_agent(
                 llm=self.llm,
                 tools=self.tools,
                 prompt=prompt
             )
-            
+
             # Create agent executor
             self.agent_executor = AgentExecutor(
                 agent=agent,
@@ -182,29 +183,29 @@ async def _create_agent(self):
                 verbose=self.config.debug_mode,
                 return_intermediate_steps=True
             )
-            
+
             logger.info("Langchain agent created successfully")
-            
+
         except Exception as e:
             logger.error(f"Failed to create agent: {e}")
             raise
-    
+
     def is_initialized(self) -> bool:
         """Check if agent is initialized"""
         return self._initialized
-    
+
     async def check_readiness(self) -> bool:
         """Check if agent is ready to handle requests"""
         try:
             return (
-                self._initialized and 
-                self.agent_executor is not None and 
+                self._initialized and
+                self.agent_executor is not None and
                 len(self.tools) >= 0 and  # Allow 0 tools for testing
                 await self.test_gateway_connection()
             )
         except Exception:
             return False
-    
+
     async def test_gateway_connection(self) -> bool:
         """Test connection to MCP Gateway"""
         try:
@@ -214,17 +215,17 @@ async def test_gateway_connection(self) -> bool:
         except Exception as e:
             logger.error(f"Gateway connection test failed: {e}")
             return False
-    
+
     def get_available_tools(self) -> List[ToolDef]:
         """Get list of available tools"""
         try:
             return self.mcp_client.list_tools()
         except Exception:
             return []
-    
+
     async def run_async(
-        self, 
-        messages: List[Dict[str, str]], 
+        self,
+        messages: List[Dict[str, str]],
         model: Optional[str] = None,
         max_tokens: Optional[int] = None,
         temperature: Optional[float] = None,
@@ -233,15 +234,15 @@ async def run_async(
         """Run the agent asynchronously"""
         if not self._initialized:
             raise RuntimeError("Agent not initialized. Call initialize() first.")
-        
+
         try:
             # Convert messages to input format
             if messages:
                 latest_message = messages[-1]
                 input_text = latest_message.get("content", "")
             else:
                 input_text = ""
-            
+
             # Prepare chat history (all messages except the last one)
             chat_history = []
             for msg in messages[:-1]:
@@ -251,20 +252,20 @@ async def run_async(
                     chat_history.append(AIMessage(content=msg["content"]))
                 elif msg["role"] == "system":
                     chat_history.append(SystemMessage(content=msg["content"]))
-            
+
             # Run the agent
             result = await self.agent_executor.ainvoke({
                 "input": input_text,
                 "chat_history": chat_history,
                 "tool_names": [tool.name for tool in self.tools]
             })
-            
+
             return result["output"]
-            
+
         except Exception as e:
             logger.error(f"Agent execution failed: {e}")
             return f"I encountered an error while processing your request: {str(e)}"
-    
+
     async def stream_async(
         self,
         messages: List[Dict[str, str]],