openhands-sdk 1.5.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

openhands/sdk/io/local.py

@@ -1,6 +1,7 @@
 import os
 import shutil
 
+from openhands.sdk.io.cache import MemoryLRUCache
 from openhands.sdk.logger import get_logger
 from openhands.sdk.observability.laminar import observe
 
@@ -12,13 +13,31 @@ logger = get_logger(__name__)
 
 class LocalFileStore(FileStore):
     root: str
+    cache: MemoryLRUCache
 
-    def __init__(self, root: str):
+    def __init__(
+        self,
+        root: str,
+        cache_limit_size: int = 500,
+        cache_memory_size: int = 20 * 1024 * 1024,
+    ) -> None:
+        """Initialize a LocalFileStore with caching.
+
+        Args:
+            root: Root directory for file storage.
+            cache_limit_size: Maximum number of cached entries (default: 500).
+            cache_memory_size: Maximum cache memory in bytes (default: 20MB).
+
+        Note:
+            The cache assumes exclusive access to files. External modifications
+            to files will not be detected and may result in stale cache reads.
+        """
         if root.startswith("~"):
             root = os.path.expanduser(root)
         root = os.path.abspath(os.path.normpath(root))
         self.root = root
         os.makedirs(self.root, exist_ok=True)
+        self.cache = MemoryLRUCache(cache_memory_size, cache_limit_size)
 
     def get_full_path(self, path: str) -> str:
         # strip leading slash to keep relative under root
@@ -32,6 +51,7 @@ class LocalFileStore(FileStore):
         # ensure sandboxing
         if os.path.commonpath([self.root, full]) != self.root:
             raise ValueError(f"path escapes filestore root: {path}")
+
         return full
 
     @observe(name="LocalFileStore.write", span_type="TOOL")
@@ -41,14 +61,27 @@ class LocalFileStore(FileStore):
         if isinstance(contents, str):
             with open(full_path, "w", encoding="utf-8") as f:
                 f.write(contents)
+            self.cache[full_path] = contents
         else:
             with open(full_path, "wb") as f:
                 f.write(contents)
+            # Don't cache binary content - LocalFileStore is meant for JSON data
+            # If binary data is written and then read, it will error on read
 
     def read(self, path: str) -> str:
         full_path = self.get_full_path(path)
+
+        if full_path in self.cache:
+            return self.cache[full_path]
+
+        if not os.path.exists(full_path):
+            raise FileNotFoundError(path)
+
         with open(full_path, encoding="utf-8") as f:
-            return f.read()
+            result = f.read()
+
+        self.cache[full_path] = result
+        return result
 
     @observe(name="LocalFileStore.list", span_type="TOOL")
     def list(self, path: str) -> list[str]:
@@ -72,11 +105,15 @@ class LocalFileStore(FileStore):
             if not os.path.exists(full_path):
                 logger.debug(f"Local path does not exist: {full_path}")
                 return
+
             if os.path.isfile(full_path):
                 os.remove(full_path)
+                del self.cache[full_path]
                 logger.debug(f"Removed local file: {full_path}")
             elif os.path.isdir(full_path):
                 shutil.rmtree(full_path)
+                self.cache.clear()
                 logger.debug(f"Removed local directory: {full_path}")
+
         except Exception as e:
             logger.error(f"Error clearing local file store: {str(e)}")

openhands/sdk/llm/llm.py

@@ -247,10 +247,11 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
             "like HuggingFace and Groq."
         ),
     )
