autobyteus 1.0.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

autobyteus/tools/timer.py

@@ -1,121 +1,169 @@
 import asyncio
-from typing import Optional
+from typing import Optional, TYPE_CHECKING, Any
 from autobyteus.tools.base_tool import BaseTool
-from autobyteus.events.event_emitter import EventEmitter
+from autobyteus.tools.tool_config import ToolConfig 
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.events.event_emitter import EventEmitter 
 from autobyteus.events.event_types import EventType
+import logging 
 
-class Timer(BaseTool, EventEmitter):
-    """
-    A tool that provides timer functionality with configurable duration and event emission.
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext 
 
-    This class inherits from BaseTool and EventEmitter. It allows setting a timer duration,
-    starting the timer, and emits events with the remaining time at configurable intervals.
-    The timer runs independently after being started.
+logger = logging.getLogger(__name__)
 
-    Attributes:
-        duration (int): The duration of the timer in seconds.
-        interval (int): The interval at which to emit timer events, in seconds.
-        _is_running (bool): Flag to indicate if the timer is currently running.
-        _task (Optional[asyncio.Task]): The asyncio task for the running timer.
+class Timer(BaseTool, EventEmitter): 
+    """
+    A tool that provides timer functionality with configurable duration and event emission.
+    The timer runs independently after being started and emits TIMER_UPDATE events.
     """
 
-    def __init__(self):
-        """
-        Initialize the Timer.
-        """
-        BaseTool.__init__(self)
-        EventEmitter.__init__(self)
-        self.duration: int = 0
-        self.interval: int = 60  # Default to 60 seconds if not specified
+    def __init__(self, config: Optional[ToolConfig] = None):
+        BaseTool.__init__(self, config=config)
+        EventEmitter.__init__(self) 
+        
+        self.duration: int = 300  
+        self.interval: int = 60   
+        
+        if config:
+            try:
+                self.duration = int(config.get('duration', 300))
+                if not (1 <= self.duration <= 86400): 
+                    logger.warning(f"Timer duration {self.duration} out of bounds (1-86400). Clamping or using default.")
+                    self.duration = max(1, min(self.duration, 86400)) 
+            except ValueError:
+                logger.warning(f"Invalid duration value in config, using default {self.duration}s.")
+            
+            try:
+                self.interval = int(config.get('interval', 60))
+                if not (1 <= self.interval <= 3600): 
+                    logger.warning(f"Timer interval {self.interval} out of bounds (1-3600). Clamping or using default.")
+                    self.interval = max(1, min(self.interval, 3600)) 
+            except ValueError:
+                 logger.warning(f"Invalid interval value in config, using default {self.interval}s.")
+
         self._is_running: bool = False
         self._task: Optional[asyncio.Task] = None
+        logger.debug(f"Timer initialized with duration: {self.duration}s, interval: {self.interval}s")
 
     @classmethod
-    def tool_usage_xml(cls):
-        """
-        Return an XML string describing the usage of the Timer tool.
-
-        Returns:
-            str: An XML description of how to use the Timer tool.
-        """
-        return '''Timer: Sets and runs a timer, emitting events with remaining time. Usage:
-    <command name="Timer">
-        <arg name="duration">300</arg>
-        <arg name="interval" optional="true">60</arg>
-    </command>
-    where duration and interval are in seconds. interval is optional and defaults to 60 seconds.
-    '''
-
-    def set_duration(self, duration: int):
-        """
-        Set the duration of the timer.
-
-        Args:
-            duration (int): The duration of the timer in seconds.
-        """
-        self.duration = duration
+    def get_description(cls) -> str:
+        return "Sets and runs a timer. Emits TIMER_UPDATE events with remaining time at specified intervals."
 
-    def set_interval(self, interval: int):
-        """
-        Set the interval for emitting timer events.
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        schema = ParameterSchema()
+        schema.add_parameter(ParameterDefinition(
+            name="duration",
+            param_type=ParameterType.INTEGER,
+            description="Duration to set for this timer run in seconds.",
+            required=True, 
+            min_value=1,
+            max_value=86400
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="interval",
+            param_type=ParameterType.INTEGER,
+            description="Interval for emitting timer events in seconds for this run. Overrides instance default.",
+            required=False, 
+            default_value=None, 
+            min_value=1,
+            max_value=3600
+        ))
+        return schema
 
