gllm-pipeline-binary 0.4.21__cp312-cp312-win_amd64.whl → 0.4.23__cp312-cp312-win_amd64.whl

gllm_pipeline/pipeline/composer/composer.pyi

@@ -154,6 +154,33 @@ class Composer:
         Returns:
             Self: The composer instance with this step appended.
         """
+    def copy(self, input_state: str | list[str], output_state: str | list[str], retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None, name: str | None = None) -> Self:
+        '''Append a copy step to copy input state(s) to output state(s).
+
+        This method creates a step that copies data from input state(s) to output state(s) without transformation.
+        The function handles different scenarios:
+        1. Single input to single output: Direct copy
+        2. Single input to multiple outputs: Broadcast the input to all outputs
+        3. Multiple inputs to single output: Pack all inputs into a list
+        4. Multiple inputs to multiple outputs: Copy each input to corresponding output (must have same length)
+
+        Args:
+            input_state (str | list[str]): Input state key(s) to copy from.
+            output_state (str | list[str]): Output state key(s) to copy to.
+            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): Error handler to use for this step.
+                Defaults to None, in which case no error handler 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.
+            name (str | None, optional): A unique identifier for this step. If None, a name will be
+                auto-generated with the prefix "copy_". Defaults to None.
+
+        Returns:
+            Self: The composer instance with this step appended.
+        '''
     def transform(self, operation: Callable[[dict[str, Any]], Any], input_map: InputMapSpec, output_state: str | list[str], retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, name: str | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None) -> Self:
         '''Append a state operator step.
 
@@ -241,12 +268,12 @@ class Composer:
     @overload
     def switch(self, condition: Component | Callable[[dict[str, Any]], str], *, input_map: InputMapSpec | None = ..., output_state: str | None = ..., retry_config: RetryConfig | None = ..., error_handler: BaseStepErrorHandler | None = ..., cache_store: BaseCache | None = ..., cache_config: dict[str, Any] | None = ..., name: str | None = ...) -> SwitchComposer: ...
     @overload
-    def switch(self, condition: Component | Callable[[dict[str, Any]], str], *, branches: dict[str, BasePipelineStep | list['BasePipelineStep']], input_map: InputMapSpec | None = ..., output_state: str | None = ..., default: BasePipelineStep | list['BasePipelineStep'] | None = ..., retry_config: RetryConfig | None = ..., error_handler: BaseStepErrorHandler | None = ..., cache_store: BaseCache | None = ..., cache_config: dict[str, Any] | None = ..., name: str | None = ...) -> Self: ...
+    def switch(self, condition: Component | Callable[[dict[str, Any]], str], *, branches: dict[str, BasePipelineStep | list[BasePipelineStep]], input_map: InputMapSpec | None = ..., output_state: str | None = ..., default: BasePipelineStep | list[BasePipelineStep] | None = ..., retry_config: RetryConfig | None = ..., error_handler: BaseStepErrorHandler | None = ..., cache_store: BaseCache | None = ..., cache_config: dict[str, Any] | None = ..., name: str | None = ...) -> Self: ...
     @overload
     def parallel(self, *, squash: bool = ..., input_map: InputMapSpec | None = ..., retry_config: RetryConfig | None = ..., error_handler: BaseStepErrorHandler | None = ..., cache_store: BaseCache | None = ..., cache_config: dict[str, Any] | None = ..., name: str | None = ...) -> ParallelComposer: ...
     @overload
-    def parallel(self, *, branches: list['PipelineSteps'] | dict[str, 'PipelineSteps'], squash: bool = ..., input_map: InputMapSpec | None = ..., retry_config: RetryConfig | None = ..., error_handler: BaseStepErrorHandler | None = ..., cache_store: BaseCache | None = ..., cache_config: dict[str, Any] | None = ..., name: str | None = ...) -> Self: ...
-    def parallel(self, *, branches: list['PipelineSteps'] | dict[str, 'PipelineSteps'] | None = None, squash: bool = True, 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, name: str | None = None) -> Self | ParallelComposer:
+    def parallel(self, *, branches: list[PipelineSteps] | dict[str, PipelineSteps], squash: bool = ..., input_map: InputMapSpec | None = ..., retry_config: RetryConfig | None = ..., error_handler: BaseStepErrorHandler | None = ..., cache_store: BaseCache | None = ..., cache_config: dict[str, Any] | None = ..., name: str | None = ...) -> Self: ...
+    def parallel(self, *, branches: list[PipelineSteps] | dict[str, PipelineSteps] | None = None, squash: bool = True, 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, name: str | None = None) -> Self | ParallelComposer:
         '''Create a parallel step (builder-style or direct-style).
 
         This method supports two usage patterns:

gllm_pipeline/pipeline/pipeline.pyi

@@ -199,14 +199,17 @@ class Pipeline:
         invalidating any built graph or compiled app. Useful for reusing a pipeline
         instance with different configurations.
         """
