soprano-sdk 0.1.96__py3-none-any.whl → 0.1.98__py3-none-any.whl

soprano_sdk/agents/adaptor.py

@@ -1,4 +1,3 @@
-import json
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List
 from langgraph.graph.state import CompiledStateGraph

soprano_sdk/agents/structured_output.py

@@ -20,7 +20,7 @@ def create_structured_output_model(
     if not fields:
         raise ValueError("At least one field definition is required")
     
-    field_definitions = {"bot_response": (Optional[str], Field(None, description="bot response for the user query"))}
+    field_definitions = {"bot_response": (Optional[str], Field(None, description="bot response for the user query, only use this for clarification or asking for more information"))}
 
     if needs_intent_change:
         field_definitions["intent_change"] = (Optional[str], Field(None, description="node name for handling new intent"))

soprano_sdk/core/engine.py

@@ -20,7 +20,7 @@ from ..validation import validate_workflow
 class WorkflowEngine:
     def __init__(self, yaml_path: str, configs: dict):
         self.yaml_path = yaml_path
-        self.configs = configs
+        self.configs = configs or {}
         logger.info(f"Loading workflow from: {yaml_path}")
 
         try:

soprano_sdk/core/rollback_strategies.py

@@ -1,5 +1,4 @@
 import copy
-import logging
 import uuid
 from abc import ABC, abstractmethod
 from datetime import datetime

soprano_sdk/core/state.py

@@ -1,5 +1,5 @@
 import types
-from typing import Annotated, Optional, Dict, List, Any, Type
+from typing import Annotated, Optional, Dict, List, Any
 
 from typing_extensions import TypedDict
 

soprano_sdk/nodes/base.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 from typing import Dict, Any, Callable, List
-import logging
 
 from langgraph.errors import GraphInterrupt
 

soprano_sdk/nodes/call_function.py

@@ -77,10 +77,14 @@ class CallFunctionStrategy(ActionStrategy):
     ) -> Dict[str, Any]:
         for transition in self.transitions:
             check_value = result
-            if 'path' in transition:
-                check_value = get_nested_value(result, transition['path'])
-
-            if check_value != transition['condition']:
+            if 'ref' in transition:
+                check_value = get_nested_value(result, transition['ref'])
+
+            condition = transition['condition']
+            if isinstance(condition, list):
+                if check_value not in condition:
+                    continue
+            elif check_value != condition:
                 continue
 
             next_dest = transition['next']

soprano_sdk/nodes/collect_input.py

@@ -61,6 +61,12 @@ IF the user's query continues with the SAME intent OR does not match any intent
 - Proceed with your normal response
 - Do NOT mention intent detection
 - Answer the user's question as configured
