soprano-sdk 0.1.100__py3-none-any.whl → 0.2.0__py3-none-any.whl

soprano_sdk/authenticators/mfa.py

@@ -0,0 +1,153 @@
+import requests
+from typing import TypedDict, Literal, NotRequired
+from soprano_sdk.core.constants import MFARestAuthorizerEnv
+
+
+class MFAChallenge(TypedDict):
+    value: str
+
+
+class MFAState(TypedDict):
+    challengeType: Literal['OTP', 'dob']
+    post_payload: dict[str, str]
+    otpValue: NotRequired[str]
+    status: Literal['IN_PROGRESS', 'COMPLETED', 'ERRORED', 'FAILED'] | None
+    message: str
+    retry_count: int
+
+
+
+def get_response(response: requests.Response):
+    if response.ok:
+        return response.json(), None
+    else:
+        return None, response.json()
+
+
+def build_path(base_url: str, path: str):
+    return f"{base_url.rstrip('/')}/{path.lstrip('/')}"
+
+
+def enforce_mfa_if_required(state: dict):
+    _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']}"}
+    )
+    _, error = get_response(generate_token_response)
+
+    challenge_type = error['additionalData']['challengeType']
+    _mfa['challengeType'] = challenge_type
+    _mfa['status'] = 'IN_PROGRESS'
+    _mfa['retry_count'] = 0
+    _mfa['message'] = f"Please enter the {challenge_type}"
+    if delivery_methods := error['additionalData'].get(f"{challenge_type.lower()}SentTo"):
+        _mfa['message'] += f" sent via {','.join(delivery_methods)}"
+    return False
+
+
+def mfa_validate_user_input(**state: dict):
+    _mfa : MFAState = state['_mfa']
+    input_field_name = state['_active_input_field']
+    if not state[input_field_name]:
+        return False
+
+    post_payload = _mfa['post_payload']
+    challenge_field_name = f"{_mfa['challengeType'].lower()}Challenge"
+    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']}"}
+    )
+    _mfa['retry_count'] += 1
+    response, error = get_response(validate_token_response)
+    if error:
+        if _mfa['retry_count'] == 1:
+            _mfa['status'] = 'ERRORED'
+            _mfa['message'] = (
+                f"You Have Entered Invalid {_mfa['challengeType']}. {_mfa['message']}"
+            )
+        return False
+
+    if response and 'token' in response:
+        token = response['token']
+        post_payload['token'] = token
+
+        authorize = requests.post(
+            build_path(
+                base_url=MFARestAuthorizerEnv.AUTHORIZE_TOKEN_BASE_URL.get_from_env(),
+                path=MFARestAuthorizerEnv.AUTHORIZE_TOKEN_PATH.get_from_env()
+            ),
+            json=post_payload,
+            timeout=30,
+            headers={"Authorization": f"Bearer {state['bearer_token']}"}
+        )
+        if authorize.status_code == 204:
+            _mfa['status'] = 'COMPLETED'
+            return True
+        else:
+            _mfa['status'] = 'FAILED'
+            return False
+
+
+class MFANodeConfig:
+
+    @classmethod
+    def get_call_function_template(cls, source_node: str, next_node: str, mfa: dict):
+        return dict(
+            id=f"{source_node}_mfa_start",
+            action="call_function",
+            function="conversational_sop.authenticators.mfa.enforce_mfa_if_required",
+            output=f"{source_node}_mfa_start",
+            mfa=mfa,
+            transitions=[
+                dict(
+                    condition=True,
+                    next=source_node,
+                ),
+                dict(
+                    condition=False,
+                    next=next_node,
+                ),
+            ]
+        )
+
+    @classmethod
+    def get_validate_user_input(cls, source_node: str, next_node: str, model_name: str):
+        input_field_name = f"{source_node}_mfa_input"
+        return 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,
+            validator="conversational_sop.authenticators.mfa.mfa_validate_user_input",
+            agent=dict(
+                name="MFA Input Data Collector",
+                model=model_name,
+                initial_message="{{_mfa.message}}",
+                instructions="""
+                    You are an authentication value extractor. Your job is to identify and extract MFA codes from user input.
+
+                    **Task:**
+                    - Read the user's message
+                    - Extract ONLY the OTP code value
+                    - Output in the exact format shown below
+
+                    **Output Format:**
+                    MFA_CAPTURED:
+
+            """),
+            transitions=[
+                dict(
+                    pattern="MFA_CAPTURED:",
+                    next=next_node
+                )
+            ]
+        )

soprano_sdk/core/constants.py

@@ -1,3 +1,4 @@
+import os
 from enum import Enum
 
 
@@ -57,3 +58,19 @@ DEFAULT_TIMEOUT = 300
 
 MAX_ATTEMPTS_MESSAGE = "I'm having trouble understanding your {field}. Please contact customer service for assistance."
 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)

soprano_sdk/core/engine.py

@@ -15,9 +15,10 @@ from ..utils.function import FunctionRepository
 from ..utils.logger import logger
 from ..utils.tool import ToolRepository
 from ..validation import validate_workflow
