gllm-pipeline-binary 0.4.21__cp312-cp312-macosx_13_0_arm64.whl

gllm_pipeline/steps/branching_step.pyi

@@ -0,0 +1,24 @@
+import abc
+from _typeshed import Incomplete
+from gllm_pipeline.alias import PipelineSteps as PipelineSteps
+from gllm_pipeline.exclusions import ExclusionSet as ExclusionSet
+from gllm_pipeline.steps.composite_step import BaseCompositeStep as BaseCompositeStep
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+
+class BranchingStep(BaseCompositeStep, metaclass=abc.ABCMeta):
+    """Mixin-like base for composites that maintain named branches.
+
+    Attributes:
+        branches (dict[str, PipelineSteps]): The branches to execute in parallel.
+    """
+    branches: dict[str, PipelineSteps]
+    is_excluded: Incomplete
+    def apply_exclusions(self, exclusions: ExclusionSet) -> None:
+        """Apply exclusions to this branching step and its children.
+
+        Marks self excluded, lets subclass perform internal structural changes,
+        then propagates exclusions to children per branch.
+
+        Args:
+            exclusions (ExclusionSet): The exclusion set to apply.
+        """

gllm_pipeline/steps/component_step.pyi

@@ -0,0 +1,82 @@
+from _typeshed import Incomplete
+from gllm_core.schema import Component as Component
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_datastore.cache.cache import BaseCache as BaseCache
+from gllm_pipeline.alias import InputMapSpec as InputMapSpec, PipelineState as PipelineState
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
+from gllm_pipeline.utils.error_handling import ErrorContext as ErrorContext
+from gllm_pipeline.utils.has_inputs_mixin import HasInputsMixin as HasInputsMixin
+from gllm_pipeline.utils.input_map import shallow_dump as shallow_dump
+from langgraph.runtime import Runtime
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+class ComponentStep(BasePipelineStep, HasInputsMixin):
+    """A pipeline step that executes a specific component.
+
+    This step wraps a component, manages its inputs and outputs, and integrates it into the pipeline.
+
+    Attributes:
+        name (str): A unique identifier for this pipeline step.
+        component (Component): The component to be executed in this step.
+        input_map (dict[str, str | Val] | None): Unified input map.
+        output_state (str | list[str] | None): Key(s) to extract from the component result and add to the pipeline
+            state. If None, the component is executed but no state updates are performed.
+        retry_policy (RetryPolicy | None): Configuration for retry behavior using LangGraph's RetryPolicy.
+        error_handler (BaseStepErrorHandler | None): Strategy to handle errors during execution.
+    """
+    component: Incomplete
+    output_state: Incomplete
+    def __init__(self, name: str, component: Component, input_state_map: dict[str, str] | None = None, output_state: str | list[str] | None = None, runtime_config_map: dict[str, str] | None = None, fixed_args: dict[str, Any] | None = None, input_map: InputMapSpec | None = None, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> None:
+        '''Initializes a new ComponentStep.
+
+        Args:
+            name (str): A unique identifier for this pipeline step.
+            component (Component): The component to be executed in this step.
+            input_state_map (dict[str, str]): Mapping of component input arguments to pipeline state keys.
+                Keys are input arguments expected by the component, values are corresponding state keys.
+            output_state ((str | list[str]) | None, optional): Key(s) to extract from the component result and add to
+                the pipeline state. If None, the component is executed but no state updates are performed.
+                Defaults to None.
+            runtime_config_map (dict[str, str] | None, optional): Mapping of component input arguments to runtime
+                configuration keys.
+                Keys are input arguments expected by the component, values are runtime configuration keys.
+                Defaults to None.
+            fixed_args (dict[str, Any] | None, optional): Fixed arguments to be passed to the component.
+                Defaults to None.
+            input_map (InputMapSpec | None, optional):
+                Unified input map. Can be a dict (arg -> str|Val) or a list with elements:
+                1. str for identity mapping
+                2. dict[str, str] for state/config mapping
+                3. dict[str, Val] for fixed args.
+                Defaults to None.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior using
+                GLLM Core\'s RetryConfig. Defaults to None, in which case no retry config is applied.
+            error_handler (BaseStepErrorHandler | None, optional): Strategy to handle errors during execution.
+                Defaults to None, in which case the RaiseStepErrorHandler is used.
+            cache_store ("BaseCache" | None, optional): Cache store to be used for caching.
+                Defaults to None, in which case no cache store is used.
+            cache_config (dict[str, Any] | None, optional): Cache configuration to be used for caching.
+                Defaults to None, in which case no cache configuration is used.
+        '''
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel]) -> dict[str, Any] | None:
+        """Executes the component and processes its output.
+
+        This method validates inputs, prepares data, executes the component, and formats the output for integration
+        into the pipeline state.
+
+        Args:
+            state (PipelineState): The current state of the pipeline, containing all data.
+            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+
+        Returns:
+            dict[str, Any] | None: The update to the pipeline state after this step's operation, or None if
+                output_state is None. When not None, this includes new or modified data produced by the component,
+                not the entire state.
+
+        Raises:
+            RuntimeError: If an error occurs during component execution.
+            TimeoutError: If the component execution times out.
+            asyncio.CancelledError: If the component execution is cancelled.
+        """