-    async def invoke(self, initial_state: PipelineState, config: dict[str, Any] | None = None) -> dict[str, Any]:
+    async def invoke(self, initial_state: PipelineState, config: dict[str, Any] | None = None, thread_id: str | None = None) -> dict[str, Any]:
         '''Runs the pipeline asynchronously with the given initial state and configuration.
 
         Args:
             initial_state (PipelineState): The initial state to start the pipeline with.
                 This initial state should comply with the state type of the pipeline.
             config (dict[str, Any], optional): Additional configuration for the pipeline. User-defined config should not
-                have "langraph_" prefix as it should be reserved for internal use. Defaults to None.
+                have "langgraph_" prefix as it should be reserved for internal use. Defaults to None.
+            thread_id (str | None, optional): The thread ID for this specific pipeline invocation. This will be passed
+                in the invocation_config.configurable when invoking the pipeline. Useful for checkpointing and
+                tracking related invocations. Defaults to None.
 
         Returns:
             dict[str, Any]: The final state after the pipeline execution.

gllm_pipeline/steps/__init__.pyi

@@ -1,4 +1,4 @@
-from gllm_pipeline.steps._func import bundle as bundle, guard as guard, if_else as if_else, log as log, map_reduce as map_reduce, no_op as no_op, parallel as parallel, step as step, subgraph as subgraph, switch as switch, terminate as terminate, toggle as toggle, transform as transform
+from gllm_pipeline.steps._func import bundle as bundle, copy as copy, guard as guard, if_else as if_else, log as log, map_reduce as map_reduce, no_op as no_op, parallel as parallel, step as step, subgraph as subgraph, switch as switch, terminate as terminate, toggle as toggle, transform as transform
 from gllm_pipeline.steps.component_step import ComponentStep as ComponentStep
 from gllm_pipeline.steps.conditional_step import ConditionalStep as ConditionalStep
 from gllm_pipeline.steps.guard_step import GuardStep as GuardStep
@@ -14,4 +14,4 @@ from gllm_pipeline.steps.step_error_handler.raise_step_error_handler import Rais
 from gllm_pipeline.steps.subgraph_step import SubgraphStep as SubgraphStep
 from gllm_pipeline.steps.terminator_step import TerminatorStep as TerminatorStep
 
-__all__ = ['ComponentStep', 'ConditionalStep', 'GuardStep', 'LogStep', 'MapReduceStep', 'NoOpStep', 'ParallelStep', 'StateOperatorStep', 'SubgraphStep', 'TerminatorStep', 'EmptyStepErrorHandler', 'FallbackStepErrorHandler', 'KeepStepErrorHandler', 'RaiseStepErrorHandler', 'bundle', 'guard', 'if_else', 'log', 'map_reduce', 'no_op', 'parallel', 'step', 'subgraph', 'switch', 'terminate', 'toggle', 'transform']
+__all__ = ['ComponentStep', 'ConditionalStep', 'GuardStep', 'LogStep', 'MapReduceStep', 'NoOpStep', 'ParallelStep', 'StateOperatorStep', 'SubgraphStep', 'TerminatorStep', 'EmptyStepErrorHandler', 'FallbackStepErrorHandler', 'KeepStepErrorHandler', 'RaiseStepErrorHandler', 'bundle', 'copy', 'guard', 'if_else', 'log', 'map_reduce', 'no_op', 'parallel', 'step', 'subgraph', 'switch', 'terminate', 'toggle', 'transform']

gllm_pipeline/steps/_func.pyi

@@ -23,7 +23,7 @@ def step(component: Component, input_state_map: dict[str, str] | None = None, ou
     This function creates a ComponentStep, which wraps a component and manages its inputs and outputs within the
     pipeline.
 
-    Usage example:
+    Examples:
         We can leverage the `input_map` parameter to specify both state/config keys (as strings)
         and fixed values (as any type) in a single dictionary.
         ```python
@@ -44,7 +44,7 @@ def step(component: Component, input_state_map: dict[str, str] | None = None, ou
         3. It will pass the `<fixed_value>` from the `conversation_id` argument of the Retriever.
         4. It will store the `retrieved_data` from the Retriever result in the pipeline state.
 
-    Legacy Approach (will be deprecated in v0.5, please use `input_map` instead):
+        Legacy Approach (will be deprecated in v0.5, please use `input_map` instead):
         ```python
         retriever = Retriever()
         retriever_step = step(retriever, {"query": "input_query"}, "retrieved_data")
@@ -53,7 +53,6 @@ def step(component: Component, input_state_map: dict[str, str] | None = None, ou
         1. It will pass the `input_query` from the pipeline state to the `query` argument of the Retriever.
         2. It will store the `retrieved_data` from the Retriever result in the pipeline state.
 
-
     Args:
         component (Component): The component to be executed in this step.
         input_state_map (dict[str, str] | None): Mapping of component input arguments to pipeline state keys.
@@ -75,7 +74,7 @@ def step(component: Component, input_state_map: dict[str, str] | None = None, ou
             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.
+        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.
@@ -93,15 +92,16 @@ def log(message: str, is_template: bool = True, emit_kwargs: dict[str, Any] | No
 
     The message can be a plain string or a template with placeholders for state variables.
 
-    Usage example 1 (plain message):
-    ```python
-    log_step = log("Processing document", is_template=False)
-    ```
+    Examples:
+        Plain message:
+        ```python
+        log_step = log("Processing document", is_template=False)
+        ```
 
-    Usage example 2 (template message with state variables):
-    ```python
-    log_step = log("Processing query: {query} with model: {model_name}")
-    ```
+        Template message with state variables:
+        ```python
+        log_step = log("Processing query: {query} with model: {model_name}")
+        ```
 
     Args:
         message (str): The message to be logged. May contain placeholders in curly braces for state variables.
@@ -110,7 +110,7 @@ def log(message: str, is_template: bool = True, emit_kwargs: dict[str, Any] | No
             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.
+        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.
@@ -133,7 +133,8 @@ def if_else(condition: ConditionType | Callable[[dict[str, Any]], bool], if_bran
     For boolean conditions and string conditions, True/true/TRUE maps to the if_branch
     and False/false/FALSE maps to the else_branch.
 
-    Usage example with a Callable condition:
+    Examples:
+        With a Callable condition:
         ```python
         # Using a Callable condition - receives merged state and config directly
         condition = lambda data: data["input"] > data["threshold"]
@@ -150,7 +151,7 @@ def if_else(condition: ConditionType | Callable[[dict[str, Any]], bool], if_bran
         )
 
         # or use the legacy approach via input_state_map, runtime_config_map, and fixed_args
-        Note: this approach is deprecated in v0.5. Please use input_map instead.
+        # Note: this approach is deprecated in v0.5. Please use input_map instead.
         if_else_step = if_else(
             condition,
             if_branch,
@@ -163,7 +164,7 @@ def if_else(condition: ConditionType | Callable[[dict[str, Any]], bool], if_bran
         the threshold (0), and the NegativeComponent otherwise. The result of the condition will be stored in the
         pipeline state under the key `condition_result`.
 
-    Usage example with a Component condition:
+        With a Component condition:
         ```python
         # Using a Component condition - requires input_state_map and runtime_config_map
         threshold_checker = ThresholdChecker()  # A Component that returns "true" or "false"
@@ -184,7 +185,7 @@ def if_else(condition: ConditionType | Callable[[dict[str, Any]], bool], if_bran
         )
 
         # or use the legacy approach via input_state_map, runtime_config_map, and fixed_args
-        Note: this approach is deprecated in v0.5. Please use input_map instead.
+        # Note: this approach is deprecated in v0.5. Please use input_map instead.
         if_else_step = if_else(
             threshold_checker,
             if_branch,
@@ -194,14 +195,12 @@ def if_else(condition: ConditionType | Callable[[dict[str, Any]], bool], if_bran
             runtime_config_map={"threshold": "threshold_config"},
             fixed_args={"strict_mode": True}
         )
-
         ```
         This will cause the step to execute the ThresholdChecker component with the `input` from the pipeline state
         as its `value` parameter and the `threshold_config` from runtime configuration as its `threshold` parameter.
         Based on the component\'s result ("true" or "false"), it will execute either the PositiveComponent or
         the NegativeComponent.
 
-
     Args:
         condition (ConditionType | Callable[[dict[str, Any]], bool]): The condition to evaluate.
         if_branch (BasePipelineStep | list[BasePipelineStep]): Step(s) to execute if condition is true.
@@ -225,7 +224,7 @@ def if_else(condition: ConditionType | Callable[[dict[str, Any]], bool], if_bran
             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.
+        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.
@@ -240,7 +239,8 @@ def switch(condition: ConditionType, branches: dict[str, BasePipelineStep | list
 
     This function creates a ConditionalStep that can execute one of multiple branches based on a condition.
 
-    Usage example with a Callable condition:
+    Examples:
+        With a Callable condition:
         ```python
         # Using a Callable condition - receives merged state and config directly
         def extract_command(data):
@@ -264,7 +264,7 @@ def switch(condition: ConditionType, branches: dict[str, BasePipelineStep | list
         )
 
         # or use the legacy approach via input_state_map, runtime_config_map, and fixed_args
-        Note: this approach is deprecated in v0.5. Please use input_map instead.
+        # Note: this approach is deprecated in v0.5. Please use input_map instead.
         switch_step = switch(
             extract_command,
             branches,
@@ -280,7 +280,7 @@ def switch(condition: ConditionType, branches: dict[str, BasePipelineStep | list
         as a fixed argument. The result of the condition will be stored in the pipeline state under the key
          `command_type`.
 
-    Usage example with a Component condition:
+        With a Component condition:
         ```python
         # Using a Component condition - requires input_state_map and runtime_config_map
         command_extractor = CommandExtractor()  # A Component that extracts command from query
@@ -301,7 +301,7 @@ def switch(condition: ConditionType, branches: dict[str, BasePipelineStep | list
         )
 
         # or use the legacy approach via input_state_map, runtime_config_map, and fixed_args
-        Note: this approach is deprecated in v0.5. Please use input_map instead.
+        # Note: this approach is deprecated in v0.5. Please use input_map instead.
         switch_step = switch(
             command_extractor,
             branches,
@@ -341,7 +341,7 @@ def switch(condition: ConditionType, branches: dict[str, BasePipelineStep | list
             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.
+        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.
@@ -357,7 +357,7 @@ def transform(operation: Callable[[dict[str, Any]], Any], input_states: list[str
     This function creates a StateOperatorStep that applies a transformation operation to the pipeline state.
     Note that the function `operation` should accept a dictionary of input data and return the operation result.
 
-    Usage example:
+    Examples:
         ```python
         def sort(data: dict) -> dict:
             is_reverse = data["reverse"]
@@ -399,7 +399,7 @@ def transform(operation: Callable[[dict[str, Any]], Any], input_states: list[str
             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.
+        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.
@@ -415,7 +415,7 @@ def bundle(input_states: list[str] | dict[str, str], output_state: str | list[st
     This function creates a StateOperatorStep that combines multiple keys from the pipeline state into a single output
     without modifying the data.
 
-    Usage example:
+    Examples:
         ```python
         bundle_step = bundle(["input1", "input2"], "output")
         # Produces: {"output": {"input1": state["input1"], "input2": state["input2"]}}
@@ -423,7 +423,7 @@ def bundle(input_states: list[str] | dict[str, str], output_state: str | list[st
         This will cause the step to bundle the values of `input1` and `input2` from the pipeline state into a single
         dictionary. The result will be stored in the pipeline state under the key `output`.
 
-        Usage example (with remapping):
+        With remapping:
         ```python
         # Provide a mapping of desired output field names to source state keys
         # Renames state key "user_id" to "id" in the bundled output
@@ -441,7 +441,7 @@ def bundle(input_states: list[str] | dict[str, str], output_state: str | list[st
             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.
+        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.
@@ -456,7 +456,7 @@ def guard(condition: ConditionType | Callable[[dict[str, Any]], bool], success_b
 
     This function creates a GuardStep that can terminate pipeline execution if a condition is not met.
 
-    Usage example:
+    Examples:
         ```python
         auth_check = lambda state: state["is_authenticated"]
         success_step = step(SuccessHandler(), {"input": "input"}, "output")
@@ -504,7 +504,7 @@ def guard(condition: ConditionType | Callable[[dict[str, Any]], bool], success_b
             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.
+        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.
@@ -519,7 +519,7 @@ def terminate(name: str | None = None, retry_config: RetryConfig | None = None,
 
     This function creates a TerminatorStep that explicitly terminates a branch or the entire pipeline.
 
-    Usage example:
+    Examples:
         ```python
         early_exit = terminate("early_exit")
 
@@ -537,7 +537,7 @@ def terminate(name: str | None = None, retry_config: RetryConfig | None = None,
             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.
+        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.
@@ -570,7 +570,8 @@ def toggle(condition: ConditionType | Callable[[dict[str, Any]], bool] | str, if
     4. A string key that will be looked up in the merged state data (state + runtime config + fixed args).
         The value will be evaluated for truthiness - any non-empty, non-zero, non-False value will be considered True.
 
-    Usage example with a Callable condition:
+    Examples:
+        With a Callable condition:
         ```python
         # Using a Callable condition - receives merged state and config directly
         condition = lambda data: data["feature_enabled"] and data["user_tier"] >= 2
@@ -596,7 +597,7 @@ def toggle(condition: ConditionType | Callable[[dict[str, Any]], bool] | str, if
         Otherwise, it will do nothing. The condition result will be stored in the pipeline state under the key
         `feature_status`.
 
-    Usage example with a Component condition:
+        With a Component condition:
         ```python
         # Using a Component condition - requires input_state_map and runtime_config_map
         feature_checker = FeatureChecker()  # A Component that returns "true" or "false"
@@ -641,7 +642,7 @@ def toggle(condition: ConditionType | Callable[[dict[str, Any]], bool] | str, if
             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.
+        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.
@@ -662,7 +663,7 @@ def subgraph(subgraph: Pipeline, input_state_map: dict[str, str] | None = None,
     in the parent state, it will be omitted from the subgraph input rather than causing an error. This allows
     for flexible composition of pipelines with different state schemas.
 
-    Usage example:
+    Examples:
         ```python
         from typing import TypedDict
         from gllm_pipeline.pipeline.pipeline import Pipeline
@@ -745,7 +746,7 @@ def subgraph(subgraph: Pipeline, input_state_map: dict[str, str] | None = None,
             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.
+        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.
@@ -775,8 +776,8 @@ def parallel(branches: list[PipelineSteps] | dict[str, PipelineSteps], input_sta
     This is especially useful when the state is large but branches only need specific parts of it.
     If input_states is None (default), all state keys will be passed.
 
-    Usage example:
-    1. Define branches as a list of steps or lists of steps
+    Examples:
+        Define branches as a list of steps or lists of steps:
         ```python
         parallel_step = parallel(
             branches=[
@@ -791,7 +792,7 @@ def parallel(branches: list[PipelineSteps] | dict[str, PipelineSteps], input_sta
         )
         ```
 
-        2. Define branches as a dictionary of branches
+        Define branches as a dictionary of branches:
         Other than the list format, we can also use the dictionary format for branches to
         make it easier to exclude branches.
         ```python
@@ -827,7 +828,7 @@ def parallel(branches: list[PipelineSteps] | dict[str, PipelineSteps], input_sta
             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.
+        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.
@@ -860,7 +861,8 @@ def map_reduce(output_state: str, map_func: Component | Callable[[dict[str, Any]
     1. If multiple list inputs are provided, they must be the same length.
     2. Scalar inputs are broadcasted to match list lengths.
 
-    Usage Example - Processing a list of items with an async map function:
+    Examples:
+        Processing a list of items with an async map function:
         ```python
         async def count_words(item):
             await asyncio.sleep(0.1)  # Simulate I/O operation
@@ -879,7 +881,7 @@ def map_reduce(output_state: str, map_func: Component | Callable[[dict[str, Any]
         # returns {"word_counts": 60} (total word count)
         ```
 
-    Usage Example - Broadcasting scalar values to match list length:
+        Broadcasting scalar values to match list length:
         ```python
         # Apply a common threshold to multiple values
         threshold_check = map_reduce(
@@ -895,7 +897,7 @@ def map_reduce(output_state: str, map_func: Component | Callable[[dict[str, Any]
         # returns {"above_threshold": [False, True, True]}
         ```
 
-    Usage Example - Multiple list inputs with the same length:
+        Multiple list inputs with the same length:
         ```python
         similarity_step = map_reduce(
             input_state_map={
@@ -910,7 +912,7 @@ def map_reduce(output_state: str, map_func: Component | Callable[[dict[str, Any]
         # returns {"similarity_scores": 0.75}
         ```
 
-    Usage Example - Using a Component for complex processing instead of a map function:
+        Using a Component for complex processing instead of a map function:
         ```python
         summarizer = TextSummarizer() # Subclass of Component
         summarize_step = map_reduce(
@@ -946,7 +948,7 @@ def map_reduce(output_state: str, map_func: Component | Callable[[dict[str, Any]
             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.
+        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.
@@ -956,3 +958,70 @@ def map_reduce(output_state: str, map_func: Component | Callable[[dict[str, Any]
     Returns:
         MapReduceStep: An instance of MapReduceStep configured with the provided parameters.
     '''
