Echo back the input message.

This is a simple example tool that demonstrates basic MCP tool functionality.
It will be automatically decorated with SAAGA decorators for exception handling
and logging.

Args:
    message: The message to echo back
    
Returns:
    The echoed message with a prefix

Get the current time.

Returns the current time in a human-readable format.

Returns:
    Current time as a string

Generate a random number within a specified range.

Args:
    min_value: Minimum value (default: 1)
    max_value: Maximum value (default: 100)
    
Returns:
    Dictionary containing the random number and range info

Calculate the nth Fibonacci number.

This is a more computationally intensive example that demonstrates
how tools can handle more complex operations.

Args:
    n: The position in the Fibonacci sequence (must be >= 0)
    
Returns:
    Dictionary containing the Fibonacci number and calculation info

Parallelized version of process_batch_data.

This function accepts a list of keyword argument dictionaries and executes process_batch_data concurrently for each set of arguments.

Original function signature: process_batch_data(items: List, operation: str)

Args: kwargs_list (List[Dict[str, Any]]): A list of dictionaries, where each dictionary provides the keyword arguments for a single call to process_batch_data.

Returns: List[Any]: A list containing the results of each call to process_batch_data, in the same order as the input kwargs_list.

Original docstring: Process a batch of data items.

This is an example of a tool that benefits from parallelization.
It will be automatically decorated with the parallelize decorator
in addition to exception handling and logging.

Args:
    items: List of strings to process
    operation: Operation to perform ('upper', 'lower', 'reverse')
    
Returns:
    Processed items with metadata

Parallelized version of simulate_heavy_computation.

This function accepts a list of keyword argument dictionaries and executes simulate_heavy_computation concurrently for each set of arguments.

Original function signature: simulate_heavy_computation(complexity: int)

Args: kwargs_list (List[Dict[str, Any]]): A list of dictionaries, where each dictionary provides the keyword arguments for a single call to simulate_heavy_computation.

Returns: List[Any]: A list containing the results of each call to simulate_heavy_computation, in the same order as the input kwargs_list.

Original docstring: Simulate a heavy computation task.

This tool demonstrates parallelization benefits by performing
a computationally intensive task that can be parallelized.

Args:
    complexity: Complexity level (1-10, higher = more computation)
    
Returns:
    Dictionary containing computation results