soprano-sdk 0.2.4__tar.gz → 0.2.5__tar.gz

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/PKG-INFO

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

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/pyproject.toml

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

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/soprano_sdk/core/constants.py

@@ -22,6 +22,13 @@ class WorkflowKeys:
 class ActionType(Enum):
     COLLECT_INPUT_WITH_AGENT = 'collect_input_with_agent'
     CALL_FUNCTION = 'call_function'
+    CALL_ASYNC_FUNCTION = 'call_async_function'
+
+
+class InterruptType:
+    """Interrupt type markers for workflow pauses"""
+    USER_INPUT = '__WORKFLOW_INTERRUPT__'
+    ASYNC = '__ASYNC_INTERRUPT__'
 
 
 class DataType(Enum):

soprano_sdk-0.2.5/soprano_sdk/nodes/async_function.py

@@ -0,0 +1,237 @@
+"""
+Async Function Strategy - Handles asynchronous function calls with interrupt/resume pattern.
+
+This strategy allows workflows to pause while waiting for an external async operation
+to complete. The async function initiates an operation and returns a "pending" status.
+The workflow then interrupts, and resumes when the external system calls back with the result.
+
+Example YAML:
+    - id: verify_identity
+      action: call_async_function
+      function: "services.identity.start_verification"
+      output: verification_result
+      transitions:
+        - condition: "verified"
+          next: approved
+        - condition: "failed"
+          next: rejected
+
+The async function should return:
+    - {"status": "pending", ...metadata} to trigger interrupt and wait for callback
+    - Any other dict for synchronous completion (no interrupt)
+
+On resume, the async result is passed via Command(resume=async_result) and stored
+in the output field, then transitions are evaluated.
+"""
+from typing import Dict, Any
+
+from langgraph.types import interrupt
+
+from .base import ActionStrategy
+from ..core.state import set_state_value, get_state_value
+from ..core.constants import WorkflowKeys
+from ..utils.logger import logger
+from ..utils.template import get_nested_value
+
+
+class AsyncFunctionStrategy(ActionStrategy):
+    """Strategy for executing async functions with interrupt/resume pattern."""
+
+    # Key for storing pending metadata in state
+    PENDING_KEY_PREFIX = '_async_pending_'
+
+    def __init__(self, step_config: Dict[str, Any], engine_context: Any):
+        super().__init__(step_config, engine_context)
+        self.function_path = step_config.get('function')
+        self.output_field = step_config.get('output')
+        self.transitions = self._get_transitions()
+        self.next_step = self._get_next_step()
+
+        if not self.function_path:
+            raise RuntimeError(f"Step '{self.step_id}' missing required 'function' property")
+
+        if not self.output_field:
+            raise RuntimeError(f"Step '{self.step_id}' missing required 'output' property")
+
+    @property
+    def _pending_key(self) -> str:
+        """State key for storing pending operation metadata."""
+        return f"{self.PENDING_KEY_PREFIX}{self.step_id}"
+
+    def _is_async_pending(self, state: Dict[str, Any]) -> bool:
+        """Check if this node is waiting for async operation to complete."""
+        return state.get(WorkflowKeys.STATUS) == f'{self.step_id}_pending'
+
+    def pre_execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
+        """Pre-execution hook."""
+        pass
+
+    def execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
+        from ..utils.tracing import trace_node_execution
+
+        with trace_node_execution(
+            node_id=self.step_id,
+            node_type="call_async_function",
+            function=self.function_path,
+            output_field=self.output_field
+        ) as span:
+            # Check if we're resuming from a pending async operation
+            if self._is_async_pending(state):
+                span.add_event("async.resuming")
+                pending_metadata = state.get(self._pending_key, {})
+            else:
+                # First invocation - call the async function
+                result = self._call_function(state, span)
+
+                if self._is_pending_result(result):
+                    # Async operation started - store metadata and prepare to interrupt
+                    span.add_event("async.pending", {"metadata": str(result)})
+                    self._set_status(state, "pending")
+                    state[self._pending_key] = result
+                    pending_metadata = result
+                else:
+                    # Synchronous completion - no interrupt needed
+                    span.add_event("async.sync_complete", {"result": str(result)})
+                    return self._handle_sync_completion(state, result, span)
+
+            # Interrupt with pending metadata
+            # On resume, interrupt() returns the async result from Command(resume=...)
+            async_result = interrupt({
+                "type": "async",
+                "step_id": self.step_id,
+                "pending": pending_metadata
+            })
+
+            # Clean up pending state
+            if self._pending_key in state:
+                del state[self._pending_key]
+
+            span.add_event("async.resumed", {"result": str(async_result)})
+
+            # Store result and handle routing
+            return self._handle_async_completion(state, async_result, span)
+
+    def _call_function(self, state: Dict[str, Any], span) -> Any:
+        """Load and execute the async function."""
+        try:
+            logger.info(f"Loading async function: {self.function_path}")
+            func = self.engine_context.function_repository.load(self.function_path)
+        except Exception as e:
+            span.set_attribute("error", True)
+            span.set_attribute("error.type", "LoadError")
+            span.set_attribute("error.message", str(e))
+            raise RuntimeError(
+                f"Failed to load function '{self.function_path}' in step '{self.step_id}': {e}"
+            )
+
+        try:
+            logger.info(f"Calling async function: {self.function_path}")
+            result = func(state)
+            logger.info(f"Async function {self.function_path} returned: {result}")
+            return result
+        except Exception as e:
+            span.set_attribute("error", True)
+            span.set_attribute("error.type", type(e).__name__)
+            span.set_attribute("error.message", str(e))
+            raise RuntimeError(
+                f"Function '{self.function_path}' failed in step '{self.step_id}': {e}"
+            )
+
+    def _is_pending_result(self, result: Any) -> bool:
+        """Check if the function result indicates a pending async operation."""
+        if not isinstance(result, dict):
+            return False
+        return result.get("status") == "pending"
+
+    def _handle_sync_completion(
+        self,
+        state: Dict[str, Any],
+        result: Any,
+        span
+    ) -> Dict[str, Any]:
+        """Handle synchronous function completion (no async wait needed)."""
+        set_state_value(state, self.output_field, result)
+        self._track_computed_field(state)
+        return self._handle_routing(state, result, span)
+
+    def _handle_async_completion(
+        self,
+        state: Dict[str, Any],
+        async_result: Any,
+        span
+    ) -> Dict[str, Any]:
+        """Handle async operation completion after resume."""
+        set_state_value(state, self.output_field, async_result)
+        self._track_computed_field(state)
+        return self._handle_routing(state, async_result, span)
+
+    def _track_computed_field(self, state: Dict[str, Any]):
+        """Track this field as computed for rollback purposes."""
+        computed_fields = get_state_value(state, WorkflowKeys.COMPUTED_FIELDS, [])
+        if self.output_field not in computed_fields:
+            computed_fields.append(self.output_field)
+        set_state_value(state, WorkflowKeys.COMPUTED_FIELDS, computed_fields)
+
+    def _handle_routing(
+        self,
+        state: Dict[str, Any],
+        result: Any,
+        span
+    ) -> Dict[str, Any]:
+        """Determine next step based on transitions or default routing."""
+        if self.transitions:
+            return self._handle_transition_routing(state, result, span)
+        return self._handle_simple_routing(state, span)
+
+    def _handle_transition_routing(
+        self,
+        state: Dict[str, Any],
+        result: Any,
+        span
+    ) -> Dict[str, Any]:
+        """Route based on transition conditions matching the result."""
+        for transition in self.transitions:
+            check_value = result
+
+            # Support nested field references
+            if 'ref' in transition:
+                check_value = get_nested_value(result, transition['ref'])
+
+            condition = transition['condition']
+
+            # Support list of conditions
+            if isinstance(condition, list):
+                if check_value not in condition:
+                    continue
+            elif check_value != condition:
+                continue
+
+            next_dest = transition['next']
+            logger.info(f"Async function matched transition, routing to {next_dest}")
+            span.add_event("transition.matched", {"next": next_dest})
+            self._set_status(state, next_dest)
+
+            if next_dest in self.engine_context.outcome_map:
+                self._set_outcome(state, next_dest)
+
+            return state
+
+        logger.warning(
+            f"No matching transition for async result '{result}' in step '{self.step_id}'"
+        )
+        span.add_event("transition.no_match", {"result": str(result)})
+        self._set_status(state, 'failed')
+        return state
+
+    def _handle_simple_routing(self, state: Dict[str, Any], span) -> Dict[str, Any]:
+        """Route to next step when no transitions are defined."""
+        self._set_status(state, 'success')
+
+        if self.next_step:
+            self._set_status(state, self.next_step)
+            span.add_event("routing.next_step", {"next": self.next_step})
+
+            if self.next_step in self.engine_context.outcome_map:
+                self._set_outcome(state, self.next_step)
+
+        return state

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/soprano_sdk/nodes/factory.py

