fix: @Bartok9 contributions

src/rai_bench/rai_bench/test_models.py

@@ -121,7 +121,7 @@ def test_models(
         raise ValueError("Number of passed models must match number of passed vendors")
     else:
         for bench_conf in benchmark_configs:
-            # for each bench configuration seperate run folder
+            # for each bench configuration separate run folder
             now = datetime.now()
             run_name = f"run_{now.strftime('%Y-%m-%d_%H-%M-%S')}"
             for i, model_name in enumerate(model_names):

src/rai_core/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rai_core"
-version = "2.12.1"
+version = "2.12.2"
 description = "Core functionality for RAI framework"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"

src/rai_core/rai/agents/langchain/agent.py

@@ -115,6 +115,8 @@ def __init__(
         max_size: int = 100,
     ):
         super().__init__()
+        if max_size <= 0:
+            raise ValueError(f"max_size must be positive, got {max_size!r}")
         self.logger = logging.getLogger(__name__)
         self.agent = runnable
         self.stream_response = stream_response

src/rai_core/rai/agents/langchain/callback.py

@@ -34,6 +34,14 @@ def __init__(
         logger: Optional[logging.Logger] = None,
         stream_response: bool = True,
     ):
+        if isinstance(max_buffer_size, bool) or not isinstance(max_buffer_size, int):
+            raise TypeError(
+                f"max_buffer_size must be a positive int, got {type(max_buffer_size).__name__}"
+            )
+        if max_buffer_size <= 0:
+            raise ValueError(
+                f"max_buffer_size must be positive, got {max_buffer_size!r}"
+            )
         self.connectors = connectors
         self.aggregate_chunks = aggregate_chunks
         self.stream_response = stream_response

src/rai_core/rai/agents/langchain/state_based_agent.py

@@ -21,7 +21,7 @@
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import BaseMessage, HumanMessage
 from langchain_core.tools import BaseTool
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from rai.agents.langchain.agent import LangChainAgent, newMessageBehaviorType
 from rai.agents.langchain.core import ReActAgentState, create_state_based_runnable
@@ -42,6 +42,20 @@ class StateBasedConfig(BaseModel):
         arbitrary_types_allowed=True,
     )
 
+    @field_validator("time_interval")
+    @classmethod
+    def _time_interval_positive(cls, v: float) -> float:
+        if v <= 0:
+            raise ValueError(f"time_interval must be positive, got {v!r}")
+        return v
+
+    @field_validator("max_workers")
+    @classmethod
+    def _max_workers_positive(cls, v: int) -> int:
+        if v <= 0:
+            raise ValueError(f"max_workers must be positive, got {v!r}")
+        return v
+
 
 class BaseStateBasedAgent(LangChainAgent, ABC):
     """

src/rai_core/rai/agents/runner.py

@@ -37,6 +37,8 @@ def wait_for_shutdown(agents: List[BaseAgent]):
     an interrupt signal (SIGINT, e.g., Ctrl+C) or SIGTERM. It installs signal handlers to
     capture these events and invokes the agent's ``stop()`` method as part of the shutdown process.
     """
+    if not agents:
+        raise ValueError("agents must be a non-empty list")
     shutdown_event = Event()
 
     def signal_handler(signum, frame):
@@ -58,6 +60,8 @@ def run_agents(agents: List[BaseAgent]):
     Args:
         agents: List of agent instances
     """
+    if not agents:
+        raise ValueError("agents must be a non-empty list")
     logger.info(
         "run_agents is an experimental function. \
                    If you believe that your agents are not running properly, \
@@ -84,6 +88,8 @@ def __init__(self, agents: List[BaseAgent]):
         agents : List[BaseAgent]
             List of agent instances to be managed by the runner.
         """
+        if not agents:
+            raise ValueError("agents must be a non-empty list")
         self.agents = agents
         self.logger = logging.getLogger(__name__)
 

src/rai_core/rai/aggregators/base.py

@@ -28,6 +28,8 @@ class BaseAggregator(ABC, Generic[T]):
 
     def __init__(self, max_size: int | None = None) -> None:
         super().__init__()
+        if max_size is not None and max_size <= 0:
+            raise ValueError(f"max_size must be positive or None, got {max_size}")
         self._buffer: Deque[T] = deque()
         self.max_size = max_size
 

src/rai_core/rai/aggregators/ros2/aggregators.py

@@ -37,7 +37,7 @@ def get(self) -> HumanMessage:
         prev_parsed = None
         counter = 0
         for log in msgs:
-            level = self.levels[log.level]
+            level = self.levels.get(log.level, str(log.level))
             parsed = f"[{log.name}] [{level}] [{log.function}] {log.msg}"
             if parsed == prev_parsed:
                 counter += 1
