soprano-sdk 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

soprano_sdk/__init__.py

@@ -1,4 +1,5 @@
 from .core.engine import WorkflowEngine, load_workflow
+from .core.constants import MFAConfig
 from .tools import WorkflowTool
 
 __version__ = "0.1.0"
@@ -6,5 +7,6 @@ __version__ = "0.1.0"
 __all__ = [
     "WorkflowEngine",
     "load_workflow",
+    "MFAConfig",
     "WorkflowTool",
 ]

soprano_sdk/authenticators/mfa.py

@@ -1,6 +1,6 @@
 import requests
-from typing import TypedDict, Literal, NotRequired
-from soprano_sdk.core.constants import MFARestAuthorizerEnv
+from typing import TypedDict, Literal, NotRequired, Optional
+from soprano_sdk.core.constants import MFAConfig
 
 
 class MFAChallenge(TypedDict):
@@ -28,15 +28,21 @@ def build_path(base_url: str, path: str):
     return f"{base_url.rstrip('/')}/{path.lstrip('/')}"
 
 
-def enforce_mfa_if_required(state: dict):
+def enforce_mfa_if_required(state: dict, mfa_config: Optional[MFAConfig] = None):
+    if mfa_config is None:
+        mfa_config = state.get('_mfa_config') or MFAConfig()
+
     _mfa : MFAState = state['_mfa']
     if _mfa['status'] == 'COMPLETED':
         return True
     generate_token_response = requests.post(
         build_path(
-            base_url=MFARestAuthorizerEnv.GENERATE_TOKEN_BASE_URL.get_from_env(),
-            path=MFARestAuthorizerEnv.GENERATE_TOKEN_PATH.get_from_env()
-        ), json=_mfa['post_payload'], timeout=30, headers={"Authorization": f"Bearer {state['bearer_token']}"}
+            base_url=mfa_config.generate_token_base_url,
+            path=mfa_config.generate_token_path
+        ),
+        json=_mfa['post_payload'],
+        timeout=mfa_config.api_timeout,
+        headers={"Authorization": f"Bearer {state['bearer_token']}"}
     )
     _, error = get_response(generate_token_response)
 
@@ -50,7 +56,10 @@ def enforce_mfa_if_required(state: dict):
     return False
 
 
-def mfa_validate_user_input(**state: dict):
+def mfa_validate_user_input(mfa_config: Optional[MFAConfig] = None, **state: dict):
+    if mfa_config is None:
+        mfa_config = state.get('_mfa_config') or MFAConfig()
+
     _mfa : MFAState = state['_mfa']
     input_field_name = state['_active_input_field']
     if not state[input_field_name]:
@@ -61,9 +70,12 @@ def mfa_validate_user_input(**state: dict):
     post_payload.update({challenge_field_name: {"value": state[input_field_name]}})
     validate_token_response = requests.post(
         build_path(
-            base_url=MFARestAuthorizerEnv.VALIDATE_TOKEN_BASE_URL.get_from_env(),
-            path=MFARestAuthorizerEnv.VALIDATE_TOKEN_PATH.get_from_env()
-        ), json=post_payload, timeout=30, headers={"Authorization": f"Bearer {state['bearer_token']}"}
+            base_url=mfa_config.validate_token_base_url,
+            path=mfa_config.validate_token_path
+        ),
+        json=post_payload,
+        timeout=mfa_config.api_timeout,
+        headers={"Authorization": f"Bearer {state['bearer_token']}"}
     )
     _mfa['retry_count'] += 1
     response, error = get_response(validate_token_response)
@@ -78,11 +90,11 @@ def mfa_validate_user_input(**state: dict):
 
         authorize = requests.post(
             build_path(
-                base_url=MFARestAuthorizerEnv.AUTHORIZE_TOKEN_BASE_URL.get_from_env(),
-                path=MFARestAuthorizerEnv.AUTHORIZE_TOKEN_PATH.get_from_env()
+                base_url=mfa_config.authorize_token_base_url,
+                path=mfa_config.authorize_token_path
             ),
             json=post_payload,
-            timeout=30,
+            timeout=mfa_config.api_timeout,
             headers={"Authorization": f"Bearer {state['bearer_token']}"}
         )
         if authorize.status_code == 204:
