soprano-sdk 0.1.100__tar.gz → 0.2.0__tar.gz

{soprano_sdk-0.1.100 → soprano_sdk-0.2.0}/PKG-INFO

@@ -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 → soprano_sdk-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "soprano-sdk"
-version = "0.1.100"
+version = "0.2.0"
 description = "YAML-driven workflow engine with AI agent integration for building conversational SOPs"
 readme = "README.md"
 requires-python = ">=3.12"

soprano_sdk-0.2.0/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-0.1.100 → soprano_sdk-0.2.0}/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-0.1.100 → soprano_sdk-0.2.0}/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-0.1.100 → soprano_sdk-0.2.0}/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-0.1.100 → soprano_sdk-0.2.0}/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}")