+
+BOT RESPONSE RULES:
+- If the user is asking a question or needs information, provide a helpful and concise response
+- If the user input is unclear or does not provide enough information, ask for clarification or more details
+- { "populate bot_response field to respond back to the user" if with_structured_output else ""}
+- Do not respond or use bot_response if the user provides a valid input
 """
 
 def _create_rollback_strategy(strategy_name: str) -> RollbackStrategy:
@@ -178,7 +184,8 @@ class CollectInputStrategy(ActionStrategy):
         return template_loader.from_string(template_str).render(state)
 
     def _apply_context_value(self, state: Dict[str, Any], span) -> None:
-        if not (context_value := self.engine_context.get_context_value(self.field)):
+        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
@@ -223,18 +230,16 @@ class CollectInputStrategy(ActionStrategy):
     def _validate_collected_input(self, state) -> Tuple[bool, Optional[str]]:
         if not self.validator:
             return True, None
-        result = self.validator(**state)
-        if isinstance(result, tuple):
-            return result
-        return result, None
+        return self.validator(**state)
 
     def _handle_pre_populated_field(self, state: Dict[str, Any], conversation: List) -> Dict[str, Any]:
         logger.info(f"Field '{self.field}' is populated, skipping collection")
 
-        is_valid_input, _ = self._validate_collected_input(state)
+        is_valid_input, validator_error_message = self._validate_collected_input(state)
         if not is_valid_input:
             self._set_status(state, "collecting")
-            return self._handle_validation_failure(state, conversation, message=f"{state[self.field]}", role="user")
+            conversation.append({"role": "user", "content": f"{state[self.field]}"})
+            return self._handle_validation_failure(state, conversation, message=validator_error_message)
 
         if self.transitions:
             first_transition = self.transitions[0]
@@ -344,16 +349,18 @@ class CollectInputStrategy(ActionStrategy):
         conversation: List[Dict[str, str]],
         state: Dict[str, Any]
     ) -> str:
-        if len(conversation) == 0:
-            if not (prompt := self.agent_config.get('initial_message')):
-                prompt = agent.invoke([{"role": "user", "content": ""}])
+        last_assistant_message = next((msg['content'] for msg in reversed(conversation) if msg['role'] == 'assistant'), None)
+
+        if last_assistant_message is not None:
+            return last_assistant_message
 
-            prompt = self._render_template_string(prompt, state)
-            conversation.append({"role": "assistant", "content": prompt})
+        if not (prompt := self.agent_config.get('initial_message')):
+            prompt = agent.invoke([{"role": "user", "content": ""}])
 
-            return prompt
+        prompt = self._render_template_string(prompt, state)
+        conversation.append({"role": "assistant", "content": prompt})
 
-        return conversation[-1]['content']
+        return prompt
 
     def _update_conversation(self, state: Dict[str, Any], conversation: List[Dict[str, str]]):
         state[WorkflowKeys.CONVERSATIONS][self._conversation_key] = conversation
@@ -391,6 +398,11 @@ class CollectInputStrategy(ActionStrategy):
             workflow_steps=workflow_steps
         )
 
+        for key, value in restored_state.items():
+            context_value = self.engine_context.get_context_value(key)
+            if context_value is not None:
+                restored_state[key] = context_value
+
         if not restored_state:
             logger.warning(f"Rollback strategy returned empty state for node '{target_node}'")
             return {}
@@ -409,8 +421,17 @@ class CollectInputStrategy(ActionStrategy):
         self._set_status(state, 'collecting')
 
         for transition in self.transitions:
-            pattern = transition['pattern']
-            if pattern not in agent_response:
+            patterns = transition['pattern']
+            if isinstance(patterns, str):
+                patterns = [patterns]
+
+            matched_pattern = None
+            for pattern in patterns:
+                if pattern in agent_response:
+                    matched_pattern = pattern
+                    break
+
+            if not matched_pattern:
                 continue
 
             matched = True
@@ -418,12 +439,12 @@ class CollectInputStrategy(ActionStrategy):
 
             logger.info(f"Matched transition: {transition}")
 
-            value = agent_response.split(pattern)[1].strip()
+            value = agent_response.split(matched_pattern)[1].strip()
             if value:
                 self._store_field_value(state, value)
-                is_valid_input, message = self._validate_collected_input(state)
+                is_valid_input, validation_error_message = self._validate_collected_input(state)
                 if not is_valid_input:
-                    return self._handle_validation_failure(state, conversation, message=message)
+                    return self._handle_validation_failure(state, conversation, message=validation_error_message)
                 state[WorkflowKeys.MESSAGES] = [f"✓ {self._formatted_field_name} collected: {value}" ]
             else:
                 state[WorkflowKeys.MESSAGES] = []
@@ -472,25 +493,20 @@ class CollectInputStrategy(ActionStrategy):
         return state
 
     def _find_matching_transition(self, agent_response: Any) -> Optional[str]:
-        is_structured_output = isinstance(agent_response, dict)
-        
         for transition in self.transitions:
-            if is_structured_output:
-                next_node = transition.get("next")
-                match_value = transition.get("match")
-                ref_field = transition.get("ref")
+            next_node = transition.get("next")
+            match_value = transition.get("match")
+            ref_field = transition.get("ref")
 
-                if not all([next_node, match_value, ref_field]):
-                    raise RuntimeError(f"Transition in step '{self.step_id}' missing required properties for structured output routing")
+            if not next_node or not ref_field or match_value is None:
+                raise RuntimeError(f"Transition in step '{self.step_id}' missing required properties for structured output routing")
 
-                if field_value := agent_response.get(ref_field):
-                    if field_value == match_value:
-                        return next_node
-            else:
-                next_node = transition.get("next")
-                pattern = transition.get("pattern")
-                if pattern in agent_response:
+            field_value = agent_response.get(ref_field)
+            if isinstance(match_value, list):
+                if field_value in match_value:
                     return next_node
+            elif field_value == match_value:
+                return next_node
 
         return None
 

soprano_sdk/tools.py

@@ -5,7 +5,6 @@ Workflow Tools - Wraps workflows as callable tools for agent frameworks
 import uuid
 from typing import Optional, Dict, Any
 
-from langgraph.graph.state import CompiledStateGraph
 
 from .utils.logger import logger
 
@@ -78,35 +77,23 @@ class WorkflowTool:
         ) as span:
             callback_handler = CallbackHandler()
             config = {"configurable": {"thread_id": thread_id}, "callbacks": [callback_handler]}
-            
-            update_context = {}
-            engine_context_data = {}
-            for key, value in initial_context.items():
-                if key in self.engine.collect_input_fields:
-                    engine_context_data[key] = value
-                    continue
-                if  value:
-                    update_context[key] = value
-
-            if engine_context_data:
-                self.engine.update_context(engine_context_data)
-                span.add_event("context.updated", {"fields": list(engine_context_data.keys())})
+
+            self.engine.update_context(initial_context)
+            span.add_event("context.updated", {"fields": list(initial_context.keys())})
 
             state = self.graph.get_state(config)
 
             if state.next:
-                # Workflow is interrupted and waiting for input
                 span.set_attribute("workflow.resumed", True)
                 logger.info(f"[WorkflowTool] Resuming interrupted workflow {self.name} (thread: {thread_id})")
                 result = self.graph.invoke(
-                    Command(resume=user_message or "", update=update_context),
+                    Command(resume=user_message or "", update=initial_context),
                     config=config
                 )
             else:
-                # Workflow is fresh or completed, start/restart
                 span.set_attribute("workflow.resumed", False)
                 logger.info(f"[WorkflowTool] Starting fresh workflow {self.name} (thread: {thread_id})")
-                result = self.graph.invoke(update_context, config=config)
+                result = self.graph.invoke(initial_context, config=config)
             
             final_state = self.graph.get_state(config)
             if not final_state.next and self.checkpointer:

soprano_sdk/utils/template.py

@@ -7,14 +7,14 @@ def get_nested_value(data: Any, path: str) -> Any:
     if not path:
         return data
 
-    if not path.strip().startswith('{{'):
-        template_str = f'{{{{ {path} }}}}'
-    else:
-        template_str = path
+    template_str = f"{{{{ {path} }}}}"
 
     try:
         template = Template(template_str)
-        result = template.render(result=data)
+        if isinstance(data, dict):
+            result = template.render(**data)
+        else:
+            result = template.render(data)
         
         if not result or result == '':
             return None

soprano_sdk/utils/tracing.py

@@ -1,10 +1,8 @@
 from opentelemetry import trace
-from typing import Optional, Dict, Any
+from typing import Any
 from contextlib import contextmanager
-import logging
 
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
-from opentelemetry.trace import Link
 
 from ..utils.logger import logger
 

soprano_sdk/validation/schema.py

@@ -164,10 +164,6 @@ WORKFLOW_SCHEMA = {
                         "pattern": "^[a-zA-Z_][a-zA-Z0-9_.]*\\.[a-zA-Z_][a-zA-Z0-9_]*$",
                         "description": "Function path (for call_function, format: module.function)"
                     },
-                    "inputs": {
-                        "type": "object",
-                        "description": "Input mapping for function"
-                    },
                     "output": {
                         "type": "string",
                         "description": "Output field name"
@@ -183,8 +179,11 @@ WORKFLOW_SCHEMA = {
                             "type": "object",
                             "properties": {
                                 "pattern": {
-                                    "type": "string",
-                                    "description": "Pattern to match in response (for non-structured output)"
+                                    "anyOf": [
+                                        {"type": "string"},
+                                        {"type": "array", "items": {"type": "string"}}
+                                    ],
+                                    "description": "Pattern(s) to match in response (for non-structured output)"
                                 },
                                 "match": {
                                     "description": "Value to match against a field (for structured output)"
@@ -196,10 +195,6 @@ WORKFLOW_SCHEMA = {
                                 "condition": {
                                     "description": "Condition to evaluate (for call_function)"
                                 },
-                                "path": {
-                                    "type": "string",
-                                    "description": "Dot-notation path to the value for evaluation (optional)"
-                                },
                                 "next": {
                                     "type": "string",
                                     "description": "Next step or outcome ID"

{soprano_sdk-0.1.96.dist-info → soprano_sdk-0.1.98.dist-info}/METADATA

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

{soprano_sdk-0.1.96.dist-info → soprano_sdk-0.1.98.dist-info}/RECORD

@@ -1,32 +1,32 @@
 soprano_sdk/__init__.py,sha256=y3c4i7Q7SAPS2Tee7V0TzWdhgMxBWfDJJ98eqD1HxGI,188
 soprano_sdk/engine.py,sha256=EFK91iTHjp72otLN6Kg-yeLye2J3CAKN0QH4FI2taL8,14838
-soprano_sdk/tools.py,sha256=A0qFEwn208GCYc-_7ZbZKR7N3HG5-6TA3Ma1RPo6YnM,8029
+soprano_sdk/tools.py,sha256=cYEto0cmQ5GZ4zsH_YPfbaaDbzl5aO3rAOm7KlzTFVk,7444
 soprano_sdk/agents/__init__.py,sha256=Yzbtv6iP_ABRgZo0IUjy9vDofEvLFbOjuABw758176A,636
-soprano_sdk/agents/adaptor.py,sha256=IMMgo9_KLI82i1eenOaojw7UE0jjx9vjm8mjfsodKSM,3226
+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=LDBWCMJFclOvcFB3OJpu37tO0Ct_M-L2PIH5MCYSjLI,3262
+soprano_sdk/agents/structured_output.py,sha256=7DSVzfMPsZAqBwI3v6XL15qG5Gh4jJ-qddcVPaa3gdc,3326
 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=WEyqGaBasGnSqlBAkFSQIZXJb7T6OEsN-DWznIBAzNs,8341
-soprano_sdk/core/rollback_strategies.py,sha256=UZyDBRmbi4kS7D9cGJT_mzSZzfqgbUoeTnOGcW1WOc0,7798
-soprano_sdk/core/state.py,sha256=h0Uo4uCwBAGTWrmzpDbcTwH6lI97-fXU9ek0tc3p2bM,2617
+soprano_sdk/core/engine.py,sha256=aN805CtG7TDBkBbIJSbAbLo_5tKqrfve394L_DzZq8s,8347
+soprano_sdk/core/rollback_strategies.py,sha256=NjDTtBCZlqyDql5PSwI9SMDLK7_BNlTxbW_cq_5gV0g,7783
+soprano_sdk/core/state.py,sha256=ICyFhio1VESQxzYNwKrS-gk3QDc0OrwJLQtVnZ9c9LU,2611
 soprano_sdk/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/nodes/base.py,sha256=H6wvvN3kUeXluZAt5Hf3iocO9NjTElAH4fTb2-1JKr0,2233
-soprano_sdk/nodes/call_function.py,sha256=UM-JpaG6DutuaFhOrXxEcT_fnK85aH6sFCVkfeYIfwc,4350
-soprano_sdk/nodes/collect_input.py,sha256=LhDsqtlBKK-uIz90QIODDoR5PZbnv4rWyj-hvTR64do,21987
+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=2Z5XztS_mBF43asds60-ZlSUUu2bFDEIPdWQY6R1c0k,22827
 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
 soprano_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 soprano_sdk/utils/function.py,sha256=yqkY4MlHOenv-Q3NciiovK1lamyrGQljpy6Q41wviy8,1216
 soprano_sdk/utils/logger.py,sha256=hMYaNHt5syGOXRkglTUKzkgfSbWerix_pHQntcYyep8,157
-soprano_sdk/utils/template.py,sha256=EssXvRDWdyITVWp52weYNIwnqj9ilJaoQotWFIg4rGQ,678
+soprano_sdk/utils/template.py,sha256=MG_B9TMx1ShpnSGo7s7TO-VfQzuFByuRNhJTvZ668kM,685
 soprano_sdk/utils/tool.py,sha256=hWN826HIKmLdswLCTURLH8hWlb2WU0MB8nIUErbpB-8,1877
-soprano_sdk/utils/tracing.py,sha256=iSJlTAaiGzgBvZhLISCGAd9_7F2HRzhcIUNHuaFv_Zc,2059
+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=uJJZRDgwzWT2W8amd_W8mUAULvDnHJhiMEl-5so1ZK0,13559
+soprano_sdk/validation/schema.py,sha256=HzqRp-5rl3GzX5KtFckAbBh8S7zklvQmRERIyfByS2w,13335
 soprano_sdk/validation/validator.py,sha256=l2P24wiCWBNTZ9-dRbgWwK48BGaR1xIdnBxzSCu0RPM,6498
-soprano_sdk-0.1.96.dist-info/METADATA,sha256=eLSUnBX8Gg_37Okmm3g82Jm4UZp6j4pA64Y3cSd0YbQ,11269
-soprano_sdk-0.1.96.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-soprano_sdk-0.1.96.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
-soprano_sdk-0.1.96.dist-info/RECORD,,
+soprano_sdk-0.1.98.dist-info/METADATA,sha256=yQkfqKo19uFrYSjqaFddjivMmAlU6IdMjHF3-NpkPkc,11269
+soprano_sdk-0.1.98.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+soprano_sdk-0.1.98.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
+soprano_sdk-0.1.98.dist-info/RECORD,,