+def copy(input_state: str | list[str], output_state: str | list[str], retry_config: RetryConfig | None = None, error_handler: BaseStepErrorHandler | None = None, cache_store: BaseCache | None = None, cache_config: dict[str, Any] | None = None, name: str | None = None) -> StateOperatorStep:
+    '''Create a StateOperatorStep to copy input state(s) to output state(s).
+
+    This function creates a StateOperatorStep that copies data from input state(s) to output state(s)
+    without any transformation. The function handles different scenarios:
+    1. Single input to single output: Direct copy
+    2. Single input to multiple outputs: Broadcast the input to all outputs
+    3. Multiple inputs to single output: Pack all inputs into a list
+    4. Multiple inputs to multiple outputs: Copy each input to corresponding output (must have same length)
+
+    Args:
+        input_state (str | list[str]): Input state key(s) to copy from.
+        output_state (str | list[str]): Output state key(s) to copy to.
+        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.
+        name (str | None, optional): A unique identifier for this step. Defaults to None, in which case the
+            name will be "Copy" followed by a unique identifier.
+
+    Returns:
+        StateOperatorStep: An instance of StateOperatorStep configured to copy the input states to output states.
+
+    Raises:
+        ValueError: If both input_state and output_state are lists but have different lengths.
+
+    Examples:
+        Single input to single output:
+        ```python
+        step = copy("input_data", "output_data")
+        # Copies value from "input_data" key to "output_data" key
+        ```
+
+        Single input to multiple outputs (broadcast):
+        ```python
+        step = copy("input_data", ["output1", "output2", "output3"])
+        # Copies value from "input_data" to all three output keys
+        ```
+
+        Multiple inputs to single output (pack):
+        ```python
+        step = copy(["input1", "input2", "input3"], "packed_output")
+        # Packs values from all three input keys into a list at "packed_output"
+        ```
+
+        Multiple inputs to multiple outputs (pairwise):
+        ```python
+        step = copy(["input1", "input2"], ["output1", "output2"])
+        # Copies "input1" → "output1" and "input2" → "output2"
+        ```
+
+        With custom name and retry config:
+        ```python
+        from gllm_core import RetryConfig
+        retry_cfg = RetryConfig(max_attempts=3, delay=1.0)
+        step = copy(
+            "input_data",
+            "output_data",
+            name="DataCopyStep",
+            retry_config=retry_cfg
+        )
+        ```
+    '''

