soprano-sdk 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

soprano_sdk/authenticators/mfa.py

@@ -10,6 +10,7 @@ class MFAChallenge(TypedDict):
 class MFAState(TypedDict):
     challengeType: Literal['OTP', 'dob']
     post_payload: dict[str, str]
+    post_headers: NotRequired[dict[str, str]]
     otpValue: NotRequired[str]
     status: Literal['IN_PROGRESS', 'COMPLETED', 'ERRORED', 'FAILED'] | None
     message: str
@@ -35,6 +36,10 @@ def enforce_mfa_if_required(state: dict, mfa_config: Optional[MFAConfig] = None)
     _mfa : MFAState = state['_mfa']
     if _mfa['status'] == 'COMPLETED':
         return True
+
+    # Use custom headers if provided, otherwise empty dict
+    headers = _mfa.get('post_headers', {})
+
     generate_token_response = requests.post(
         build_path(
             base_url=mfa_config.generate_token_base_url,
@@ -42,7 +47,7 @@ def enforce_mfa_if_required(state: dict, mfa_config: Optional[MFAConfig] = None)
         ),
         json=_mfa['post_payload'],
         timeout=mfa_config.api_timeout,
-        headers={"Authorization": f"Bearer {state['bearer_token']}"}
+        headers=headers
     )
     _, error = get_response(generate_token_response)
 
@@ -65,6 +70,9 @@ def mfa_validate_user_input(mfa_config: Optional[MFAConfig] = None, **state: dic
     if not state[input_field_name]:
         return False
 
+    # Use custom headers if provided, otherwise empty dict
+    headers = _mfa.get('post_headers', {})
+
     post_payload = _mfa['post_payload']
     challenge_field_name = f"{_mfa['challengeType'].lower()}Challenge"
     post_payload.update({challenge_field_name: {"value": state[input_field_name]}})
@@ -75,7 +83,7 @@ def mfa_validate_user_input(mfa_config: Optional[MFAConfig] = None, **state: dic
         ),
         json=post_payload,
         timeout=mfa_config.api_timeout,
-        headers={"Authorization": f"Bearer {state['bearer_token']}"}
+        headers=headers
     )
     _mfa['retry_count'] += 1
     response, error = get_response(validate_token_response)
@@ -95,7 +103,7 @@ def mfa_validate_user_input(mfa_config: Optional[MFAConfig] = None, **state: dic
             ),
             json=post_payload,
             timeout=mfa_config.api_timeout,
-            headers={"Authorization": f"Bearer {state['bearer_token']}"}
+            headers=headers
         )
         if authorize.status_code == 204:
             _mfa['status'] = 'COMPLETED'

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/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/nodes/call_function.py

@@ -39,11 +39,17 @@ class CallFunctionStrategy(ActionStrategy):
         if 'mfa' in self.step_config:
             state['_mfa'] = state.get('_mfa', {})
             state['_mfa']['post_payload'] = dict(transactionId=str(uuid.uuid4()))
+            state['_mfa']['post_headers'] = {}
             state['_mfa_config'] = self.engine_context.mfa_config
             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)
 
+            # Process headers if provided
+            if 'headers' in self.step_config['mfa']:
+                for k, v in self.step_config['mfa']['headers'].items():
+                    state['_mfa']['post_headers'][k] = compile_values(template_loader, state, v)
+
     def execute(self, state: Dict[str, Any]) -> Dict[str, Any]:
         from ..utils.tracing import trace_node_execution
         

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/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/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/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.4.dist-info → soprano_sdk-0.2.6.dist-info}/METADATA

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

{soprano_sdk-0.2.4.dist-info → soprano_sdk-0.2.6.dist-info}/RECORD

@@ -1,24 +1,25 @@
 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=v2QGEaXxKzCBZCTdmhZXMXiVcwccJivdQdCxETkp-lQ,7656
+soprano_sdk/tools.py,sha256=xsJbY1hZzhXbNRTAVj9M_2saU0oa7J8O9DaRGGuPf30,8832
 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/structured_output.py,sha256=7DSVzfMPsZAqBwI3v6XL15qG5Gh4jJ-qddcVPaa3gdc,3326
 soprano_sdk/authenticators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/authenticators/mfa.py,sha256=7aTueLu2jLxl213Q5_BkNQ534RgEwf6lodQa_PaJFWs,5980
+soprano_sdk/authenticators/mfa.py,sha256=Zl1dcwCmuwsAbruFMqguJ4lY0PPnC6v2EZ-xTPULX04,6098
 soprano_sdk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/core/constants.py,sha256=F7gL3hkpq5mZgbgiBcEERmzxYJ4zZG2ZFx1YQp5Z580,3130
+soprano_sdk/core/constants.py,sha256=21ful8skHgDeDJJMdB_oJDw7Xq3lkbO6KWOhHuuLIa0,3330
 soprano_sdk/core/engine.py,sha256=UTFJimrgUzfdDZgc4rW5nvkOKevAEGW8C5Zr1D0tgcs,11270
 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=PdmSSVXkMT5ptxeUjmKqND-wvqbaXp1i61QzIzFOfgQ,5535
+soprano_sdk/nodes/call_function.py,sha256=afYBmj5Aditbkvb_7gD3CsXBEEUohcsC1_cdHfcOunE,5847
 soprano_sdk/nodes/collect_input.py,sha256=lEltZOU5ALvc57q8I_4SjzzEapVejy9mS0E73Jf7-sk,23759
-soprano_sdk/nodes/factory.py,sha256=l-Gysfgnao-o2dphhnbjjxcH3ojZanZNYN3CBH9dDbA,1624
+soprano_sdk/nodes/factory.py,sha256=IbBzT4FKBnYw5PuSo7uDONV3HSFtoyqjBQQtXtUY2IY,1756
 soprano_sdk/routing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soprano_sdk/routing/router.py,sha256=SrNciTIXXdC9bAbbO5bX7PN9mlRbITjr4RZdNm4jEVA,3450
+soprano_sdk/routing/router.py,sha256=Z218r4BMbmlL9282ombutAoKsIs1WHZ2d5YHnbCeet8,3698
 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
@@ -26,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=7B60_8xIt5bLXTYEGEDwU2DwmQn2f4QFyyIca2FYM9s,15420
+soprano_sdk/validation/schema.py,sha256=SlC4sq-ueEg0p_8Uox_cgPj9S-0AEEiOOlA1Vsu0DsE,15443
 soprano_sdk/validation/validator.py,sha256=GaCvHvjwVe88Z8yatQsueiPnqtq1oo5uN75gogzpQT0,8940
-soprano_sdk-0.2.4.dist-info/METADATA,sha256=W-e-Si4pewUkpuWewKz_pmkWvUeRVR8HPwQ-Z-7tpTQ,11297
-soprano_sdk-0.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-soprano_sdk-0.2.4.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
-soprano_sdk-0.2.4.dist-info/RECORD,,
+soprano_sdk-0.2.6.dist-info/METADATA,sha256=Ykmgc9OD9Q5nBvGSD-z67oPU7Cy4jynpvhjZkwdPxzQ,11297
+soprano_sdk-0.2.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+soprano_sdk-0.2.6.dist-info/licenses/LICENSE,sha256=A1aBauSjPNtVehOXJe3WuvdU2xvM9H8XmigFMm6665s,1073
+soprano_sdk-0.2.6.dist-info/RECORD,,