Merge branch 'main' of github.com:All-Hands-AI/OpenHands into enyst/gemini

Author: enyst

.github/ISSUE_TEMPLATE/bug_template.yml

@@ -5,11 +5,12 @@ labels: ['bug']
 body:
   - type: markdown
     attributes:
-      value: Thank you for taking the time to fill out this bug report. Please provide as much information as possible to help us understand and address the issue effectively.
+      value: Thank you for taking the time to fill out this bug report. Please provide as much information as possible
+       to help us understand and address the issue effectively.
 
   - type: checkboxes
     attributes:
-      label: Is there an existing issue for the same bug?
+      label: Is there an existing issue for the same bug? (If one exists, thumbs up or comment on the issue instead).
       description: Please check if an issue already exists for the bug you encountered.
       options:
       - label: I have checked the existing issues.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,6 +1,6 @@
 ---
-name: Feature Request
-about: Suggest an idea for OpenHands features
+name: Feature Request or Enhancement
+about: Suggest an idea for an OpenHands feature or enhancement
 title: ''
 labels: 'enhancement'
 assignees: ''
@@ -9,10 +9,6 @@ assignees: ''
 
 **What problem or use case are you trying to solve?**
 
-**Describe the UX of the solution you'd like**
-
-**Do you have thoughts on the technical implementation?**
-
-**Describe alternatives you've considered**
+**Describe the UX or technical implementation you have in mind**
 
 **Additional context**

.github/ISSUE_TEMPLATE/technical_proposal.md

@@ -1,6 +1,6 @@
 import asyncio
 from functools import partial
-from typing import Any
+from typing import Any, Callable
 
 from litellm import acompletion as litellm_acompletion
 
@@ -17,7 +17,7 @@
 class AsyncLLM(LLM):
     """Asynchronous LLM class."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         self._async_completion = partial(
@@ -46,7 +46,7 @@ def __init__(self, *args, **kwargs):
             retry_max_wait=self.config.retry_max_wait,
             retry_multiplier=self.config.retry_multiplier,
         )
-        async def async_completion_wrapper(*args, **kwargs):
+        async def async_completion_wrapper(*args: Any, **kwargs: Any) -> Any:
             """Wrapper for the litellm acompletion function that adds logging and cost tracking."""
             messages: list[dict[str, Any]] | dict[str, Any] = []
 
@@ -77,7 +77,7 @@ async def async_completion_wrapper(*args, **kwargs):
 
             self.log_prompt(messages)
 
-            async def check_stopped():
+            async def check_stopped() -> None:
                 while should_continue():
                     if (
                         hasattr(self.config, 'on_cancel_requested_fn')
@@ -117,14 +117,14 @@ async def check_stopped():
                 except asyncio.CancelledError:
                     pass
 
-        self._async_completion = async_completion_wrapper  # type: ignore
+        self._async_completion = async_completion_wrapper
 
-    async def _call_acompletion(self, *args, **kwargs):
+    async def _call_acompletion(self, *args: Any, **kwargs: Any) -> Any:
         """Wrapper for the litellm acompletion function."""
         # Used in testing?
         return await litellm_acompletion(*args, **kwargs)
 
     @property
-    def async_completion(self):
+    def async_completion(self) -> Callable:
         """Decorator for the async litellm acompletion function."""
         return self._async_completion

openhands/llm/async_llm.py

@@ -28,5 +28,5 @@ def list_foundation_models(
         return []
 
 
-def remove_error_modelId(model_list):
+def remove_error_modelId(model_list: list[str]) -> list[str]:
     return list(filter(lambda m: not m.startswith('bedrock'), model_list))

openhands/llm/bedrock.py

@@ -7,7 +7,7 @@
 
 
 class DebugMixin:
-    def log_prompt(self, messages: list[dict[str, Any]] | dict[str, Any]):
+    def log_prompt(self, messages: list[dict[str, Any]] | dict[str, Any]) -> None:
         if not messages:
             logger.debug('No completion messages!')
             return
@@ -24,30 +24,30 @@ def log_prompt(self, messages: list[dict[str, Any]] | dict[str, Any]):
         else:
             logger.debug('No completion messages!')
 
-    def log_response(self, message_back: str):
+    def log_response(self, message_back: str) -> None:
         if message_back:
             llm_response_logger.debug(message_back)
 
-    def _format_message_content(self, message: dict[str, Any]):
+    def _format_message_content(self, message: dict[str, Any]) -> str:
         content = message['content']
         if isinstance(content, list):
             return '\n'.join(
                 self._format_content_element(element) for element in content
             )
         return str(content)
 
-    def _format_content_element(self, element: dict[str, Any]):
+    def _format_content_element(self, element: dict[str, Any] | Any) -> str:
         if isinstance(element, dict):
             if 'text' in element:
-                return element['text']
+                return str(element['text'])
             if (
                 self.vision_is_active()
                 and 'image_url' in element
                 and 'url' in element['image_url']
             ):
-                return element['image_url']['url']
+                return str(element['image_url']['url'])
         return str(element)
 
     # This method should be implemented in the class that uses DebugMixin
-    def vision_is_active(self):
+    def vision_is_active(self) -> bool:
         raise NotImplementedError

openhands/llm/debug_mixin.py

@@ -187,7 +187,7 @@ def __init__(
             retry_multiplier=self.config.retry_multiplier,
             retry_listener=self.retry_listener,
         )
-        def wrapper(*args, **kwargs):
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
             """Wrapper for the litellm completion function. Logs the input and output of the completion function."""
             from openhands.io import json
 
@@ -356,14 +356,14 @@ def wrapper(*args, **kwargs):
         self._completion = wrapper
 
     @property
-    def completion(self):
+    def completion(self) -> Callable:
         """Decorator for the litellm completion function.
 
         Check the complete documentation at https://litellm.vercel.app/docs/completion
         """
         return self._completion
 
-    def init_model_info(self):
+    def init_model_info(self) -> None:
         if self._tried_model_info:
             return
         self._tried_model_info = True
@@ -623,10 +623,12 @@ def get_token_count(self, messages: list[dict] | list[Message]) -> int:
         # try to get the token count with the default litellm tokenizers
         # or the custom tokenizer if set for this LLM configuration
         try:
-            return litellm.token_counter(
-                model=self.config.model,
-                messages=messages,
-                custom_tokenizer=self.tokenizer,
+            return int(
+                litellm.token_counter(
+                    model=self.config.model,
+                    messages=messages,
+                    custom_tokenizer=self.tokenizer,
+                )
             )
         except Exception as e:
             # limit logspam in case token count is not supported
@@ -655,7 +657,7 @@ def _is_local(self) -> bool:
                 return True
         return False
 
-    def _completion_cost(self, response) -> float:
+    def _completion_cost(self, response: Any) -> float:
         """Calculate completion cost and update metrics with running total.
 
         Calculate the cost of a completion response based on the model. Local models are treated as free.