@@ -112,7 +112,7 @@ class ROS2ImgDescription(BaseModel):
 class ROS2ImgVLMDiffAggregator(BaseAggregator[Image | CompressedImage]):
     """
     Returns the LLM analysis of the differences between 3 images in the
-    aggregation buffer: 1st, midden, last
+    aggregation buffer: 1st, middle, last
     """
 
     SYSTEM_PROMPT = "You are an expert in image analysis and your speciality is the comparison of 3 images"
@@ -142,6 +142,7 @@ def get(self) -> HumanMessage | None:
             return None
 
         b64_images = [convert_ros_img_to_base64(msg) for msg in msgs]
+        original_count = len(b64_images)
 
         self.clear_buffer()
 
@@ -165,5 +166,8 @@ class ROS2ImgDiffOutput(BaseModel):
         llm = self.llm.with_structured_output(ROS2ImgDiffOutput)
         response = cast(ROS2ImgDiffOutput, llm.invoke(task))
         return HumanMessage(
-            content=f"Result of the analysis of the {len(b64_images)} keyframes selected from {len(b64_images)} last images:\n{response}"
+            content=(
+                f"Result of the analysis of the {len(b64_images)} keyframes "
+                f"selected from {original_count} last images:\n{response}"
+            )
         )

src/rai_core/rai/communication/base_connector.py

@@ -72,6 +72,10 @@ class ParametrizedCallback(BaseModel, Generic[T]):
 
 class BaseConnector(Generic[T]):
     def __init__(self, callback_max_workers: int = 4):