@@ -3,6 +3,7 @@ from typing import Dict, Any, Type, Callable
 from .base import ActionStrategy
 from .call_function import CallFunctionStrategy
 from .collect_input import CollectInputStrategy
+from .async_function import AsyncFunctionStrategy
 from ..core.constants import ActionType
 from ..utils.logger import logger
 
@@ -44,3 +45,4 @@ class NodeFactory:
 
 NodeFactory.register(ActionType.COLLECT_INPUT_WITH_AGENT.value, CollectInputStrategy)
 NodeFactory.register(ActionType.CALL_FUNCTION.value, CallFunctionStrategy)
+NodeFactory.register(ActionType.CALL_ASYNC_FUNCTION.value, AsyncFunctionStrategy)

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/soprano_sdk/routing/router.py

@@ -32,6 +32,10 @@ class WorkflowRouter:
             logger.info(f"Self-loop: {self.step_id} (collecting)")
             return self.step_id
 
+        if status == f'{self.step_id}_pending':
+            logger.info(f"Self-loop: {self.step_id} (async pending)")
+            return self.step_id
+
         if status == f'{self.step_id}_error' :
             logger.info(f"Error encountered in {self.step_id}, ending workflow")
             return END
@@ -73,7 +77,8 @@ class WorkflowRouter:
     def get_routing_map(self, collector_nodes: List[str]) -> Dict[str, str]:
         routing_map = {}
 