@@ -708,21 +710,21 @@ def _completion_cost(self, response) -> float:
                 logger.debug(
                     f'Using fallback model name {_model_name} to get cost: {cost}'
                 )
-            self.metrics.add_cost(cost)
-            return cost
+            self.metrics.add_cost(float(cost))
+            return float(cost)
         except Exception:
             self.cost_metric_supported = False
             logger.debug('Cost calculation not supported for this model.')
         return 0.0
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self.config.api_version:
             return f'LLM(model={self.config.model}, api_version={self.config.api_version}, base_url={self.config.base_url})'
         elif self.config.base_url:
             return f'LLM(model={self.config.model}, base_url={self.config.base_url})'
         return f'LLM(model={self.config.model})'
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return str(self)
 
     def reset(self) -> None:

openhands/llm/llm.py

@@ -177,7 +177,7 @@ def get(self) -> dict:
             'token_usages': [usage.model_dump() for usage in self._token_usages],
         }
 
-    def reset(self):
+    def reset(self) -> None:
         self._accumulated_cost = 0.0
         self._costs = []
         self._response_latencies = []
@@ -192,13 +192,13 @@ def reset(self):
             response_id='',
         )
 
-    def log(self):
+    def log(self) -> str:
         """Log the metrics."""
         metrics = self.get()
         logs = ''
         for key, value in metrics.items():
             logs += f'{key}: {value}\n'
         return logs
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'Metrics({self.get()}'

openhands/llm/metrics.py

@@ -1,5 +1,6 @@
 import json
 import re