+        if callback_max_workers <= 0:
+            raise ValueError(
+                f"callback_max_workers must be positive, got {callback_max_workers!r}"
+            )
         self.callback_max_workers = callback_max_workers
         self.logger = logging.getLogger(self.__class__.__name__)
         self.registered_callbacks: Dict[str, Dict[str, ParametrizedCallback[T]]] = (

src/rai_core/rai/communication/ros2/api/action.py

@@ -152,8 +152,17 @@ def create_action_server(
             The handle for the created action server
 
         Raises:
-            ValueError: If the action server cannot be created
+            TypeError: If result_timeout is not a positive number (bool rejected).
+            ValueError: If the action server cannot be created or result_timeout <= 0.
         """
+        if isinstance(result_timeout, bool) or not isinstance(
+            result_timeout, (int, float)
+        ):
+            raise TypeError(
+                f"result_timeout must be a positive number, got {type(result_timeout).__name__}"
+            )
+        if result_timeout <= 0:
+            raise ValueError(f"result_timeout must be positive, got {result_timeout!r}")
         handle = self._generate_handle()
         action_ros_type = import_message_from_str(action_type)
         try:

src/rai_core/rai/communication/ros2/ros_async.py

@@ -26,6 +26,8 @@ def get_future_result(
     future: rclpy.task.Future, timeout_sec: float = 5.0
 ) -> Any | None:
     """Replaces rclpy.spin_until_future_complete"""
+    if timeout_sec <= 0:
+        raise ValueError(f"timeout_sec must be positive, got {timeout_sec}")
     result = None
     event = threading.Event()
 

src/rai_core/rai/communication/ros2/waiters.py

@@ -30,8 +30,8 @@ def get_missing_entities(
     callable_get_entities: Callable[[], List[str]],
     requested_entities: List[str],
 ) -> set[str]:
-    requested_set = set(requested_entities)
-    available_set = set(callable_get_entities())
+    requested_set = {ensure_slash(name) for name in requested_entities}
+    available_set = {ensure_slash(name) for name in callable_get_entities()}
     return requested_set - available_set
 
 

src/rai_core/rai/messages/artifacts.py

@@ -26,18 +26,18 @@ def store_artifacts(
     tool_call_id: str, artifacts: List[Any], db_path="artifact_database.pkl"
 ):
     # TODO(boczekbartek): refactor
-    db_path = Path(db_path)
-    if not db_path.is_file():
-        artifact_database = {}
-        with open("artifact_database.pkl", "wb") as file:
+    path = Path(db_path)
+    if not path.is_file():
+        artifact_database: dict = {}
+        with path.open("wb") as file:
             pickle.dump(artifact_database, file)
-    with open("artifact_database.pkl", "rb") as file:
+    with path.open("rb") as file:
         artifact_database = pickle.load(file)
         if tool_call_id not in artifact_database:
             artifact_database[tool_call_id] = artifacts
         else:
             artifact_database[tool_call_id].extend(artifacts)
-    with open("artifact_database.pkl", "wb") as file:
+    with path.open("wb") as file:
         pickle.dump(artifact_database, file)
 
 

src/rai_core/rai/tools/ros2/cli.py

@@ -22,6 +22,12 @@
 
 
 def run_with_timeout(cmd: List[str], timeout_sec: int):
+    if isinstance(timeout_sec, bool) or not isinstance(timeout_sec, (int, float)):
+        raise TypeError(
+            f"timeout_sec must be a positive number, got {type(timeout_sec).__name__}"
+        )
+    if timeout_sec <= 0:
+        raise ValueError(f"timeout_sec must be positive, got {timeout_sec!r}")
     proc = Popen(cmd, stdout=PIPE, stderr=PIPE)
     timer = Timer(timeout_sec, proc.kill)
     try:

tests/agents/langchain/test_hri_callback_handler.py

@@ -0,0 +1,39 @@
+# Copyright (C) 2025 Robotec.AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+from rai.agents.langchain.callback import HRICallbackHandler
+
+
+def test_hri_callback_handler_rejects_nonpositive_max_buffer_size():
+    with pytest.raises(ValueError, match="max_buffer_size must be positive"):
+        HRICallbackHandler(connectors={}, max_buffer_size=0)
+    with pytest.raises(ValueError, match="max_buffer_size must be positive"):
+        HRICallbackHandler(connectors={}, max_buffer_size=-1)
+
+
+def test_hri_callback_handler_rejects_non_int_max_buffer_size():
+    with pytest.raises(TypeError, match="max_buffer_size must be a positive int"):
+        HRICallbackHandler(connectors={}, max_buffer_size=False)
+    with pytest.raises(TypeError, match="max_buffer_size must be a positive int"):
+        HRICallbackHandler(connectors={}, max_buffer_size=1.5)  # type: ignore[arg-type]
+    with pytest.raises(TypeError, match="max_buffer_size must be a positive int"):
+        HRICallbackHandler(connectors={}, max_buffer_size="200")  # type: ignore[arg-type]
+
+
+def test_hri_callback_handler_accepts_positive_max_buffer_size():
+    handler = HRICallbackHandler(connectors={}, max_buffer_size=1)
+    assert handler.max_buffer_size == 1
+    default_handler = HRICallbackHandler(connectors={})
+    assert default_handler.max_buffer_size == 200

tests/agents/langchain/test_langchain_agent_max_size.py

@@ -0,0 +1,37 @@
+# Copyright (C) 2025 Robotec.AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from unittest.mock import MagicMock
+
+import pytest
+from rai.agents.langchain.agent import LangChainAgent
+
+
+def _make_agent(max_size: int) -> LangChainAgent:
+    return LangChainAgent(
+        target_connectors={},
+        runnable=MagicMock(),
+        max_size=max_size,
+    )
+
+
+def test_max_size_must_be_positive():
+    for bad in (0, -1, False):
+        with pytest.raises(ValueError, match="max_size must be positive"):
+            _make_agent(bad)  # type: ignore[arg-type]
+
+
+def test_max_size_accepts_positive():
+    agent = _make_agent(1)
+    assert agent.max_size == 1

tests/agents/langchain/test_state_based_config.py

@@ -0,0 +1,38 @@
+# Copyright (C) 2025 Robotec.AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+from pydantic import ValidationError
+from rai.agents.langchain.state_based_agent import StateBasedConfig
+
+
+def test_time_interval_must_be_positive():
+    for bad in (0, -1.0, 0.0):
+        with pytest.raises(ValidationError):
+            StateBasedConfig(aggregators={}, time_interval=bad)
+
+
+def test_max_workers_must_be_positive():
+    for bad in (0, -1):
+        with pytest.raises(ValidationError):
+            StateBasedConfig(aggregators={}, max_workers=bad)
+
+
+def test_defaults_and_positive_ok():
+    cfg = StateBasedConfig(aggregators={})
+    assert cfg.time_interval == 5.0
+    assert cfg.max_workers == 8
+    cfg2 = StateBasedConfig(aggregators={}, time_interval=0.1, max_workers=1)
+    assert cfg2.time_interval == 0.1
+    assert cfg2.max_workers == 1

tests/agents/test_agent_runner.py

@@ -61,3 +61,26 @@ def fake_signal(signum, handler):
 
     assert thread.is_alive() is False
     assert all(agent.stop_called for agent in agents)
+
+
+def test_agent_runner_rejects_empty_agents():
+    import pytest
+
+    with pytest.raises(ValueError, match="non-empty"):
+        AgentRunner([])
+
+
+def test_wait_for_shutdown_rejects_empty_agents():
+    import pytest
+    from rai.agents.runner import wait_for_shutdown
+
+    with pytest.raises(ValueError, match="non-empty"):
+        wait_for_shutdown([])
+
+
+def test_run_agents_rejects_empty_agents():
+    import pytest
+    from rai.agents.runner import run_agents
+
+    with pytest.raises(ValueError, match="non-empty"):
+        run_agents([])