-        Args:
-            interval (int): The interval at which to emit timer events, in seconds.
-        """
-        self.interval = interval
+    @classmethod
+    def get_config_schema(cls) -> Optional[ParameterSchema]: 
+        schema = ParameterSchema()
+        schema.add_parameter(ParameterDefinition(
+            name="duration",
+            param_type=ParameterType.INTEGER,
+            description="Default duration of the timer in seconds if not overridden by execute.",
+            required=False,
+            default_value=300,
+            min_value=1,
+            max_value=86400 
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="interval",
+            param_type=ParameterType.INTEGER,
+            description="Default interval at which to emit timer events, in seconds, if not overridden by execute.",
+            required=False,
+            default_value=60,
+            min_value=1,
+            max_value=3600
+        ))
+        return schema
+
+    def set_duration(self, duration: int) -> None: 
+        if not (1 <= duration <= 86400):
+            raise ValueError("Duration must be between 1 and 86400 seconds.")
+        self.duration = duration
 
-    def start(self):
-        """
-        Start the timer if it's not already running.
+    def set_interval(self, interval: int) -> None: 
+        if not (1 <= interval <= 3600):
+            raise ValueError("Interval must be between 1 and 3600 seconds.")
+        self.interval = interval
 
-        Raises:
-            RuntimeError: If the timer is already running or if no duration has been set.
-        """
+    def start(self, run_duration: Optional[int] = None, run_interval: Optional[int] = None) -> None: 
         if self._is_running:
-            raise RuntimeError("Timer is already running")
-        if self.duration <= 0:
-            raise RuntimeError("Timer duration must be set before starting")
-        self._is_running = True
-        self._task = asyncio.create_task(self._run_timer())
-
-    async def _run_timer(self):
-        """
-        Run the timer, emitting events at the specified interval.
-        """
-        remaining_time = self.duration
-        while remaining_time > 0:
-            self.emit(EventType.TIMER_UPDATE, remaining_time=remaining_time)
-            await asyncio.sleep(min(self.interval, remaining_time))
-            remaining_time -= self.interval
-        self.emit(EventType.TIMER_UPDATE, remaining_time=0)
-        self._is_running = False
-
-    async def _execute(self, **kwargs):
-        """
-        Execute the timer.
-
-        This method sets the duration and interval if provided, and starts the timer.
-        It returns immediately after starting the timer, allowing the timer to run independently.
-
-        Args:
-            **kwargs: Keyword arguments. Expected arguments:
-                - duration (int): The duration to set for the timer in seconds.
-                - interval (int, optional): The interval at which to emit timer events, in seconds.
-                  Defaults to 60 seconds if not provided.
-
-        Returns:
-            str: A message indicating the timer has started.
-
-        Raises:
-            ValueError: If the duration is not provided.
-        """
-        duration = kwargs.get('duration')
-        if duration is None:
-            raise ValueError("Timer duration must be provided")
-        self.set_duration(duration)
+            logger.warning("Timer start called but timer is already running.")
+            return
+
+        current_duration = run_duration if run_duration is not None else self.duration
+        current_interval = run_interval if run_interval is not None else self.interval
         
-        interval = kwargs.get('interval', 60)
-        self.set_interval(interval)
+        if current_duration <= 0:
+            raise RuntimeError("Timer duration must be positive and set before starting.")
+        if current_interval <=0:
+            raise RuntimeError("Timer interval must be positive and set.")
 
-        self.start()
-        return f"Timer started for {self.duration} seconds, emitting events every {self.interval} seconds"
+        self._is_running = True
+        self._task = asyncio.create_task(self._run_timer_task(current_duration, current_interval))
+        logger.info(f"Timer started for {current_duration}s, events every {current_interval}s.")
+
+    async def _run_timer_task(self, duration: int, interval: int) -> None: 
+        remaining_time = duration
+        try:
+            while remaining_time > 0:
+                self.emit(EventType.TIMER_UPDATE, remaining_time=remaining_time)
+                await asyncio.sleep(min(interval, remaining_time))
+                remaining_time -= interval
+            self.emit(EventType.TIMER_UPDATE, remaining_time=0) 
+        except asyncio.CancelledError:
+            logger.info("Timer task was cancelled.")
+            self.emit(EventType.TIMER_UPDATE, remaining_time=-1, status="cancelled") 
+            raise 
+        finally:
+            self._is_running = False
+            logger.info("Timer task finished.")
+
+    async def _execute(self, context: 'AgentContext', duration: int, interval: Optional[int] = None) -> str: 
+        logger.debug(f"Timer execute called by agent {context.agent_id} with duration: {duration}, interval: {interval}")
+        
+        effective_interval = interval if interval is not None else self.interval
+
+        if self._task and not self._task.done():
+            logger.info("Cancelling previous timer task before starting a new one.")
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                logger.debug("Previous timer task successfully cancelled.")
+            self._task = None 
+
+        self.start(run_duration=duration, run_interval=effective_interval) 
+        return f"Timer started for {duration} seconds, emitting events every {effective_interval} seconds."
+
+    async def stop(self) -> None: 
+        if self._task and not self._task.done():
+            logger.info("Stopping timer task...")
+            self._task.cancel()
+            try:
+                await self._task 
+            except asyncio.CancelledError:
+                logger.info("Timer task stopped successfully.")
+            self._task = None
+            self._is_running = False 
+        else:
+            logger.info("Stop called, but no timer task is running or task already done.")

autobyteus/tools/tool_config.py

@@ -0,0 +1,117 @@
+# file: autobyteus/autobyteus/tools/tool_config.py
+import logging
+from typing import Dict, Any
+from dataclasses import dataclass, field
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ToolConfig:
+    """
+    Configuration class for tools - a simple dictionary wrapper.
+    Tools define their own default configurations internally and use this
+    class to receive configuration overrides.
+    """
+    params: Dict[str, Any] = field(default_factory=dict)
+    
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if not isinstance(self.params, dict):
+            raise TypeError("params must be a dictionary")
+        
+        logger.debug(f"ToolConfig initialized with params keys: {list(self.params.keys())}")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the ToolConfig to a dictionary representation.
+        
+        Returns:
+            Dict[str, Any]: Dictionary representation of the configuration.
+        """
+        return self.params.copy()
+
+    @classmethod
+    def from_dict(cls, config_data: Dict[str, Any]) -> 'ToolConfig':
+        """
+        Create a ToolConfig instance from a dictionary.
+        
+        Args:
+            config_data: Dictionary containing configuration parameters.
+            
+        Returns:
+            ToolConfig: New ToolConfig instance.
+        """
+        if not isinstance(config_data, dict):
+            raise TypeError("config_data must be a dictionary")
+        
+        return cls(params=config_data.copy())
+
+    def merge(self, other: 'ToolConfig') -> 'ToolConfig':
+        """
+        Merge this ToolConfig with another, with the other taking precedence.
+        
+        Args:
+            other: ToolConfig to merge with this one.
+            
+        Returns:
+            ToolConfig: New merged ToolConfig instance.
+        """
+        if not isinstance(other, ToolConfig):
+            raise TypeError("Can only merge with another ToolConfig instance")
+        
+        merged_params = self.params.copy()
+        merged_params.update(other.params)
+        
+        return ToolConfig(params=merged_params)
+
+    def get_constructor_kwargs(self) -> Dict[str, Any]:
+        """
+        Get keyword arguments suitable for tool constructor calls.
+        
+        Returns:
+            Dict[str, Any]: Dictionary of constructor arguments.
+        """
+        return self.params.copy()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get a configuration parameter.
+        
+        Args:
+            key: The parameter key.
+            default: Default value if key doesn't exist.
+            
+        Returns:
+            The parameter value or default.
+        """
+        return self.params.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """
+        Set a configuration parameter.
+        
+        Args:
+            key: The parameter key.
+            value: The parameter value.
+        """
+        self.params[key] = value
+
+    def update(self, params: Dict[str, Any]) -> None:
+        """
+        Update multiple configuration parameters.
+        
+        Args:
+            params: Dictionary of parameters to update.
+        """
+        if not isinstance(params, dict):
+            raise TypeError("params must be a dictionary")
+        self.params.update(params)
+
+    def __repr__(self) -> str:
+        return f"ToolConfig(params={self.params})"
+
+    def __len__(self) -> int:
+        return len(self.params)
+
+    def __bool__(self) -> bool:
+        return bool(self.params)

autobyteus/tools/tool_meta.py

@@ -1,52 +1,74 @@
-# file: autobyteus/tools/tool_meta.py
+# file: autobyteus/autobyteus/tools/tool_meta.py
 import logging
 from abc import ABCMeta
+from typing import Dict, Any 
 
-# Import the global registry and definition class from the registry package
 from autobyteus.tools.registry import default_tool_registry, ToolDefinition
+from autobyteus.tools.parameter_schema import ParameterSchema
 
-logger = logging.getLogger(__name__) # Using __name__ for specific logger
+logger = logging.getLogger(__name__)
 
 class ToolMeta(ABCMeta):
     """
