waldiez 0.5.9__py3-none-any.whl → 0.6.0__py3-none-any.whl

waldiez/models/common/dict_utils.py

@@ -2,63 +2,192 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Dictionary related utilities."""
 
+import ast
+import json
 import re
-from typing import Any
+from typing import Any, Union
 
 BOOL_VALUES = {"true", "false"}
 NULL_VALUES = {"none", "null", "nil", "undefined"}
 
 
+def _strip_outer_quotes(value: str) -> str:
+    """Remove outer quotes from a string if present."""
+    value_stripped = value.strip()
+    if (value_stripped.startswith('"') and value_stripped.endswith('"')) or (
+        value_stripped.startswith("'") and value_stripped.endswith("'")
+    ):
+        return value_stripped[1:-1]
+    return value_stripped
+
+
+def _detect_null_or_boolean(value: str) -> Union[None, bool, str]:
+    """
+    Detect null values or booleans.
+
+    Parameters
+    ----------
+    value : str
+        The string value to check.
+
+    Returns
+    -------
+    Union[None, bool, str]
+        None for null values, bool for booleans, or original string if neither.
+    """
+    value_lower = value.lower()
+
+    if value_lower in NULL_VALUES:
+        return None
+    if value_lower in BOOL_VALUES:
+        return value_lower == "true"
+
+    return value
+
+
+def _detect_numeric_type(value: str) -> Union[int, float, str]:
+    """
+    Detect if string represents an integer or float.
+
+    Parameters
+    ----------
+    value : str
+        The string value to check.
+
+    Returns
+    -------
+    Union[int, float, str]
+        int for integers, float for floats, or original string if neither.
+    """
+    # Check for integer first (more specific)
+    if re.fullmatch(r"[-+]?\d+", value):
+        return int(value)
+
+    # Try float conversion
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+def _detect_container_type(
+    value: str,
+) -> Union[dict[str, Any], list[Any], tuple[Any], set[Any], str]:
+    """
+    Detect if string represents a container type (dict, list, tuple, set).
+
+    Parameters
+    ----------
+    value : str
+        The string value to check.
+
+    Returns
+    -------
+    Union[dict[str, Any], list[Any], tuple[Any], set[Any], str]
+        Parsed container or original string if not a container.
+    """
+    if not (value[0] in "{[(" and value[-1] in "}])"):
+        return value
+
+    # Handle empty containers
+    if value in ("()", "[]", "{}"):
+        return ast.literal_eval(value)
+
+    # Try JSON first (expects double quotes)
+    try:
+        parsed = json.loads(value)
+        if isinstance(parsed, (dict, list)):
+            return parsed  # pyright: ignore
+    except (json.JSONDecodeError, TypeError):
+        pass
+
+    # Fallback: Python literal (handles single quotes, tuples, sets)
+    try:
+        parsed = ast.literal_eval(value)
+        if isinstance(parsed, (dict, list, tuple, set)):
+            return parsed  # pyright: ignore
+    except (ValueError, SyntaxError):
+        pass
+
+    return value
+
+
+def _convert_string_value(value: str) -> Any:
+    """
+    Convert a string value to its detected type.
+
+    Parameters
+    ----------
+    value : str
+        The string value to convert.
+
+    Returns
+    -------
+    Any
+        The converted value or original string if no conversion possible.
+    """
+    # Strip outer quotes if present
+    cleaned_value = _strip_outer_quotes(value)
+
+    # Skip conversion for empty strings
+    if not cleaned_value:
+        return value
+
+    # Try conversions in order of specificity
+
+    # 1. Container types (most specific structure)
+    container_result = _detect_container_type(cleaned_value)
+    if container_result != cleaned_value:
+        return container_result
+
+    # 2. Null and boolean values
+    null_bool_result = _detect_null_or_boolean(cleaned_value)
+    if null_bool_result != cleaned_value:
+        return null_bool_result
+
+    # 3. Numeric types
+    numeric_result = _detect_numeric_type(cleaned_value)
+    if numeric_result != cleaned_value:
+        return numeric_result
+
+    # 4. Keep as string if no conversion succeeded
+    return cleaned_value
+
+
 def update_dict(original: dict[str, Any]) -> dict[str, Any]:
     """
-    Try to determine the type of the dictionary values.
+    Convert string values in a dictionary to their detected types.
+
+    Automatically detects and converts strings that represent:
+    - Boolean values (true/false)
+    - Null values (none/null/nil/undefined)
+    - Integers and floats
+    - Container types (lists, dicts, tuples, sets)
 
     Parameters
     ----------
     original : dict[str, Any]
-        The original dictionary.
+        The original dictionary with potentially string-encoded values.
 
     Returns
     -------
     dict[str, Any]