@@ -116,14 +128,18 @@ class MFANodeConfig:
         )
 
     @classmethod
-    def get_validate_user_input(cls, source_node: str, next_node: str, model_name: str):
+    def get_validate_user_input(cls, source_node: str, next_node: str, mfa_config: dict):
+        model_name = mfa_config['model']
+        max_attempts = mfa_config.get('max_attempts', 3)
+        on_max_attempts_reached = mfa_config.get('on_max_attempts_reached')
+
         input_field_name = f"{source_node}_mfa_input"
-        return dict(
+        node_config = dict(
             id=f"{source_node}_mfa_validate",
             action="collect_input_with_agent",
             description="Collect Input for MFA value",
             field=input_field_name,
-            max_attempts=3,
+            max_attempts=max_attempts,
             validator="soprano_sdk.authenticators.mfa.mfa_validate_user_input",
             agent=dict(
                 name="MFA Input Data Collector",
@@ -152,3 +168,8 @@ class MFANodeConfig:
                 )
             ]
         )
+
+        if on_max_attempts_reached:
+            node_config['on_max_attempts_reached'] = on_max_attempts_reached
+
+        return node_config

soprano_sdk/core/constants.py

@@ -1,5 +1,7 @@
-import os
 from enum import Enum
+from typing import Optional
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class WorkflowKeys:
@@ -60,17 +62,53 @@ MAX_ATTEMPTS_MESSAGE = "I'm having trouble understanding your {field}. Please co
 WORKFLOW_COMPLETE_MESSAGE = "Workflow completed."
 
 
-class MFARestAuthorizerEnv(Enum):
-    GENERATE_TOKEN_BASE_URL = 'GENERATE_TOKEN_BASE_URL'
-    GENERATE_TOKEN_PATH = 'GENERATE_TOKEN_PATH'
-    VALIDATE_TOKEN_BASE_URL = 'VALIDATE_TOKEN_BASE_URL'
-    VALIDATE_TOKEN_PATH = 'VALIDATE_TOKEN_PATH'
-    AUTHORIZE_TOKEN_BASE_URL = 'AUTHORIZE_TOKEN_BASE_URL'
-    AUTHORIZE_TOKEN_PATH = 'AUTHORIZE_TOKEN_PATH'
-
-    API_TIMEOUT = 'API_TIMEOUT'
-
-    def get_from_env(self):
-        if self == MFARestAuthorizerEnv.API_TIMEOUT:
-            return int(os.getenv(self.value, '30'))
-        return os.getenv(self.value)
+class MFAConfig(BaseSettings):
+    """
+    Configuration for MFA REST API endpoints.
+
+    Values can be provided during initialization or will be automatically
+    loaded from environment variables with the same name (uppercase).
+
+    Example:
+        # Load from environment variables
+        config = MFAConfig()
+
+        # Or provide specific values
+        config = MFAConfig(
+            generate_token_base_url="https://api.example.com",
+            generate_token_path="/v1/mfa/generate"
+        )
+    """
+    generate_token_base_url: Optional[str] = Field(
+        default=None,
+        description="Base URL for the generate token endpoint"
+    )
+    generate_token_path: Optional[str] = Field(
+        default=None,
+        description="Path for the generate token endpoint"
+    )
+    validate_token_base_url: Optional[str] = Field(
+        default=None,
+        description="Base URL for the validate token endpoint"
+    )
+    validate_token_path: Optional[str] = Field(
+        default=None,
+        description="Path for the validate token endpoint"
+    )
+    authorize_token_base_url: Optional[str] = Field(
+        default=None,
+        description="Base URL for the authorize token endpoint"
+    )
+    authorize_token_path: Optional[str] = Field(
+        default=None,
+        description="Path for the authorize token endpoint"
+    )
+    api_timeout: int = Field(
+        default=30,
+        description="API request timeout in seconds"
+    )
+
+    model_config = SettingsConfigDict(
+        case_sensitive=False,
+        extra='ignore'
+    )

