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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soprano-sdk
-Version: 0.1.100
+Version: 0.2.1
 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.1}/pyproject.toml

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

soprano_sdk-0.2.1/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="soprano_sdk.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="soprano_sdk.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.1}/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.1}/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.1}/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.1}/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-0.1.100 → soprano_sdk-0.2.1}/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-0.1.100 → soprano_sdk-0.2.1}/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-0.1.100 → soprano_sdk-0.2.1}/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-0.1.100 → soprano_sdk-0.2.1}/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-0.1.100 → soprano_sdk-0.2.1}/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 → soprano_sdk-0.2.1}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.12"
 resolution-markers = [
     "python_full_version >= '3.13'",
@@ -704,6 +704,72 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a7/06/3d6badcf13db419e25b07041d9c7b4a2c331d3f4e7134445ec5df57714cd/coloredlogs-15.0.1-py2.py3-none-any.whl", hash = "sha256:612ee75c546f53e92e70049c9dbfcc18c935a2b9a53b66085ce9ef6a6e5c0934", size = 46018, upload-time = "2021-06-11T10:22:42.561Z" },
 ]
 
+[[package]]
+name = "conversational-sop-framework"
+version = "0.1.83"
+source = { editable = "." }
+dependencies = [
+    { name = "agno" },
+    { name = "crewai" },
+    { name = "jsonschema" },
+    { name = "langchain" },
+    { name = "langchain-community" },
+    { name = "langchain-core" },
+    { name = "langchain-openai" },
+    { name = "langfuse" },
+    { name = "langgraph" },
+    { name = "openai" },
+    { name = "pydantic" },
+    { name = "pydantic-ai" },
+    { name = "pyyaml" },
+]
+
+[package.optional-dependencies]
+dev = [
+    { name = "gradio" },
+    { name = "pytest" },
+]
+persistence = [
+    { name = "langgraph-checkpoint-mongodb" },
+    { name = "pymongo" },
+]
+supervisors = [
+    { name = "crewai" },
+    { name = "langchain-openai" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "conversational-sop-framework" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "agno", specifier = ">=2.0.7" },
+    { name = "crewai", specifier = ">=0.186.1" },
+    { name = "crewai", marker = "extra == 'supervisors'", specifier = ">=0.1.0" },
+    { name = "gradio", marker = "extra == 'dev'", specifier = ">=5.46.0" },
+    { name = "jsonschema", specifier = ">=4.0.0" },
+    { name = "langchain", specifier = ">=1.0.7" },
+    { name = "langchain-community", specifier = ">=0.4.1" },
+    { name = "langchain-core", specifier = ">=0.3.67" },
+    { name = "langchain-openai", specifier = ">=1.0.3" },
+    { name = "langchain-openai", marker = "extra == 'supervisors'", specifier = ">=0.3.34" },
+    { name = "langfuse", specifier = ">=3.10.1" },
+    { name = "langgraph", specifier = "==1.0.2" },
+    { name = "langgraph-checkpoint-mongodb", marker = "extra == 'persistence'", specifier = ">=0.2.0" },
+    { name = "openai", specifier = ">=1.92.1" },
+    { name = "pydantic", specifier = ">=2.0.0" },
+    { name = "pydantic-ai", specifier = ">=1.22.0" },
+    { name = "pymongo", marker = "extra == 'persistence'", specifier = ">=4.0.0" },
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" },
+    { name = "pyyaml", specifier = ">=6.0" },
+]
+provides-extras = ["dev", "persistence", "supervisors"]
+
+[package.metadata.requires-dev]
+dev = [{ name = "conversational-sop-framework", editable = "." }]
+
 [[package]]
 name = "crewai"
 version = "1.4.1"
@@ -4227,74 +4293,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
 ]
 
-[[package]]
-name = "soprano-sdk"
-version = "0.1.99"
-source = { editable = "." }
-dependencies = [
-    { name = "agno" },
-    { name = "crewai" },
-    { name = "jsonschema" },
-    { name = "langchain" },
-    { name = "langchain-community" },
-    { name = "langchain-core" },
-    { name = "langchain-openai" },
-    { name = "langfuse" },
-    { name = "langgraph" },
-    { name = "openai" },
-    { name = "pydantic" },
-    { name = "pydantic-ai" },
-    { name = "pytest" },
-    { name = "pyyaml" },
-]
-
-[package.optional-dependencies]
-dev = [
-    { name = "gradio" },
-    { name = "pytest" },
-]
-persistence = [
-    { name = "langgraph-checkpoint-mongodb" },
-    { name = "pymongo" },
-]
-supervisors = [
-    { name = "crewai" },
-    { name = "langchain-openai" },
-]
-
-[package.dev-dependencies]
-dev = [
-    { name = "soprano-sdk" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "agno", specifier = ">=2.0.7" },
-    { name = "crewai", specifier = ">=0.186.1" },
-    { name = "crewai", marker = "extra == 'supervisors'", specifier = ">=0.1.0" },
-    { name = "gradio", marker = "extra == 'dev'", specifier = ">=5.46.0" },
-    { name = "jsonschema", specifier = ">=4.0.0" },
-    { name = "langchain", specifier = ">=1.0.7" },
-    { name = "langchain-community", specifier = ">=0.4.1" },
-    { name = "langchain-core", specifier = ">=0.3.67" },
-    { name = "langchain-openai", specifier = ">=1.0.3" },
-    { name = "langchain-openai", marker = "extra == 'supervisors'", specifier = ">=0.3.34" },
-    { name = "langfuse", specifier = ">=3.10.1" },
-    { name = "langgraph", specifier = "==1.0.2" },
-    { name = "langgraph-checkpoint-mongodb", marker = "extra == 'persistence'", specifier = ">=0.2.0" },
-    { name = "openai", specifier = ">=1.92.1" },
-    { name = "pydantic", specifier = ">=2.0.0" },
-    { name = "pydantic-ai", specifier = ">=1.22.0" },
-    { name = "pymongo", marker = "extra == 'persistence'", specifier = ">=4.0.0" },
-    { name = "pytest", specifier = ">=9.0.1" },
-    { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" },
-    { name = "pyyaml", specifier = ">=6.0" },
-]
-provides-extras = ["dev", "persistence", "supervisors"]
-
-[package.metadata.requires-dev]
-dev = [{ name = "soprano-sdk", editable = "." }]
-
 [[package]]
 name = "sqlalchemy"
 version = "2.0.44"