-    Metaclass for BaseTool that automatically registers concrete tool subclasses
-    with the default_tool_registry using their static name and usage description
-    obtained from class method `tool_usage()`.
+    Metaclass for BaseTool that automatically registers concrete tool subclasses.
     """
     def __init__(cls, name, bases, dct):
-        """
-        Called when a class using this metaclass is defined.
-        """
         super().__init__(name, bases, dct)
 
-        # Prevent registration of the BaseTool class itself or other explicitly abstract classes
-        if name == 'BaseTool' or getattr(cls, "__abstractmethods__", None):
-             logger.debug(f"Skipping registration for abstract class: {name}")
+        # Skip registration for special classes that are not meant to be standalone tools.
+        # FunctionalTool is an explicit wrapper but shouldn't be registered itself.
+        if name in ['BaseTool', 'GenericMcpTool', 'FunctionalTool'] or getattr(cls, "__abstractmethods__", None):
+             logger.debug(f"Skipping registration for abstract or special tool class: {name}")
              return
 
         try:
-            # Get static/class info from the class being defined
+            # Use the class itself to get the metadata, not an instance.
             tool_name = cls.get_name()
-
-            usage_description = cls.tool_usage()
-
-            # Basic validation of fetched static info
             if not tool_name or not isinstance(tool_name, str):
                 logger.error(f"Tool class {name} must return a valid string from static get_name(). Skipping registration.")
                 return
-            if not usage_description or not isinstance(usage_description, str):
-                 # Updated error message to reflect source method
-                 logger.error(f"Tool class {name} must return a valid string from class method tool_usage(). Skipping registration.")
+
+            general_description = cls.get_description()
+            if not general_description or not isinstance(general_description, str):
+                 logger.error(f"Tool class {name} ({tool_name}) must return a valid string from get_description(). Skipping registration.")
                  return
 
-            # Create definition using name and the usage description from tool_usage()
-            definition = ToolDefinition(name=tool_name, description=usage_description)
+            argument_schema: ParameterSchema = None 
+            try:
+                argument_schema = cls.get_argument_schema() 
+                if argument_schema is not None and not isinstance(argument_schema, ParameterSchema): 
+                    logger.error(f"Tool class {name} ({tool_name}) get_argument_schema() must return a ParameterSchema or None. Got {type(argument_schema)}. Skipping registration.")
+                    return
+            except Exception as e:
+                logger.error(f"Tool class {name} ({tool_name}) failed to provide argument_schema via get_argument_schema(): {e}. Skipping registration.", exc_info=True)
+                return
+            
+            instantiation_config_schema: ParameterSchema = None 
+            if hasattr(cls, 'get_config_schema'):
+                try:
+                    instantiation_config_schema = cls.get_config_schema()
+                    if instantiation_config_schema is not None and not isinstance(instantiation_config_schema, ParameterSchema): 
+                        logger.warning(f"Tool class {name} ({tool_name}) get_config_schema() returned non-ParameterSchema type: {type(instantiation_config_schema)}. Treating as no config schema.")
+                        instantiation_config_schema = None
+                except Exception as e:
+                    logger.warning(f"Tool class {name} ({tool_name}) has get_config_schema() but it failed: {e}. Assuming no instantiation config.")
+            
+            # Create the definition without pre-generating usage strings
+            definition = ToolDefinition(
+                name=tool_name, 
+                description=general_description, 
+                tool_class=cls,
+                custom_factory=None,
+                argument_schema=argument_schema,
+                config_schema=instantiation_config_schema 
+            )
             default_tool_registry.register_tool(definition)
-            logger.info(f"Auto-registered tool: '{tool_name}' from class {name}")
+            
+            arg_schema_info = f"args: {len(argument_schema) if argument_schema else '0'}"
+            config_info = f"inst_config: {len(instantiation_config_schema) if instantiation_config_schema else '0'}"
+            logger.info(f"Auto-registered tool: '{tool_name}' from class {name} ({arg_schema_info}, {config_info})")
 
         except AttributeError as e:
-             # Catch if required methods are missing (get_name or tool_usage/tool_usage_xml)
-             logger.error(f"Tool class {name} is missing required static/class method ({e}). Skipping registration.")
+             logger.error(f"Tool class {name} is missing a required method ({e}). Skipping registration.")
         except Exception as e:
             logger.error(f"Failed to auto-register tool class {name}: {e}", exc_info=True)
-

autobyteus/tools/usage/__init__.py

@@ -0,0 +1,6 @@
+# file: autobyteus/autobyteus/tools/usage/__init__.py
+"""
+This package contains the framework for generating provider-specific
+tool usage information (schemas and examples) and for parsing
+tool usage from LLM responses.
+"""

autobyteus/tools/usage/formatters/__init__.py

@@ -0,0 +1,31 @@
+# file: autobyteus/autobyteus/tools/usage/formatters/__init__.py
+"""
+This package contains concrete formatter classes that translate a BaseTool's
+metadata into a specific provider's format (e.g., OpenAI JSON, Anthropic JSON, XML).
+"""
+from .base_formatter import BaseSchemaFormatter, BaseExampleFormatter
+from .default_xml_schema_formatter import DefaultXmlSchemaFormatter
+from .default_json_schema_formatter import DefaultJsonSchemaFormatter
+from .openai_json_schema_formatter import OpenAiJsonSchemaFormatter
+from .anthropic_json_schema_formatter import AnthropicJsonSchemaFormatter
+from .gemini_json_schema_formatter import GeminiJsonSchemaFormatter
+from .default_xml_example_formatter import DefaultXmlExampleFormatter
+from .default_json_example_formatter import DefaultJsonExampleFormatter
+from .openai_json_example_formatter import OpenAiJsonExampleFormatter
+from .anthropic_json_example_formatter import AnthropicJsonExampleFormatter
+from .gemini_json_example_formatter import GeminiJsonExampleFormatter
+
+__all__ = [
+    "BaseSchemaFormatter",
+    "BaseExampleFormatter",
+    "DefaultXmlSchemaFormatter",
+    "DefaultJsonSchemaFormatter",
+    "OpenAiJsonSchemaFormatter",
+    "AnthropicJsonSchemaFormatter",
+    "GeminiJsonSchemaFormatter",
+    "DefaultXmlExampleFormatter",
+    "DefaultJsonExampleFormatter",
+    "OpenAiJsonExampleFormatter",
+    "AnthropicJsonExampleFormatter",
+    "GeminiJsonExampleFormatter",
+]

autobyteus/tools/usage/formatters/anthropic_json_example_formatter.py

@@ -0,0 +1,18 @@
+# file: autobyteus/autobyteus/tools/usage/formatters/anthropic_json_example_formatter.py
+from typing import TYPE_CHECKING
+
+from .base_formatter import BaseExampleFormatter
+from .default_xml_example_formatter import DefaultXmlExampleFormatter
+
+if TYPE_CHECKING:
+    from autobyteus.tools.registry import ToolDefinition
+
+class AnthropicJsonExampleFormatter(BaseExampleFormatter):
+    """
+    Formats a tool usage example for Anthropic models. Since Anthropic uses XML
+    for tool calls, this formatter returns a string representing the XML call.
+    """
+    def provide(self, tool_definition: 'ToolDefinition') -> str:
+        # Anthropic expects XML tool call examples.
+        # We use the XML formatter's logic directly.
+        return DefaultXmlExampleFormatter().provide(tool_definition)

autobyteus/tools/usage/formatters/anthropic_json_schema_formatter.py

@@ -0,0 +1,25 @@
+# file: autobyteus/autobyteus/tools/usage/formatters/anthropic_json_schema_formatter.py
+from typing import Dict, TYPE_CHECKING
+
+from .base_formatter import BaseSchemaFormatter
+
+if TYPE_CHECKING:
+    from autobyteus.tools.registry import ToolDefinition
+
+class AnthropicJsonSchemaFormatter(BaseSchemaFormatter):
+    """Formats a tool's schema into the Anthropic JSON format."""
+
+    def provide(self, tool_definition: 'ToolDefinition') -> Dict:
+        name = tool_definition.name
+        description = tool_definition.description
+        arg_schema = tool_definition.argument_schema
+
+        input_schema = arg_schema.to_json_schema_dict() if arg_schema else {
+            "type": "object", "properties": {}, "required": []
+        }
+
+        return {
+            "name": name,
+            "description": description,
+            "input_schema": input_schema,
+        }