+from typing import Any, Callable
 
 from tenacity import (
     retry,
@@ -90,7 +91,7 @@ def custom_wait_strategy(self, retry_state) -> float:
 
         return default_wait
 
-    def retry_decorator(self, **kwargs):
+    def retry_decorator(self, **kwargs: Any) -> Callable:
         """
         Create a LLM retry decorator with customizable parameters. This is used for 429 errors, and a few other exceptions in LLM classes.
 
@@ -109,7 +110,7 @@ def retry_decorator(self, **kwargs):
         self.retry_multiplier = kwargs.get('retry_multiplier')
         retry_listener = kwargs.get('retry_listener')
 
-        def before_sleep(retry_state):
+        def before_sleep(retry_state: Any) -> None:
             self.log_retry_attempt(retry_state)
             if retry_listener:
                 retry_listener(retry_state.attempt_number, self.num_retries)
@@ -130,15 +131,16 @@ def before_sleep(retry_state):
                             f'LLMNoResponseError detected with temperature={current_temp}, keeping original temperature'
                         )
 
-        return retry(
+        retry_decorator: Callable = retry(
             before_sleep=before_sleep,
             stop=stop_after_attempt(self.num_retries) | stop_if_should_exit(),
             reraise=True,
             retry=retry_if_exception_type(self.retry_exceptions),
             wait=self.custom_wait_strategy,
         )
+        return retry_decorator
 
-    def log_retry_attempt(self, retry_state):
+    def log_retry_attempt(self, retry_state: Any) -> None:
         """Log retry attempts."""
         exception = retry_state.outcome.exception()
         logger.error(

openhands/llm/retry_mixin.py

@@ -1,6 +1,6 @@
 import asyncio
 from functools import partial
-from typing import Any
+from typing import Any, Callable
 
 from openhands.core.exceptions import UserCancelledError
 from openhands.core.logger import openhands_logger as logger
@@ -11,7 +11,7 @@
 class StreamingLLM(AsyncLLM):
     """Streaming LLM class."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         self._async_streaming_completion = partial(
@@ -40,7 +40,7 @@ def __init__(self, *args, **kwargs):
             retry_max_wait=self.config.retry_max_wait,
             retry_multiplier=self.config.retry_multiplier,
         )
-        async def async_streaming_completion_wrapper(*args, **kwargs):
+        async def async_streaming_completion_wrapper(*args: Any, **kwargs: Any) -> Any:
             messages: list[dict[str, Any]] | dict[str, Any] = []
 
             # some callers might send the model and messages directly
@@ -108,6 +108,6 @@ async def async_streaming_completion_wrapper(*args, **kwargs):
         self._async_streaming_completion = async_streaming_completion_wrapper
 
     @property
-    def async_streaming_completion(self):
+    def async_streaming_completion(self) -> Callable:
         """Decorator for the async litellm acompletion function with streaming."""
         return self._async_streaming_completion

openhands/llm/streaming_llm.py

@@ -585,7 +585,10 @@ async def validation_exception_handler(
         logger.error(f'Validation error occurred: {exc}')
         return JSONResponse(
             status_code=422,
-            content={'detail': 'Invalid request parameters', 'errors': exc.errors()},
+            content={
+                'detail': 'Invalid request parameters',
+                'errors': str(exc.errors()),
+            },
         )
 
     @app.middleware('http')

openhands/runtime/action_execution_server.py

@@ -45,7 +45,7 @@
 from openhands.utils.tenacity_stop import stop_if_should_exit
 
 
-def _is_retryable_check_alive_error(exception):
+def _is_retryable_error(exception):
     return isinstance(
         exception, (httpx.RemoteProtocolError, httpcore.RemoteProtocolError)
     )
@@ -93,6 +93,11 @@ def __init__(
     def _get_action_execution_server_host(self) -> str:
         pass
 
+    @retry(
+        retry=retry_if_exception(_is_retryable_error),
+        stop=stop_after_attempt(5) | stop_if_should_exit(),
+        wait=wait_exponential(multiplier=1, min=4, max=15),
+    )
     def _send_action_server_request(
         self,
         method: str,
@@ -114,11 +119,6 @@ def _send_action_server_request(
         """
         return send_request(self.session, method, url, **kwargs)
 
-    @retry(
-        retry=retry_if_exception(_is_retryable_check_alive_error),
-        stop=stop_after_attempt(5) | stop_if_should_exit(),
-        wait=wait_exponential(multiplier=1, min=4, max=15),
-    )
     def check_if_alive(self) -> None:
         response = self._send_action_server_request(
             'GET',