Reduce line-length from 500 to 88 and fix pre-commit errors (#68)

Co-authored-by: openhands <openhands@all-hands.dev>

Author: xingyaoww

examples/hello_world.py

@@ -61,7 +61,14 @@ def conversation_callback(event: EventType):
 conversation.send_message(
     message=Message(
         role="user",
-        content=[TextContent(text="Hello! Can you create a new Python file named hello.py that prints 'Hello, World!'?")],
+        content=[
+            TextContent(
+                text=(
+                    "Hello! Can you create a new Python file named hello.py that "
+                    "prints 'Hello, World!'?"
+                )
+            )
+        ],
     )
 )
 conversation.run()

openhands/core/agent/base.py

@@ -73,7 +73,8 @@ def init_state(
         state: ConversationState,
         on_event: ConversationCallbackType,
     ) -> None:
-        """Initialize the empty conversation state to prepare the agent for user messages.
+        """Initialize the empty conversation state to prepare the agent for user
+        messages.
 
         Typically this involves adding system message
 

openhands/core/agent/codeact_agent/codeact_agent.py

@@ -11,10 +11,23 @@
 
 from openhands.core.context import EnvContext, render_system_message
 from openhands.core.conversation import ConversationCallbackType, ConversationState
-from openhands.core.event import ActionEvent, AgentErrorEvent, LLMConvertibleEvent, MessageEvent, ObservationEvent, SystemPromptEvent
+from openhands.core.event import (
+    ActionEvent,
+    AgentErrorEvent,
+    LLMConvertibleEvent,
+    MessageEvent,
+    ObservationEvent,
+    SystemPromptEvent,
+)
 from openhands.core.llm import LLM, Message, TextContent, get_llm_metadata
 from openhands.core.logger import get_logger
-from openhands.core.tool import BUILT_IN_TOOLS, ActionBase, FinishTool, ObservationBase, Tool
+from openhands.core.tool import (
+    BUILT_IN_TOOLS,
+    ActionBase,
+    FinishTool,
+    ObservationBase,
+    Tool,
+)
 
 from ..base import AgentBase
 
@@ -32,10 +45,18 @@ def __init__(
         cli_mode: bool = True,
     ) -> None:
         for tool in BUILT_IN_TOOLS:
-            assert tool not in tools, f"{tool} is automatically included and should not be provided."
+            assert tool not in tools, (
+                f"{tool} is automatically included and should not be provided."
+            )
         super().__init__(llm=llm, tools=tools + BUILT_IN_TOOLS, env_context=env_context)
 
-        self.system_message: TextContent = TextContent(text=render_system_message(prompt_dir=self.prompt_dir, system_prompt_filename=system_prompt_filename, cli_mode=cli_mode))
+        self.system_message: TextContent = TextContent(
+            text=render_system_message(
+                prompt_dir=self.prompt_dir,
+                system_prompt_filename=system_prompt_filename,
+                cli_mode=cli_mode,
+            )
+        )
 
         self.max_iterations: int = 10
 
@@ -44,11 +65,16 @@ def init_state(
         state: ConversationState,
         on_event: ConversationCallbackType,
     ) -> None:
-        # TODO(openhands): we should add test to test this init_state will actually modify state in-place
+        # TODO(openhands): we should add test to test this init_state will actually
+        # modify state in-place
         messages = [e.to_llm_message() for e in state.events]
         if len(messages) == 0:
             # Prepare system message
-            event = SystemPromptEvent(source="agent", system_prompt=self.system_message, tools=[t.to_openai_tool() for t in self.tools.values()])
+            event = SystemPromptEvent(
+                source="agent",
+                system_prompt=self.system_message,
+                tools=[t.to_openai_tool() for t in self.tools.values()],
+            )
             on_event(event)
 
     def step(
@@ -57,13 +83,22 @@ def step(
         on_event: ConversationCallbackType,
     ) -> None:
         # Get LLM Response (Action)
-        llm_convertible_events = cast(list[LLMConvertibleEvent], [e for e in state.events if isinstance(e, LLMConvertibleEvent)])
-        _messages = self.llm.format_messages_for_llm(LLMConvertibleEvent.events_to_messages(llm_convertible_events))
+        llm_convertible_events = cast(
+            list[LLMConvertibleEvent],
+            [e for e in state.events if isinstance(e, LLMConvertibleEvent)],
+        )
+        _messages = self.llm.format_messages_for_llm(
+            LLMConvertibleEvent.events_to_messages(llm_convertible_events)
+        )
         logger.debug(f"Sending messages to LLM: {json.dumps(_messages, indent=2)}")
         response: ModelResponse = self.llm.completion(
             messages=_messages,
             tools=[tool.to_openai_tool() for tool in self.tools.values()],
-            extra_body={"metadata": get_llm_metadata(model_name=self.llm.config.model, agent_name=self.name)},
+            extra_body={
+                "metadata": get_llm_metadata(
+                    model_name=self.llm.config.model, agent_name=self.name
+                )
+            },
         )
         assert len(response.choices) == 1 and isinstance(response.choices[0], Choices)
         llm_message: LiteLLMMessage = response.choices[0].message  # type: ignore
@@ -72,12 +107,24 @@ def step(
         if message.tool_calls and len(message.tool_calls) > 0:
             tool_call: ChatCompletionMessageToolCall
             if any(tc.type != "function" for tc in message.tool_calls):
-                logger.warning("LLM returned tool calls but some are not of type 'function' - ignoring those")
+                logger.warning(
+                    "LLM returned tool calls but some are not of type 'function' - "
+                    "ignoring those"
+                )
 
-            tool_calls = [tool_call for tool_call in message.tool_calls if tool_call.type == "function"]
-            assert len(tool_calls) > 0, "LLM returned tool calls but none are of type 'function'"
+            tool_calls = [
+                tool_call
+                for tool_call in message.tool_calls
+                if tool_call.type == "function"
+            ]
+            assert len(tool_calls) > 0, (
+                "LLM returned tool calls but none are of type 'function'"
+            )
             if not all(isinstance(c, TextContent) for c in message.content):
-                logger.warning("LLM returned tool calls but message content is not all TextContent - ignoring non-text content")
+                logger.warning(
+                    "LLM returned tool calls but message content is not all "
+                    "TextContent - ignoring non-text content"
+                )
 
             # Generate unique batch ID for this LLM response
             thought_content = [c for c in message.content if isinstance(c, TextContent)]
@@ -89,7 +136,9 @@ def step(
                     tool_call,
                     llm_response_id=response.id,
                     on_event=on_event,
-                    thought=thought_content if i == 0 else [],  # Only first gets thought
+                    thought=thought_content
+                    if i == 0
+                    else [],  # Only first gets thought
                 )
                 if action_event is None:
                     continue
@@ -130,34 +179,62 @@ def _get_action_events(
 
         # Validate arguments
         try:
-            action: ActionBase = tool.action_type.model_validate(json.loads(tool_call.function.arguments))
+            action: ActionBase = tool.action_type.model_validate(
+                json.loads(tool_call.function.arguments)
+            )
         except (json.JSONDecodeError, ValidationError) as e:
-            err = f"Error validating args {tool_call.function.arguments} for tool '{tool.name}': {e}"
+            err = (
+                f"Error validating args {tool_call.function.arguments} for tool "
+                f"'{tool.name}': {e}"
+            )
             event = AgentErrorEvent(error=err)
             on_event(event)
             return
 
         # Create one ActionEvent per action
-        action_event = ActionEvent(action=action, thought=thought, tool_name=tool.name, tool_call_id=tool_call.id, tool_call=tool_call, llm_response_id=llm_response_id)
+        action_event = ActionEvent(
+            action=action,
+            thought=thought,
+            tool_name=tool.name,
+            tool_call_id=tool_call.id,
+            tool_call=tool_call,
+            llm_response_id=llm_response_id,
+        )
         on_event(action_event)
         return action_event
 
-    def _execute_action_events(self, state: ConversationState, action_event: ActionEvent, on_event: ConversationCallbackType):
+    def _execute_action_events(
+        self,
+        state: ConversationState,
+        action_event: ActionEvent,
+        on_event: ConversationCallbackType,
+    ):
         """Execute action events and update the conversation state.
 
-        It will call the tool's executor and update the state & call callback fn with the observation.
+        It will call the tool's executor and update the state & call callback fn
+        with the observation.
         """
         tool = self.tools.get(action_event.tool_name, None)
         if tool is None:
-            raise RuntimeError(f"Tool '{action_event.tool_name}' not found. This should not happen as it was checked earlier.")
+            raise RuntimeError(
+                f"Tool '{action_event.tool_name}' not found. This should not happen "
+                "as it was checked earlier."
+            )
 
         # Execute actions!
         if tool.executor is None:
             raise RuntimeError(f"Tool '{tool.name}' has no executor")
         observation: ObservationBase = tool.executor(action_event.action)
-        assert isinstance(observation, ObservationBase), f"Tool '{tool.name}' executor must return an ObservationBase"
+        assert isinstance(observation, ObservationBase), (
+            f"Tool '{tool.name}' executor must return an ObservationBase"
+        )
 
-        obs_event = ObservationEvent(observation=observation, action_id=action_event.id, tool_name=tool.name, tool_call_id=action_event.tool_call.id)
+        obs_event = ObservationEvent(
+            observation=observation,
+            action_id=action_event.id,
+            tool_name=tool.name,
+            tool_call_id=action_event.tool_call.id,
+        )
         on_event(obs_event)
 
         # Set conversation state

openhands/core/config/llm_config.py

@@ -46,7 +46,7 @@ class LLMConfig(BaseModel):
         reasoning_effort: The effort to put into reasoning. This is a string that can be one of 'low', 'medium', 'high', or 'none'. Can apply to all reasoning models.
         seed: The seed to use for the LLM.
         safety_settings: Safety settings for models that support them (like Mistral AI and Gemini).
-    """
+    """  # noqa: E501
 
     model: str = Field(default="claude-sonnet-4-20250514")
     api_key: SecretStr | None = Field(default=None)
@@ -63,7 +63,9 @@ class LLMConfig(BaseModel):
     retry_min_wait: int = Field(default=8)
     retry_max_wait: int = Field(default=64)
     timeout: int | None = Field(default=None)
-    max_message_chars: int = Field(default=30_000)  # maximum number of characters in an observation's content when sent to the llm
+    max_message_chars: int = Field(
+        default=30_000
+    )  # maximum number of characters in an observation's content when sent to the llm
     temperature: float = Field(default=0.0)
     top_p: float = Field(default=1.0)
     top_k: float | None = Field(default=None)
@@ -81,20 +83,25 @@ class LLMConfig(BaseModel):
     disable_stop_word: bool | None = Field(default=False)
     caching_prompt: bool = Field(default=True)
     log_completions: bool = Field(default=False)
-    log_completions_folder: str = Field(default=os.path.join(ENV_LOG_DIR, "completions"))
+    log_completions_folder: str = Field(
+        default=os.path.join(ENV_LOG_DIR, "completions")
+    )
     custom_tokenizer: str | None = Field(default=None)
     native_tool_calling: bool | None = Field(default=None)
     reasoning_effort: str | None = Field(default=None)
     seed: int | None = Field(default=None)
     safety_settings: list[dict[str, str]] | None = Field(
         default=None,
-        description="Safety settings for models that support them (like Mistral AI and Gemini)",
+        description=(
+            "Safety settings for models that support them (like Mistral AI and Gemini)"
+        ),
     )
 
     model_config = ConfigDict(extra="forbid")
 
     def model_post_init(self, __context: Any) -> None:
-        """Post-initialization hook to assign OpenRouter-related variables to environment variables.
+        """Post-initialization hook to assign OpenRouter-related variables to
+        environment variables.
 
         This ensures that these values are accessible to litellm at runtime.
         """
@@ -121,6 +128,8 @@ def model_post_init(self, __context: Any) -> None:
         if self.aws_access_key_id:
             os.environ["AWS_ACCESS_KEY_ID"] = self.aws_access_key_id.get_secret_value()
         if self.aws_secret_access_key:
-            os.environ["AWS_SECRET_ACCESS_KEY"] = self.aws_secret_access_key.get_secret_value()
+            os.environ["AWS_SECRET_ACCESS_KEY"] = (
+                self.aws_secret_access_key.get_secret_value()
+            )
         if self.aws_region_name:
             os.environ["AWS_REGION_NAME"] = self.aws_region_name

openhands/core/config/mcp_config.py

@@ -89,7 +89,10 @@ def validate_server_name(cls, v: str) -> str:
 
         # Check for valid characters (alphanumeric, hyphens, underscores)
         if not re.match(r"^[a-zA-Z0-9_-]+$", v):
-            raise ValueError("Server name can only contain letters, numbers, hyphens, and underscores")
+            raise ValueError(
+                "Server name can only contain letters, numbers, hyphens, and "
+                "underscores"
+            )
 
         return v
 
@@ -104,7 +107,10 @@ def validate_command(cls, v: str) -> str:
 
         # Check that command doesn't contain spaces (should be a single executable)
         if " " in v:
-            raise ValueError("Command should be a single executable without spaces (use arguments field for parameters)")
+            raise ValueError(
+                "Command should be a single executable without spaces (use "
+                "arguments field for parameters)"
+            )
 
         return v
 
@@ -131,7 +137,10 @@ def parse_args(cls, v) -> list[str]:
                 return shlex.split(v)
             except ValueError as e:
                 # If shlex parsing fails (e.g., unmatched quotes), provide clear error
-                raise ValueError(f'Invalid argument format: {str(e)}. Use shell-like format, e.g., "arg1 arg2" or \'--config "value with spaces"\'')
+                raise ValueError(
+                    f"Invalid argument format: {str(e)}. Use shell-like format, "
+                    f'e.g., "arg1 arg2" or \'--config "value with spaces"\''
+                )
 
         return v or []
 
@@ -150,14 +159,20 @@ def parse_env(cls, v) -> dict[str, str]:
                     continue
 
                 if "=" not in pair:
-                    raise ValueError(f"Environment variable '{pair}' must be in KEY=VALUE format")
+                    raise ValueError(
+                        f"Environment variable '{pair}' must be in KEY=VALUE format"
+                    )
 
                 key, value = pair.split("=", 1)
                 key = key.strip()
                 if not key:
                     raise ValueError("Environment variable key cannot be empty")
                 if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", key):
-                    raise ValueError(f"Invalid environment variable name '{key}'. Must start with letter or underscore, contain only alphanumeric characters and underscores")
+                    raise ValueError(
+                        f"Invalid environment variable name '{key}'. Must start with "
+                        f"letter or underscore, contain only alphanumeric characters "
+                        f"and underscores"
+                    )
 
                 env[key] = value
             return env
@@ -172,7 +187,12 @@ def __eq__(self, other):
         """
         if not isinstance(other, MCPStdioServerConfig):
             return False
-        return self.name == other.name and self.command == other.command and self.args == other.args and set(self.env.items()) == set(other.env.items())
+        return (
+            self.name == other.name
+            and self.command == other.command
+            and self.args == other.args
+            and set(self.env.items()) == set(other.env.items())
+        )
 
 
 class MCPSHTTPServerConfig(BaseModel):
@@ -191,7 +211,8 @@ class MCPConfig(BaseModel):
 
     Attributes:
         sse_servers: List of MCP SSE server configs
-        stdio_servers: List of MCP stdio server configs. These servers will be added to the MCP Router running inside runtime container.
+        stdio_servers: List of MCP stdio server configs. These servers will be
+            added to the MCP Router running inside runtime container.
         shttp_servers: List of MCP HTTP server configs.
     """
 
@@ -242,12 +263,14 @@ def validate_servers(self) -> None:
 
     @classmethod
     def from_toml_section(cls, data: dict) -> dict[str, "MCPConfig"]:
-        """Create a mapping of MCPConfig instances from a toml dictionary representing the [mcp] section.
+        """Create a mapping of MCPConfig instances from a toml dictionary
+        representing the [mcp] section.
 
         The configuration is built from all keys in data.
 
         Returns:
-            dict[str, MCPConfig]: A mapping where the key "mcp" corresponds to the [mcp] configuration
+            dict[str, MCPConfig]: A mapping where the key "mcp" corresponds to the
+                [mcp] configuration
         """
         # Initialize the result mapping
         mcp_mapping: dict[str, MCPConfig] = {}
@@ -256,7 +279,9 @@ def from_toml_section(cls, data: dict) -> dict[str, "MCPConfig"]:
             # Convert all entries in sse_servers to MCPSSEServerConfig objects
             if "sse_servers" in data:
                 data["sse_servers"] = cls._normalize_servers(data["sse_servers"])
-                servers: list[MCPSSEServerConfig | MCPStdioServerConfig | MCPSHTTPServerConfig] = []
+                servers: list[
+                    MCPSSEServerConfig | MCPStdioServerConfig | MCPSHTTPServerConfig
+                ] = []
                 for server in data["sse_servers"]:
                     servers.append(MCPSSEServerConfig(**server))
                 data["sse_servers"] = servers