gllm_pipeline/steps/composite_step.pyi

@@ -0,0 +1,65 @@
+import abc
+from abc import ABC, abstractmethod
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_datastore.cache.cache import BaseCache as BaseCache
+from gllm_pipeline.exclusions import ExclusionSet as ExclusionSet
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
+from gllm_pipeline.utils.error_handling import ErrorContext as ErrorContext
+from gllm_pipeline.utils.graph import create_edge as create_edge
+from gllm_pipeline.utils.mermaid import combine_mermaid_diagrams as combine_mermaid_diagrams, extract_step_diagrams as extract_step_diagrams
+from langgraph.graph import StateGraph as StateGraph
+from langgraph.types import RetryPolicy as RetryPolicy
+from typing import Any
+
+class BaseCompositeStep(BasePipelineStep, ABC, metaclass=abc.ABCMeta):
+    """Base class for all composite pipeline steps.
+
+    Attributes:
+        name (str): A unique identifier for the pipeline step.
+        retry_policy (RetryPolicy | None): Configuration for retry behavior using LangGraph's RetryPolicy.
+    """
+    def __init__(self, name: str, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> None:
+        '''Initialize the composite step.
+
+        Args:
+            name (str): A unique identifier for the pipeline step.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior. Defaults to None.
+            error_handler (BaseStepErrorHandler | None, optional): Strategy to handle errors during execution.
+            cache_store ("BaseCache" | None, optional): Cache store to be used for caching.
+                Defaults to None, in which case no cache store is used.
+            cache_config (dict[str, Any] | None, optional): Cache configuration to be used for caching.
+                Defaults to None, in which case no cache configuration is used.
+        '''
+    def add_to_graph(self, graph: StateGraph, previous_endpoints: list[str], retry_policy: RetryPolicy | None = None) -> list[str]:
+        """Template method: Add this composite step to the graph.
+
+        Args:
+            graph (StateGraph): The graph to add this step to.
+            previous_endpoints (list[str]): Endpoints from previous steps to connect to.
+            retry_policy (RetryPolicy | None, optional): Retry policy to use for this step and propagate to child steps.
+                If provided, takes precedence over the step's own retry policy.
+                Defaults to None, in which case the step's own retry policy is used.
+
+        Returns:
+            list[str]: Exit points after adding all child steps
+        """
+    @abstractmethod
+    def apply_exclusions(self, exclusions: ExclusionSet) -> None:
+        """Apply exclusions to this composite step and its children.
+
+        Subclasses must implement full exclusion behavior, including any
+        internal structure updates and propagation to children.
+
+        Args:
+            exclusions: The exclusion set to apply.
+
+        Raises:
+            NotImplementedError: If not implemented by subclass.
+        """
+    def get_mermaid_diagram(self) -> str:
+        """Template method: Generate complete mermaid diagram.
+
+        Returns:
+            str: Complete mermaid diagram representation.
+        """

gllm_pipeline/steps/conditional_step.pyi

@@ -0,0 +1,161 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from gllm_core.event.event_emitter import EventEmitter as EventEmitter
+from gllm_core.schema import Component
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_datastore.cache.cache import BaseCache as BaseCache
+from gllm_pipeline.alias import InputMapSpec as InputMapSpec, PipelineState as PipelineState, PipelineSteps as PipelineSteps
+from gllm_pipeline.steps.branching_step import BranchingStep as BranchingStep
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
+from gllm_pipeline.steps.terminator_step import TerminatorStep as TerminatorStep
+from gllm_pipeline.types import Val as Val
+from gllm_pipeline.utils.async_utils import execute_callable as execute_callable
+from gllm_pipeline.utils.graph import create_edge as create_edge
+from gllm_pipeline.utils.has_inputs_mixin import HasInputsMixin as HasInputsMixin
+from gllm_pipeline.utils.input_map import shallow_dump as shallow_dump
+from gllm_pipeline.utils.mermaid import MERMAID_HEADER as MERMAID_HEADER
+from gllm_pipeline.utils.step_execution import execute_sequential_steps as execute_sequential_steps
+from langgraph.graph import StateGraph as StateGraph
+from langgraph.runtime import Runtime as Runtime
+from langgraph.types import Command, RetryPolicy as RetryPolicy
+from pydantic import BaseModel as BaseModel
+from typing import Any, Callable
+
+ConditionType = Component | Callable[[dict[str, Any]], str]
+DEFAULT_BRANCH: str
+
+@dataclass
+class ConditionInputs:
+    """Container for different types of inputs used in condition evaluation.
+
+    Attributes:
+        merged (dict[str, Any]): Complete merged dictionary containing all state, config, and fixed args.
+            Used for Callable conditions.
+        mapped (dict[str, Any]): Dictionary containing only explicitly mapped inputs.
+            Used for Component conditions.
+        event_emitter (EventEmitter | None): Event emitter instance for logging.
+        has_mapped_specs (bool): Whether the mapped inputs have specs or is a literal value.
+    """
+    merged: dict[str, Any]
+    mapped: dict[str, Any]
+    event_emitter: EventEmitter | None
+    has_mapped_specs: bool
+
+class ConditionalStep(BranchingStep, HasInputsMixin):
+    '''A conditional pipeline step that conditionally executes different branches based on specified conditions.
+
+    This step evaluates one or more conditions and selects a branch to execute based on the result.
+    It provides flexibility in defining complex conditional logic within a pipeline.
+
+    A minimal usage requires defining the branches to execute based on a `condition`, which is a callable
+    that takes input from the state and returns a string identifying the branch to execute.
+
+    The condition can be a `Component` or a `Callable`. The handling of inputs differs:
+    1. If the condition is a `Component`, `input_map` is used to map the pipeline\'s
+        state and config to the component\'s inputs.
+    2. If the condition is a `Callable`, it receives a merged dictionary of the
+        pipeline\'s state and config directly. In this case, `input_map` is not used
+        to build the payload and should not be passed.
+
+    Example:
+    ```python
+    ConditionalStep(
+        name="UseCaseSelection",
+        branches={"A": step_a, DEFAULT_BRANCH: step_b},
+        condition=lambda x: "A" if "<A>" in x["query"] else "__default__"
+    )
+    ```
+    This will execute `step_a` if the query contains "<A>", and `step_b` otherwise.
+
+    The special key `__default__` (importable as DEFAULT_BRANCH) defines the default branch to execute
+    if no other condition matches. If the DEFAULT_BRANCH is not defined and no condition matches,
+    the step will raise an error.
+
+    Attributes:
+        name (str): A unique identifier for this pipeline step.
+        branches (dict[str, BasePipelineStep | list[BasePipelineStep]]): Mapping of condition results to steps.
+        condition (list[ConditionType] | None): The condition(s) to evaluate for branch selection.
+        input_map (dict[str, str | Val] | None): Unified input map.
+        output_state (str | None): Key to store the condition result in the state, if desired.
+        condition_aggregator (Callable[[list[Any]], str]): Function to aggregate multiple condition results.
+        retry_policy (RetryPolicy | None): Configuration for retry behavior using LangGraph\'s RetryPolicy.
+        error_handler (BaseStepErrorHandler | None): Strategy to handle errors during execution.
+    '''
+    branches: Incomplete
+    condition: Incomplete
+    output_state: Incomplete
+    condition_aggregator: Incomplete
+    def __init__(self, name: str, branches: dict[str, BasePipelineStep | list[BasePipelineStep]], condition: ConditionType | list[ConditionType] | None = None, input_state_map: dict[str, str] | None = None, output_state: str | None = None, condition_aggregator: Callable[[list[Any]], str] = ..., runtime_config_map: dict[str, str] | None = None, fixed_args: dict[str, Any] | None = None, input_map: InputMapSpec | None = None, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> None:
+        '''Initializes a new ConditionalStep.
+
+        Args:
+            name (str): A unique identifier for this pipeline step.
+            branches (dict[str, BasePipelineStep | list[BasePipelineStep]]): Mapping of condition results to steps to
+                execute.
+            condition (ConditionType | list[ConditionType] | None, optional): The condition(s) to evaluate for branch
+                selection. If a `Callable`, it receives the merged state and config as keyword arguments. If None,
+                the condition is evaluated from the state. Defaults to None.
+            input_state_map (dict[str, str] | None, optional): A dictionary mapping the state keys to the component\'s
+                input keys. This is only used if the condition is a `Component`. Defaults to None.
+            output_state (str | None, optional): Key to store the condition result in the state. If None, the
+                output is not saved in the state. Defaults to None.
+            condition_aggregator (Callable[[list[Any]], str], optional): Function to aggregate multiple condition
+                results. Defaults to joining results with a semicolon (";").
+            runtime_config_map (dict[str, str] | None, optional): A dictionary mapping the runtime config keys to the
+                component\'s input keys. This is only used if the condition is a
+                `Component`. Defaults to None.
+            fixed_args (dict[str, Any] | None, optional): Fixed arguments to be passed to the condition.
+                Defaults to None.
+            input_map (InputMapSpec | None, optional):
+                Unified input map. Can be a dict (arg -> str|Val) or a list with elements:
+                1. str for identity mapping
+                2. dict[str, str] for state/config mapping
+                3. dict[str, Val] for fixed args.
+                Defaults to None.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior using
+                GLLM Core\'s RetryConfig. Defaults to None, in which case no retry config is applied.
+            error_handler (BaseStepErrorHandler | None, optional): Strategy to handle errors during execution.
+                Defaults to None, in which case the RaiseStepErrorHandler is used.
+            cache_store ("BaseCache" | None, optional): Cache store to be used for caching.
+                Defaults to None, in which case no cache store is used.
+            cache_config (dict[str, Any] | None, optional): Cache configuration to be used for caching.
+                Defaults to None, in which case no cache configuration is used.
+        '''
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel]) -> Command:
+        """Executes the conditional step, determines the route, and returns a Command.
+
+        Args:
+            state (PipelineState): The current state of the pipeline.
+            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+
+        Returns:
+            Command: A LangGraph Command object with 'goto' for routing and 'update' for state changes.
+        """
+    async def execute_direct(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel]) -> dict[str, Any] | None:
+        """Execute this step directly, handling both branch selection and execution.
+
+        This method is used when the step needs to be executed directly (e.g. in parallel execution).
+        It will both select and execute the appropriate branch, unlike execute() which only handles selection.
+
+        Args:
+            state (dict[str, Any]): The current state of the pipeline.
+            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+
+        Returns:
+            dict[str, Any] | None: Updates to apply to the pipeline state, or None if no updates.
+        """
+    async def select_path(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel]) -> str:
+        """Determines the logical route key based on the evaluated condition(s).
+
+        This method prepares input data, evaluates conditions, aggregates results,
+        and determines the logical route key.
+
+        Args:
+            state (dict[str, Any]): The current state of the pipeline, containing all data.
+            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+
+        Returns:
+            str: The identifier of the selected logical route. Returns DEFAULT_BRANCH if an error occurs
+                or if the condition result doesn't match any branch key.
+        """