gllm_pipeline/steps/component_step.pyi

@@ -9,6 +9,7 @@ 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 langgraph.types import RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
@@ -60,7 +61,7 @@ class ComponentStep(BasePipelineStep, HasInputsMixin):
             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:
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> 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
@@ -69,6 +70,7 @@ class ComponentStep(BasePipelineStep, HasInputsMixin):
         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.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             dict[str, Any] | None: The update to the pipeline state after this step's operation, or None if

gllm_pipeline/steps/conditional_step.pyi

@@ -18,7 +18,7 @@ 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 langgraph.types import Command, RetryPolicy as RetryPolicy, RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any, Callable
 
@@ -122,17 +122,18 @@ class ConditionalStep(BranchingStep, HasInputsMixin):
             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:
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> 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.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         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:
+    async def execute_direct(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> 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).
@@ -141,6 +142,7 @@ class ConditionalStep(BranchingStep, HasInputsMixin):
         Args:
             state (dict[str, Any]): The current state of the pipeline.
             runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             dict[str, Any] | None: Updates to apply to the pipeline state, or None if no updates.

gllm_pipeline/steps/log_step.pyi

@@ -5,6 +5,7 @@ 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 langgraph.types import RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
@@ -38,12 +39,13 @@ class LogStep(BasePipelineStep):
             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:
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> 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.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             None: This step does not modify the pipeline state.

