soprano-sdk 0.2.2__py3-none-any.whl → 0.2.3__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:

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']
@@ -259,7 +260,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 +271,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 +281,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

@@ -116,6 +116,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:

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/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.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soprano-sdk
-Version: 0.2.2
+Version: 0.2.3
 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.3.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=OHbPYsns2LZEbnqod7H_iW0AE9bdJ_74-EiaAmvOoVc,5644
 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=RbLmKSq65I8q-vFTBFC_dqozvhQ13X_eRh_aHuEkRT0,11259
 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=IsHXb8J-4Dpjcza4zVLLtzQ82NMlZDgXhpNxtoJ6FCg,23567
 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
@@ -27,8 +27,8 @@ soprano_sdk/utils/tool.py,sha256=hWN826HIKmLdswLCTURLH8hWlb2WU0MB8nIUErbpB-8,187
 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/validator.py,sha256=GaCvHvjwVe88Z8yatQsueiPnqtq1oo5uN75gogzpQT0,8940
+soprano_sdk-0.2.3.dist-info/METADATA,sha256=gZasJ2fAEfHIcgd7wKjyPsPUJv0PdTeP5B06eimF03U,11297
+soprano_sdk-0.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+soprano_sdk-0.2.3.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
+soprano_sdk-0.2.3.dist-info/RECORD,,