gllm_pipeline/steps/guard_step.pyi

@@ -0,0 +1,71 @@
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_datastore.cache.cache import BaseCache as BaseCache
+from gllm_pipeline.alias import InputMapSpec as InputMapSpec
+from gllm_pipeline.steps.conditional_step import ConditionType as ConditionType, ConditionalStep as ConditionalStep, DEFAULT_BRANCH as DEFAULT_BRANCH
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
+from gllm_pipeline.steps.terminator_step import TerminatorStep as TerminatorStep
+from typing import Any
+
+class GuardStep(ConditionalStep):
+    '''A conditional step that can terminate pipeline execution if a condition is not met.
+
+    This step evaluates a condition and either:
+    1. Continues execution through the success_branch if the condition is True
+    2. Executes the failure_branch and terminates if the condition is False
+
+    Example:
+        ```python
+        pipeline = (
+            step_a
+            | GuardStep(
+                name="auth_check",
+                condition=lambda x: x["is_authenticated"],
+                success_branch=step_b,
+                failure_branch=error_handling_step,
+            )
+            | step_c
+        )
+        ```
+
+    Attributes:
+        name (str): A unique identifier for this pipeline step.
+        condition (ConditionType): The condition to evaluate.
+        input_map (dict[str, str | Any] | None): Unified input map.
+        success_branch (BasePipelineStep | list[BasePipelineStep]): Steps to execute if condition is True.
+        failure_branch (BasePipelineStep | list[BasePipelineStep] | None): Steps to execute if condition is False.
+            If None, pipeline terminates immediately on False condition.
+        retry_policy (RetryPolicy | None): Configuration for retry behavior using LangGraph\'s RetryPolicy.
+    '''
+    def __init__(self, name: str, condition: ConditionType, success_branch: BasePipelineStep | list[BasePipelineStep], failure_branch: BasePipelineStep | list[BasePipelineStep] | None = None, input_state_map: dict[str, str] | None = None, output_state: str | None = None, runtime_config_map: dict[str, str] | None = None, fixed_args: dict[str, Any] | None = None, input_map: InputMapSpec | None = None, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> None:
+        '''Initializes a new GuardStep.
+
+        Args:
+            name (str): A unique identifier for this pipeline step.
+            condition (ConditionType): The condition to evaluate.
+            success_branch (BasePipelineStep | list[BasePipelineStep]): Steps to execute if condition is True.
+            failure_branch (BasePipelineStep | list[BasePipelineStep] | None, optional): Steps to execute if
+                condition is False. If None, pipeline terminates immediately. Defaults to None.
+            input_state_map (dict[str, str] | None, optional): Mapping of condition input arguments to
+                pipeline state keys. Defaults to None.
+            output_state (str | None, optional): Key to store the condition result in the pipeline state.
+                Defaults to None.
+            runtime_config_map (dict[str, str] | None, optional): Mapping of condition input arguments to runtime
+                configuration keys. Defaults to None.
+            fixed_args (dict[str, Any] | None, optional): Fixed arguments to be passed to the condition.
+                Defaults to None.
+            input_map (InputMapSpec | None, optional):
+                Unified input map. Can be a dict (arg -> str|Val) or a list with elements:
+                1. str for identity mapping
+                2. dict[str, str] for state/config mapping
+                3. dict[str, Val] for fixed args.
+                Defaults to None.
+            error_handler (BaseStepErrorHandler | None, optional): Strategy to handle errors during execution.
+                Defaults to None, in which case the RaiseStepErrorHandler is used.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior using
+                GLLM Core\'s RetryConfig. Defaults to None, in which case no retry config is applied.
+            cache_store ("BaseCache" | None, optional): Cache store to be used for caching.
+                Defaults to None, in which case no cache store is used.
+            cache_config (dict[str, Any] | None, optional): Cache configuration to be used for caching.
+                Defaults to None, in which case no cache configuration is used.
+        '''

gllm_pipeline/steps/log_step.pyi

@@ -0,0 +1,53 @@
+from _typeshed import Incomplete
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_datastore.cache.cache import BaseCache as BaseCache
+from gllm_pipeline.alias import PipelineState as PipelineState
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from gllm_pipeline.utils.input_map import shallow_dump as shallow_dump
+from langgraph.runtime import Runtime as Runtime
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+class LogStep(BasePipelineStep):
+    """A specialized pipeline step for logging messages.
+
+    This step uses the Messenger component to log messages during pipeline execution.
+    It supports both plain text messages and template messages with placeholders for state variables.
+
+    Attributes:
+        name (str): A unique identifier for this pipeline step.
+        messenger (Messenger): The messenger component used to format and send messages.
+        emit_kwargs (dict[str, Any]): Additional arguments to pass to the event emitter.
+        retry_policy (RetryPolicy | None): Configuration for retry behavior using LangGraph's RetryPolicy.
+    """
+    messenger: Incomplete
+    emit_kwargs: Incomplete
+    def __init__(self, name: str, message: str, is_template: bool = True, emit_kwargs: dict[str, Any] | None = None, retry_config: RetryConfig | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> None:
+        '''Initializes a new LogStep.
+
+        Args:
+            name (str): A unique identifier for this pipeline step.
+            message (str): The message to be logged, may contain placeholders enclosed in curly braces.
+            is_template (bool, optional): Whether the message contains placeholders. Defaults to True.
+            emit_kwargs (dict[str, Any] | None, optional): Additional arguments to pass to the event emitter.
+                Defaults to None.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior using
+                GLLM Core\'s RetryConfig. Defaults to None, in which case no retry config is applied.
+            cache_store ("BaseCache" | None, optional): Cache store to be used for caching.
+                Defaults to None, in which case no cache store is used.
+            cache_config (dict[str, Any] | None, optional): Cache configuration to be used for caching.
+                Defaults to None, in which case no cache configuration is used.
+        '''
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel]) -> None:
+        """Executes the log step by formatting and emitting the message.
+
+        Args:
+            state (PipelineState): The current state of the pipeline, containing all data.
+            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+
+        Returns:
+            None: This step does not modify the pipeline state.
+
+        Raises:
+            RuntimeError: If an error occurs during message emission.
+        """