-        if self.action == 'collect_input_with_agent':
+        # Self-loop for nodes that can interrupt (agent input or async)
+        if self.action in ('collect_input_with_agent', 'call_async_function'):
             routing_map[self.step_id] = self.step_id
 
         for transition in self.transitions:

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/soprano_sdk/tools.py

@@ -2,14 +2,15 @@
 Workflow Tools - Wraps workflows as callable tools for agent frameworks
 """
 from __future__ import annotations
+import json
 import uuid
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Union
 from .utils.logger import logger
 
 from langfuse.langchain import CallbackHandler
 
 from .core.engine import load_workflow
-from .core.constants import MFAConfig
+from .core.constants import MFAConfig, InterruptType
 
 
 class WorkflowTool:
@@ -103,35 +104,56 @@ class WorkflowTool:
             if not final_state.next and self.checkpointer:
                 self.checkpointer.delete_thread(thread_id)
 
-            # If workflow needs user input, return structured interrupt data
+            # If workflow needs user input or async operation, return structured interrupt data
             if "__interrupt__" in result and result["__interrupt__"]:
+                interrupt_value = result["__interrupt__"][0].value
+
+                # Check if this is an async interrupt
+                if isinstance(interrupt_value, dict) and interrupt_value.get("type") == "async":
+                    span.set_attribute("workflow.status", "async_interrupted")
+                    span.set_attribute("async.step_id", interrupt_value.get("step_id", ""))
+                    pending_metadata = json.dumps(interrupt_value.get("pending", {}))
+                    return f"{InterruptType.ASYNC}|{thread_id}|{self.name}|{pending_metadata}"
+
+                # User input interrupt (existing behavior)
                 span.set_attribute("workflow.status", "interrupted")
-                prompt = result["__interrupt__"][0].value
-                return f"__WORKFLOW_INTERRUPT__|{thread_id}|{self.name}|{prompt}"
+                prompt = interrupt_value
+                return f"{InterruptType.USER_INPUT}|{thread_id}|{self.name}|{prompt}"
 
             # Workflow completed without interrupting
             span.set_attribute("workflow.status", "completed")
             return self.engine.get_outcome_message(result)
 
-    def resume(self, thread_id: str, user_message: str) -> str:
-        """Resume an interrupted workflow with user input
+    def resume(
+        self,
+        thread_id: str,
+        resume_value: Union[str, Dict[str, Any]]
+    ) -> str:
+        """Resume an interrupted workflow with user input or async result
 
         Args:
             thread_id: Thread ID of the interrupted workflow
-            user_message: User's response to the interrupt prompt
+            resume_value: User's response (str) or async operation result (dict)
 
         Returns:
-            Either another interrupt prompt or final outcome message
+            Either another interrupt prompt/async metadata or final outcome message
         """
         from langgraph.types import Command
 
         config = {"configurable": {"thread_id": thread_id}}