soprano_sdk/core/engine.py

@@ -7,7 +7,7 @@ from langgraph.constants import START
 from langgraph.graph import StateGraph
 from langgraph.graph.state import CompiledStateGraph
 
-from .constants import WorkflowKeys
+from .constants import WorkflowKeys, MFAConfig
 from .state import create_state_model
 from ..nodes.factory import NodeFactory
 from ..routing.router import WorkflowRouter
@@ -19,7 +19,7 @@ from soprano_sdk.authenticators.mfa import MFANodeConfig
 
 class WorkflowEngine:
 
-    def __init__(self, yaml_path: str, configs: dict):
+    def __init__(self, yaml_path: str, configs: dict, mfa_config: Optional[MFAConfig] = None):
         self.yaml_path = yaml_path
         self.configs = configs or {}
         logger.info(f"Loading workflow from: {yaml_path}")
@@ -29,7 +29,7 @@ class WorkflowEngine:
                 self.config = yaml.safe_load(f)
 
             logger.info("Validating workflow configuration")
-            validate_workflow(self.config)
+            validate_workflow(self.config, mfa_config=mfa_config or MFAConfig())
 
             self.workflow_name = self.config['name']
             self.workflow_description = self.config['description']
@@ -37,6 +37,7 @@ class WorkflowEngine:
             self.mfa_validator_steps: set[str] = set()
             self.steps: list = self.load_steps()
             self.step_map = {step['id']: step for step in self.steps}
+            self.mfa_config = (mfa_config or MFAConfig()) if self.mfa_validator_steps else None
             self.data_fields = self.load_data()
 
             self.outcomes = self.config['outcomes']
