pylint fixes (#44010)

Author: ganeshyb

sdk/agentserver/azure-ai-agentserver-agentframework/azure/ai/agentserver/agentframework/__init__.py

@@ -5,20 +5,20 @@
 
 from typing import TYPE_CHECKING, Optional, Any
 
-from ._version import VERSION
 from .agent_framework import AgentFrameworkCBAgent
+from .tool_client import ToolClient
+from ._version import VERSION
 
 if TYPE_CHECKING:  # pragma: no cover
     from azure.core.credentials_async import AsyncTokenCredential
 
 
-def from_agent_framework(agent, credentials: Optional["AsyncTokenCredential"] = None, **kwargs: Any) -> "AgentFrameworkCBAgent":
-    from .agent_framework import AgentFrameworkCBAgent
+def from_agent_framework(agent,
+                         credentials: Optional["AsyncTokenCredential"] = None,
+                         **kwargs: Any) -> "AgentFrameworkCBAgent":
 
     return AgentFrameworkCBAgent(agent, credentials=credentials, **kwargs)
 
-from .tool_client import ToolClient
-
 
 __all__ = ["from_agent_framework", "ToolClient"]
 __version__ = VERSION

sdk/agentserver/azure-ai-agentserver-agentframework/azure/ai/agentserver/agentframework/agent_framework.py

@@ -9,7 +9,7 @@
 from typing import TYPE_CHECKING, Any, AsyncGenerator, Awaitable, Optional, Protocol, Union, List
 import inspect
 
-from agent_framework import AgentProtocol
+from agent_framework import AgentProtocol, AIFunction
 from agent_framework.azure import AzureAIAgentClient  # pylint: disable=no-name-in-module
 from opentelemetry import trace
 
@@ -28,7 +28,6 @@
 from .models.agent_framework_output_non_streaming_converter import (
     AgentFrameworkOutputNonStreamingConverter,
 )
-from agent_framework import AIFunction
 from .models.agent_framework_output_streaming_converter import AgentFrameworkOutputStreamingConverter
 from .models.constants import Constants
 from .tool_client import ToolClient
@@ -45,7 +44,7 @@ class AgentFactory(Protocol):
     An agent factory is a callable that takes a ToolClient and returns
     an AgentProtocol, either synchronously or asynchronously.
     """
-    
+
     def __call__(self, tools: List[AIFunction]) -> Union[AgentProtocol, Awaitable[AgentProtocol]]:
         """Create an AgentProtocol using the provided ToolClient.
         
@@ -74,18 +73,20 @@ class AgentFrameworkCBAgent(FoundryCBAgent):
         - Supports both streaming and non-streaming responses based on the `stream` flag.
     """
 
-    def __init__(self, agent: Union[AgentProtocol, AgentFactory], credentials: "Optional[AsyncTokenCredential]" = None, **kwargs: Any):
+    def __init__(self, agent: Union[AgentProtocol, AgentFactory],
+                 credentials: "Optional[AsyncTokenCredential]" = None,
+                 **kwargs: Any):
         """Initialize the AgentFrameworkCBAgent with an AgentProtocol or a factory function.
 
-        :param agent: The Agent Framework agent to adapt, or a callable that takes ToolClient and returns AgentProtocol (sync or async).
+        :param agent: The Agent Framework agent to adapt, or a callable that takes ToolClient
+            and returns AgentProtocol (sync or async).
         :type agent: Union[AgentProtocol, AgentFactory]
         :param credentials: Azure credentials for authentication.
         :type credentials: Optional[AsyncTokenCredential]
         """
-        super().__init__(credentials=credentials, **kwargs)
+        super().__init__(credentials=credentials, **kwargs)  # pylint: disable=unexpected-keyword-arg
         self._agent_or_factory: Union[AgentProtocol, AgentFactory] = agent
         self._resolved_agent: "Optional[AgentProtocol]" = None
-        
         # If agent is already instantiated, use it directly
         if isinstance(agent, AgentProtocol):
             self._resolved_agent = agent
@@ -126,21 +127,24 @@ async def _resolve_agent(self, context: AgentRunContext):
         """Resolve the agent if it's a factory function (for single-use/first-time resolution).
         Creates a ToolClient and calls the factory function with it.
         This is used for the initial resolution.
+
+        :param context: The agent run context containing tools and user information.
+        :type context: AgentRunContext
         """
         if callable(self._agent_or_factory):
             logger.debug("Resolving agent from factory function")
-            
+
             # Create ToolClient with credentials
-            tool_client = self.get_tool_client(tools=context.get_tools(), user_info=context.get_user_info())
+            tool_client = self.get_tool_client(tools=context.get_tools(), user_info=context.get_user_info()) # pylint: disable=no-member
             tool_client_wrapper = ToolClient(tool_client)
             tools = await tool_client_wrapper.list_tools()
-            
+
             result = self._agent_or_factory(tools)
             if inspect.iscoroutine(result):
                 self._resolved_agent = await result
             else:
                 self._resolved_agent = result
-            
+
             logger.debug("Agent resolved successfully")
         else:
             # Should not reach here, but just in case
@@ -149,19 +153,18 @@ async def _resolve_agent(self, context: AgentRunContext):
     async def _resolve_agent_for_request(self, context: AgentRunContext):
 
         logger.debug("Resolving fresh agent from factory function for request")
-        
+
         # Create ToolClient with credentials
-        tool_client = self.get_tool_client(tools=context.get_tools(), user_info=context.get_user_info())
+        tool_client = self.get_tool_client(tools=context.get_tools(), user_info=context.get_user_info()) # pylint: disable=no-member
         tool_client_wrapper = ToolClient(tool_client)
         tools = await tool_client_wrapper.list_tools()
-        
-        import inspect
+
         result = self._agent_or_factory(tools)
         if inspect.iscoroutine(result):
             agent = await result
         else:
             agent = result
-        
+
         logger.debug("Fresh agent resolved successfully for request")
         return agent, tool_client_wrapper
 
@@ -184,7 +187,7 @@ def init_tracing(self):
             agent_client.setup_azure_ai_observability()
         self.tracer = trace.get_tracer(__name__)
 
-    async def agent_run(
+    async def agent_run(  # pylint: disable=too-many-statements
         self, context: AgentRunContext
     ) -> Union[
         OpenAIResponse,
@@ -201,7 +204,7 @@ async def agent_run(
                 agent = self._resolved_agent
             else:
                 agent = self._resolved_agent
-            
+
             logger.info(f"Starting agent_run with stream={context.stream}")
             request_input = context.request.get("input")
 
@@ -248,7 +251,7 @@ async def stream_updates():
                             try:
                                 await tool_client.close()
                                 logger.debug("Closed tool_client after streaming completed")
-                            except Exception as e:
+                            except Exception as e:  # pylint: disable=broad-exception-caught
                                 logger.warning(f"Error closing tool_client in stream: {e}")
 
                 return stream_updates()
@@ -267,5 +270,5 @@ async def stream_updates():
                 try:
                     await tool_client.close()
                     logger.debug("Closed tool_client after request processing")
-                except Exception as e:
+                except Exception as e:  # pylint: disable=broad-exception-caught
                     logger.warning(f"Error closing tool_client: {e}")

sdk/agentserver/azure-ai-agentserver-agentframework/azure/ai/agentserver/agentframework/tool_client.py

@@ -3,13 +3,16 @@
 # ---------------------------------------------------------
 """Tool client for integrating AzureAIToolClient with Agent Framework."""
 
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from agent_framework import AIFunction
-from pydantic import BaseModel, Field, create_model
-
+from pydantic import Field, create_model
+from azure.ai.agentserver.core.logger import get_logger
 if TYPE_CHECKING:
     from azure.ai.agentserver.core.client.tools.aio import AzureAIToolClient, FoundryTool
 
+logger = get_logger()
+
+# pylint: disable=client-accepts-api-version-keyword,missing-client-constructor-parameter-credential,missing-client-constructor-parameter-kwargs
 class ToolClient:
     """Client that integrates AzureAIToolClient with Agent Framework.
     
@@ -46,7 +49,7 @@ class ToolClient:
 
     :meta private:
     """
-    
+
     def __init__(self, tool_client: "AzureAIToolClient") -> None:
         """Initialize the ToolClient.
         
@@ -55,7 +58,7 @@ def __init__(self, tool_client: "AzureAIToolClient") -> None:
         """
         self._tool_client = tool_client
         self._aifunction_cache: List[AIFunction] = None
-    
+
     async def list_tools(self) -> List[AIFunction]:
         """List all available tools as Agent Framework tool definitions.
         
@@ -77,7 +80,7 @@ async def list_tools(self) -> List[AIFunction]:
         # Get tools from AzureAIToolClient
         if self._aifunction_cache is not None:
             return self._aifunction_cache
-        
+
         azure_tools = await self._tool_client.list_tools()
         self._aifunction_cache = []
 
@@ -98,42 +101,48 @@ def _convert_to_agent_framework_tool(self, azure_tool: "FoundryTool") -> AIFunct
         """
         # Get the input schema from the tool descriptor
         input_schema = azure_tool.input_schema or {}
-        
+
         # Create a Pydantic model from the input schema
         properties = input_schema.get("properties", {})
         required_fields = set(input_schema.get("required", []))
-        
+
         # Build field definitions for the Pydantic model
         field_definitions: Dict[str, Any] = {}
         for field_name, field_info in properties.items():
             field_type = self._json_schema_type_to_python(field_info.get("type", "string"))
             field_description = field_info.get("description", "")
             is_required = field_name in required_fields
-            
+
             if is_required:
                 field_definitions[field_name] = (field_type, Field(description=field_description))
             else:
-                field_definitions[field_name] = (Optional[field_type], Field(default=None, description=field_description))
-        
+                field_definitions[field_name] = (Optional[field_type],
+                                                 Field(default=None, description=field_description))
+
         # Create the Pydantic model dynamically
         input_model = create_model(
             f"{azure_tool.name}_input",
             **field_definitions
         )
-        
+
         # Create a wrapper function that calls the Azure tool
         async def tool_func(**kwargs: Any) -> Any:
-            """Dynamically generated function to invoke the Azure AI tool."""
-            return await self.invoke_tool(azure_tool.name, kwargs)
-        
+            """Dynamically generated function to invoke the Azure AI tool.
+
+            :return: The result from the tool invocation.
+            :rtype: Any
+            """
+            logger.debug("Invoking tool: %s with input: %s", azure_tool.name, kwargs)
+            return await azure_tool.ainvoke(kwargs)
+
         # Create and return the AIFunction
         return AIFunction(
             name=azure_tool.name,
             description=azure_tool.description or "No description available",
             func=tool_func,
             input_model=input_model
         )
-    
+
     def _json_schema_type_to_python(self, json_type: str) -> type:
         """Convert JSON schema type to Python type.
         
@@ -151,14 +160,23 @@ def _json_schema_type_to_python(self, json_type: str) -> type:
             "object": dict,
         }
         return type_map.get(json_type, str)