gllm_pipeline/steps/map_reduce_step.pyi

@@ -0,0 +1,92 @@
+from _typeshed import Incomplete
+from gllm_core.schema import Component
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_datastore.cache.cache import BaseCache as BaseCache
+from gllm_pipeline.alias import InputMapSpec as InputMapSpec
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from gllm_pipeline.steps.step_error_handler.step_error_handler import BaseStepErrorHandler as BaseStepErrorHandler
+from gllm_pipeline.utils.async_utils import execute_callable as execute_callable
+from gllm_pipeline.utils.error_handling import ErrorContext as ErrorContext
+from gllm_pipeline.utils.has_inputs_mixin import HasInputsMixin as HasInputsMixin
+from gllm_pipeline.utils.input_map import shallow_dump as shallow_dump
+from langgraph.runtime import Runtime as Runtime
+from pydantic import BaseModel as BaseModel
+from typing import Any, Callable
+
+class MapReduceStep(BasePipelineStep, HasInputsMixin):
+    """A step that applies a mapping function to multiple inputs and reduces the results.
+
+    This step performs parallel processing of multiple input items using:
+    1. A map function that processes each input item independently. The map function receives a dictionary
+        containing the input values for the current item (derived from input_state_map, runtime_config_map,
+        and fixed_args).
+    2. A reduce function that combines all the mapped results.
+
+    Note on parallel execution:
+    1. For true parallelism, the map_func MUST be an async function or a Component.
+    2. Synchronous map functions will block the event loop and run sequentially.
+
+    Input handling:
+    1. Automatically detects which inputs are lists/sequences.
+    2. Ensures all list inputs have the same length.
+    3. Broadcasts scalar values to match list lengths.
+    4. If no list inputs, applies the map function once to the whole input.
+
+    Internally, this step uses asyncio.gather() for efficient parallel execution.
+
+    Attributes:
+        name (str): A unique identifier for this step.
+        map_func (Component | Callable[[dict[str, Any]], Any]): Function to apply to each input item.
+            Will be run in parallel if the function is an asynchronous function.
+        reduce_func (Callable[[list[Any]], Any]): Function to reduce the mapped results.
+        input_map (dict[str, str | Any] | None): Unified input map.
+        output_state (str): Key to store the reduced result in the pipeline state.
+        retry_policy (RetryPolicy | None): Configuration for retry behavior using LangGraph's RetryPolicy.
+    """
+    map_func: Incomplete
+    reduce_func: Incomplete
+    output_state: Incomplete
+    def __init__(self, name: str, output_state: str, map_func: Component | Callable[[dict[str, Any]], Any], reduce_func: Callable[[list[Any]], Any] = ..., input_state_map: dict[str, str] | None = None, runtime_config_map: dict[str, str] | None = None, fixed_args: dict[str, Any] | None = None, input_map: InputMapSpec | None = None, retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> None:
+        '''Initialize a new MapReduceStep.
+
+        Args:
+            name (str): A unique identifier for this step.
+            output_state (str): Key to store the reduced result in the pipeline state.
+            map_func (Component | Callable[[dict[str, Any]], Any]): Function to apply to each input item.
+                The map function receives a dictionary containing the input values derived from input_state_map,
+                runtime_config_map, and fixed_args.
+            reduce_func (Callable[[list[Any]], Any], optional): Function to reduce the mapped results.
+                Defaults to a function that returns the list of results as is.
+            input_state_map (dict[str, str] | None, optional): Mapping of function arguments to pipeline state keys.
+                Defaults to None.
+            runtime_config_map (dict[str, str] | None, optional): Mapping of arguments to runtime config keys.
+                Defaults to None.
+            fixed_args (dict[str, Any] | None, optional): Fixed arguments to pass to the functions. Defaults to None.
+            input_map (InputMapSpec | None, optional):
+                Unified input map. Can be a dict (arg -> str|Val) or a list with elements:
+                1. str for identity mapping
+                2. dict[str, str] for state/config mapping
+                3. dict[str, Val] for fixed args.
+                If provided, it will be used directly instead of synthesizing from maps. Defaults to None.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior using
+                GLLM Core\'s RetryConfig. Defaults to None, in which case no retry config is applied.
+            error_handler (BaseStepErrorHandler | None, optional): Strategy to handle errors during execution.
+                Defaults to None, in which case the RaiseStepErrorHandler is used.
+            cache_store ("BaseCache" | None, optional): Cache store to be used for caching.
+                Defaults to None, in which case no cache store is used.
+            cache_config (dict[str, Any] | None, optional): Cache configuration to be used for caching.
+                Defaults to None, in which case no cache configuration is used.
+        '''
+    async def execute(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel]) -> dict[str, Any]:
+        """Execute the map and reduce operations.
+
+        Args:
+            state (dict[str, Any]): The current state of the pipeline.
+            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+
+        Returns:
+            dict[str, Any]: The reduced result stored under output_state.
+
+        Raises:
+            RuntimeError: If an error occurs during execution.
+        """

gllm_pipeline/steps/no_op_step.pyi

@@ -0,0 +1,40 @@
+from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
+from langgraph.runtime import Runtime as Runtime
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+class NoOpStep(BasePipelineStep):
+    '''A step that does nothing.
+
+    This step is useful when you want to add a step that does not perform any processing.
+    For example, you can use this step to implement a toggle pattern for a certain component.
+
+    Example:
+    ```python
+    pipeline = (
+        step_a
+        | ConditionalStep(
+            name="branch",
+            branches={
+                "execute": step_b,
+                "continue": NoOpStep("no_op")
+            },
+            condition=lambda x: "execute" if x["should_execute"] else "continue"
+        )
+        | step_c
+    )
+    ```
+
+    Attributes:
+        name (str): A unique identifier for this pipeline step.
+    '''
+    async def execute(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel]) -> None:
+        """Executes this step, which does nothing.
+
+        Args:
+            state (dict[str, Any]): The current state of the pipeline.
+            runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+
+        Returns:
+            None: This step does not modify the pipeline state.
+        """