style: Apply ruff formatting across project

Author: uzair330

src/agents/lifecycle.py

@@ -1,6 +1,7 @@
-from typing import Any, Generic,List
-from .items import ModelResponse, TResponseInputItem
+from typing import Any, Generic
+
 from .agent import Agent
+from .items import ModelResponse, TResponseInputItem
 from .run_context import RunContextWrapper, TContext
 from .tool import Tool
 
@@ -10,28 +11,24 @@ class RunHooks(Generic[TContext]):
     override the methods you need.
     """
 
-    #Two new hook methods added to the RunHooks class to handle LLM start and end events.
-    #These methods allow you to perform actions just before and after the LLM call for an agent.
-    #This is useful for logging, monitoring, or modifying the context before and after the LLM call.
+    # Two new hook methods added to the RunHooks class to handle LLM start and end events.
+    # These methods allow you to perform actions just before and after the LLM call for an agent.
+    # This is useful for logging, monitoring, or modifying the context before and after the LLM call
     async def on_llm_start(
         self,
         context: RunContextWrapper[TContext],
         agent: Agent[TContext],
         system_prompt: str | None,
-        input_items: List[TResponseInputItem]
+        input_items: list[TResponseInputItem],
     ) -> None:
         """Called just before invoking the LLM for this agent."""
         pass
 
     async def on_llm_end(
-        self,
-        context: RunContextWrapper[TContext],
-        agent: Agent[TContext],
-        response: ModelResponse
+        self, context: RunContextWrapper[TContext], agent: Agent[TContext], response: ModelResponse
     ) -> None:
         """Called immediately after the LLM call returns for this agent."""
         pass
-    
 
     async def on_agent_start(
         self, context: RunContextWrapper[TContext], agent: Agent[TContext]

src/agents/run.py

@@ -1069,12 +1069,7 @@ async def _get_new_response(
         model_settings = RunImpl.maybe_reset_tool_choice(agent, tool_use_tracker, model_settings)
         # If the agent has hooks, we need to call them before and after the LLM call
         if agent.hooks:
-            await agent.hooks.on_llm_start(
-                context_wrapper,
-                agent,
-                system_prompt,
-                input
-            )
+            await agent.hooks.on_llm_start(context_wrapper, agent, system_prompt, input)
 
         new_response = await model.get_response(
             system_instructions=system_prompt,
@@ -1091,11 +1086,7 @@ async def _get_new_response(
         )
         # If the agent has hooks, we need to call them after the LLM call
         if agent.hooks:
-            await agent.hooks.on_llm_end(
-                context_wrapper,
-                agent,
-                new_response
-            )
+            await agent.hooks.on_llm_end(context_wrapper, agent, new_response)
 
         context_wrapper.usage.add(new_response.usage)
 

tests/test_agent_llm_hooks.py

@@ -1,25 +1,25 @@
-
-from typing import Any, List
+from typing import Any
 
 import pytest
 
+# Types from the openai library used by the SDK
+from openai.types.responses import ResponseFunctionToolCall, ResponseOutputMessage
+
 # Core SDK Imports
 from agents.agent import Agent
-from agents.run import Runner
-from agents.lifecycle import AgentHooks
-from agents.tool import Tool, function_tool, FunctionTool
 from agents.items import ModelResponse
-from agents.usage import Usage, InputTokensDetails, OutputTokensDetails
+from agents.lifecycle import AgentHooks
 from agents.models.interface import Model
+from agents.run import Runner
+from agents.tool import Tool, function_tool
+from agents.usage import InputTokensDetails, OutputTokensDetails, Usage
 
-# Types from the openai library used by the SDK
-from openai.types.responses import ResponseFunctionToolCall, ResponseOutputMessage
 
 # --- 1. Spy Hook Implementation ---
 class LoggingAgentHooks(AgentHooks[Any]):
     def __init__(self):
         super().__init__()
-        self.called_hooks: List[str] = []
+        self.called_hooks: list[str] = []
 
     # Spy on the NEW hooks
     async def on_llm_start(self, *args, **kwargs):
@@ -41,9 +41,11 @@ async def on_tool_start(self, *args, **kwargs):
     async def on_tool_end(self, *args, **kwargs):
         self.called_hooks.append("on_tool_end")
 
+
 # --- 2. Mock Model and Tools ---
 class MockModel(Model):
     """A mock model that can be configured to either return a chat message or a tool call."""
+
     def __init__(self):
         self._call_count = 0
         self._should_call_tool = False
@@ -59,54 +61,77 @@ def configure_for_chat(self):
 
     async def get_response(self, *args, **kwargs) -> ModelResponse:
         self._call_count += 1
-        response_items: List[Any] = []
+        response_items: list[Any] = []
 
         if self._should_call_tool and self._call_count == 1:
             response_items.append(
-                ResponseFunctionToolCall(name=self._tool_to_call.name, arguments='{}', call_id="call123", type="function_call")
+                ResponseFunctionToolCall(
+                    name=self._tool_to_call.name,
+                    arguments="{}",
+                    call_id="call123",
+                    type="function_call",
+                )
             )
         else:
             response_items.append(
-                ResponseOutputMessage(id="msg1", content=[{"type":"output_text", "text":"Mock response", "annotations":[]}], role="assistant", status="completed", type="message")
+                ResponseOutputMessage(
+                    id="msg1",
+                    content=[{"type": "output_text", "text": "Mock response", "annotations": []}],
+                    role="assistant",
+                    status="completed",
+                    type="message",
+                )
             )
-        
+
         mock_usage = Usage(
-            requests=1, input_tokens=10, output_tokens=10, total_tokens=20,
+            requests=1,
+            input_tokens=10,
+            output_tokens=10,
+            total_tokens=20,
             input_tokens_details=InputTokensDetails(cached_tokens=0),
-            output_tokens_details=OutputTokensDetails(reasoning_tokens=0)
+            output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
         )
         return ModelResponse(output=response_items, usage=mock_usage, response_id="resp123")
 
     async def stream_response(self, *args, **kwargs):
         final_response = await self.get_response(*args, **kwargs)
         from openai.types.responses import ResponseCompletedEvent
+
         class MockSDKResponse:
-            def __init__(self, id, output, usage): self.id, self.output, self.usage = id, output, usage
-        yield ResponseCompletedEvent(response=MockSDKResponse(final_response.response_id, final_response.output, final_response.usage), type="response_completed")
+            def __init__(self, id, output, usage):
+                self.id, self.output, self.usage = id, output, usage
+
+        yield ResponseCompletedEvent(
+            response=MockSDKResponse(
+                final_response.response_id, final_response.output, final_response.usage
+            ),
+            type="response_completed",
+        )
+
 
 @function_tool
 def mock_tool(a: int, b: int) -> int:
     """A mock tool for testing tool call hooks."""
     return a + b
 
+
 # --- 3. Pytest Fixtures for Test Setup ---
 @pytest.fixture
 def logging_hooks() -> LoggingAgentHooks:
     """Provides a fresh instance of LoggingAgentHooks for each test."""
     return LoggingAgentHooks()
 
+
 @pytest.fixture
 def chat_agent(logging_hooks: LoggingAgentHooks) -> Agent:
     """Provides an agent configured for a simple chat interaction."""
     mock_model = MockModel()
     mock_model.configure_for_chat()
     return Agent(
-        name="ChatAgent",
-        instructions="Test agent for chat.",
-        model=mock_model,
-        hooks=logging_hooks
+        name="ChatAgent", instructions="Test agent for chat.", model=mock_model, hooks=logging_hooks
     )
 
+
 @pytest.fixture
 def tool_agent(logging_hooks: LoggingAgentHooks) -> Agent:
     """Provides an agent configured to use a tool."""
@@ -117,21 +142,20 @@ def tool_agent(logging_hooks: LoggingAgentHooks) -> Agent:
         instructions="Test agent for tools.",
         model=mock_model,
         hooks=logging_hooks,
-        tools=[mock_tool]
+        tools=[mock_tool],
     )
 
+
 # --- 4. Test Cases Focused on New Hooks ---
 @pytest.mark.asyncio
-async def test_llm_hooks_fire_in_chat_scenario(
-    chat_agent: Agent, logging_hooks: LoggingAgentHooks
-):
+async def test_llm_hooks_fire_in_chat_scenario(chat_agent: Agent, logging_hooks: LoggingAgentHooks):
     """
     Tests that on_llm_start and on_llm_end fire correctly for a chat-only turn.
     """
     await Runner.run(chat_agent, "Hello")
-    
+
     sequence = logging_hooks.called_hooks
-    
+
     expected_sequence = [
         "on_start",
         "on_llm_start",
@@ -140,6 +164,7 @@ async def test_llm_hooks_fire_in_chat_scenario(
     ]
     assert sequence == expected_sequence
 
+
 @pytest.mark.asyncio
 async def test_llm_hooks_wrap_tool_hooks_in_tool_scenario(
     tool_agent: Agent, logging_hooks: LoggingAgentHooks
@@ -159,10 +184,11 @@ async def test_llm_hooks_wrap_tool_hooks_in_tool_scenario(
         "on_tool_end",
         "on_llm_start",
         "on_llm_end",
-        "on_end"
+        "on_end",
     ]
     assert sequence == expected_sequence
 
+
 @pytest.mark.asyncio
 async def test_no_hooks_run_if_hooks_is_none():
     """
@@ -171,13 +197,10 @@ async def test_no_hooks_run_if_hooks_is_none():
     mock_model = MockModel()
     mock_model.configure_for_chat()
     agent_no_hooks = Agent(
-        name="NoHooksAgent",
-        instructions="Test agent without hooks.",
-        model=mock_model,
-        hooks=None
+        name="NoHooksAgent", instructions="Test agent without hooks.", model=mock_model, hooks=None
     )
-    
+
     try:
         await Runner.run(agent_no_hooks, "Hello")
     except Exception as e:
-        pytest.fail(f"Runner.run failed when agent.hooks was None: {e}")
+        pytest.fail(f"Runner.run failed when agent.hooks was None: {e}")