-        result = self.graph.invoke(Command(resume=user_message), config=config)
+        result = self.graph.invoke(Command(resume=resume_value), config=config)
 
-        # Check if workflow needs more input
+        # Check if workflow needs more input or has another async operation
         if "__interrupt__" in result and result["__interrupt__"]:
-            prompt = result["__interrupt__"][0].value
-            return f"__WORKFLOW_INTERRUPT__|{thread_id}|{self.name}|{prompt}"
+            interrupt_value = result["__interrupt__"][0].value
+
+            # Check if this is an async interrupt
+            if isinstance(interrupt_value, dict) and interrupt_value.get("type") == "async":
+                pending_metadata = json.dumps(interrupt_value.get("pending", {}))
+                return f"{InterruptType.ASYNC}|{thread_id}|{self.name}|{pending_metadata}"
+
+            # User input interrupt
+            return f"{InterruptType.USER_INPUT}|{thread_id}|{self.name}|{interrupt_value}"
 
         # Workflow completed
         return self.engine.get_outcome_message(result)

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/soprano_sdk/validation/schema.py

@@ -73,7 +73,7 @@ WORKFLOW_SCHEMA = {
                     },
                     "action": {
                         "type": "string",
-                        "enum": ["collect_input_with_agent", "call_function"],
+                        "enum": ["collect_input_with_agent", "call_function", "call_async_function"],
                         "description": "Action type"
                     },
                     "field": {

soprano_sdk-0.2.5/tests/test_async_function.py

@@ -0,0 +1,379 @@
+"""
+Tests for AsyncFunctionStrategy - the call_async_function node type.
+"""
+
+import pytest
+from unittest.mock import MagicMock, patch
+
+from soprano_sdk.nodes.async_function import AsyncFunctionStrategy
+from soprano_sdk.core.constants import WorkflowKeys
+
+
+class TestAsyncFunctionStrategy:
+    """Tests for AsyncFunctionStrategy."""
+
+    @pytest.fixture
+    def engine_context(self):
+        """Create a mock engine context."""
+        context = MagicMock()
+        context.function_repository = MagicMock()
+        context.outcome_map = {"success": {}, "failed": {}}
+        return context
+
+    @pytest.fixture
+    def step_config(self):
+        """Basic step config for async function."""
+        return {
+            "id": "async_validate",
+            "action": "call_async_function",
+            "function": "test_module.async_function",
+            "output": "validation_result",
+        }
+
+    def test_init_requires_function(self, engine_context):
+        """Test that function property is required."""
+        step_config = {
+            "id": "test_step",
+            "output": "result",
+        }
+        with pytest.raises(RuntimeError, match="missing required 'function' property"):
+            AsyncFunctionStrategy(step_config, engine_context)
+
+    def test_init_requires_output(self, engine_context):
+        """Test that output property is required."""
+        step_config = {
+            "id": "test_step",
+            "function": "test.func",
+        }
+        with pytest.raises(RuntimeError, match="missing required 'output' property"):
+            AsyncFunctionStrategy(step_config, engine_context)
+
+    def test_init_success(self, step_config, engine_context):
+        """Test successful initialization."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+        assert strategy.step_id == "async_validate"
+        assert strategy.function_path == "test_module.async_function"
+        assert strategy.output_field == "validation_result"
+
+    def test_is_pending_result_true(self, step_config, engine_context):
+        """Test detection of pending result."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        pending_result = {"status": "pending", "job_id": "123"}
+        assert strategy._is_pending_result(pending_result) is True
+
+    def test_is_pending_result_false_different_status(self, step_config, engine_context):
+        """Test non-pending status is not detected as pending."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        completed_result = {"status": "completed", "value": True}
+        assert strategy._is_pending_result(completed_result) is False
+
+    def test_is_pending_result_false_not_dict(self, step_config, engine_context):
+        """Test non-dict result is not detected as pending."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        assert strategy._is_pending_result(True) is False
+        assert strategy._is_pending_result("result") is False
+        assert strategy._is_pending_result(123) is False
+
+    def test_is_async_pending_true(self, step_config, engine_context):
+        """Test detection of async pending state."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+        state = {WorkflowKeys.STATUS: "async_validate_pending"}
+
+        assert strategy._is_async_pending(state) is True
+
+    def test_is_async_pending_false(self, step_config, engine_context):
+        """Test non-pending state is not detected as pending."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+        state = {WorkflowKeys.STATUS: "async_validate_success"}
+
+        assert strategy._is_async_pending(state) is False
+
+    def test_pending_key(self, step_config, engine_context):
+        """Test pending key generation."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+        assert strategy._pending_key == "_async_pending_async_validate"
+
+    def test_sync_completion_stores_result(self, step_config, engine_context):
+        """Test that synchronous completion stores the result."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        # Mock function that returns sync result (not pending)
+        mock_func = MagicMock(return_value=True)
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+
+        with patch.object(strategy, '_handle_routing', return_value=state):
+            strategy.execute(state)
+
+        assert state["validation_result"] is True
+
+    def test_sync_completion_tracks_computed_field(self, step_config, engine_context):
+        """Test that synchronous completion tracks computed fields."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(return_value={"result": "success"})
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+
+        with patch.object(strategy, '_handle_routing', return_value=state):
+            strategy.execute(state)
+
+        assert "validation_result" in state.get(WorkflowKeys.COMPUTED_FIELDS, [])
+
+    def test_transition_routing_matches_condition(self, engine_context):
+        """Test transition routing with matching condition."""
+        step_config = {
+            "id": "async_validate",
+            "function": "test.func",
+            "output": "result",
+            "transitions": [
+                {"condition": True, "next": "next_step"},
+                {"condition": False, "next": "failed"},
+            ]
+        }
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(return_value=True)
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+        result = strategy.execute(state)
+
+        assert result[WorkflowKeys.STATUS] == "async_validate_next_step"
+
+    def test_transition_routing_with_ref(self, engine_context):
+        """Test transition routing with nested ref field."""
+        step_config = {
+            "id": "async_validate",
+            "function": "test.func",
+            "output": "result",
+            "transitions": [
+                {"condition": "approved", "next": "success", "ref": "status"},
+                {"condition": "rejected", "next": "failed", "ref": "status"},
+            ]
+        }
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(return_value={"status": "approved", "score": 95})
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+        result = strategy.execute(state)
+
+        assert result[WorkflowKeys.STATUS] == "async_validate_success"
+
+    def test_transition_routing_list_condition(self, engine_context):
+        """Test transition routing with list of conditions."""
+        step_config = {
+            "id": "async_validate",
+            "function": "test.func",
+            "output": "result",
+            "transitions": [
+                {"condition": ["approved", "verified"], "next": "success"},
+                {"condition": ["rejected", "failed"], "next": "failed"},
+            ]
+        }
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(return_value="verified")
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+        result = strategy.execute(state)
+
+        assert result[WorkflowKeys.STATUS] == "async_validate_success"
+
+    def test_simple_routing_with_next_step(self, engine_context):
+        """Test simple routing when no transitions defined."""
+        step_config = {
+            "id": "async_validate",
+            "function": "test.func",
+            "output": "result",
+            "next": "process_result",
+        }
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(return_value=True)
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+        result = strategy.execute(state)
+
+        assert result[WorkflowKeys.STATUS] == "async_validate_process_result"
+
+    def test_simple_routing_sets_outcome(self, engine_context):
+        """Test that routing to outcome sets outcome_id."""
+        step_config = {
+            "id": "async_validate",
+            "function": "test.func",
+            "output": "result",
+            "next": "success",
+        }
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(return_value=True)
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+        result = strategy.execute(state)
+
+        assert result[WorkflowKeys.OUTCOME_ID] == "success"
+
+    def test_function_load_error(self, step_config, engine_context):
+        """Test handling of function load error."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        engine_context.function_repository.load.side_effect = ImportError("Module not found")
+
+        state = {}
+        with pytest.raises(RuntimeError, match="Failed to load function"):
+            strategy.execute(state)
+
+    def test_function_execution_error(self, step_config, engine_context):
+        """Test handling of function execution error."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(side_effect=ValueError("Invalid input"))
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+        with pytest.raises(RuntimeError, match="Function.*failed"):
+            strategy.execute(state)
+
+
+class TestAsyncFunctionPendingBehavior:
+    """Tests for async pending interrupt behavior."""
+
+    @pytest.fixture
+    def engine_context(self):
+        context = MagicMock()
+        context.function_repository = MagicMock()
+        context.outcome_map = {}
+        return context
+
+    @pytest.fixture
+    def step_config(self):
+        return {
+            "id": "async_validate",
+            "function": "test.func",
+            "output": "result",
+            "transitions": [
+                {"condition": True, "next": "success"},
+                {"condition": False, "next": "failed"},
+            ]
+        }
+
+    def test_pending_result_sets_status(self, step_config, engine_context):
+        """Test that pending result sets status to pending."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        mock_func = MagicMock(return_value={"status": "pending", "job_id": "abc123"})
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+
+        # Mock interrupt to simulate the async pause
+        # interrupt() returns the resume value when called during resume
+        with patch('soprano_sdk.nodes.async_function.interrupt', return_value=True) as mock_interrupt:
+            strategy.execute(state)
+
+            # Verify interrupt was called with correct async metadata
+            mock_interrupt.assert_called_once()
+            call_args = mock_interrupt.call_args[0][0]
+            assert call_args["type"] == "async"
+            assert call_args["step_id"] == "async_validate"
+            assert call_args["pending"]["status"] == "pending"
+            assert call_args["pending"]["job_id"] == "abc123"
+
+    def test_pending_result_stores_metadata_before_interrupt(self, step_config, engine_context):
+        """Test that pending result stores metadata in state before interrupt."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        pending_metadata = {"status": "pending", "job_id": "abc123", "callback_url": "http://..."}
+        mock_func = MagicMock(return_value=pending_metadata)
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+        stored_state = {}
+
+        # Custom interrupt mock that captures state at the moment of interrupt
+        def capture_state_interrupt(value):
+            stored_state.update(dict(state))  # Copy state at interrupt time
+            return True  # Return resume value
+
+        with patch('soprano_sdk.nodes.async_function.interrupt', side_effect=capture_state_interrupt):
+            strategy.execute(state)
+
+        # Check that metadata was stored before interrupt
+        assert stored_state["_async_pending_async_validate"] == pending_metadata
+        assert stored_state[WorkflowKeys.STATUS] == "async_validate_pending"
+
+    def test_resume_cleans_up_pending_metadata(self, step_config, engine_context):
+        """Test that resuming cleans up pending metadata from state."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        pending_metadata = {"status": "pending", "job_id": "abc123"}
+        mock_func = MagicMock(return_value=pending_metadata)
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+
+        # Simulate the full flow: first call sets pending, second call (resume) cleans up
+        with patch('soprano_sdk.nodes.async_function.interrupt', return_value=True):
+            strategy.execute(state)
+
+        # After resume (interrupt returns async result), pending key should be cleaned up
+        assert "_async_pending_async_validate" not in state
+
+    def test_resume_uses_async_result_for_routing(self, step_config, engine_context):
+        """Test that async result from resume is used for routing."""
+        strategy = AsyncFunctionStrategy(step_config, engine_context)
+
+        pending_metadata = {"status": "pending", "job_id": "abc123"}
+        mock_func = MagicMock(return_value=pending_metadata)
+        engine_context.function_repository.load.return_value = mock_func
+
+        state = {}
+
+        # Mock interrupt to return True (simulating resume with async_result=True)
+        with patch('soprano_sdk.nodes.async_function.interrupt', return_value=True):
+            result = strategy.execute(state)
+
+        # Result should be True (from the mocked interrupt return value)
+        assert state["result"] is True
+        assert result[WorkflowKeys.STATUS] == "async_validate_success"
+
+
+class TestAsyncFunctionNodeFactory:
+    """Test that AsyncFunctionStrategy is properly registered."""
+
+    def test_factory_registration(self):
+        """Test that call_async_function is registered in NodeFactory."""
+        from soprano_sdk.nodes.factory import NodeFactory
+        from soprano_sdk.core.constants import ActionType
+
+        assert NodeFactory.is_registered(ActionType.CALL_ASYNC_FUNCTION.value)
+
+    def test_factory_creates_async_strategy(self):
+        """Test that factory creates AsyncFunctionStrategy for call_async_function."""
+        from soprano_sdk.nodes.factory import NodeFactory
+
+        step_config = {
+            "id": "test_async",
+            "action": "call_async_function",
+            "function": "test.func",
+            "output": "result",
+        }
+        engine_context = MagicMock()
+        engine_context.function_repository = MagicMock()
+        engine_context.outcome_map = {}
+
+        node_fn = NodeFactory.create(step_config, engine_context)
+
+        # The returned function should be callable
+        assert callable(node_fn)

{soprano_sdk-0.2.4 → soprano_sdk-0.2.5}/tests/test_collect_input_refactor.py

@@ -30,6 +30,7 @@ class TestCollectInputStrategyRefactor:
     def test_handle_max_attempts_default_message(self):
         """Test that default error message is used when on_max_attempts_reached is not provided"""
         step_config = {
+            "id": "collect_customer_name",
             "field": "customer_name",
             "agent": {"name": "test_agent"}
         }
@@ -41,7 +42,7 @@ class TestCollectInputStrategyRefactor:
 
         result = strategy._handle_max_attempts(state)
 
-        assert result[WorkflowKeys.STATUS] == "max_attempts"
+        assert result[WorkflowKeys.STATUS] == "collect_customer_name_max_attempts"
         assert "customer_name" in result[WorkflowKeys.MESSAGES][0]
         assert "customer service" in result[WorkflowKeys.MESSAGES][0].lower()
 
@@ -49,6 +50,7 @@ class TestCollectInputStrategyRefactor:
         """Test that custom error message is used when on_max_attempts_reached is provided"""
         custom_message = "Custom error: Too many attempts. Please call 1-800-SUPPORT."
         step_config = {
+            "id": "collect_customer_name",
             "field": "customer_name",
             "agent": {"name": "test_agent"},
             "on_max_attempts_reached": custom_message
@@ -61,6 +63,6 @@ class TestCollectInputStrategyRefactor:
 
         result = strategy._handle_max_attempts(state)
 
-        assert result[WorkflowKeys.STATUS] == "max_attempts"
+        assert result[WorkflowKeys.STATUS] == "collect_customer_name_max_attempts"
         assert result[WorkflowKeys.MESSAGES][0] == custom_message
         assert "1-800-SUPPORT" in result[WorkflowKeys.MESSAGES][0]