-        The updated dictionary with values converted to the detected types.
+        A new dictionary with string values converted to their detected types.
+        Non-string values are preserved unchanged.
+
+    Examples
+    --------
+    >>> data = {"count": "42", "active": "true", "tags": "['a', 'b']"}
+    >>> update_dict(data)
+    {"count": 42, "active": True, "tags": ['a', 'b']}
     """
-    new_dict: dict[str, Any] = {}
+    converted_dict: dict[str, Any] = {}
 
     for key, value in original.items():
-        # Skip conversion if already the desired type
-        if not isinstance(value, str):
-            new_dict[key] = value
-            continue
-
-        value_stripped = value.strip()
-        if (
-            value_stripped.startswith('"') and value_stripped.endswith('"')
-        ) or (value_stripped.startswith("'") and value_stripped.endswith("'")):
-            value_stripped = value_stripped[1:-1]
-        if not value_stripped:  # Empty or whitespace-only
-            new_dict[key] = value
-            continue
-
-        value_lower = value_stripped.lower()
-
-        # Check for None/null
-        if value_lower in NULL_VALUES:
-            new_dict[key] = None
-        # Check for boolean
-        elif value_lower in BOOL_VALUES:
-            new_dict[key] = value_lower == "true"
-        # Check for integer
-        elif re.fullmatch(r"[-+]?\d+", value_stripped):
-            new_dict[key] = int(value_stripped)
-        # Check for float
+        # Only process string values
+        if isinstance(value, str):
+            converted_dict[key] = _convert_string_value(value)
         else:
-            try:
-                # This handles floats, scientific notation, etc.
-                float_val = float(value_stripped)
-                new_dict[key] = float_val
-            except ValueError:
-                # Keep as string if conversion fails
-                new_dict[key] = value_stripped
-
-    return new_dict
+            converted_dict[key] = value
+
+    return converted_dict

waldiez/models/common/handoff.py

@@ -343,6 +343,7 @@ class WaldiezTransitionAvailability(WaldiezBase):
     value: str = ""
 
 
+# noinspection PyTypeHints
 class WaldiezLLMBasedTransition(WaldiezBase):
     """Condition wrapper for LLM conditions."""
 
@@ -351,6 +352,7 @@ class WaldiezLLMBasedTransition(WaldiezBase):
     available: WaldiezTransitionAvailability
 
 
+# noinspection PyTypeHints
 class WaldiezContextBasedTransition(WaldiezBase):
     """Condition wrapper for context conditions."""
 

waldiez/models/common/method_utils.py

@@ -123,11 +123,13 @@ def _extract_imports_from_ast(code_string: str) -> tuple[list[str], list[str]]:
 
     for node in ast.walk(tree):
         if isinstance(node, (ast.Import, ast.ImportFrom)):
+            # noinspection PyTypeChecker
             full_import_statement = ast.get_source_segment(code_string, node)
             if not full_import_statement:  # pragma: no cover
                 continue
             full_import_statement = full_import_statement.strip()
 
+            # noinspection PyTypeChecker
             module_name = _extract_module_name(node)
             if not module_name:  # pragma: no cover
                 continue

waldiez/models/flow/flow.py

@@ -397,7 +397,7 @@ class WaldiezFlow(WaldiezBase):
             If no group manager is found.
         """
         for agent in self.data.agents.groupManagerAgents:
-            if agent.data.parent_id is None:
+            if agent.data.parent_id is None:  # pragma: no branch
                 return agent
         raise ValueError("No group manager found.")
 
@@ -431,16 +431,16 @@ class WaldiezFlow(WaldiezBase):
         to_root_manager: WaldiezChat | None = None
         root_manager: WaldiezGroupManager = self.get_root_group_manager()
         for chat in self.data.chats:
-            if chat.target == root_manager.id:
+            if chat.target == root_manager.id:  # pragma: no branch
                 # check if the source is a user agent
                 source = self.get_agent_by_id(chat.source)
-                if source.is_user:
+                if source.is_user:  # pragma: no branch
                     user_agent = source
                     to_root_manager = chat
                     break
-        if not to_root_manager:
+        if not to_root_manager:  # pragma: no cover
             return []