-    reasoning_effort: Literal["low", "medium", "high", "none"] | None = Field(
+    reasoning_effort: Literal["low", "medium", "high", "xhigh", "none"] | None = Field(
         default="high",
         description="The effort to put into reasoning. "
-        "This is a string that can be one of 'low', 'medium', 'high', or 'none'. "
+        "This is a string that can be one of 'low', 'medium', 'high', 'xhigh', "
+        "or 'none'. "
         "Can apply to all reasoning models.",
     )
     reasoning_summary: Literal["auto", "concise", "detailed"] | None = Field(

openhands/sdk/llm/message.py

@@ -120,8 +120,8 @@ class ThinkingBlock(BaseModel):
 
     type: Literal["thinking"] = "thinking"
     thinking: str = Field(..., description="The thinking content")
-    signature: str = Field(
-        ..., description="Cryptographic signature for the thinking block"
+    signature: str | None = Field(
+        default=None, description="Cryptographic signature for the thinking block"
     )
 
 
@@ -169,11 +169,12 @@ class TextContent(BaseContent):
     model_config: ClassVar[ConfigDict] = ConfigDict(
         extra="forbid", populate_by_name=True
     )
+    enable_truncation: bool = True
 
     def to_llm_dict(self) -> list[dict[str, str | dict[str, str]]]:
         """Convert to LLM API format."""
         text = self.text
-        if len(text) > DEFAULT_TEXT_CONTENT_LIMIT:
+        if self.enable_truncation and len(text) > DEFAULT_TEXT_CONTENT_LIMIT:
             logger.warning(
                 f"TextContent text length ({len(text)}) exceeds limit "
                 f"({DEFAULT_TEXT_CONTENT_LIMIT}), truncating"

openhands/sdk/llm/mixins/fn_call_converter.py

@@ -450,7 +450,8 @@ PLEASE follow the format strictly! PLEASE EMIT ONE AND ONLY ONE FUNCTION CALL PE
 """  # noqa: E501
 
 # Regex patterns for function call parsing
-FN_REGEX_PATTERN = r"<function=([^>]+)>\n(.*?)</function>"
+# Note: newline after function name is optional for compatibility with various models
+FN_REGEX_PATTERN = r"<function=([^>]+)>\n?(.*?)</function>"
 FN_PARAM_REGEX_PATTERN = r"<parameter=([^>]+)>(.*?)</parameter>"
 
 # Add new regex pattern for tool execution results
@@ -702,7 +703,7 @@ def convert_fncall_messages_to_non_fncall_messages(
     first_user_message_encountered = False
     for message in messages:
         role = message["role"]
-        content: Content = message["content"]
+        content: Content = message.get("content") or ""
 
         # 1. SYSTEM MESSAGES
         # append system prompt suffix to content
@@ -880,6 +881,9 @@ def _extract_and_validate_params(
     for param_match in param_matches:
         param_name = param_match.group(1)
         param_value = param_match.group(2)
+        # Normalize whitespace: some models add extra newlines around values
+        if isinstance(param_value, str):
+            param_value = param_value.strip()
 
         # Validate parameter is allowed
         if allowed_params and param_name not in allowed_params:
@@ -927,7 +931,11 @@ def _extract_and_validate_params(
         found_params.add(param_name)
 
     # Check all required parameters are present
-    missing_params = required_params - found_params
+    # Note: security_risk is excluded here because its validation happens later
+    # in Agent._extract_security_risk(), which has context about whether a security
+    # analyzer is configured. This allows weaker models to omit it when no analyzer
+    # is active, while still enforcing it for stronger models with LLMSecurityAnalyzer.
+    missing_params = required_params - found_params - {"security_risk"}
     if missing_params:
         raise FunctionCallValidationError(
             f"Missing required parameters for function '{fn_name}': {missing_params}"
@@ -935,12 +943,31 @@ def _extract_and_validate_params(
     return params
 
 
+def _preprocess_model_output(content: str) -> str:
+    """Clean up model-specific formatting before parsing function calls.
+
+    Removes wrapper tags that some models (like Nemotron) emit around function calls:
+    - </think> before the function call
+    - <tool_call>...</tool_call> around the function call
+
+    Only strips tags at boundaries, not inside parameter values.
+    """
+    # Strip </think> when it appears before <function= (Nemotron reasoning end)
+    content = re.sub(r"</think>\s*(?=<function=)", "", content)
+    # Strip <tool_call> when it appears right before <function=
+    content = re.sub(r"<tool_call>\s*(?=<function=)", "", content)
+    # Strip </tool_call> when it appears right after </function>
+    content = re.sub(r"(?<=</function>)\s*</tool_call>", "", content)
+    return content
+
+
 def _fix_stopword(content: str) -> str:
     """Fix the issue when some LLM would NOT return the stopword."""
+    content = _preprocess_model_output(content)
     if "<function=" in content and content.count("<function=") == 1:
         if content.endswith("</"):
             content = content.rstrip() + "function>"
-        else:
+        elif not content.rstrip().endswith("</function>"):
             content = content + "\n</function>"
     return content
 
@@ -981,8 +1008,8 @@ def convert_non_fncall_messages_to_fncall_messages(
 
     first_user_message_encountered = False
     for message in messages:
-        role, content = message["role"], message["content"]
-        content = content or ""  # handle cases where content is None
+        role = message["role"]
+        content = message.get("content") or ""
         # For system messages, remove the added suffix
         if role == "system":
             if isinstance(content, str):
@@ -1124,15 +1151,32 @@ def convert_non_fncall_messages_to_fncall_messages(
             if fn_match:
                 fn_name = fn_match.group(1)
                 fn_body = _normalize_parameter_tags(fn_match.group(2))
-                matching_tool: ChatCompletionToolParamFunctionChunk | None = next(
-                    (
-                        tool["function"]
-                        for tool in tools
-                        if tool["type"] == "function"
-                        and tool["function"]["name"] == fn_name
-                    ),
-                    None,
-                )
+
+                def _find_tool(
+                    name: str,
+                ) -> ChatCompletionToolParamFunctionChunk | None:
+                    return next(
+                        (
+                            tool["function"]
+                            for tool in tools
+                            if tool["type"] == "function"
+                            and tool["function"]["name"] == name
+                        ),
+                        None,
+                    )
+
+                matching_tool = _find_tool(fn_name)
+                # Try aliases if tool not found (some models use legacy names)
+                if not matching_tool:
+                    TOOL_NAME_ALIASES = {
+                        "str_replace_editor": "file_editor",
+                        "bash": "terminal",
+                        "execute_bash": "terminal",
+                        "str_replace": "file_editor",
+                    }
+                    if fn_name in TOOL_NAME_ALIASES:
+                        fn_name = TOOL_NAME_ALIASES[fn_name]
+                        matching_tool = _find_tool(fn_name)
                 # Validate function exists in tools
                 if not matching_tool:
                     available_tools = [
@@ -1203,7 +1247,8 @@ def convert_from_multiple_tool_calls_to_single_tool_call_messages(
     for message in messages:
         role: str
         content: Content
-        role, content = message["role"], message["content"]
+        role = message["role"]
+        content = message.get("content") or ""
         if role == "assistant":
             if message.get("tool_calls") and len(message["tool_calls"]) > 1:
                 # handle multiple tool calls by breaking them into multiple messages

openhands/sdk/llm/mixins/non_native_fc.py

@@ -41,7 +41,11 @@ class NonNativeToolCallingMixin:
         kwargs: dict,
     ) -> tuple[list[dict], dict]:
         """Convert to non-fncall prompting when native tool-calling is off."""
-        add_iclex = not any(s in self.model for s in ("openhands-lm", "devstral"))
+        # Skip in-context learning examples for models that understand the format
+        # or have limited context windows
+        add_iclex = not any(
+            s in self.model for s in ("openhands-lm", "devstral", "nemotron")
+        )
         messages = convert_fncall_messages_to_non_fncall_messages(
             messages, tools, add_in_context_learning_example=add_iclex
         )

openhands/sdk/llm/utils/model_features.py

@@ -15,6 +15,28 @@ def model_matches(model: str, patterns: list[str]) -> bool:
     return False
 
 
+def apply_ordered_model_rules(model: str, rules: list[str]) -> bool:
+    """Apply ordered include/exclude model rules to determine final support.
+
+    Rules semantics:
+    - Each entry is a substring token. '!' prefix marks an exclude rule.
+    - Case-insensitive substring matching against the raw model string.
+    - Evaluated in order; the last matching rule wins.
+    - If no rule matches, returns False.
+    """
+    raw = (model or "").strip().lower()
+    decided: bool | None = None
+    for rule in rules:
+        token = rule.strip().lower()
+        if not token:
+            continue
+        is_exclude = token.startswith("!")
+        core = token[1:] if is_exclude else token
+        if core and core in raw:
+            decided = not is_exclude
+    return bool(decided)
+
+
 @dataclass(frozen=True)
 class ModelFeatures:
     supports_reasoning_effort: bool
@@ -27,9 +49,9 @@ class ModelFeatures:
     supports_prompt_cache_retention: bool
 
 
-# Pattern tables capturing current behavior. Keep patterns lowercase.
+# Model lists capturing current behavior. Keep entries lowercase.
 
-REASONING_EFFORT_PATTERNS: list[str] = [
+REASONING_EFFORT_MODELS: list[str] = [
     # Mirror main behavior exactly (no unintended expansion)
     "o1-2024-12-17",
     "o1",
@@ -45,9 +67,11 @@ REASONING_EFFORT_PATTERNS: list[str] = [
     "gpt-5",
     # Anthropic Opus 4.5
     "claude-opus-4-5",
+    # Nova 2 Lite
+    "nova-2-lite",
 ]
 
-EXTENDED_THINKING_PATTERNS: list[str] = [
+EXTENDED_THINKING_MODELS: list[str] = [
     # Anthropic model family
     # We did not include sonnet 3.7 and 4 here as they don't brings
     # significant performance improvements for agents
@@ -55,7 +79,7 @@ EXTENDED_THINKING_PATTERNS: list[str] = [
     "claude-haiku-4-5",
 ]
 
-PROMPT_CACHE_PATTERNS: list[str] = [
+PROMPT_CACHE_MODELS: list[str] = [
     "claude-3-7-sonnet",
     "claude-sonnet-3-7-latest",
     "claude-3-5-sonnet",
@@ -70,14 +94,27 @@ PROMPT_CACHE_PATTERNS: list[str] = [
 ]
 
 # Models that support a top-level prompt_cache_retention parameter
-PROMPT_CACHE_RETENTION_PATTERNS: list[str] = [
-    # OpenAI GPT-5+ family
+# Source: OpenAI Prompt Caching docs (extended retention), which list:
+#   - gpt-5.2
+#   - gpt-5.1
+#   - gpt-5.1-codex
+#   - gpt-5.1-codex-mini
+#   - gpt-5.1-chat-latest
+#   - gpt-5
+#   - gpt-5-codex
+#   - gpt-4.1
+# Use ordered include/exclude rules (last wins) to naturally express exceptions.
+PROMPT_CACHE_RETENTION_MODELS: list[str] = [
+    # Broad allow for GPT-5 family and GPT-4.1 (covers gpt-5.2 and variants)
     "gpt-5",
-    # GPT-4.1 too
     "gpt-4.1",
+    # Exclude all mini variants by default
+    "!mini",
+    # Re-allow the explicitly documented supported mini variant
+    "gpt-5.1-codex-mini",
 ]
 
-SUPPORTS_STOP_WORDS_FALSE_PATTERNS: list[str] = [
+SUPPORTS_STOP_WORDS_FALSE_MODELS: list[str] = [
     # o-series families don't support stop words
     "o1",
     "o3",
@@ -89,7 +126,7 @@ SUPPORTS_STOP_WORDS_FALSE_PATTERNS: list[str] = [
 ]
 
 # Models that should use the OpenAI Responses API path by default
-RESPONSES_API_PATTERNS: list[str] = [
+RESPONSES_API_MODELS: list[str] = [
     # OpenAI GPT-5 family (includes mini variants)
     "gpt-5",
     # OpenAI Codex (uses Responses API)
@@ -101,41 +138,44 @@ RESPONSES_API_PATTERNS: list[str] = [
 # and need plain strings instead
 # NOTE: model_matches uses case-insensitive substring matching, not globbing.
 #       Keep these entries as bare substrings without wildcards.
-FORCE_STRING_SERIALIZER_PATTERNS: list[str] = [
+FORCE_STRING_SERIALIZER_MODELS: list[str] = [
     "deepseek",  # e.g., DeepSeek-V3.2-Exp
     "glm",  # e.g., GLM-4.5 / GLM-4.6
     # Kimi K2-Instruct requires string serialization only on Groq
     "groq/kimi-k2-instruct",  # explicit provider-prefixed IDs
+    # MiniMax-M2 via OpenRouter rejects array content with
+    # "Input should be a valid string" for ChatCompletionToolMessage.content
+    "openrouter/minimax",
 ]
 
 # Models that we should send full reasoning content
 # in the message input
-SEND_REASONING_CONTENT_PATTERNS: list[str] = [
+SEND_REASONING_CONTENT_MODELS: list[str] = [
     "kimi-k2-thinking",
+    "deepseek/deepseek-reasoner",
 ]
 
 
 def get_features(model: str) -> ModelFeatures:
     """Get model features."""
     return ModelFeatures(
-        supports_reasoning_effort=model_matches(model, REASONING_EFFORT_PATTERNS),
-        supports_extended_thinking=model_matches(model, EXTENDED_THINKING_PATTERNS),
-        supports_prompt_cache=model_matches(model, PROMPT_CACHE_PATTERNS),
-        supports_stop_words=not model_matches(
-            model, SUPPORTS_STOP_WORDS_FALSE_PATTERNS
-        ),
-        supports_responses_api=model_matches(model, RESPONSES_API_PATTERNS),
-        force_string_serializer=model_matches(model, FORCE_STRING_SERIALIZER_PATTERNS),
-        send_reasoning_content=model_matches(model, SEND_REASONING_CONTENT_PATTERNS),
-        supports_prompt_cache_retention=model_matches(
-            model, PROMPT_CACHE_RETENTION_PATTERNS
+        supports_reasoning_effort=model_matches(model, REASONING_EFFORT_MODELS),
+        supports_extended_thinking=model_matches(model, EXTENDED_THINKING_MODELS),
+        supports_prompt_cache=model_matches(model, PROMPT_CACHE_MODELS),
+        supports_stop_words=not model_matches(model, SUPPORTS_STOP_WORDS_FALSE_MODELS),
+        supports_responses_api=model_matches(model, RESPONSES_API_MODELS),
+        force_string_serializer=model_matches(model, FORCE_STRING_SERIALIZER_MODELS),
+        send_reasoning_content=model_matches(model, SEND_REASONING_CONTENT_MODELS),
+        # Extended prompt_cache_retention support follows ordered include/exclude rules.
+        supports_prompt_cache_retention=apply_ordered_model_rules(
+            model, PROMPT_CACHE_RETENTION_MODELS
         ),
     )
 
 
 # Default temperature mapping.
 # Each entry: (pattern, default_temperature)
-DEFAULT_TEMPERATURE_PATTERNS: list[tuple[str, float]] = [
+DEFAULT_TEMPERATURE_MODELS: list[tuple[str, float]] = [
     ("kimi-k2-thinking", 1.0),
 ]
 
@@ -145,7 +185,7 @@ def get_default_temperature(model: str) -> float:
 
     Uses case-insensitive substring matching via model_matches.
     """
-    for pattern, value in DEFAULT_TEMPERATURE_PATTERNS:
+    for pattern, value in DEFAULT_TEMPERATURE_MODELS:
         if model_matches(model, [pattern]):
             return value
     return 0.0

openhands/sdk/llm/utils/model_prompt_spec.py

@@ -0,0 +1,98 @@
+"""Utilities for detecting model families and variants.
+
+These helpers allow prompts and other systems to tailor behavior for specific
+LLM providers while keeping naming heuristics centralized.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ModelPromptSpec(BaseModel):
+    """Detected prompt metadata for a given model configuration."""
+
+    model_config = ConfigDict(frozen=True)
+
+    family: str | None = None
+    variant: str | None = None
+
+
+_MODEL_FAMILY_PATTERNS: dict[str, tuple[str, ...]] = {
+    "openai_gpt": (
+        "gpt-",
+        "o1",
+        "o3",
+        "o4",
+    ),
+    "anthropic_claude": ("claude",),
+    "google_gemini": ("gemini",),
+    "meta_llama": ("llama",),
+    "mistral": ("mistral",),
+    "deepseek": ("deepseek",),
+    "alibaba_qwen": ("qwen",),
+}
+
+# Ordered heuristics to pick the most specific variant available for a family.
+_MODEL_VARIANT_PATTERNS: dict[str, tuple[tuple[str, tuple[str, ...]], ...]] = {
+    "openai_gpt": (
+        ("gpt-5-codex", ("gpt-5-codex", "gpt-5.1-codex")),
+        ("gpt-5", ("gpt-5", "gpt-5.1")),
+    ),
+}
+
+
+def _normalize(name: str | None) -> str:
+    return (name or "").strip().lower()
+
+
+def _match_family(model_name: str) -> str | None:
+    normalized = _normalize(model_name)
+    if not normalized:
+        return None
+
+    for family, patterns in _MODEL_FAMILY_PATTERNS.items():
+        if any(pattern in normalized for pattern in patterns):
+            return family
+    return None
+
+
+def _match_variant(
+    family: str,
+    model_name: str,
+    canonical_name: str | None = None,
+) -> str | None:
+    patterns = _MODEL_VARIANT_PATTERNS.get(family)
+    if not patterns:
+        return None
+
+    # Choose canonical_name if available, otherwise fall back to model_name
+    candidate = _normalize(canonical_name) or _normalize(model_name)
+    if not candidate:
+        return None
+
+    for variant, substrings in patterns:
+        if any(sub in candidate for sub in substrings):
+            return variant
+
+    return None
+
+
+def get_model_prompt_spec(
+    model_name: str,
+    canonical_name: str | None = None,
+) -> ModelPromptSpec:
+    """Return family and variant prompt metadata for the given identifiers."""
+
+    family = _match_family(model_name)
+    if family is None and canonical_name:
+        family = _match_family(canonical_name)
+
+    variant = None
+    if family is not None:
+        variant = _match_variant(family, model_name, canonical_name)
+
+    return ModelPromptSpec(family=family, variant=variant)
+
+
+__all__ = ["ModelPromptSpec", "get_model_prompt_spec"]

openhands/sdk/llm/utils/verified_models.py

@@ -1,11 +1,12 @@
 VERIFIED_OPENAI_MODELS = [
-    "gpt-5-codex",
-    "gpt-5-2025-08-07",
-    "gpt-5-mini-2025-08-07",
+    "gpt-5.2",
     "gpt-5.1",
-    "gpt-5.1-codex",
     "gpt-5.1-codex-max",
+    "gpt-5.1-codex",
     "gpt-5.1-codex-mini",
+    "gpt-5-codex",
+    "gpt-5-2025-08-07",
+    "gpt-5-mini-2025-08-07",
     "o4-mini",
     "gpt-4o",
     "gpt-4o-mini",
@@ -44,6 +45,7 @@ VERIFIED_MISTRAL_MODELS = [
 VERIFIED_OPENHANDS_MODELS = [
     "claude-opus-4-5-20251101",
     "claude-sonnet-4-5-20250929",
+    "gpt-5.2",
     "gpt-5.1-codex-max",
     "gpt-5.1-codex",
     "gpt-5.1",

openhands/sdk/logger/logger.py

@@ -83,7 +83,7 @@ def disable_logger(name: str, level: int = logging.CRITICAL) -> None:
 
 # Quiet chatty third-party loggers
 for name in ["litellm", "LiteLLM", "openai"]:
-    disable_logger(name, logging.DEBUG if _ENABLE_LITELLM_DEBUG else logging.WARNING)
+    disable_logger(name, logging.DEBUG if _ENABLE_LITELLM_DEBUG else logging.ERROR)
 for name in ["httpcore", "httpx", "libtmux"]:
     disable_logger(name, logging.WARNING)
 

openhands/sdk/tool/schema.py

@@ -22,6 +22,16 @@ S = TypeVar("S", bound="Schema")
 def py_type(spec: dict[str, Any]) -> Any:
     """Map JSON schema types to Python types."""
     t = spec.get("type")
+
+    # Normalize union types like ["string", "null"] to a single representative type.
+    # MCP schemas often mark optional fields this way; we keep the non-null type.
+    if isinstance(t, (list, tuple, set)):
+        types = list(t)
+        non_null = [tp for tp in types if tp != "null"]
+        if len(non_null) == 1:
+            t = non_null[0]
+        else:
+            return Any
     if t == "array":
         items = spec.get("items", {})
         inner = py_type(items) if isinstance(items, dict) else Any

openhands/sdk/tool/tool.py

@@ -364,7 +364,7 @@ class ToolDefinition[ActionT, ObservationT](DiscriminatedUnionMixin, ABC):
         action_type: type[Schema] | None = None,
     ) -> dict[str, Any]:
         action_type = action_type or self.action_type
-        action_type_with_risk = _create_action_type_with_risk(action_type)
+        action_type_with_risk = create_action_type_with_risk(action_type)
 
         add_security_risk_prediction = add_security_risk_prediction and (
             self.annotations is None or (not self.annotations.readOnlyHint)
@@ -460,7 +460,7 @@ class ToolDefinition[ActionT, ObservationT](DiscriminatedUnionMixin, ABC):
         raise ValueError(error_msg)
 
 
-def _create_action_type_with_risk(action_type: type[Schema]) -> type[Schema]:
+def create_action_type_with_risk(action_type: type[Schema]) -> type[Schema]:
     action_type_with_risk = _action_types_with_risk.get(action_type)
     if action_type_with_risk:
         return action_type_with_risk