-   
+
     async def close(self) -> None:
+        """Close the tool client and release resources."""
         await self._tool_client.close()
-    
+
     async def __aenter__(self) -> "ToolClient":
-        """Async context manager entry."""
+        """Async context manager entry.
+
+        :return: The ToolClient instance.
+        :rtype: ToolClient
+        """
         return self
-    
+
     async def __aexit__(self, *exc_details: Any) -> None:
-        """Async context manager exit."""
+        """Async context manager exit.
+
+        :param exc_details: Exception details if an exception occurred.
+        :type exc_details: Any
+        """
         await self.close()

sdk/agentserver/azure-ai-agentserver-core/azure/ai/agentserver/core/client/tools/_utils/_model_base.py

@@ -751,8 +751,11 @@ def from_dict(cls, data: Mapping[str, Any], tool_definitions: List[ToolDefinitio
 		result_data = data.get("result", {})
 		tools_list = []
 		tool_definitions_map = {f"{td.type.lower()}": td for td in tool_definitions}
-
+		filter_tools = len(tool_definitions_map) > 0
 		for tool_data in result_data.get("tools", []):
+
+			if filter_tools and tool_data["name"].lower() not in tool_definitions_map:
+				continue
 			# Parse inputSchema
 			input_schema_data = tool_data.get("inputSchema", {})
 			input_schema = MCPToolSchema(

sdk/agentserver/azure-ai-agentserver-core/azure/ai/agentserver/core/client/tools/operations/_operations.py

@@ -4,8 +4,7 @@
 # mypy: ignore-errors
 
 import json
-import logging
-from typing import Any, Dict, List, Mapping, MutableMapping, Optional, Tuple, Union
+from typing import Any, Dict, List, Mapping, MutableMapping, Tuple, Union
 from azure.core import PipelineClient
 from .._configuration import AzureAIToolClientConfiguration
 from .._model_base import FoundryTool, ToolSource, UserInfo
@@ -26,7 +25,6 @@
     map_error,
 )
 
-logger = logging.getLogger(__name__)
 
 # Shared constants
 API_VERSION = "2025-11-15-preview"
@@ -192,7 +190,7 @@ def build_invoke_mcp_tool_request(
 	_params = {}
 
 	_content = prepare_mcptools_invoke_tool_request_content(tool, arguments, TOOL_PROPERTY_OVERRIDES)
-	logger.info("Invoking MCP tool: %s with arguments: %s", tool.name, dict(arguments))
+
 	content = json.dumps(_content)
 	_request = build_mcptools_invoke_tool_request(api_version=api_version, headers=_headers, params=_params, content=content)
 
@@ -370,7 +368,7 @@ def prepare_mcptools_invoke_tool_request_content(tool: FoundryTool, arguments: M
 			)
 		if meta_config:
 			params["_meta"] = meta_config
-	logger.info("Prepared MCP tool invocation params: %s", params)
+
 	payload = {
 		"jsonrpc": "2.0",
 		"id": 2,

sdk/agentserver/azure-ai-agentserver-core/azure/ai/agentserver/core/server/base.py

@@ -337,6 +337,7 @@ def setup_otlp_exporter(self, endpoint, provider):
     def get_tool_client(
             self, tools: Optional[list[ToolDefinition]], user_info: Optional[UserInfo]
         ) -> AzureAIToolClient:
+        logger.debug("Creating AzureAIToolClient with tools: %s", tools)
         if not self.credentials:
             raise ValueError("Credentials are required to create Tool Client.")
         return AzureAIToolClient(

sdk/agentserver/azure-ai-agentserver-langgraph/azure/ai/agentserver/langgraph/__init__.py

@@ -6,19 +6,23 @@
 from typing import TYPE_CHECKING, Optional, Any
 
 from ._version import VERSION
+from .tool_client import ToolClient
 
 if TYPE_CHECKING:  # pragma: no cover
     from . import models
     from azure.core.credentials_async import AsyncTokenCredential
 
 
-def from_langgraph(agent, credentials: Optional["AsyncTokenCredential"] = None, state_converter: Optional["models.LanggraphStateConverter"] = None, **kwargs: Any) -> "LangGraphAdapter":
+def from_langgraph(
+    agent,
+    credentials: Optional["AsyncTokenCredential"] = None,
+    state_converter: Optional["models.LanggraphStateConverter"] = None,
+    **kwargs: Any
+) -> "LangGraphAdapter":
     from .langgraph import LangGraphAdapter
 
     return LangGraphAdapter(agent, credentials=credentials, state_converter=state_converter, **kwargs)
 
-from .tool_client import ToolClient
-
 
 __all__ = ["from_langgraph", "ToolClient"]
 __version__ = VERSION