-        if not user_agent:
+        if not user_agent:  # pragma: no cover
             return []
         return [
             {
@@ -572,7 +572,7 @@ class WaldiezFlow(WaldiezBase):
             - If the model IDs are not unique.
             - If the tool IDs are not unique.
         """
-        if member.is_group_manager:
+        if member.is_group_manager:  # pragma: no cover
             raise ValueError(
                 "In single agent mode, the agent must not be a group manager."
             )

waldiez/models/flow/info.py

@@ -18,6 +18,8 @@ class WaldiezAgentInfo(WaldiezBase):
 
     Attributes
     ----------
+    id : str
+        The ID of the agent.
     name : str
         The name of the agent.
     human_input_mode : WaldiezAgentHumanInputMode
@@ -27,6 +29,7 @@ class WaldiezAgentInfo(WaldiezBase):
         The type of the agent (e.g., "user", "assistant").
     """
 
+    id: Annotated[str, Field(description="ID of the agent")]
     name: Annotated[str, Field(description="Name of the agent")]
     human_input_mode: Annotated[
         WaldiezAgentHumanInputMode,
@@ -53,7 +56,7 @@ class WaldiezFlowInfo(WaldiezBase):
             description="List of chat participants with their info",
             default_factory=list[WaldiezAgentInfo],
         ),
-    ]
+    ] = []
 
     @classmethod
     def create(
@@ -77,6 +80,7 @@ class WaldiezFlowInfo(WaldiezBase):
         for agent in agents:
             participants.append(
                 WaldiezAgentInfo(
+                    id=agent.id,
                     name=agent_names.get(agent.id, agent.name),
                     human_input_mode=agent.data.human_input_mode,
                     agent_type=agent.agent_type,

waldiez/models/model/_llm.py

@@ -31,9 +31,10 @@ if TYPE_CHECKING:
     from .model import WaldiezModel
 
 
+# noinspection PyUnusedLocal
 def get_llm_requirements(
     model: "WaldiezModel",
-    ag2_version: str,
+    ag2_version: str,  # pylint: disable=unused-argument
 ) -> set[str]:
     """Get the LLM requirements for the model.
 
@@ -50,9 +51,16 @@ def get_llm_requirements(
         The set of LLM requirements for the model.
     """
     requirements: set[str] = {
+        # f"ag2[rag]=={ag2_version}",
+        "chromadb>=0.5,<2",
+        "docling>=2.15.1,<3",
+        "selenium>=4.28.1,<5",
+        "webdriver-manager==4.0.2",
         "llama-index",
         "llama-index-core",
-        f"ag2[rag]=={ag2_version}",
+        "llama-index-embeddings-huggingface",
+        "llama-index-llms-langchain",
+        "llama-index-vector-stores-chroma",
     }
     match model.data.api_type:
         case "openai":
@@ -87,7 +95,7 @@ def get_llm_requirements(
             )
         case "together":
             requirements.add("llama-index-llms-together")
-        case "other":
+        case "other":  # pragma: no cover
             # openai compatible LLMs
             requirements.add("llama-index-llms-openai-like")
 
@@ -147,6 +155,7 @@ def get_llm_imports(model: "WaldiezModel") -> set[str]:
         case "other":
             return {"from llama_index.llms.openai_like import OpenAILike"}
         case _:  # pragma: no cover
+            # noinspection PyUnreachableCode
             raise ValueError(f"Unsupported API type: {model.data.api_type}")
 
 
@@ -194,6 +203,7 @@ def get_llm_arg(model: "WaldiezModel") -> tuple[str, str]:
         case "other":
             return do_other_llm(model)
         case _:  # pragma: no cover
+            # noinspection PyUnreachableCode
             raise ValueError(f"Unsupported API type: {model.data.api_type}")
 
 
@@ -279,9 +289,9 @@ def do_azure_llm(model: "WaldiezModel") -> tuple[str, str]:
         f'    model="{model.name}",\n'
         f"    temperature={temperature},\n"
     )
-    if model.data.base_url:
+    if model.data.base_url:  # pragma: no branch
         arg += f'    azure_endpoint="{model.data.base_url}",\n'
-    if model.data.api_version:
+    if model.data.api_version:  # pragma: no branch
         arg += f'    api_version="{model.data.api_version}",\n'
     arg += ")"
     before = ""
@@ -322,11 +332,11 @@ def do_bedrock_llm(model: "WaldiezModel") -> tuple[str, str]:
         aws_access_key_id = model.data.aws.access_key or ""
         aws_region = model.data.aws.region or ""
     arg = f'BedrockConverse(\n    model="{model.name}",\n'
-    if profile_name:
+    if profile_name:  # pragma: no branch
         arg += f'    profile_name="{profile_name}",\n'
-    if aws_access_key_id:
+    if aws_access_key_id:  # pragma: no branch
         arg += f'    aws_access_key_id="{aws_access_key_id}",\n'
-    if aws_region:
+    if aws_region:  # pragma: no branch
         arg += f'    region_name="{aws_region}",\n'
     arg += ")"
     before = ""
@@ -347,11 +357,11 @@ def do_cohere_llm(model: "WaldiezModel") -> tuple[str, str]:
         A tuple containing the LLM argument string and any content before it.
     """
     arg = f'Cohere(\n    model="{model.name}",\n'
-    if model.data.api_key:
+    if model.data.api_key:  # pragma: no branch
         arg += f'    api_key="{model.data.api_key}",\n'
-    if model.data.base_url:
+    if model.data.base_url:  # pragma: no branch
         arg += f'    base_url="{model.data.base_url}",\n'
-    if model.data.temperature is not None:
+    if model.data.temperature is not None:  # pragma: no branch
         arg += f"    temperature={model.data.temperature},\n"
     arg += ")"
     before = ""
@@ -507,11 +517,18 @@ def do_other_llm(model: "WaldiezModel") -> tuple[str, str]:
         f'    model="{model.name}",\n'
         f'    api_base="{model.data.base_url}",\n'
     )
-    if not model.data.api_key:
+    if not model.data.api_key:  # pragma: no cover
         arg += '    api_key="na",\n'
-    if model.data.extras:
+    else:
+        arg += f'    api_key="{model.data.api_key}",\n'
+    if model.data.temperature is not None:  # pragma: no branch
+        arg += f"    temperature={model.data.temperature},\n"
+    if model.data.extras:  # pragma: no branch
         for key, value in model.data.extras.items():
-            arg += f'    {key}="{value}",\n'
+            if isinstance(value, str):
+                arg += f'    {key}="{value}",\n'
+            else:
+                arg += f"    {key}={value},\n"
     arg += ")"
     # if model.data.price:
     before = ""

waldiez/models/model/model.py

@@ -213,7 +213,7 @@ class WaldiezModel(WaldiezBase):
         optionals: list[tuple[str, type]] = [
             ("base_url", str),
             ("max_tokens", int),
-            # ("temperature", float),
+            ("temperature", float),
             ("top_p", float),
             ("api_version", str),
             ("default_headers", dict),
@@ -229,6 +229,9 @@ class WaldiezModel(WaldiezBase):
             value = getattr(self, attr)
             if value:
                 _llm_config[attr] = value
+        if "top_p" in _llm_config and "temperature" in _llm_config:
+            # only keep one
+            _llm_config.pop("top_p", None)
         if self.data.api_type == "bedrock":
             _llm_config.pop("base_url", None)
             return set_bedrock_aws_config(_llm_config, self.data.aws)

waldiez/models/model/model_data.py

@@ -3,12 +3,12 @@
 # flake8: noqa: E501
 """Waldiez Model Data."""
 
-from typing import Optional
+from typing import Any, Optional
 
-from pydantic import Field
-from typing_extensions import Annotated, Literal
+from pydantic import Field, model_validator
+from typing_extensions import Annotated, Literal, Self
 
-from ..common import WaldiezBase
+from ..common import WaldiezBase, update_dict
 from ._aws import WaldiezModelAWS
 from ._price import WaldiezModelPrice
 
@@ -131,7 +131,7 @@ class WaldiezModelData(WaldiezBase):
         ),
     ] = None
     extras: Annotated[
-        dict[str, str],
+        dict[str, Any],
         Field(
             alias="extras",
             default_factory=dict,
@@ -154,3 +154,16 @@ class WaldiezModelData(WaldiezBase):
             default=None, title="Price", description="The price of the model"
         ),
     ] = None
+
+    @model_validator(mode="after")
+    def validate_model_data(self) -> Self:
+        """Validate model data.
+
+        Returns
+        -------
+        WaldiezModelData
+            The validated model data.
+        """
+        if self.extras:
+            self.extras = update_dict(self.extras)
+        return self

waldiez/models/tool/predefined/_config.py

@@ -3,6 +3,7 @@
 """Predefined tool configuration for Waldiez."""
 
 from dataclasses import dataclass
+from typing import Any
 
 from .protocol import PredefinedTool
 
@@ -52,6 +53,7 @@ class PredefinedToolConfig:
     def get_content(
         self,
         secrets: dict[str, str],
+        runtime_kwargs: dict[str, Any] | None = None,
     ) -> str:
         """Get the content of the tool.
 
@@ -59,10 +61,12 @@ class PredefinedToolConfig:
         ----------
         secrets : dict[str, str]
             Dictionary of secrets/environment variables.
+        runtime_kwargs : dict[str, Any] | None, optional
+            Runtime keyword arguments to customize the content generation.
 
         Returns
         -------
         str
             Content of the tool.
         """
-        return self.implementation.get_content(secrets)
+        return self.implementation.get_content(secrets, runtime_kwargs)

waldiez/models/tool/predefined/_duckduckgo.py

@@ -81,6 +81,7 @@ class DuckDuckGoSearchToolImpl(PredefinedTool):
     def get_content(
         self,
         secrets: dict[str, str],
+        runtime_kwargs: dict[str, Any] | None = None,
     ) -> str:
         """Get content for the tool.
 
@@ -89,6 +90,9 @@ class DuckDuckGoSearchToolImpl(PredefinedTool):
         secrets : dict[str, str]
             Dictionary of secrets/environment variables.
 
+        runtime_kwargs : dict[str, Any] | None, optional
+            Runtime keyword arguments to customize the content generation.
+
         Returns
         -------
         str