fixed ruff

Author: are-ces

lightspeed_stack_providers/providers/inline/agents/lightspeed_inline_agent/agents.py

@@ -222,13 +222,9 @@ async def _filter_tools_for_response(
             model=tools_filter_model_id,
             messages=[
                 OpenAISystemMessageParam(
-                    role="system",
-                    content=self.config.tools_filter.system_prompt
-                ),
-                OpenAIUserMessageParam(
-                    role="user",
-                    content=filter_prompt
+                    role="system", content=self.config.tools_filter.system_prompt
                 ),
+                OpenAIUserMessageParam(role="user", content=filter_prompt),
             ],
             stream=False,
             temperature=0.1,
@@ -289,7 +285,11 @@ async def _get_previously_called_tools(self, conversation_id: str) -> set[str]:
         tool_names: set[str] = set()
         try:
             items_response = await self.conversations_api.list_items(conversation_id)
-            items = items_response.data if hasattr(items_response, "data") else items_response
+            items = (
+                items_response.data
+                if hasattr(items_response, "data")
+                else items_response
+            )
             for item in items:
                 item_type = getattr(item, "type", None)
                 if item_type == "function_call":
@@ -330,23 +330,24 @@ async def _extract_tool_definitions(
                 mcp_tools = await self._get_mcp_tool_definitions(tool_dict)
                 tool_defs.extend(mcp_tools)
             elif tool_type == "file_search":
-                tool_defs.append({
-                    "tool_name": "file_search",
-                    "description": "Search through uploaded files and knowledge base"
-                })
+                tool_defs.append(
+                    {
+                        "tool_name": "file_search",
+                        "description": "Search through uploaded files and knowledge base",
+                    }
+                )
             elif tool_type == "function":
                 name = tool_dict.get("name", f"function_{i}")
                 description = tool_dict.get("description", "")
-                tool_defs.append({
-                    "tool_name": name,
-                    "description": description
-                })
+                tool_defs.append({"tool_name": name, "description": description})
             else:
                 logger.warning("Unknown tool type: %s", tool_type)
-                tool_defs.append({
-                    "tool_name": f"{tool_type}_{i}",
-                    "description": f"Tool of type {tool_type}"
-                })
+                tool_defs.append(
+                    {
+                        "tool_name": f"{tool_type}_{i}",
+                        "description": f"Tool of type {tool_type}",
+                    }
+                )
 
         return tool_defs
 
@@ -380,10 +381,12 @@ async def _get_mcp_tool_definitions(
             )
 
             for tool_def in tools_response.data:
-                tool_defs.append({
-                    "tool_name": tool_def.name,
-                    "description": tool_def.description or ""
-                })
+                tool_defs.append(
+                    {
+                        "tool_name": tool_def.name,
+                        "description": tool_def.description or "",
+                    }
+                )
 
             logger.debug(
                 "Retrieved %d tools from MCP server %s",
@@ -392,10 +395,12 @@ async def _get_mcp_tool_definitions(
             )
         except Exception as e:
             logger.error("Failed to get MCP tool definitions: %s", e)
-            tool_defs.append({
-                "tool_name": mcp_tool_config.get("server_label", "mcp_tool"),
-                "description": "MCP tool server"
-            })
+            tool_defs.append(
+                {
+                    "tool_name": mcp_tool_config.get("server_label", "mcp_tool"),
+                    "description": "MCP tool server",
+                }
+            )
 
         return tool_defs
 

lightspeed_stack_providers/providers/inline/safety/lightspeed_question_validity/safety.py

@@ -113,14 +113,15 @@ async def run_shield(
     ) -> RunShieldResponse:
         # Take last user message (can be UserMessage or OpenAIUserMessageParam)
         user_messages = [
-            m for m in messages
-            if isinstance(m, (UserMessage, OpenAIUserMessageParam)) or
-               (hasattr(m, 'role') and m.role == 'user')
+            m
+            for m in messages
+            if isinstance(m, (UserMessage, OpenAIUserMessageParam))
+            or (hasattr(m, "role") and m.role == "user")
         ]
         if not user_messages:
             return RunShieldResponse(violation=None)
         last_msg = user_messages[-1]
-        content = last_msg.content if hasattr(last_msg, 'content') else str(last_msg)
+        content = last_msg.content if hasattr(last_msg, "content") else str(last_msg)
         message = UserMessage(content=content)
         log.debug(f"Shield UserMessage: {message.content}")
 
@@ -179,7 +180,9 @@ async def run(self, message: UserMessage) -> RunShieldResponse:
         request = OpenAIChatCompletionRequestWithExtraBody(
             model=self.model_id,
             messages=[
-                OpenAIUserMessageParam(role="user", content=shield_input_message.content),
+                OpenAIUserMessageParam(
+                    role="user", content=shield_input_message.content
+                ),
             ],
             stream=False,
         )

lightspeed_stack_providers/providers/inline/safety/lightspeed_redaction/lightspeed_redaction/redaction.py

@@ -90,7 +90,7 @@ async def run_shield(
         """Run the redaction shield - mutates messages directly."""
 
         for message in messages:
-            if hasattr(message, 'content') and isinstance(message.content, str):
+            if hasattr(message, "content") and isinstance(message.content, str):
                 original_content: str = message.content
                 redacted_content: str = self._apply_redaction_rules(original_content)
 

lightspeed_stack_providers/providers/remote/agents/lightspeed_agent/lightspeed.py

@@ -36,7 +36,10 @@ def __init__(self, config: LightspeedAgentConfig):
 
     async def initialize(self) -> None:
         """Initialize the remote agent provider."""
-        logger.info("Initializing LightspeedRemoteAgentProvider with URL: %s", self.lightspeed_agent_url)
+        logger.info(
+            "Initializing LightspeedRemoteAgentProvider with URL: %s",
+            self.lightspeed_agent_url,
+        )
 
     async def shutdown(self) -> None:
         """Shutdown the remote agent provider."""
@@ -90,16 +93,19 @@ async def create_openai_response(
         if tools:
             # Convert tools to dict format if they're objects
             payload["tools"] = [
-                t if isinstance(t, dict) else t.model_dump()
-                for t in tools
+                t if isinstance(t, dict) else t.model_dump() for t in tools
             ]
         if instructions:
             payload["instructions"] = instructions
 
         # Add any additional kwargs
         payload.update(kwargs)
 
-        logger.debug("Proxying request to %s with payload: %s", self.lightspeed_agent_url, payload)
+        logger.debug(
+            "Proxying request to %s with payload: %s",
+            self.lightspeed_agent_url,
+            payload,
+        )
 
         if stream:
             return self._stream_response(payload)
@@ -118,7 +124,9 @@ async def _get_response(self, payload: dict) -> OpenAIResponseObject:
             data = response.json()
             return OpenAIResponseObject.model_validate(data)
 
-    async def _stream_response(self, payload: dict) -> AsyncIterator[OpenAIResponseObjectStream]:
+    async def _stream_response(
+        self, payload: dict
+    ) -> AsyncIterator[OpenAIResponseObjectStream]:
         """Stream response from the remote agent."""
         async with httpx.AsyncClient() as client:
             async with client.stream(

tests/unit/providers/inline/agents/lightspeed_inline_agent/test_agent_instance_inline_agent.py

@@ -44,11 +44,12 @@ def lightspeed_agents_impl(
     """Fixture for creating a LightspeedAgentsImpl instance."""
     persistence = AgentPersistenceConfig(
         agent_state=KVStoreReference(namespace="test", backend="in_memory"),
-        responses=ResponsesStoreReference(table_name="test_responses", backend="in_memory"),
+        responses=ResponsesStoreReference(
+            table_name="test_responses", backend="in_memory"
+        ),
     )
     config = LightspeedAgentsImplConfig(
-        persistence=persistence,
-        tools_filter=ToolsFilter(enabled=True, min_tools=0)
+        persistence=persistence, tools_filter=ToolsFilter(enabled=True, min_tools=0)
     )
     impl = LightspeedAgentsImpl(
         config=config,
@@ -99,8 +100,16 @@ async def test_filter_tools_for_response_filters_correctly(
 
     # Create MCP tools
     tools = [
-        {"type": "mcp", "server_label": "mcp_server1", "server_url": "http://test1.com"},
-        {"type": "mcp", "server_label": "mcp_server2", "server_url": "http://test2.com"},
+        {
+            "type": "mcp",
+            "server_label": "mcp_server1",
+            "server_url": "http://test1.com",
+        },
+        {
+            "type": "mcp",
+            "server_label": "mcp_server2",
+            "server_url": "http://test2.com",
+        },
     ]
 
     # Call the filtering method
@@ -138,8 +147,16 @@ async def test_filter_tools_for_response_includes_always_included_tools(
 
     # Create MCP tools
     tools = [
-        {"type": "mcp", "server_label": "mcp_server1", "server_url": "http://test1.com"},
-        {"type": "mcp", "server_label": "mcp_server2", "server_url": "http://test2.com"},
+        {
+            "type": "mcp",
+            "server_label": "mcp_server1",
+            "server_url": "http://test1.com",
+        },
+        {
+            "type": "mcp",
+            "server_label": "mcp_server2",
+            "server_url": "http://test2.com",
+        },
     ]
 
     # Call the filtering method

tests/unit/providers/inline/agents/lightspeed_inline_agent/test_agents_inline_agent.py

@@ -34,11 +34,12 @@ def lightspeed_agents_impl(mock_inference_api, mock_conversations_api, mocker):
     """Fixture for creating a LightspeedAgentsImpl instance."""
     persistence = AgentPersistenceConfig(
         agent_state=KVStoreReference(namespace="test", backend="in_memory"),
-        responses=ResponsesStoreReference(table_name="test_responses", backend="in_memory"),
+        responses=ResponsesStoreReference(
+            table_name="test_responses", backend="in_memory"
+        ),
     )
     config = LightspeedAgentsImplConfig(
-        persistence=persistence,
-        tools_filter=ToolsFilter(enabled=True, min_tools=5)
+        persistence=persistence, tools_filter=ToolsFilter(enabled=True, min_tools=5)
     )
     impl = LightspeedAgentsImpl(
         config=config,
@@ -66,7 +67,9 @@ def test_lightspeed_agents_impl_config_defaults():
     """Test that LightspeedAgentsImplConfig has correct defaults."""
     persistence = AgentPersistenceConfig(
         agent_state=KVStoreReference(namespace="test", backend="in_memory"),
-        responses=ResponsesStoreReference(table_name="test_responses", backend="in_memory"),
+        responses=ResponsesStoreReference(
+            table_name="test_responses", backend="in_memory"
+        ),
     )
     config = LightspeedAgentsImplConfig(persistence=persistence)
     assert config.tools_filter is not None

tests/unit/providers/inline/agents/lightspeed_inline_agent/test_config_inline_agent.py

@@ -3,7 +3,9 @@
 import os
 
 from llama_stack.core.storage.datatypes import KVStoreReference, ResponsesStoreReference
-from llama_stack.providers.inline.agents.meta_reference.config import AgentPersistenceConfig
+from llama_stack.providers.inline.agents.meta_reference.config import (
+    AgentPersistenceConfig,
+)
 
 from lightspeed_stack_providers.providers.inline.agents.lightspeed_inline_agent.config import (
     ToolsFilter,
@@ -59,7 +61,9 @@ def test_lightspeed_agents_impl_config_defaults():
     """Test that the LightspeedAgentsImplConfig model can be instantiated with default values."""
     persistence = AgentPersistenceConfig(
         agent_state=KVStoreReference(namespace="test", backend="in_memory"),
-        responses=ResponsesStoreReference(table_name="test_responses", backend="in_memory"),
+        responses=ResponsesStoreReference(
+            table_name="test_responses", backend="in_memory"
+        ),
     )
     config = LightspeedAgentsImplConfig(persistence=persistence)
     assert isinstance(config.tools_filter, ToolsFilter)

tests/unit/providers/inline/safety/lightspeed_question_validity/test_safety_question_validity.py

@@ -16,6 +16,7 @@
 def mock_inference_api():
     """Fixture for mocking the Inference API."""
     from unittest.mock import AsyncMock
+
     return AsyncMock()
 
 
@@ -133,7 +134,12 @@ async def test_run_shield_allowed(question_validity_shield_impl, mocker):
     )
     # Use OpenAI message format
     from llama_stack_api.inference import OpenAIUserMessageParam
-    messages = [OpenAIUserMessageParam(role="user", content="How do I create a Kubernetes service?")]
+
+    messages = [
+        OpenAIUserMessageParam(
+            role="user", content="How do I create a Kubernetes service?"
+        )
+    ]
 
     response = await question_validity_shield_impl.run_shield("test_shield", messages)
 
@@ -157,7 +163,10 @@ async def test_run_shield_rejected(question_validity_shield_impl, mocker):
     )
     # Use OpenAI message format
     from llama_stack_api.inference import OpenAIUserMessageParam
-    messages = [OpenAIUserMessageParam(role="user", content="What is the weather today?")]
+
+    messages = [
+        OpenAIUserMessageParam(role="user", content="What is the weather today?")
+    ]
 
     response = await question_validity_shield_impl.run_shield("test_shield", messages)
 

tests/unit/providers/remote/agents/lightspeed_agent/test_lightspeed_remote_agent.py

@@ -20,19 +20,29 @@ def lightspeed_remote_agent_provider():
 
 def test_provider_initialization(lightspeed_remote_agent_provider):
     """Test that the provider initializes correctly."""
-    assert lightspeed_remote_agent_provider.lightspeed_agent_url == "http://test.com/agent"
+    assert (
+        lightspeed_remote_agent_provider.lightspeed_agent_url == "http://test.com/agent"
+    )
     assert lightspeed_remote_agent_provider.config is not None
 
 
 @pytest.mark.asyncio
-async def test_create_openai_response_non_streaming(lightspeed_remote_agent_provider, mocker):
+async def test_create_openai_response_non_streaming(
+    lightspeed_remote_agent_provider, mocker
+):
     """Test the create_openai_response method with non-streaming."""
     mock_response_data = {
         "id": "resp_123",
         "object": "response",
         "created_at": 1234567890,
         "model": "test_model",
-        "output": [{"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "Hello!"}]}],
+        "output": [
+            {
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": "Hello!"}],
+            }
+        ],
         "status": "completed",
     }
 
@@ -57,7 +67,9 @@ async def test_create_openai_response_non_streaming(lightspeed_remote_agent_prov
 
 
 @pytest.mark.asyncio
-async def test_create_openai_response_streaming(lightspeed_remote_agent_provider, mocker):
+async def test_create_openai_response_streaming(
+    lightspeed_remote_agent_provider, mocker
+):
     """Test the create_openai_response method with streaming."""
     # Create valid response.created stream chunks
     response_obj = {
@@ -79,8 +91,8 @@ async def mock_stream(*args, **kwargs):
         mock_response.raise_for_status = mocker.MagicMock()
 
         async def async_generator():
-            yield f'data: {json.dumps(chunk1)}'
-            yield f'data: {json.dumps(chunk2)}'
+            yield f"data: {json.dumps(chunk1)}"
+            yield f"data: {json.dumps(chunk2)}"
             yield "data: [DONE]"
 
         mock_response.aiter_lines = async_generator
@@ -100,7 +112,9 @@ async def async_generator():
 
 
 @pytest.mark.asyncio
-async def test_create_openai_response_with_tools(lightspeed_remote_agent_provider, mocker):
+async def test_create_openai_response_with_tools(
+    lightspeed_remote_agent_provider, mocker
+):
     """Test the create_openai_response method with tools."""
     mock_response_data = {
         "id": "resp_123",