autobyteus/tools/usage/formatters/base_formatter.py

@@ -0,0 +1,42 @@
+# file: autobyteus/autobyteus/tools/usage/formatters/base_formatter.py
+from abc import ABC, abstractmethod
+from typing import Union, Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.tools.registry import ToolDefinition
+
+class BaseSchemaFormatter(ABC):
+    """
+    Abstract base class for formatting the schema of a single tool
+    into a provider-specific format.
+    """
+    @abstractmethod
+    def provide(self, tool_definition: 'ToolDefinition') -> Union[str, Dict]:
+        """
+        Formats the schema of the given tool definition.
+
+        Args:
+            tool_definition: The tool definition to format.
+
+        Returns:
+            An XML string or a dictionary representing the tool's schema.
+        """
+        pass
+
+class BaseExampleFormatter(ABC):
+    """
+    Abstract base class for formatting a usage example of a single tool
+    into a provider-specific format.
+    """
+    @abstractmethod
+    def provide(self, tool_definition: 'ToolDefinition') -> Union[str, Dict]:
+        """
+        Formats a usage example for the given tool definition.
+
+        Args:
+            tool_definition: The tool definition to format an example for.
+
+        Returns:
+            An XML string or a dictionary representing a tool usage example.
+        """
+        pass

autobyteus/tools/usage/formatters/default_json_example_formatter.py