gllm_pipeline/steps/map_reduce_step.pyi

@@ -10,6 +10,7 @@ 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 langgraph.types import RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any, Callable
 
@@ -77,12 +78,13 @@ class MapReduceStep(BasePipelineStep, HasInputsMixin):
             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]:
+    async def execute(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> 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.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             dict[str, Any]: The reduced result stored under output_state.

gllm_pipeline/steps/no_op_step.pyi

@@ -1,5 +1,6 @@
 from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
 from langgraph.runtime import Runtime as Runtime
+from langgraph.types import RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
@@ -28,12 +29,13 @@ class NoOpStep(BasePipelineStep):
     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:
+    async def execute(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> 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.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             None: This step does not modify the pipeline state.

gllm_pipeline/steps/parallel_step.pyi

@@ -14,7 +14,7 @@ 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 RetryPolicy as RetryPolicy
+from langgraph.types import RetryPolicy as RetryPolicy, RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
@@ -106,7 +106,7 @@ class ParallelStep(BranchingStep, HasInputsMixin):
         Returns:
             list[str]: Exit points after adding all child steps.
         """
-    async def execute(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel]) -> dict[str, Any] | None:
+    async def execute(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> dict[str, Any] | None:
         """Execute all branches in parallel and merge their results.
 
         This method is only used for the squashed approach. For the expanded approach,
@@ -115,6 +115,7 @@ class ParallelStep(BranchingStep, HasInputsMixin):
         Args:
             state (dict[str, Any]): The current state of the pipeline.
             runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             dict[str, Any] | None: The merged results from all parallel branches, or None if no updates were produced.

gllm_pipeline/steps/pipeline_step.pyi

@@ -13,7 +13,7 @@ from gllm_pipeline.utils.graph import create_edge as create_edge
 from gllm_pipeline.utils.retry_converter import retry_config_to_langgraph_policy as retry_config_to_langgraph_policy
 from langgraph.graph import StateGraph as StateGraph
 from langgraph.runtime import Runtime as Runtime
-from langgraph.types import RetryPolicy as RetryPolicy
+from langgraph.types import RetryPolicy as RetryPolicy, RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
@@ -153,7 +153,7 @@ class BasePipelineStep(ABC, metaclass=abc.ABCMeta):
             list[str]: The exit points (endpoints) of this step.
         """
     @abstractmethod
-    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel]) -> dict[str, Any] | None:
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> dict[str, Any] | None:
         """Executes the operation defined for this pipeline step.
 
         This method should be implemented by subclasses to perform the actual processing or computation for this step.
@@ -161,6 +161,9 @@ class BasePipelineStep(ABC, metaclass=abc.ABCMeta):
         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.
+            config (RunnableConfig | None, optional): Runnable configuration containing thread_id and other
+                LangGraph config. This allows steps to access invocation-level configuration like thread_id for
+                tracking and checkpointing. Defaults to None.
 
         Returns:
             dict[str, Any] | None: The update to the pipeline state after this step's operation.
@@ -170,7 +173,7 @@ class BasePipelineStep(ABC, metaclass=abc.ABCMeta):
         Raises:
             NotImplementedError: If the subclass does not implement this method.
         """
-    async def execute_direct(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel]) -> dict[str, Any] | None:
+    async def execute_direct(self, state: dict[str, Any], runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> dict[str, Any] | None:
         """Execute this step directly, bypassing graph-based execution.
 
         This method is used when a step needs to be executed directly, such as in parallel execution.
@@ -179,6 +182,7 @@ class BasePipelineStep(ABC, metaclass=abc.ABCMeta):
         Args:
             state (dict[str, Any]): The current state of the pipeline.
             runtime (Runtime[dict[str, Any] | BaseModel]): Runtime information for this step's execution.
+            config (RunnableConfig | None, optional): The runnable configuration to pass to the step.
 
         Returns:
             dict[str, Any] | None: Updates to apply to the pipeline state, or None if no updates.

gllm_pipeline/steps/state_operator_step.pyi

@@ -9,6 +9,7 @@ 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 langgraph.types import RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any, Callable
 
@@ -56,7 +57,7 @@ class StateOperatorStep(BasePipelineStep, HasInputsMixin):
             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]:
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> dict[str, Any]:
         """Executes the operation and processes its output.
 
         This method validates inputs, prepares data, executes the operation, and formats the output for integration
@@ -65,6 +66,7 @@ class StateOperatorStep(BasePipelineStep, HasInputsMixin):
         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.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             dict[str, Any]: The update to the pipeline state after this step's operation.

gllm_pipeline/steps/subgraph_step.pyi

@@ -11,6 +11,7 @@ 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 langgraph.types import RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
@@ -59,7 +60,7 @@ class SubgraphStep(BaseCompositeStep, HasInputsMixin):
             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]:
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> dict[str, Any]:
         """Executes the subgraph and processes its output.
 
         This method prepares data, executes the subgraph, and formats the output for integration
@@ -69,6 +70,7 @@ class SubgraphStep(BaseCompositeStep, HasInputsMixin):
         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.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
 
         Returns:
             dict[str, Any]: The update to the pipeline state after this step's operation.

gllm_pipeline/steps/terminator_step.pyi

@@ -2,7 +2,7 @@ from gllm_pipeline.alias import PipelineState as PipelineState
 from gllm_pipeline.steps.pipeline_step import BasePipelineStep as BasePipelineStep
 from langgraph.graph import StateGraph as StateGraph
 from langgraph.runtime import Runtime as Runtime
-from langgraph.types import RetryPolicy as RetryPolicy
+from langgraph.types import RetryPolicy as RetryPolicy, RunnableConfig as RunnableConfig
 from pydantic import BaseModel as BaseModel
 from typing import Any
 
@@ -48,10 +48,11 @@ class TerminatorStep(BasePipelineStep):
         Returns:
             list[str]: Empty list as this step has no endpoints (it terminates the flow).
         """
-    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel]) -> None:
+    async def execute(self, state: PipelineState, runtime: Runtime[dict[str, Any] | BaseModel], config: RunnableConfig | None = None) -> None:
         """Executes this step, which does nothing but pass through the state.
 
         Args:
             state (PipelineState): The current pipeline state.
             runtime (Runtime[dict[str, Any] | BaseModel]): The runtime information.
+            config (RunnableConfig | None, optional): The runnable configuration. Defaults to None.
         """

gllm_pipeline.pyi

@@ -20,6 +20,7 @@ import gllm_datastore
 import gllm_datastore.cache
 import gllm_datastore.cache.cache
 import asyncio
+import uuid
 import copy
 import gllm_core.utils.imports
 import gllm_core.utils.logger_manager

{gllm_pipeline_binary-0.4.21.dist-info → gllm_pipeline_binary-0.4.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-pipeline-binary
-Version: 0.4.21
+Version: 0.4.23
 Summary: A library containing components related to Gen AI applications pipeline orchestration.
 Author-email: Dimitrij Ray <dimitrij.ray@gdplabs.id>, Henry Wicaksono <henry.wicaksono@gdplabs.id>, Kadek Denaya <kadek.d.r.diana@gdplabs.id>
 Requires-Python: <3.13,>=3.11

{gllm_pipeline_binary-0.4.21.dist-info → gllm_pipeline_binary-0.4.23.dist-info}/RECORD

@@ -1,5 +1,5 @@
-gllm_pipeline.cp312-win_amd64.pyd,sha256=zH_aiOL7m_egsHnbFCLel10g9B5V0dGQi19F367U2XI,2160640
-gllm_pipeline.pyi,sha256=QRQhvO2Qq-xIEm7IGhaJ7ZELWzla_t4KiOV9MtH6zSQ,2294
+gllm_pipeline.cp312-win_amd64.pyd,sha256=tzPFp3ZMu0Ek6EYDOwCAfzeEO6N-jxpuOPCntj91GHE,2177024
+gllm_pipeline.pyi,sha256=SCe8vHfVDlgMZ1I_dfYPa-qFjsj_IWl0lgTa7lRrQqQ,2306
 gllm_pipeline/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_pipeline/alias.pyi,sha256=FbALRYZpDlmQMsKNUvgCi6ji11PrEtNo2kgzbt0iT7g,237
 gllm_pipeline/types.pyi,sha256=CV3cEAxlNsnVatYz5iCxqmEFPEqeKW5vv-qUD3FpF54,241
@@ -7,10 +7,10 @@ gllm_pipeline/exclusions/__init__.pyi,sha256=_LwIlqmH4Iiksn7p09d2vZG4Ek8CdKC8UcD
 gllm_pipeline/exclusions/exclusion_manager.pyi,sha256=DzoL-2KeTRmFgJEo8rzYViFYKbzZVTZGJmKvzaoTC0M,2960
 gllm_pipeline/exclusions/exclusion_set.pyi,sha256=11XTt6IfkHpzomcNybA78SfWlp752Z3AGhXfm2rL0Fk,1685
 gllm_pipeline/pipeline/__init__.pyi,sha256=1IKGdMvmLWEiOOmAKFNUPm-gdw13zrnU1gs7tDNzgEU,168
-gllm_pipeline/pipeline/pipeline.pyi,sha256=3aPgaDfAUohJo5yCbJ68uSJyD7QE3jD8LszFkkTVA-Y,14651
+gllm_pipeline/pipeline/pipeline.pyi,sha256=m8OStEgk9SsV6faKX6wEqGyygE_xF421wJWQJvBAEeY,14979
 gllm_pipeline/pipeline/states.pyi,sha256=EiyfBPwrVDZ336w5wyD1q8W4E6G1uZNzsP-bzrHDumo,6464
 gllm_pipeline/pipeline/composer/__init__.pyi,sha256=-hcOUQgpTRt1QjQfRurTf-UApFnTrhilx6vN-gYd5J0,666
-gllm_pipeline/pipeline/composer/composer.pyi,sha256=foztmOTsqdd6CW1CY4QQrObe2shy_yvEopz_knwAmFk,26697
+gllm_pipeline/pipeline/composer/composer.pyi,sha256=7h7EhEA-hex6w36Is6uGTz9OBUbmq6C0SdkeBeLFcAI,28715
 gllm_pipeline/pipeline/composer/guard_composer.pyi,sha256=YfbXmzyU3CwAvGnCfM-6MVcTdxk53-j6Cv3IdzNr_-c,3335
 gllm_pipeline/pipeline/composer/if_else_composer.pyi,sha256=uGyd1S7P5uXdER_fAzVIftg0yovZjMbN-L9JxgHxZNw,3196
 gllm_pipeline/pipeline/composer/parallel_composer.pyi,sha256=rL6dc9Rm1Bzo_Acl0yLEEUZZQmNmfuNNpU4jhjt3Yzg,2593
@@ -39,21 +39,21 @@ gllm_pipeline/router/preset/aurelio/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeu
 gllm_pipeline/router/preset/aurelio/router_image_domain_specific.pyi,sha256=6pm2aV2fgmyIaKPMkNbAl337HSbFAUFuDxVIEgYAmk8,1093
 gllm_pipeline/router/preset/lm_based/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_pipeline/router/preset/lm_based/router_image_domain_specific.pyi,sha256=UdiuoSXm2MVAL8AspAaSkyXYkE59bYj1y4xRRgKwavE,655
-gllm_pipeline/steps/__init__.pyi,sha256=f_dgel-CsDow7nSWYQDVTQYOogwvty8tEeh2lZautqM,1967
-gllm_pipeline/steps/_func.pyi,sha256=fKL6aCobBmjo7vznRKJeeML4VmJtoQhD8G5L5vG3Pao,60843
+gllm_pipeline/steps/__init__.pyi,sha256=5HtVA5CODr_9_7_OGEXFXU40edqhHa9YlCV5qVx3xbU,1989
+gllm_pipeline/steps/_func.pyi,sha256=FS-g9LiyHb8OHLM8bXrAMiqvk4-KgaxV8RacD0IQw-Q,64125
 gllm_pipeline/steps/branching_step.pyi,sha256=iNarrcZgWfiRdr8CJfGm8GzUlYq13Rx5cgYXnBsNWN4,1041
-gllm_pipeline/steps/component_step.pyi,sha256=2rHqYeVHcKCqsA8GXeTyVAWus6rCkYp0GHK7qnACZjc,5547
+gllm_pipeline/steps/component_step.pyi,sha256=VNBFZscK2Q4HgBt8ZrbE6B69oLTKcXo-KkqbTjmYYhM,5748
 gllm_pipeline/steps/composite_step.pyi,sha256=lvueTBQG_t0TtS5qRvUzZOIt3h6-uD26DJXW4ZSkuUc,3544
-gllm_pipeline/steps/conditional_step.pyi,sha256=8WLvtNAS-wuYxjelTBBKo8KwkLaJmNWYrMXgsnpIeSk,10189
+gllm_pipeline/steps/conditional_step.pyi,sha256=Nm7zjxyPooRjJboT8Pqc3UwWKiA1gJHOwCtPW7KtrpE,10501
 gllm_pipeline/steps/guard_step.pyi,sha256=c_vdRz3hjfPu2DFkBt0_UBGJErQpdJwl0AE-GNxC4gM,4779
-gllm_pipeline/steps/log_step.pyi,sha256=p0DVXHV1mf4zhC5QP5uuzM8cVytrzY9uZHS_s1SYgKs,3100
-gllm_pipeline/steps/map_reduce_step.pyi,sha256=WE4a7SqeIf9BC-aJWQ-KnikN9q2YfJzQc5-_slIpRtg,6034
-gllm_pipeline/steps/no_op_step.pyi,sha256=mVCpfUOIGGs_q6BMy0g1tsaDH8JBiKyFMcVHeeOTMXY,1379
-gllm_pipeline/steps/parallel_step.pyi,sha256=Z5FhVXJslQ777cdi7Bnzm27yqJU61MflNic7lAIscno,8382
-gllm_pipeline/steps/pipeline_step.pyi,sha256=oc_Sg-YhFSFbGKaNZoLvkka44kyQap7euj30AB0WWJ4,11213
-gllm_pipeline/steps/state_operator_step.pyi,sha256=60hvqAw8QLYyhO9zo8F56bVpG2494WZpoZOtpYyiaT8,5111
-gllm_pipeline/steps/subgraph_step.pyi,sha256=j0oF18OJ3VjApXO27l6B2zZO-joBdkS3J2dZYjSwTAo,5825
-gllm_pipeline/steps/terminator_step.pyi,sha256=ZBZEWS232HRWJUgxqznB3dCjLw0XoezBAuK3gczaKp0,2514
+gllm_pipeline/steps/log_step.pyi,sha256=XjL_-mlsWAEcoCBZ--qa8XkGdIXrx1K-chI8aXVsOFE,3301
+gllm_pipeline/steps/map_reduce_step.pyi,sha256=c9qo_EmQWlu-jjAHeOKeyj8dVRL6yR89Tj5RHRoxhhA,6235
+gllm_pipeline/steps/no_op_step.pyi,sha256=3DWW_gmY_66_mmNmnn2ic_NJZ0tNi_obDfjN8oLZByk,1580
+gllm_pipeline/steps/parallel_step.pyi,sha256=XI_gM3Z1WS2R0j_qfrwf0tausxvX6VWuiknSCLgAetg,8555
+gllm_pipeline/steps/pipeline_step.pyi,sha256=p0qNBL7v8Gv0wc7CeN3hIv08u_I8uaT1xPQwt-YOQPM,11711
+gllm_pipeline/steps/state_operator_step.pyi,sha256=55mX2vxUUmRy2sS4iqIE4ZM_D4pB1FFoQa5Ox9N1Jdg,5312
+gllm_pipeline/steps/subgraph_step.pyi,sha256=xvHxBiFbXJhMPW-06YcoW1SjVGthTj1_O4nymSew9L0,6026
+gllm_pipeline/steps/terminator_step.pyi,sha256=M1LNw1AszTVMtwOHGrWvnr15A8qIgWuHYUdbFNrCzUM,2687
 gllm_pipeline/steps/step_error_handler/__init__.pyi,sha256=6eUbWMlQKQjlqS2KJHIMZksb_dXUxmsgRzoJ03tnX4o,618
 gllm_pipeline/steps/step_error_handler/empty_step_error_handler.pyi,sha256=JwD09mJD-80_pmeOEaB7blKCuYXOsju4JyVejOGtTLI,901
 gllm_pipeline/steps/step_error_handler/fallback_step_error_handler.pyi,sha256=N4Skd5C5df34KdephUX5l_KclMBnnvGBmhNQFKhmtBs,1326
@@ -71,7 +71,7 @@ gllm_pipeline/utils/mermaid.pyi,sha256=B096GTXxVAO--kw3UDsbysOsnjGOytYfozX39YaM2
 gllm_pipeline/utils/retry_converter.pyi,sha256=JPUuaGzKpVLshrbhX9rQHYl5XmC9GDa59rGU-FtOpWM,1128
 gllm_pipeline/utils/step_execution.pyi,sha256=3o28tiCHR8t-6Vk3Poz91V-CLdYrdhvJblPW9AoOK-c,996
 gllm_pipeline.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gllm_pipeline_binary-0.4.21.dist-info/METADATA,sha256=qXwlCvVnTxYG6BT28dtv-18pNAT7IQFumJKQ4jcbwUA,4476
-gllm_pipeline_binary-0.4.21.dist-info/WHEEL,sha256=x5rgv--I0NI0IT1Lh9tN1VG2cI637p3deednwYLKnxc,96
-gllm_pipeline_binary-0.4.21.dist-info/top_level.txt,sha256=C3yeOtoE6ZhuOnBEq_FFc_Rp954IHJBlB6fBgSdAWYI,14
-gllm_pipeline_binary-0.4.21.dist-info/RECORD,,
+gllm_pipeline_binary-0.4.23.dist-info/METADATA,sha256=rro3zbAKhq4bHW2wFZZjHyFTFaAH_ZxbCCWFpJ9OKvY,4476
+gllm_pipeline_binary-0.4.23.dist-info/WHEEL,sha256=x5rgv--I0NI0IT1Lh9tN1VG2cI637p3deednwYLKnxc,96
+gllm_pipeline_binary-0.4.23.dist-info/top_level.txt,sha256=C3yeOtoE6ZhuOnBEq_FFc_Rp954IHJBlB6fBgSdAWYI,14
+gllm_pipeline_binary-0.4.23.dist-info/RECORD,,