@@ -208,8 +209,9 @@ class WorkflowEngine:
 
             if mfa_config := step.get('mfa'):
                 mfa_data_collector = MFANodeConfig.get_validate_user_input(
-                    next_node=step_id, model_name=mfa_config['model'],
-                    source_node=step_id
+                    next_node=step_id,
+                    source_node=step_id,
+                    mfa_config=mfa_config
                 )
                 mfa_start = MFANodeConfig.get_call_function_template(
                     source_node=step_id,
@@ -259,7 +261,7 @@ class WorkflowEngine:
         return data
 
 
-def load_workflow(yaml_path: str, checkpointer=None, config=None) -> Tuple[CompiledStateGraph, WorkflowEngine]:
+def load_workflow(yaml_path: str, checkpointer=None, config=None, mfa_config: Optional[MFAConfig] = None) -> Tuple[CompiledStateGraph, WorkflowEngine]:
     """
     Load a workflow from YAML configuration.
 
@@ -270,6 +272,8 @@ def load_workflow(yaml_path: str, checkpointer=None, config=None) -> Tuple[Compi
         checkpointer: Optional checkpointer for state persistence.
                      Defaults to InMemorySaver() if not provided.
                      Example: MongoDBSaver for production persistence.
+        config: Optional configuration dictionary
+        mfa_config: Optional MFA configuration. If not provided, will load from environment variables.
 
     Returns:
         Tuple of (compiled_graph, engine) where:
@@ -278,11 +282,21 @@ def load_workflow(yaml_path: str, checkpointer=None, config=None) -> Tuple[Compi
 
     Example:
         ```python
+        # Load with environment variables
         graph, engine = load_workflow("workflow.yaml")
+
+        # Or provide MFA configuration explicitly
+        from soprano_sdk.core.constants import MFAConfig
+        mfa_config = MFAConfig(
+            generate_token_base_url="https://api.example.com",
+            generate_token_path="/v1/mfa/generate"
+        )
+        graph, engine = load_workflow("workflow.yaml", mfa_config=mfa_config)
+
         result = graph.invoke({}, config={"configurable": {"thread_id": "123"}})
         message = engine.get_outcome_message(result)
         ```
     """
-    engine = WorkflowEngine(yaml_path, configs=config)
+    engine = WorkflowEngine(yaml_path, configs=config, mfa_config=mfa_config)
     graph = engine.build_graph(checkpointer=checkpointer)
     return graph, engine

soprano_sdk/core/state.py

@@ -48,6 +48,7 @@ def create_state_model(data_fields: List[dict]):
     fields['_computed_fields'] = Annotated[List[str], replace]
     fields['error'] = Annotated[Optional[Dict[str, str]], replace]
     fields['_mfa'] = Annotated[Optional[Dict[str, str]], replace]
+    fields['_mfa_config'] = Annotated[Optional[Any], replace]
     fields['mfa_input'] = Annotated[Optional[Dict[str, str]], replace]
 
     return types.new_class('WorkflowState', (TypedDict,), {}, lambda ns: ns.update({'__annotations__': fields}))

soprano_sdk/nodes/call_function.py

@@ -39,6 +39,7 @@ class CallFunctionStrategy(ActionStrategy):
         if 'mfa' in self.step_config:
             state['_mfa'] = state.get('_mfa', {})
             state['_mfa']['post_payload'] = dict(transactionId=str(uuid.uuid4()))
+            state['_mfa_config'] = self.engine_context.mfa_config
             template_loader = self.engine_context.get_config_value("template_loader", Environment())
             for k, v in self.step_config['mfa']['payload'].items():
                 state['_mfa']['post_payload'][k] = compile_values(template_loader, state, v)

soprano_sdk/nodes/collect_input.py

@@ -92,6 +92,7 @@ class CollectInputStrategy(ActionStrategy):
         self.field = step_config.get('field')
         self.agent_config = step_config.get('agent', {})
         self.max_attempts = step_config.get('retry_limit') or engine_context.get_config_value("max_retry_limit", DEFAULT_MAX_ATTEMPTS)
+        self.on_max_attempts_reached = step_config.get('on_max_attempts_reached')
         self.transitions = self._get_transitions()
         self.next_step = self.step_config.get("next", None)
         self.is_structured_output = self.agent_config.get("structured_output", {}).get("enabled", False)
@@ -116,6 +117,9 @@ class CollectInputStrategy(ActionStrategy):
 
     def pre_execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
         state['_active_input_field'] = self.step_config.get('field')
+        # Inject MFA config for MFA validator nodes
+        if self.step_id in self.engine_context.mfa_validator_steps:
+            state['_mfa_config'] = self.engine_context.mfa_config
 
     @property
     def _formatted_field_name(self) -> str:
@@ -269,7 +273,10 @@ class CollectInputStrategy(ActionStrategy):
     def _handle_max_attempts(self, state: Dict[str, Any]) -> Dict[str, Any]:
         logger.warning(f"Max attempts reached for field '{self.field}'")
         self._set_status(state, 'max_attempts')
-        message = MAX_ATTEMPTS_MESSAGE.format(field=self.field)
+        if self.on_max_attempts_reached:
+            message = self.on_max_attempts_reached
+        else:
+            message = MAX_ATTEMPTS_MESSAGE.format(field=self.field)
         state[WorkflowKeys.MESSAGES] = [message]
         return state
 

soprano_sdk/tools.py

@@ -1,7 +1,7 @@
 """
 Workflow Tools - Wraps workflows as callable tools for agent frameworks
 """
-
+from __future__ import annotations
 import uuid
 from typing import Optional, Dict, Any
 from .utils.logger import logger
@@ -9,6 +9,7 @@ from .utils.logger import logger
 from langfuse.langchain import CallbackHandler
 
 from .core.engine import load_workflow
+from .core.constants import MFAConfig
 
 
 class WorkflowTool:
@@ -25,7 +26,8 @@ class WorkflowTool:
         name: str,
         description: str,
         checkpointer=None,
-        config: Optional[Dict]=None
+        config: Optional[Dict]=None,
+        mfa_config: Optional[MFAConfig] = None
     ):
         """Initialize workflow tool
 
@@ -39,9 +41,13 @@ class WorkflowTool:
         self.name = name
         self.description = description
         self.checkpointer = checkpointer
+        self.mfa_config = mfa_config
 
         # Load workflow
-        self.graph, self.engine = load_workflow(yaml_path, checkpointer=checkpointer, config=config)
+        self.graph, self.engine = load_workflow(
+            yaml_path, checkpointer=checkpointer,
+            config=config, mfa_config=mfa_config
+        )
 
     def execute(
         self,

soprano_sdk/validation/schema.py

@@ -90,6 +90,10 @@ WORKFLOW_SCHEMA = {
                         "maximum": 20,
                         "description": "Maximum attempts (for collect_input_with_agent)"
                     },
+                    "on_max_attempts_reached": {
+                        "type": "string",
+                        "description": "Custom error message to display when max attempts are exhausted (for collect_input_with_agent)"
+                    },
                     "agent": {
                         "type": "object",
                         "description": "Agent configuration (for collect_input_with_agent)",
@@ -245,6 +249,16 @@ WORKFLOW_SCHEMA = {
                                 "type": "object",
                                 "description": "MFA payload data that is posted to the RESTAPI, Apart from the properties provided transactionId is sent by the framework in the post payload as an additional property, transactionId is the same throughout the MFA process",
                                 "additionalProperties": True
+                            },
+                            "max_attempts": {
+                                "type": "integer",
+                                "minimum": 1,
+                                "maximum": 20,
+                                "description": "Maximum number of attempts allowed for MFA validation (default: 3)"
+                            },
+                            "on_max_attempts_reached": {
+                                "type": "string",
+                                "description": "Custom error message to display when MFA max attempts are exhausted"
                             }
                         }
                     },

soprano_sdk/validation/validator.py

@@ -1,9 +1,11 @@
-from typing import List, Set
+from typing import List, Set, Optional, TYPE_CHECKING
 
 import jsonschema
 
 from .schema import WORKFLOW_SCHEMA
-from soprano_sdk.core.constants import MFARestAuthorizerEnv
+
+if TYPE_CHECKING:
+    from soprano_sdk.core.constants import MFAConfig
 
 
 class ValidationResult:
@@ -21,8 +23,9 @@ class ValidationResult:
 
 
 class WorkflowValidator:
-    def __init__(self, config: dict):
+    def __init__(self, config: dict, mfa_config: Optional['MFAConfig'] = None):
         self.config = config
+        self.mfa_config = mfa_config
         self.errors: List[str] = []
 
     def validate(self) -> ValidationResult:
@@ -110,20 +113,10 @@ class WorkflowValidator:
                     )
 
     def _validate_authorizer(self, step):
-
-        def _validate_rest_fields():
-            if mfa_authorizer['type'] == 'REST':
-                for field in MFARestAuthorizerEnv:
-                    is_present = field.get_from_env()
-                    if not is_present:
-                        self.errors.append(f"`{field.value}` needs to be set as Environment for REST MFA")
-            else:
-                self.errors.append(f"step({step['id']}) -> mfa -> type is unsupported")
-
         mfa_authorizer = step.get("mfa", None)
         if mfa_authorizer is None:
             return
-        
+
         if mfa_authorizer and step['action'] != 'call_function':
             self.errors.append(
                 f"MFA is enabled in step({step['id']}). MFA is supported only for `call_function` nodes"
@@ -133,7 +126,31 @@ class WorkflowValidator:
         if not model:
             self.errors.append(f"step({step['id']}) -> mfa -> model is missing")
 
-        _validate_rest_fields()
+        mfa_type = mfa_authorizer.get('type')
+        if mfa_type and mfa_type != 'REST':
+            self.errors.append(f"step({step['id']}) -> mfa -> type '{mfa_type}' is unsupported. Only 'REST' is supported.")
+
+        # Validate mfa_config if provided
+        if self.mfa_config is not None:
+            missing_fields = []
+            if not self.mfa_config.generate_token_base_url:
+                missing_fields.append('generate_token_base_url')
+            if not self.mfa_config.generate_token_path:
+                missing_fields.append('generate_token_path')
+            if not self.mfa_config.validate_token_base_url:
+                missing_fields.append('validate_token_base_url')
+            if not self.mfa_config.validate_token_path:
+                missing_fields.append('validate_token_path')
+            if not self.mfa_config.authorize_token_base_url:
+                missing_fields.append('authorize_token_base_url')
+            if not self.mfa_config.authorize_token_path:
+                missing_fields.append('authorize_token_path')
+
+            if missing_fields:
+                self.errors.append(
+                    f"MFA configuration is missing required fields: {', '.join(missing_fields)}. "
+                    f"Either provide them via mfa_config parameter or set corresponding environment variables."
+                )
 
 
     def _validate_data_fields(self):
@@ -200,8 +217,8 @@ class WorkflowValidator:
                     )
 
 
-def validate_workflow(config: dict) -> ValidationResult:
-    validator = WorkflowValidator(config)
+def validate_workflow(config: dict, mfa_config: Optional['MFAConfig'] = None) -> ValidationResult:
+    validator = WorkflowValidator(config, mfa_config=mfa_config)
     result = validator.validate()
 
     if not result.is_valid:

{soprano_sdk-0.2.2.dist-info → soprano_sdk-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soprano-sdk
-Version: 0.2.2
+Version: 0.2.4
 Summary: YAML-driven workflow engine with AI agent integration for building conversational SOPs
 Author: Arvind Thangamani
 License: MIT

{soprano_sdk-0.2.2.dist-info → soprano_sdk-0.2.4.dist-info}/RECORD

@@ -1,21 +1,21 @@
-soprano_sdk/__init__.py,sha256=y3c4i7Q7SAPS2Tee7V0TzWdhgMxBWfDJJ98eqD1HxGI,188
+soprano_sdk/__init__.py,sha256=YZVl_SwQ0C-E_5_f1AwUe_hPcbgCt8k7k4_WAHM8vjE,243
 soprano_sdk/engine.py,sha256=EFK91iTHjp72otLN6Kg-yeLye2J3CAKN0QH4FI2taL8,14838
-soprano_sdk/tools.py,sha256=bjJzapnQp31iLDx8jHp_0X2FcS2kY8uqf6hsgD3uDx4,7442
+soprano_sdk/tools.py,sha256=v2QGEaXxKzCBZCTdmhZXMXiVcwccJivdQdCxETkp-lQ,7656
 soprano_sdk/agents/__init__.py,sha256=Yzbtv6iP_ABRgZo0IUjy9vDofEvLFbOjuABw758176A,636
 soprano_sdk/agents/adaptor.py,sha256=Cm02YKFclrESu-Qq4CTknCgU7KaA7Z_2FspnQDkEVfU,3214
 soprano_sdk/agents/factory.py,sha256=Aucfz4rZVKCXMAQtbGAqp1JR8aYwa66mokRmKkKGhYA,6699
 soprano_sdk/agents/structured_output.py,sha256=7DSVzfMPsZAqBwI3v6XL15qG5Gh4jJ-qddcVPaa3gdc,3326
 soprano_sdk/authenticators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/authenticators/mfa.py,sha256=st71m2R2Ag8l4dEbvARbIXV6kdqACBO9i5DaPK0rlWs,5429
+soprano_sdk/authenticators/mfa.py,sha256=7aTueLu2jLxl213Q5_BkNQ534RgEwf6lodQa_PaJFWs,5980
 soprano_sdk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/core/constants.py,sha256=-Ij4bbSDsyxQ_NZ5NiusJeepWhoe13WGuzN3LlnXqWY,2017
-soprano_sdk/core/engine.py,sha256=BNwmydKlqm64ZIj7VVVqSbn9ebKvOmUvHSr5XZBdQo4,10473
+soprano_sdk/core/constants.py,sha256=F7gL3hkpq5mZgbgiBcEERmzxYJ4zZG2ZFx1YQp5Z580,3130
+soprano_sdk/core/engine.py,sha256=UTFJimrgUzfdDZgc4rW5nvkOKevAEGW8C5Zr1D0tgcs,11270
 soprano_sdk/core/rollback_strategies.py,sha256=NjDTtBCZlqyDql5PSwI9SMDLK7_BNlTxbW_cq_5gV0g,7783
-soprano_sdk/core/state.py,sha256=ENf81OOe4C2IEYGWUcaBwJ3O1P6VRg4DVirOXFXjioA,2899
+soprano_sdk/core/state.py,sha256=k8ojLfWgjES3p9XWMeGU5s4UK-Xa5T8mS4VtZzTrcDw,2961
 soprano_sdk/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 soprano_sdk/nodes/base.py,sha256=idFyOGGPnjsASYnrOF_NIh7eFcSuJqw61EoVN_WCTaU,2360
-soprano_sdk/nodes/call_function.py,sha256=Quys2Rf2JitV1fnTpnEIpIoCCOQDzhWBriRXO59UqqI,5469
-soprano_sdk/nodes/collect_input.py,sha256=2zhUXYrWlMJ8KH3qo39hZdPiYmc0_moNvvuP3tl3RGY,23381
+soprano_sdk/nodes/call_function.py,sha256=PdmSSVXkMT5ptxeUjmKqND-wvqbaXp1i61QzIzFOfgQ,5535
+soprano_sdk/nodes/collect_input.py,sha256=lEltZOU5ALvc57q8I_4SjzzEapVejy9mS0E73Jf7-sk,23759
 soprano_sdk/nodes/factory.py,sha256=l-Gysfgnao-o2dphhnbjjxcH3ojZanZNYN3CBH9dDbA,1624
 soprano_sdk/routing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 soprano_sdk/routing/router.py,sha256=SrNciTIXXdC9bAbbO5bX7PN9mlRbITjr4RZdNm4jEVA,3450
@@ -26,9 +26,9 @@ soprano_sdk/utils/template.py,sha256=MG_B9TMx1ShpnSGo7s7TO-VfQzuFByuRNhJTvZ668kM
 soprano_sdk/utils/tool.py,sha256=hWN826HIKmLdswLCTURLH8hWlb2WU0MB8nIUErbpB-8,1877
 soprano_sdk/utils/tracing.py,sha256=gSHeBDLe-MbAZ9rkzpCoGFveeMdR9KLaA6tteB0IWjk,1991
 soprano_sdk/validation/__init__.py,sha256=ImChmO86jYHU90xzTttto2-LmOUOmvY_ibOQaLRz5BA,262
-soprano_sdk/validation/schema.py,sha256=R6bm4Pzgx8p08o77FN9FFSKTLTKOCf7WuThrR6rV2FI,14578
-soprano_sdk/validation/validator.py,sha256=mUTweaQyDaPqHWQDlsE9AFwnB3_MQAEOBrj1hwKQK68,7888
-soprano_sdk-0.2.2.dist-info/METADATA,sha256=lH2Z9tMo_U7riXwJ_Ucgmp7I0foTtlfsU4MWKBscQPU,11297
-soprano_sdk-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-soprano_sdk-0.2.2.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
-soprano_sdk-0.2.2.dist-info/RECORD,,
+soprano_sdk/validation/schema.py,sha256=7B60_8xIt5bLXTYEGEDwU2DwmQn2f4QFyyIca2FYM9s,15420
+soprano_sdk/validation/validator.py,sha256=GaCvHvjwVe88Z8yatQsueiPnqtq1oo5uN75gogzpQT0,8940
+soprano_sdk-0.2.4.dist-info/METADATA,sha256=W-e-Si4pewUkpuWewKz_pmkWvUeRVR8HPwQ-Z-7tpTQ,11297
+soprano_sdk-0.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+soprano_sdk-0.2.4.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
+soprano_sdk-0.2.4.dist-info/RECORD,,