@@ -0,0 +1,42 @@
+# file: autobyteus/autobyteus/tools/usage/formatters/default_json_example_formatter.py
+from typing import Dict, Any, TYPE_CHECKING
+
+from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
+from .base_formatter import BaseExampleFormatter
+
+if TYPE_CHECKING:
+    from autobyteus.tools.registry import ToolDefinition
+
+class DefaultJsonExampleFormatter(BaseExampleFormatter):
+    """
+    Formats a tool usage example into a generic JSON format, inspired by
+    the default XML format.
+    """
+
+    def provide(self, tool_definition: 'ToolDefinition') -> Dict:
+        tool_name = tool_definition.name
+        arg_schema = tool_definition.argument_schema
+        arguments = {}
+
+        if arg_schema and arg_schema.parameters:
+            for param_def in arg_schema.parameters:
+                if param_def.required or param_def.default_value is not None:
+                    arguments[param_def.name] = self._generate_placeholder_value(param_def)
+
+        return {
+            "tool": {
+                "function": tool_name,
+                "parameters": arguments,
+            },
+        }
+
+    def _generate_placeholder_value(self, param_def: ParameterDefinition) -> Any:
+        if param_def.default_value is not None: return param_def.default_value
+        if param_def.param_type == ParameterType.STRING: return f"example_{param_def.name}"
+        if param_def.param_type == ParameterType.INTEGER: return 123
+        if param_def.param_type == ParameterType.FLOAT: return 123.45
+        if param_def.param_type == ParameterType.BOOLEAN: return True
+        if param_def.param_type == ParameterType.ENUM: return param_def.enum_values[0] if param_def.enum_values else "enum_val"
+        if param_def.param_type == ParameterType.OBJECT: return {"key": "value"}
+        if param_def.param_type == ParameterType.ARRAY: return ["item1", "item2"]
+        return "placeholder"