soprano-sdk 0.2.10__py3-none-any.whl → 0.2.17__py3-none-any.whl

soprano_sdk/agents/adaptor.py

@@ -6,6 +6,9 @@ from pydantic import BaseModel
 from pydantic_ai.agent import Agent as PydanticAIAgent
 from crewai.agent import Agent as CrewAIAgent
 from ..utils.logger import logger
+import json
+import ast
+
 
 class AgentAdapter(ABC):
     
@@ -20,7 +23,7 @@ class LangGraphAgentAdapter(AgentAdapter):
         self.agent = agent
     
     def invoke(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
-        logger.info("Invoking LangGraph agent with messages")
+        logger.info("Invoking LangGraphAgentAdapter agent with messages")
         response = self.agent.invoke({"messages": messages})
         
         if structured_response := response.get('structured_response'):
@@ -37,23 +40,69 @@ class LangGraphAgentAdapter(AgentAdapter):
 
 
 class CrewAIAgentAdapter(AgentAdapter):
-    
+
     def __init__(self, agent: CrewAIAgent, output_schema: BaseModel):
         self.agent = agent
-        self.output_schema=output_schema
-    
+        self.output_schema = output_schema
+
+    def _convert_to_dict(self, response: Any) -> Dict[str, Any]:
+        """
+        Convert response to dict using 3 strategies:
+        1. Check if already a dict
+        2. Try json.loads()
+        3. Try ast.literal_eval()
+        """
+
+        # Strategy 1: Already a dict
+        if isinstance(response, dict):
+            logger.info("Response is already a dict")
+            return response
+
+        # Convert to string for parsing
+        response_str = str(response)
+
+        # Strategy 2: Try json.loads()
+        try:
+            parsed = json.loads(response_str)
+            logger.info("Successfully parsed with json.loads()")
+            return parsed
+        except (json.JSONDecodeError, ValueError, TypeError) as e:
+            logger.error(f"json.loads() failed: {e}")
+
+        # Strategy 3: Try ast.literal_eval()
+        try:
+            parsed = ast.literal_eval(response_str)
+            if isinstance(parsed, dict):
+                logger.info("Successfully parsed with ast.literal_eval()")
+                return parsed
+        except (ValueError, SyntaxError, TypeError) as e:
+            logger.error(f"ast.literal_eval() failed: {e}")
+
+        # No schema and all parsing failed - return as string
+        logger.error("No schema provided and parsing failed, returning raw response")
+        return response_str
+
     def invoke(self, messages: List[Dict[str, str]]) -> Any:
         try:
-            logger.info("Invoking LangGraph agent with messages")
+            logger.info("Invoking CrewAIAgentAdapter agent with messages")
             result = self.agent.kickoff(messages, response_format=self.output_schema)
 
-            if structured_response := getattr(result, 'pydantic', None) :
+            if structured_response := getattr(result, 'pydantic', None):
+                logger.info("Got pydantic structured response")
                 return structured_response.model_dump()
 
-            if agent_response := getattr(result, 'raw', None) :
+            agent_response = getattr(result, 'raw', None)
+            if agent_response is None:
+                agent_response = str(result)
+
+            logger.info(f"Processing raw response type: {type(agent_response)}")
+
+            if not self.output_schema:
+                logger.info("No output schema provided, returning raw response")
                 return agent_response
-            
-            return str(result)
+
+            return self._convert_to_dict(agent_response)
+
         except Exception as e:
             raise RuntimeError(f"CrewAI agent invocation failed: {e}")
 
@@ -65,7 +114,7 @@ class AgnoAgentAdapter(AgentAdapter):
     
     def invoke(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
         try:
-            logger.info("Invoking LangGraph agent with messages")
+            logger.info("Invoking AgnoAgentAdapter agent with messages")
             response = self.agent.run(messages)
             agent_response = response.content if hasattr(response, 'content') else str(response)
             

soprano_sdk/agents/factory.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Literal, Tuple, Callable
+from typing import Any, Dict, List, Literal, Tuple, Callable, get_origin, get_args
 
 from agno.models.openai import OpenAIChat
 from crewai import LLM
@@ -18,36 +18,41 @@ from .adaptor import (
 
 def get_model(config: Dict[str, Any], framework: Literal['langgraph', 'crewai', 'agno', 'pydantic-ai'] = "langgraph", output_schema: Optional[BaseModel] = None, tools: Optional[List] = None):
     errors = []
-    
+
     model_name: str = config.get("model_name", "")
     if not model_name:
         errors.append("Model name is required in model_config")
-    
+
+    # Determine provider (openai, ollama, etc.)
+    provider = config.get("provider", "openai").lower()
+
+    # Handle base_url - required for Ollama, optional for OpenAI
     base_url = config.get("base_url")
-    if not base_url:
-        errors.append("Base url for model is required in model_config")
-    
     api_key = config.get("api_key", "")
     if not api_key:
         if auth_callback := config.get("auth_callback"):
             api_key = auth_callback()
         if not api_key:
-            errors.append("API key/Auth callback for model is required in model_config")
-    
+            # Ollama doesn't require a real API key
+            if provider == "ollama":
+                api_key = "ollama"
+            else:
+                errors.append("API key/Auth callback for model is required in model_config")
+
     if errors:
         raise ValueError("; ".join(errors))
-    
-    if framework == "agno" :
+
+    if framework == "agno":
         return OpenAIChat(
             id=model_name,
             api_key=api_key,
             base_url=base_url
         )
 
-    if framework == "crewai" :
+    if framework == "crewai":
         return LLM(
             api_key=api_key,
-            model=f"openai/{model_name}",
+            model=f"{provider}/{model_name}",
             base_url=base_url,
             temperature=0.1,
             top_p=0.7
@@ -58,7 +63,6 @@ def get_model(config: Dict[str, Any], framework: Literal['langgraph', 'crewai',
         api_key=SecretStr(api_key),
         base_url=base_url,
     )
-    
     if output_schema:
         return llm.with_structured_output(output_schema)
 
@@ -120,12 +124,77 @@ class CrewAIAgentCreator(AgentCreator):
         structured_output_model: Any = None
     ) -> CrewAIAgentAdapter:
         from crewai.agent import Agent
-        from crewai.tools import tool
+        from crewai.tools import BaseTool
+        from pydantic import Field, create_model
+        from typing import Type
+        import inspect
+
+        def create_crewai_tool(tool_name: str, tool_description: str, tool_callable: Callable) -> Any:
+            """Create a CrewAI tool with proper Pydantic schema for type hints"""
+
+            # Get function signature to build schema
+            sig = inspect.signature(tool_callable)
+
+            # Build Pydantic fields from function parameters
+            schema_fields = {}
+            for param_name, param in sig.parameters.items():
+                # Skip **kwargs and **state parameters - they shouldn't be in the schema
+                # These are used for validators and internal context
+                if param.kind == inspect.Parameter.VAR_KEYWORD:
+                    continue
+
+                # Get parameter annotation, default to str if not specified
+                param_type = param.annotation if param.annotation != inspect.Parameter.empty else str
+
+                # Default description
+                description = f"Parameter: {param_name}"
+
+                # Check if using Annotated type hint for description
+                if get_origin(param_type) is not None:
+                    # Handle Annotated[type, "description", ...]
+                    try:
+                        from typing import Annotated
+                        if get_origin(param_type) is Annotated:
+                            args = get_args(param_type)
+                            param_type = args[0]  # First arg is the actual type
+                            # Look for string metadata as description
+                            for metadata in args[1:]:
+                                if isinstance(metadata, str):
+                                    description = metadata
+                                    break
+                    except ImportError:
+                        # Python < 3.9 doesn't have Annotated in typing
+                        pass
+
+                # Get default value if exists
+                if param.default != inspect.Parameter.empty:
+                    schema_fields[param_name] = (
+                        param_type,
+                        Field(default=param.default, description=description)
+                    )
+                else:
+                    schema_fields[param_name] = (
+                        param_type,
+                        Field(..., description=description)
+                    )
+
+            # Create dynamic Pydantic model for tool input schema
+            ToolInputSchema = create_model(
+                f"{tool_name.title().replace('_', '')}Input",
+                **schema_fields
+            )
+
+            # Create custom BaseTool class with proper schema
+            class CustomCrewAITool(BaseTool):
+                name: str = tool_name
+                description: str = tool_description
+                args_schema: Type[BaseModel] = ToolInputSchema
+
+                def _run(self, **kwargs) -> str:
+                    return tool_callable(**kwargs)
+
+            return CustomCrewAITool()
 
-        def create_crewai_tool(tool_name: str, description: str, tool_callable: Callable) -> Any:
-            tool_callable.__doc__ = description
-            return tool(tool_name)(tool_callable)
-        
         tools = [create_crewai_tool(tn, desc, tc) for tn, desc, tc in tools]
 
         agent = Agent(
@@ -136,7 +205,7 @@ class CrewAIAgentCreator(AgentCreator):
             llm=get_model(model_config, 'crewai'),
             max_retry_limit=2
         )
-        
+
         return CrewAIAgentAdapter(agent, output_schema=structured_output_model)
 
 

soprano_sdk/authenticators/mfa.py

@@ -137,7 +137,47 @@ class MFANodeConfig:
 
     @classmethod
     def get_validate_user_input(cls, source_node: str, next_node: str, mfa_config: dict):
-        model_name = mfa_config['model']
+        agent_config = dict(
+            name="MFA Input Data Collector",
+            initial_message="{{_mfa.message}}",
+            instructions="""
+                You are an authentication value extractor. Your job is to identify and extract MFA codes from user input, or detect if the user wants to cancel the authentication flow.
+
+                **Task:**
+                - Read the user's message carefully
+                - First, check if the user wants to cancel, stop, or exit the authentication process
+                - If they want to cancel, output: MFA_CANCELLED:
+                - Otherwise, extract ONLY the OTP/MFA code value and output in the format shown below
+
+                **Cancellation Detection:**
+                If the user expresses any intent to cancel, stop, exit, abort, or quit the authentication process, respond with: MFA_CANCELLED
+
+                Examples of cancellation phrases:
+                * "cancel" → MFA_CANCELLED:
+                * "I want to stop" → MFA_CANCELLED:
+                * "exit" → MFA_CANCELLED:
+                * "nevermind" → MFA_CANCELLED:
+                * "I don't want to continue" → MFA_CANCELLED:
+                * "stop this" → MFA_CANCELLED:
+                * "forget it" → MFA_CANCELLED:
+                * "abort" → MFA_CANCELLED:
+                * "quit" → MFA_CANCELLED:
+
+                **OTP Capture Examples:**
+                * "1234" → MFA_CAPTURED:1234
+                * "2345e" → MFA_CAPTURED:2345e
+                * "the code is 567890" → MFA_CAPTURED:567890
+                * "my otp is 123456" → MFA_CAPTURED:123456
+
+                **Output Format:**
+                - For OTP/MFA codes: MFA_CAPTURED:<otp_value>
+                - For cancellation: MFA_CANCELLED:
+
+        """)
+
+        if mfa_model := mfa_config.get('model'):
+            agent_config.update(model_name=mfa_model)
+        
         max_attempts = mfa_config.get('max_attempts', 3)
         on_max_attempts_reached = mfa_config.get('on_max_attempts_reached')
 
@@ -149,44 +189,7 @@ class MFANodeConfig:
             field=input_field_name,
             max_attempts=max_attempts,
             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, or detect if the user wants to cancel the authentication flow.
-
-                    **Task:**
-                    - Read the user's message carefully
-                    - First, check if the user wants to cancel, stop, or exit the authentication process
-                    - If they want to cancel, output: MFA_CANCELLED:
-                    - Otherwise, extract ONLY the OTP/MFA code value and output in the format shown below
-
-                    **Cancellation Detection:**
-                    If the user expresses any intent to cancel, stop, exit, abort, or quit the authentication process, respond with: MFA_CANCELLED
-
-                    Examples of cancellation phrases:
-                    * "cancel" → MFA_CANCELLED:
-                    * "I want to stop" → MFA_CANCELLED:
-                    * "exit" → MFA_CANCELLED:
-                    * "nevermind" → MFA_CANCELLED:
-                    * "I don't want to continue" → MFA_CANCELLED:
-                    * "stop this" → MFA_CANCELLED:
-                    * "forget it" → MFA_CANCELLED:
-                    * "abort" → MFA_CANCELLED:
-                    * "quit" → MFA_CANCELLED:
-
-                    **OTP Capture Examples:**
-                    * "1234" → MFA_CAPTURED:1234
-                    * "2345e" → MFA_CAPTURED:2345e
-                    * "the code is 567890" → MFA_CAPTURED:567890
-                    * "my otp is 123456" → MFA_CAPTURED:123456
-
-                    **Output Format:**
-                    - For OTP/MFA codes: MFA_CAPTURED:<otp_value>
-                    - For cancellation: MFA_CANCELLED:
-
-            """),
+            agent=agent_config,
             transitions=[
                 dict(
                     pattern="MFA_CAPTURED:",

soprano_sdk/core/engine.py

@@ -56,7 +56,8 @@ class WorkflowEngine:
 
             logger.info(
                 f"Workflow loaded: {self.workflow_name} v{self.workflow_version} "
-                f"({len(self.steps)} steps, {len(self.outcomes)} outcomes)"
+                f"({len(self.steps)} steps, {len(self.outcomes)} outcomes, "
+                f"{len(self.collector_node_field_map)} collector nodes)"
             )
 
         except Exception as e:
@@ -202,6 +203,7 @@ class WorkflowEngine:
     def load_steps(self):
         prepared_steps: list = []
         mfa_redirects: Dict[str, str] = {}
+        self.collector_node_field_map: Dict[str, str] = {}  # Map of node_id -> field
 
         for step in self.config['steps']:
             step_id = step['id']
@@ -228,6 +230,14 @@ class WorkflowEngine:
 
             prepared_steps.append(step)
 
+        # Build collector node -> field map
+        for step in prepared_steps:
+            if step.get('action') == 'collect_input':
+                node_id = step.get('id')
+                field = step.get('field')
+                if node_id and field:
+                    self.collector_node_field_map[node_id] = field
+
         for step in prepared_steps:
             if step['id'] in self.mfa_validator_steps: # MFA Validator
                 continue

soprano_sdk/nodes/collect_input.py

@@ -195,6 +195,7 @@ class CollectInputStrategy(ActionStrategy):
         context_value = self.engine_context.get_context_value(self.field)
         if context_value is None:
             return
+
         logger.info(f"Using context value for '{self.field}': {context_value}")
         state[self.field] = context_value
         span.add_event("context.value_used", {"field": self.field, "value": str(context_value)})
@@ -375,15 +376,18 @@ class CollectInputStrategy(ActionStrategy):
             if self.is_structured_output:
                 try:
                     response_dict = json.loads(agent_response) if isinstance(agent_response, str) else agent_response
-                    prompt = response_dict.get("bot_response", "")
+                    bot_response = response_dict.get("bot_response", None)
+                    # Treat empty or whitespace-only bot_response as None
+                    prompt = bot_response if (bot_response and bot_response.strip()) else None
                 except (json.JSONDecodeError, TypeError, ValueError) as e:
                     logger.error(f"Error When Converting Structured Output {agent_response} to JSON {e}")
                     prompt = agent_response
             else:
                 prompt = agent_response
 
-        prompt = self._render_template_string(prompt, state)
-        conversation.append({"role": "assistant", "content": prompt})
+        if prompt is not None:
+            prompt = self._render_template_string(prompt, state)
+            conversation.append({"role": "assistant", "content": prompt})
 
         return prompt
 
@@ -490,7 +494,7 @@ class CollectInputStrategy(ActionStrategy):
     def _handle_structured_output_transition(self, state: Dict[str, Any], conversation: List, agent_response: Any) -> Dict[str, Any]:
 
         try:
-            agent_response = json.loads(agent_response)
+            agent_response = json.loads(agent_response) if isinstance(agent_response, str) else agent_response
         except (json.JSONDecodeError, TypeError, ValueError):
             pass
 

soprano_sdk/tools.py

@@ -83,21 +83,35 @@ class WorkflowTool:
             callback_handler = CallbackHandler()
             config = {"configurable": {"thread_id": thread_id}, "callbacks": [callback_handler]}
 
-            self.engine.update_context(initial_context)
-            span.add_event("context.updated", {"fields": list(initial_context.keys())})
-
             state = self.graph.get_state(config)
 
+            # Intelligently update context based on workflow state
             if state.next:
+                # Workflow is resuming - only update fields that haven't been collected yet
                 span.set_attribute("workflow.resumed", True)
                 logger.info(f"[WorkflowTool] Resuming interrupted workflow {self.name} (thread: {thread_id})")
+
+                filtered_context = self._filter_already_collected_fields(state.values, initial_context)
+                self.engine.update_context(filtered_context)
+
+                span.add_event("context.updated", {
+                    "fields": list(filtered_context.keys()),
+                    "filtered_out": list(set(initial_context.keys()) - set(filtered_context.keys()))
+                })
+
                 result = self.graph.invoke(
-                    Command(resume=user_message or "", update=initial_context),
+                    Command(resume=user_message or "", update=filtered_context),
                     config=config
                 )
+
             else:
+                # Fresh start - update all fields from initial_context
                 span.set_attribute("workflow.resumed", False)
                 logger.info(f"[WorkflowTool] Starting fresh workflow {self.name} (thread: {thread_id})")
+
+                self.engine.update_context(initial_context)
+                span.add_event("context.updated", {"fields": list(initial_context.keys())})
+
                 result = self.graph.invoke(initial_context, config=config)
             
             final_state = self.graph.get_state(config)
@@ -124,6 +138,51 @@ class WorkflowTool:
             span.set_attribute("workflow.status", "completed")
             return self.engine.get_outcome_message(result)
 
+    def _filter_already_collected_fields(
+        self,
+        current_state: Dict[str, Any],
+        initial_context: Optional[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Filter initial_context to exclude fields that have already been collected.
+
+        Args:
+            current_state: Current workflow state
+            initial_context: Context to filter
+
+        Returns:
+            Filtered context with only uncollected fields
+        """
+        if not initial_context:
+            return {}
+
+        from .core.constants import WorkflowKeys
+
+        execution_order = current_state.get(WorkflowKeys.NODE_EXECUTION_ORDER, [])
+
+        node_to_field_map = self.engine.collector_node_field_map
+
+        # Determine which fields have already been collected
+        collected_fields = set()
+        for executed_node_id in execution_order:
+            if executed_node_id in node_to_field_map:
+                collected_fields.add(node_to_field_map[executed_node_id])
+
+        # Filter initial_context to exclude already-collected fields
+        filtered_context = {
+            field: value
+            for field, value in initial_context.items()
+            if field not in collected_fields
+        }
+
+        if collected_fields:
+            logger.info(
+                f"[WorkflowTool] Filtered out already-collected fields: {collected_fields}. "
+                f"Updating context with: {list(filtered_context.keys())}"
+            )
+
+        return filtered_context
+
     def resume(
         self,
         thread_id: str,

soprano_sdk/validation/schema.py

@@ -234,7 +234,7 @@ WORKFLOW_SCHEMA = {
                     "mfa": {
                         "type": "object",
                         "description": "Multi-factor authentication configuration",
-                        "required": ["type", "model", "payload"],
+                        "required": ["type", "payload"],
                         "properties": {
                             "model": {
                                 "type": "string",

soprano_sdk/validation/validator.py

@@ -122,10 +122,6 @@ class WorkflowValidator:
                 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")
-
         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.")

{soprano_sdk-0.2.10.dist-info → soprano_sdk-0.2.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soprano-sdk
-Version: 0.2.10
+Version: 0.2.17
 Summary: YAML-driven workflow engine with AI agent integration for building conversational SOPs
 Author: Arvind Thangamani
 License: MIT
@@ -21,6 +21,7 @@ Requires-Dist: langchain-openai>=1.0.3
 Requires-Dist: langchain>=1.0.7
 Requires-Dist: langfuse>=3.10.1
 Requires-Dist: langgraph==1.0.2
+Requires-Dist: litellm>=1.74.9
 Requires-Dist: openai>=1.92.1
 Requires-Dist: pydantic-ai>=1.22.0
 Requires-Dist: pydantic>=2.0.0
@@ -29,6 +30,7 @@ Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: gradio>=5.46.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff==0.14.13; extra == 'dev'
 Provides-Extra: persistence
 Requires-Dist: langgraph-checkpoint-mongodb>=0.2.0; extra == 'persistence'
 Requires-Dist: pymongo>=4.0.0; extra == 'persistence'

{soprano_sdk-0.2.10.dist-info → soprano_sdk-0.2.17.dist-info}/RECORD

@@ -1,22 +1,22 @@
 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=xsJbY1hZzhXbNRTAVj9M_2saU0oa7J8O9DaRGGuPf30,8832
+soprano_sdk/tools.py,sha256=dmJ0OZ7Bj3rvjBQvLzgWlYRFVtNJOyMO2jLqaS13cAc,10971
 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/adaptor.py,sha256=xJ3MBTU91fQxA9O7V5Xds6m8-n_NxkF0YiKGaWKLmrQ,4959
+soprano_sdk/agents/factory.py,sha256=CvXhpvtjf_Hb4Ce8WKAa0FzyY5Jm6lssvIIfSXu7jPY,9788
 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=Vew9Nb8pIRTw9hKbEZTH3YScY-fZ_TLq4ZuCzc-wbr8,7387
+soprano_sdk/authenticators/mfa.py,sha256=bEV9edY2PvyRnb8YoQWt8UXAETMKLFVKrTvgSpfRer4,7341
 soprano_sdk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 soprano_sdk/core/constants.py,sha256=UPXlRbF7gsOUNOV0Lm0jvgFfgZX7JrsV6n9I5csMfns,3508
-soprano_sdk/core/engine.py,sha256=vM2-nAvDc6Oam-q_BegabBT4uKVMV8DVV10SyJJPgVw,11762
+soprano_sdk/core/engine.py,sha256=HKYoqwDm541pWSWwEKHxLlL3PX90Ux_5l_-HqihgL-g,12245
 soprano_sdk/core/rollback_strategies.py,sha256=NjDTtBCZlqyDql5PSwI9SMDLK7_BNlTxbW_cq_5gV0g,7783
 soprano_sdk/core/state.py,sha256=k8ojLfWgjES3p9XWMeGU5s4UK-Xa5T8mS4VtZzTrcDw,2961
 soprano_sdk/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 soprano_sdk/nodes/async_function.py,sha256=v6WujLKm8NXX2iAkJ7Gz_QIVCtWFrpC6nnPyyfuCxXs,9354
 soprano_sdk/nodes/base.py,sha256=idFyOGGPnjsASYnrOF_NIh7eFcSuJqw61EoVN_WCTaU,2360
 soprano_sdk/nodes/call_function.py,sha256=afYBmj5Aditbkvb_7gD3CsXBEEUohcsC1_cdHfcOunE,5847
-soprano_sdk/nodes/collect_input.py,sha256=nBTLCq6nxNSO6lCV2FIbCaX6SBCZhn6-SvWm82Gl83Y,24345
+soprano_sdk/nodes/collect_input.py,sha256=PySlghXOWDl6AYKgimY_7BnVFN7odYG656aBK_z4ACE,24617
 soprano_sdk/nodes/factory.py,sha256=IbBzT4FKBnYw5PuSo7uDONV3HSFtoyqjBQQtXtUY2IY,1756
 soprano_sdk/routing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 soprano_sdk/routing/router.py,sha256=Z218r4BMbmlL9282ombutAoKsIs1WHZ2d5YHnbCeet8,3698
@@ -27,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=SlC4sq-ueEg0p_8Uox_cgPj9S-0AEEiOOlA1Vsu0DsE,15443
-soprano_sdk/validation/validator.py,sha256=GaCvHvjwVe88Z8yatQsueiPnqtq1oo5uN75gogzpQT0,8940
-soprano_sdk-0.2.10.dist-info/METADATA,sha256=Oowx80YoqwZb11UYh8KSt4BCKrQz1qY5kwxSWIkolJ4,11298
-soprano_sdk-0.2.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-soprano_sdk-0.2.10.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
-soprano_sdk-0.2.10.dist-info/RECORD,,
+soprano_sdk/validation/schema.py,sha256=eRGXXMDlJyaH0XYMOXY1azvJlJwOdbHFrHjB1yuGROg,15434
+soprano_sdk/validation/validator.py,sha256=f-e2MMRL70asOIXr_0Fsd5CgGKVRiQp7AaYsHA45Km0,8792
+soprano_sdk-0.2.17.dist-info/METADATA,sha256=SEWpX1K-uAsRJQg8lWXWy2MhRsDZHchSJh8UQ8uZtN8,11374
+soprano_sdk-0.2.17.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+soprano_sdk-0.2.17.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
+soprano_sdk-0.2.17.dist-info/RECORD,,