-
+from soprano_sdk.authenticators.mfa import MFANodeConfig
 
 class WorkflowEngine:
+
     def __init__(self, yaml_path: str, configs: dict):
         self.yaml_path = yaml_path
         self.configs = configs or {}
@@ -33,14 +34,16 @@ class WorkflowEngine:
             self.workflow_name = self.config['name']
             self.workflow_description = self.config['description']
             self.workflow_version = self.config['version']
-            self.data_fields = self.config['data']
-            self.steps = self.config['steps']
+            self.mfa_node_indexes: list[int] = []
+            self.steps: list = self.load_steps()
+            self.step_map = {step['id']: step for step in self.steps}
+            self.data_fields = self.load_data()
+
             self.outcomes = self.config['outcomes']
             self.metadata = self.config.get('metadata', {})
 
             self.StateType = create_state_model(self.data_fields)
 
-            self.step_map = {step['id']: step for step in self.steps}
             self.outcome_map = {outcome['id']: outcome for outcome in self.outcomes}
 
             self.function_repository = FunctionRepository()
@@ -196,6 +199,51 @@ class WorkflowEngine:
         return tool_config.get('usage_policy')
 
 
+    def load_steps(self):
+        prepared_steps: list = []
+        previous_step: dict | None = None
+        for step in self.config['steps']:
+            step_id = step['id']
+
+            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
+                )
+                mfa_start = MFANodeConfig.get_call_function_template(
+                    source_node=step_id,
+                    next_node=mfa_data_collector['id'],
+                    mfa=mfa_config
+                )
+                prepared_steps.append(mfa_start)
+                prepared_steps.append(mfa_data_collector)
+                self.mfa_node_indexes.append(len(prepared_steps) - 1)
+
+                if previous_step and previous_step.get('transitions'):
+                    for transition in previous_step.get('transitions'):
+                        if transition.get('next') == step_id:
+                            transition['next'] = mfa_start['id']
+
+                del step['mfa']
+
+            prepared_steps.append(step)
+            previous_step = step
+        return prepared_steps
+
+    def load_data(self):
+        data: list = self.config['data']
+        for mfa_node_index in self.mfa_node_indexes:
+            data.append(
+                dict(
+                    name=f'{self.steps[mfa_node_index]['field']}',
+                    type='text',
+                    description='Input Recieved from the user during MFA'
+                )
+            )
+
+        return data
+
+
 def load_workflow(yaml_path: str, checkpointer=None, config=None) -> Tuple[CompiledStateGraph, WorkflowEngine]:
     """
     Load a workflow from YAML configuration.

soprano_sdk/core/state.py

@@ -47,6 +47,8 @@ def create_state_model(data_fields: List[dict]):
     fields['_node_field_map'] = Annotated[Dict[str, str], replace]
     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_input'] = Annotated[Optional[Dict[str, str]], replace]
 
     return types.new_class('WorkflowState', (TypedDict,), {}, lambda ns: ns.update({'__annotations__': fields}))
 
@@ -61,7 +63,13 @@ def initialize_state(state: Dict[str, Any]) -> Dict[str, Any]:
         '_node_execution_order': [],
         '_node_field_map': {},
         '_computed_fields': [],
-        'error': None
+        'error': None,
+        '_mfa': {
+            'retry_count': 0,
+            'challengeType': None,
+            'status': None,
+            'message': None,
+        }
     }
 
     for field_name, default_value in fields_to_initialize.items():

soprano_sdk/nodes/base.py

@@ -18,10 +18,15 @@ class ActionStrategy(ABC):
     def execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
         pass
 
+    @abstractmethod
+    def pre_execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+
     def get_node_function(self) -> Callable[[Dict[str, Any]], Dict[str, Any]]:
         def node_fn(state: Dict[str, Any]) -> Dict[str, Any]:
             logger.info(f"Executing node: {self.step_id} (action: {self.action})")
             try:
+                self.pre_execute(state)
                 result = self.execute(state)
                 logger.info(f"Node {self.step_id} completed successfully")
                 logger.info(f"Result: {result}")

soprano_sdk/nodes/call_api.py

@@ -0,0 +1,651 @@
+# # api_response_handler.py
+# import re
+# import os
+# import json
+# import time
+# from typing import Any, Dict, List, Optional, Union, Callable
+# from dataclasses import dataclass
+# from enum import Enum
+# import requests
+# from requests.adapters import HTTPAdapter
+# from urllib3.util.retry import Retry
+# import importlib
+# import operator
+
+# class ErrorSeverity(Enum):
+#     """Error severity levels"""
+
+#     INFO = "info"
+#     WARNING = "warning"
+#     ERROR = "error"
+#     CRITICAL = "critical"
+
+
+# @dataclass
+# class APIError:
+#     """Structured API error"""
+
+#     step_id: str
+#     status_code: int
+#     error_code: Optional[str] = None
+#     message: str = ""
+#     severity: ErrorSeverity = ErrorSeverity.ERROR
+#     response_data: Optional[Dict] = None
+#     retry_after: Optional[int] = None
+
+#     def to_dict(self) -> Dict[str, Any]:
+#         return {
+#             "error": True,
+#             "step_id": self.step_id,
+#             "status_code": self.status_code,
+#             "error_code": self.error_code,
+#             "message": self.message,
+#             "severity": self.severity.value,
+#             "response_data": self.response_data,
+#             "retry_after": self.retry_after,
+#         }
+
+
+# class ValueResolver:
+#     """Resolves references and variables in values"""
+
+#     @staticmethod
+#     def resolve(value: Any, state: Dict[str, Any]) -> Any:
+#         """Resolve a value with state context"""
+#         if not isinstance(value, str):
+#             return value
+
+#         # Handle ${env.VAR_NAME}
+#         value = ValueResolver._resolve_env_vars(value)
+
+#         # Handle ${timestamp}
+#         if "${timestamp}" in value:
+#             value = value.replace("${timestamp}", str(int(time.time())))
+
+#         # Handle {state.variable} or {variable.nested.path}
+#         value = ValueResolver._resolve_state_references(value, state)
+
+#         return value
+
+#     @staticmethod
+#     def _resolve_env_vars(value: str) -> str:
+#         """Resolve environment variables"""
+#         env_pattern = r"\$\{env\.([^}]+)\}"
+#         matches = re.findall(env_pattern, value)
+#         for match in matches:
+#             env_value = os.environ.get(match, "")
+#             value = value.replace(f"${{env.{match}}}", env_value)
+#         return value
+
+#     @staticmethod
+#     def _resolve_state_references(value: str, state: Dict[str, Any]) -> str:
+#         """Resolve state references like {username} or {user.profile.name}"""
+#         pattern = r"\{([^}]+)\}"
+#         matches = re.findall(pattern, value)
+
+#         for match in matches:
+#             resolved = ValueResolver._extract_nested_value(state, match)
+#             if resolved is not None:
+#                 value = value.replace(f"{{{match}}}", str(resolved))
+
+#         return value
+
+#     @staticmethod
+#     def _extract_nested_value(data: Any, path: str) -> Any:
+#         """Extract value from nested structure using dot notation"""
+#         parts = path.split(".")
+#         result = data
+
+#         for part in parts:
+#             if isinstance(result, dict):
+#                 result = result.get(part)
+#             elif isinstance(result, list) and part.isdigit():
+#                 try:
+#                     result = result[int(part)]
+#                 except (IndexError, ValueError):
+#                     return None
+#             else:
+#                 return None
+
+#             if result is None:
+#                 return None
+
+#         return result
+
+
+# class ConditionEvaluator:
+#     OPERATORS = {
+#         "==": operator.eq,
+#         "!=": operator.ne,
+#         ">": operator.gt,
+#         "<": operator.lt,
+#         ">=": operator.ge,
+#         "<=": operator.le,
+#         "contains": lambda a, b: b in str(a) if a is not None else False,
+#         "not_contains": lambda a, b: b not in str(a) if a is not None else True,
+#         "in": lambda a, b: a in b if isinstance(b, (list, tuple)) else False,
+#         "not_in": lambda a, b: a not in b if isinstance(b, (list, tuple)) else True,
+#         "starts_with": (
+#             lambda a, b: str(a).startswith(str(b))
+#             if a is not None else False
+#         ),
+#         "ends_with": lambda a, b: str(a).endswith(str(b)) if a is not None else False,
+#         "is_null": lambda a, b: a is None,
+#         "is_not_null": lambda a, b: a is not None,
+#         "is_empty": lambda a, b: not a if isinstance(a, (list, dict, str)) else False,
+#         "is_not_empty": (
+#             lambda a, b: bool(a)
+#             if isinstance(a, (list, dict, str)) else False
+#         ),
+#     }
+
+#     @staticmethod
+#     def evaluate(
+#         condition: Dict[str, Any], response: Dict[str, Any], state: Dict[str, Any]) -> bool:
+
+#         if "status_code" in condition:
+#             expected = condition["status_code"]
+#             actual = response.get("status")
+
+#             if isinstance(expected, list):
+#                 if actual not in expected:
+#                     return False
+#             elif actual != expected:
+#                 return False
+
+#         if "field" in condition:
+#             field_path = condition["field"]
+#             operator = condition.get("operator", "==")
+#             expected_value = condition.get("value")
+
+#             actual_value = ValueResolver._extract_nested_value(response, field_path)
+
+#             if isinstance(expected_value, str):
+#                 expected_value = ValueResolver.resolve(expected_value, state)
+
+#             if operator not in ConditionEvaluator.OPERATORS:
+#                 raise ValueError(f"Unknown operator: {operator}")
+
+#             return ConditionEvaluator.OPERATORS[operator](actual_value, expected_value)
+
+#         if "and" in condition:
+#             return all(
+#                 ConditionEvaluator.evaluate(sub_cond, response, state)
+#                 for sub_cond in condition["and"]
+#             )
+
+#         if "or" in condition:
+#             return any(
+#                 ConditionEvaluator.evaluate(sub_cond, response, state)
+#                 for sub_cond in condition["or"]
+#             )
+
+#         return True
+
+#     @staticmethod
+#     def evaluate_all(
+#         conditions: List[Dict[str, Any]],
+#         response: Dict[str, Any],
+#         state: Dict[str, Any],
+#     ) -> Optional[Dict[str, Any]]:
+#         """Find first matching condition from a list"""
+#         for condition in conditions:
+#             # Skip default conditions for now
+#             if condition.get("default"):
+#                 continue
+
+#             if ConditionEvaluator.evaluate(condition, response, state):
+#                 return condition
+
+#         # Return default if no match
+#         for condition in conditions:
+#             if condition.get("default"):
+#                 return condition
+
+#         return None
+
+
+# class ResponseMapper:
+#     """Maps response data to state variables"""
+
+#     @staticmethod
+#     def apply_mappings(
+#         response: Dict[str, Any], mappings: List[Dict[str, Any]], state: Dict[str, Any]
+#     ) -> None:
+#         """Apply response mappings to state"""
+#         for mapping in mappings:
+#             from_path = mapping.get("from", "")
+#             to_field = mapping.get("to", "")
+#             transform = mapping.get("transform")  # Optional transformation function
+#             default = mapping.get("default")  # Default value if extraction fails
+
+#             # Extract value
+#             value = ValueResolver._extract_nested_value(response, from_path)
+
+#             # Apply default if needed
+#             if value is None and default is not None:
+#                 value = default
+
+#             # Apply transformation if specified
+#             if value is not None and transform:
+#                 value = ResponseMapper._apply_transform(value, transform, state)
+
+#             # Store in state
+#             if to_field:
+#                 state[to_field] = value
+
+#     @staticmethod
+#     def _apply_transform(
+#         value: Any, transform: Union[str, Dict], state: Dict[str, Any]
+#     ) -> Any:
+#         """Apply transformation to a value"""
+#         if isinstance(transform, str):
+#             # Simple transformations
+#             if transform == "lowercase":
+#                 return str(value).lower()
+#             elif transform == "uppercase":
+#                 return str(value).upper()
+#             elif transform == "trim":
+#                 return str(value).strip()
+#             elif transform == "int":
+#                 return int(value)
+#             elif transform == "float":
+#                 return float(value)
+#             elif transform == "bool":
+#                 return bool(value)
+#             elif transform == "json":
+#                 return json.loads(value) if isinstance(value, str) else value
+
+#         elif isinstance(transform, dict):
+#             # Function-based transformation
+#             if "function" in transform:
+#                 func_path = transform["function"]
+#                 func_args = transform.get("args", {})
+
+#                 # Resolve arguments
+#                 resolved_args = {
+#                     k: ValueResolver.resolve(v, state) for k, v in func_args.items()
+#                 }
+#                 resolved_args["value"] = value
+
+#                 # Execute transformation function
+#                 return FunctionExecutor.execute_transform(func_path, resolved_args)
+
+#         return value
+
+
+# class ErrorHandler:
+#     """Handles API errors with configurable responses"""
+
+#     @staticmethod
+#     def handle_error(
+#         step_id: str,
+#         response: Dict[str, Any],
+#         error_config: Dict[str, Any],
+#         state: Dict[str, Any],
+#     ) -> APIError:
+#         """Handle an error based on configuration"""
+#         status_code = response.get("status", 0)
+
+#         message = error_config.get("message", "An error occurred")
+#         message = ValueResolver.resolve(message, {**state, "response": response})
+
+#         error_code_path = error_config.get("error_code_field", "error_code")
+#         error_code = ValueResolver._extract_nested_value(
+#             response, f"data.{error_code_path}"
+#         )
+
+#         severity_str = error_config.get("severity", "error")
+#         severity = ErrorSeverity(severity_str)
+
+#         retry_after = error_config.get("retry_after")
+#         if retry_after:
+#             retry_after = ValueResolver.resolve(retry_after, state)
+
+#         return APIError(
+#             step_id=step_id,
+#             status_code=status_code,
+#             error_code=error_code,
+#             message=message,
+#             severity=severity,
+#             response_data=response.get("data"),
+#             retry_after=retry_after,
+#         )
+
+
+# class PostProcessor:
+#     """Handles post-processing of API responses"""
+
+#     @staticmethod
+#     def process(
+#         response: Dict[str, Any], post_config: Dict[str, Any], state: Dict[str, Any]
+#     ) -> Any:
+#         """Execute post-processing on response"""
+#         function_path = post_config.get("function")
+#         inputs = post_config.get("inputs", {})
+#         output_field = post_config.get("output")
+
+#         resolved_inputs = {"response": response}
+#         for key, value in inputs.items():
+#             resolved_inputs[key] = ValueResolver.resolve(value, state)
+
+#         result = FunctionExecutor.execute(function_path, resolved_inputs)
+
+#         if output_field:
+#             state[output_field] = result
+
+#         return result
+
+
+# class FunctionExecutor:
+#     """Executes functions from module paths"""
+
+#     @staticmethod
+#     def execute(function_path: str, inputs: Dict[str, Any]) -> Any:
+#         """Execute a function given its module path"""
+#         try:
+#             # Parse module and function name
+#             parts = function_path.rsplit(".", 1)
+#             if len(parts) != 2:
+#                 raise ValueError(f"Invalid function path: {function_path}")
+
+#             module_name, function_name = parts
+
+#             module = importlib.import_module(module_name)
+#             function = getattr(module, function_name)
+
+#             return function(**inputs)
+
+#         except Exception as e:
+#             raise Exception(f"Failed to execute function {function_path}: {str(e)}")
+
+#     @staticmethod
+#     def execute_transform(function_path: str, inputs: Dict[str, Any]) -> Any:
+#         """Execute a transformation function"""
+#         return FunctionExecutor.execute(function_path, inputs)
+
+
+# class APIClient:
+#     """Handles API requests with comprehensive error handling"""
+
+#     def __init__(self, config: Dict[str, Any]):
+#         self.name = config.get("name")
+#         self.base_url = ValueResolver._resolve_env_vars(config.get("base_url", ""))
+#         self.headers = self._resolve_headers(config.get("headers", {}))
+#         self.timeout = config.get("timeout", 30)
+#         self.retry_config = config.get("retry", {})
+
+#         self.session = self._create_session()
+
+#     def _resolve_headers(self, headers: Dict[str, str]) -> Dict[str, str]:
+#         """Resolve all header values"""
+#         return {k: ValueResolver._resolve_env_vars(v) for k, v in headers.items()}
+
+#     def _create_session(self) -> requests.Session:
+#         """Create requests session with retry logic"""
+#         session = requests.Session()
+
+#         if self.retry_config:
+#             retry_strategy = Retry(
+#                 total=self.retry_config.get("max_attempts", 3),
+#                 backoff_factor=1 if self.retry_config.get("backoff") == "exponential" else 0,
+#                 status_forcelist=self.retry_config.get("for_status_codes", [429, 500, 502, 503, 504]),
+#             )
+#             adapter = HTTPAdapter(max_retries=retry_strategy)
+#             session.mount("http://", adapter)
+#             session.mount("https://", adapter)
+
+#         return session
+
+#     def execute(
+#         self,
+#         request_config: Dict[str, Any],
+#         state: Dict[str, Any],
+#         step_id: str = "api_call",
+#     ) -> Dict[str, Any]:
+#         """Execute API request with full error handling"""
+
+#         method = request_config.get("method", "GET").upper()
+#         path = self._prepare_path(request_config, state)
+#         url = f"{self.base_url}{path}"
+
+#         query_params = self._prepare_params(
+#             request_config.get("query_params", {}), state
+#         )
+#         headers = self._prepare_headers(request_config, state)
+#         body = self._prepare_body(request_config, state)
+
+#         try:
+#             response = self.session.request(
+#                 method=method,
+#                 url=url,
+#                 headers=headers,
+#                 params=query_params,
+#                 json=body if request_config.get("body_type", "json") == "json" else None,
+#                 data=body if request_config.get("body_type") != "json" else None,
+#                 timeout=self.timeout,
+#             )
+
+#             try:
+#                 response_data = response.json()
+#             except:
+#                 response_data = {"raw": response.text}
+
+#             return {
+#                 "status": response.status_code,
+#                 "data": response_data,
+#                 "headers": dict(response.headers),
+#                 "success": response.ok,
+#                 "url": url,
+#                 "method": method,
+#             }
+
+#         except requests.exceptions.Timeout:
+#             return {
+#                 "status": 0,
+#                 "error": "Request timeout",
+#                 "error_type": "timeout",
+#                 "success": False,
+#             }
+#         except requests.exceptions.ConnectionError:
+#             return {
+#                 "status": 0,
+#                 "error": "Connection error",
+#                 "error_type": "connection",
+#                 "success": False,
+#             }
+#         except requests.exceptions.RequestException as e:
+#             return {
+#                 "status": 0,
+#                 "error": str(e),
+#                 "error_type": "request",
+#                 "success": False,
+#             }
+
+#     def _prepare_path(
+#         self, request_config: Dict[str, Any], state: Dict[str, Any]
+#     ) -> str:
+#         """Prepare URL path with variable substitution"""
+#         path = request_config.get("path", "")
+#         path_params = request_config.get("path_params", {})
+
+#         for key, value in path_params.items():
+#             resolved_value = ValueResolver.resolve(value, state)
+#             path = path.replace(f"{{{key}}}", str(resolved_value))
+
+#         return path
+
+#     def _prepare_params(
+#         self, params: Dict[str, Any], state: Dict[str, Any]
+#     ) -> Dict[str, Any]:
+#         """Prepare query parameters"""
+#         return {k: ValueResolver.resolve(v, state) for k, v in params.items()}
+
+#     def _prepare_headers(
+#         self, request_config: Dict[str, Any], state: Dict[str, Any]
+#     ) -> Dict[str, str]:
+#         """Prepare request headers"""
+#         headers = {**self.headers}
+
+#         if "headers" in request_config:
+#             for key, value in request_config["headers"].items():
+#                 headers[key] = ValueResolver.resolve(value, state)
+
+#         return headers
+
+#     def _prepare_body(
+#         self, request_config: Dict[str, Any], state: Dict[str, Any]
+#     ) -> Optional[Dict[str, Any]]:
+#         """Prepare request body"""
+#         if "body" not in request_config:
+#             return None
+
+#         body = request_config["body"]
+#         return self._resolve_dict(body, state)
+
+#     def _resolve_dict(
+#         self, data: Dict[str, Any], state: Dict[str, Any]
+#     ) -> Dict[str, Any]:
+#         """Recursively resolve dictionary values"""
+#         result = {}
+#         for key, value in data.items():
+#             if isinstance(value, dict):
+#                 result[key] = self._resolve_dict(value, state)
+#             elif isinstance(value, list):
+#                 result[key] = [
+#                     self._resolve_dict(item, state)
+#                     if isinstance(item, dict)
+#                     else ValueResolver.resolve(item, state)
+#                     for item in value
+#                 ]
+#             else:
+#                 result[key] = ValueResolver.resolve(value, state)
+#         return result
+
+
+# class APIResponseHandler:
+#     """Main handler for API responses with error handling and post-processing"""
+
+#     def __init__(self, step_id: str, api_client: APIClient):
+#         self.step_id = step_id
+#         self.api_client = api_client
+
+#     def execute_with_handling(
+#         self,
+#         request_config: Dict[str, Any],
+#         response_config: Dict[str, Any],
+#         state: Dict[str, Any],
+#     ) -> Dict[str, Any]:
+#         """Execute API call with full response handling"""
+
+#         response = self.api_client.execute(request_config, state, self.step_id)
+
+#         error_handlers = response_config.get("error_handlers", [])
+#         error = self._check_errors(response, error_handlers, state)
+
+#         if error:
+#             return error.to_dict()
+
+#         mappings = response_config.get("mappings", [])
+#         if mappings:
+#             ResponseMapper.apply_mappings(response, mappings, state)
+
+#         if "post_process" in response_config:
+#             post_result = PostProcessor.process(
+#                 response, response_config["post_process"], state
+#             )
+
+#         conditions = response_config.get("conditions", [])
+#         if conditions:
+#             matching_condition = ConditionEvaluator.evaluate_all(
+#                 conditions, response, state
+#             )
+
+#             if matching_condition:
+#                 if "mappings" in matching_condition:
+#                     ResponseMapper.apply_mappings(
+#                         response, matching_condition["mappings"], state
+#                     )
+
+#                 if "next" in matching_condition:
+#                     state["_next_step"] = matching_condition["next"]
+
+#                 if "action" in matching_condition:
+#                     state["_action"] = matching_condition["action"]
+
+#         return {"success": True, "response": response, "state": state}
+
+#     def _check_errors(
+#         self,
+#         response: Dict[str, Any],
+#         error_handlers: List[Dict[str, Any]],
+#         state: Dict[str, Any],
+#     ) -> Optional[APIError]:
+#         for error_config in error_handlers:
+#             # Evaluate error condition
+#             if ConditionEvaluator.evaluate(error_config, response, state):
+#                 return ErrorHandler.handle_error(
+#                     self.step_id, response, error_config, state
+#                 )
+
+#         return None
+
+
+# # Example usage
+# if __name__ == "__main__":
+#     # Example configuration
+#     api_config = {
+#         "name": "user_service",
+#         "base_url": "https://api.example.com",
+#         "headers": {
+#             "Authorization": "Bearer ${env.API_TOKEN}",
+#             "Content-Type": "application/json",
+#         },
+#         "timeout": 30,
+#     }
+
+#     request_config = {
+#         "method": "GET",
+#         "path": "/users/{user_id}",
+#         "path_params": {"user_id": "{user_id}"},
+#     }
+
+#     response_config = {
+#         "mappings": [
+#             {"from": "data.name", "to": "user_name"},
+#             {"from": "data.email", "to": "user_email"},
+#         ],
+#         "error_handlers": [
+#             {
+#                 "status_code": 404,
+#                 "field": "data.error_code",
+#                 "operator": "==",
+#                 "value": "ERR_NOT_FOUND",
+#                 "message": "Sorry, we could not find the user you requested",
+#                 "severity": "error",
+#             },
+#             {
+#                 "status_code": 200,
+#                 "field": "data.error_data",
+#                 "operator": "==",
+#                 "value": "ERR_NOT_FOUND",
+#                 "message": "Sorry, we could not find the request",
+#                 "severity": "warning",
+#             },
+#         ],
+#         "post_process": {
+#             "function": "response_processors.format_user_data",
+#             "inputs": {"user_id": "{user_id}"},
+#             "output": "formatted_user",
+#         },
+#     }
+
+#     # Initialize
+#     state = {"user_id": "12345"}
+#     api_client = APIClient(api_config)
+#     handler = APIResponseHandler("fetch_user", api_client)
+
+#     # Execute
+#     result = handler.execute_with_handling(request_config, response_config, state)
+
+#     print(json.dumps(result, indent=2))

soprano_sdk/nodes/call_function.py

@@ -3,9 +3,23 @@ from typing import Dict, Any
 from .base import ActionStrategy
 from ..core.state import set_state_value, get_state_value
 from ..utils.logger import logger
+from jinja2 import Environment
+import uuid
+from ..core.constants import WorkflowKeys
 from ..utils.template import get_nested_value
 
 
+def compile_values(template_loader, state: dict, values: Any):
+    if isinstance(values, dict):
+        return {k: compile_values(template_loader, state, v) for k, v in values.items()}
+    elif isinstance(values, list):
+        return [compile_values(template_loader, state, value) for value in values]
+    elif isinstance(values, str):
+        return template_loader.from_string(values).render(state)
+    else:
+        return values
+
+
 class CallFunctionStrategy(ActionStrategy):
     def __init__(self, step_config: Dict[str, Any], engine_context: Any):
         super().__init__(step_config, engine_context)
@@ -21,6 +35,14 @@ class CallFunctionStrategy(ActionStrategy):
         if not self.output_field:
             raise RuntimeError(f"Step '{self.step_id}' missing required 'output' property")
 
+    def pre_execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
+        if 'mfa' in self.step_config:
+            state['_mfa'] = state.get('_mfa', {})
+            state['_mfa']['post_payload'] = dict(transactionId=str(uuid.uuid4()))
+            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)
+
     def execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
         from ..utils.tracing import trace_node_execution
         
@@ -58,8 +80,6 @@ class CallFunctionStrategy(ActionStrategy):
 
             if self.output_field:
                 set_state_value(state, self.output_field, result)
-
-                from ..core.constants import WorkflowKeys
                 computed_fields = get_state_value(state, WorkflowKeys.COMPUTED_FIELDS, [])
                 if self.output_field not in computed_fields:
                     computed_fields.append(self.output_field)

soprano_sdk/nodes/collect_input.py

@@ -114,6 +114,9 @@ class CollectInputStrategy(ActionStrategy):
     def _conversation_key(self) -> str:
         return f'{self.field}_conversation'
 
+    def pre_execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
+        state['_active_input_field'] = self.step_config.get('field')
+
     @property
     def _formatted_field_name(self) -> str:
         return self.field.replace('_', ' ').title()

soprano_sdk/tools.py

@@ -4,8 +4,6 @@ Workflow Tools - Wraps workflows as callable tools for agent frameworks
 
 import uuid
 from typing import Optional, Dict, Any
-
-
 from .utils.logger import logger
 
 from langfuse.langchain import CallbackHandler

soprano_sdk/validation/schema.py

@@ -226,7 +226,28 @@ WORKFLOW_SCHEMA = {
                         "minimum": 1,
                         "maximum": 600,
                         "description": "Timeout in seconds"
-                    }
+                    },
+                    "mfa": {
+                        "type": "object",
+                        "description": "Multi-factor authentication configuration",
+                        "required": ["type", "model", "payload"],
+                        "properties": {
+                            "model": {
+                                "type": "string",
+                                "description": "Path to the model which will be used to parse the MFA input from the user"
+                            },
+                            "type": {
+                                "type": "string",
+                                "enum": ["REST"],
+                                "description": "API type for MFA"
+                            },
+                            "payload": {
+                                "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
+                            }
+                        }
+                    },
                 }
             }
         },

soprano_sdk/validation/validator.py

@@ -3,6 +3,7 @@ from typing import List, Set
 import jsonschema
 
 from .schema import WORKFLOW_SCHEMA
+from soprano_sdk.core.constants import MFARestAuthorizerEnv
 
 
 class ValidationResult:
@@ -64,7 +65,7 @@ class WorkflowValidator:
             if not step_id:
                 self.errors.append(f"Step at index {i} is missing 'id' field")
                 continue
-
+            self._validate_authorizer(step)
             if step_id in step_ids:
                 self.errors.append(f"Duplicate step ID: '{step_id}'")
             step_ids.add(step_id)
@@ -108,9 +109,37 @@ class WorkflowValidator:
                         f"Step '{step_id}' transition {i} references unknown target: '{next_target}'"
                     )
 
+    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"
+            )
+
+        model = mfa_authorizer.get('model')
+        if not model:
+            self.errors.append(f"step({step['id']}) -> mfa -> model is missing")
+
+        _validate_rest_fields()
+
+
     def _validate_data_fields(self):
         data_fields = {field.get('name') for field in self.config.get('data', [])}
         steps = self.config.get('steps', [])
+        has_mfa = False
 
         for step in steps:
             step_id = step.get('id', 'unknown')
@@ -135,6 +164,9 @@ class WorkflowValidator:
                 output = step.get('output')
                 function = step.get('function')
 
+                if step.get('mfa'):
+                    has_mfa = True
+
                 if not function:
                     self.errors.append(f"Step '{step_id}' is missing 'function' property")
 
@@ -145,6 +177,11 @@ class WorkflowValidator:
                         f"Step '{step_id}' output field '{output}' not defined in data fields"
                     )
 
+        if has_mfa and 'bearer_token' not in data_fields:
+            self.errors.append(
+                "`bearer_token` must be defined in `data` section: for MFA authorization"
+            )
+
     def _validate_function_references(self):
         steps = self.config.get('steps', [])
 

{soprano_sdk-0.1.100.dist-info → soprano_sdk-0.2.0.dist-info}/METADATA

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

{soprano_sdk-0.1.100.dist-info → soprano_sdk-0.2.0.dist-info}/RECORD

@@ -1,19 +1,22 @@
 soprano_sdk/__init__.py,sha256=y3c4i7Q7SAPS2Tee7V0TzWdhgMxBWfDJJ98eqD1HxGI,188
 soprano_sdk/engine.py,sha256=EFK91iTHjp72otLN6Kg-yeLye2J3CAKN0QH4FI2taL8,14838
-soprano_sdk/tools.py,sha256=cYEto0cmQ5GZ4zsH_YPfbaaDbzl5aO3rAOm7KlzTFVk,7444
+soprano_sdk/tools.py,sha256=bjJzapnQp31iLDx8jHp_0X2FcS2kY8uqf6hsgD3uDx4,7442
 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=bSUiwN2xH9kJlP4C_YTIOIXhmYb2QObAthL9C6vM238,5248
 soprano_sdk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/core/constants.py,sha256=pEwW_NeHhxs7aG457uiBCs65czAapozY6r9JAegc01Y,1451
-soprano_sdk/core/engine.py,sha256=aN805CtG7TDBkBbIJSbAbLo_5tKqrfve394L_DzZq8s,8347
+soprano_sdk/core/constants.py,sha256=-Ij4bbSDsyxQ_NZ5NiusJeepWhoe13WGuzN3LlnXqWY,2017
+soprano_sdk/core/engine.py,sha256=w1ofIGmBaXBa4UxWwYzRjIdJiCFC6QXqivuo3eESW5M,10085
 soprano_sdk/core/rollback_strategies.py,sha256=NjDTtBCZlqyDql5PSwI9SMDLK7_BNlTxbW_cq_5gV0g,7783
-soprano_sdk/core/state.py,sha256=ICyFhio1VESQxzYNwKrS-gk3QDc0OrwJLQtVnZ9c9LU,2611
+soprano_sdk/core/state.py,sha256=ENf81OOe4C2IEYGWUcaBwJ3O1P6VRg4DVirOXFXjioA,2899
 soprano_sdk/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/nodes/base.py,sha256=bD8P_SLW65yQ1QaCQ5aN8eQCe50sdHh4wdcQzdY6wGA,2218
-soprano_sdk/nodes/call_function.py,sha256=23Q9wUY1F9dLMW2qSAApA8Sw5SyvtS70RBCMhZxvRu0,4506
-soprano_sdk/nodes/collect_input.py,sha256=HrjE-HqRa4vWiKU7GPnYryX1jsvpNBKKeTvbr8srNmY,23002
+soprano_sdk/nodes/base.py,sha256=idFyOGGPnjsASYnrOF_NIh7eFcSuJqw61EoVN_WCTaU,2360
+soprano_sdk/nodes/call_api.py,sha256=9ApkuKMU8en5pQ7SK0yB8eF6KXY_bYV2Q3DkthibizU,22655
+soprano_sdk/nodes/call_function.py,sha256=Quys2Rf2JitV1fnTpnEIpIoCCOQDzhWBriRXO59UqqI,5469
+soprano_sdk/nodes/collect_input.py,sha256=pR4PrQfnufAZmCpN_1T14zBp3rg8BkSWGP7eMSa3pZE,23140
 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
@@ -24,9 +27,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=HzqRp-5rl3GzX5KtFckAbBh8S7zklvQmRERIyfByS2w,13335
-soprano_sdk/validation/validator.py,sha256=l2P24wiCWBNTZ9-dRbgWwK48BGaR1xIdnBxzSCu0RPM,6498
-soprano_sdk-0.1.100.dist-info/METADATA,sha256=zVgLpVjgNQiGmZoF1NQAd7CePTtpasTXFlcaEzyUmAY,11299
-soprano_sdk-0.1.100.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-soprano_sdk-0.1.100.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
-soprano_sdk-0.1.100.dist-info/RECORD,,
+soprano_sdk/validation/schema.py,sha256=R6bm4Pzgx8p08o77FN9FFSKTLTKOCf7WuThrR6rV2FI,14578
+soprano_sdk/validation/validator.py,sha256=mUTweaQyDaPqHWQDlsE9AFwnB3_MQAEOBrj1hwKQK68,7888
+soprano_sdk-0.2.0.dist-info/METADATA,sha256=ovCyWtkIXMfuAvs3-5UttlzCEn7r57ZhUNMfm9C6L2o,11297
+soprano_sdk-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+soprano_sdk-0.2.0.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
+soprano_sdk-0.2.0.dist-info/RECORD,,